feat: add Object::try_into_blob() and into_blob() and Repository::empty_blob()

This way it's easier to assert that an object is actually a blob.

Author: Byron

gix/src/lib.rs

@@ -158,7 +158,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> {

gix/src/repository/object.rs

@@ -10,7 +10,7 @@ use gix_ref::{
 };
 use smallvec::SmallVec;
 
-use crate::{commit, ext::ObjectIdExt, object, tag, Id, Object, Reference, Tree};
+use crate::{commit, ext::ObjectIdExt, object, tag, Blob, Id, Object, Reference, Tree};
 
 /// Methods related to object creation.
 impl crate::Repository {
@@ -312,11 +312,23 @@ impl crate::Repository {
 
     /// Return an empty tree object, suitable for [getting changes](crate::Tree::changes()).
     ///
-    /// Note that it is special and doesn't physically exist in the object database even though it can be returned.
+    /// Note that the returned object is special and doesn't necessarily physically exist in the object database.
     /// This means that this object can be used in an uninitialized, empty repository which would report to have no objects at all.
     pub fn empty_tree(&self) -> Tree<'_> {
         self.find_object(gix_hash::ObjectId::empty_tree(self.object_hash()))
             .expect("always present")
             .into_tree()
     }
+
+    /// Return an empty blob object.
+    ///
+    /// Note that the returned object is special and doesn't necessarily physically exist in the object database.
+    /// This means that this object can be used in an uninitialized, empty repository which would report to have no objects at all.
+    pub fn empty_blob(&self) -> Blob<'_> {
+        Blob {
+            id: gix_hash::ObjectId::empty_blob(self.object_hash()),
+            data: Vec::new(),
+            repo: self,
+        }
+    }
 }

gix/src/types.rs

@@ -47,6 +47,21 @@ impl<'a> Drop for Object<'a> {
     }
 }
 
+/// A blob along with access to its owning repository.
+pub struct Blob<'repo> {
+    /// The id of the tree
+    pub id: ObjectId,
+    /// The blob's data.
+    pub data: Vec<u8>,
+    pub(crate) repo: &'repo Repository,
+}
+
+impl<'a> Drop for Blob<'a> {
+    fn drop(&mut self) {
+        self.repo.reuse_buffer(&mut self.data);
+    }
+}
+
 /// A decoded tree object with access to its owning repository.
 pub struct Tree<'repo> {
     /// The id of the tree

gix/tests/repository/object.rs

@@ -90,9 +90,10 @@ fn writes_avoid_io_using_duplicate_check() -> crate::Result {
                 assert_eq!(new_id, id);
             }
             Blob => {
-                let new_id = repo.write_blob(&obj.data)?;
+                let blob = obj.into_blob();
+                let new_id = repo.write_blob(&blob.data)?;
                 assert_eq!(new_id, id);
-                let new_id = repo.write_blob_stream(std::io::Cursor::new(&obj.data))?;
+                let new_id = repo.write_blob_stream(std::io::Cursor::new(&blob.data))?;
                 assert_eq!(new_id, id);
             }
         }