diff --git a/src/client.rs b/src/client.rs
index e014b92..fe83d2c 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -50,16 +50,17 @@
 
 use std::io::{Read, Write};
 
-use Result;
 use crypto::{self, KeyId};
 use error::Error;
 use interchange::DataInterchange;
-use metadata::{MetadataVersion, RootMetadata, Role, MetadataPath, VirtualTargetPath,
-               TargetDescription, TargetsMetadata, SnapshotMetadata, TargetPath};
+use metadata::{
+    MetadataPath, MetadataVersion, Role, RootMetadata, SnapshotMetadata, TargetDescription,
+    TargetPath, TargetsMetadata, VirtualTargetPath,
+};
 use repository::Repository;
 use tuf::Tuf;
 use util::SafeReader;
-
+use Result;
 
 /// Translates real paths (where a file is stored) into virtual paths (how it is addressed in TUF)
 /// and back.
@@ -267,8 +268,7 @@
             config.min_bytes_per_second,
             None,
         )?;
-        let latest_version = D::deserialize::<RootMetadata>(latest_root.signed())?
-            .version();
+        let latest_version = D::deserialize::<RootMetadata>(latest_root.signed())?.version();
 
         if latest_version < tuf.root().version() {
             return Err(Error::VerificationFailure(format!(
@@ -329,8 +329,7 @@
         let snapshot_description = match tuf.timestamp() {
             Some(ts) => Ok(ts.snapshot()),
             None => Err(Error::MissingMetadata(Role::Timestamp)),
-        }?
-            .clone();
+        }?.clone();
 
         if snapshot_description.version() <= tuf.snapshot().map(|s| s.version()).unwrap_or(0) {
             return Ok(false);
@@ -361,19 +360,16 @@
         U: PathTranslator,
     {
         let targets_description = match tuf.snapshot() {
-            Some(sn) => {
-                match sn.meta().get(&MetadataPath::from_role(&Role::Targets)) {
-                    Some(d) => Ok(d),
-                    None => Err(Error::VerificationFailure(
-                        "Snapshot metadata did not contain a description of the \
-                                current targets metadata."
-                            .into(),
-                    )),
-                }
-            }
+            Some(sn) => match sn.meta().get(&MetadataPath::from_role(&Role::Targets)) {
+                Some(d) => Ok(d),
+                None => Err(Error::VerificationFailure(
+                    "Snapshot metadata did not contain a description of the \
+                     current targets metadata."
+                        .into(),
+                )),
+            },
             None => Err(Error::MissingMetadata(Role::Snapshot)),
-        }?
-            .clone();
+        }?.clone();
 
         if targets_description.version() <= tuf.targets().map(|t| t.version()).unwrap_or(0) {
             return Ok(false);
@@ -452,17 +448,15 @@
             // tuf in the loop below
             let targets = match targets {
                 Some(t) => t.clone(),
-                None => {
-                    match tuf.targets() {
-                        Some(t) => t.clone(),
-                        None => {
-                            return (
-                                default_terminate,
-                                Err(Error::MissingMetadata(Role::Targets)),
-                            )
-                        }
+                None => match tuf.targets() {
+                    Some(t) => t.clone(),
+                    None => {
+                        return (
+                            default_terminate,
+                            Err(Error::MissingMetadata(Role::Targets)),
+                        )
                     }
-                }
+                },
             };
 
             if let Some(t) = targets.targets().get(target) {
@@ -536,13 +530,11 @@
                             &signed_meta,
                         ) {
                             Ok(_) => (),
-                            Err(e) => {
-                                warn!(
-                                    "Error storing metadata {:?} locally: {:?}",
-                                    delegation.role(),
-                                    e
-                                )
-                            }
+                            Err(e) => warn!(
+                                "Error storing metadata {:?} locally: {:?}",
+                                delegation.role(),
+                                e
+                            ),
                         }
 
                         let meta = tuf.delegations().get(delegation.role()).unwrap().clone();
@@ -566,7 +558,6 @@
                     }
                     Err(_) if !delegation.terminating() => continue,
                     Err(e) => return (true, Err(e)),
-
                 };
             }
 
@@ -764,7 +755,7 @@
     use chrono::prelude::*;
     use crypto::{PrivateKey, SignatureScheme};
     use interchange::Json;
-    use metadata::{RootMetadata, SignedMetadata, RoleDefinition, MetadataPath, MetadataVersion};
+    use metadata::{MetadataPath, MetadataVersion, RoleDefinition, RootMetadata, SignedMetadata};
     use repository::EphemeralRepository;
 
     lazy_static! {
@@ -777,8 +768,9 @@
                 include_bytes!("../tests/ed25519/ed25519-5.pk8.der"),
                 include_bytes!("../tests/ed25519/ed25519-6.pk8.der"),
             ];
-            keys.iter().map(|b| PrivateKey::from_pkcs8(b, SignatureScheme::Ed25519)
-                            .unwrap()).collect()
+            keys.iter()
+                .map(|b| PrivateKey::from_pkcs8(b, SignatureScheme::Ed25519).unwrap())
+                .collect()
         };
     }
 
@@ -795,8 +787,8 @@
             RoleDefinition::new(1, hashset!(KEYS[0].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[0].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
-            .unwrap();
+        let root: SignedMetadata<Json, RootMetadata> =
+            SignedMetadata::new(&root, &KEYS[0]).unwrap();
 
         repo.store_metadata(
             &MetadataPath::from_role(&Role::Root),
@@ -814,8 +806,8 @@
             RoleDefinition::new(1, hashset!(KEYS[1].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[1].key_id().clone())).unwrap(),
         ).unwrap();
-        let mut root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[1])
-            .unwrap();
+        let mut root: SignedMetadata<Json, RootMetadata> =
+            SignedMetadata::new(&root, &KEYS[1]).unwrap();
 
         root.add_signature(&KEYS[0]).unwrap();
 
@@ -835,8 +827,8 @@
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
         ).unwrap();
-        let mut root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[2])
-            .unwrap();
+        let mut root: SignedMetadata<Json, RootMetadata> =
+            SignedMetadata::new(&root, &KEYS[2]).unwrap();
 
         root.add_signature(&KEYS[1]).unwrap();
 
diff --git a/src/crypto.rs b/src/crypto.rs
index b893b96..3050122 100644
--- a/src/crypto.rs
+++ b/src/crypto.rs
@@ -5,11 +5,12 @@
 use ring;
 use ring::digest::{self, SHA256, SHA512};
 use ring::rand::SystemRandom;
-use ring::signature::{RSAKeyPair, RSASigningState, Ed25519KeyPair, ED25519,
-                      RSA_PSS_2048_8192_SHA256, RSA_PSS_2048_8192_SHA512, RSA_PSS_SHA256,
-                      RSA_PSS_SHA512};
+use ring::signature::{
+    ED25519, Ed25519KeyPair, RSAKeyPair, RSASigningState, RSA_PSS_2048_8192_SHA256,
+    RSA_PSS_2048_8192_SHA512, RSA_PSS_SHA256, RSA_PSS_SHA512,
+};
 use serde::de::{Deserialize, Deserializer, Error as DeserializeError};
-use serde::ser::{Serialize, Serializer, Error as SerializeError};
+use serde::ser::{Error as SerializeError, Serialize, Serializer};
 use std::cmp::Ordering;
 use std::collections::HashMap;
 use std::fmt::{self, Debug, Display};
@@ -20,9 +21,9 @@
 use std::sync::Arc;
 use untrusted::Input;
 
-use Result;
 use error::Error;
 use shims;
+use Result;
 
 const HASH_ALG_PREFS: &[HashAlgorithm] = &[HashAlgorithm::Sha512, HashAlgorithm::Sha256];
 
@@ -77,9 +78,12 @@
         let context = match *alg {
             HashAlgorithm::Sha256 => digest::Context::new(&SHA256),
             HashAlgorithm::Sha512 => digest::Context::new(&SHA512),
-            HashAlgorithm::Unknown(ref s) => return Err(Error::IllegalArgument(
-                format!("Unknown hash algorithm: {}", s)
-            )),
+            HashAlgorithm::Unknown(ref s) => {
+                return Err(Error::IllegalArgument(format!(
+                    "Unknown hash algorithm: {}",
+                    s
+                )))
+            }
         };
 
         let _ = hashes.insert(alg, context);
@@ -105,9 +109,7 @@
 
     let hashes = hashes
         .drain()
-        .map(|(k, v)| {
-            (k.clone(), HashValue::new(v.finish().as_ref().to_vec()))
-        })
+        .map(|(k, v)| (k.clone(), HashValue::new(v.finish().as_ref().to_vec())))
         .collect();
     Ok((size, hashes))
 }
@@ -320,9 +322,9 @@
 impl<'de> Deserialize<'de> for KeyType {
     fn deserialize<D: Deserializer<'de>>(de: D) -> ::std::result::Result<Self, D::Error> {
         let string: String = Deserialize::deserialize(de)?;
-        string.parse().map_err(|e| {
-            DeserializeError::custom(format!("{:?}", e))
-        })
+        string
+            .parse()
+            .map_err(|e| DeserializeError::custom(format!("{:?}", e)))
     }
 }
 
@@ -353,15 +355,11 @@
     /// Note: For RSA keys, `openssl` needs to the on the `$PATH`.
     pub fn new(key_type: KeyType) -> Result<Vec<u8>> {
         match key_type {
-            KeyType::Ed25519 => {
-                Ed25519KeyPair::generate_pkcs8(&SystemRandom::new())
-                    .map(|bytes| bytes.to_vec())
-                    .map_err(|_| Error::Opaque("Failed to generate Ed25519 key".into()))
-            },
+            KeyType::Ed25519 => Ed25519KeyPair::generate_pkcs8(&SystemRandom::new())
+                .map(|bytes| bytes.to_vec())
+                .map_err(|_| Error::Opaque("Failed to generate Ed25519 key".into())),
             KeyType::Rsa => Self::rsa_gen(),
-            KeyType::Unknown(s) => Err(Error::IllegalArgument(
-                format!("Unknown key type: {}", s)
-            )),
+            KeyType::Unknown(s) => Err(Error::IllegalArgument(format!("Unknown key type: {}", s))),
         }
     }
 
@@ -416,25 +414,19 @@
                 };
                 Ok(k)
             }
