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()