feat!: allow to emit all collapsed entries.

This is useful for rename tracking as it allows to see all files
that may take part in a rename (i.e. when a directory is renamed).

Author: Byron

gix-dir/src/walk/mod.rs

@@ -58,8 +58,9 @@ pub trait Delegate {
     /// item isn't yet known. Pruned entries are also only emitted if [`Options::emit_pruned`] is `true`.
     ///
     /// `collapsed_directory_status` is `Some(dir_status)` if this entry was part of a directory with the given
-    /// `dir_status` that wasn't the same as the one of `entry`. Depending on the operation, these then want to be
-    /// used or discarded.
+    /// `dir_status` that wasn't the same as the one of `entry` and if [Options::emit_collapsed] was
+    /// [CollapsedEntriesEmissionMode::OnStatusMismatch]. It will also be `Some(dir_status)` if that option
+    /// was [CollapsedEntriesEmissionMode::All].
     fn emit(&mut self, entry: EntryRef<'_>, collapsed_directory_status: Option<entry::Status>) -> Action;
 
     /// Return `true` if the given entry can be recursed into. Will only be called if the entry is a physical directory.
@@ -94,6 +95,23 @@ pub enum EmissionMode {
     CollapseDirectory,
 }
 
+/// The way entries that are contained in collapsed directories are emitted using the [Delegate].
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub enum CollapsedEntriesEmissionMode {
+    /// Emit only entries if their status does not match the one of the parent directory that is
+    /// going to be collapsed.
+    ///
+    /// E.g. if a directory is determined to be untracked, and the entries in question are ignored,
+    /// they will be emitted.
+    ///
+    /// Entries that have the same status will essentially be 'merged' into the collapsing directory
+    /// and won't be observable anymore.
+    #[default]
+    OnStatusMismatch,
+    /// Emit all entries inside of a collapsed directory to make them observable.
+    All,
+}
+
 /// When the walk is for deletion, assure that we don't collapse directories that have precious files in
 /// them, and otherwise assure that no entries are observable that shouldn't be deleted.
 #[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
@@ -151,6 +169,8 @@ pub struct Options {
     /// subdirectories, as long as none of them includes a file.
     /// Thus, this makes leaf-level empty directories visible, as those don't have any content.
     pub emit_empty_directories: bool,
+    /// If `None`, no entries inside of collapsed directories are emitted. Otherwise, act as specified by `Some(mode)`.
+    pub emit_collapsed: Option<CollapsedEntriesEmissionMode>,
 }
 
 /// All information that is required to perform a dirwalk, and classify paths properly.

gix-dir/src/walk/readdir.rs

@@ -5,7 +5,7 @@ use std::path::PathBuf;
 use crate::entry::{PathspecMatch, Status};
 use crate::walk::function::{can_recurse, emit_entry};
 use crate::walk::EmissionMode::CollapseDirectory;
-use crate::walk::{classify, Action, Context, Delegate, Error, Options, Outcome};
+use crate::walk::{classify, Action, CollapsedEntriesEmissionMode, Context, Delegate, Error, Options, Outcome};
 use crate::{entry, walk, Entry};
 
 /// ### Deviation
@@ -286,12 +286,21 @@ impl Mark {
         let mut removed_without_emitting = 0;
         let mut action = Action::Continue;
         for entry in state.on_hold.drain(self.start_index..) {
-            if entry.status != dir_status && action == Action::Continue {
-                let info = classify::Outcome::from(&entry);
-                action = emit_entry(Cow::Owned(entry.rela_path), info, Some(dir_status), opts, out, delegate);
-            } else {
+            if action != Action::Continue {
                 removed_without_emitting += 1;
-            };
+                continue;
+            }
+            match opts.emit_collapsed {
+                Some(mode) => {
+                    if mode == CollapsedEntriesEmissionMode::All || entry.status != dir_status {
+                        let info = classify::Outcome::from(&entry);
+                        action = emit_entry(Cow::Owned(entry.rela_path), info, Some(dir_status), opts, out, delegate);
+                    } else {
+                        removed_without_emitting += 1;
+                    }
+                }
+                None => removed_without_emitting += 1,
+            }
         }
         out.seen_entries += removed_without_emitting as u32;
 

gix-dir/tests/walk/mod.rs

@@ -10,6 +10,7 @@ use gix_dir::entry;
 use gix_dir::entry::Kind::*;
 use gix_dir::entry::PathspecMatch::*;
 use gix_dir::entry::Status::*;
+use gix_dir::walk::CollapsedEntriesEmissionMode::{All, OnStatusMismatch};
 use gix_dir::walk::EmissionMode::*;
 use gix_dir::walk::ForDeletionMode;
 use gix_ignore::Kind::*;
@@ -1060,6 +1061,7 @@ fn untracked_and_ignored() -> crate::Result {
             walk::Options {
                 emit_ignored: Some(CollapseDirectory),
                 emit_untracked: CollapseDirectory,
+                emit_collapsed: Some(OnStatusMismatch),
                 ..options()
             },
             keep,
@@ -1147,6 +1149,7 @@ fn untracked_and_ignored_collapse_handling_mixed() -> crate::Result {
                         emit_ignored: Some(CollapseDirectory),
                         emit_untracked: CollapseDirectory,
                         for_deletion: None,
+                        emit_collapsed: Some(OnStatusMismatch),
                         ..options()
                     },
                     keep,
@@ -1242,6 +1245,7 @@ fn untracked_and_ignored_collapse_handling_for_deletion_with_wildcards() -> crat
                     emit_ignored: Some(CollapseDirectory),
                     emit_untracked: CollapseDirectory,
                     for_deletion: Some(Default::default()),
+                    emit_collapsed: Some(OnStatusMismatch),
                     ..options()
                 },
                 keep,
@@ -1363,6 +1367,7 @@ fn untracked_and_ignored_collapse_handling_for_deletion_mixed() -> crate::Result
                 emit_ignored: Some(CollapseDirectory),
                 emit_untracked: CollapseDirectory,
                 for_deletion: Some(Default::default()),
+                emit_collapsed: Some(OnStatusMismatch),
                 ..options()
             },
             keep,
@@ -1408,6 +1413,7 @@ fn untracked_and_ignored_collapse_handling_for_deletion_mixed() -> crate::Result
                     emit_ignored: Some(CollapseDirectory),
                     emit_untracked: CollapseDirectory,
                     for_deletion: Some(Default::default()),
+                    emit_collapsed: Some(OnStatusMismatch),
                     ..options()
                 },
                 keep,
@@ -1489,6 +1495,7 @@ fn untracked_and_ignored_collapse_handling_for_deletion_mixed() -> crate::Result
                     emit_ignored: Some(CollapseDirectory),
                     emit_untracked: CollapseDirectory,
                     for_deletion: Some(Default::default()),
+                    emit_collapsed: Some(OnStatusMismatch),
                     ..options()
                 },
                 keep,
