Use new oid where possible in git-odb (#63)

Author: Byron

experiments/object-access/src/main.rs

@@ -117,7 +117,7 @@ fn do_gitoxide(hashes: &[String], objects_dir: &Path) -> anyhow::Result<u64> {
     let mut bytes = 0u64;
     for hash in hashes {
         let hash: git_hash::ObjectId = hash.parse()?;
-        let obj = odb.locate(hash.to_borrowed(), &mut buf)?.expect("object must exist");
+        let obj = odb.locate(hash, &mut buf)?.expect("object must exist");
         bytes += obj.size() as u64;
     }
     Ok(bytes)
@@ -131,7 +131,7 @@ fn do_parallel_gitoxide(hashes: &[String], objects_dir: &Path) -> anyhow::Result
         .par_iter()
         .try_for_each_init::<_, _, _, anyhow::Result<_>>(Vec::new, |mut buf, hash| {
             let hash: git_hash::ObjectId = hash.parse()?;
-            let obj = odb.locate(hash.to_borrowed(), &mut buf)?.expect("object must exist");
+            let obj = odb.locate(hash, &mut buf)?.expect("object must exist");
             bytes.fetch_add(obj.size() as u64, std::sync::atomic::Ordering::Relaxed);
             Ok(())
         })?;

git-hash/src/borrowed.rs

@@ -11,7 +11,7 @@ use std::{
 pub struct Id<'a>(&'a [u8; SIZE_OF_SHA1_DIGEST]);
 
 /// A borrowed reference to a hash identifying objects.
-#[derive(Hash)]
+#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd)]
 #[repr(transparent)]
 #[allow(non_camel_case_types)]
 #[cfg_attr(feature = "serde1", derive(serde::Serialize))]
@@ -74,6 +74,30 @@ impl oid {
     }
 }
 
+/// Sha1 specific methods
+impl oid {
+    /// Returns an array with a hexadecimal encoded version of the Sha1 hash this `Id` represents.
+    ///
+    /// **Panics** if this is not a Sha1 hash, as identifiable by [`Id::kind()`].
+    pub fn to_sha1_hex(&self) -> [u8; SIZE_OF_SHA1_DIGEST * 2] {
+        let mut buf = [0u8; SIZE_OF_SHA1_DIGEST * 2];
+        hex::encode_to_slice(&self.bytes, &mut buf).expect("to count correctly");
+        buf
+    }
+
+    /// Returns the bytes making up the Sha1.
+    ///
+    /// **Panics** if this is not a Sha1 hash, as identifiable by [`Id::kind()`].
+    pub fn sha1(&self) -> &[u8; SIZE_OF_SHA1_DIGEST] {
+        self.bytes.try_into().expect("correctly sized slice")
+    }
+
+    /// Returns a Sha1 digest with all bytes being initialized to zero.
+    pub fn null_sha1() -> &'static Self {
+        oid::from([0u8; SIZE_OF_SHA1_DIGEST].as_ref())
+    }
+}
+
 impl AsRef<oid> for &oid {
     fn as_ref(&self) -> &oid {
         self

git-hash/src/owned.rs

@@ -93,12 +93,19 @@ impl From<[u8; SIZE_OF_SHA1_DIGEST]> for ObjectId {
     }
 }
 
-// TODO: remove this - what do we deref to if there are multiple hash sizes?
+impl From<&crate::borrowed::oid> for ObjectId {
+    fn from(v: &oid) -> Self {
+        match v.kind() {
+            crate::Kind::Sha1 => ObjectId::from_20_bytes(v.as_bytes()),
+        }
+    }
+}
+
 impl Deref for ObjectId {
-    type Target = [u8; SIZE_OF_SHA1_DIGEST];
+    type Target = oid;
 
     fn deref(&self) -> &Self::Target {
-        &self.0
+        self.as_ref()
     }
 }
 

git-object/src/borrowed/tree.rs

@@ -29,7 +29,7 @@ pub struct Entry<'a> {
     pub filename: &'a BStr,
     /// The id of the object representing the entry.
     #[cfg_attr(feature = "serde1", serde(borrow))]
-    pub oid: git_hash::borrowed::Id<'a>,
+    pub oid: &'a git_hash::oid,
 }
 
 impl<'a> Tree<'a> {
@@ -68,7 +68,7 @@ fn parse_entry(i: &[u8]) -> IResult<&[u8], Entry<'_>, Error> {
         Entry {
             mode,
             filename: filename.as_bstr(),
-            oid: git_hash::borrowed::Id::try_from(oid).expect("we counted exactly 20 bytes"),
+            oid: git_hash::oid::try_from(oid).expect("we counted exactly 20 bytes"),
         },
     ))
 }

