refactor!: split crates into multiple to isolate breaking changes (#272)

This is a huge refactor that splits things into sparate crates, so that the
core crates will receive less breaking changes. It will also reduce the chance
to pull in features accidentally that are not desired.

The upgrade path will be documented in a later commit.

Author: thomaseizinger

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 renamed to 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 renamed to 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 renamed to 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 renamed to 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;