Merge branch 'improvements'

Author: Byron

crate-status.md

@@ -615,6 +615,8 @@ See its [README.md](https://github.com/Byron/gitoxide/blob/main/gix-lock/README.
 * [x] utilities for applications to make long running operations interruptible gracefully and to support timeouts in servers.
 * [x] handle `core.repositoryFormatVersion` and extensions
 * [x] support for unicode-precomposition of command-line arguments (needs explicit use in parent application)
+* [ ] strict object creation (validate objects referenced by newly created objects exist)
+* [ ] strict hash verification (validate that objects actually have the hashes they claim to have)
 * **Repository**  
     * [x] discovery
         * [x] option to not cross file systems (default)

gix-hash/src/object_id.rs

@@ -123,6 +123,7 @@ impl ObjectId {
 
     /// Returns an instances whose bytes are all zero.
     #[inline]
+    #[doc(alias = "zero", alias = "git2")]
     pub const fn null(kind: Kind) -> ObjectId {
         match kind {
             Kind::Sha1 => Self::null_sha1(),
@@ -131,6 +132,7 @@ impl ObjectId {
 
     /// Returns `true` if this hash consists of all null bytes.
     #[inline]
+    #[doc(alias = "is_zero", alias = "git2")]
     pub fn is_null(&self) -> bool {
         match self {
             ObjectId::Sha1(digest) => &digest[..] == oid::null_sha1().as_bytes(),

gix-object/Cargo.toml

@@ -28,7 +28,7 @@ serde = ["dep:serde", "bstr/serde", "smallvec/serde", "gix-hash/serde", "gix-act
 verbose-object-parsing-errors = []
 
 [dependencies]
-gix-features = { version = "^0.35.0", path = "../gix-features", features = ["rustsha1"] }
+gix-features = { version = "^0.35.0", path = "../gix-features", features = ["rustsha1", "progress"] }
 gix-hash = { version = "^0.13.0", path = "../gix-hash" }
 gix-validate = { version = "^0.8.0", path = "../gix-validate" }
 gix-actor = { version = "^0.27.0", path = "../gix-actor" }

gix-object/src/lib.rs

@@ -364,7 +364,8 @@ pub mod decode {
     }
 }
 
-/// A standalone function to compute a hash of kind `hash_kind` for an object of `object_kind` and its `data`.
+/// A function to compute a hash of kind `hash_kind` for an object of `object_kind` and its `data`.
+#[doc(alias = "hash_object", alias = "git2")]
 pub fn compute_hash(hash_kind: gix_hash::Kind, object_kind: Kind, data: &[u8]) -> gix_hash::ObjectId {
     let header = encode::loose_header(object_kind, data.len() as u64);
 
@@ -374,3 +375,23 @@ pub fn compute_hash(hash_kind: gix_hash::Kind, object_kind: Kind, data: &[u8]) -
 
     hasher.digest().into()
 }
+
+/// A function to compute a hash of kind `hash_kind` for an object of `object_kind` and its data read from `stream`
+/// which has to yield exactly `stream_len` bytes.
+/// Use `progress` to learn about progress in bytes processed and `should_interrupt` to be able to abort the operation
+/// if set to `true`.
+#[doc(alias = "hash_file", alias = "git2")]
+pub fn compute_stream_hash(
+    hash_kind: gix_hash::Kind,
+    object_kind: Kind,
+    stream: &mut dyn std::io::Read,
+    stream_len: u64,
+    progress: &mut dyn gix_features::progress::Progress,
+    should_interrupt: &std::sync::atomic::AtomicBool,
+) -> std::io::Result<gix_hash::ObjectId> {
+    let header = encode::loose_header(object_kind, stream_len);
+    let mut hasher = gix_features::hash::hasher(hash_kind);
+
+    hasher.update(&header);
+    gix_features::hash::bytes_with_hasher(stream, stream_len, hasher, progress, should_interrupt)
+}

gix-object/tests/object.rs

@@ -1,4 +1,5 @@
 use std::path::PathBuf;
+use std::sync::atomic::AtomicBool;
 
 use gix_hash::ObjectId;
 
@@ -21,6 +22,35 @@ fn compute_hash() {
     );
 }
 
+#[test]
+fn compute_stream_hash() {
+    let hk = gix_hash::Kind::Sha1;
+    assert_eq!(
+        gix_object::compute_stream_hash(
+            hk,
+            gix_object::Kind::Blob,
+            &mut &[][..],
+            0,
+            &mut gix_features::progress::Discard,
+            &AtomicBool::default()
+        )
+        .expect("in-memory works"),
+        gix_hash::ObjectId::empty_blob(hk)
+    );
+    assert_eq!(
+        gix_object::compute_stream_hash(
+            hk,
+            gix_object::Kind::Tree,
+            &mut &[][..],
+            0,
+            &mut gix_features::progress::Discard,
+            &AtomicBool::default()
+        )
+        .expect("in-memory works"),
+        gix_hash::ObjectId::empty_tree(hk)
+    );
+}
+
 use gix_testtools::Result;
 
 #[cfg(not(windows))]

gix-status/src/index_as_worktree/traits.rs

@@ -148,18 +148,14 @@ impl CompareBlobs for HashEq {
                         stream.read_to_end(buf)?;
                         gix_object::compute_hash(entry.id.kind(), gix_object::Kind::Blob, buf)
                     }
-                    Some(len) => {
-                        let header = gix_object::encode::loose_header(gix_object::Kind::Blob, len);
-                        let mut hasher = gix_features::hash::hasher(entry.id.kind());
-                        hasher.update(&header);
-                        gix_features::hash::bytes_with_hasher(
-                            &mut stream,
-                            len,
-                            hasher,
-                            &mut gix_features::progress::Discard,
-                            &AtomicBool::default(),
-                        )?
-                    }
+                    Some(len) => gix_object::compute_stream_hash(
+                        entry.id.kind(),
+                        gix_object::Kind::Blob,
+                        &mut stream,
+                        len,
+                        &mut gix_features::progress::Discard,
+                        &AtomicBool::default(),
+                    )?,
                 };
                 Ok((entry.id != file_hash).then_some(file_hash))
             }

gix/src/head/peel.rs

@@ -47,6 +47,10 @@ impl<'repo> Head<'repo> {
     }
 
     // TODO: tests
+    // TODO: Fix this! It's not consistently peeling tags. The whole peeling business should be reconsidered to do what people usually
+    //       want which is to peel references, if present, and then peel objects with control over which object type to end at.
+    //       Finding a good interface for that isn't easy as ideally, it's an iterator that shows the intermediate objects so the user
+    //       can select which tag of a chain to choose.
     /// Follow the symbolic reference of this head until its target object and peel it by following tag objects until there is no
     /// more object to follow, and return that object id.
     ///

gix/src/lib.rs

@@ -75,6 +75,11 @@
 //! * [`git2::build::CheckoutBuilder::disable_filters()](https://docs.rs/git2/*/git2/build/struct.CheckoutBuilder.html#method.disable_filters) ➡ ❌ *(filters are always applied during checkouts)*
 //! * [`git2::Repository::submodule_status()`](https://docs.rs/git2/*/git2/struct.Repository.html#method.submodule_status) ➡ [`Submodule::state()`] - status provides more information and conveniences though, and an actual worktree status isn't performed.
 //!
+//! #### Integrity checks
+//!
+//! `git2` by default performs integrity checks via [`strict_hash_verification()`](https://docs.rs/git2/latest/git2/opts/fn.strict_hash_verification.html) and
+//! [`strict_object_creation`](https://docs.rs/git2/latest/git2/opts/fn.strict_object_creation.html) which `gitoxide` *currently* **does not have**.
+//!
 //! ### Feature Flags
 #![cfg_attr(
     feature = "document-features",
@@ -158,7 +163,8 @@ mod types;
 #[cfg(any(feature = "excludes", feature = "attributes"))]
 pub use types::AttributeStack;
 pub use types::{
-    Commit, Head, Id, Object, ObjectDetached, Reference, Remote, Repository, Tag, ThreadSafeRepository, Tree, Worktree,
+    Blob, Commit, Head, Id, Object, ObjectDetached, Reference, Remote, Repository, Tag, ThreadSafeRepository, Tree,
+    Worktree,
 };
 #[cfg(feature = "attributes")]
 pub use types::{Pathspec, PathspecDetached, Submodule};

gix/src/object/impls.rs

@@ -1,6 +1,6 @@
 use std::convert::TryFrom;
 
-use crate::{object, Commit, Object, ObjectDetached, Tag, Tree};
+use crate::{object, Blob, Commit, Object, ObjectDetached, Tag, Tree};
 
 impl<'repo> From<Object<'repo>> for ObjectDetached {
     fn from(mut v: Object<'repo>) -> Self {
@@ -59,11 +59,11 @@ impl<'repo> TryFrom<Object<'repo>> for Commit<'repo> {
     type Error = Object<'repo>;
 
     fn try_from(mut value: Object<'repo>) -> Result<Self, Self::Error> {
-        let handle = value.repo;
+        let repo = value.repo;
         match value.kind {
             object::Kind::Commit => Ok(Commit {
                 id: value.id,
-                repo: handle,
+                repo,
                 data: steal_from_freelist(&mut value.data),
             }),
             _ => Err(value),
@@ -75,11 +75,11 @@ impl<'repo> TryFrom<Object<'repo>> for Tag<'repo> {
     type Error = Object<'repo>;
 
     fn try_from(mut value: Object<'repo>) -> Result<Self, Self::Error> {
-        let handle = value.repo;
+        let repo = value.repo;
         match value.kind {
             object::Kind::Tag => Ok(Tag {
                 id: value.id,
-                repo: handle,
+                repo,
                 data: steal_from_freelist(&mut value.data),
             }),
             _ => Err(value),
@@ -91,11 +91,27 @@ impl<'repo> TryFrom<Object<'repo>> for Tree<'repo> {
     type Error = Object<'repo>;
 
     fn try_from(mut value: Object<'repo>) -> Result<Self, Self::Error> {
-        let handle = value.repo;
+        let repo = value.repo;
         match value.kind {
             object::Kind::Tree => Ok(Tree {
                 id: value.id,
-                repo: handle,
+                repo,
+                data: steal_from_freelist(&mut value.data),
+            }),
+            _ => Err(value),
+        }
+    }
+}
+
+impl<'repo> TryFrom<Object<'repo>> for Blob<'repo> {
+    type Error = Object<'repo>;
+
+    fn try_from(mut value: Object<'repo>) -> Result<Self, Self::Error> {
+        let repo = value.repo;
+        match value.kind {
+            object::Kind::Blob => Ok(Blob {
+                id: value.id,
+                repo,
                 data: steal_from_freelist(&mut value.data),
             }),
             _ => Err(value),

gix/src/object/mod.rs

@@ -4,7 +4,7 @@ use std::convert::TryInto;
 use gix_hash::ObjectId;
 pub use gix_object::Kind;
 
-use crate::{Commit, Id, Object, ObjectDetached, Tag, Tree};
+use crate::{Blob, Commit, Id, Object, ObjectDetached, Tag, Tree};
 
 mod errors;
 pub(crate) mod cache {
@@ -74,6 +74,14 @@ impl<'repo> Object<'repo> {
         }
     }
 
+    /// Transform this object into a blob, or panic if it is none.
+    pub fn into_blob(self) -> Blob<'repo> {
+        match self.try_into() {
+            Ok(tree) => tree,
+            Err(this) => panic!("Tried to use {} as tree, but was {}", this.id, this.kind),
+        }
+    }
+
     /// Transform this object into a tree, or panic if it is none.
     pub fn into_tree(self) -> Tree<'repo> {
         match self.try_into() {
@@ -124,6 +132,15 @@ impl<'repo> Object<'repo> {
             expected: gix_object::Kind::Tree,
         })
     }
+
+    /// Transform this object into a blob, or return it as part of the `Err` if it is no blob.
+    pub fn try_into_blob(self) -> Result<Blob<'repo>, try_into::Error> {
+        self.try_into().map_err(|this: Self| try_into::Error {
+            id: this.id,
+            actual: this.kind,
+            expected: gix_object::Kind::Blob,
+        })
+    }
 }
 
 impl<'repo> Object<'repo> {