feat: add Search::can_match_relative_path().

This way it's possible to match partial input against a pathspec
to see if this root would have a chance to actually match.

Author: Byron

gix-pathspec/src/pattern.rs

@@ -142,6 +142,12 @@ impl Pattern {
         self.signature.contains(MagicSignature::EXCLUDE)
     }
 
+    /// Returns `true` is this pattern is supposed to always match, as it's either empty or designated `nil`.
+    /// Note that technically the pattern might still be excluded.
+    pub fn always_matches(&self) -> bool {
+        self.is_nil() || self.path.is_empty()
+    }
+
     /// Translate ourselves to a long display format, that when parsed back will yield the same pattern.
     ///
     /// Note that the

gix-pathspec/src/search/matching.rs

@@ -8,7 +8,7 @@ use crate::{
 
 impl Search {
     /// Return the first [`Match`] of `relative_path`, or `None`.
-    /// `is_dir` is `true` if `relative_path` is a directory.
+    /// `is_dir` is `true` if `relative_path` is a directory, or assumed `false` if `None`.
     /// `attributes` is called as `attributes(relative_path, case, is_dir, outcome) -> has_match` to obtain for attributes for `relative_path`, if
     /// the underlying pathspec defined an attribute filter, to be stored in `outcome`, returning true if there was a match.
     /// All attributes of the pathspec have to be present in the defined value for the pathspec to match.
@@ -52,7 +52,7 @@ impl Search {
             }
 
             let case = if ignore_case { Case::Fold } else { Case::Sensitive };
-            let mut is_match = mapping.value.pattern.is_nil() || mapping.value.pattern.path.is_empty();
+            let mut is_match = mapping.value.pattern.always_matches();
             if !is_match {
                 is_match = if mapping.pattern.first_wildcard_pos.is_none() {
                     match_verbatim(mapping, relative_path, is_dir, case)
@@ -117,6 +117,54 @@ impl Search {
             res
         }
     }
+
+    /// As opposed to [`Self::pattern_matching_relative_path()`], this method will return `true` for a possibly partial `relative_path`
+    /// if this pathspec *could* match by looking at the shortest shared prefix only.
+    ///
+    /// This is useful if `relative_path` is a directory leading up to the item that is going to be matched in full later.
+    /// Note that it should not end with `/` to indicate it's a directory, rather, use `is_dir` to indicate this.
+    /// `is_dir` is `true` if `relative_path` is a directory, or assumed `false` if `None`.
+    /// Returns `false` if this pathspec has no chance of ever matching `relative_path`.
+    pub fn can_match_relative_path(&self, relative_path: &BStr, is_dir: Option<bool>) -> bool {
+        if self.patterns.is_empty() {
+            return true;
+        }
+        let common_prefix_len = self.common_prefix_len.min(relative_path.len());
+        if relative_path.get(..common_prefix_len).map_or(true, |rela_path_prefix| {
+            rela_path_prefix != self.common_prefix()[..common_prefix_len]
+        }) {
+            return false;
+        }
+        let is_dir = is_dir.unwrap_or_default();
+        for mapping in &self.patterns {
+            if mapping.value.pattern.signature.contains(MagicSignature::MUST_BE_DIR) && !is_dir {
+                continue;
+            }
+            let pattern = &mapping.value.pattern;
+            let common_len = mapping
+                .pattern
+                .first_wildcard_pos
+                .unwrap_or_else(|| pattern.path.len())
+                .min(relative_path.len());
+
+            let pattern_path = pattern.path[..common_len].as_bstr();
+            let longest_possible_relative_path = &relative_path[..common_len];
+            let ignore_case = pattern.signature.contains(MagicSignature::ICASE);
+            let mut is_match = pattern.always_matches();
+            if !is_match && common_len != 0 {
+                is_match = if ignore_case {
+                    pattern_path.eq_ignore_ascii_case(longest_possible_relative_path)
+                } else {
+                    pattern_path == longest_possible_relative_path
+                };
+            }
+            if is_match {
+                return !pattern.is_excluded();
+            }
+        }
+
+        self.all_patterns_are_excluded
+    }
 }
 
 fn match_verbatim(

gix-pathspec/tests/search/mod.rs

@@ -15,6 +15,68 @@ fn no_pathspecs_match_everything() -> crate::Result {
         })
         .expect("matches");
     assert_eq!(m.pattern.prefix_directory(), "", "there is no prefix as none was given");
+    assert_eq!(
+        m.sequence_number, 0,
+        "this is actually a fake pattern, as we have to match even though there isn't anything"
+    );
+
+    assert!(search.can_match_relative_path("anything".into(), None));
+
+    Ok(())
+}
+
+#[test]
+fn simplified_search_respects_must_be_dir() -> crate::Result {
+    let search = gix_pathspec::Search::from_specs(pathspecs(&["a/b/"]), None, Path::new(""))?;
+    assert!(!search.can_match_relative_path("a".into(), None));
+    assert!(!search.can_match_relative_path("a".into(), Some(false)));
+    assert!(search.can_match_relative_path("a".into(), Some(true)));
+    assert!(search.can_match_relative_path("a/b".into(), Some(true)));
+
+    Ok(())
+}
+
+#[test]
+fn simplified_search_respects_ignore_case() -> crate::Result {
+    let search = gix_pathspec::Search::from_specs(pathspecs(&[":(icase)foo/**/bar"]), None, Path::new(""))?;
+    assert!(search.can_match_relative_path("Foo".into(), None));
+    assert!(search.can_match_relative_path("foo".into(), Some(true)));
+    assert!(search.can_match_relative_path("FOO/".into(), Some(true)));
+
+    Ok(())
+}
+
+#[test]
+fn simplified_search_respects_all_excluded() -> crate::Result {
+    let search = gix_pathspec::Search::from_specs(
+        pathspecs(&[":(exclude)a/file", ":(exclude)b/file"]),
+        None,
+        Path::new(""),
+    )?;
+    assert!(!search.can_match_relative_path("b".into(), None));
+    assert!(!search.can_match_relative_path("a".into(), None));
+    assert!(search.can_match_relative_path("c".into(), None));
+    assert!(search.can_match_relative_path("c/".into(), None));
+
+    Ok(())
+}
+
+#[test]
+fn simplified_search_handles_nil() -> crate::Result {
+    let search = gix_pathspec::Search::from_specs(pathspecs(&[":"]), None, Path::new(""))?;
+    assert!(search.can_match_relative_path("a".into(), None), "everything matches");
+    assert!(search.can_match_relative_path("a".into(), Some(false)));
+    assert!(search.can_match_relative_path("a".into(), Some(true)));
+    assert!(search.can_match_relative_path("a/b".into(), Some(true)));
+
+    let search = gix_pathspec::Search::from_specs(pathspecs(&[":(exclude)"]), None, Path::new(""))?;
+    assert!(
+        !search.can_match_relative_path("a".into(), None),
+        "everything does not match"
+    );
+    assert!(!search.can_match_relative_path("a".into(), Some(false)));
+    assert!(!search.can_match_relative_path("a".into(), Some(true)));
+    assert!(!search.can_match_relative_path("a/b".into(), Some(true)));
 
     Ok(())
 }
@@ -28,6 +90,15 @@ fn init_with_exclude() -> crate::Result {
         "re-orded so that excluded are first"
     );
     assert_eq!(search.common_prefix(), "tests");
+    assert!(
+        search.can_match_relative_path("tests".into(), Some(true)),
+        "prefix matches"
+    );
+    assert!(
+        search.can_match_relative_path("test".into(), Some(true)),
+        "prefix can also be shorter"
+    );
+    assert!(!search.can_match_relative_path("outside-of-tests".into(), None));
     Ok(())
 }
 
