integrate gix-status

gitoxide-core/src/repository/clean.rs

@@ -15,6 +15,7 @@ pub struct Options {
  pub precious: bool,
  pub directories: bool,
  pub repositories: bool,
+ pub pathspec_matches_result: bool,
  pub skip_hidden_repositories: Option<FindRepository>,
  pub find_untracked_repositories: FindRepository,
 }
@@ -46,6 +47,7 @@ pub(crate) mod function {
  repositories,
  skip_hidden_repositories,
  find_untracked_repositories,
+ pathspec_matches_result,
  }: Options,
  ) -> anyhow::Result<()> {
  if format != OutputFormat::Human {
@@ -56,6 +58,7 @@ pub(crate) mod function {
  };
 
  let index = repo.index_or_empty()?;
+ let pathspec_for_dirwalk = !pathspec_matches_result;
  let has_patterns = !patterns.is_empty();
  let mut collect = InterruptableCollect::default();
  let collapse_directories = CollapseDirectory;
@@ -66,19 +69,39 @@ pub(crate) mod function {
  match skip_hidden_repositories {
  Some(FindRepository::NonBare) => Some(FindNonBareRepositoriesInIgnoredDirectories),
  Some(FindRepository::All) => Some(FindRepositoriesInIgnoredDirectories),
- None => None,
+ None => Some(Default::default()),
  }
  } else {
- Some(IgnoredDirectoriesCanHideNestedRepositories)
+ Some(Default::default())
  })
  .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(""));
+ repo.dirwalk(
+ &index,
+ if pathspec_for_dirwalk {
+ patterns.clone()
+ } else {
+ Vec::new()
+ },
+ options,
+ &mut collect,
+ )?;
 
+ let mut pathspec = pathspec_matches_result
+ .then(|| {
+ repo.pathspec(
+ true,
+ patterns,
+ true,
+ &index,
+ gix::worktree::stack::state::attributes::Source::WorktreeThenIdMapping,
+ )
+ })
+ .transpose()?;
+ let prefix = repo.prefix()?.unwrap_or(Path::new(""));
  let entries = collect.inner.into_entries_by_path();
  let mut entries_to_clean = 0;
  let mut skipped_directories = 0;
