fix!: leave more control to the user when creating pathspecs

Author: Byron

gitoxide-core/src/repository/clean.rs

@@ -29,7 +29,6 @@ pub(crate) mod function {
     use gix::dir::walk::ForDeletionMode::*;
     use gix::dir::{walk, EntryRef};
     use std::borrow::Cow;
-    use std::path::Path;
 
     pub fn clean(
         repo: gix::Repository,
@@ -75,12 +74,13 @@ pub(crate) mod function {
             .emit_untracked(collapse_directories)
             .emit_ignored(Some(collapse_directories))
             .emit_empty_directories(true);
-        repo.dirwalk(&index, patterns, options, &mut collect)?;
-        let prefix = repo.prefix()?.unwrap_or(Path::new(""));
-        let prefix_len = if prefix.as_os_str().is_empty() {
-            0
-        } else {
-            prefix.to_str().map_or(0, |s| s.len() + 1 /* slash */)
+        let actual_root = repo.dirwalk(&index, patterns, options, &mut collect)?.traversal_root;
+        let prefix_len = {
+            let prefix = actual_root
+                .strip_prefix(repo.work_dir().expect("definitely set after successful walk"))
+                .expect("actual root is always inside workdir")
+                .as_os_str();
+            prefix.len() + if prefix.is_empty() { 0 } else { 1 } // slash
         };
 
         let entries = collect.inner.into_entries_by_path();

gitoxide-core/src/repository/status.rs

@@ -87,15 +87,16 @@ pub fn show(
                 let repo = repo.clone().into_sync();
                 let index = &index;
                 let collect = &mut collect;
-                move || {
+                move || -> anyhow::Result<_> {
                     let repo = repo.to_thread_local();
-                    repo.dirwalk(
+                    let outcome = repo.dirwalk(
                         index,
                         pathspecs,
                         repo.dirwalk_options()?
                             .emit_untracked(gix::dir::walk::EmissionMode::CollapseDirectory),
                         collect,
-                    )
+                    )?;
+                    Ok((outcome.dirwalk, outcome.traversal_root))
                 }
             })?;
 
@@ -112,7 +113,7 @@ pub fn show(
             options,
         )?;
 
-        let walk_outcome = walk_outcome.join().expect("no panic")?;
+        let (walk_outcome, _actual_root) = walk_outcome.join().expect("no panic")?;
         Ok((outcome, walk_outcome))
     })?;
 

gix/src/repository/dirwalk.rs

@@ -1,5 +1,5 @@
 use crate::bstr::BStr;
-use crate::{config, dirwalk, Repository};
+use crate::{config, dirwalk, AttributeStack, Pathspec, Repository};
 use std::path::PathBuf;
 
 /// The error returned by [dirwalk()](Repository::dirwalk()).
@@ -20,6 +20,19 @@ pub enum Error {
     FilesystemOptions(#[from] config::boolean::Error),
 }
 
+/// The outcome of the [dirwalk()](Repository::dirwalk).
+pub struct Outcome<'repo> {
+    /// The excludes stack used for the dirwalk, for access of `.gitignore` information.
+    pub excludes: AttributeStack<'repo>,
+    /// The pathspecs used to guide the operation,
+    pub pathspec: Pathspec<'repo>,
+    /// The root actually being used for the traversal, and useful to transform the paths returned for the user.
+    /// It's always within the [`work-dir`](Repository::work_dir).
+    pub traversal_root: PathBuf,
+    /// The actual result of the dirwalk.
+    pub dirwalk: gix_dir::walk::Outcome,
+}
+
 impl Repository {
     /// Return default options suitable for performing a directory walk on this repository.
     ///
@@ -42,54 +55,57 @@ impl Repository {
         patterns: impl IntoIterator<Item = impl AsRef<BStr>>,
         options: dirwalk::Options,
         delegate: &mut dyn gix_dir::walk::Delegate,
-    ) -> Result<(gix_dir::walk::Outcome, PathBuf), Error> {
+    ) -> Result<Outcome<'_>, Error> {
         let _span = gix_trace::coarse!("gix::dirwalk");
         let workdir = self.work_dir().ok_or(Error::MissinWorkDir)?;
-        let mut excludes = self
-            .excludes(
-                index,
-                None,
-                crate::worktree::stack::state::ignore::Source::WorktreeThenIdMappingIfNotSkipped,
-            )?
-            .detach();
-        let (mut pathspec, mut maybe_attributes) = self
-            .pathspec(
-                patterns,
-                true, /* inherit ignore case */
-                index,
-                crate::worktree::stack::state::attributes::Source::WorktreeThenIdMapping,
-            )?
-            .into_parts();
-        gix_trace::debug!(patterns = ?pathspec.patterns().map(|p| p.path()).collect::<Vec<_>>());
+        let mut excludes = self.excludes(
+            index,
+            None,
+            crate::worktree::stack::state::ignore::Source::WorktreeThenIdMappingIfNotSkipped,
+        )?;
+        let mut pathspec = self.pathspec(
+            patterns,
+            true, /* inherit ignore case */
+            index,
+            crate::worktree::stack::state::attributes::Source::WorktreeThenIdMapping,
+        )?;
+        gix_trace::debug!(longest_prefix = ?pathspec.search.longest_common_directory(), prefix_dir = ?pathspec.search.prefix_directory(),patterns = ?pathspec.search.patterns().map(|p| p.path()).collect::<Vec<_>>());
 
         let git_dir_realpath =
             crate::path::realpath_opts(self.git_dir(), self.current_dir(), crate::path::realpath::MAX_SYMLINKS)?;
         let fs_caps = self.filesystem_options()?;
         let accelerate_lookup = fs_caps.ignore_case.then(|| index.prepare_icase_backing());
-        gix_dir::walk(
+        let (outcome, traversal_root) = gix_dir::walk(
             workdir,
             gix_dir::walk::Context {
                 git_dir_realpath: git_dir_realpath.as_ref(),
                 current_dir: self.current_dir(),
                 index,
                 ignore_case_index_lookup: accelerate_lookup.as_ref(),
-                pathspec: &mut pathspec,
+                pathspec: &mut pathspec.search,
                 pathspec_attributes: &mut |relative_path, case, is_dir, out| {
-                    let stack = maybe_attributes
+                    let stack = pathspec
+                        .stack
                         .as_mut()
                         .expect("can only be called if attributes are used in patterns");
                     stack
                         .set_case(case)
                         .at_entry(relative_path, Some(is_dir), &self.objects)
                         .map_or(false, |platform| platform.matching_attributes(out))
                 },
-                excludes: Some(&mut excludes),
+                excludes: Some(&mut excludes.inner),
                 objects: &self.objects,
                 explicit_traversal_root: None,
             },
             options.into(),
             delegate,
-        )
-        .map_err(Into::into)
+        )?;
+
+        Ok(Outcome {
+            dirwalk: outcome,
+            traversal_root,
+            excludes,
+            pathspec,
+        })
     }
 }