-            Err(e1) => {
-                match Self::rsa_from_pkcs8(der_key, scheme) {
-                    Ok(k) => Ok(k),
-                    Err(e2) => Err(Error::Opaque(format!(
-                        "Key was neither Ed25519 nor RSA: {:?} {:?}",
-                        e1,
-                        e2
-                    ))),
-                }
-            }
+            Err(e1) => match Self::rsa_from_pkcs8(der_key, scheme) {
+                Ok(k) => Ok(k),
+                Err(e2) => Err(Error::Opaque(format!(
+                    "Key was neither Ed25519 nor RSA: {:?} {:?}",
+                    e1, e2
+                ))),
+            },
         }
     }
 
     fn ed25519_from_pkcs8(der_key: &[u8]) -> Result<Self> {
-        let key = Ed25519KeyPair::from_pkcs8(Input::from(der_key)).map_err(
-            |_| {
-                Error::Encoding("Could not parse key as PKCS#8v2".into())
-            },
-        )?;
+        let key = Ed25519KeyPair::from_pkcs8(Input::from(der_key))
+            .map_err(|_| Error::Encoding("Could not parse key as PKCS#8v2".into()))?;
 
         let public = PublicKey {
             typ: KeyType::Ed25519,
@@ -444,10 +436,7 @@
         };
         let private = PrivateKeyType::Ed25519(key);
 
-        Ok(PrivateKey {
-            private,
-            public,
-        })
+        Ok(PrivateKey { private, public })
     }
 
     fn rsa_from_pkcs8(der_key: &[u8], scheme: SignatureScheme) -> Result<Self> {
@@ -457,9 +446,8 @@
             ));
         }
 
