migrate all hashing API users to gix_hash

emilazy · emilazy · commit baa1430aed0d · 2025-04-02T17:37:23.000+01:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/gix-commitgraph/Cargo.toml b/gix-commitgraph/Cargo.toml
@@ -20,7 +20,6 @@ doctest = false
 serde = ["dep:serde", "gix-hash/serde", "bstr/serde"]
 
 [dependencies]
-gix-features = { version = "^0.40.0", path = "../gix-features", features = ["rustsha1"] }
 gix-hash = { version = "^0.16.0", path = "../gix-hash" }
 gix-chunk = { version = "^0.4.11", path = "../gix-chunk" }
 
diff --git a/gix-commitgraph/src/file/verify.rs b/gix-commitgraph/src/file/verify.rs
@@ -140,12 +140,12 @@ impl File {
     ///
     /// Return the actual checksum on success or `(actual checksum, expected checksum)` if there is a mismatch.
     pub fn verify_checksum(&self) -> Result<gix_hash::ObjectId, (gix_hash::ObjectId, gix_hash::ObjectId)> {
-        // Even though we could use gix_features::hash::bytes_of_file(…), this would require using our own
+        // Even though we could use gix_hash::bytes_of_file(…), this would require using our own
         // Error type to support io::Error and Mismatch. As we only gain progress, there probably isn't much value
         // as these files are usually small enough to process them in less than a second, even for the large ones.
         // But it's possible, once a progress instance is passed.
         let data_len_without_trailer = self.data.len() - self.hash_len;
-        let mut hasher = gix_features::hash::hasher(self.object_hash());
+        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());
 
diff --git a/gix-hash/Cargo.toml b/gix-hash/Cargo.toml
@@ -34,7 +34,6 @@ document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
 gix-testtools = { path = "../tests/tools" }
-gix-features = { path = "../gix-features", features = ["rustsha1"] }
 
 [package.metadata.docs.rs]
 all-features = true
diff --git a/gix-index/Cargo.toml b/gix-index/Cargo.toml
@@ -23,7 +23,6 @@ serde = ["dep:serde", "smallvec/serde", "gix-hash/serde"]
 
 [dependencies]
 gix-features = { version = "^0.40.0", path = "../gix-features", features = [
-    "rustsha1",
     "progress",
 ] }
 gix-hash = { version = "^0.16.0", path = "../gix-hash" }
diff --git a/gix-index/src/extension/end_of_index_entry/decode.rs b/gix-index/src/extension/end_of_index_entry/decode.rs
@@ -33,7 +33,7 @@ pub fn decode(data: &[u8], object_hash: gix_hash::Kind) -> Option<usize> {
         return None;
     }
 
-    let mut hasher = gix_features::hash::hasher(gix_hash::Kind::Sha1);
+    let mut hasher = gix_hash::hasher(gix_hash::Kind::Sha1);
     let mut last_chunk = None;
     for (signature, chunk) in extension::Iter::new(&data[offset..data.len() - MIN_SIZE_WITH_HEADER - hash_len]) {
         hasher.update(&signature);
diff --git a/gix-index/src/extension/end_of_index_entry/write.rs b/gix-index/src/extension/end_of_index_entry/write.rs
@@ -18,7 +18,7 @@ pub fn write_to(
 
     out.write_all(&offset_to_extensions.to_be_bytes())?;
 
-    let mut hasher = gix_features::hash::hasher(hash_kind);
+    let mut hasher = gix_hash::hasher(hash_kind);
     for (signature, size) in prior_extensions {
         hasher.update(&signature);
         hasher.update(&size.to_be_bytes());
diff --git a/gix-index/src/file/init.rs b/gix-index/src/file/init.rs
@@ -75,7 +75,7 @@ impl File {
                     let _span = gix_features::trace::detail!("gix::open_index::hash_index", path = ?path);
                     let meta = file.metadata()?;
                     let num_bytes_to_hash = meta.len() - object_hash.len_in_bytes() as u64;
-                    let actual_hash = gix_features::hash::bytes(
+                    let actual_hash = gix_hash::bytes(
                         &mut file,
                         num_bytes_to_hash,
                         object_hash,
diff --git a/gix-index/src/file/verify.rs b/gix-index/src/file/verify.rs
@@ -25,7 +25,7 @@ impl File {
         if let Some(checksum) = self.checksum {
             let num_bytes_to_hash = self.path.metadata()?.len() - checksum.as_bytes().len() as u64;
             let should_interrupt = AtomicBool::new(false);
-            let actual = gix_features::hash::bytes_of_file(
+            let actual = gix_hash::bytes_of_file(
                 &self.path,
                 num_bytes_to_hash,
                 checksum.kind(),
diff --git a/gix-index/src/file/write.rs b/gix-index/src/file/write.rs
@@ -1,4 +1,4 @@
-use gix_features::hash;
+use gix_hash::hasher;
 
 use crate::{write, File, Version};
 
@@ -28,7 +28,7 @@ impl File {
             let version = self.state.write_to(out, options)?;
             (version, self.state.object_hash.null())
         } else {
-            let mut hasher = hash::Write::new(&mut out, self.state.object_hash);
+            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()))
diff --git a/gix-index/tests/Cargo.toml b/gix-index/tests/Cargo.toml
@@ -20,7 +20,7 @@ gix-features-parallel = ["gix-features/parallel"]
 
 [dev-dependencies]
 gix-index = { path = ".." }
-gix-features = { path = "../../gix-features", features = ["rustsha1", "progress"] }
+gix-features = { path = "../../gix-features", features = ["progress"] }
 gix-testtools = { path = "../../tests/tools" }
 gix-odb = { path = "../../gix-odb" }
 gix-object = { path = "../../gix-object" }
diff --git a/gix-object/Cargo.toml b/gix-object/Cargo.toml
@@ -42,7 +42,6 @@ verbose-object-parsing-errors = ["winnow/std"]
 
 [dependencies]
 gix-features = { version = "^0.40.0", path = "../gix-features", features = [
-    "rustsha1",
     "progress",
 ] }
 gix-hash = { version = "^0.16.0", path = "../gix-hash" }
diff --git a/gix-object/src/lib.rs b/gix-object/src/lib.rs
@@ -398,8 +398,8 @@ pub mod decode {
     }
 }
 
-fn object_hasher(hash_kind: gix_hash::Kind, object_kind: Kind, object_size: u64) -> gix_features::hash::Hasher {
-    let mut hasher = gix_features::hash::hasher(hash_kind);
+fn object_hasher(hash_kind: gix_hash::Kind, object_kind: Kind, object_size: u64) -> gix_hash::Hasher {
+    let mut hasher = gix_hash::hasher(hash_kind);
     hasher.update(&encode::loose_header(object_kind, object_size));
     hasher
 }
@@ -426,5 +426,5 @@ pub fn compute_stream_hash(
     should_interrupt: &std::sync::atomic::AtomicBool,
 ) -> std::io::Result<gix_hash::ObjectId> {
     let hasher = object_hasher(hash_kind, object_kind, stream_len);
-    gix_features::hash::bytes_with_hasher(stream, stream_len, hasher, progress, should_interrupt)
+    gix_hash::bytes_with_hasher(stream, stream_len, hasher, progress, should_interrupt)
 }
diff --git a/gix-odb/Cargo.toml b/gix-odb/Cargo.toml
@@ -20,7 +20,7 @@ doctest = false
 serde = ["dep:serde", "gix-hash/serde", "gix-object/serde", "gix-pack/serde"]
 
 [dependencies]
-gix-features = { version = "^0.40.0", path = "../gix-features", features = ["rustsha1", "walkdir", "zlib", "crc32"] }
+gix-features = { version = "^0.40.0", path = "../gix-features", features = ["walkdir", "zlib", "crc32"] }
 gix-hashtable = { version = "^0.7.0", path = "../gix-hashtable" }
 gix-hash = { version = "^0.16.0", path = "../gix-hash" }
 gix-date = { version = "^0.9.3", path = "../gix-date" }
diff --git a/gix-odb/src/sink.rs b/gix-odb/src/sink.rs
@@ -36,7 +36,7 @@ impl gix_object::Write for Sink {
             Ok(())
         };
 
-        let mut hasher = gix_features::hash::hasher(self.object_hash);
+        let mut hasher = gix_hash::hasher(self.object_hash);
         hasher.update(&header);
         possibly_compress(&header).map_err(Box::new)?;
 
diff --git a/gix-odb/src/store_impls/loose/write.rs b/gix-odb/src/store_impls/loose/write.rs
@@ -1,6 +1,7 @@
 use std::{fs, io, io::Write, path::PathBuf};
 
-use gix_features::{hash, zlib::stream::deflate};
+use gix_features::zlib::stream::deflate;
+use gix_hash::hasher;
 use gix_object::WriteTo;
 use tempfile::NamedTempFile;
 
@@ -106,7 +107,7 @@ impl Store {
 }
 
 impl Store {
-    fn dest(&self) -> Result<hash::Write<CompressedTempfile>, Error> {
+    fn dest(&self) -> Result<hasher::io::Write<CompressedTempfile>, Error> {
         #[cfg_attr(not(unix), allow(unused_mut))]
         let mut builder = tempfile::Builder::new();
         #[cfg(unix)]
@@ -115,7 +116,7 @@ impl Store {
             let perms = std::fs::Permissions::from_mode(0o444);
             builder.permissions(perms);
         }
-        Ok(hash::Write::new(
+        Ok(hasher::io::Write::new(
             deflate::Write::new(builder.tempfile_in(&self.path).map_err(|err| Error::Io {
                 source: err,
                 message: "create named temp file in",
@@ -127,7 +128,7 @@ impl Store {
 
     fn finalize_object(
         &self,
-        hash::Write { hash, inner: file }: hash::Write<CompressedTempfile>,
+        hasher::io::Write { hash, inner: file }: hasher::io::Write<CompressedTempfile>,
     ) -> Result<gix_hash::ObjectId, Error> {
         let id = gix_hash::ObjectId::from(hash.digest());
         let object_path = loose::hash_path(&id, self.path.clone());
diff --git a/gix-pack/Cargo.toml b/gix-pack/Cargo.toml
@@ -34,7 +34,7 @@ serde = ["dep:serde", "gix-object/serde"]
 wasm = ["gix-diff?/wasm"]
 
 [dependencies]
-gix-features = { version = "^0.40.0", path = "../gix-features", features = ["crc32", "rustsha1", "progress", "zlib"] }
+gix-features = { version = "^0.40.0", path = "../gix-features", features = ["crc32", "progress", "zlib"] }
 gix-path = { version = "^0.10.14", path = "../gix-path" }
 gix-hash = { version = "^0.16.0", path = "../gix-hash" }
 gix-chunk = { version = "^0.4.11", path = "../gix-chunk" }
diff --git a/gix-pack/src/data/input/bytes_to_entries.rs b/gix-pack/src/data/input/bytes_to_entries.rs
@@ -1,7 +1,7 @@
 use std::{fs, io};
 
-use gix_features::{hash::Hasher, zlib::Decompress};
-use gix_hash::ObjectId;
+use gix_features::zlib::Decompress;
+use gix_hash::{Hasher, ObjectId};
 
 use crate::data::input;
 
@@ -69,7 +69,7 @@ where
             version,
             objects_left: num_objects,
             hash: (mode != input::Mode::AsIs).then(|| {
-                let mut hash = gix_features::hash::hasher(object_hash);
+                let mut hash = gix_hash::hasher(object_hash);
                 hash.update(&header_data);
                 hash
             }),
diff --git a/gix-pack/src/data/input/entries_to_bytes.rs b/gix-pack/src/data/input/entries_to_bytes.rs
@@ -1,7 +1,5 @@
 use std::iter::Peekable;
 
-use gix_features::hash;
-
 use crate::data::input;
 
 /// An implementation of [`Iterator`] to write [encoded entries][input::Entry] to an inner implementation each time
@@ -95,7 +93,7 @@ where
 
         self.output.rewind()?;
         let interrupt_never = std::sync::atomic::AtomicBool::new(false);
-        let digest = hash::bytes(
+        let digest = gix_hash::bytes(
             &mut self.output,
             num_bytes_written,
             self.object_hash,
diff --git a/gix-pack/src/data/output/bytes.rs b/gix-pack/src/data/output/bytes.rs
@@ -1,6 +1,6 @@
 use std::io::Write;
 
-use gix_features::hash;
+use gix_hash::hasher;
 
 use crate::data::output;
 use crate::exact_vec;
@@ -24,7 +24,7 @@ pub struct FromEntriesIter<I, W> {
     /// An iterator for input [`output::Entry`] instances
     pub input: I,
     /// A way of writing encoded bytes.
-    output: hash::Write<W>,
+    output: hasher::io::Write<W>,
     /// Our trailing hash when done writing all input entries
     trailer: Option<gix_hash::ObjectId>,
     /// The amount of objects in the iteration and the version of the packfile to be written.
@@ -71,7 +71,7 @@ where
         );
         FromEntriesIter {
             input,
-            output: hash::Write::new(output, object_hash),
+            output: hasher::io::Write::new(output, object_hash),
             trailer: None,
             entry_version: version,
             pack_offsets_and_validity: exact_vec(num_entries as usize),
diff --git a/gix-pack/src/index/encode.rs b/gix-pack/src/index/encode.rs
@@ -36,10 +36,8 @@ pub(crate) fn fanout(iter: &mut dyn ExactSizeIterator<Item = u8>) -> [u32; 256]
 mod function {
     use std::io;
 
-    use gix_features::{
-        hash,
-        progress::{self, DynNestedProgress},
-    };
+    use gix_features::progress::{self, DynNestedProgress};
+    use gix_hash::hasher;
 
     use super::{fanout, HIGH_BIT, LARGE_OFFSET_THRESHOLD};
     use crate::index::V2_SIGNATURE;
@@ -87,7 +85,7 @@ mod function {
         // Write header
         let mut out = Count::new(std::io::BufWriter::with_capacity(
             8 * 4096,
-            hash::Write::new(out, kind.hash()),
+            hasher::io::Write::new(out, kind.hash()),
         ));
         out.write_all(V2_SIGNATURE)?;
         out.write_all(&(kind as u32).to_be_bytes())?;
diff --git a/gix-pack/src/index/write/mod.rs b/gix-pack/src/index/write/mod.rs
@@ -225,7 +225,7 @@ impl crate::index::File {
             Some(ph) => ph,
             None if num_objects == 0 => {
                 let header = crate::data::header::encode(pack_version, 0);
-                let mut hasher = gix_features::hash::hasher(object_hash);
+                let mut hasher = gix_hash::hasher(object_hash);
                 hasher.update(&header);
                 gix_hash::ObjectId::from(hasher.digest())
             }
diff --git a/gix-pack/src/multi_index/write.rs b/gix-pack/src/multi_index/write.rs
@@ -5,6 +5,7 @@ use std::{
 };
 
 use gix_features::progress::{Count, DynNestedProgress, Progress};
+use gix_hash::hasher;
 
 use crate::multi_index;
 
@@ -83,7 +84,7 @@ impl multi_index::File {
         should_interrupt: &AtomicBool,
         Options { object_hash }: Options,
     ) -> Result<Outcome, Error> {
-        let out = gix_features::hash::Write::new(out, object_hash);
+        let out = hasher::io::Write::new(out, object_hash);
         let (index_paths_sorted, index_filenames_sorted) = {
             index_paths.sort();
             let file_names = index_paths
diff --git a/gix-pack/src/verify.rs b/gix-pack/src/verify.rs
@@ -37,7 +37,7 @@ pub fn checksum_on_disk_or_mmap(
     should_interrupt: &AtomicBool,
 ) -> Result<gix_hash::ObjectId, checksum::Error> {
     let data_len_without_trailer = data.len() - object_hash.len_in_bytes();
-    let actual = match gix_features::hash::bytes_of_file(
+    let actual = match gix_hash::bytes_of_file(
         data_path,
         data_len_without_trailer as u64,
         object_hash,
@@ -48,7 +48,7 @@ pub fn checksum_on_disk_or_mmap(
         Err(err) if err.kind() == std::io::ErrorKind::Interrupted => return Err(checksum::Error::Interrupted),
         Err(_io_err) => {
             let start = std::time::Instant::now();
-            let mut hasher = gix_features::hash::hasher(object_hash);
+            let mut hasher = gix_hash::hasher(object_hash);
             hasher.update(&data[..data_len_without_trailer]);
             progress.inc_by(data_len_without_trailer);
             progress.show_throughput(start);

Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ pub fn decode(data: &[u8], object_hash: gix_hash::Kind) -> Option<usize> {`
`33`	`33`	`return None;`
`34`	`34`	`}`
`35`	`35`
`36`		`- let mut hasher = gix_features::hash::hasher(gix_hash::Kind::Sha1);`
	`36`	`+ let mut hasher = gix_hash::hasher(gix_hash::Kind::Sha1);`
`37`	`37`	`let mut last_chunk = None;`
`38`	`38`	`for (signature, chunk) in extension::Iter::new(&data[offset..data.len() - MIN_SIZE_WITH_HEADER - hash_len]) {`
`39`	`39`	`hasher.update(&signature);`