Make it even harder to remove your own CWD

Author: Byron

gix-dir/src/entry.rs

@@ -9,6 +9,12 @@ pub enum Property {
     DotGit,
     /// The entry is a directory, and that directory is empty.
     EmptyDirectory,
+    /// The entry is a directory, it is empty and the current working directory.
+    ///
+    /// The caller should pay special attention to this very special case, as it is indeed only possible to run into it
+    /// while traversing the directory for deletion.
+    /// Non-empty directory will never be collapsed, hence if they are working directories, they naturally become unobservable.
+    EmptyDirectoryAndCWD,
     /// Always in conjunction with a directory on disk that is also known as cone-mode sparse-checkout exclude marker
     /// - i.e. a directory that is excluded, so its whole content is excluded and not checked out nor is part of the index.
     ///

gix-dir/src/walk/readdir.rs

@@ -94,6 +94,7 @@ pub(super) fn recursive(
         num_entries,
         state,
         &mut prevent_collapse,
+        current,
         current_bstr.as_bstr(),
         current_info,
         opts,
@@ -157,7 +158,7 @@ impl State {
 
     pub(super) fn emit_remaining(
         &mut self,
-        is_top_level: bool,
+        may_collapse: bool,
         opts: Options,
         out: &mut walk::Outcome,
         delegate: &mut dyn walk::Delegate,
@@ -168,7 +169,7 @@ impl State {
 
         _ = Mark {
             start_index: 0,
-            may_collapse: is_top_level,
+            may_collapse,
         }
         .emit_all_held(self, opts, out, delegate);
     }
@@ -186,6 +187,7 @@ impl Mark {
         num_entries: usize,
         state: &mut State,
         prevent_collapse: &mut bool,
+        dir_path: &Path,
         dir_rela_path: &BStr,
         dir_info: classify::Outcome,
         opts: Options,
@@ -195,19 +197,20 @@ impl Mark {
     ) -> walk::Action {
         if num_entries == 0 {
             let empty_info = classify::Outcome {
-                property: if num_entries == 0 {
+                property: {
                     assert_ne!(
                         dir_info.disk_kind,
                         Some(entry::Kind::Repository),
                         "BUG: it shouldn't be possible to classify an empty dir as repository"
                     );
-                    if dir_info.property.is_none() {
+                    if !state.may_collapse(dir_path) {
+                        *prevent_collapse = true;
+                        entry::Property::EmptyDirectoryAndCWD.into()
+                    } else if dir_info.property.is_none() {
                         entry::Property::EmptyDirectory.into()
                     } else {
                         dir_info.property
                     }
-                } else {
-                    dir_info.property
                 },
                 pathspec_match: ctx
                     .pathspec

gix-dir/tests/fixtures/many.sh

@@ -178,6 +178,14 @@ git init only-untracked
   >c
 )
 
+git init ignored-with-empty
+(cd ignored-with-empty
+  echo "/target/" >> .gitignore
+  git add .gitignore && git commit -m "init"
+  mkdir -p target/empty target/debug target/release
+  touch target/debug/a target/release/b
+)
+
 cp -R only-untracked subdir-untracked
 (cd subdir-untracked
   git add .

gix-dir/tests/walk/mod.rs

@@ -357,6 +357,86 @@ fn ignored_dir_with_cwd_handling() -> crate::Result {
     Ok(())
 }
 
+#[test]
+fn ignored_with_cwd_handling() -> crate::Result {
+    let root = gix_path::realpath(fixture("ignored-with-empty"))?;
+    let ((out, _root), entries) = collect_filtered_with_cwd(
+        &root,
+        None,
+        None,
+        |keep, ctx| {
+            walk(
+                &root,
+                ctx,
+                walk::Options {
+                    for_deletion: Some(Default::default()),
+                    emit_ignored: Some(CollapseDirectory),
+                    emit_empty_directories: true,
+                    ..options()
+                },
+                keep,
+            )
+        },
+        None::<&str>,
+    );
+
+    assert_eq!(
+        out,
+        walk::Outcome {
+            read_dir_calls: 1,
+            returned_entries: entries.len(),
+            seen_entries: 3,
+        }
+    );
+
+    assert_eq!(
+        entries,
+        [entry("target", Ignored(Expendable), Directory),],
+        "the baseline shows the content"
+    );
+
+    let ((out, _root), entries) = collect_filtered_with_cwd(
+        &root,
+        Some(&root),
+        Some("target/empty"),
+        |keep, ctx| {
+            walk(
+                &root,
+                ctx,
+                walk::Options {
+                    for_deletion: Some(Default::default()),
+                    emit_ignored: Some(CollapseDirectory),
+                    emit_empty_directories: true,
+                    ..options()
+                },
+                keep,
+            )
+        },
+        Some("target"),
+    );
+
+    assert_eq!(
+        out,
+        walk::Outcome {
+            read_dir_calls: 5,
+            returned_entries: entries.len(),
+            seen_entries: 7,
+        }
+    );
+
+    assert_eq!(
+        entries,
+        [
+            entryps("target/debug", Ignored(Expendable), Directory, Prefix),
+            entryps("target/empty", Ignored(Expendable), Directory, Prefix).with_property(EmptyDirectoryAndCWD),
+            entryps("target/release", Ignored(Expendable), Directory, Prefix),
+        ],
+        "it detects empty as CWD (very special case) and lists it as usual, while also preventing collapse to assure \
+         to not accidentally end up trying to delete a parent directory"
+    );
+    Ok(())
+}
+
 #[test]
 fn only_untracked_with_cwd_handling() -> crate::Result {
     let root = fixture("only-untracked");