-        let key = RSAKeyPair::from_pkcs8(Input::from(der_key)).map_err(|_| {
-            Error::Encoding("Could not parse key as PKCS#8v2".into())
-        })?;
+        let key = RSAKeyPair::from_pkcs8(Input::from(der_key))
+            .map_err(|_| Error::Encoding("Could not parse key as PKCS#8v2".into()))?;
 
         if key.public_modulus_len() < 256 {
             return Err(Error::IllegalArgument(format!(
@@ -478,19 +466,15 @@
         };
         let private = PrivateKeyType::Rsa(Arc::new(key));
 
-        Ok(PrivateKey {
-            private,
-            public,
-        })
+        Ok(PrivateKey { private, public })
     }
 
     /// Sign a message.
     pub fn sign(&self, msg: &[u8]) -> Result<Signature> {
         let value = match (&self.private, &self.public.scheme) {
             (&PrivateKeyType::Rsa(ref rsa), &SignatureScheme::RsaSsaPssSha256) => {
-                let mut signing_state = RSASigningState::new(rsa.clone()).map_err(|_| {
-                    Error::Opaque("Could not initialize RSA signing state.".into())
-                })?;
+                let mut signing_state = RSASigningState::new(rsa.clone())
+                    .map_err(|_| Error::Opaque("Could not initialize RSA signing state.".into()))?;
                 let rng = SystemRandom::new();
                 let mut buf = vec![0; signing_state.key_pair().public_modulus_len()];
                 signing_state
@@ -499,9 +483,8 @@
                 SignatureValue(buf)
             }
             (&PrivateKeyType::Rsa(ref rsa), &SignatureScheme::RsaSsaPssSha512) => {
-                let mut signing_state = RSASigningState::new(rsa.clone()).map_err(|_| {
-                    Error::Opaque("Could not initialize RSA signing state.".into())
-                })?;
+                let mut signing_state = RSASigningState::new(rsa.clone())
+                    .map_err(|_| Error::Opaque("Could not initialize RSA signing state.".into()))?;
                 let rng = SystemRandom::new();
                 let mut buf = vec![0; signing_state.key_pair().public_modulus_len()];
                 signing_state
@@ -513,9 +496,10 @@
                 SignatureValue(ed.sign(msg).as_ref().into())
             }
             (k, s) => {
-                return Err(Error::IllegalArgument(
-                    format!("Key {:?} can't be used with scheme {:?}", k, s),
-                ))
+                return Err(Error::IllegalArgument(format!(
+                    "Key {:?} can't be used with scheme {:?}",
+                    k, s
+                )))
             }
         };
 
@@ -527,33 +511,23 @@
 
     fn rsa_gen() -> Result<Vec<u8>> {
         let gen = Command::new("openssl")
-            .args(
-                &[
-                    "genpkey",
-                    "-algorithm",
-                    "RSA",
-                    "-pkeyopt",
-                    "rsa_keygen_bits:4096",
-                    "-pkeyopt",
-                    "rsa_keygen_pubexp:65537",
-                    "-outform",
-                    "der",
-                ],
-            )
+            .args(&[
+                "genpkey",
+                "-algorithm",
+                "RSA",
+                "-pkeyopt",
+                "rsa_keygen_bits:4096",
+                "-pkeyopt",
+                "rsa_keygen_pubexp:65537",
+                "-outform",
+                "der",
+            ])
             .output()?;
 
         let mut pk8 = Command::new("openssl")
-            .args(
-                &[
-                    "pkcs8",
-                    "-inform",
-                    "der",
-                    "-topk8",
-                    "-nocrypt",
-                    "-outform",
-                    "der",
-                ],
-            )
+            .args(&[
+                "pkcs8", "-inform", "der", "-topk8", "-nocrypt", "-outform", "der",
+            ])
             .stdin(Stdio::piped())
             .stdout(Stdio::piped())
             .spawn()?;
@@ -566,7 +540,6 @@
         Ok(pk8.wait_with_output()?.stdout)
     }
 
-
     /// Return the public component of the key.
     pub fn public(&self) -> &PublicKey {
         &self.public
@@ -599,9 +572,8 @@
                 let typ = derp::nested(input, Tag::Sequence, |input| {
                     let typ = derp::expect_tag_and_get_value(input, Tag::Oid)?;
 
-                    let typ = KeyType::from_oid(typ.as_slice_less_safe()).map_err(|_| {
-                        derp::Error::WrongValue
-                    })?;
+                    let typ = KeyType::from_oid(typ.as_slice_less_safe())
+                        .map_err(|_| derp::Error::WrongValue)?;
 
                     // for RSA / ed25519 this is null, so don't both parsing it
                     derp::read_null(input)?;
@@ -649,9 +621,12 @@
             SignatureScheme::Ed25519 => &ED25519,
             SignatureScheme::RsaSsaPssSha256 => &RSA_PSS_2048_8192_SHA256,
             SignatureScheme::RsaSsaPssSha512 => &RSA_PSS_2048_8192_SHA512,
-            SignatureScheme::Unknown(ref s) => return Err(Error::IllegalArgument(
-                format!("Unknown signature scheme: {}", s)
-            )),
+            SignatureScheme::Unknown(ref s) => {
+                return Err(Error::IllegalArgument(format!(
+                    "Unknown signature scheme: {}",
+                    s
+                )))
+            }
         };
 
         ring::signature::verify(
@@ -696,9 +671,8 @@
     where
         S: Serializer,
     {
-        let bytes = self.as_spki().map_err(|e| {
-            SerializeError::custom(format!("Couldn't write key as SPKI: {:?}", e))
-        })?;
+        let bytes = self.as_spki()
+            .map_err(|e| SerializeError::custom(format!("Couldn't write key as SPKI: {:?}", e)))?;
         shims::PublicKey::new(self.typ.clone(), self.scheme.clone(), &bytes).serialize(ser)
     }
 }
@@ -711,18 +685,15 @@
             .map_err(|e| DeserializeError::custom(format!("{:?}", e)))?;
 
         let key = PublicKey::from_spki(&bytes, intermediate.scheme().clone())
-            .map_err(|e| {
-                DeserializeError::custom(format!("Couldn't parse key as SPKI: {:?}", e))
-            })?;
+            .map_err(|e| DeserializeError::custom(format!("Couldn't parse key as SPKI: {:?}", e)))?;
 
         if intermediate.typ() != &key.typ {
-            return Err(DeserializeError::custom(
-                format!("Key type listed in the metadata did not match the type extrated \
-                            from the key. {:?} vs. {:?}",
-                            intermediate.typ(),
-                            key.typ,
-                            ),
-            ));
+            return Err(DeserializeError::custom(format!(
+                "Key type listed in the metadata did not match the type extrated \
+                 from the key. {:?} vs. {:?}",
+                intermediate.typ(),
+                key.typ,
+            )));
         }
 
         Ok(key)
@@ -798,9 +769,9 @@
 impl<'de> Deserialize<'de> for HashValue {
     fn deserialize<D: Deserializer<'de>>(de: D) -> ::std::result::Result<Self, D::Error> {
         let s: String = Deserialize::deserialize(de)?;
-        let bytes = BASE64URL.decode(s.as_bytes()).map_err(|e| {
-            DeserializeError::custom(format!("Base64: {:?}", e))
-        })?;
+        let bytes = BASE64URL
+            .decode(s.as_bytes())
+            .map_err(|e| DeserializeError::custom(format!("Base64: {:?}", e)))?;
         Ok(HashValue(bytes))
     }
 }
@@ -822,16 +793,14 @@
     {
         let mut der = Der::new(&mut output);
         der.sequence(|der| {
-            der.sequence(|der| {
-                match key_type.as_oid().ok() {
-                    Some(tag) => {
-                        der.element(Tag::Oid, tag)?;
-                        der.null()
-                    },
-                    None => Err(derp::Error::WrongValue)
+            der.sequence(|der| match key_type.as_oid().ok() {
+                Some(tag) => {
+                    der.element(Tag::Oid, tag)?;
+                    der.null()
                 }
+                None => Err(derp::Error::WrongValue),
             })?;
-            der.bit_string(0,public)
+            der.bit_string(0, public)
         })?;
     }
 
@@ -957,8 +926,8 @@
 
         let sig = key.sign(msg).unwrap();
 
-        let public = PublicKey::from_spki(&key.public.as_spki().unwrap(), SignatureScheme::Ed25519)
-            .unwrap();
+        let public =
+            PublicKey::from_spki(&key.public.as_spki().unwrap(), SignatureScheme::Ed25519).unwrap();
         public.verify(msg, &sig).unwrap();
     }
 
diff --git a/src/error.rs b/src/error.rs
index 4cfc435..45cc70b 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -37,9 +37,9 @@
     /// chain to the target cannot be fully verified.
     TargetUnavailable,
     /// There is no known or available hash algorithm.
-    UnkonwnHashAlgorithm(String), 
+    UnkonwnHashAlgorithm(String),
     /// There is no known or available key type.
-    UnknownKeyType(String), 
+    UnknownKeyType(String),
     /// The metadata or target failed to verify.
     VerificationFailure(String),
 }
diff --git a/src/interchange/cjson.rs b/src/interchange/cjson.rs
index 5f2d947..b6e0095 100644
--- a/src/interchange/cjson.rs
+++ b/src/interchange/cjson.rs
@@ -33,16 +33,12 @@
                 buf.extend(b"false");
                 Ok(())
             }
-            Value::Number(Number::I64(n)) => {
-                itoa::write(buf, n).map(|_| ()).map_err(|err| {
-                    format!("Write error: {}", err)
-                })
-            }
-            Value::Number(Number::U64(n)) => {
-                itoa::write(buf, n).map(|_| ()).map_err(|err| {
-                    format!("Write error: {}", err)
-                })
-            }
+            Value::Number(Number::I64(n)) => itoa::write(buf, n)
+                .map(|_| ())
+                .map_err(|err| format!("Write error: {}", err)),
+            Value::Number(Number::U64(n)) => itoa::write(buf, n)
+                .map(|_| ())
+                .map_err(|err| format!("Write error: {}", err)),
             Value::String(ref s) => {
                 // this mess is abusing serde_json to get json escaping
                 let s = json::Value::String(s.clone());
@@ -96,13 +92,11 @@
     match *jsn {
         json::Value::Null => Ok(Value::Null),
         json::Value::Bool(b) => Ok(Value::Bool(b)),
-        json::Value::Number(ref n) => {
-            n.as_i64()
-                .map(Number::I64)
-                .or_else(|| n.as_u64().map(Number::U64))
-                .map(Value::Number)
-                .ok_or_else(|| String::from("only i64 and u64 are supported"))
-        }
+        json::Value::Number(ref n) => n.as_i64()
+            .map(Number::I64)
+            .or_else(|| n.as_u64().map(Number::U64))
+            .map(Value::Number)
+            .ok_or_else(|| String::from("only i64 and u64 are supported")),
         json::Value::Array(ref arr) => {
             let mut out = Vec::new();
             for res in arr.iter().map(|v| convert(v)) {
diff --git a/src/interchange/mod.rs b/src/interchange/mod.rs
index 9a98257..7f6dbd6 100644
--- a/src/interchange/mod.rs
+++ b/src/interchange/mod.rs
@@ -8,8 +8,8 @@
 use std::fmt::Debug;
 use std::io::{Read, Write};
 
-use Result;
 use error::Error;
+use Result;
 
 /// The format used for data interchange, serialization, and deserialization.
 pub trait DataInterchange: Debug + PartialEq + Clone {
diff --git a/src/lib.rs b/src/lib.rs
index aa65a60..761519d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -102,16 +102,9 @@
 //! metadata on every update.
 
 #![deny(missing_docs)]
-
 #![cfg_attr(
     feature = "cargo-clippy",
-    allow(
-        collapsible_if,
-        implicit_hasher,
-        new_ret_no_self,
-        op_ref,
-        too_many_arguments,
-    )
+    allow(collapsible_if, implicit_hasher, new_ret_no_self, op_ref, too_many_arguments)
 )]
 
 extern crate chrono;
diff --git a/src/metadata.rs b/src/metadata.rs
index 7d401bc..21bd9a4 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -1,25 +1,25 @@
 //! TUF metadata.
 
-use chrono::DateTime;
 use chrono::offset::Utc;
+use chrono::DateTime;
 use serde::de::{Deserialize, DeserializeOwned, Deserializer, Error as DeserializeError};
-use serde::ser::{Serialize, Serializer, Error as SerializeError};
+use serde::ser::{Error as SerializeError, Serialize, Serializer};
 use std::collections::{HashMap, HashSet};
 use std::fmt::{self, Debug, Display};
 use std::io::Read;
 use std::iter::FromIterator;
 use std::marker::PhantomData;
 
-use Result;
-use crypto::{self, KeyId, PublicKey, Signature, HashAlgorithm, HashValue, PrivateKey};
+use crypto::{self, HashAlgorithm, HashValue, KeyId, PrivateKey, PublicKey, Signature};
 use error::Error;
 use interchange::DataInterchange;
 use shims;
+use Result;
 
 static PATH_ILLEGAL_COMPONENTS: &'static [&str] = &[
     ".", // current dir
     "..", // parent dir
-    // TODO ? "0", // may translate to nul in windows
+         // TODO ? "0", // may translate to nul in windows
 ];
 
 static PATH_ILLEGAL_COMPONENTS_CASE_INSENSITIVE: &'static [&str] = &[
@@ -108,27 +108,30 @@
 
     for bad_str in PATH_ILLEGAL_STRINGS {
         if path.contains(bad_str) {
-            return Err(Error::IllegalArgument(
-                format!("Path cannot contain {:?}", bad_str),
-            ));
+            return Err(Error::IllegalArgument(format!(
+                "Path cannot contain {:?}",
+                bad_str
+            )));
         }
     }
 
     for component in path.split('/') {
         for bad_str in PATH_ILLEGAL_COMPONENTS {
             if component == *bad_str {
-                return Err(Error::IllegalArgument(
-                    format!("Path cannot have component {:?}", component),
-                ));
+                return Err(Error::IllegalArgument(format!(
+                    "Path cannot have component {:?}",
+                    component
+                )));
             }
         }
 
         let component_lower = component.to_lowercase();
         for bad_str in PATH_ILLEGAL_COMPONENTS_CASE_INSENSITIVE {
             if component_lower.as_str() == *bad_str {
-                return Err(Error::IllegalArgument(
-                    format!("Path cannot have component {:?}", component),
-                ));
+                return Err(Error::IllegalArgument(format!(
+                    "Path cannot have component {:?}",
+                    component
+                )));
             }
         }
     }
@@ -322,9 +325,8 @@
         let raw = D::serialize(&self.signed)?;
         let bytes = D::canonicalize(&raw)?;
         let sig = private_key.sign(&bytes)?;
-        self.signatures.retain(
-            |s| s.key_id() != private_key.key_id(),
-        );
+        self.signatures
+            .retain(|s| s.key_id() != private_key.key_id());
         self.signatures.push(sig);
         Ok(())
     }
@@ -428,8 +430,7 @@
     {
         if self.signatures.is_empty() {
             return Err(Error::VerificationFailure(
-                "The metadata was not signed with any authorized keys."
-                    .into(),
+                "The metadata was not signed with any authorized keys.".into(),
             ));
         }
 
@@ -449,17 +450,15 @@
         let mut signatures_needed = threshold;
         for sig in &self.signatures {
             match authorized_keys.get(sig.key_id()) {
-                Some(ref pub_key) => {
-                    match pub_key.verify(&canonical_bytes, &sig) {
-                        Ok(()) => {
-                            debug!("Good signature from key ID {:?}", pub_key.key_id());
-                            signatures_needed -= 1;
-                        }
-                        Err(e) => {
-                            warn!("Bad signature from key ID {:?}: {:?}", pub_key.key_id(), e);
-                        }
+                Some(ref pub_key) => match pub_key.verify(&canonical_bytes, &sig) {
+                    Ok(()) => {
+                        debug!("Good signature from key ID {:?}", pub_key.key_id());
+                        signatures_needed -= 1;
                     }
-                }
+                    Err(e) => {
+                        warn!("Bad signature from key ID {:?}: {:?}", pub_key.key_id(), e);
+                    }
+                },
                 None => {
                     warn!(
                         "Key ID {:?} was not found in the set of authorized keys.",
@@ -586,9 +585,8 @@
     where
         S: Serializer,
     {
-        let m = shims::RootMetadata::from(self).map_err(|e| {
-            SerializeError::custom(format!("{:?}", e))
-        })?;
+        let m = shims::RootMetadata::from(self)
+            .map_err(|e| SerializeError::custom(format!("{:?}", e)))?;
         m.serialize(ser)
     }
 }
@@ -596,9 +594,9 @@
 impl<'de> Deserialize<'de> for RootMetadata {
     fn deserialize<D: Deserializer<'de>>(de: D) -> ::std::result::Result<Self, D::Error> {
         let intermediate: shims::RootMetadata = Deserialize::deserialize(de)?;
-        intermediate.try_into().map_err(|e| {
-            DeserializeError::custom(format!("{:?}", e))
-        })
+        intermediate
+            .try_into()
+            .map_err(|e| DeserializeError::custom(format!("{:?}", e)))
     }
 }
 
@@ -630,10 +628,7 @@
             )));
         }
 
-        Ok(RoleDefinition {
-            threshold,
-            key_ids,
-        })
+        Ok(RoleDefinition { threshold, key_ids })
     }
 
     /// The threshold number of signatures required for the role to be trusted.
@@ -661,9 +656,9 @@
 impl<'de> Deserialize<'de> for RoleDefinition {
     fn deserialize<D: Deserializer<'de>>(de: D) -> ::std::result::Result<Self, D::Error> {
         let intermediate: shims::RoleDefinition = Deserialize::deserialize(de)?;
-        intermediate.try_into().map_err(|e| {
-            DeserializeError::custom(format!("{:?}", e))
-        })
+        intermediate
+            .try_into()
+            .map_err(|e| DeserializeError::custom(format!("{:?}", e)))
     }
 }
 
@@ -824,9 +819,9 @@
 impl<'de> Deserialize<'de> for TimestampMetadata {
     fn deserialize<D: Deserializer<'de>>(de: D) -> ::std::result::Result<Self, D::Error> {
         let intermediate: shims::TimestampMetadata = Deserialize::deserialize(de)?;
-        intermediate.try_into().map_err(|e| {
-            DeserializeError::custom(format!("{:?}", e))
-        })
+        intermediate
+            .try_into()
+            .map_err(|e| DeserializeError::custom(format!("{:?}", e)))
     }
 }
 
@@ -911,9 +906,9 @@
 impl<'de> Deserialize<'de> for MetadataDescription {
     fn deserialize<D: Deserializer<'de>>(de: D) -> ::std::result::Result<Self, D::Error> {
         let intermediate: shims::MetadataDescription = Deserialize::deserialize(de)?;
-        intermediate.try_into().map_err(|e| {
-            DeserializeError::custom(format!("{:?}", e))
-        })
+        intermediate
+            .try_into()
+            .map_err(|e| DeserializeError::custom(format!("{:?}", e)))
     }
 }
 
@@ -980,13 +975,12 @@
 impl<'de> Deserialize<'de> for SnapshotMetadata {
     fn deserialize<D: Deserializer<'de>>(de: D) -> ::std::result::Result<Self, D::Error> {
         let intermediate: shims::SnapshotMetadata = Deserialize::deserialize(de)?;
-        intermediate.try_into().map_err(|e| {
-            DeserializeError::custom(format!("{:?}", e))
-        })
+        intermediate
+            .try_into()
+            .map_err(|e| DeserializeError::custom(format!("{:?}", e)))
     }
 }
 
-
 /// Wrapper for the virtual path to a target.
 #[derive(Debug, Clone, PartialEq, Hash, Eq, PartialOrd, Ord, Serialize)]
 pub struct VirtualTargetPath(String);
@@ -1067,9 +1061,9 @@
                 group
                     .iter()
                     .filter(|parent| {
-                        parents[0].iter().any(
-                            |p| parent.is_child(p) || parent == &p,
-                        )
+                        parents[0]
+                            .iter()
+                            .any(|p| parent.is_child(p) || parent == &p)
                     })
                     .cloned()
                     .collect::<HashSet<_>>()
