adapt to changes in gix

Author: Byron

gitoxide-core/src/query/engine/command.rs

@@ -23,6 +23,7 @@ impl query::Engine {
                 let relpath = self
                     .repo
                     .pathspec(
+                        true,
                         Some(spec.to_bstring()),
                         false,
                         &gix::index::State::new(self.repo.object_hash()),

gitoxide-core/src/repository/attributes/query.rs

@@ -10,7 +10,7 @@ pub struct Options {
 pub(crate) mod function {
     use std::{borrow::Cow, io, path::Path};
 
-    use anyhow::{anyhow, bail};
+    use anyhow::bail;
     use gix::bstr::BStr;
 
     use crate::{
@@ -52,43 +52,45 @@ pub(crate) mod function {
             }
             PathsOrPatterns::Patterns(patterns) => {
                 let mut pathspec = repo.pathspec(
+                    true,
                     patterns.iter(),
                     true,
                     &index,
                     gix::worktree::stack::state::attributes::Source::WorktreeThenIdMapping
                         .adjust_for_bare(repo.is_bare()),
                 )?;
                 let mut pathspec_matched_entry = false;
-                for (path, _entry) in pathspec
-                    .index_entries_with_paths(&index)
-                    .ok_or_else(|| anyhow!("Pathspec didn't match a single path in the index"))?
-                {
-                    pathspec_matched_entry = true;
-                    let entry = cache.at_entry(path, Some(false))?;
-                    if !entry.matching_attributes(&mut matches) {
-                        continue;
+                if let Some(it) = pathspec.index_entries_with_paths(&index) {
+                    for (path, _entry) in it {
+                        pathspec_matched_entry = true;
+                        let entry = cache.at_entry(path, Some(false))?;
+                        if !entry.matching_attributes(&mut matches) {
+                            continue;
+                        }
+                        print_match(&matches, path, &mut out)?;
                     }
-                    print_match(&matches, path, &mut out)?;
                 }
 
                 if !pathspec_matched_entry {
                     // TODO(borrowchk): this shouldn't be necessary at all, but `pathspec` stays borrowed mutably for some reason.
                     //                  It's probably due to the strange lifetimes of `index_entries_with_paths()`.
                     let pathspec = repo.pathspec(
+                        true,
                         patterns.iter(),
                         true,
                         &index,
                         gix::worktree::stack::state::attributes::Source::WorktreeThenIdMapping
                             .adjust_for_bare(repo.is_bare()),
                     )?;
+                    let workdir = repo.work_dir();
                     for pattern in pathspec.search().patterns() {
                         let path = pattern.path();
                         let entry = cache.at_entry(
                             path,
-                            pattern
-                                .signature
-                                .contains(gix::pathspec::MagicSignature::MUST_BE_DIR)
-                                .into(),
+                            Some(
+                                workdir.map_or(false, |wd| wd.join(gix::path::from_bstr(path)).is_dir())
+                                    || pattern.signature.contains(gix::pathspec::MagicSignature::MUST_BE_DIR),
+                            ),
                         )?;
                         if !entry.matching_attributes(&mut matches) {
                             continue;

gitoxide-core/src/repository/clean.rs

@@ -74,14 +74,10 @@ pub(crate) mod function {
             .classify_untracked_bare_repositories(matches!(find_untracked_repositories, FindRepository::All))
             .emit_untracked(collapse_directories)
             .emit_ignored(Some(collapse_directories))
+            .empty_patterns_match_prefix(true)
             .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 entries = collect.inner.into_entries_by_path();
         let mut entries_to_clean = 0;
@@ -173,15 +169,16 @@ pub(crate) mod function {
             };
 
             let is_ignored = matches!(entry.status, gix::dir::entry::Status::Ignored(_));
-            let display_path = entry.rela_path[prefix_len..].as_bstr();
+            let entry_path = gix::path::from_bstr(entry.rela_path);
+            let display_path = gix::path::relativize_with_prefix(&entry_path, prefix);
             if disk_kind == gix::dir::entry::Kind::Directory {
                 saw_ignored_directory |= is_ignored;
                 saw_untracked_directory |= entry.status == gix::dir::entry::Status::Untracked;
             }
             writeln!(
                 out,
                 "{maybe}{suffix} {}{} {status}",
-                display_path,
+                display_path.display(),
                 disk_kind.is_dir().then_some("/").unwrap_or_default(),
                 status = match entry.status {
                     Status::Ignored(kind) => {
@@ -221,7 +218,7 @@ pub(crate) mod function {
                 execute = false;
             }
             if execute {
-                let path = workdir.join(gix::path::from_bstr(entry.rela_path));
+                let path = workdir.join(entry_path);
                 if disk_kind.is_dir() {
                     std::fs::remove_dir_all(path)?;
                 } else {

gitoxide-core/src/repository/exclude.rs

@@ -1,6 +1,6 @@
 use std::{borrow::Cow, io};
 
-use anyhow::{anyhow, bail};
+use anyhow::bail;
 use gix::bstr::BStr;
 
 use crate::{repository::PathsOrPatterns, OutputFormat};
@@ -58,42 +58,44 @@ pub fn query(
         PathsOrPatterns::Patterns(patterns) => {
             let mut pathspec_matched_something = false;
             let mut pathspec = repo.pathspec(
+                true,
                 patterns.iter(),
                 repo.work_dir().is_some(),
                 &index,
                 gix::worktree::stack::state::attributes::Source::WorktreeThenIdMapping.adjust_for_bare(repo.is_bare()),
             )?;
 
-            for (path, _entry) in pathspec
-                .index_entries_with_paths(&index)
-                .ok_or_else(|| anyhow!("Pathspec didn't yield any entry"))?
-            {
-                pathspec_matched_something = true;
-                let entry = cache.at_entry(path, Some(false))?;
-                let match_ = entry
-                    .matching_exclude_pattern()
-                    .and_then(|m| (show_ignore_patterns || !m.pattern.is_negative()).then_some(m));
-                print_match(match_, path, &mut out)?;
+            if let Some(it) = pathspec.index_entries_with_paths(&index) {
+                for (path, _entry) in it {
+                    pathspec_matched_something = true;
+                    let entry = cache.at_entry(path, Some(false))?;
+                    let match_ = entry
+                        .matching_exclude_pattern()
+                        .and_then(|m| (show_ignore_patterns || !m.pattern.is_negative()).then_some(m));
+                    print_match(match_, path, &mut out)?;
+                }
             }
 
             if !pathspec_matched_something {
                 // TODO(borrowchk): this shouldn't be necessary at all, but `pathspec` stays borrowed mutably for some reason.
                 //                  It's probably due to the strange lifetimes of `index_entries_with_paths()`.
                 let pathspec = repo.pathspec(
+                    true,
                     patterns.iter(),
                     repo.work_dir().is_some(),
                     &index,
                     gix::worktree::stack::state::attributes::Source::WorktreeThenIdMapping
                         .adjust_for_bare(repo.is_bare()),
                 )?;
+                let workdir = repo.work_dir();
                 for pattern in pathspec.search().patterns() {
                     let path = pattern.path();
                     let entry = cache.at_entry(
                         path,
-                        pattern
-                            .signature
-                            .contains(gix::pathspec::MagicSignature::MUST_BE_DIR)
-                            .into(),
+                        Some(
+                            workdir.map_or(false, |wd| wd.join(gix::path::from_bstr(path)).is_dir())
+                                || pattern.signature.contains(gix::pathspec::MagicSignature::MUST_BE_DIR),
+                        ),
                     )?;
                     let match_ = entry
                         .matching_exclude_pattern()

gitoxide-core/src/repository/index/entries.rs

@@ -256,6 +256,7 @@ pub(crate) mod function {
     )> {
         let index = repo.index_or_load_from_head()?;
         let pathspec = repo.pathspec(
+            true,
             pathspecs,
             false,
             &index,

gitoxide-core/src/repository/status.rs

@@ -6,6 +6,7 @@ use gix::{
     Progress,
 };
 use gix_status::index_as_worktree::{traits::FastEq, Change, Conflict, EntryStatus};
+use std::path::{Path, PathBuf};
 
 use crate::OutputFormat;
 
@@ -54,15 +55,19 @@ pub fn show(
             gix::worktree::stack::state::attributes::Source::WorktreeThenIdMapping,
         )?
         .detach();
-    let pathspec = gix::Pathspec::new(&repo, pathspecs.iter().map(|p| p.as_bstr()), true, || Ok(stack.clone()))?;
+    let pathspec = gix::Pathspec::new(&repo, false, pathspecs.iter().map(|p| p.as_bstr()), true, || {
+        Ok(stack.clone())
+    })?;
     let options = gix_status::index_as_worktree::Options {
         fs: repo.filesystem_options()?,
         thread_limit,
         stat: repo.stat_options()?,
     };
+    let prefix = repo.prefix()?.unwrap_or(Path::new(""));
     let mut printer = Printer {
         out,
         changes: Vec::new(),
+        prefix: prefix.to_owned(),
     };
     let filter_pipeline = repo
         .filter_pipeline(Some(gix::hash::ObjectId::empty_tree(repo.object_hash())))?
@@ -87,15 +92,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)
                 }
             })?;
 
@@ -125,7 +131,7 @@ pub fn show(
             printer.out,
             "{status: >3} {rela_path}",
             status = "?",
-            rela_path = entry.rela_path
+            rela_path = gix::path::relativize_with_prefix(&gix::path::from_bstr(entry.rela_path), prefix).display()
         )?;
     }
 
@@ -175,6 +181,7 @@ impl gix_status::index_as_worktree::traits::SubmoduleStatus for Submodule {
 struct Printer<W> {
     out: W,
     changes: Vec<(usize, ApplyChange)>,
+    prefix: PathBuf,
 }
 
 enum ApplyChange {
@@ -226,7 +233,9 @@ impl<W: std::io::Write> Printer<W> {
             EntryStatus::IntentToAdd => "A",
         };
 
-        writeln!(&mut self.out, "{status: >3} {rela_path}")
+        let rela_path = gix::path::from_bstr(rela_path);
+        let display_path = gix::path::relativize_with_prefix(&rela_path, &self.prefix);
+        writeln!(&mut self.out, "{status: >3} {}", display_path.display())
     }
 }