change!: move the hashing API to gix_hash

This will soon not be dependent on any feature configuration. I
wasn’t sure the ideal crate to put this in, but after checking
reverse dependencies on crates.io, it seems like there’s essentially
no user of `gix-hash` that wouldn’t be pulling in a hashing
implementation anyway, so I think this is a fine and logical place
for it to be.

I named the module `gix_hash::hasher` since `gix_hash::hash` seemed
like it would be confusing. This does mean that there is a function
and module with the same name, which is permitted but perhaps a
little strange.

Everything is re‐exported directly other than
`gix_features::hash::Write`, which moves along with the I/O
convenience functions into a new public submodule and becomes
`gix_hash::hasher::io::Write`, as that seems like a clearer name
to me, being akin to the `gix_hash::hasher` function but as an
`std::io::Write` wrapper.

Author: emilazy

Cargo.lock

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

gix-commitgraph/src/file/verify.rs

@@ -121,7 +121,6 @@ path = "tests/pipe.rs"
 required-features = ["io-pipe"]
 
 [dependencies]
-gix-hash = { version = "^0.16.0", path = "../gix-hash" }
 gix-trace = { version = "^0.1.12", path = "../gix-trace" }
 
 # for walkdir

gix-features/Cargo.toml

@@ -71,132 +71,3 @@ pub fn crc32(bytes: &[u8]) -> u32 {
     h.update(bytes);
     h.finalize()
 }
-
-/// Produce a hasher suitable for the given kind of hash.
-#[cfg(any(feature = "rustsha1", feature = "fast-sha1"))]
-pub fn hasher(kind: gix_hash::Kind) -> Hasher {
-    match kind {
-        gix_hash::Kind::Sha1 => Hasher::default(),
-    }
-}
-
-/// Compute the hash of `kind` for the bytes in the file at `path`, hashing only the first `num_bytes_from_start`
-/// while initializing and calling `progress`.
-///
-/// `num_bytes_from_start` is useful to avoid reading trailing hashes, which are never part of the hash itself,
-/// denoting the amount of bytes to hash starting from the beginning of the file.
-///
-/// # Note
-///
-/// * Only available with the `gix-object` feature enabled due to usage of the [`gix_hash::Kind`] enum and the
-///   [`gix_hash::ObjectId`] return value.
-/// * [Interrupts][crate::interrupt] are supported.
-#[cfg(all(feature = "progress", any(feature = "rustsha1", feature = "fast-sha1")))]
-pub fn bytes_of_file(
-    path: &std::path::Path,
-    num_bytes_from_start: u64,
-    kind: gix_hash::Kind,
-    progress: &mut dyn crate::progress::Progress,
-    should_interrupt: &std::sync::atomic::AtomicBool,
-) -> std::io::Result<gix_hash::ObjectId> {
-    bytes(
-        &mut std::fs::File::open(path)?,
-        num_bytes_from_start,
-        kind,
-        progress,
-        should_interrupt,
-    )
-}
-
-/// Similar to [`bytes_of_file`], but operates on a stream of bytes.
-#[cfg(all(feature = "progress", any(feature = "rustsha1", feature = "fast-sha1")))]
-pub fn bytes(
-    read: &mut dyn std::io::Read,
-    num_bytes_from_start: u64,
-    kind: gix_hash::Kind,
-    progress: &mut dyn crate::progress::Progress,
-    should_interrupt: &std::sync::atomic::AtomicBool,
-) -> std::io::Result<gix_hash::ObjectId> {
-    bytes_with_hasher(read, num_bytes_from_start, hasher(kind), progress, should_interrupt)
-}
-
-/// Similar to [`bytes()`], but takes a `hasher` instead of a hash kind.
-#[cfg(all(feature = "progress", any(feature = "rustsha1", feature = "fast-sha1")))]
-pub fn bytes_with_hasher(
-    read: &mut dyn std::io::Read,
-    num_bytes_from_start: u64,
-    mut hasher: Hasher,
-    progress: &mut dyn crate::progress::Progress,
-    should_interrupt: &std::sync::atomic::AtomicBool,
-) -> std::io::Result<gix_hash::ObjectId> {
-    let start = std::time::Instant::now();
-    // init progress before the possibility for failure, as convenience in case people want to recover
-    progress.init(
-        Some(num_bytes_from_start as prodash::progress::Step),
-        crate::progress::bytes(),
-    );
-
-    const BUF_SIZE: usize = u16::MAX as usize;
-    let mut buf = [0u8; BUF_SIZE];
-    let mut bytes_left = num_bytes_from_start;
-
-    while bytes_left > 0 {
-        let out = &mut buf[..BUF_SIZE.min(bytes_left as usize)];
-        read.read_exact(out)?;
-        bytes_left -= out.len() as u64;
-        progress.inc_by(out.len());
-        hasher.update(out);
-        if should_interrupt.load(std::sync::atomic::Ordering::SeqCst) {
-            return Err(std::io::Error::new(std::io::ErrorKind::Other, "Interrupted"));
-        }
-    }
-
-    let id = gix_hash::ObjectId::from(hasher.digest());
-    progress.show_throughput(start);
-    Ok(id)
-}
-
-#[cfg(any(feature = "rustsha1", feature = "fast-sha1"))]
-mod write {
-    use crate::hash::Hasher;
-
-    /// A utility to automatically generate a hash while writing into an inner writer.
-    pub struct Write<T> {
-        /// The hash implementation.
-        pub hash: Hasher,
-        /// The inner writer.
-        pub inner: T,
-    }
-
-    impl<T> std::io::Write for Write<T>
-    where
-        T: std::io::Write,
-    {
-        fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-            let written = self.inner.write(buf)?;
-            self.hash.update(&buf[..written]);
-            Ok(written)
-        }
-
-        fn flush(&mut self) -> std::io::Result<()> {
-            self.inner.flush()
-        }
-    }
-
-    impl<T> Write<T>
-    where
-        T: std::io::Write,
-    {
-        /// Create a new hash writer which hashes all bytes written to `inner` with a hash of `kind`.
-        pub fn new(inner: T, object_hash: gix_hash::Kind) -> Self {
-            match object_hash {
-                gix_hash::Kind::Sha1 => Write {
-                    inner,
-                    hash: Hasher::default(),
-                },
-            }
-        }
-    }
-}
-#[cfg(any(feature = "rustsha1", feature = "fast-sha1"))]
-pub use write::Write;