@@ -1145,10 +1139,7 @@
             ));
         }
 
-        Ok(TargetDescription {
-            size,
-            hashes,
-        })
+        Ok(TargetDescription { size, hashes })
     }
 
     /// Read the from the given reader and calculate the size and hash values.
@@ -1186,10 +1177,7 @@
         R: Read,
     {
         let (size, hashes) = crypto::calculate_hashes(read, hash_algs)?;
-        Ok(TargetDescription {
-            size,
-            hashes,
-        })
+        Ok(TargetDescription { size, hashes })
     }
 
     /// The maximum size of the target.
@@ -1206,9 +1194,9 @@
 impl<'de> Deserialize<'de> for TargetDescription {
     fn deserialize<D: Deserializer<'de>>(de: D) -> ::std::result::Result<Self, D::Error> {
         let intermediate: shims::TargetDescription = Deserialize::deserialize(de)?;
-        intermediate.try_into().map_err(|e| {
-            DeserializeError::custom(format!("{:?}", e))
-        })
+        intermediate
+            .try_into()
+            .map_err(|e| DeserializeError::custom(format!("{:?}", e)))
     }
 }
 
@@ -1283,9 +1271,9 @@
 impl<'de> Deserialize<'de> for TargetsMetadata {
     fn deserialize<D: Deserializer<'de>>(de: D) -> ::std::result::Result<Self, D::Error> {
         let intermediate: shims::TargetsMetadata = Deserialize::deserialize(de)?;
-        intermediate.try_into().map_err(|e| {
-            DeserializeError::custom(format!("{:?}", e))
-        })
+        intermediate
+            .try_into()
+            .map_err(|e| DeserializeError::custom(format!("{:?}", e)))
     }
 }
 
@@ -1309,8 +1297,8 @@
             return Err(Error::IllegalArgument("Roles cannot be empty.".into()));
         }
 
-        if roles.len() !=
-            roles
+        if roles.len()
+            != roles
                 .iter()
                 .map(|r| &r.role)
                 .collect::<HashSet<&MetadataPath>>()
@@ -1350,13 +1338,12 @@
     }
 }
 
-
 impl<'de> Deserialize<'de> for Delegations {
     fn deserialize<D: Deserializer<'de>>(de: D) -> ::std::result::Result<Self, D::Error> {
         let intermediate: shims::Delegations = Deserialize::deserialize(de)?;
-        intermediate.try_into().map_err(|e| {
-            DeserializeError::custom(format!("{:?}", e))
-        })
+        intermediate
+            .try_into()
+            .map_err(|e| DeserializeError::custom(format!("{:?}", e)))
     }
 }
 
@@ -1444,9 +1431,9 @@
 impl<'de> Deserialize<'de> for Delegation {
     fn deserialize<D: Deserializer<'de>>(de: D) -> ::std::result::Result<Self, D::Error> {
         let intermediate: shims::Delegation = Deserialize::deserialize(de)?;
-        intermediate.try_into().map_err(|e| {
-            DeserializeError::custom(format!("{:?}", e))
-        })
+        intermediate
+            .try_into()
+            .map_err(|e| DeserializeError::custom(format!("{:?}", e)))
     }
 }
 
@@ -1454,9 +1441,9 @@
 mod test {
     use super::*;
     use chrono::prelude::*;
-    use json;
     use crypto::SignatureScheme;
     use interchange::Json;
+    use json;
 
     const ED25519_1_PK8: &'static [u8] = include_bytes!("../tests/ed25519/ed25519-1.pk8.der");
     const ED25519_2_PK8: &'static [u8] = include_bytes!("../tests/ed25519/ed25519-2.pk8.der");
@@ -1483,33 +1470,32 @@
 
     #[test]
     fn path_matches_chain() {
-        let test_cases: &[(bool, &str, &[&[&str]])] =
-            &[
-                // simplest case
-                (true, "foo", &[&["foo"]]),
-                // direct delegation case
-                (true, "foo", &[&["foo"], &["foo"]]),
-                // is a dir
-                (false, "foo", &[&["foo/"]]),
-                // target not in last position
-                (false, "foo", &[&["foo"], &["bar"]]),
-                // target nested
-                (true, "foo/bar", &[&["foo/"], &["foo/bar"]]),
-                // target illegally nested
-                (false, "foo/bar", &[&["baz/"], &["foo/bar"]]),
-                // target illegally deeply nested
-                (
-                    false,
-                    "foo/bar/baz",
-                    &[&["foo/"], &["foo/quux/"], &["foo/bar/baz"]],
-                ),
-                // empty
-                (false, "foo", &[&[]]),
-                // empty 2
-                (false, "foo", &[&[], &["foo"]]),
-                // empty 3
-                (false, "foo", &[&["foo"], &[]]),
-            ];
+        let test_cases: &[(bool, &str, &[&[&str]])] = &[
+            // simplest case
+            (true, "foo", &[&["foo"]]),
+            // direct delegation case
+            (true, "foo", &[&["foo"], &["foo"]]),
+            // is a dir
+            (false, "foo", &[&["foo/"]]),
+            // target not in last position
+            (false, "foo", &[&["foo"], &["bar"]]),
+            // target nested
+            (true, "foo/bar", &[&["foo/"], &["foo/bar"]]),
+            // target illegally nested
+            (false, "foo/bar", &[&["baz/"], &["foo/bar"]]),
+            // target illegally deeply nested
+            (
+                false,
+                "foo/bar/baz",
+                &[&["foo/"], &["foo/quux/"], &["foo/bar/baz"]],
+            ),
+            // empty
+            (false, "foo", &[&[]]),
+            // empty 2
+            (false, "foo", &[&[], &["foo"]]),
+            // empty 3
+            (false, "foo", &[&["foo"], &[]]),
+        ];
 
         for case in test_cases {
             let expected = case.0;
@@ -1525,9 +1511,7 @@
                 .collect::<Vec<_>>();
             println!(
                 "CASE: expect: {} path: {:?} parents: {:?}",
-                expected,
-                target,
-                parents
+                expected, target, parents
             );
             assert_eq!(target.matches_chain(&parents), expected);
         }
@@ -1609,8 +1593,8 @@
         let root_key = PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519).unwrap();
         let snapshot_key = PrivateKey::from_pkcs8(ED25519_2_PK8, SignatureScheme::Ed25519).unwrap();
         let targets_key = PrivateKey::from_pkcs8(ED25519_3_PK8, SignatureScheme::Ed25519).unwrap();
-        let timestamp_key = PrivateKey::from_pkcs8(ED25519_4_PK8, SignatureScheme::Ed25519)
-            .unwrap();
+        let timestamp_key =
+            PrivateKey::from_pkcs8(ED25519_4_PK8, SignatureScheme::Ed25519).unwrap();
 
         let keys = vec![
             root_key.public().clone(),
@@ -1622,8 +1606,8 @@
         let root_def = RoleDefinition::new(1, hashset!(root_key.key_id().clone())).unwrap();
         let snapshot_def = RoleDefinition::new(1, hashset!(snapshot_key.key_id().clone())).unwrap();
         let targets_def = RoleDefinition::new(1, hashset!(targets_key.key_id().clone())).unwrap();
-        let timestamp_def = RoleDefinition::new(1, hashset!(timestamp_key.key_id().clone()))
-            .unwrap();
+        let timestamp_def =
+            RoleDefinition::new(1, hashset!(timestamp_key.key_id().clone())).unwrap();
 
         let root = RootMetadata::new(
             1,
@@ -1798,13 +1782,15 @@
         let key = PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519).unwrap();
         let delegations = Delegations::new(
             &hashset![key.public().clone()],
-            vec![Delegation::new(
-                MetadataPath::new("foo/bar".into()).unwrap(),
-                false,
-                1,
-                hashset!(key.key_id().clone()),
-                hashset!(VirtualTargetPath::new("baz/quux".into()).unwrap()),
-            ).unwrap()],
+            vec![
+                Delegation::new(
+                    MetadataPath::new("foo/bar".into()).unwrap(),
+                    false,
+                    1,
+                    hashset!(key.key_id().clone()),
+                    hashset!(VirtualTargetPath::new("baz/quux".into()).unwrap()),
+                ).unwrap(),
+            ],
         ).unwrap();
 
         let targets = TargetsMetadata::new(
@@ -1921,42 +1907,66 @@
     fn make_root() -> json::Value {
         let root_def = RoleDefinition::new(
             1,
-            hashset!(PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519)
-                     .unwrap().key_id().clone()),
+            hashset!(
+                PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519)
+                    .unwrap()
+                    .key_id()
+                    .clone()
+            ),
         ).unwrap();
 
         let snapshot_def = RoleDefinition::new(
             1,
-            hashset!(PrivateKey::from_pkcs8(ED25519_2_PK8, SignatureScheme::Ed25519)
-                     .unwrap().key_id().clone()),
+            hashset!(
+                PrivateKey::from_pkcs8(ED25519_2_PK8, SignatureScheme::Ed25519)
+                    .unwrap()
+                    .key_id()
+                    .clone()
+            ),
         ).unwrap();
 
         let targets_def = RoleDefinition::new(
             1,
-            hashset!(PrivateKey::from_pkcs8(ED25519_3_PK8, SignatureScheme::Ed25519)
-                     .unwrap().key_id().clone()),
+            hashset!(
+                PrivateKey::from_pkcs8(ED25519_3_PK8, SignatureScheme::Ed25519)
+                    .unwrap()
+                    .key_id()
+                    .clone()
+            ),
         ).unwrap();
 
         let timestamp_def = RoleDefinition::new(
             1,
-            hashset!(PrivateKey::from_pkcs8(ED25519_4_PK8, SignatureScheme::Ed25519)
-                     .unwrap().key_id().clone()),
+            hashset!(
+                PrivateKey::from_pkcs8(ED25519_4_PK8, SignatureScheme::Ed25519)
+                    .unwrap()
+                    .key_id()
+                    .clone()
+            ),
         ).unwrap();
 
         let root = RootMetadata::new(
             1,
             Utc.ymd(2038, 1, 1).and_hms(0, 0, 0),
             false,
-            vec!(
+            vec![
                 PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519)
-                    .unwrap().public().clone(),
+                    .unwrap()
+                    .public()
+                    .clone(),
                 PrivateKey::from_pkcs8(ED25519_2_PK8, SignatureScheme::Ed25519)
-                    .unwrap().public().clone(),
+                    .unwrap()
+                    .public()
+                    .clone(),
                 PrivateKey::from_pkcs8(ED25519_3_PK8, SignatureScheme::Ed25519)
-                    .unwrap().public().clone(),
+                    .unwrap()
+                    .public()
+                    .clone(),
                 PrivateKey::from_pkcs8(ED25519_4_PK8, SignatureScheme::Ed25519)
-                    .unwrap().public().clone(),
-            ),
+                    .unwrap()
+                    .public()
+                    .clone(),
+            ],
             root_def,
             snapshot_def,
             targets_def,
@@ -1967,8 +1977,8 @@
     }
 
     fn make_snapshot() -> json::Value {
-        let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!())
-            .unwrap();
+        let snapshot =
+            SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!()).unwrap();
 
         json::to_value(&snapshot).unwrap()
     }
