feat!: various improvements

Author: Byron

Cargo.lock

@@ -20,6 +20,7 @@ gix-hash = { version = "^0.13.0", path = "../gix-hash" }
 gix-object = { version = "^0.36.0", path = "../gix-object" }
 gix-path = { version = "^0.10.0", path = "../gix-path" }
 gix-features = { version = "^0.34.0", path = "../gix-features" }
+gix-pathspec = { version = "0.2.0", path = "../gix-pathspec" }
 
 thiserror = "1.0.26"
 filetime = "0.2.15"

gix-status/Cargo.toml

@@ -1,3 +1,4 @@
+use std::sync::atomic::Ordering;
 use std::{io, marker::PhantomData, path::Path};
 
 use bstr::BStr;
@@ -11,7 +12,7 @@ use crate::{
         types::{Error, Options},
         Change, VisitEntry,
     },
-    read,
+    read, Pathspec,
 };
 
 /// Calculates the changes that need to be applied to an `index` to match the state of the `worktree` and makes them
@@ -24,12 +25,15 @@ use crate::{
 /// Note that this isn't technically quite what this function does as this also provides some additional information,
 /// like whether a file has conflicts, and files that were added with `git add` are shown as a special
 /// changes despite not technically requiring a change to the index since `git add` already added the file to the index.
+#[allow(clippy::too_many_arguments)]
 pub fn index_as_worktree<'index, T, Find, E>(
     index: &'index mut gix_index::State,
     worktree: &Path,
     collector: &mut impl VisitEntry<'index, ContentChange = T>,
     compare: impl CompareBlobs<Output = T> + Send + Clone,
     find: Find,
+    progress: &mut dyn gix_features::progress::Progress,
+    pathspec: impl Pathspec + Send + Clone,
     options: Options,
 ) -> Result<(), Error>
 where
@@ -43,14 +47,22 @@ where
     let timestamp = index.timestamp();
     index.set_timestamp(FileTime::now());
     let (chunk_size, thread_limit, _) = gix_features::parallel::optimize_chunk_size_and_thread_limit(
-        100,
+        500, // just like git
         index.entries().len().into(),
         options.thread_limit,
         None,
     );
+
+    let range = index
+        .prefixed_entries_range(pathspec.common_prefix())
+        .unwrap_or(0..index.entries().len());
     let (entries, path_backing) = index.entries_mut_and_pathbacking();
+    let entries = &mut entries[range];
+    progress.init(entries.len().into(), gix_features::progress::count("files"));
+    let count = progress.counter();
+
     in_parallel_if(
-        || true, // TODO: heuristic: when is parallelization not worth it?
+        || true, // TODO: heuristic: when is parallelization not worth it? Git says 500 items per thread, but to 20 threads, we can be more fine-grained though.
         entries.chunks_mut(chunk_size),
         thread_limit,
         {
@@ -65,15 +77,20 @@ where
                         worktree,
                         options,
                     },
-                    compare.clone(),
-                    find.clone(),
+                    compare,
+                    find,
+                    pathspec,
                 )
             }
         },
-        |entries, (state, diff, find)| {
+        |entries, (state, diff, find, pathspec)| {
             entries
                 .iter_mut()
-                .filter_map(|entry| state.process(entry, diff, find))
+                .filter_map(|entry| {
+                    let res = state.process(entry, diff, find, pathspec);
+                    count.fetch_add(1, Ordering::Relaxed);
+                    res
+                })
                 .collect()
         },
         ReduceChange {
@@ -101,10 +118,11 @@ impl<'index> State<'_, 'index> {
         entry: &'index mut gix_index::Entry,
         diff: &mut impl CompareBlobs<Output = T>,
         find: &mut Find,
+        pathspec: &mut impl Pathspec,
     ) -> Option<StatusResult<'index, T>>
     where
         E: std::error::Error + Send + Sync + 'static,
-        Find: for<'a> FnMut(&gix_hash::oid, &'a mut Vec<u8>) -> Result<gix_object::BlobRef<'a>, E> + Send + Clone,
+        Find: for<'a> FnMut(&gix_hash::oid, &'a mut Vec<u8>) -> Result<gix_object::BlobRef<'a>, E>,
     {
         let conflict = match entry.stage() {
             0 => false,
@@ -120,6 +138,9 @@ impl<'index> State<'_, 'index> {
             return None;
         }
         let path = entry.path_in(self.path_backing);
+        if !pathspec.is_included(path, Some(false)) {
+            return None;
+        }
         let status = self.compute_status(&mut *entry, path, diff, find);
         Some(status.map(move |status| (&*entry, path, status, conflict)))
     }
@@ -172,7 +193,7 @@ impl<'index> State<'_, 'index> {
     ) -> Result<Option<Change<T>>, Error>
     where
         E: std::error::Error + Send + Sync + 'static,