gix-features/src/hash.rs

@@ -20,6 +20,8 @@ test = false
 serde = ["dep:serde"]
 
 [dependencies]
+gix-features = { version = "^0.40.0", path = "../gix-features", features = ["rustsha1", "progress"] }
+
 thiserror = "2.0.0"
 faster-hex = { version = "0.9.0" }
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }

gix-hash/Cargo.toml

@@ -0,0 +1,110 @@
+use crate::{hasher, Hasher};
+
+/// Compute the hash of `kind` for the bytes in the file at `path`, hashing only the first `num_bytes_from_start`
+/// while initializing and calling `progress`.
+///
+/// `num_bytes_from_start` is useful to avoid reading trailing hashes, which are never part of the hash itself,
+/// denoting the amount of bytes to hash starting from the beginning of the file.
+///
+/// # Note
+///
+/// * [Interrupts][gix_features::interrupt] are supported.
+pub fn bytes_of_file(
+    path: &std::path::Path,
+    num_bytes_from_start: u64,
+    kind: crate::Kind,
+    progress: &mut dyn gix_features::progress::Progress,
+    should_interrupt: &std::sync::atomic::AtomicBool,
+) -> std::io::Result<crate::ObjectId> {
+    bytes(
+        &mut std::fs::File::open(path)?,
+        num_bytes_from_start,
+        kind,
+        progress,
+        should_interrupt,
+    )
+}
+
+/// Similar to [`bytes_of_file`], but operates on a stream of bytes.
+pub fn bytes(
+    read: &mut dyn std::io::Read,
+    num_bytes_from_start: u64,
+    kind: crate::Kind,
+    progress: &mut dyn gix_features::progress::Progress,
+    should_interrupt: &std::sync::atomic::AtomicBool,
+) -> std::io::Result<crate::ObjectId> {
+    bytes_with_hasher(read, num_bytes_from_start, hasher(kind), progress, should_interrupt)
+}
+
+/// Similar to [`bytes()`], but takes a `hasher` instead of a hash kind.
+pub fn bytes_with_hasher(
+    read: &mut dyn std::io::Read,
+    num_bytes_from_start: u64,
+    mut hasher: Hasher,
+    progress: &mut dyn gix_features::progress::Progress,
+    should_interrupt: &std::sync::atomic::AtomicBool,
+) -> std::io::Result<crate::ObjectId> {
+    let start = std::time::Instant::now();
+    // init progress before the possibility for failure, as convenience in case people want to recover
+    progress.init(
+        Some(num_bytes_from_start as gix_features::progress::prodash::progress::Step),
+        gix_features::progress::bytes(),
+    );
+
+    const BUF_SIZE: usize = u16::MAX as usize;
+    let mut buf = [0u8; BUF_SIZE];
+    let mut bytes_left = num_bytes_from_start;
+
+    while bytes_left > 0 {
+        let out = &mut buf[..BUF_SIZE.min(bytes_left as usize)];
+        read.read_exact(out)?;
+        bytes_left -= out.len() as u64;
+        progress.inc_by(out.len());
+        hasher.update(out);
+        if should_interrupt.load(std::sync::atomic::Ordering::SeqCst) {
+            return Err(std::io::Error::new(std::io::ErrorKind::Other, "Interrupted"));
+        }
+    }
+
+    let id = crate::ObjectId::from(hasher.digest());
+    progress.show_throughput(start);
+    Ok(id)
+}
+
+/// A utility to automatically generate a hash while writing into an inner writer.
+pub struct Write<T> {
+    /// The hash implementation.
+    pub hash: Hasher,
+    /// The inner writer.
+    pub inner: T,
+}
+
+impl<T> std::io::Write for Write<T>
+where
+    T: std::io::Write,
+{
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        let written = self.inner.write(buf)?;
+        self.hash.update(&buf[..written]);
+        Ok(written)
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        self.inner.flush()
+    }
+}
+
+impl<T> Write<T>
+where
+    T: std::io::Write,
+{
+    /// Create a new hash writer which hashes all bytes written to `inner` with a hash of `kind`.
+    pub fn new(inner: T, object_hash: crate::Kind) -> Self {
+        match object_hash {
+            crate::Kind::Sha1 => Write {
+                inner,
+                hash: Hasher::default(),
+            },
+        }
+    }
+}

