feat: Add State::path_is_dir() and State::path_is_dir_icase()

Co-authored-by: Byron <63622+Byron@users.noreply.github.com>

Author: Copilot

gix-index/src/access/mod.rs

@@ -212,7 +212,7 @@ impl State {
     /// make another call to [`entry_by_path_icase()`](Self::entry_by_path_icase) to check for this
     /// possibility. Doing so might also reveal a sparse directory.
     ///
-    /// If `ignore_case` is set
+    /// If `ignore_case` is set, a case-insensitive (ASCII-folding only) search will be performed.
     pub fn entry_closest_to_directory_icase<'a>(
         &'a self,
         directory: &BStr,
@@ -259,6 +259,39 @@ impl State {
         None
     }
 
+    /// Check if `path` is a directory that contains entries in the index.
+    ///
+    /// Returns `true` if there is at least one entry in the index whose path starts with `path/`,
+    /// indicating that `path` is a directory containing indexed files.
+    ///
+    /// For example, if the index contains an entry at `dirname/file`, then calling this method
+    /// with `dirname` would return `true`, but calling it with `dir` would return `false`.
+    ///
+    /// Note that this is a case-sensitive search.
+    pub fn path_is_directory(&self, path: &BStr) -> bool {
+        self.entry_closest_to_directory(path).is_some()
+    }
+
+    /// Check if `path` is a directory that contains entries in the index, with optional case-insensitive matching.
+    ///
+    /// Returns `true` if there is at least one entry in the index whose path starts with `path/`,
+    /// indicating that `path` is a directory containing indexed files.
+    ///
+    /// If `ignore_case` is `true`, a case-insensitive (ASCII-folding only) search will be performed.
+    ///
+    /// For example, if the index contains an entry at `dirname/file`, then calling this method
+    /// with `dirname` (or `DirName` with `ignore_case = true`) would return `true`, but calling it
+    /// with `dir` would return `false`.
+    pub fn path_is_directory_icase<'a>(
+        &'a self,
+        path: &BStr,
+        ignore_case: bool,
+        lookup: &AccelerateLookup<'a>,
+    ) -> bool {
+        self.entry_closest_to_directory_icase(path, ignore_case, lookup)
+            .is_some()
+    }
+
     /// Find the entry index in [`entries()[..upper_bound]`][State::entries()] matching the given repository-relative
     /// `path` and `stage`, or `None`.
     ///

gix-index/tests/index/access.rs

@@ -324,3 +324,112 @@ fn check_prefix(index: &gix_index::State, prefix: &str, expected: &[&str]) {
         "{prefix:?}"
     );
 }
+
+#[test]
+fn path_is_directory() {
+    let file = Fixture::Loose("ignore-case-realistic").open();
+
+    // Test that directories containing entries are detected
+    assert!(
+        file.path_is_directory("tests".into()),
+        "tests is a directory containing entries"
+    );
+    assert!(
+        file.path_is_directory("tests/snapshots".into()),
+        "tests/snapshots is a directory containing entries"
+    );
+    assert!(
+        file.path_is_directory("tests/snapshots/porcelain".into()),
+        "tests/snapshots/porcelain is a directory"
+    );
+    assert!(
+        file.path_is_directory("tests/tools".into()),
+        "tests/tools is a directory"
+    );
+
+    // Test that non-existent directories return false
+    assert!(
+        !file.path_is_directory("nonexistent".into()),
+        "nonexistent is not a directory"
+    );
+    assert!(!file.path_is_directory("z".into()), "z is not a directory");
+    assert!(
+        !file.path_is_directory("test".into()),
+        "test is not a directory (tests is)"
+    );
+
+    // Test that files are not directories
+    assert!(
+        !file.path_is_directory("tests/utilities.sh".into()),
+        "tests/utilities.sh is a file, not a directory"
+    );
+
+    // Test that partial directory names don't match
+    assert!(!file.path_is_directory("".into()), "empty path is not a directory");
+}
+
+#[test]
+fn path_is_directory_icase() {
+    let file = Fixture::Loose("ignore-case-realistic").open();
+    let icase = file.prepare_icase_backing();
+
+    // Test case-sensitive matching
+    assert!(
+        file.path_is_directory_icase("tests".into(), false, &icase),
+        "tests is a directory (case-sensitive)"
+    );
+    assert!(
+        file.path_is_directory_icase("tests/tools".into(), false, &icase),
+        "tests/tools is a directory (case-sensitive)"
+    );
+
+    // Test case-insensitive matching
+    assert!(
+        file.path_is_directory_icase("TESTS".into(), true, &icase),
+        "TESTS is a directory (case-insensitive, matches 'tests')"
+    );
+    assert!(
+        file.path_is_directory_icase("tests/TOOLS".into(), true, &icase),
+        "tests/TOOLS is a directory (case-insensitive, matches 'tests/tools')"
+    );
+    assert!(
+        file.path_is_directory_icase("TESTS/SNAPSHOTS".into(), true, &icase),
+        "TESTS/SNAPSHOTS is a directory (case-insensitive)"
+    );
+
+    // Test that non-existent paths return false even with icase
+    assert!(
+        !file.path_is_directory_icase("nonexistent".into(), true, &icase),
+        "nonexistent is not a directory even with icase"
+    );
+    assert!(
+        !file.path_is_directory_icase("Z".into(), true, &icase),
+        "Z is not a directory even with icase"
+    );
+}
+
+#[test]
+fn path_is_directory_icase_with_clashes() {
+    let file = icase_fixture();
+    let icase = file.prepare_icase_backing();
+
+    // Test directory detection with case clashes
+    assert!(
+        file.path_is_directory_icase("D".into(), false, &icase),
+        "D is a directory (case-sensitive)"
+    );
+    assert!(
+        file.path_is_directory_icase("d".into(), true, &icase),
+        "d matches D directory (case-insensitive)"
+    );
+
+    // Test that files aren't detected as directories
+    assert!(
+        !file.path_is_directory_icase("X".into(), false, &icase),
+        "X is a file, not a directory"
+    );
+    assert!(
+        !file.path_is_directory_icase("x".into(), false, &icase),
+        "x is a symlink, not a directory"
+    );
+}