feat: Add Search::directory_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,59 @@ 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`.
+    /// When `leading` is `true`, then `d` matches `d/d` as well. Thus `relative_path` must may be
+    /// partially included in `pathspec`, otherwise it has to be fully included.
+    pub fn directory_matches_prefix(&self, relative_path: &BStr, leading: 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.is_some() && pattern.is_excluded() {
+                return true;
+            }
+            let mut 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 {
+                let plen = relative_path.len();
+                if leading && rightmost_idx > plen {
+                    if let Some(idx) = pattern.path[..plen]
+                        .rfind_byte(b'/')
+                        .or_else(|| pattern.path[plen..].find_byte(b'/').map(|idx| idx + plen))
+                    {
+                        rightmost_idx = idx;
+                    }
+                }
+                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,116 @@ 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(), false),
+                "{spec}: must match"
+            );
+            assert!(
+                !search.directory_matches_prefix("d".into(), false),
+                "{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(), false),
+                "{spec}: must match"
+            );
+            assert!(
+                search.directory_matches_prefix("dir/d".into(), true),
+                "{spec}: must match"
+            );
+            for leading in [false, true] {
+                assert!(
+                    !search.directory_matches_prefix("d".into(), leading),
+                    "{spec}: must not match"
+                );
+                assert!(
+                    !search.directory_matches_prefix("di".into(), leading),
+                    "{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(), false));
+    assert!(search.directory_matches_prefix("d".into(), false));
+    Ok(())
+}
+
+#[test]
+fn directory_matches_prefix_leading() -> crate::Result {
+    let search = gix_pathspec::Search::from_specs(pathspecs(&["d/d/generated/b"]), None, Path::new(""))?;
+    assert!(!search.directory_matches_prefix("di".into(), false));
+    assert!(!search.directory_matches_prefix("di".into(), true));
+    assert!(search.directory_matches_prefix("d".into(), true));
+    assert!(!search.directory_matches_prefix("d".into(), false));
+    assert!(search.directory_matches_prefix("d/d".into(), true));
+    assert!(!search.directory_matches_prefix("d/d".into(), false));
+    assert!(search.directory_matches_prefix("d/d/generated".into(), true));
+    assert!(!search.directory_matches_prefix("d/d/generated".into(), false));
+    assert!(!search.directory_matches_prefix("d/d/generatedfoo".into(), false));
+    assert!(!search.directory_matches_prefix("d/d/generatedfoo".into(), true));
+
+    let search = gix_pathspec::Search::from_specs(pathspecs(&[":(icase)d/d/GENERATED/b"]), None, Path::new(""))?;
+    assert!(
+        search.directory_matches_prefix("d/d/generated".into(), true),
+        "icase is respected as well"
+    );
+    assert!(!search.directory_matches_prefix("d/d/generated".into(), false));
+    Ok(())
+}
+
+#[test]
+fn directory_matches_prefix_negative_wildcard() -> crate::Result {
+    let search = gix_pathspec::Search::from_specs(pathspecs(&[":!*generated*"]), None, Path::new(""))?;
+    assert!(
+        search.directory_matches_prefix("di".into(), false),
+        "it's always considered matching, we can't really tell anyway"
+    );
+    assert!(search.directory_matches_prefix("di".into(), true));
+    assert!(search.directory_matches_prefix("d".into(), true));
+    assert!(search.directory_matches_prefix("d".into(), false));
+    assert!(search.directory_matches_prefix("d/d".into(), true));
+    assert!(search.directory_matches_prefix("d/d".into(), false));
+    assert!(search.directory_matches_prefix("d/d/generated".into(), true));
+    assert!(search.directory_matches_prefix("d/d/generated".into(), false));
+    assert!(search.directory_matches_prefix("d/d/generatedfoo".into(), false));
+    assert!(search.directory_matches_prefix("d/d/generatedfoo".into(), true));
+
+    let search = gix_pathspec::Search::from_specs(pathspecs(&[":(exclude,icase)*GENERATED*"]), None, Path::new(""))?;
+    assert!(search.directory_matches_prefix("d/d/generated".into(), true));
+    assert!(search.directory_matches_prefix("d/d/generated".into(), false));
+    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(), false),
+                "{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 +131,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(), false));
     Ok(())
 }
 
@@ -51,6 +162,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(), false));
+    assert!(!search.directory_matches_prefix("ab".into(), false));
     assert_eq!(
         search
             .pattern_matching_relative_path("a/file".into(), None, &mut no_attrs)