@@ -1977,8 +1987,7 @@
         let timestamp = TimestampMetadata::new(
             1,
             Utc.ymd(2038, 1, 1).and_hms(0, 0, 0),
-            MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256])
-                .unwrap(),
+            MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256]).unwrap(),
         ).unwrap();
 
         json::to_value(&timestamp).unwrap()
@@ -1999,13 +2008,15 @@
             .clone();
         let delegations = Delegations::new(
             &hashset![key.clone()],
-            vec![Delegation::new(
-                MetadataPath::new("foo".into()).unwrap(),
-                false,
-                1,
-                hashset!(key.key_id().clone()),
-                hashset!(VirtualTargetPath::new("bar".into()).unwrap()),
-            ).unwrap()],
+            vec![
+                Delegation::new(
+                    MetadataPath::new("foo".into()).unwrap(),
+                    false,
+                    1,
+                    hashset!(key.key_id().clone()),
+                    hashset!(VirtualTargetPath::new("bar".into()).unwrap()),
+                ).unwrap(),
+            ],
         ).unwrap();
 
         json::to_value(&delegations).unwrap()
@@ -2058,8 +2069,7 @@
             .get("keys")
             .unwrap()
             .as_array()
-            .unwrap()
-            [0]
+            .unwrap()[0]
             .clone();
         root_json
             .as_object_mut()
@@ -2086,8 +2096,12 @@
     fn deserialize_json_role_definition_illegal_threshold() {
         let role_def = RoleDefinition::new(
             1,
-            hashset!(PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519)
-                        .unwrap().key_id().clone()),
+            hashset!(
+                PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519)
+                    .unwrap()
+                    .key_id()
+                    .clone()
+            ),
         ).unwrap();
 
         let mut jsn = json::to_value(&role_def).unwrap();
@@ -2102,9 +2116,13 @@
             2,
             hashset!(
                 PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519)
-                    .unwrap().key_id().clone(),
+                    .unwrap()
+                    .key_id()
+                    .clone(),
                 PrivateKey::from_pkcs8(ED25519_2_PK8, SignatureScheme::Ed25519)
-                    .unwrap().key_id().clone(),
+                    .unwrap()
+                    .key_id()
+                    .clone(),
             ),
         ).unwrap();
 
@@ -2117,10 +2135,9 @@
     #[test]
     fn deserialize_json_root_bad_type() {
         let mut root = make_root();
-        let _ = root.as_object_mut().unwrap().insert(
-            "type".into(),
-            json!("snapshot"),
-        );
+        let _ = root.as_object_mut()
+            .unwrap()
+            .insert("type".into(), json!("snapshot"));
         assert!(json::from_value::<RootMetadata>(root).is_err());
     }
 
@@ -2135,12 +2152,10 @@
         let mut jsn = json::to_value(&role_def).unwrap();
 
         match jsn.as_object_mut() {
-            Some(obj) => {
-                match obj.get_mut("key_ids").unwrap().as_array_mut() {
-                    Some(arr) => arr.push(json!(key_id)),
-                    None => panic!(),
-                }
-            }
+            Some(obj) => match obj.get_mut("key_ids").unwrap().as_array_mut() {
+                Some(arr) => arr.push(json!(key_id)),
+                None => panic!(),
+            },
             None => panic!(),
         }
 
@@ -2163,10 +2178,10 @@
     #[test]
     fn deserialize_json_snapshot_bad_type() {
         let mut snapshot = make_snapshot();
-        let _ = snapshot.as_object_mut().unwrap().insert(
-            "type".into(),
-            json!("root"),
-        );
+        let _ = snapshot
+            .as_object_mut()
+            .unwrap()
+            .insert("type".into(), json!("root"));
         assert!(json::from_value::<SnapshotMetadata>(snapshot).is_err());
     }
 
@@ -2186,10 +2201,10 @@
     #[test]
     fn deserialize_json_timestamp_bad_type() {
         let mut timestamp = make_timestamp();
-        let _ = timestamp.as_object_mut().unwrap().insert(
-            "type".into(),
-            json!("root"),
-        );
+        let _ = timestamp
+            .as_object_mut()
+            .unwrap()
+            .insert("type".into(), json!("root"));
         assert!(json::from_value::<TimestampMetadata>(timestamp).is_err());
     }
 
@@ -2209,10 +2224,10 @@
     #[test]
     fn deserialize_json_targets_bad_type() {
         let mut targets = make_targets();
-        let _ = targets.as_object_mut().unwrap().insert(
-            "type".into(),
-            json!("root"),
-        );
+        let _ = targets
+            .as_object_mut()
+            .unwrap()
+            .insert("type".into(), json!("root"));
         assert!(json::from_value::<TargetsMetadata>(targets).is_err());
     }
 
@@ -2256,8 +2271,7 @@
             .get("roles".into())
             .unwrap()
             .as_array()
-            .unwrap()
-            [0]
+            .unwrap()[0]
             .clone();
         delegations
             .as_object_mut()
@@ -2292,8 +2306,7 @@
             .get("key_ids".into())
             .unwrap()
             .as_array()
-            .unwrap()
-            [0]
+            .unwrap()[0]
             .clone();
         delegation
             .as_object_mut()
@@ -2316,8 +2329,7 @@
             .get("paths".into())
             .unwrap()
             .as_array()
-            .unwrap()
-            [0]
+            .unwrap()[0]
             .clone();
         delegation
             .as_object_mut()
@@ -2339,13 +2351,15 @@
             .clone();
         let delegations = Delegations::new(
             &hashset!(key.clone()),
-            vec![Delegation::new(
-                MetadataPath::new("foo".into()).unwrap(),
-                false,
-                1,
-                hashset!(key.key_id().clone()),
-                hashset!(VirtualTargetPath::new("bar".into()).unwrap()),
-            ).unwrap()],
+            vec![
+                Delegation::new(
+                    MetadataPath::new("foo".into()).unwrap(),
+                    false,
+                    1,
+                    hashset!(key.key_id().clone()),
+                    hashset!(VirtualTargetPath::new("bar".into()).unwrap()),
+                ).unwrap(),
+            ],
         ).unwrap();
         let mut delegations = json::to_value(delegations).unwrap();
 
@@ -2355,8 +2369,7 @@
             .get("keys".into())
             .unwrap()
             .as_array()
-            .unwrap()
-            [0]
+            .unwrap()[0]
             .clone();
         delegations
             .as_object_mut()
diff --git a/src/repository.rs b/src/repository.rs
index c6649c6..38e5191 100644
--- a/src/repository.rs
+++ b/src/repository.rs
@@ -1,23 +1,24 @@
 //! Interfaces for interacting with different types of TUF repositories.
 
-use hyper::{Url, Client};
 use hyper::client::response::Response;
 use hyper::header::{Headers, UserAgent};
 use hyper::status::StatusCode;
+use hyper::{Client, Url};
 use std::collections::HashMap;
-use std::fs::{self, File, DirBuilder};
-use std::io::{Read, Write, Cursor};
+use std::fs::{self, DirBuilder, File};
+use std::io::{Cursor, Read, Write};
 use std::marker::PhantomData;
 use std::path::PathBuf;
 use tempfile::NamedTempFile;
 
-use Result;
 use crypto::{self, HashAlgorithm, HashValue};
 use error::Error;
 use interchange::DataInterchange;
-use metadata::{SignedMetadata, MetadataVersion, Metadata, TargetPath, TargetDescription,
-               MetadataPath};
+use metadata::{
+    Metadata, MetadataPath, MetadataVersion, SignedMetadata, TargetDescription, TargetPath,
+};
 use util::SafeReader;
+use Result;
 
 /// Top-level trait that represents a TUF repository and contains all the ways it can be interacted
 /// with.
