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,67 @@ 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;
+        }
+        for mapping in &self.patterns {
+            let pattern = &mapping.value.pattern;
+            if mapping.pattern.first_wildcard_pos == Some(0) && !pattern.is_excluded() {
+                return true;
+            }
+            let max_usable_pattern_len = mapping.pattern.first_wildcard_pos.unwrap_or_else(|| pattern.path.len());
+            let common_len = max_usable_pattern_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 {
+                    is_match = if common_len < max_usable_pattern_len {
+                        pattern.path.get(common_len) == Some(&b'/')
+                    } else if relative_path.len() > max_usable_pattern_len {
+                        relative_path.get(common_len) == Some(&b'/')
+                    } else {
+                        is_match
+                    };
+                    if let Some(is_dir) = is_dir.filter(|_| pattern.signature.contains(MagicSignature::MUST_BE_DIR)) {
+                        is_match = if is_dir {
+                            matches!(pattern.path.get(common_len), None | Some(&b'/'))
+                        } else {
+                            relative_path.get(common_len) == Some(&b'/')
+                        }
+                    }
+                }
+            }
+            if is_match {
+                return !pattern.is_excluded();
+            }
+        }
+
+        self.all_patterns_are_excluded
+    }
 }
 
 fn match_verbatim(

gix-pathspec/tests/search/mod.rs

@@ -15,6 +15,139 @@ 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 mut search = gix_pathspec::Search::from_specs(pathspecs(&["a/be/"]), None, Path::new(""))?;
+    search
+        .pattern_matching_relative_path("a/be/file".into(), Some(false), &mut |_, _, _, _| {
+            unreachable!("must not be called")
+        })
+        .expect("matches as this is a prefix match");
+    assert!(
+        !search.can_match_relative_path("any".into(), Some(false)),
+        "not our directory: a, and must be dir"
+    );
+    assert!(
+        !search.can_match_relative_path("any".into(), Some(true)),
+        "not our directory: a"
+    );
+    assert!(
+        !search.can_match_relative_path("any".into(), None),
+        "not our directory: a, and must be dir, still completely out of scope"
+    );
+    assert!(
+        !search.can_match_relative_path("a/bei".into(), None),
+        "not our directory: a/be"
+    );
+    assert!(!search.can_match_relative_path("a".into(), Some(false)), "must be dir");
+    assert!(search.can_match_relative_path("a".into(), Some(true)));
+    assert!(
+        search.can_match_relative_path("a".into(), None),
+        "now dir or not doesn't matter"
+    );
+    assert!(search.can_match_relative_path("a/be".into(), Some(true)));
+    assert!(
+        search.can_match_relative_path("a/be".into(), None),
+        "dir doesn't matter anymore"
+    );
+    assert!(
+        !search.can_match_relative_path("a/be".into(), Some(false)),
+        "files can't match as prefix"
+    );
+    assert!(
+        search.can_match_relative_path("a/be/file".into(), Some(false)),
+        "files can match if they are part of the suffix"
+    );
+
+    assert!(
+        !search.can_match_relative_path("a/b".into(), Some(false)),
+        "can't match a/be"
+    );
+    assert!(
+        !search.can_match_relative_path("a/b".into(), None),
+        "still can't match a/be"
+    );
+    assert!(
+        search
+            .pattern_matching_relative_path("a/b".into(), None, &mut |_, _, _, _| unreachable!("must not be called"))
+            .is_none(),
+        "no match if it's not the whole pattern that matches"
+    );
+    assert!(
+        !search.can_match_relative_path("a/b".into(), Some(true)),
+        "can't match a/be, which must be directory"
+    );
+
+    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_wildcards() -> crate::Result {
+    let search = gix_pathspec::Search::from_specs(pathspecs(&["**/a*"]), None, Path::new(""))?;
+    assert!(
+        search.can_match_relative_path("a".into(), None),
+        "it can't determine it, so assume match"
+    );
+    assert!(search.can_match_relative_path("a/a".into(), Some(false)));
+    assert!(search.can_match_relative_path("a/a.o".into(), Some(false)));
+    assert!(
+        search.can_match_relative_path("b-unrelated".into(), None),
+        "this is also assumed to be a match, prefer false-positives over false-negatives"
+    );
+    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 +161,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 not be shorter"
+    );
+    assert!(!search.can_match_relative_path("outside-of-tests".into(), None));
     Ok(())
 }
 
@@ -47,6 +189,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 +198,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), "simple prefix search");
 
     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 +255,22 @@ 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)),
+        "a full match is needed"
+    );
+    assert!(search.can_match_relative_path("FOO/bar".into(), Some(true)));
     Ok(())
 }