feat: Add Search::matches_prefix() to see if the prefix of a pathspec matches.

That way it's possible to see if some paths can never match.

Author: Byron

gix-pathspec/src/search/matching.rs

@@ -149,11 +149,11 @@ impl Search {
             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 {
+                let pattern_path = pattern.path[..common_len].as_bstr();
+                let longest_possible_relative_path = &relative_path[..common_len];
                 is_match = if ignore_case {
                     pattern_path.eq_ignore_ascii_case(longest_possible_relative_path)
                 } else {
@@ -184,6 +184,48 @@ impl Search {
 
         self.all_patterns_are_excluded
     }
+
+    /// Returns `true` if `relative_path` matches the prefix of this pathspec.
+    ///
+    /// For example, the relative path `d` matches `d/`, `d*/`, `d/` and `d/*`, but not `d/d/*` or `dir`.
+    pub fn directory_matches_prefix(&self, relative_path: &BStr) -> 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 rightmost_idx = mapping.pattern.first_wildcard_pos.map_or_else(
+                || pattern.path.len(),
+                |idx| pattern.path[..idx].rfind_byte(b'/').unwrap_or(idx),
+            );
+            let ignore_case = pattern.signature.contains(MagicSignature::ICASE);
+            let mut is_match = pattern.always_matches();
+            if !is_match {
+                if let Some(relative_path) = relative_path.get(..rightmost_idx) {
+                    let pattern_path = pattern.path[..rightmost_idx].as_bstr();
+                    is_match = if ignore_case {
+                        pattern_path.eq_ignore_ascii_case(relative_path)
+                    } else {
+                        pattern_path == relative_path
+                    };
+                }
+            }
+            if is_match {
+                return !pattern.is_excluded();
+            }
+        }
+
+        self.all_patterns_are_excluded
+    }
 }
 
 fn match_verbatim(

gix-pathspec/tests/search/mod.rs

@@ -7,6 +7,49 @@ fn directories() -> crate::Result {
     baseline::run("directory", true, baseline::directories)
 }
 
+#[test]
+fn directory_matches_prefix() -> crate::Result {
+    for spec in ["dir", "dir/", "di*", "dir/*", "dir/*.o"] {
+        for specs in [&[spec] as &[_], &[spec, "other"]] {
+            let search = gix_pathspec::Search::from_specs(pathspecs(specs), None, Path::new(""))?;
+            assert!(search.directory_matches_prefix("dir".into()), "{spec}: must match");
+            assert!(!search.directory_matches_prefix("d".into()), "{spec}: must not match");
+        }
+    }
+
+    for spec in ["dir/d", "dir/d/", "dir/*/*", "dir/d/*.o"] {
+        for specs in [&[spec] as &[_], &[spec, "other"]] {
+            let search = gix_pathspec::Search::from_specs(pathspecs(specs), None, Path::new(""))?;
+            assert!(search.directory_matches_prefix("dir/d".into()), "{spec}: must match");
+            assert!(!search.directory_matches_prefix("d".into()), "{spec}: must not match");
+            assert!(!search.directory_matches_prefix("di".into()), "{spec}: must not match");
+        }
+    }
+    Ok(())
+}
+
+#[test]
+fn directory_matches_prefix_starting_wildcards_always_match() -> crate::Result {
+    let search = gix_pathspec::Search::from_specs(pathspecs(&["*ir"]), None, Path::new(""))?;
+    assert!(search.directory_matches_prefix("dir".into()));
+    assert!(search.directory_matches_prefix("d".into()));
+    Ok(())
+}
+
+#[test]
+fn directory_matches_prefix_all_excluded() -> crate::Result {
+    for spec in ["!dir", "!dir/", "!d*", "!di*", "!dir/*", "!dir/*.o", "!*ir"] {
+        for specs in [&[spec] as &[_], &[spec, "other"]] {
+            let search = gix_pathspec::Search::from_specs(pathspecs(specs), None, Path::new(""))?;
+            assert!(
+                !search.directory_matches_prefix("dir".into()),
+                "{spec}: must not match, it's excluded"
+            );
+        }
+    }
+    Ok(())
+}
+
 #[test]
 fn no_pathspecs_match_everything() -> crate::Result {
     let mut search = gix_pathspec::Search::from_specs([], None, Path::new(""))?;
@@ -21,6 +64,7 @@ fn no_pathspecs_match_everything() -> crate::Result {
         "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));
+    assert!(search.directory_matches_prefix("anything".into()));
     Ok(())
 }
 
@@ -51,6 +95,8 @@ fn starts_with() -> crate::Result {
         search.can_match_relative_path("a".into(), None),
         "if unspecified, we match for good measure"
     );
+    assert!(search.directory_matches_prefix("a".into()));
+    assert!(!search.directory_matches_prefix("ab".into()));
     assert_eq!(
         search
             .pattern_matching_relative_path("a/file".into(), None, &mut no_attrs)