gix-hash/src/hasher/io.rs

@@ -0,0 +1,24 @@
+/// A implementation of the Sha1 hash, which can be used once.
+#[derive(Default, Clone)]
+pub struct Hasher(gix_features::hash::Hasher);
+
+impl Hasher {
+    /// Digest the given `bytes`.
+    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()
+    }
+}
+
+/// Produce a hasher suitable for the given kind of hash.
+pub fn hasher(kind: crate::Kind) -> Hasher {
+    match kind {
+        crate::Kind::Sha1 => Hasher::default(),
+    }
+}
+
+/// Hashing utilities for I/O operations.
+pub mod io;

gix-hash/src/hasher/mod.rs

@@ -13,6 +13,11 @@
 mod borrowed;
 pub use borrowed::{oid, Error};
 
+///
+pub mod hasher;
+pub use hasher::io::{bytes, bytes_of_file, bytes_with_hasher};
+pub use hasher::{hasher, Hasher};
+
 mod object_id;
 pub use object_id::{decode, ObjectId};
 

gix-hash/src/lib.rs

@@ -45,8 +45,7 @@ mod from_hex {
 mod sha1 {
     use std::str::FromStr as _;
 
-    use gix_features::hash::hasher;
-    use gix_hash::{Kind, ObjectId};
+    use gix_hash::{hasher, Kind, ObjectId};
 
     fn hash_contents(s: &[u8]) -> ObjectId {
         let mut hasher = hasher(Kind::Sha1);

gix-hash/tests/object_id/mod.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);

gix-index/src/extension/end_of_index_entry/decode.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());

gix-index/src/extension/end_of_index_entry/write.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,

gix-index/src/file/init.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(),

gix-index/src/file/verify.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()))

gix-index/src/file/write.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)
 }