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,46 @@
+[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"]
+identity = []
+
+[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,27 +1,22 @@
-use crate::hasher::Hasher;
-
-#[cfg(feature = "std")]
-use std::io;
-
-#[cfg(not(feature = "std"))]
-use core2::io;
-
+#[cfg(any(feature = "strobe", feature = "identity", feature = "blake3"))]
 macro_rules! derive_write {
     ($name:ident) => {
-        impl<const S: usize> io::Write for $name<S> {
-            fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        impl<const S: usize> core2::io::Write for $name<S> {
+            fn write(&mut self, buf: &[u8]) -> core2::io::Result<usize> {
+                use multihash_derive::Hasher as _;
+
                 self.update(buf);
                 Ok(buf.len())
             }
 
-            fn flush(&mut self) -> io::Result<()> {
+            fn flush(&mut self) -> core2::io::Result<()> {
                 Ok(())
             }
         }
     };
 }
 
-#[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.
@@ -42,7 +37,7 @@ macro_rules! derive_hasher_blake {
             }
         }
 
-        impl<const S: usize> Hasher for $name<S> {
+        impl<const S: usize> multihash_derive::Hasher for $name<S> {
             fn update(&mut self, input: &[u8]) {
                 self.state.update(input);
             }
@@ -67,8 +62,6 @@ macro_rules! derive_hasher_blake {
 
 #[cfg(feature = "blake2b")]
 pub mod blake2b {
-    use super::*;
-
     derive_hasher_blake!(blake2b_simd, Blake2bHasher);
 
     /// 256 bit blake2b hasher.
@@ -80,8 +73,6 @@ pub mod blake2b {
 
 #[cfg(feature = "blake2s")]
 pub mod blake2s {
-    use super::*;
-
     derive_hasher_blake!(blake2s_simd, Blake2sHasher);
 
     /// 256 bit blake2b hasher.
@@ -93,8 +84,6 @@ pub mod blake2s {
 
 #[cfg(feature = "blake3")]
 pub mod blake3 {
-    use super::*;
-
     /// Multihash hasher.
     #[derive(Debug)]
     pub struct Blake3Hasher<const S: usize> {
@@ -121,7 +110,7 @@ pub mod blake3 {
         }
     }
 
-    impl<const S: usize> Hasher for Blake3Hasher<S> {
+    impl<const S: usize> multihash_derive::Hasher for Blake3Hasher<S> {
         fn update(&mut self, input: &[u8]) {
             self.hasher.update(input);
         }
@@ -143,7 +132,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 +156,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)
@@ -183,13 +177,15 @@ macro_rules! derive_rustcrypto_hasher {
             }
         }
 
-        impl io::Write for $name {
-            fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        impl core2::io::Write for $name {
+            fn write(&mut self, buf: &[u8]) -> core2::io::Result<usize> {
+                use multihash_derive::Hasher as _;
+
                 self.update(buf);
                 Ok(buf.len())
             }
 
-            fn flush(&mut self) -> io::Result<()> {
+            fn flush(&mut self) -> core2::io::Result<()> {
                 Ok(())
             }
         }
@@ -198,47 +194,37 @@ macro_rules! derive_rustcrypto_hasher {
 
 #[cfg(feature = "sha1")]
 pub mod sha1 {
-    use super::*;
-
     derive_rustcrypto_hasher!(::sha1::Sha1, Sha1, 20);
 }
 
 #[cfg(feature = "sha2")]
 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!(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::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!(::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);
 }
 
+#[cfg(feature = "identity")]
 pub mod identity {
-    use super::*;
-
     /// Identity hasher with a maximum size.
     ///
     /// # Panics
@@ -259,7 +245,7 @@ pub mod identity {
         }
     }
 
-    impl<const S: usize> Hasher for IdentityHasher<S> {
+    impl<const S: usize> multihash_derive::Hasher for IdentityHasher<S> {
         fn update(&mut self, input: &[u8]) {
             let start = self.i.min(self.bytes.len());
             let end = (self.i + input.len()).min(self.bytes.len());
@@ -288,7 +274,6 @@ pub mod identity {
 
 #[cfg(feature = "strobe")]
 pub mod strobe {
-    use super::*;
     use strobe_rs::{SecParam, Strobe};
 
     /// Strobe hasher.
@@ -308,7 +293,7 @@ pub mod strobe {
         }
     }
 
-    impl<const S: usize> Hasher for StrobeHasher<S> {
+    impl<const S: usize> multihash_derive::Hasher for StrobeHasher<S> {
         fn update(&mut self, input: &[u8]) {
             self.strobe.ad(input, self.initialized);
             self.initialized = true;