@@ -72,9 +73,11 @@
         M: Metadata,
     {
         if !M::ROLE.fuzzy_matches_path(meta_path) {
-            return Err(Error::IllegalArgument(
-                format!("Role {} does not match path {:?}", M::ROLE, meta_path),
-            ));
+            return Err(Error::IllegalArgument(format!(
+                "Role {} does not match path {:?}",
+                M::ROLE,
+                meta_path
+            )));
         }
 
         Ok(())
@@ -97,9 +100,9 @@
     /// Create a new repository on the local file system.
     pub fn new(local_path: PathBuf) -> Result<Self> {
         for p in &["metadata", "targets", "temp"] {
-            DirBuilder::new().recursive(true).create(
-                local_path.join(p),
-            )?
+            DirBuilder::new()
+                .recursive(true)
+                .create(local_path.join(p))?
         }
 
         Ok(FileSystemRepository {
@@ -144,7 +147,6 @@
         let mut file = File::create(&path)?;
         D::to_writer(&mut file, metadata)?;
         Ok(())
-
     }
 
     /// Fetch signed metadata.
@@ -227,7 +229,6 @@
     }
 }
 
-
 /// A repository accessible over HTTP.
 pub struct HttpRepository<D>
 where
@@ -296,9 +297,10 @@
             if resp.status == StatusCode::NotFound {
                 Err(Error::NotFound)
             } else {
-                Err(Error::Opaque(
-                    format!("Error getting {:?}: {:?}", url, resp),
-                ))
+                Err(Error::Opaque(format!(
+                    "Error getting {:?}: {:?}",
+                    url, resp
+                )))
             }
         } else {
             Ok(resp)
@@ -340,10 +342,7 @@
     {
         Self::check::<M>(meta_path)?;
 
-        let resp = self.get(
-            &self.metadata_prefix,
-            &meta_path.components::<D>(&version),
-        )?;
+        let resp = self.get(&self.metadata_prefix, &meta_path.components::<D>(&version))?;
 
         let read = SafeReader::new(
             resp,
@@ -359,9 +358,7 @@
     where
         R: Read,
     {
-        Err(Error::Opaque(
-            "Http repo store not implemented".to_string(),
-        ))
+        Err(Error::Opaque("Http repo store not implemented".to_string()))
     }
 
     fn fetch_target(
@@ -381,7 +378,6 @@
     }
 }
 
-
 /// An ephemeral repository contained solely in memory.
 pub struct EphemeralRepository<D>
 where
@@ -433,10 +429,8 @@
         Self::check::<M>(meta_path)?;
         let mut buf = Vec::new();
         D::to_writer(&mut buf, metadata)?;
-        let _ = self.metadata.insert(
-            (meta_path.clone(), version.clone()),
-            buf,
-        );
+        let _ = self.metadata
+            .insert((meta_path.clone(), version.clone()), buf);
         Ok(())
     }
 
@@ -503,16 +497,16 @@
 #[cfg(test)]
 mod test {
     use super::*;
-    use tempdir::TempDir;
     use interchange::Json;
+    use tempdir::TempDir;
 
     #[test]
     fn ephemeral_repo_targets() {
         let mut repo = EphemeralRepository::<Json>::new();
 
         let data: &[u8] = b"like tears in the rain";
-        let target_description = TargetDescription::from_reader(data, &[HashAlgorithm::Sha256])
-            .unwrap();
+        let target_description =
+            TargetDescription::from_reader(data, &[HashAlgorithm::Sha256]).unwrap();
         let path = TargetPath::new("batty".into()).unwrap();
         repo.store_target(data, &path).unwrap();
 
@@ -538,11 +532,19 @@
         assert!(temp_dir.path().join("temp").exists());
 
         let data: &[u8] = b"like tears in the rain";
-        let target_description = TargetDescription::from_reader(data, &[HashAlgorithm::Sha256])
-            .unwrap();
+        let target_description =
+            TargetDescription::from_reader(data, &[HashAlgorithm::Sha256]).unwrap();
         let path = TargetPath::new("foo/bar/baz".into()).unwrap();
         repo.store_target(data, &path).unwrap();
-        assert!(temp_dir.path().join("targets").join("foo").join("bar").join("baz").exists());
+        assert!(
+            temp_dir
+                .path()
+                .join("targets")
+                .join("foo")
+                .join("bar")
+                .join("baz")
+                .exists()
+        );
 
         let mut buf = Vec::new();
 
diff --git a/src/shims.rs b/src/shims.rs
index cb7197a..855c7b2 100644
--- a/src/shims.rs
+++ b/src/shims.rs
@@ -1,17 +1,16 @@
-use chrono::prelude::*;
 use chrono::offset::Utc;
+use chrono::prelude::*;
 use data_encoding::BASE64URL;
 use std::collections::{HashMap, HashSet};
 
-use Result;
 use crypto;
 use error::Error;
 use metadata;
+use Result;
 
 fn parse_datetime(ts: &str) -> Result<DateTime<Utc>> {
-    Utc.datetime_from_str(ts, "%FT%TZ").map_err(|e| {
-        Error::Encoding(format!("Can't parse DateTime: {:?}", e))
-    })
+    Utc.datetime_from_str(ts, "%FT%TZ")
+        .map_err(|e| Error::Encoding(format!("Can't parse DateTime: {:?}", e)))
 }
 
 fn format_datetime(ts: &DateTime<Utc>) -> String {
@@ -114,9 +113,10 @@
         let dupes = vec_len - key_ids.len();
 
         if dupes != 0 {
-            return Err(Error::Encoding(
-                format!("Found {} duplicate key IDs.", dupes),
-            ));
+            return Err(Error::Encoding(format!(
+                "Found {} duplicate key IDs.",
+                dupes
+            )));
         }
 
         Ok(metadata::RoleDefinition::new(self.threshold, key_ids)?)
@@ -189,7 +189,6 @@
     }
 }
 
-
 #[derive(Serialize, Deserialize)]
 pub struct TargetsMetadata {
     #[serde(rename = "type")]
@@ -321,7 +320,6 @@
     roles: Vec<metadata::Delegation>,
 }
 
-
 impl Delegations {
     pub fn from(delegations: &metadata::Delegations) -> Delegations {
         let mut keys = delegations
diff --git a/src/tuf.rs b/src/tuf.rs
index 1227402..9e06704 100644
--- a/src/tuf.rs
+++ b/src/tuf.rs
@@ -1,15 +1,17 @@
 //! Components needed to verify TUF metadata and targets.
 
 use chrono::offset::Utc;
-use std::collections::{HashSet, HashMap};
+use std::collections::{HashMap, HashSet};
 use std::marker::PhantomData;
 
-use Result;
 use crypto::KeyId;
 use error::Error;
 use interchange::DataInterchange;
-use metadata::{SignedMetadata, RootMetadata, TimestampMetadata, Role, SnapshotMetadata,
-               MetadataPath, TargetsMetadata, VirtualTargetPath, TargetDescription, Delegations};
+use metadata::{
+    Delegations, MetadataPath, Role, RootMetadata, SignedMetadata, SnapshotMetadata,
+    TargetDescription, TargetsMetadata, TimestampMetadata, VirtualTargetPath,
+};
+use Result;
 
 /// Contains trusted TUF metadata and can be used to verify other metadata and targets.
 #[derive(Debug)]
@@ -34,9 +36,9 @@
     {
         let root_key_ids = root_key_ids.into_iter().collect::<HashSet<&KeyId>>();
 
-        signed_root.signatures_mut().retain(|s| {
-            root_key_ids.contains(s.key_id())
-        });
+        signed_root
+            .signatures_mut()
+            .retain(|s| root_key_ids.contains(s.key_id()));
         Self::from_root(&signed_root)
     }
 
@@ -48,16 +50,13 @@
         let root = D::deserialize::<RootMetadata>(signed_root.signed())?;
         signed_root.verify(
             root.root().threshold(),
-            root.keys().iter().filter_map(
-                |(k, v)| if root.root()
-                    .key_ids()
-                    .contains(k)
-                {
+            root.keys().iter().filter_map(|(k, v)| {
+                if root.root().key_ids().contains(k) {
                     Some(v)
                 } else {
                     None
-                },
-            ),
+                }
+            }),
         )?;
         Ok(Tuf {
             root,
@@ -113,7 +112,7 @@
             x if x == self.root.version() => {
                 info!(
                     "Attempted to update root to new metadata with the same version. \
-                      Refusing to update."
+                     Refusing to update."
                 );
                 return Ok(false);
             }
@@ -129,16 +128,13 @@
 
         signed_root.verify(
             root.root().threshold(),
-            root.keys().iter().filter_map(
-                |(k, v)| if root.root()
-                    .key_ids()
-                    .contains(k)
-                {
+            root.keys().iter().filter_map(|(k, v)| {
+                if root.root().key_ids().contains(k) {
                     Some(v)
                 } else {
                     None
-                },
-            ),
+                }
+            }),
         )?;
 
         self.purge_metadata();
@@ -154,15 +150,13 @@
     ) -> Result<bool> {
         signed_timestamp.verify(
             self.root.timestamp().threshold(),
-            self.root.keys().iter().filter_map(
-                |(k, v)| {
-                    if self.root.timestamp().key_ids().contains(k) {
-                        Some(v)
-                    } else {
-                        None
-                    }
-                },
-            ),
+            self.root.keys().iter().filter_map(|(k, v)| {
+                if self.root.timestamp().key_ids().contains(k) {
+                    Some(v)
+                } else {
+                    None
+                }
+            }),
         )?;
 
         let current_version = self.timestamp.as_ref().map(|t| t.version()).unwrap_or(0);
@@ -181,8 +175,8 @@
         } else if timestamp.version() == current_version {
             Ok(false)
         } else {
-            if self.snapshot.as_ref().map(|s| s.version()).unwrap_or(0) !=
-                timestamp.snapshot().version()
+            if self.snapshot.as_ref().map(|s| s.version()).unwrap_or(0)
+                != timestamp.snapshot().version()
             {
                 self.snapshot = None;
             }
@@ -215,15 +209,13 @@
 
             signed_snapshot.verify(
                 root.snapshot().threshold(),
-                self.root.keys().iter().filter_map(
-                    |(k, v)| {
-                        if root.snapshot().key_ids().contains(k) {
-                            Some(v)
-                        } else {
-                            None
-                        }
-                    },
-                ),
+                self.root.keys().iter().filter_map(|(k, v)| {
+                    if root.snapshot().key_ids().contains(k) {
+                        Some(v)
+                    } else {
+                        None
+                    }
+                }),
             )?;
 
             let snapshot: SnapshotMetadata = D::deserialize(&signed_snapshot.signed())?;
@@ -231,7 +223,7 @@
             if snapshot.version() != timestamp.snapshot().version() {
                 return Err(Error::VerificationFailure(format!(
                     "The timestamp metadata reported that the snapshot metadata should be at \
-                    version {} but version {} was found instead.",
+                     version {} but version {} was found instead.",
                     timestamp.snapshot().version(),
                     snapshot.version()
                 )));
@@ -243,8 +235,8 @@
             snapshot
         };
 
-        if self.targets.as_ref().map(|s| s.version()).unwrap_or(0) !=
-            snapshot
+        if self.targets.as_ref().map(|s| s.version()).unwrap_or(0)
+            != snapshot
                 .meta()
                 .get(&MetadataPath::from_role(&Role::Targets))
                 .map(|m| m.version())
@@ -256,7 +248,6 @@
         self.snapshot = Some(snapshot);
         self.purge_delegations();
         Ok(true)
-
     }
 
     fn purge_delegations(&mut self) {
@@ -331,7 +322,7 @@
             if targets.version() != targets_description.version() {
                 return Err(Error::VerificationFailure(format!(
                     "The timestamp metadata reported that the targets metadata should be at \
-                    version {} but version {} was found instead.",
+                     version {} but version {} was found instead.",
                     targets_description.version(),
                     targets.version()
                 )));
@@ -380,7 +371,7 @@
             if delegation_description.version() < current_version {
                 return Err(Error::VerificationFailure(format!(
                     "Snapshot metadata did listed delegation {:?} version as {} but current\
-                    version is {}",
+                     version is {}",
                     role,
                     delegation_description.version(),
                     current_version
@@ -402,16 +393,13 @@
 
                 signed.verify(
                     delegation.threshold(),
-                    parent.keys().iter().filter_map(
-                        |(k, v)| if delegation
-                            .key_ids()
-                            .contains(k)
-                        {
+                    parent.keys().iter().filter_map(|(k, v)| {
+                        if delegation.key_ids().contains(k) {
                             Some(v)
                         } else {
                             None
-                        },
-                    ),
+                        }
+                    }),
                 )?;
             }
 
@@ -419,11 +407,11 @@
             if delegation.version() != delegation_description.version() {
                 return Err(Error::VerificationFailure(format!(
                     "The snapshot metadata reported that the delegation {:?} should be at \
-                    version {} but version {} was found instead.",
+                     version {} but version {} was found instead.",
                     role,
                     delegation_description.version(),
                     delegation.version(),
-                    )));
+                )));
             }
 
             if delegation.expires() <= &Utc::now() {
@@ -573,9 +561,9 @@
 mod test {
     use super::*;
     use chrono::prelude::*;
-    use crypto::{PrivateKey, SignatureScheme, HashAlgorithm};
+    use crypto::{HashAlgorithm, PrivateKey, SignatureScheme};
     use interchange::Json;
-    use metadata::{RoleDefinition, MetadataDescription};
+    use metadata::{MetadataDescription, RoleDefinition};
 
     lazy_static! {
         static ref KEYS: Vec<PrivateKey> = {
@@ -587,7 +575,8 @@
                 include_bytes!("../tests/ed25519/ed25519-5.pk8.der"),
                 include_bytes!("../tests/ed25519/ed25519-6.pk8.der"),
             ];
-            keys.iter().map(|b| PrivateKey::from_pkcs8(b, SignatureScheme::Ed25519).unwrap())
+            keys.iter()
+                .map(|b| PrivateKey::from_pkcs8(b, SignatureScheme::Ed25519).unwrap())
                 .collect()
         };
     }
@@ -605,8 +594,8 @@
             RoleDefinition::new(1, hashset!(KEYS[0].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[0].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &root_key)
-            .unwrap();
+        let root: SignedMetadata<Json, RootMetadata> =
+            SignedMetadata::new(&root, &root_key).unwrap();
 
         assert!(Tuf::from_root_pinned(root, &[root_key.key_id().clone()]).is_ok());
     }
@@ -623,8 +612,8 @@
             RoleDefinition::new(1, hashset!(KEYS[0].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[0].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
-            .unwrap();
+        let root: SignedMetadata<Json, RootMetadata> =
+            SignedMetadata::new(&root, &KEYS[0]).unwrap();
 
         assert!(Tuf::from_root_pinned(root, &[KEYS[1].key_id().clone()]).is_err());
     }
@@ -641,8 +630,8 @@
             RoleDefinition::new(1, hashset!(KEYS[0].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[0].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
-            .unwrap();
+        let root: SignedMetadata<Json, RootMetadata> =
+            SignedMetadata::new(&root, &KEYS[0]).unwrap();
 
         let mut tuf = Tuf::from_root(&root).unwrap();
 
@@ -656,8 +645,8 @@
             RoleDefinition::new(1, hashset!(KEYS[1].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[1].key_id().clone())).unwrap(),
         ).unwrap();
-        let mut root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[1])
-            .unwrap();
+        let mut root: SignedMetadata<Json, RootMetadata> =
+            SignedMetadata::new(&root, &KEYS[1]).unwrap();
 
         // add the original key's signature to make it cross signed
         root.add_signature(&KEYS[0]).unwrap();
@@ -680,8 +669,8 @@
             RoleDefinition::new(1, hashset!(KEYS[0].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[0].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
-            .unwrap();
+        let root: SignedMetadata<Json, RootMetadata> =
+            SignedMetadata::new(&root, &KEYS[0]).unwrap();
 
         let mut tuf = Tuf::from_root(&root).unwrap();
 
@@ -696,8 +685,8 @@
             RoleDefinition::new(1, hashset!(KEYS[1].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[1].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[1])
-            .unwrap();
+        let root: SignedMetadata<Json, RootMetadata> =
+            SignedMetadata::new(&root, &KEYS[1]).unwrap();
 
         assert!(tuf.update_root(&root).is_err());
     }
@@ -714,16 +703,15 @@
             RoleDefinition::new(1, hashset!(KEYS[1].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[1].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
-            .unwrap();
+        let root: SignedMetadata<Json, RootMetadata> =
+            SignedMetadata::new(&root, &KEYS[0]).unwrap();
 
         let mut tuf = Tuf::from_root(&root).unwrap();
 
         let timestamp = TimestampMetadata::new(
             1,
             Utc.ymd(2038, 1, 1).and_hms(0, 0, 0),
-            MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256])
-                .unwrap(),
+            MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256]).unwrap(),
         ).unwrap();
         let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[1]).unwrap();
@@ -746,16 +734,15 @@
             RoleDefinition::new(1, hashset!(KEYS[1].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[1].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
-            .unwrap();
+        let root: SignedMetadata<Json, RootMetadata> =
+            SignedMetadata::new(&root, &KEYS[0]).unwrap();
 
         let mut tuf = Tuf::from_root(&root).unwrap();
 
         let timestamp = TimestampMetadata::new(
             1,
             Utc.ymd(2038, 1, 1).and_hms(0, 0, 0),
-            MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256])
-                .unwrap(),
+            MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256]).unwrap(),
         ).unwrap();
 
         // sign it with the root key
@@ -781,24 +768,23 @@
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
-            .unwrap();
+        let root: SignedMetadata<Json, RootMetadata> =
+            SignedMetadata::new(&root, &KEYS[0]).unwrap();
 
         let mut tuf = Tuf::from_root(&root).unwrap();
 
         let timestamp = TimestampMetadata::new(
             1,
             Utc.ymd(2038, 1, 1).and_hms(0, 0, 0),
-            MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256])
-                .unwrap(),
+            MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256]).unwrap(),
         ).unwrap();
         let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[2]).unwrap();
 
         tuf.update_timestamp(&timestamp).unwrap();
 
-        let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!())
-            .unwrap();
+        let snapshot =
+            SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!()).unwrap();
         let snapshot: SignedMetadata<Json, SnapshotMetadata> =
             SignedMetadata::new(&snapshot, &KEYS[1]).unwrap();
 
