feat!: Stack::at_path() replaces is_dir parameter with mode.

That way, detailed information about the path-to-be is available not
only for evaluating attributes or excludes, but also for validating
path components (in this case, relevant for `.gitmodules`).

Author: Byron

gix-worktree/src/stack/delegate.rs

@@ -1,3 +1,4 @@
+use crate::stack::mode_is_dir;
 use crate::{stack::State, PathIdMapping};
 
 /// Various aggregate numbers related to the stack delegate itself.
@@ -20,7 +21,7 @@ pub(crate) struct StackDelegate<'a, 'find> {
     pub state: &'a mut State,
     pub buf: &'a mut Vec<u8>,
     #[cfg_attr(not(feature = "attributes"), allow(dead_code))]
-    pub is_dir: bool,
+    pub mode: Option<gix_index::entry::Mode>,
     pub id_mappings: &'a Vec<PathIdMapping>,
     pub objects: &'find dyn gix_object::Find,
     pub case: gix_glob::pattern::Case,
@@ -91,11 +92,11 @@ impl<'a, 'find> gix_fs::stack::Delegate for StackDelegate<'a, 'find> {
                 validate,
                 attributes: _,
             } => {
-                validate_last_component(stack, *validate)?;
+                validate_last_component(stack, self.mode, *validate)?;
                 create_leading_directory(
                     is_last_component,
                     stack,
-                    self.is_dir,
+                    self.mode,
                     &mut self.statistics.delegate.num_mkdir_calls,
                     *unlink_on_collision,
                 )?
@@ -127,8 +128,11 @@ impl<'a, 'find> gix_fs::stack::Delegate for StackDelegate<'a, 'find> {
 }
 
 #[cfg(feature = "attributes")]
-fn validate_last_component(stack: &gix_fs::Stack, opts: gix_validate::path::component::Options) -> std::io::Result<()> {
-    // TODO: add mode-information
+fn validate_last_component(
+    stack: &gix_fs::Stack,
+    mode: Option<gix_index::entry::Mode>,
+    opts: gix_validate::path::component::Options,
+) -> std::io::Result<()> {
     let Some(last_component) = stack.current_relative().components().rev().next() else {
         return Ok(());
     };
@@ -143,7 +147,13 @@ fn validate_last_component(stack: &gix_fs::Stack, opts: gix_validate::path::comp
             )
         })?;
 
-    if let Err(err) = gix_validate::path::component(last_component.as_ref(), None, opts) {
+    if let Err(err) = gix_validate::path::component(
+        last_component.as_ref(),
+        mode.and_then(|m| {
+            (m == gix_index::entry::Mode::SYMLINK).then_some(gix_validate::path::component::Mode::Symlink)
+        }),
+        opts,
+    ) {
         return Err(std::io::Error::new(std::io::ErrorKind::Other, err));
     }
     Ok(())
@@ -153,11 +163,11 @@ fn validate_last_component(stack: &gix_fs::Stack, opts: gix_validate::path::comp
 fn create_leading_directory(
     is_last_component: bool,
     stack: &gix_fs::Stack,
-    is_dir: bool,
+    mode: Option<gix_index::entry::Mode>,
     mkdir_calls: &mut usize,
     unlink_on_collision: bool,
 ) -> std::io::Result<()> {
-    if is_last_component && !is_dir {
+    if is_last_component && !mode_is_dir(mode).unwrap_or(false) {
         return Ok(());
     }
     *mkdir_calls += 1;

gix-worktree/src/stack/mod.rs

@@ -105,42 +105,46 @@ impl Stack {
 impl Stack {
     /// Append the `relative` path to the root directory of the cache and efficiently create leading directories, while assuring that no
     /// symlinks are in that path.
-    /// Unless `is_dir` is known with `Some(…)`, then `relative` points to a directory itself in which case the entire resulting
-    /// path is created as directory. If it's not known it is assumed to be a file.
+    /// Unless `mode` is known with `Some(gix_index::entry::Mode::DIR|COMMIT)`,
+    /// then `relative` points to a directory itself in which case the entire resulting path is created as directory.
+    /// If it's not known it is assumed to be a file.
     /// `objects` maybe used to lookup objects from an [id mapping][crate::stack::State::id_mappings_from_index()], with mappnigs
     ///
     /// Provide access to cached information for that `relative` path via the returned platform.
     pub fn at_path(
         &mut self,
         relative: impl AsRef<Path>,
-        is_dir: Option<bool>,
+        mode: Option<gix_index::entry::Mode>,
         objects: &dyn gix_object::Find,
     ) -> std::io::Result<Platform<'_>> {
         self.statistics.platforms += 1;
         let mut delegate = StackDelegate {
             state: &mut self.state,
             buf: &mut self.buf,
-            is_dir: is_dir.unwrap_or(false),
+            mode,
             id_mappings: &self.id_mappings,
             objects,
             case: self.case,
             statistics: &mut self.statistics,
         };
         self.stack
             .make_relative_path_current(relative.as_ref(), &mut delegate)?;
-        Ok(Platform { parent: self, is_dir })
+        Ok(Platform {
+            parent: self,
+            is_dir: mode_is_dir(mode),
+        })
     }
 
-    /// Obtain a platform for lookups from a repo-`relative` path, typically obtained from an index entry. `is_dir` should reflect
-    /// whether it's a directory or not, or left at `None` if unknown.
+    /// Obtain a platform for lookups from a repo-`relative` path, typically obtained from an index entry. `mode` should reflect
+    /// the kind of item set here, or left at `None` if unknown.
     /// `objects` maybe used to lookup objects from an [id mapping][crate::stack::State::id_mappings_from_index()].
     /// All effects are similar to [`at_path()`][Self::at_path()].
     ///
-    /// If `relative` ends with `/` and `is_dir` is `None`, it is automatically assumed to be a directory.
+    /// If `relative` ends with `/` and `mode` is `None`, it is automatically assumed set to be a directory.
     pub fn at_entry<'r>(
         &mut self,
         relative: impl Into<&'r BStr>,
-        is_dir: Option<bool>,
+        mode: Option<gix_index::entry::Mode>,
         objects: &dyn gix_object::Find,
     ) -> std::io::Result<Platform<'_>> {
         let relative = relative.into();
@@ -156,12 +160,18 @@ impl Stack {
 
         self.at_path(
             relative_path,
-            is_dir.or_else(|| relative.ends_with_str("/").then_some(true)),
+            mode.or_else(|| relative.ends_with_str("/").then_some(gix_index::entry::Mode::DIR)),
             objects,
         )
     }
 }
 
+fn mode_is_dir(mode: Option<gix_index::entry::Mode>) -> Option<bool> {
+    mode.map(|m|
+        // This applies to directories and commits (submodules are directories on disk)
+        m.is_sparse() || m.is_submodule())
+}
+
 /// Mutation
 impl Stack {
     /// Reset the statistics after returning them.

gix-worktree/tests/worktree/stack/create_directory.rs

@@ -3,6 +3,9 @@ use std::path::Path;
 use gix_testtools::tempfile::{tempdir, TempDir};
 use gix_worktree::{stack, Stack};
 
+const IS_FILE: Option<gix_index::entry::Mode> = Some(gix_index::entry::Mode::FILE);
+const IS_DIR: Option<gix_index::entry::Mode> = Some(gix_index::entry::Mode::DIR);
+
 #[test]
 fn root_is_assumed_to_exist_and_files_in_root_do_not_create_directory() -> crate::Result {
     let dir = tempdir()?;
@@ -15,7 +18,7 @@ fn root_is_assumed_to_exist_and_files_in_root_do_not_create_directory() -> crate
     );
     assert_eq!(cache.statistics().delegate.num_mkdir_calls, 0);
 
-    let path = cache.at_path("hello", Some(false), &gix_object::find::Never)?.path();
+    let path = cache.at_path("hello", IS_FILE, &gix_object::find::Never)?.path();
     assert!(!path.parent().unwrap().exists(), "prefix itself is never created");
     assert_eq!(cache.statistics().delegate.num_mkdir_calls, 0);
     Ok(())
@@ -25,15 +28,15 @@ fn root_is_assumed_to_exist_and_files_in_root_do_not_create_directory() -> crate
 fn directory_paths_are_created_in_full() {
     let (mut cache, _tmp) = new_cache();
 
-    for (name, is_dir) in &[
-        ("dir", Some(true)),
-        ("submodule", Some(true)),
-        ("file", Some(false)),
-        ("exe", Some(false)),
+    for (name, mode) in [
+        ("dir", IS_DIR),
+        ("submodule", IS_DIR),
+        ("file", IS_FILE),
+        ("exe", IS_FILE),
         ("link", None),
     ] {
         let path = cache
-            .at_path(Path::new("dir").join(name), *is_dir, &gix_object::find::Never)
+            .at_path(Path::new("dir").join(name), mode, &gix_object::find::Never)
             .unwrap()
             .path();
         assert!(path.parent().unwrap().is_dir(), "dir exists");
@@ -47,7 +50,7 @@ fn existing_directories_are_fine() -> crate::Result {
     let (mut cache, tmp) = new_cache();
     std::fs::create_dir(tmp.path().join("dir"))?;
 
-    let path = cache.at_path("dir/file", Some(false), &gix_object::find::Never)?.path();
+    let path = cache.at_path("dir/file", IS_FILE, &gix_object::find::Never)?.path();
     assert!(path.parent().unwrap().is_dir(), "directory is still present");
     assert!(!path.exists(), "it won't create the file");
     assert_eq!(cache.statistics().delegate.num_mkdir_calls, 1);
@@ -59,7 +62,7 @@ fn validation_to_each_component() -> crate::Result {
     let (mut cache, tmp) = new_cache();
 
     let err = cache
-        .at_path("valid/.gIt", Some(false), &gix_object::find::Never)
+        .at_path("valid/.gIt", IS_FILE, &gix_object::find::Never)
         .unwrap_err();
     assert_eq!(
         cache.statistics().delegate.num_mkdir_calls,
@@ -89,7 +92,7 @@ fn symlinks_or_files_in_path_are_forbidden_or_unlinked_when_forced() -> crate::R
         let relative_path = format!("{dirname}/file");
         assert_eq!(
             cache
-                .at_path(&relative_path, Some(false), &gix_object::find::Never)
+                .at_path(&relative_path, IS_FILE, &gix_object::find::Never)
                 .unwrap_err()
                 .kind(),
             std::io::ErrorKind::AlreadyExists
@@ -109,9 +112,7 @@ fn symlinks_or_files_in_path_are_forbidden_or_unlinked_when_forced() -> crate::R
             *unlink_on_collision = true;
         }
         let relative_path = format!("{dirname}/file");
-        let path = cache
-            .at_path(&relative_path, Some(false), &gix_object::find::Never)?
-            .path();
+        let path = cache.at_path(&relative_path, IS_FILE, &gix_object::find::Never)?.path();
         assert!(path.parent().unwrap().is_dir(), "directory was forcefully created");
         assert!(!path.exists());
     }

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

@@ -1,5 +1,7 @@
 use bstr::{BStr, ByteSlice};
+use gix_index::entry::Mode;
 use gix_worktree::{stack::state::ignore::Source, Stack};
+use std::fs::Metadata;
 
 use crate::{hex_to_id, worktree::stack::probe_case};
 
@@ -62,7 +64,7 @@ fn exclude_by_dir_is_handled_just_like_git() {
     for (relative_entry, source_and_line) in expectations {
         let (source, line, expected_pattern) = source_and_line.expect("every value is matched");
         let relative_path = gix_path::from_byte_slice(relative_entry);
-        let is_dir = dir.join(relative_path).metadata().ok().map(|m| m.is_dir());
+        let is_dir = dir.join(relative_path).metadata().ok().map(metadata_to_mode);
 
         let platform = cache.at_entry(relative_entry, is_dir, &FindError).unwrap();
         let match_ = platform.matching_exclude_pattern().expect("match all values");
@@ -87,6 +89,14 @@ fn exclude_by_dir_is_handled_just_like_git() {
     }
 }
 
+fn metadata_to_mode(meta: Metadata) -> Mode {
+    if meta.is_dir() {
+        gix_index::entry::Mode::DIR
+    } else {
+        gix_index::entry::Mode::FILE
+    }
+}
+
 #[test]
 fn check_against_baseline() -> crate::Result {
     let dir = gix_testtools::scripted_fixture_read_only_standalone("make_ignore_and_attributes_setup.sh")?;
@@ -127,7 +137,7 @@ fn check_against_baseline() -> crate::Result {
     };
     for (relative_entry, source_and_line) in expectations {
         let relative_path = gix_path::from_byte_slice(relative_entry);
-        let is_dir = worktree_dir.join(relative_path).metadata().ok().map(|m| m.is_dir());
+        let is_dir = worktree_dir.join(relative_path).metadata().ok().map(metadata_to_mode);
 
         let platform = cache.at_entry(relative_entry, is_dir, &odb)?;