Formatting.

src/lib.rs

@@ -17,14 +17,8 @@ mod signatures;
 pub use merkle::Proof;
 
 pub use lamport_sigs::PublicKey;
-pub use signatures::{
-    MerklePublicKey,
-    MerkleSignature,
-    MerkleSignedData,
-    verify_data_vec_signature,
-    sign_data_vec
-};
+pub use signatures::{MerklePublicKey, MerkleSignature, MerkleSignedData,
+                     verify_data_vec_signature, sign_data_vec};
 
 #[cfg(test)]
 mod tests;
-

src/signatures.rs

@@ -14,15 +14,13 @@ pub struct MerklePublicKey {
 impl MerklePublicKey {
     /// Convenience method to wrap a Lamport `PublicKey` into a `MerklePublicKey`
     pub fn new(pk: PublicKey) -> MerklePublicKey {
-        MerklePublicKey{
-            key: pk
-        }
+        MerklePublicKey { key: pk }
     }
 }
 
 impl Hashable for MerklePublicKey {
     fn update_context(&self, context: &mut Context) {
-         context.update(&self.key.to_bytes());
+        context.update(&self.key.to_bytes());
     }
 }
 
@@ -39,12 +37,20 @@ pub type MerkleSignature = (LamportSignatureData, Proof<MerklePublicKey>);
 pub type MerkleSignedData<T> = (Vec<T>, MerkleSignature);
 
 fn signing_error(reason: &str) -> Error {
-    Error::new(ErrorKind::Other, format!("A signature could not be produced because {}", reason))
+    Error::new(
+        ErrorKind::Other,
+        format!("A signature could not be produced because {}", reason),
+    )
 }
 
 /// Signs the entries of the data vector
-pub fn sign_data_vec<T>(data: &Vec<T>, algorithm: &'static Algorithm) -> io::Result<Vec<MerkleSignature>>
-        where T: AsRef<[u8]> {
+pub fn sign_data_vec<T>(
+    data: &Vec<T>,
+    algorithm: &'static Algorithm,
+) -> io::Result<Vec<MerkleSignature>>
+where
+    T: AsRef<[u8]>,
+{
 
     let mut leaf_keys = (0..data.len())
         .map(|_| PrivateKey::new(algorithm))
@@ -52,34 +58,40 @@ pub fn sign_data_vec<T>(data: &Vec<T>, algorithm: &'static Algorithm) -> io::Res
 
     debug_assert!(data.len() == leaf_keys.len());
 
-    let leaf_pub_keys = leaf_keys.iter()
+    let leaf_pub_keys = leaf_keys
+        .iter()
         .map(|priv_key| priv_key.public_key())
         .collect::<Vec<_>>();
 
-    let wrapped_leafs = leaf_pub_keys.clone().into_iter()
+    let wrapped_leafs = leaf_pub_keys
+        .clone()
+        .into_iter()
         .map(|pk| MerklePublicKey::new(pk))
         .collect::<Vec<_>>();
 
     let tree = MerkleTree::from_vec(algorithm, wrapped_leafs);
 
-    let proofs_opt = leaf_pub_keys.into_iter()
+    let proofs_opt = leaf_pub_keys
+        .into_iter()
         .map(|pub_key| tree.gen_proof(MerklePublicKey::new(pub_key)))
         .collect::<Option<Vec<_>>>();
 
-    let signatures_opt = leaf_keys.iter_mut()
+    let signatures_opt = leaf_keys
+        .iter_mut()
         .zip(data.iter())
         .map(|(mut priv_key, data)| priv_key.sign(data.as_ref()))
         .collect::<Result<Vec<_>, _>>();
 
     match (signatures_opt, proofs_opt) {
-        (_, None) =>
-            Err(signing_error("an issue occured while generating the inclusion proofs.")),
+        (_, None) => Err(signing_error(
+            "an issue occured while generating the inclusion proofs.",
+        )),
 
-        (Err(err), _) =>
-            Err(signing_error(&format!("an issue occured while signing the data: {}", err))),
+        (Err(err), _) => Err(signing_error(
+            &format!("an issue occured while signing the data: {}", err),
+        )),
 
-        (Ok(signatures), Some(proofs)) =>
-            Ok(signatures.into_iter().zip(proofs).collect())
+        (Ok(signatures), Some(proofs)) => Ok(signatures.into_iter().zip(proofs).collect()),
     }
 }
 
@@ -88,15 +100,21 @@ fn verif_error(reason: &str) -> Error {
 }
 
 /// Verifies the signature of the data. Returns an error if data couldn't be verified.
-pub fn verify_data_vec_signature<T>(data: T, signature: &MerkleSignature, root_hash: &Vec<u8>) -> io::Result<()>
-        where T: Into<Vec<u8>> {
+pub fn verify_data_vec_signature<T>(
+    data: T,
+    signature: &MerkleSignature,
+    root_hash: &Vec<u8>,
+) -> io::Result<()>
+where
+    T: Into<Vec<u8>>,
+{
 
     let (ref sig, ref proof) = *signature;
 
     let valid_root = proof.validate(root_hash);
-    let data_vec   = data.into();
+    let data_vec = data.into();
 
-    let valid_sig  = proof.value.key.verify_signature(sig, data_vec.as_slice());
+    let valid_sig = proof.value.key.verify_signature(sig, data_vec.as_slice());
 
     if !valid_root {
         return Err(verif_error("The inclusion proof failed to validate."));

src/tests.rs

@@ -64,7 +64,9 @@ fn serialization() {
 
     let proof_bytes = proof.clone().write_to_bytes().unwrap();
 
-    let p = Proof::<Vec<u8>>::parse_from_bytes(&proof_bytes, digest).unwrap().unwrap();
+    let p = Proof::<Vec<u8>>::parse_from_bytes(&proof_bytes, digest)
+        .unwrap()
+        .unwrap();
 
     let proof2 = Proof {
         algorithm: digest,