@@ -1590,6 +1597,7 @@ fn precious_are_not_expendable() {
             walk::Options {
                 emit_ignored: Some(CollapseDirectory),
                 emit_untracked: CollapseDirectory,
+                emit_collapsed: Some(OnStatusMismatch),
                 ..options()
             },
             keep,
@@ -1629,6 +1637,7 @@ fn precious_are_not_expendable() {
                     walk::Options {
                         emit_ignored: Some(CollapseDirectory),
                         emit_untracked: CollapseDirectory,
+                        emit_collapsed: Some(OnStatusMismatch),
                         ..options()
                     },
                     keep,
@@ -2763,6 +2772,7 @@ fn untracked_and_ignored_collapse_mix() {
             walk::Options {
                 emit_ignored: Some(Matching),
                 emit_untracked: CollapseDirectory,
+                emit_collapsed: Some(OnStatusMismatch),
                 ..options_emit_all()
             },
             keep,
@@ -2788,6 +2798,43 @@ fn untracked_and_ignored_collapse_mix() {
         ],
         "untracked collapses separately from ignored, but note that matching directories are still emitted, i.e. ignored/"
     );
+
+    let (out, entries) = collect(&root, |keep, ctx| {
+        walk(
+            &root,
+            &root,
+            ctx,
+            walk::Options {
+                emit_ignored: Some(Matching),
+                emit_untracked: CollapseDirectory,
+                emit_collapsed: Some(All),
+                ..options_emit_all()
+            },
+            keep,
+        )
+    });
+    assert_eq!(
+        out,
+        walk::Outcome {
+            read_dir_calls: 4,
+            returned_entries: entries.len(),
+            seen_entries: 8,
+        }
+    );
+    assert_eq!(
+        entries,
+        [
+            entry(".gitignore", Untracked, File),
+            entry("ignored", Ignored(Expendable), Directory),
+            entry("ignored-inside/d.o", Ignored(Expendable), File),
+            entry("mixed", Untracked, Directory),
+            entry_dirstat("mixed/c", Untracked, File, Untracked),
+            entry_dirstat("mixed/c.o", Ignored(Expendable), File, Untracked),
+            entry("untracked", Untracked, Directory),
+            entry_dirstat("untracked/a", Untracked, File, Untracked),
+        ],
+        "we can also emit all collapsed entries"
+    );
 }
 
 #[test]

gix-dir/tests/walk_utils/mod.rs

@@ -30,6 +30,7 @@ pub fn options_emit_all() -> walk::Options {
         emit_tracked: true,
         emit_untracked: walk::EmissionMode::Matching,
         emit_empty_directories: true,
+        emit_collapsed: None,
     }
 }