streamline status API

Author: pascalkuthe

Cargo.lock

@@ -127,6 +127,12 @@ impl ObjectId {
         }
     }
 
+    /// Returns true if this hash is equal to an empty blob
+    #[inline]
+    pub fn is_empty_blob(&self) -> bool {
+        self == &Self::empty_blob(self.kind())
+    }
+
     /// Returns an Digest representing a hash with whose memory is zeroed.
     #[inline]
     pub const fn null(kind: crate::Kind) -> ObjectId {

gix-hash/src/object_id.rs

@@ -21,6 +21,15 @@ impl State {
         self.timestamp
     }
 
+    /// Updates the timestamp of this state, indicating its freshness compared
+    /// to other files on disk. Be careful about using this as setting a
+    /// timestamp without correctly updating the index **will cause (file
+    /// system) race conditions** see racy-git.txt (in the git documentation)
+    /// for more details.
+    pub fn set_timestamp(&mut self, timestamp: FileTime) {
+        self.timestamp = timestamp
+    }
+
     /// Return the kind of hashes used in this instance.
     pub fn object_hash(&self) -> gix_hash::Kind {
         self.object_hash

gix-index/src/access/mod.rs

@@ -1,7 +1,8 @@
 /// The stage of an entry, one of 0 = base, 1 = ours, 2 = theirs
 pub type Stage = u32;
 
-mod mode;
+///
+pub mod mode;
 pub use mode::Mode;
 
 mod flags;

gix-index/src/entry/mod.rs

@@ -1,4 +1,8 @@
 use bitflags::bitflags;
+
+// TODO: we essentially treat this as an enum withj the only exception being
+// that `FILE_EXECUTABLE.contains(FILE)` works might want to turn this into an
+// enum proper
 bitflags! {
     /// The kind of file of an entry.
     pub struct Mode: u32 {
@@ -16,9 +20,74 @@ bitflags! {
     }
 }
 
+#[cfg(unix)]
+/// Returns whether a a file has the executable permission set
+pub fn is_executable(metadata: &std::fs::Metadata) -> bool {
+    use std::os::unix::fs::MetadataExt;
+    (metadata.mode() & 0o100) != 0
+}
+
+#[cfg(not(unix))]
+/// Returns whether a a file has the executable permission set
+pub fn is_executable(_metadata: &std::fs::Metadata) -> bool {
+    false
+}
+
 impl Mode {
     /// Return true if this is a sparse entry, as it points to a directory which usually isn't what an unsparse index tracks.
     pub fn is_sparse(&self) -> bool {
         *self == Self::DIR
     }
+
+    /// Compares this mode to the file system version ([`std::fs::symlink_metadata`])
+    /// and returns the change needed to update this mode to match the file if
+    pub fn change_to_match_fs(
+        self,
+        stat: &std::fs::Metadata,
+        has_symlinks: bool,
+        executable_bit: bool,
+    ) -> Option<Change> {
+        match self {
+            Mode::FILE if !stat.is_file() => (),
+            Mode::SYMLINK if has_symlinks && !stat.is_symlink() => (),
+            Mode::SYMLINK if !has_symlinks && !stat.is_file() => (),
+            Mode::COMMIT | Mode::DIR if !stat.is_dir() => (),
+            Mode::FILE if executable_bit && is_executable(stat) => return Some(Change::ExecutableBit),
+            Mode::FILE_EXECUTABLE if executable_bit && !is_executable(stat) => return Some(Change::ExecutableBit),
+            _ => return None,
+        };
+        let new_mode = if stat.is_dir() {
+            Mode::DIR
+        } else if executable_bit && is_executable(stat) {
+            Mode::FILE_EXECUTABLE
+        } else {
+            Mode::FILE
+        };
+        Some(Change::Type { new_mode })
+    }
+}
+
+/// A change of a [`Mode`]
+pub enum Change {
+    /// The type of mode changed (like symlink => file)
+    Type {
+        /// The mode representing the new index type
+        new_mode: Mode,
+    },
+    /// The executable permission of this file has changed
+    ExecutableBit,
+}
+
+impl Change {
+    /// Applies this change to a `Mode`
+    pub fn apply(self, mode: &mut Mode) {
+        *mode = match self {
+            Change::Type { new_mode } => new_mode,
+            Change::ExecutableBit => match *mode {
+                Mode::FILE => Mode::FILE_EXECUTABLE,
+                Mode::FILE_EXECUTABLE => Mode::FILE,
+                _ => unreachable!("invalid mode change: can't flip executable bit of {mode:?}"),
+            },
+        }
+    }
 }

gix-index/src/entry/mode.rs

@@ -41,6 +41,7 @@ gix-features = { version = "^0.28.0", path = "../gix-features" }
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"]}
 
 thiserror = "1.0.26"
+filetime = "0.2.15"
 bstr = { version = "1.3.0", default-features = false }
 
 document-features = { version = "0.2.0", optional = true }

gix-worktree/Cargo.toml

@@ -1,29 +1,60 @@
 //!
 
+use bstr::BStr;
+
 ///
 pub mod worktree;
 
-mod index;
-
 ///
-pub mod visit;
+pub mod index;
 
 ///
 pub mod recorder;
 
 ///
-pub struct IndexStatus<'index> {
-    index: &'index gix_index::State,
-}
+pub mod diff;
 
-impl<'index> From<&'index gix_index::File> for IndexStatus<'index> {
-    fn from(file: &'index gix_index::File) -> Self {
-        Self { index: file }
-    }
+/// The status of an index entry in a worktree
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Default)]
+pub enum Status<T = ()> {
+    #[default]
+    /// The file in the worktree is identical to the index entry
+    Unchanged,
+    /// An index entry has no corresponding file in the worktree.
+    Removed,
+    /// The type of file changed (symlink <=> file) performing a
+    /// diff is usually not necessary/desired
+    TypeChange,
+    /// The worktree file that belongs to this index has a changed stat
+    /// therefore could have been modified.
+    ///
+    /// Note that this doesn't necessarily mean that the *content* of the file changed.
+    /// A modified even is emitted whenever a change could have occurred. It is up
+    /// to API consumers to check the file for content changes
+    Modified {
+        /// Indicates that one of the stat changes was an executable bit change
+        /// which is a significant change itself (for git status)
+        /// these files don't need to be rechanged
+        executable_bit_changed: bool,
+        /// The output of the diff run on this entry.
+        /// if the there is no content change and only the executable bit
+        /// changed than this is `None`
+        diff: Option<T>,
+    },
+    /// An index entry that correspond to an untracked worktree file marked with `git add`
+    Added,
 }
 
