Create new gix-status crate to capture git-status like functionality

This includes the various diffs git can do between different representations
of the repository state, like

* index and working tree
* index and tree
* find untracked files
* check if the working tree is dirty (quickly)

Author: Byron

Cargo.lock

@@ -235,6 +235,7 @@ members = [
     "gix-index",
     "gix-bitmap",
     "gix-worktree",
+    "gix-status",
     "gix-revision",
     "gix-packetline",
     "gix-packetline-blocking",

Cargo.toml

@@ -95,6 +95,7 @@ is usable to some extent.
   * [gix-worktree-stream](https://github.com/Byron/gitoxide/blob/main/crate-status.md#gix-worktree-stream)
   * [gix-archive](https://github.com/Byron/gitoxide/blob/main/crate-status.md#gix-archive)
   * [gix-submodule](https://github.com/Byron/gitoxide/blob/main/crate-status.md#gix-submodule)
+  * [gix-status](https://github.com/Byron/gitoxide/blob/main/crate-status.md#gix-status)
   * `gitoxide-core`
 * **very early**  _(possibly without any documentation and many rough edges)_
   * [gix-date](https://github.com/Byron/gitoxide/blob/main/crate-status.md#gix-date)

README.md

@@ -453,6 +453,12 @@ Make it the best-performing implementation and the most convenient one.
 ### gix-glob
 * [x] parse pattern
 * [x] a type for pattern matching of paths and non-paths, optionally case-insensitively.
+ 
+### gix-status
+* [x] differences between index and worktree to turn index into worktree
+* [ ] differences between tree and index to turn tree into index
+* [ ] untracked files
+* [ ] fast answer to 'is it dirty'.
 
 ### gix-worktree
 * handle the working **tree/checkout**
@@ -463,18 +469,17 @@ Make it the best-performing implementation and the most convenient one.
      - [ ] handle sparse index
      - [x] linear scaling with multi-threading up to IO saturation
   - supported attributes to affect working tree and index contents
-     - [ ] eol
-     - [ ] working-tree-encoding
+     - [x] eol
+     - [x] working-tree-encoding
      - …more
   - **filtering** 
-     - [ ] `text`
-     - [ ] `ident`
-     - [ ] filter processes
-     - [ ] single-invocation clean/smudge filters
-* manage multiple worktrees
+     - [x] `text`
+     - [x] `ident`
+     - [x] filter processes
+     - [x] single-invocation clean/smudge filters
 * access to per-path information, like `.gitignore` and `.gitattributes` in a manner well suited for efficient lookups
   * [x] _exclude_ information
-  * [ ] attributes
+  * [x] attributes
 
 ### gix-revision
 * [x] `describe()` (similar to `git name-rev`)

crate-status.md

@@ -0,0 +1,37 @@
+[package]
+name = "gix-status"
+version = "0.1.0"
+repository = "https://github.com/Byron/gitoxide"
+license = "MIT OR Apache-2.0"
+description = "A crate of the gitoxide project dealing with 'git status'-like functionality"
+authors = ["Sebastian Thiel <[email protected]>", "Pascal Kuthe <[email protected]>"]
+edition = "2021"
+include = ["src/**/*", "LICENSE-*", "CHANGELOG.md"]
+rust-version = "1.65"
+
+[lib]
+doctest = false
+
+[[test]]
+name = "multi-threaded"
+path = "tests/status-multi-threaded.rs"
+required-features = ["internal-testing-gix-features-parallel"]
+
+[features]
+internal-testing-gix-features-parallel = ["gix-features/parallel"]
+
+[dependencies]
+gix-index = { version = "^0.22.0", path = "../gix-index" }
+gix-fs = { version = "^0.4.1", path = "../gix-fs" }
+gix-hash = { version = "^0.11.4", path = "../gix-hash" }
+gix-object = { version = "^0.34.0", path = "../gix-object" }
+gix-path = { version = "^0.8.4", path = "../gix-path" }
+gix-features = { version = "^0.32.1", path = "../gix-features" }
+
+thiserror = "1.0.26"
+filetime = "0.2.15"
+bstr = { version = "1.3.0", default-features = false }
+
+[dev-dependencies]
+gix-testtools = { path = "../tests/tools" }
+

gix-worktree/CHANGELOG.md renamed to gix-status/CHANGELOG.md

@@ -0,0 +1 @@
+../LICENSE-APACHE

gix-status/Cargo.toml

@@ -0,0 +1 @@
+../LICENSE-MIT

gix-status/LICENSE-APACHE

@@ -0,0 +1,80 @@
+use gix_hash::ObjectId;
+use gix_index as index;
+use index::Entry;
+
+/// Compares the content of two blobs in some way.
+pub trait CompareBlobs {
+    /// Output data produced by [`compare_blobs()`][CompareBlobs::compare_blobs()].
+    type Output;
+
+    /// Providing the underlying index `entry`, allow comparing a file in the worktree of size `worktree_blob_size`
+    /// and allow reading its bytes using `worktree_blob`.
+    /// If this function returns `None` the `entry` and the `worktree_blob` are assumed to be identical.
+    /// Use `entry_blob` to obtain the data for the blob referred to by `entry`, allowing comparisons of the data itself.
+    fn compare_blobs<'a, E>(
+        &mut self,
+        entry: &'a gix_index::Entry,
+        worktree_blob_size: usize,
+        worktree_blob: impl ReadDataOnce<'a, E>,
+        entry_blob: impl ReadDataOnce<'a, E>,
+    ) -> Result<Option<Self::Output>, E>;
+}
+
+/// Lazy borrowed access to blob data.
+pub trait ReadDataOnce<'a, E> {
+    /// Returns the contents of this blob.
+    ///
+    /// This potentially performs IO and other expensive operations
+    /// and should only be called when necessary.
+    fn read_data(self) -> Result<&'a [u8], E>;
+}
+
+/// Compares to blobs by comparing their size and oid, and only looks at the file if
+/// the size matches, therefore it's very fast.
+#[derive(Clone)]
+pub struct FastEq;
+
+impl CompareBlobs for FastEq {
+    type Output = ();
+
+    fn compare_blobs<'a, E>(
+        &mut self,
+        entry: &'a Entry,
+        worktree_blob_size: usize,
+        worktree_blob: impl ReadDataOnce<'a, E>,
+        _entry_blob: impl ReadDataOnce<'a, E>,
+    ) -> Result<Option<Self::Output>, E> {
+        // make sure to account for racily smudged entries here so that they don't always keep
+        // showing up as modified even after their contents have changed again, to a potentially
+        // unmodified state. That means that we want to ignore stat.size == 0 for non_empty_blobs.
+        if entry.stat.size as usize != worktree_blob_size && (entry.id.is_empty_blob() || entry.stat.size != 0) {
+            return Ok(Some(()));
+        }
+        let blob = worktree_blob.read_data()?;
+        let file_hash = gix_object::compute_hash(entry.id.kind(), gix_object::Kind::Blob, blob);
+        Ok((entry.id != file_hash).then_some(()))
+    }
+}
+
+/// Compares files to blobs by *always* comparing their hashes.
+///
+/// Same as [`FastEq`] but does not contain a fast path for files with mismatched files and
+/// therefore always returns an OID that can be reused later.
+#[derive(Clone)]
+pub struct HashEq;
+
+impl CompareBlobs for HashEq {
+    type Output = ObjectId;
+
+    fn compare_blobs<'a, E>(
+        &mut self,
+        entry: &'a Entry,
+        _worktree_blob_size: usize,
+        worktree_blob: impl ReadDataOnce<'a, E>,
+        _entry_blob: impl ReadDataOnce<'a, E>,
+    ) -> Result<Option<Self::Output>, E> {
+        let blob = worktree_blob.read_data()?;
+        let file_hash = gix_object::compute_hash(entry.id.kind(), gix_object::Kind::Blob, blob);
+        Ok((entry.id != file_hash).then_some(file_hash))
+    }
+}