change!: make the hashing API return ObjectId

The vast majority of users of this API immediately converted the result
to `ObjectId`, so this eliminates a lot of cruft across the tree. It
also has a nicer `Debug` and `Display` instance than `[u8; 20]`,
and should theoretically make supporting the hash function transition
easier, although I suspect further API changes will be required for
that anyway.

I wasn’t sure whether this would be a good change, as not every
digest identifies an entry in the Git object database, but even many
of the existing uses for non‐object digests across the tree used the
`ObjectId` API anyway. Perhaps it would be best to have a separate
non‐alias `Digest` type that `ObjectId` wraps, but this seems like
the pragmatic choice for now that sticks with current practice.

Author: emilazy

gix-commitgraph/src/file/verify.rs

@@ -147,7 +147,7 @@ impl File {
         let data_len_without_trailer = self.data.len() - self.hash_len;
         let mut hasher = gix_hash::hasher(self.object_hash());
         hasher.update(&self.data[..data_len_without_trailer]);
-        let actual = gix_hash::ObjectId::from_bytes_or_panic(hasher.digest().as_ref());
+        let actual = hasher.digest();
 
         let expected = self.checksum();
         if actual == expected {

gix-hash/src/hasher/io.rs

@@ -66,7 +66,7 @@ pub fn bytes_with_hasher(
         }
     }
 
-    let id = crate::ObjectId::from(hasher.digest());
+    let id = hasher.digest();
     progress.show_throughput(start);
     Ok(id)
 }

gix-hash/src/hasher/mod.rs

@@ -7,9 +7,9 @@ impl Hasher {
     pub fn update(&mut self, bytes: &[u8]) {
         self.0.update(bytes);
     }
-    /// Finalize the hash and produce a digest.
-    pub fn digest(self) -> gix_features::hash::Digest {
-        self.0.digest()
+    /// Finalize the hash and produce an object ID.
+    pub fn digest(self) -> crate::ObjectId {
+        self.0.digest().into()
     }
 }
 

gix-hash/tests/object_id/mod.rs

@@ -50,7 +50,7 @@ mod sha1 {
     fn hash_contents(s: &[u8]) -> ObjectId {
         let mut hasher = hasher(Kind::Sha1);
         hasher.update(s);
-        ObjectId::Sha1(hasher.digest())
+        hasher.digest()
     }
 
     #[test]

gix-index/src/extension/end_of_index_entry/decode.rs

@@ -41,7 +41,7 @@ pub fn decode(data: &[u8], object_hash: gix_hash::Kind) -> Option<usize> {
         last_chunk = Some(chunk);
     }
 
-    if hasher.digest() != checksum {
+    if hasher.digest().as_slice() != checksum {
         return None;
     }
     // The last-to-this chunk ends where ours starts

gix-index/src/extension/end_of_index_entry/write.rs

@@ -23,7 +23,7 @@ pub fn write_to(
         hasher.update(&signature);
         hasher.update(&size.to_be_bytes());
     }
-    out.write_all(&hasher.digest())?;
+    out.write_all(hasher.digest().as_slice())?;
 
     Ok(())
 }

gix-index/src/file/write.rs

@@ -31,7 +31,7 @@ impl File {
             let mut hasher = hasher::io::Write::new(&mut out, self.state.object_hash);
             let out: &mut dyn std::io::Write = &mut hasher;
             let version = self.state.write_to(out, options)?;
-            (version, gix_hash::ObjectId::from(hasher.hash.digest()))
+            (version, hasher.hash.digest())
         };
         out.write_all(hash.as_slice())?;
         Ok((version, hash))

gix-object/src/lib.rs

@@ -409,7 +409,7 @@ fn object_hasher(hash_kind: gix_hash::Kind, object_kind: Kind, object_size: u64)
 pub fn compute_hash(hash_kind: gix_hash::Kind, object_kind: Kind, data: &[u8]) -> gix_hash::ObjectId {
     let mut hasher = object_hasher(hash_kind, object_kind, data.len() as u64);
     hasher.update(data);
-    hasher.digest().into()
+    hasher.digest()
 }
 
 /// A function to compute a hash of kind `hash_kind` for an object of `object_kind` and its data read from `stream`

gix-odb/src/sink.rs

@@ -53,6 +53,6 @@ impl gix_object::Write for Sink {
             c.reset();
         }
 
-        Ok(hasher.digest().into())
+        Ok(hasher.digest())
     }
 }