@@ -824,24 +810,23 @@
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
-            .unwrap();
+        let root: SignedMetadata<Json, RootMetadata> =
+            SignedMetadata::new(&root, &KEYS[0]).unwrap();
 
         let mut tuf = Tuf::from_root(&root).unwrap();
 
         let timestamp = TimestampMetadata::new(
             1,
             Utc.ymd(2038, 1, 1).and_hms(0, 0, 0),
-            MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256])
-                .unwrap(),
+            MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256]).unwrap(),
         ).unwrap();
         let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[2]).unwrap();
 
         tuf.update_timestamp(&timestamp).unwrap();
 
-        let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!())
-            .unwrap();
+        let snapshot =
+            SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!()).unwrap();
         let snapshot: SignedMetadata<Json, SnapshotMetadata> =
             SignedMetadata::new(&snapshot, &KEYS[2]).unwrap();
 
@@ -864,24 +849,23 @@
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
-            .unwrap();
+        let root: SignedMetadata<Json, RootMetadata> =
+            SignedMetadata::new(&root, &KEYS[0]).unwrap();
 
         let mut tuf = Tuf::from_root(&root).unwrap();
 
         let timestamp = TimestampMetadata::new(
             1,
             Utc.ymd(2038, 1, 1).and_hms(0, 0, 0),
-            MetadataDescription::from_reader(&*vec![], 2, &[HashAlgorithm::Sha256])
-                .unwrap(),
+            MetadataDescription::from_reader(&*vec![], 2, &[HashAlgorithm::Sha256]).unwrap(),
         ).unwrap();
         let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[2]).unwrap();
 
         tuf.update_timestamp(&timestamp).unwrap();
 
-        let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!())
-            .unwrap();
+        let snapshot =
+            SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!()).unwrap();
         let snapshot: SignedMetadata<Json, SnapshotMetadata> =
             SignedMetadata::new(&snapshot, &KEYS[1]).unwrap();
 
@@ -905,29 +889,27 @@
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[3].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
-            .unwrap();
+        let root: SignedMetadata<Json, RootMetadata> =
+            SignedMetadata::new(&root, &KEYS[0]).unwrap();
 
         let mut tuf = Tuf::from_root(&root).unwrap();
 
         let timestamp = TimestampMetadata::new(
             1,
             Utc.ymd(2038, 1, 1).and_hms(0, 0, 0),
-            MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256])
-                .unwrap(),
+            MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256]).unwrap(),
         ).unwrap();
         let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[3]).unwrap();
 
         tuf.update_timestamp(&timestamp).unwrap();
 
-        let meta_map =
-            hashmap!(
+        let meta_map = hashmap!(
             MetadataPath::from_role(&Role::Targets) =>
                 MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256]).unwrap(),
         );
-        let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), meta_map)
-            .unwrap();
+        let snapshot =
+            SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), meta_map).unwrap();
         let snapshot: SignedMetadata<Json, SnapshotMetadata> =
             SignedMetadata::new(&snapshot, &KEYS[1]).unwrap();
 
@@ -962,29 +944,27 @@
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[3].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
-            .unwrap();
+        let root: SignedMetadata<Json, RootMetadata> =
+            SignedMetadata::new(&root, &KEYS[0]).unwrap();
 
         let mut tuf = Tuf::from_root(&root).unwrap();
 
         let timestamp = TimestampMetadata::new(
             1,
             Utc.ymd(2038, 1, 1).and_hms(0, 0, 0),
-            MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256])
-                .unwrap(),
+            MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256]).unwrap(),
         ).unwrap();
         let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[3]).unwrap();
 
         tuf.update_timestamp(&timestamp).unwrap();
 
-        let meta_map =
-            hashmap!(
+        let meta_map = hashmap!(
             MetadataPath::from_role(&Role::Targets) =>
                 MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256]).unwrap(),
         );
-        let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), meta_map)
-            .unwrap();
+        let snapshot =
+            SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), meta_map).unwrap();
         let snapshot: SignedMetadata<Json, SnapshotMetadata> =
             SignedMetadata::new(&snapshot, &KEYS[1]).unwrap();
 
@@ -1016,29 +996,27 @@
             RoleDefinition::new(1, hashset!(KEYS[2].key_id().clone())).unwrap(),
             RoleDefinition::new(1, hashset!(KEYS[3].key_id().clone())).unwrap(),
         ).unwrap();
-        let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
-            .unwrap();
+        let root: SignedMetadata<Json, RootMetadata> =
+            SignedMetadata::new(&root, &KEYS[0]).unwrap();
 
         let mut tuf = Tuf::from_root(&root).unwrap();
 
         let timestamp = TimestampMetadata::new(
             1,
             Utc.ymd(2038, 1, 1).and_hms(0, 0, 0),
-            MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256])
-                .unwrap(),
+            MetadataDescription::from_reader(&*vec![], 1, &[HashAlgorithm::Sha256]).unwrap(),
         ).unwrap();
         let timestamp: SignedMetadata<Json, TimestampMetadata> =
             SignedMetadata::new(&timestamp, &KEYS[3]).unwrap();
 
         tuf.update_timestamp(&timestamp).unwrap();
 
-        let meta_map =
-            hashmap!(
+        let meta_map = hashmap!(
             MetadataPath::from_role(&Role::Targets) =>
                 MetadataDescription::from_reader(&*vec![], 2, &[HashAlgorithm::Sha256]).unwrap(),
         );
-        let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), meta_map)
-            .unwrap();
+        let snapshot =
+            SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), meta_map).unwrap();
         let snapshot: SignedMetadata<Json, SnapshotMetadata> =
             SignedMetadata::new(&snapshot, &KEYS[1]).unwrap();
 
