Refactor: string-or-struct matcher syntax, Case enum, remove case_sensitive_mappings table

Co-authored-by: keith-hall <11882719+keith-hall@users.noreply.github.com>

src/syntax_mapping.rs

@@ -17,9 +17,16 @@ use ignored_suffixes::IgnoredSuffixes;
 mod builtin;
 pub mod ignored_suffixes;
 
-fn make_glob_matcher(from: &str, case_insensitive: bool) -> Result<GlobMatcher> {
+/// Whether a glob pattern should be matched case-sensitively or case-insensitively.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum Case {
+    Sensitive,
+    Insensitive,
+}
+
+fn make_glob_matcher(from: &str, case: Case) -> Result<GlobMatcher> {
     let matcher = GlobBuilder::new(from)
-        .case_insensitive(case_insensitive)
+        .case_insensitive(matches!(case, Case::Insensitive))
         .literal_separator(true)
         .build()?
         .compile_matcher();
@@ -97,14 +104,14 @@ impl<'a> SyntaxMapping<'a> {
     }
 
     pub fn insert(&mut self, from: &str, to: MappingTarget<'a>) -> Result<()> {
-        let matcher = make_glob_matcher(from, true)?;
+        let matcher = make_glob_matcher(from, Case::Insensitive)?;
         self.custom_mappings.push((matcher, to));
         Ok(())
     }
 
     /// Like [`Self::insert`], but the glob pattern is matched case-sensitively.
     pub fn insert_case_sensitive(&mut self, from: &str, to: MappingTarget<'a>) -> Result<()> {
-        let matcher = make_glob_matcher(from, false)?;
+        let matcher = make_glob_matcher(from, Case::Sensitive)?;
         self.custom_mappings.push((matcher, to));
         Ok(())
     }

src/syntax_mapping/builtin.rs

@@ -3,7 +3,7 @@ use std::env;
 use globset::GlobMatcher;
 use once_cell::sync::Lazy;
 
-use crate::syntax_mapping::{make_glob_matcher, MappingTarget};
+use crate::syntax_mapping::{make_glob_matcher, Case, MappingTarget};
 
 // Static syntax mappings generated from /src/syntax_mapping/builtins/ by the
 // build script (/build/syntax_mapping.rs).
@@ -53,8 +53,8 @@ include!(concat!(
 /// A failure to compile is a fatal error.
 ///
 /// Used internally by `Lazy<Option<GlobMatcher>>`'s lazy evaluation closure.
-fn build_matcher_fixed(from: &str, case_insensitive: bool) -> GlobMatcher {
-    make_glob_matcher(from, case_insensitive)
+fn build_matcher_fixed(from: &str, case: Case) -> GlobMatcher {
+    make_glob_matcher(from, case)
         .expect("A builtin fixed glob matcher failed to compile")
 }
 
@@ -65,7 +65,7 @@ fn build_matcher_fixed(from: &str, case_insensitive: bool) -> GlobMatcher {
 /// to compile.
 ///
 /// Used internally by `Lazy<Option<GlobMatcher>>`'s lazy evaluation closure.
-fn build_matcher_dynamic(segs: &[MatcherSegment], case_insensitive: bool) -> Option<GlobMatcher> {
+fn build_matcher_dynamic(segs: &[MatcherSegment], case: Case) -> Option<GlobMatcher> {
     // join segments
     let mut buf = String::new();
     for seg in segs {
@@ -78,7 +78,7 @@ fn build_matcher_dynamic(segs: &[MatcherSegment], case_insensitive: bool) -> Opt
         }
     }
     // compile glob matcher
-    let matcher = make_glob_matcher(&buf, case_insensitive).ok()?;
+    let matcher = make_glob_matcher(&buf, case).ok()?;
     Some(matcher)
 }
 

src/syntax_mapping/builtins/common/50-bazel.toml

@@ -1,2 +1,2 @@
-[case_sensitive_mappings]
-"Python" = ["BUILD"]
+[mappings]
+"Python" = [{ glob = "BUILD", case_sensitive = true }]