gix-odb/src/store_impls/loose/write.rs

@@ -130,7 +130,7 @@ impl Store {
         &self,
         hasher::io::Write { hash, inner: file }: hasher::io::Write<CompressedTempfile>,
     ) -> Result<gix_hash::ObjectId, Error> {
-        let id = gix_hash::ObjectId::from(hash.digest());
+        let id = hash.digest();
         let object_path = loose::hash_path(&id, self.path.clone());
         let object_dir = object_path
             .parent()

gix-pack/src/data/input/bytes_to_entries.rs

@@ -177,7 +177,7 @@ where
             }
 
             if let Some(hash) = self.hash.take() {
-                let actual_id = gix_hash::ObjectId::from(hash.digest());
+                let actual_id = hash.digest();
                 if self.mode == input::Mode::Restore {
                     id = actual_id;
                 }
@@ -191,7 +191,7 @@ where
             Some(id)
         } else if self.mode == input::Mode::Restore {
             let hash = self.hash.clone().expect("in restore mode a hash is set");
-            Some(gix_hash::ObjectId::from(hash.digest()))
+            Some(hash.digest())
         } else {
             None
         })

gix-pack/src/data/output/bytes.rs

@@ -122,11 +122,11 @@ where
             }
             None => {
                 let digest = self.output.hash.clone().digest();
-                self.output.inner.write_all(&digest[..])?;
-                self.written += digest.len() as u64;
+                self.output.inner.write_all(digest.as_slice())?;
+                self.written += digest.as_slice().len() as u64;
                 self.output.inner.flush()?;
                 self.is_done = true;
-                self.trailer = Some(gix_hash::ObjectId::from(digest));
+                self.trailer = Some(digest);
             }
         }
         Ok(self.written - previous_written)

gix-pack/src/index/encode.rs

@@ -137,7 +137,7 @@ mod function {
 
         let bytes_written_without_trailer = out.bytes;
         let out = out.inner.into_inner()?;
-        let index_hash: gix_hash::ObjectId = out.hash.digest().into();
+        let index_hash = out.hash.digest();
         out.inner.write_all(index_hash.as_slice())?;
         out.inner.flush()?;
 

gix-pack/src/index/write/mod.rs

@@ -227,7 +227,7 @@ impl crate::index::File {
                 let header = crate::data::header::encode(pack_version, 0);
                 let mut hasher = gix_hash::hasher(object_hash);
                 hasher.update(&header);
-                gix_hash::ObjectId::from(hasher.digest())
+                hasher.digest()
             }
             None => return Err(Error::IteratorInvariantTrailer),
         };

gix-pack/src/multi_index/write.rs

@@ -214,7 +214,7 @@ impl multi_index::File {
         }
 
         // write trailing checksum
-        let multi_index_checksum: gix_hash::ObjectId = out.inner.hash.digest().into();
+        let multi_index_checksum = out.inner.hash.digest();
         out.inner.inner.write_all(multi_index_checksum.as_slice())?;
         out.progress.show_throughput(write_start);
 

gix-pack/src/verify.rs

@@ -52,7 +52,7 @@ pub fn checksum_on_disk_or_mmap(
             hasher.update(&data[..data_len_without_trailer]);
             progress.inc_by(data_len_without_trailer);
             progress.show_throughput(start);
-            gix_hash::ObjectId::from(hasher.digest())
+            hasher.digest()
         }
     };