-        Find: for<'a> FnMut(&gix_hash::oid, &'a mut Vec<u8>) -> Result<gix_object::BlobRef<'a>, E> + Send + Clone,
+        Find: for<'a> FnMut(&gix_hash::oid, &'a mut Vec<u8>) -> Result<gix_object::BlobRef<'a>, E>,
     {
         // TODO fs cache
         let worktree_path = gix_path::try_from_bstr(git_path).map_err(|_| Error::IllformedUtf8)?;

gix-status/src/index_as_worktree/function.rs

@@ -14,7 +14,7 @@ pub enum Error {
     Find(#[source] Box<dyn std::error::Error + Send + Sync + 'static>),
 }
 
-#[derive(Clone, Default)]
+#[derive(Clone, Debug, Default)]
 /// Options that control how the index status with a worktree is computed.
 pub struct Options {
     /// Capabilities of the file system which affect the status computation.

gix-status/src/index_as_worktree/types.rs

@@ -12,4 +12,22 @@
 pub mod read;
 
 pub mod index_as_worktree;
+
+use bstr::BStr;
 pub use index_as_worktree::function::index_as_worktree;
+
+/// A trait to facilitate working working with pathspecs.
+pub trait Pathspec {
+    /// Return the portion of the prefix among all of the pathspecs involved in this search, or an empty string if
+    /// there is none. It doesn't have to end at a directory boundary though, nor does it denote a directory.
+    ///
+    /// Note that the common_prefix is always matched case-sensitively, and it is useful to skip large portions of input.
+    /// Further, excluded pathspecs don't participate which makes this common prefix inclusive. To work correclty though,
+    /// one will have to additionally match paths that have the common prefix with that pathspec itself to assure it is
+    /// not excluded.
+    fn common_prefix(&self) -> &BStr;
+
+    /// Return `true` if `relative_path` is included in this pathspec.
+    /// `is_dir` is `true` if `relative_path` is a directory.
+    fn is_included(&mut self, relative_path: &BStr, is_dir: Option<bool>) -> bool;
+}

gix-status/src/lib.rs

@@ -24,7 +24,7 @@ gix-fs = { path = "../../gix-fs" }
 gix-hash = { path = "../../gix-hash" }
 gix-object = { path = "../../gix-object" }
 gix-features = { path = "../../gix-features" }
-
+gix-pathspec = { version = "0.2.0", path = "../../gix-pathspec" }
 filetime = "0.2.15"
 bstr = { version = "1.3.0", default-features = false }
 

gix-status/tests/Cargo.toml

@@ -29,17 +29,25 @@ const TEST_OPTIONS: index::entry::stat::Options = index::entry::stat::Options {
 };
 
 fn fixture(name: &str, expected_status: &[(&BStr, Option<Change>, bool)]) {
+    fixture_filtered(name, &[], expected_status)
+}
+
+fn fixture_filtered(name: &str, pathspecs: &[&str], expected_status: &[(&BStr, Option<Change>, bool)]) {
     let worktree = fixture_path(name);
     let git_dir = worktree.join(".git");
     let mut index =
         gix_index::File::at(git_dir.join("index"), gix_hash::Kind::Sha1, false, Default::default()).unwrap();
     let mut recorder = Recorder::default();
+    let search = gix_pathspec::Search::from_specs(to_pathspecs(pathspecs), None, std::path::Path::new(""))
+        .expect("valid specs can be normalized");
     index_as_worktree(
         &mut index,
         &worktree,
         &mut recorder,
         FastEq,
         |_, _| Ok::<_, std::convert::Infallible>(gix_object::BlobRef { data: &[] }),
+        &mut gix_features::progress::Discard,
+        Pathspec(search),
         Options {
             fs: gix_fs::Capabilities::probe(&git_dir),
             stat: TEST_OPTIONS,
@@ -51,6 +59,13 @@ fn fixture(name: &str, expected_status: &[(&BStr, Option<Change>, bool)]) {
     assert_eq!(recorder.records, expected_status)
 }
 
+fn to_pathspecs(input: &[&str]) -> Vec<gix_pathspec::Pattern> {
+    input
+        .iter()
+        .map(|pattern| gix_pathspec::parse(pattern.as_bytes(), Default::default()).expect("known to be valid"))
+        .collect()
+}
+
 #[test]
 fn removed() {
     fixture(
@@ -62,6 +77,15 @@ fn removed() {
             (BStr::new(b"executable"), Some(Change::Removed), false),
         ],
     );
+
+    fixture_filtered(
+        "status_removed",
+        &["dir"],
+        &[
+            (BStr::new(b"dir/content"), Some(Change::Removed), false),
+            (BStr::new(b"dir/sub-dir/symlink"), Some(Change::Removed), false),
+        ],
+    );
 }
 
 #[test]
@@ -180,6 +204,8 @@ fn racy_git() {
         &mut recorder,
         counter.clone(),
         |_, _| Err(std::io::Error::new(std::io::ErrorKind::Other, "no odb access expected")),
+        &mut gix_features::progress::Discard,
+        Pathspec::default(),
         Options {
             fs,
             stat: TEST_OPTIONS,
@@ -201,6 +227,8 @@ fn racy_git() {
         &mut recorder,
         counter,
         |_, _| Err(std::io::Error::new(std::io::ErrorKind::Other, "no odb access expected")),
+        &mut gix_features::progress::Discard,
+        Pathspec::default(),
         Options {
             fs,
             stat: TEST_OPTIONS,
@@ -226,3 +254,28 @@ fn racy_git() {
         "racy change is correctly detected"
     );
 }
+
+#[derive(Clone)]
+struct Pathspec(gix_pathspec::Search);
+
+impl Default for Pathspec {
+    fn default() -> Self {
+        let search = gix_pathspec::Search::from_specs(to_pathspecs(&[]), None, std::path::Path::new(""))
+            .expect("empty is always valid");
+        Self(search)
+    }
+}
+
+impl gix_status::Pathspec for Pathspec {
+    fn common_prefix(&self) -> &BStr {
+        self.0.common_prefix()
+    }
+
+    fn is_included(&mut self, relative_path: &BStr, is_dir: Option<bool>) -> bool {
+        self.0
+            .pattern_matching_relative_path(relative_path, is_dir, &mut |_, _, _, _| {
+                unreachable!("we don't use attributes in our pathspecs")
+            })
+            .map_or(false, |m| !m.is_excluded())
+    }
+}