git-object/src/owned/tree.rs

@@ -69,7 +69,7 @@ impl Tree {
             out.write_all(&filename)?;
             out.write_all(&[b'\0'])?;
 
-            out.write_all(&oid[..])?;
+            out.write_all(oid.as_bytes())?;
         }
         Ok(())
     }

git-object/tests/borrowed/tree.rs

@@ -11,7 +11,7 @@ mod from_bytes {
         <[u8; 20]>::from_hex(hex).expect("40 bytes hex sha")
     }
 
-    pub fn as_id(id: &[u8; 20]) -> git_hash::borrowed::Id {
+    pub fn as_id(id: &[u8; 20]) -> &git_hash::oid {
         id.into()
     }
 

git-odb/src/borrowed.rs

@@ -46,14 +46,15 @@ pub mod verify {
         /// Compute the checksum of `self` and compare it with the `desired` hash.
         /// If the hashes do not match, an [`Error`] is returned, containing the actual
         /// hash of `self`.
-        pub fn verify_checksum(&self, desired: git_hash::borrowed::Id<'_>) -> Result<(), Error> {
+        pub fn verify_checksum(&self, desired: impl AsRef<git_hash::oid>) -> Result<(), Error> {
+            let desired = desired.as_ref();
             let mut sink = hash::Write::new(io::sink(), desired.kind());
 
             loose::object::header::encode(self.kind, self.data.len() as u64, &mut sink).expect("hash to always work");
             sink.hash.update(&self.data);
 
             let actual_id = git_hash::ObjectId::from(sink.hash.digest());
-            if desired != actual_id.to_borrowed() {
+            if desired != actual_id.as_ref() {
                 return Err(Error::ChecksumMismatch {
                     desired: desired.into(),
                     actual: actual_id,

git-odb/src/compound/locate.rs

@@ -11,13 +11,14 @@ pub enum Error {
 }
 
 impl compound::Db {
-    /// Find an object as identified by [`id`][git_hash::borrowed::Id] and store its data in full in the provided `buffer`.
+    /// Find an object as identified by [`ObjectId`][git_hash::ObjectId] and store its data in full in the provided `buffer`.
     /// This will search the object in all contained object databases.
     pub fn locate<'a>(
         &self,
-        id: git_hash::borrowed::Id<'_>,
+        id: impl AsRef<git_hash::oid>,
         buffer: &'a mut Vec<u8>,
     ) -> Result<Option<compound::Object<'a>>, Error> {
+        let id = id.as_ref();
         for pack in &self.packs {
             if let Some(idx) = pack.internal_locate_index(id) {
                 let object = pack.internal_get_object_by_index(idx, buffer, &mut pack::cache::Noop)?;

git-odb/src/compound/object.rs

@@ -69,7 +69,7 @@ pub mod verify {
 
     impl<'a> Object<'a> {
         /// Assert whether the actual checksum of this object matches the `desired` one.
-        pub fn verify_checksum(&mut self, desired: git_hash::borrowed::Id<'_>) -> Result<(), Error> {
+        pub fn verify_checksum(&mut self, desired: impl AsRef<git_hash::oid>) -> Result<(), Error> {
             match self {
                 Object::Borrowed(object) => object.verify_checksum(desired).map_err(Into::into),
                 Object::Loose(object) => object.verify_checksum(desired).map_err(Into::into),

git-odb/src/loose/db/locate.rs

@@ -26,12 +26,12 @@ pub enum Error {
 impl Db {
     const OPEN_ACTION: &'static str = "open";
 
-    /// Return the object identified by the given [`id][git_hash::borrowed::Id] if present in this database.
+    /// Return the object identified by the given [`ObjectId`][git_hash::ObjectId] if present in this database.
     ///
     /// Returns `Err` if there was an error locating or reading the object. Returns `Ok<None>` if
     /// there was no such object.
-    pub fn locate(&self, id: git_hash::borrowed::Id<'_>) -> Result<Option<Object>, Error> {
-        match self.locate_inner(id) {
+    pub fn locate(&self, id: impl AsRef<git_hash::oid>) -> Result<Option<Object>, Error> {
+        match self.locate_inner(id.as_ref()) {
             Ok(obj) => Ok(Some(obj)),
             Err(err) => match err {
                 Error::Io {
@@ -54,7 +54,7 @@ impl Db {
         }
     }
 
-    fn locate_inner(&self, id: git_hash::borrowed::Id<'_>) -> Result<Object, Error> {
+    fn locate_inner(&self, id: &git_hash::oid) -> Result<Object, Error> {
         let path = sha1_path(id, self.path.clone());
 
         let mut inflate = zlib::Inflate::default();