@@ -47,6 +118,7 @@ fn no_pathspecs_respect_prefix() -> crate::Result {
             .is_none(),
         "not the right prefix"
     );
+    assert!(!search.can_match_relative_path("hello".into(), None));
     let m = search
         .pattern_matching_relative_path("a/b".into(), None, &mut |_, _, _, _| unreachable!("must not be called"))
         .expect("match");
@@ -55,12 +127,16 @@ fn no_pathspecs_respect_prefix() -> crate::Result {
         "a",
         "the prefix directory matched verbatim"
     );
+    assert!(search.can_match_relative_path("a/".into(), Some(true)));
+    assert!(search.can_match_relative_path("a".into(), Some(true)));
+    assert!(!search.can_match_relative_path("a".into(), Some(false)));
+    assert!(!search.can_match_relative_path("a".into(), None));
 
     Ok(())
 }
 
 #[test]
-fn prefixes_are_always_case_insensitive() -> crate::Result {
+fn prefixes_are_always_case_sensitive() -> crate::Result {
     let path = gix_testtools::scripted_fixture_read_only("match_baseline_files.sh")?.join("paths");
     let items = baseline::parse_paths(path)?;
 
@@ -108,6 +184,18 @@ fn prefixes_are_always_case_insensitive() -> crate::Result {
             .collect();
         assert_eq!(actual, expected, "{spec} {prefix}");
     }
+
+    let search = gix_pathspec::Search::from_specs(
+        gix_pathspec::parse(":(icase)bar".as_bytes(), Default::default()),
+        Some(Path::new("FOO")),
+        Path::new(""),
+    )?;
+    assert!(
+        !search.can_match_relative_path("foo".into(), Some(true)),
+        "icase does not apply to the prefix"
+    );
+    assert!(search.can_match_relative_path("FOO".into(), Some(true)));
+    assert!(search.can_match_relative_path("FOO/ba".into(), Some(true)));
     Ok(())
 }