fix: cache::Ignore assures that case-sensitivity is handled similarly to git.

Previously directory excludes like `dir/` could yield different results compared to git.

Author: Byron

gix-worktree/src/cache/state/ignore.rs

@@ -149,13 +149,23 @@ impl Ignore {
         Find: for<'b> FnMut(&oid, &'b mut Vec<u8>) -> Result<gix_object::BlobRef<'b>, E>,
         E: std::error::Error + Send + Sync + 'static,
     {
-        gix_glob::search::pattern::strip_base_handle_recompute_basename_pos()
-        let rela_dir = dir.strip_prefix(root).expect("dir in root");
+        let dir_bstr = gix_path::into_bstr(dir);
+        let mut rela_dir = gix_glob::search::pattern::strip_base_handle_recompute_basename_pos(
+            gix_path::into_bstr(root).as_ref(),
+            dir_bstr.as_ref(),
+            None,
+            self.case,
+        )
+        .expect("dir in root")
+        .0;
+        if rela_dir.starts_with(b"/") {
+            rela_dir = &rela_dir[1..];
+        }
         self.matched_directory_patterns_stack
-            .push(self.matching_exclude_pattern_no_dir(gix_path::into_bstr(rela_dir).as_ref(), Some(true), self.case));
+            .push(self.matching_exclude_pattern_no_dir(rela_dir, Some(true), self.case));
 
-        let ignore_path_relative = rela_dir.join(".gitignore");
-        let ignore_path_relative = gix_path::to_unix_separators_on_windows(gix_path::into_bstr(ignore_path_relative));
+        let ignore_path_relative =
+            gix_path::to_unix_separators_on_windows(gix_path::join_bstr_unix_pathsep(rela_dir, ".gitignore"));
         let ignore_file_in_index =
             attribute_files_in_index.binary_search_by(|t| t.0.as_bstr().cmp(ignore_path_relative.as_ref()));
         let follow_symlinks = ignore_file_in_index.is_err();

gix-worktree/tests/fixtures/generated-archives/.gitignore

@@ -0,0 +1 @@
+make_ignore_and_attributes_setup.tar.xz

gix-worktree/tests/fixtures/generated-archives/make_ignore_and_attributes_setup.tar.xz

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ae297f2c067e2cc7b0c8eabfff721ff775a7d8266ffef979bde2458de2ab03c9
-size 10944
+oid sha256:38df6900cdb0ad620e158a3cc19325053658b9cfcb8987779af634813d957f6c
+size 11088

gix-worktree/tests/fixtures/make_ignore_and_attributes_setup.sh

@@ -6,11 +6,13 @@ cat <<EOF >user.exclude
 user-file-anywhere
 /user-file-from-top
 
-user-dir-anywhere/
+user-Dir-anywhere/
 /user-dir-from-top
 
 user-subdir/file
 **/user-subdir-anywhere/file
+a/b/*
+z/x
 EOF
 
 mkdir repo;
@@ -33,13 +35,15 @@ EOF
   cat <<EOF >.gitignore
 # a sample .gitignore
 top-level-local-file-anywhere
+d/e/*
+e/f
 EOF
 
   mkdir dir-with-ignore
   cat <<EOF >dir-with-ignore/.gitignore
 # a sample .gitignore
 sub-level-local-file-anywhere
-sub-level-dir-anywhere/
+sub-Level-dir-anywhere/
 !/negated
 /negated-dir/
 !/negated-dir/
@@ -63,13 +67,13 @@ EOF
 
   git check-ignore -vn --stdin 2>&1 <<EOF >git-check-ignore.baseline || :
 dir-with-ignore/sub-level-dir-anywhere/
-dir-with-ignore/foo/sub-level-dir-anywhere/
-dir-with-ignore/sub-level-dir-anywhere
+dir-with-ignore/foo/Sub-level-dir-anywhere/
+dir-with-ignore/Sub-level-dir-anywhere
 user-file-anywhere
 dir/user-file-anywhere
 user-file-from-top
 no-match/user-file-from-top
-user-dir-anywhere
+USER-dir-anywhere
 user-dir-from-top
 no-match/user-dir-from-top
 user-subdir/file
@@ -107,6 +111,20 @@ other-dir-with-ignore/other-sub-level-dir-anywhere/hello
 other-dir-with-ignore/other-sub-level-dir-anywhere/
 dir-with-ignore/negated
 dir-with-ignore/negated-dir/hello
+a/b/C
+a/B/c
+A/B/C
+z/x
+Z/x
+z/X
+Z/X
+d/e/F
+d/e/f
+D/e/F
+D/E/F
+e/f
+e/F
+E/f
+E/F
 EOF
-
 )

gix-worktree/tests/worktree/cache/ignore.rs

@@ -1,11 +1,7 @@
-use std::path::Path;
-
 use bstr::{BStr, ByteSlice};
 use gix_glob::pattern::Case;
-use gix_index::entry::Mode;
-use gix_odb::{pack::bundle::write::Options, FindExt};
+use gix_odb::FindExt;
 use gix_worktree::Cache;
-use tempfile::{tempdir, TempDir};
 
 use crate::hex_to_id;
 
@@ -68,12 +64,12 @@ fn special_exclude_cases_we_handle_differently() {
         let is_dir = dir.join(&relative_path).metadata().ok().map(|m| m.is_dir());
 
         let platform = cache
-            .at_entry(relative_entry, is_dir, |oid, buf| {
+            .at_entry(relative_entry, is_dir, |_oid, _buf| {
                 Err(std::io::Error::new(std::io::ErrorKind::Other, "unreachable"))
             })
             .unwrap();
         let match_ = platform.matching_exclude_pattern().expect("match all values");
-        let is_excluded = platform.is_excluded();
+        let _is_excluded = platform.is_excluded();
 
         match relative_entry.as_bytes() {
             b"tld" | b"tld/" | b"tld/file" | b"tld/sd" | b"tld/sd/" => {
@@ -93,11 +89,17 @@ fn check_against_baseline() -> crate::Result {
     let user_exclude_path = dir.join("user.exclude");
     assert!(user_exclude_path.is_file());
 
+    // Due to the way our setup differs from gits dynamic stack (which involves trying to read files from disk
+    // by path) we can only test one case baseline, so we require multiple platforms (or filesystems) to run this.
+    let case = if gix_fs::Capabilities::probe("../.git").ignore_case {
+        Case::Fold
+    } else {
+        Case::Sensitive
+    };
     let mut index = gix_index::File::at(git_dir.join("index"), gix_hash::Kind::Sha1, Default::default())?;
     let odb = gix_odb::at(git_dir.join("objects"))?;
-    let case = gix_glob::pattern::Case::Sensitive;
     let state = gix_worktree::cache::State::for_add(
-        Default::default(), // TODO: attribute tests
+        Default::default(),
         gix_worktree::cache::state::Ignore::new(
             gix_ignore::Search::from_overrides(vec!["!force-include"]),
             gix_ignore::Search::from_git_dir(&git_dir, Some(user_exclude_path), &mut buf)?,
@@ -159,5 +161,10 @@ fn check_against_baseline() -> crate::Result {
     let platform = cache.at_entry("User-file-ANYWHERE", Some(false), |oid, buf| odb.find_blob(oid, buf))?;
     let m = platform.matching_exclude_pattern().expect("match");
     assert_eq!(m.pattern.text, "user-file-anywhere");
+
+    cache.set_case(Case::Fold);
+    let platform = cache.at_entry("User-Dir-ANYWHERE", Some(true), |oid, buf| odb.find_blob(oid, buf))?;
+    let m = platform.matching_exclude_pattern().expect("match");
+    assert_eq!(m.pattern.text, "user-Dir-anywhere");
     Ok(())
 }