diff --git a/src/client.rs b/src/client.rs
index 7b2cdd1..097b309 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -85,21 +85,25 @@
         local.initialize()?;
         remote.initialize()?;
 
-        let root = local.fetch_metadata(
-            &Role::Root,
-            &MetadataPath::from_role(&Role::Root),
-            &MetadataVersion::Number(1),
-            &config.max_root_size,
-            config.min_bytes_per_second,
-            None
-        ).or_else(|_| local.fetch_metadata(
-            &Role::Root,
-            &MetadataPath::from_role(&Role::Root),
-            &MetadataVersion::Number(1),
-            &config.max_root_size,
-            config.min_bytes_per_second,
-            None
-        ))?;
+        let root = local
+            .fetch_metadata(
+                &Role::Root,
+                &MetadataPath::from_role(&Role::Root),
+                &MetadataVersion::Number(1),
+                &config.max_root_size,
+                config.min_bytes_per_second,
+                None,
+            )
+            .or_else(|_| {
+                local.fetch_metadata(
+                    &Role::Root,
+                    &MetadataPath::from_role(&Role::Root),
+                    &MetadataVersion::Number(1),
+                    &config.max_root_size,
+                    config.min_bytes_per_second,
+                    None,
+                )
+            })?;
 
         let tuf = Tuf::from_root(root)?;
 
@@ -113,13 +117,13 @@
 
     /// Create a new TUF client. It will attempt to load initial root metadata the local and remote
     /// repositories using the provided key IDs to pin the verification.
-    /// 
+    ///
     /// This is the preferred method of creating a client.
     pub fn with_root_pinned<'a, I>(
         trusted_root_keys: I,
         config: Config,
         mut local: L,
-        mut remote: R
+        mut remote: R,
     ) -> Result<Self>
     where
         I: IntoIterator<Item = &'a KeyId>,
@@ -127,21 +131,25 @@
         local.initialize()?;
         remote.initialize()?;
 
-        let root = local.fetch_metadata(
-            &Role::Root,
-            &MetadataPath::from_role(&Role::Root),
-            &MetadataVersion::Number(1),
-            &config.max_root_size,
-            config.min_bytes_per_second,
-            None
-        ).or_else(|_| remote.fetch_metadata(
-            &Role::Root,
-            &MetadataPath::from_role(&Role::Root),
-            &MetadataVersion::Number(1),
-            &config.max_root_size,
-            config.min_bytes_per_second,
-            None
-        ))?;
+        let root = local
+            .fetch_metadata(
+                &Role::Root,
+                &MetadataPath::from_role(&Role::Root),
+                &MetadataVersion::Number(1),
+                &config.max_root_size,
+                config.min_bytes_per_second,
+                None,
+            )
+            .or_else(|_| {
+                remote.fetch_metadata(
+                    &Role::Root,
+                    &MetadataPath::from_role(&Role::Root),
+                    &MetadataVersion::Number(1),
+                    &config.max_root_size,
+                    config.min_bytes_per_second,
+                    None,
+                )
+            })?;
 
         let tuf = Tuf::from_root_pinned(root, trusted_root_keys)?;
 
diff --git a/src/metadata.rs b/src/metadata.rs
index e0816c6..1fbd10a 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -432,13 +432,9 @@
     ///         &[],
     ///     ).is_err());
     /// }
-    pub fn verify<'a, I>(
-        &self,
-        threshold: u32,
-        authorized_keys: I,
-    ) -> Result<()> 
+    pub fn verify<'a, I>(&self, threshold: u32, authorized_keys: I) -> Result<()>
     where
-        I: IntoIterator<Item = &'a PublicKey>
+        I: IntoIterator<Item = &'a PublicKey>,
     {
         if self.signatures.len() < 1 {
             return Err(Error::VerificationFailure(
@@ -453,7 +449,10 @@
             ));
         }
 
-        let authorized_keys = authorized_keys.into_iter().map(|k| (k.key_id(), k)).collect::<HashMap<&KeyId, &PublicKey>>();
+        let authorized_keys = authorized_keys
+            .into_iter()
+            .map(|k| (k.key_id(), k))
+            .collect::<HashMap<&KeyId, &PublicKey>>();
 
         let canonical_bytes = D::canonicalize(&self.signed)?;
 
diff --git a/src/tuf.rs b/src/tuf.rs
index 2750c33..1db839a 100644
--- a/src/tuf.rs
+++ b/src/tuf.rs
@@ -30,7 +30,7 @@
         root_key_ids: I,
     ) -> Result<Self>
     where
-        I: IntoIterator<Item=&'a KeyId>,
+        I: IntoIterator<Item = &'a KeyId>,
     {
         let root_key_ids = root_key_ids.into_iter().collect::<HashSet<&KeyId>>();
 
@@ -48,7 +48,16 @@
         let root = D::deserialize::<RootMetadata>(signed_root.signed())?;
         let _ = signed_root.verify(
             root.root().threshold(),
-            root.keys().iter().filter_map(|(k, v)| if root.root().key_ids().contains(k) { Some(v) } else { None }),
+            root.keys().iter().filter_map(
+                |(k, v)| if root.root()
+                    .key_ids()
+                    .contains(k)
+                {
+                    Some(v)
+                } else {
+                    None
+                },
+            ),
         )?;
         Ok(Tuf {
             root: root,
@@ -89,7 +98,13 @@
     pub fn update_root(&mut self, signed_root: SignedMetadata<D, RootMetadata>) -> Result<bool> {
         signed_root.verify(
             self.root.root().threshold(),
-            self.root.keys().iter().filter_map(|(k, v)| if self.root.root().key_ids().contains(k) { Some(v) } else { None }),
+            self.root.keys().iter().filter_map(|(k, v)| {
+                if self.root.root().key_ids().contains(k) {
+                    Some(v)
+                } else {
+                    None
+                }
+            }),
         )?;
 
         let root = D::deserialize::<RootMetadata>(signed_root.signed())?;
@@ -114,7 +129,16 @@
 
         let _ = signed_root.verify(
             root.root().threshold(),
-            root.keys().iter().filter_map(|(k, v)| if root.root().key_ids().contains(k) { Some(v) } else { None }),
+            root.keys().iter().filter_map(
+                |(k, v)| if root.root()
+                    .key_ids()
+                    .contains(k)
+                {
+                    Some(v)
+                } else {
+                    None
+                },
+            ),
         )?;
 
         self.purge_metadata();
@@ -130,7 +154,15 @@
     ) -> 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);
@@ -176,7 +208,15 @@
 
             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())?;
@@ -260,7 +300,13 @@
 
             signed_targets.verify(
                 root.targets().threshold(),
-                root.keys().iter().filter_map(|(k, v)| if root.targets().key_ids().contains(k) { Some(v) } else { None }),
+                root.keys().iter().filter_map(|(k, v)| {
+                    if root.targets().key_ids().contains(k) {
+                        Some(v)
+                    } else {
+                        None
+                    }
+                }),
             )?;
 
             let targets: TargetsMetadata = D::deserialize(&signed_targets.signed())?;
@@ -339,7 +385,16 @@
 
                 signed.verify(
                     delegation.threshold(),
-                    parent.keys().iter().filter_map(|(k, v)| if delegation.key_ids().contains(k) { Some(v) } else { None }),
+                    parent.keys().iter().filter_map(
+                        |(k, v)| if delegation
+                            .key_ids()
+                            .contains(k)
+                        {
+                            Some(v)
+                        } else {
+                            None
+                        },
+                    ),
                 )?;
             }