fix: Search::can_match_relative_path() won't report false-negatives anymore.

It does this by ignoring exclude patterns, preferring false-positives that way.

Author: Byron

gix-pathspec/src/search/matching.rs

@@ -176,12 +176,14 @@ impl Search {
                             matches!(pattern.path.get(common_len), None | Some(&b'/'))
                         } else {
                             relative_path.get(common_len) == Some(&b'/')
-                        }
+                        };
                     }
                 }
             }
             if is_match {
-                return !pattern.is_excluded();
+                if !pattern.is_excluded() || pattern.always_matches() {
+                    return !pattern.is_excluded();
+                }
             }
         }
 
@@ -191,7 +193,7 @@ impl Search {
     /// 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
+    /// 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() {
@@ -234,7 +236,9 @@ impl Search {
                 }
             }
             if is_match {
-                return !pattern.is_excluded();
+                if !pattern.is_excluded() || pattern.always_matches() {
+                    return !pattern.is_excluded();
+                }
             }
         }
 

gix-pathspec/tests/search/mod.rs

@@ -135,6 +135,47 @@ fn no_pathspecs_match_everything() -> crate::Result {
     Ok(())
 }
 
+#[test]
+fn included_directory_and_excluded_subdir_top_level_with_prefix() -> crate::Result {
+    let mut search = gix_pathspec::Search::from_specs(pathspecs(&[":/foo", ":!/foo/target/"]), None, Path::new("foo"))?;
+    let m = search
+        .pattern_matching_relative_path("foo".into(), Some(true), &mut no_attrs)
+        .expect("matches");
+    assert_eq!(m.kind, Verbatim);
+
+    let m = search
+        .pattern_matching_relative_path("foo/bar".into(), Some(false), &mut no_attrs)
+        .expect("matches");
+    assert_eq!(m.kind, Prefix);
+
+    let m = search
+        .pattern_matching_relative_path("foo/target".into(), Some(false), &mut no_attrs)
+        .expect("matches");
+    assert_eq!(m.kind, Prefix, "files named `target` are allowed");
+
+    let m = search
+        .pattern_matching_relative_path("foo/target".into(), Some(true), &mut no_attrs)
+        .expect("matches");
+    assert!(m.is_excluded(), "directories named `target` are excluded");
+    assert_eq!(m.kind, Verbatim);
+
+    let m = search
+        .pattern_matching_relative_path("foo/target/file".into(), Some(false), &mut no_attrs)
+        .expect("matches");
+    assert!(m.is_excluded(), "everything below `target/` is also excluded");
+    assert_eq!(m.kind, Prefix);
+
+    assert!(search.directory_matches_prefix("foo/bar".into(), false));
+    assert!(search.directory_matches_prefix("foo/bar".into(), true));
+    assert!(search.directory_matches_prefix("foo".into(), false));
+    assert!(search.directory_matches_prefix("foo".into(), true));
+    assert!(search.can_match_relative_path("foo".into(), Some(true)));
+    assert!(search.can_match_relative_path("foo".into(), Some(false)));
+    assert!(search.can_match_relative_path("foo/hi".into(), Some(true)));
+    assert!(search.can_match_relative_path("foo/hi".into(), Some(false)));
+    Ok(())
+}
+
 #[test]
 fn starts_with() -> crate::Result {
     let mut search = gix_pathspec::Search::from_specs(pathspecs(&["a/*"]), None, Path::new(""))?;
@@ -261,8 +302,14 @@ fn simplified_search_respects_all_excluded() -> crate::Result {
         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("b".into(), None),
+        "non-trivial excludes are ignored in favor of false-positives"
+    );
+    assert!(
+        search.can_match_relative_path("a".into(), None),
+        "non-trivial excludes are ignored in favor of false-positives"
+    );
     assert!(search.can_match_relative_path("c".into(), None));
     assert!(search.can_match_relative_path("c/".into(), None));