feat!: split crates into multiple to isolate breaking changes

Cargo.toml

@@ -1,5 +1,6 @@
 [workspace]
-members = ["derive", "."]
+members = ["derive", "derive-impl", ".", "codetable"]
+resolver = "2"
 
 [package]
 name = "multihash"
@@ -15,56 +16,28 @@ edition = "2021"
 rust-version = "1.59"
 
 [features]
-default = ["std", "derive", "multihash-impl", "secure-hashes"]
-std = ["unsigned-varint/std", "multihash-derive/std", "alloc"]
-alloc = ["core2/alloc"]
-multihash-impl = ["derive"]
-derive = ["multihash-derive"]
-arb = ["quickcheck", "rand", "arbitrary"]
-secure-hashes = ["blake2b", "blake2s", "blake3", "sha2", "sha3"]
-scale-codec = ["parity-scale-codec"]
-serde-codec = ["serde", "serde-big-array"]
-
-blake2b = ["blake2b_simd"]
-blake2s = ["blake2s_simd"]
-identity = []
-sha1 = ["digest", "sha-1"]
-sha2 = ["digest", "sha-2"]
-sha3 = ["digest", "sha-3"]
-strobe = ["strobe-rs"]
-ripemd = ["ripemd-rs"]
+default = ["std"]
+std = ["unsigned-varint/std", "alloc"]
+alloc = []
+arb = ["dep:quickcheck", "dep:rand", "dep:arbitrary"]
+scale-codec = ["dep:parity-scale-codec"]
+serde-codec = ["serde"] # Deprecated, don't use.
+serde = ["dep:serde", "dep:serde-big-array"]
 
 [dependencies]
 parity-scale-codec = { version = "3.0.0", default-features = false, features = ["derive"], optional = true }
 quickcheck = { version = "1.0.3", optional = true }
 rand = { version = "0.8.5", optional = true, features = ["small_rng"] }
 serde = { version = "1.0.116", optional = true, default-features = false, features = ["derive"] }
 serde-big-array = { version = "0.3.2", optional = true, features = ["const-generics"] }
-multihash-derive = { version = "0.8.0", path = "derive", default-features = false, optional = true }
 unsigned-varint = { version = "0.7.1", default-features = false }
 arbitrary = {version = "1.1.0", optional = true }
 
-blake2b_simd = { version = "1.0.0", default-features = false, optional = true }
-blake2s_simd = { version = "1.0.0", default-features = false, optional = true }
-blake3 = { version = "1.2.0", default-features = false, optional = true }
-digest = { version = "0.10.1", default-features = false, optional = true }
-sha-1 = { version = "0.10.0", default-features = false, optional = true }
-sha-2 = { version = "0.10.0", default-features = false, optional = true, package = "sha2" }
-sha-3 = { version = "0.10.0", default-features = false, optional = true, package = "sha3" }
-strobe-rs = { version = "0.7.0", default-features = false, optional = true }
-ripemd-rs = { package = "ripemd", version = "0.1.1", optional = true}
-
 core2 = { version = "0.4.0", default-features = false }
 
 [dev-dependencies]
-criterion = "0.3.3"
 hex = "0.4.2"
 serde_json = "1.0.58"
 quickcheck = "1.0.3"
 rand = "0.8.5"
 arbitrary = "1.1.0"
-multihash = { path = ".", features = ["sha1", "strobe"] }
-
-[[bench]]
-name = "multihash"
-harness = false

codetable/Cargo.toml

@@ -0,0 +1,45 @@
+[package]
+name = "multihash-codetable"
+description = "Default multihash code-table with cryptographically secure hash implementations"
+version = "0.1.0"
+repository = "https://github.com/multiformats/rust-multihash"
+license = "MIT"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[features]
+default = ["std"]
+std = ["blake2b_simd?/std", "blake2s_simd?/std", "blake3?/std", "digest?/std", "sha-1?/std", "sha2?/std", "sha3?/std", "strobe-rs?/std", "ripemd?/std", "multihash-derive/std", "core2/std"]
+sha1 = ["dep:sha-1"]
+strobe = ["dep:strobe-rs"]
+blake2b = ["dep:blake2b_simd"]
+blake2s = ["dep:blake2s_simd"]
+
+[dependencies]
+blake2b_simd = { version = "1.0.0", default-features = false, optional = true }
+blake2s_simd = { version = "1.0.0", default-features = false, optional = true }
+blake3 = { version = "1.2.0", default-features = false, optional = true }
+digest = { version = "0.10.1", default-features = false, optional = true }
+sha-1 = { version = "0.10.0", default-features = false, optional = true }
+sha2 = { version = "0.10.0", default-features = false, optional = true }
+sha3 = { version = "0.10.0", default-features = false, optional = true }
+strobe-rs = { version = "0.7.0", default-features = false, optional = true }
+ripemd = { version = "0.1.1", default-features = false, optional = true }
+multihash-derive = { version = "0.8.0", path = "../derive", default-features = false }
+core2 = { version = "0.4.0", default-features = false }
+serde = { version = "1.0.158", features = ["derive"], optional = true }
+
+[dev-dependencies]
+hex = "0.4.2"
+unsigned-varint = { version = "0.7.1", default-features = false }
+criterion = "0.3.3"
+rand = "0.8.5"
+
+[[bench]]
+name = "multihash"
+harness = false
+
+[[test]]
+name = "lib"
+required-features = ["sha1", "sha2", "sha3", "ripemd", "strobe", "blake2b", "blake2s", "blake3"]