diff --git a/src/util.rs b/src/util.rs
index ea0f5b2..c6ba957 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -1,11 +1,11 @@
 use chrono::offset::Utc;
 use chrono::DateTime;
 use ring::digest::{self, SHA256, SHA512};
-use std::io::{self, Read, ErrorKind};
+use std::io::{self, ErrorKind, Read};
 
-use Result;
 use crypto::{HashAlgorithm, HashValue};
 use error::Error;
+use Result;
 
 /// Wrapper to verify a byte stream as it is read.
 ///
@@ -44,12 +44,15 @@
                 let ctx = match *alg {
                     HashAlgorithm::Sha256 => digest::Context::new(&SHA256),
                     HashAlgorithm::Sha512 => digest::Context::new(&SHA512),
-                    HashAlgorithm::Unknown(ref s) => return Err(Error::IllegalArgument(
-                        format!("Unknown hash algorithm: {}", s)
-                    )),
+                    HashAlgorithm::Unknown(ref s) => {
+                        return Err(Error::IllegalArgument(format!(
+                            "Unknown hash algorithm: {}",
+                            s
+                        )))
+                    }
                 };
                 Some((ctx, value))
-            },
+            }
             None => None,
         };
 
@@ -99,8 +102,8 @@
                 let duration = Utc::now().signed_duration_since(self.start_time.unwrap());
                 // 30 second grace period before we start checking the bitrate
                 if duration.num_seconds() >= 30 {
-                    if self.bytes_read as f32 / (duration.num_seconds() as f32) <
-                        self.min_bytes_per_second as f32
+                    if self.bytes_read as f32 / (duration.num_seconds() as f32)
+                        < self.min_bytes_per_second as f32
                     {
                         return Err(io::Error::new(
                             ErrorKind::TimedOut,
diff --git a/tests/integration.rs b/tests/integration.rs
index 4a7fd3c..92af93e 100644
--- a/tests/integration.rs
+++ b/tests/integration.rs
@@ -3,15 +3,17 @@
 extern crate maplit;
 extern crate tuf;
 
-use chrono::prelude::*;
 use chrono::offset::Utc;
+use chrono::prelude::*;
 use std::collections::HashMap;
-use tuf::Tuf;
-use tuf::crypto::{PrivateKey, SignatureScheme, HashAlgorithm};
+use tuf::crypto::{HashAlgorithm, PrivateKey, SignatureScheme};
 use tuf::interchange::Json;
-use tuf::metadata::{RoleDefinition, RootMetadata, MetadataPath, SignedMetadata, TargetDescription,
-                    VirtualTargetPath, TargetsMetadata, MetadataDescription, SnapshotMetadata,
-                    TimestampMetadata, Delegation, Delegations};
+use tuf::metadata::{
+    Delegation, Delegations, MetadataDescription, MetadataPath, RoleDefinition, RootMetadata,
+    SignedMetadata, SnapshotMetadata, TargetDescription, TargetsMetadata, TimestampMetadata,
+    VirtualTargetPath,
+};
+use tuf::Tuf;
 
 const ED25519_1_PK8: &'static [u8] = include_bytes!("./ed25519/ed25519-1.pk8.der");
 const ED25519_2_PK8: &'static [u8] = include_bytes!("./ed25519/ed25519-2.pk8.der");
@@ -60,21 +62,20 @@
     let snap = MetadataDescription::from_reader(&*vec![0u8], 1, &[HashAlgorithm::Sha256]).unwrap();
     let timestamp = TimestampMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), snap).unwrap();
 
-    let signed = SignedMetadata::<Json, TimestampMetadata>::new(&timestamp, &timestamp_key)
-        .unwrap();
+    let signed =
+        SignedMetadata::<Json, TimestampMetadata>::new(&timestamp, &timestamp_key).unwrap();
 
     tuf.update_timestamp(&signed).unwrap();
 
     //// build the snapshot ////
-    let meta_map =
-        hashmap! {
+    let meta_map = hashmap! {
         MetadataPath::new("targets".into()).unwrap() =>
             MetadataDescription::from_reader(&*vec![0u8], 1, &[HashAlgorithm::Sha256]).unwrap(),
         MetadataPath::new("delegation".into()).unwrap() =>
             MetadataDescription::from_reader(&*vec![0u8], 1, &[HashAlgorithm::Sha256]).unwrap(),
     };
-    let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), meta_map)
-        .unwrap();
+    let snapshot =
+        SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), meta_map).unwrap();
 
     let signed = SignedMetadata::<Json, SnapshotMetadata>::new(&snapshot, &snapshot_key).unwrap();
 
@@ -95,7 +96,7 @@
                 vec![VirtualTargetPath::new("foo".into()).unwrap()]
                     .iter()
                     .cloned()
-                    .collect()
+                    .collect(),
             ).unwrap(),
         ],
     ).unwrap();
@@ -112,16 +113,15 @@
 
     //// build the delegation ////
     let target_file: &[u8] = b"bar";
-    let target_map =
-        hashmap! {
+    let target_map = hashmap! {
         VirtualTargetPath::new("foo".into()).unwrap() =>
             TargetDescription::from_reader(target_file, &[HashAlgorithm::Sha256]).unwrap(),
     };
     let delegation =
         TargetsMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), target_map, None).unwrap();
 
-    let signed = SignedMetadata::<Json, TargetsMetadata>::new(&delegation, &delegation_key)
-        .unwrap();
+    let signed =
+        SignedMetadata::<Json, TargetsMetadata>::new(&delegation, &delegation_key).unwrap();
 
     tuf.update_delegation(&MetadataPath::new("delegation".into()).unwrap(), &signed)
         .unwrap();
@@ -173,14 +173,13 @@
     let snap = MetadataDescription::from_reader(&*vec![0u8], 1, &[HashAlgorithm::Sha256]).unwrap();
     let timestamp = TimestampMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), snap).unwrap();
 
-    let signed = SignedMetadata::<Json, TimestampMetadata>::new(&timestamp, &timestamp_key)
-        .unwrap();
+    let signed =
+        SignedMetadata::<Json, TimestampMetadata>::new(&timestamp, &timestamp_key).unwrap();
 
     tuf.update_timestamp(&signed).unwrap();
 
     //// build the snapshot ////
-    let meta_map =
-        hashmap! {
+    let meta_map = hashmap! {
         MetadataPath::new("targets".into()).unwrap() =>
             MetadataDescription::from_reader(&*vec![0u8], 1, &[HashAlgorithm::Sha256]).unwrap(),
         MetadataPath::new("delegation-a".into()).unwrap() =>
@@ -188,8 +187,8 @@
         MetadataPath::new("delegation-b".into()).unwrap() =>
             MetadataDescription::from_reader(&*vec![0u8], 1, &[HashAlgorithm::Sha256]).unwrap(),
     };
-    let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), meta_map)
-        .unwrap();
+    let snapshot =
+        SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), meta_map).unwrap();
 
     let signed = SignedMetadata::<Json, SnapshotMetadata>::new(&snapshot, &snapshot_key).unwrap();
 
@@ -210,7 +209,7 @@
                 vec![VirtualTargetPath::new("foo".into()).unwrap()]
                     .iter()
                     .cloned()
-                    .collect()
+                    .collect(),
             ).unwrap(),
         ],
     ).unwrap();
@@ -240,7 +239,7 @@
                 vec![VirtualTargetPath::new("foo".into()).unwrap()]
                     .iter()
                     .cloned()
-                    .collect()
+                    .collect(),
             ).unwrap(),
         ],
     ).unwrap();
@@ -251,16 +250,15 @@
         Some(delegations),
     ).unwrap();
 
-    let signed = SignedMetadata::<Json, TargetsMetadata>::new(&delegation, &delegation_a_key)
-        .unwrap();
+    let signed =
+        SignedMetadata::<Json, TargetsMetadata>::new(&delegation, &delegation_a_key).unwrap();
 
     tuf.update_delegation(&MetadataPath::new("delegation-a".into()).unwrap(), &signed)
         .unwrap();
 
     //// build delegation B ////
     let target_file: &[u8] = b"bar";
-    let target_map =
-        hashmap! {
+    let target_map = hashmap! {
         VirtualTargetPath::new("foo".into()).unwrap() =>
             TargetDescription::from_reader(target_file, &[HashAlgorithm::Sha256]).unwrap(),
     };
@@ -268,8 +266,8 @@
     let delegation =
         TargetsMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), target_map, None).unwrap();
 
-    let signed = SignedMetadata::<Json, TargetsMetadata>::new(&delegation, &delegation_b_key)
-        .unwrap();
+    let signed =
+        SignedMetadata::<Json, TargetsMetadata>::new(&delegation, &delegation_b_key).unwrap();
 
     tuf.update_delegation(&MetadataPath::new("delegation-b".into()).unwrap(), &signed)
         .unwrap();
diff --git a/tests/simple_example.rs b/tests/simple_example.rs
index fc06d14..5782fa0 100644
--- a/tests/simple_example.rs
+++ b/tests/simple_example.rs
@@ -3,16 +3,18 @@
 extern crate maplit;
 extern crate tuf;
 
-use chrono::prelude::*;
 use chrono::offset::Utc;
-use tuf::Result;
+use chrono::prelude::*;
 use tuf::client::{Client, Config, PathTranslator};
-use tuf::crypto::{PrivateKey, SignatureScheme, KeyId, HashAlgorithm};
+use tuf::crypto::{HashAlgorithm, KeyId, PrivateKey, SignatureScheme};
 use tuf::interchange::{DataInterchange, Json};
-use tuf::metadata::{RoleDefinition, RootMetadata, MetadataVersion, MetadataPath,
-                    SignedMetadata, TargetDescription, VirtualTargetPath, TargetsMetadata,
-                    MetadataDescription, SnapshotMetadata, TimestampMetadata, TargetPath};
+use tuf::metadata::{
+    MetadataDescription, MetadataPath, MetadataVersion, RoleDefinition, RootMetadata,
+    SignedMetadata, SnapshotMetadata, TargetDescription, TargetPath, TargetsMetadata,
+    TimestampMetadata, VirtualTargetPath,
+};
 use tuf::repository::{EphemeralRepository, Repository};
+use tuf::Result;
 
 // Ironically, this is far from simple, but it's as simple as it can be made.
 
@@ -145,8 +147,7 @@
     let targets_bytes = Json::canonicalize(&Json::serialize(&signed)?)?;
 
     //// build the snapshot ////
-    let meta_map =
-        hashmap! {
+    let meta_map = hashmap! {
         MetadataPath::new("targets".into())? =>
             MetadataDescription::from_reader(&*targets_bytes, 1, &[HashAlgorithm::Sha256])?,
     };