-impl<'index> From<&'index gix_index::State> for IndexStatus<'index> {
-    fn from(index: &'index gix_index::State) -> Self {
-        Self { index }
-    }
+///
+pub trait Collector<'index> {
+    /// Data generated by comparing two files/entries
+    type Diff;
+    ///
+    fn visit_entry(
+        &mut self,
+        entry: &'index gix_index::Entry,
+        path: &'index BStr,
+        status: Status<Self::Diff>,
+        conflict: bool,
+    );
 }

gix-worktree/src/index/status.rs

@@ -0,0 +1,87 @@
+use gix_features::hash;
+use gix_hash::ObjectId;
+use gix_index as index;
+use gix_object::encode::loose_header;
+use index::Entry;
+
+///
+pub trait LazyBlob<'a, E> {
+    ///
+    fn read(self) -> Result<&'a [u8], E>;
+}
+
+///
+pub trait Diff: Send + Sync {
+    ///
+    type Output;
+    ///
+    fn content_changed<'a, E>(
+        &self,
+        entry: &'a Entry,
+        blob_size: usize,
+        blob: impl LazyBlob<'a, E>,
+        resolve_oid: impl FnMut(gix_hash::ObjectId) -> Result<&'a [u8], E>,
+    ) -> Result<Option<Self::Output>, E>;
+}
+
+/// compares to blobs by comparing their size and oid very fast
+pub struct Fast;
+
+impl Diff for Fast {
+    type Output = ();
+
+    fn content_changed<'a, E>(
+        &self,
+        entry: &'a Entry,
+        blob_size: usize,
+        blob: impl LazyBlob<'a, E>,
+        _resolve_oid: impl FnMut(gix_hash::ObjectId) -> Result<&'a [u8], 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 != blob_size && (entry.id.is_empty_blob() || entry.stat.size != 0) {
+            return Ok(Some(()));
+        }
+        let blob = blob.read()?;
+        let header = loose_header(gix_object::Kind::Blob, blob.len());
+        match entry.id {
+            ObjectId::Sha1(entry_hash) => {
+                let mut file_hash = hash::Sha1::default();
+                file_hash.update(&header);
+                file_hash.update(blob);
+                let file_hash = file_hash.digest();
+                Ok((entry_hash != file_hash).then_some(()))
+            }
+        }
+    }
+}
+
+/// compares to blobs by comparing their oid
+/// Same as [`FastEq`] but always
+pub struct Hash;
+
+impl Diff for Hash {
+    type Output = ObjectId;
+
+    fn content_changed<'a, E>(
+        &self,
+        entry: &'a Entry,
+        _blob_size: usize,
+        blob: impl LazyBlob<'a, E>,
+        _resolve_oid: impl FnMut(gix_hash::ObjectId) -> Result<&'a [u8], E>,
+    ) -> Result<Option<Self::Output>, E> {
+        let blob = blob.read()?;
+        let header = loose_header(gix_object::Kind::Blob, blob.len());
+        match entry.id {
+            ObjectId::Sha1(entry_hash) => {
+                let mut file_hash = hash::Sha1::default();
+                file_hash.update(&header);
+                file_hash.update(blob);
+                let file_hash = file_hash.digest();
+                Ok((entry_hash != file_hash).then_some(ObjectId::Sha1(file_hash)))
+            }
+        }
+    }
+}

gix-worktree/src/index/status/diff.rs

@@ -1,4 +1,28 @@
+use bstr::BStr;
+
+use gix_index as index;
+
+use crate::index::status::{Collector, Status};
+
 ///
-pub mod index;
-///
-pub mod worktree;
+#[derive(Debug, Default)]
+pub struct Recorder<'index, T = ()> {
+    /// collected records, unchanged fields are excluded
+    pub records: Vec<(&'index BStr, Status<T>, bool)>,
+}
+
+impl<'index, T> Collector<'index> for Recorder<'index, T> {
+    type Diff = T;
+
+    fn visit_entry(
+        &mut self,
+        _entry: &'index index::Entry,
+        path: &'index BStr,
+        status: Status<Self::Diff>,
+        conflict: bool,
+    ) {
+        if !matches!(status, Status::Unchanged) {
+            self.records.push((path, status, conflict))
+        }
+    }
+}