benches/multihash.rs → codetable/benches/multihash.rs

@@ -1,11 +1,12 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use rand::Rng;
 
-use multihash::{
-    Blake2b256, Blake2b512, Blake2s128, Blake2s256, Blake3_256, Hasher, Keccak224, Keccak256,
-    Keccak384, Keccak512, Sha1, Sha2_256, Sha2_512, Sha3_224, Sha3_256, Sha3_384, Sha3_512,
-    Strobe256, Strobe512,
+use multihash_codetable::{
+    Blake2b256, Blake2b512, Blake2s128, Blake2s256, Blake3_256, Keccak224, Keccak256, Keccak384,
+    Keccak512, Sha1, Sha2_256, Sha2_512, Sha3_224, Sha3_256, Sha3_384, Sha3_512, Strobe256,
+    Strobe512,
 };
+use multihash_derive::Hasher;
 
 macro_rules! group_digest {
     ($criterion:ident, $( $id:expr => $hash:ident, $input:expr)* ) => {{

examples/custom_table.rs → codetable/examples/custom_table.rs

@@ -1,7 +1,7 @@
 use std::convert::TryFrom;
 
-use multihash::derive::Multihash;
-use multihash::{Error, Hasher, MultihashDigest, MultihashGeneric, Sha2_256};
+use multihash_codetable::Sha2_256;
+use multihash_derive::{Hasher, MultihashDigest};
 
 // You can implement a custom hasher. This is a SHA2 256-bit hasher that returns a hash that is
 // truncated to 160 bits.
@@ -19,14 +19,14 @@ impl Hasher for Sha2_256Truncated20 {
     }
 }
 
-#[derive(Clone, Copy, Debug, Eq, Multihash, PartialEq)]
+#[derive(Clone, Copy, Debug, Eq, MultihashDigest, PartialEq)]
 #[mh(alloc_size = 64)]
 pub enum Code {
     /// Example for using a custom hasher which returns truncated hashes
     #[mh(code = 0x12, hasher = Sha2_256Truncated20)]
     Sha2_256Truncated20,
     /// Example for using a hasher with a bit size that is not exported by default
-    #[mh(code = 0xb219, hasher = multihash::Blake2bHasher::<25>)]
+    #[mh(code = 0xb219, hasher = multihash_codetable::Blake2bHasher::<25>)]
     Blake2b200,
 }
 

examples/manual_mh.rs → codetable/examples/manual_mh.rs

@@ -1,4 +1,5 @@
-use multihash::{Code, MultihashDigest};
+use multihash_codetable::Code;
+use multihash_derive::MultihashDigest;
 
 /// prefix/multihash generating tool to aid when adding new tests
 fn prefix_util() {

src/hasher_impl.rs → codetable/src/hasher_impl.rs

@@ -1,9 +1,5 @@
-use crate::hasher::Hasher;
+use multihash_derive::Hasher;
 
-#[cfg(feature = "std")]
-use std::io;
-
-#[cfg(not(feature = "std"))]
 use core2::io;
 
 macro_rules! derive_write {
@@ -21,7 +17,7 @@ macro_rules! derive_write {
     };
 }
 
-#[cfg(any(feature = "blake2b", feature = "blake2s"))]
+#[cfg(any(feature = "blake2b", feature = "blake2s", feature = "blake3"))]
 macro_rules! derive_hasher_blake {
     ($module:ident, $name:ident) => {
         /// Multihash hasher.
@@ -143,7 +139,12 @@ pub mod blake3 {
     pub type Blake3_256 = Blake3Hasher<32>;
 }
 
-#[cfg(feature = "digest")]
+#[cfg(any(
+    feature = "sha1",
+    feature = "sha2",
+    feature = "sha3",
+    feature = "ripemd"
+))]
 macro_rules! derive_rustcrypto_hasher {
     ($module:ty, $name:ident, $size:expr) => {
         /// Multihash hasher.
@@ -162,7 +163,7 @@ macro_rules! derive_rustcrypto_hasher {
             }
         }
 
-        impl $crate::hasher::Hasher for $name {
+        impl ::multihash_derive::Hasher for $name {
             fn update(&mut self, input: &[u8]) {
                 use digest::Digest;
                 self.state.update(input)
@@ -207,33 +208,33 @@ pub mod sha1 {
 pub mod sha2 {
     use super::*;
 
-    derive_rustcrypto_hasher!(sha_2::Sha256, Sha2_256, 32);
-    derive_rustcrypto_hasher!(sha_2::Sha512, Sha2_512, 64);
+    derive_rustcrypto_hasher!(::sha2::Sha256, Sha2_256, 32);
+    derive_rustcrypto_hasher!(::sha2::Sha512, Sha2_512, 64);
 }
 
 #[cfg(feature = "sha3")]
 pub mod sha3 {
     use super::*;
 
-    derive_rustcrypto_hasher!(sha_3::Sha3_224, Sha3_224, 28);
-    derive_rustcrypto_hasher!(sha_3::Sha3_256, Sha3_256, 32);
-    derive_rustcrypto_hasher!(sha_3::Sha3_384, Sha3_384, 48);
-    derive_rustcrypto_hasher!(sha_3::Sha3_512, Sha3_512, 64);
+    derive_rustcrypto_hasher!(::sha3::Sha3_224, Sha3_224, 28);
+    derive_rustcrypto_hasher!(::sha3::Sha3_256, Sha3_256, 32);
+    derive_rustcrypto_hasher!(::sha3::Sha3_384, Sha3_384, 48);
+    derive_rustcrypto_hasher!(::sha3::Sha3_512, Sha3_512, 64);
 
-    derive_rustcrypto_hasher!(sha_3::Keccak224, Keccak224, 28);
-    derive_rustcrypto_hasher!(sha_3::Keccak256, Keccak256, 32);
-    derive_rustcrypto_hasher!(sha_3::Keccak384, Keccak384, 48);
-    derive_rustcrypto_hasher!(sha_3::Keccak512, Keccak512, 64);
+    derive_rustcrypto_hasher!(::sha3::Keccak224, Keccak224, 28);
+    derive_rustcrypto_hasher!(::sha3::Keccak256, Keccak256, 32);
+    derive_rustcrypto_hasher!(::sha3::Keccak384, Keccak384, 48);
+    derive_rustcrypto_hasher!(::sha3::Keccak512, Keccak512, 64);
 }
 
 #[cfg(feature = "ripemd")]
 pub mod ripemd {
 
     use super::*;
 
-    derive_rustcrypto_hasher!(ripemd_rs::Ripemd160, Ripemd160, 20);
-    derive_rustcrypto_hasher!(ripemd_rs::Ripemd256, Ripemd256, 32);
-    derive_rustcrypto_hasher!(ripemd_rs::Ripemd320, Ripemd320, 40);
+    derive_rustcrypto_hasher!(::ripemd::Ripemd160, Ripemd160, 20);
+    derive_rustcrypto_hasher!(::ripemd::Ripemd256, Ripemd256, 32);
+    derive_rustcrypto_hasher!(::ripemd::Ripemd320, Ripemd320, 40);
 }
 
 pub mod identity {

src/multihash_impl.rs → codetable/src/lib.rs

@@ -1,14 +1,37 @@
-pub use multihash_derive::Multihash;
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod hasher_impl;
+
+use multihash_derive::MultihashDigest;
+
+#[cfg(feature = "blake2b")]
+pub use crate::hasher_impl::blake2b::{Blake2b256, Blake2b512, Blake2bHasher};
+#[cfg(feature = "blake2s")]
+pub use crate::hasher_impl::blake2s::{Blake2s128, Blake2s256, Blake2sHasher};
+#[cfg(feature = "blake3")]
+pub use crate::hasher_impl::blake3::{Blake3Hasher, Blake3_256};
+pub use crate::hasher_impl::identity::{Identity256, IdentityHasher};
+#[cfg(feature = "ripemd")]
+pub use crate::hasher_impl::ripemd::{Ripemd160, Ripemd256, Ripemd320};
+#[cfg(feature = "sha1")]
+pub use crate::hasher_impl::sha1::Sha1;
+#[cfg(feature = "sha2")]
+pub use crate::hasher_impl::sha2::{Sha2_256, Sha2_512};
+#[cfg(feature = "sha3")]
+pub use crate::hasher_impl::sha3::{
+    Keccak224, Keccak256, Keccak384, Keccak512, Sha3_224, Sha3_256, Sha3_384, Sha3_512,
+};
+#[cfg(feature = "strobe")]
+pub use crate::hasher_impl::strobe::{Strobe256, Strobe512, StrobeHasher};
 
 /// Default (cryptographically secure) Multihash implementation.
 ///
 /// This is a default set of hashing algorithms. Usually applications would use their own subset of
-/// algorithms. See the [`Multihash` derive] for more information.
+/// algorithms. See the [`multihash-derive`] crate for more information.
 ///
-/// [`Multihash` derive]: crate::derive
-#[cfg_attr(feature = "serde-codec", derive(serde::Deserialize))]
-#[cfg_attr(feature = "serde-codec", derive(serde::Serialize))]
-#[derive(Copy, Clone, Debug, Eq, Multihash, PartialEq)]
+/// [`multihash-derive`]: https://docs.rs/multihash-derive
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Copy, Clone, Debug, Eq, MultihashDigest, PartialEq)]
 #[mh(alloc_size = 64)]
 pub enum Code {
     /// SHA-256 (32-byte hash size)
@@ -83,22 +106,20 @@ pub enum Code {
     #[cfg(feature = "ripemd")]
     #[mh(code = 0x1055, hasher = crate::Ripemd320)]
     Ripemd320,
-
     // The following hashes are not cryptographically secure hashes and are not enabled by default
     /// Identity hash (max. 64 bytes)
-    #[cfg(feature = "identity")]
     #[mh(code = 0x00, hasher = crate::IdentityHasher::<64>)]
     Identity,
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::hasher::Hasher;
     use crate::hasher_impl::sha3::{Sha3_256, Sha3_512};
-    use crate::multihash::MultihashDigest;
+    use multihash_derive::{Hasher, Multihash, MultihashDigest};
 
     #[test]
+    #[cfg(feature = "sha3")]
     fn test_hasher_256() {
         let mut hasher = Sha3_256::default();
         hasher.update(b"hello world");
@@ -112,6 +133,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(feature = "sha3")]
     fn test_hasher_512() {
         let mut hasher = Sha3_512::default();
         hasher.update(b"hello world");
@@ -123,4 +145,52 @@ mod tests {
         assert_eq!(hash.digest(), digest);
         assert_eq!(hash, hash2);
     }
+
+    #[test]
+    #[cfg(feature = "sha2")]
+    fn roundtrip() {
+        let hash = Code::Sha2_256.digest(b"hello world");
+        let mut buf = [0u8; 35];
+        let written = hash.write(&mut buf[..]).unwrap();
+        let hash2 = Multihash::<32>::read(&buf[..]).unwrap();
+        assert_eq!(hash, hash2);
+        assert_eq!(hash.encoded_len(), written);
+    }
+
+    #[test]
+    #[cfg(feature = "sha2")]
+    fn test_truncate_down() {
+        let hash = Code::Sha2_256.digest(b"hello world");
+        let small = hash.truncate(20);
+        assert_eq!(small.size(), 20);
+    }
+
+    #[test]
+    #[cfg(feature = "sha2")]
+    fn test_truncate_up() {
+        let hash = Code::Sha2_256.digest(b"hello world");
+        let small = hash.truncate(100);
+        assert_eq!(small.size(), 32);
+    }
+
+    #[test]
+    #[cfg(feature = "sha2")]
+    fn test_resize_fits() {
+        let hash = Code::Sha2_256.digest(b"hello world");
+        let _: Multihash<32> = hash.resize().unwrap();
+    }
+
+    #[test]
+    #[cfg(feature = "sha2")]
+    fn test_resize_up() {
+        let hash = Code::Sha2_256.digest(b"hello world");
+        let _: Multihash<100> = hash.resize().unwrap();
+    }
+
+    #[test]
+    #[cfg(feature = "sha2")]
+    fn test_resize_truncate() {
+        let hash = Code::Sha2_256.digest(b"hello world");
+        hash.resize::<20>().unwrap_err();
+    }
 }