feat: gix dirwalk as a way to run gix-dir directly

codex · Byron · Byron · commit add4cf4c0d2c · 2026-05-08T14:28:08.000+08:00
This is mostly for testing walks specifically, without needing them as part
of `gix clean` or `gix status`.

Co-authored-by: Sebastian Thiel &lt;sebastian.thiel@icloud.com&gt;
diff --git a/gitoxide-core/src/repository/dirwalk.rs b/gitoxide-core/src/repository/dirwalk.rs
@@ -0,0 +1,82 @@
+use anyhow::bail;
+use gix::{
+    bstr::BString,
+    dir::{
+        EntryRef,
+        walk::{self, EmissionMode},
+    },
+};
+
+use crate::OutputFormat;
+
+#[derive(Copy, Clone)]
+pub enum Untracked {
+    Collapsed,
+    Matching,
+}
+
+pub struct Options {
+    pub output_format: OutputFormat,
+    pub statistics: bool,
+    pub untracked: Untracked,
+}
+
+pub fn walk(
+    repo: gix::Repository,
+    patterns: Vec<BString>,
+    mut out: impl std::io::Write,
+    mut err: impl std::io::Write,
+    Options {
+        output_format,
+        statistics,
+        untracked,
+    }: Options,
+) -> anyhow::Result<()> {
+    if output_format != OutputFormat::Human {
+        bail!("Only human format is supported right now");
+    }
+    let index = repo.index_or_empty()?;
+    let options = repo.dirwalk_options()?.emit_untracked(match untracked {
+        Untracked::Collapsed => EmissionMode::CollapseDirectory,
+        Untracked::Matching => EmissionMode::Matching,
+    });
+
+    let start = std::time::Instant::now();
+    let mut delegate = Count::default();
+    let outcome = repo.dirwalk(
+        &index,
+        patterns,
+        &gix::interrupt::IS_INTERRUPTED,
+        options,
+        &mut delegate,
+    )?;
+
+    if statistics {
+        writeln!(
+            err,
+            "dirwalk done {} entries in {:.2?}",
+            delegate.entries,
+            start.elapsed()
+        )?;
+        writeln!(err, "{:?}", outcome.dirwalk)?;
+    } else {
+        writeln!(out, "{}", delegate.entries)?;
+    }
+    Ok(())
+}
+
+#[derive(Default)]
+struct Count {
+    entries: u64,
+}
+
+impl walk::Delegate for Count {
+    fn emit(
+        &mut self,
+        _entry: EntryRef<'_>,
+        _collapsed_directory_status: Option<gix::dir::entry::Status>,
+    ) -> walk::Action {
+        self.entries += 1;
+        std::ops::ControlFlow::Continue(())
+    }
+}
diff --git a/gitoxide-core/src/repository/mod.rs b/gitoxide-core/src/repository/mod.rs
@@ -19,6 +19,7 @@ pub mod attributes;
 pub mod clean;
 pub mod diff;
 pub mod dirty;
+pub mod dirwalk;
 #[cfg(feature = "clean")]
 pub use clean::function::clean;
 #[cfg(feature = "blocking-client")]
diff --git a/src/plumbing/main.rs b/src/plumbing/main.rs
@@ -443,6 +443,38 @@ pub fn main() -> Result<()> {
                 )
             },
         ),
+        Subcommands::Dirwalk(crate::plumbing::options::dirwalk::Platform {
+            statistics,
+            untracked,
+            pathspec,
+        }) => prepare_and_run(
+            "dirwalk",
+            trace,
+            auto_verbose,
+            progress,
+            progress_keep_open,
+            None,
+            move |_progress, out, err| {
+                core::repository::dirwalk::walk(
+                    repository(Mode::Lenient)?,
+                    pathspec,
+                    out,
+                    err,
+                    core::repository::dirwalk::Options {
+                        output_format: format,
+                        statistics,
+                        untracked: match untracked {
+                            crate::plumbing::options::dirwalk::Untracked::Collapsed => {
+                                core::repository::dirwalk::Untracked::Collapsed
+                            }
+                            crate::plumbing::options::dirwalk::Untracked::Matching => {
+                                core::repository::dirwalk::Untracked::Matching
+                            }
+                        },
+                    },
+                )
+            },
+        ),
         Subcommands::Submodule(platform) => match platform
             .cmds
             .unwrap_or(crate::plumbing::options::submodule::Subcommands::List { dirty_suffix: None })
diff --git a/src/plumbing/options/mod.rs b/src/plumbing/options/mod.rs
@@ -153,6 +153,7 @@ pub enum Subcommands {
     /// Show which git configuration values are used or planned.
     ConfigTree,
     Status(status::Platform),
+    Dirwalk(dirwalk::Platform),
     Config(config::Platform),
     #[cfg(feature = "gitoxide-core-tools-corpus")]
     Corpus(corpus::Platform),
@@ -325,6 +326,35 @@ pub mod status {
     }
 }
 
+pub mod dirwalk {
+    use gix::bstr::BString;
+
+    use crate::shared::CheckPathSpec;
+
+    #[derive(Default, Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, clap::ValueEnum)]
+    pub enum Untracked {
+        /// Collapse untracked directories when possible.
+        #[default]
+        Collapsed,
+        /// Emit matching untracked files and directories.
+        Matching,
+    }
+
+    #[derive(Debug, clap::Parser)]
+    #[command(about = "Run only the repository directory walk")]
+    pub struct Platform {
+        /// Print additional statistics to help understanding performance.
+        #[clap(long, short = 's')]
+        pub statistics: bool,
+        /// How untracked files should be emitted.
+        #[clap(long, default_value = "collapsed")]
+        pub untracked: Untracked,
+        /// The git path specifications to walk.
+        #[clap(value_parser = CheckPathSpec)]
+        pub pathspec: Vec<BString>,
+    }
+}
+
 pub mod merge_base {
     #[derive(Debug, clap::Parser)]
     #[command(about = "A command for calculating all merge-bases")]