@@ -88,7 +111,7 @@ pub(crate) mod function {
  let mut pruned_entries = 0;
  let mut saw_ignored_directory = false;
  let mut saw_untracked_directory = false;
- for (entry, dir_status) in entries.into_iter() {
+ for (mut entry, dir_status) in entries.into_iter() {
  if dir_status.is_some() {
  if debug {
  writeln!(
@@ -101,21 +124,25 @@ pub(crate) mod function {
  continue;
  }
 
- let pathspec_includes_entry = entry
- .pathspec_match
- .map_or(false, |m| m != gix::dir::entry::PathspecMatch::Excluded);
+ let pathspec_includes_entry = match pathspec.as_mut() {
+ None => entry
+ .pathspec_match
+ .map_or(false, |m| m != gix::dir::entry::PathspecMatch::Excluded),
+ Some(pathspec) => pathspec
+ .pattern_matching_relative_path(entry.rela_path.as_bstr(), entry.disk_kind.map(|k| k.is_dir()))
+ .map_or(false, |m| !m.is_excluded()),
+ };
  pruned_entries += usize::from(!pathspec_includes_entry);
  if !pathspec_includes_entry && debug {
- writeln!(err, "DBG: prune '{}' as it is excluded by pathspec", entry.rela_path).ok();
+ writeln!(err, "DBG: prune '{}'", entry.rela_path).ok();
  }
  if entry.status.is_pruned() || !pathspec_includes_entry {
  continue;
  }
 
- let mut disk_kind = entry.disk_kind.expect("present if not pruned");
  let keep = match entry.status {
- Status::DotGit | Status::Pruned | Status::TrackedExcluded => {
- unreachable!("BUG: Pruned are skipped already as their pathspec is always None")
+ Status::Pruned => {
+ unreachable!("BUG: we skipped these above")
  }
  Status::Tracked => {
  unreachable!("BUG: tracked aren't emitted")
@@ -130,6 +157,14 @@ pub(crate) mod function {
  }
  Status::Untracked => true,
  };
+ if entry.disk_kind.is_none() {
+ entry.disk_kind = workdir
+ .join(gix::path::from_bstr(entry.rela_path.as_bstr()))
+ .metadata()
+ .ok()
+ .map(|e| e.file_type().into());
+ }
+ let mut disk_kind = entry.disk_kind.expect("present if not pruned");
  if !keep {
  if debug {
  writeln!(err, "DBG: prune '{}' as -x or -p is missing", entry.rela_path).ok();
@@ -148,7 +183,7 @@ pub(crate) mod function {
 
  match disk_kind {
  Kind::File | Kind::Symlink => {}
- Kind::EmptyDirectory | Kind::Directory => {
+ Kind::Directory => {
  if !directories {
  skipped_directories += 1;
  if debug {
@@ -175,6 +210,11 @@ pub(crate) mod function {
  saw_ignored_directory |= is_ignored;
  saw_untracked_directory |= entry.status == gix::dir::entry::Status::Untracked;
  }
+
+ if gix::interrupt::is_triggered() {
+ execute = false;
+ }
+ let mut may_remove_this_entry = execute;
  writeln!(
  out,
  "{maybe}{suffix} {}{} {status}",
@@ -200,24 +240,32 @@ pub(crate) mod function {
  "".into()
  },
  },
- maybe = if execute { "removing" } else { "WOULD remove" },
- suffix = match disk_kind {
- Kind::File | Kind::Symlink | Kind::Directory => {
- ""
+ maybe = if entry.property == Some(gix::dir::entry::Property::EmptyDirectoryAndCWD) {
+ may_remove_this_entry = false;
+ if execute {
+ "Refusing to remove empty current working directory"
+ } else {
+ "Would refuse to remove empty current working directory"
  }
- Kind::EmptyDirectory => {
+ } else if execute {
+ "removing"
+ } else {
+ "WOULD remove"
+ },
+ suffix = match disk_kind {
+ Kind::Directory if entry.property == Some(gix::dir::entry::Property::EmptyDirectory) => {
  " empty"
  }
  Kind::Repository => {
  " repository"
  }
+ Kind::File | Kind::Symlink | Kind::Directory => {
+ ""
+ }
  },
  )?;
 
- if gix::interrupt::is_triggered() {
- execute = false;
- }
- if execute {
+ if may_remove_this_entry {
  let path = workdir.join(entry_path);
  if disk_kind.is_dir() {
  std::fs::remove_dir_all(path)?;
@@ -256,7 +304,7 @@ pub(crate) mod function {
  }));
  messages.extend((pruned_entries > 0 && has_patterns).then(|| {
  format!(
- "try to adjust your pathspec to reveal some of the {pruned_entries} pruned {entries}",
+ "try to adjust your pathspec to reveal some of the {pruned_entries} pruned {entries} - show with --debug",
  entries = plural("entry", "entries", pruned_entries)
  )
  }));

gix-dir/src/entry.rs

@@ -2,40 +2,51 @@ use crate::walk::ForDeletionMode;
 use crate::{Entry, EntryRef};
 use std::borrow::Cow;
 
-/// The kind of the entry.
+/// A way of attaching additional information to an [Entry] .
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub enum Property {
+ /// The entry was named `.git`, matched according to the case-sensitivity rules of the repository.
+ 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.
+ ///
+ /// Note that evne if the directory is empty, it will only have this state, not `EmptyDirectory`.
+ TrackedExcluded,
+}
+
+/// The kind of the entry, seated in their kinds available on disk.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
 pub enum Kind {
  /// The entry is a blob, executable or not.
  File,
  /// The entry is a symlink.
  Symlink,
- /// A directory that contains no file or directory.
- EmptyDirectory,
  /// The entry is an ordinary directory.
  ///
  /// Note that since we don't check for bare repositories, this could in fact be a collapsed
  /// bare repository. To be sure, check it again with [`gix_discover::is_git()`] and act accordingly.
  Directory,
- /// The entry is a directory which *contains* a `.git` folder.
+ /// The entry is a directory which *contains* a `.git` folder, or a submodule entry in the index.
  Repository,
 }
 
 /// The kind of entry as obtained from a directory.
-///
-/// The order of variants roughly relates from cheap-to-compute to most expensive, as each level needs more tests to assert.
-/// Thus, `DotGit` is the cheapest, while `Untracked` is among the most expensive and one of the major outcomes of any
-/// [`walk`](crate::walk()) run.
-/// For example, if an entry was `Pruned`, we effectively don't know if it would have been `Untracked` as well as we stopped looking.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
 pub enum Status {
- /// The filename of an entry was `.git`, which is generally pruned.
- DotGit,
- /// The provided pathspec prevented further processing as the path didn't match.
- /// If this happens, no further checks are done so we wouldn't know if the path is also ignored for example (by mention in `.gitignore`).
+ /// The entry was removed from the walk due to its other properties, like [Property] or [PathspecMatch]
+ ///
+ /// Note that entries flagged as `DotGit` directory will always be considered `Pruned`, but if they are
+ /// also ignored, in delete mode, they will be considered `Ignored` instead. This way, it's easier to remove them
+ /// while they will not be available for any interactions in read-only mode.
  Pruned,
- /// 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.
- TrackedExcluded,
  /// The entry is tracked in Git.
  Tracked,
  /// The entry is ignored as per `.gitignore` files and their rules.
@@ -52,7 +63,7 @@ pub enum Status {
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, Ord, PartialOrd)]
 pub enum PathspecMatch {
  /// The match happened because there wasn't any pattern, which matches all, or because there was a nil pattern or one with an empty path.
- /// Thus this is not a match by merit.
+ /// Thus, this is not a match by merit.
  Always,
  /// A match happened, but the pattern excludes everything it matches, which means this entry was excluded.
  Excluded,
@@ -84,12 +95,24 @@ impl From<gix_pathspec::search::MatchKind> for PathspecMatch {
  }
 }
 
+impl From<gix_pathspec::search::Match<'_>> for PathspecMatch {
+ fn from(m: gix_pathspec::search::Match<'_>) -> Self {
+ if m.is_excluded() {
+ PathspecMatch::Excluded
+ } else {
+ m.kind.into()
+ }
+ }
+}
+
+/// Conversion
 impl EntryRef<'_> {
  /// Strip the lifetime to obtain a fully owned copy.
  pub fn to_owned(&self) -> Entry {
  Entry {
  rela_path: self.rela_path.clone().into_owned(),
  status: self.status,
+ property: self.property,
  disk_kind: self.disk_kind,
  index_kind: self.index_kind,
  pathspec_match: self.pathspec_match,
@@ -101,19 +124,22 @@ impl EntryRef<'_> {
  Entry {
  rela_path: self.rela_path.into_owned(),
  status: self.status,
+ property: self.property,
  disk_kind: self.disk_kind,
  index_kind: self.index_kind,
  pathspec_match: self.pathspec_match,
  }
  }
 }
 
+/// Conversion
 impl Entry {
  /// Obtain an [`EntryRef`] from this instance.
  pub fn to_ref(&self) -> EntryRef<'_> {
  EntryRef {
  rela_path: Cow::Borrowed(self.rela_path.as_ref()),
  status: self.status,
+ property: self.property,
  disk_kind: self.disk_kind,
  index_kind: self.index_kind,
  pathspec_match: self.pathspec_match,
@@ -136,10 +162,7 @@ impl From<std::fs::FileType> for Kind {
 impl Status {
  /// Return true if this status is considered pruned. A pruned entry is typically hidden from view due to a pathspec.
  pub fn is_pruned(&self) -> bool {
- match self {
- Status::DotGit | Status::TrackedExcluded | Status::Pruned => true,
- Status::Ignored(_) | Status::Untracked | Status::Tracked => false,
- }
+ matches!(&self, Status::Pruned)
  }
  /// Return `true` if `file_type` is a directory on disk and isn't ignored, and is not a repository.
  /// This implements the default rules of `git status`, which is good for a minimal traversal through
@@ -158,7 +181,7 @@ impl Status {
  return false;
  }
  match self {
- Status::DotGit | Status::TrackedExcluded | Status::Pruned => false,
+ Status::Pruned => false,
  Status::Ignored(_) => {
  for_deletion.map_or(false, |fd| {
  matches!(
@@ -174,12 +197,12 @@ impl Status {
 }
 
 impl Kind {
- fn is_recursable_dir(&self) -> bool {
+ pub(super) fn is_recursable_dir(&self) -> bool {
  matches!(self, Kind::Directory)
  }
 
  /// Return `true` if this is a directory on disk. Note that this is true for repositories as well.
  pub fn is_dir(&self) -> bool {
- matches!(self, Kind::EmptyDirectory | Kind::Directory | Kind::Repository)
+ matches!(self, Kind::Directory | Kind::Repository)
  }
 }

gix-dir/src/lib.rs

@@ -29,14 +29,14 @@ pub struct EntryRef<'a> {
  /// Note that many entries with status `Pruned` will not show up as their kind hasn't yet been determined when they were
  /// pruned very early on.
  pub status: entry::Status,
- /// Further specify the what the entry is on disk, similar to a file mode.
- /// This is `None` if the entry was pruned by a pathspec that could not match, as we then won't invest the time to obtain
- /// the kind of the entry on disk.
+ /// Additional properties of the entry.
+ pub property: Option<entry::Property>,
+ /// Further specify what the entry is on disk, similar to a file mode.
+ /// This is `None` if we decided it's not worth it to exit early and avoid trying to obtain this information.
  pub disk_kind: Option<entry::Kind>,
  /// The kind of entry according to the index, if tracked. *Usually* the same as `disk_kind`.
  pub index_kind: Option<entry::Kind>,
  /// Determines how the pathspec matched.
- /// Can also be `None` if no pathspec matched, or if the status check stopped prior to checking for pathspec matches which is the case for [`entry::Status::DotGit`].
  /// Note that it can also be `Some(PathspecMatch::Excluded)` if a negative pathspec matched.
  pub pathspec_match: Option<entry::PathspecMatch>,
 }
@@ -48,7 +48,9 @@ pub struct Entry {
  pub rela_path: BString,
  /// The status of entry, most closely related to what we know from `git status`, but not the same.
  pub status: entry::Status,
- /// Further specify the what the entry is on disk, similar to a file mode.
+ /// Additional flags that further clarify properties of the entry.
+ pub property: Option<entry::Property>,
+ /// Further specify what the entry is on disk, similar to a file mode.
  pub disk_kind: Option<entry::Kind>,
  /// The kind of entry according to the index, if tracked. *Usually* the same as `disk_kind`.
  pub index_kind: Option<entry::Kind>,