diff --git a/src/client.rs b/src/client.rs
index 06670dc..a5f7053 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -701,7 +701,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()).collect()
+            keys.iter().map(|b| PrivateKey::from_pkcs8(b, SignatureScheme::Ed25519)
+                            .unwrap()).collect()
         };
     }
 
@@ -718,8 +719,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(
             &Role::Root,
@@ -738,12 +739,11 @@
             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();
-
-        root.add_signature(&KEYS[0])
+        let mut root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[1])
             .unwrap();
 
+        root.add_signature(&KEYS[0]).unwrap();
+
         repo.store_metadata(
             &Role::Root,
             &MetadataPath::from_role(&Role::Root),
@@ -761,12 +761,11 @@
             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();
-
-        root.add_signature(&KEYS[1])
+        let mut root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[2])
             .unwrap();
 
+        root.add_signature(&KEYS[1]).unwrap();
+
         repo.store_metadata(
             &Role::Root,
             &MetadataPath::from_role(&Role::Root),
diff --git a/src/crypto.rs b/src/crypto.rs
index 715f687..2ea2b48 100644
--- a/src/crypto.rs
+++ b/src/crypto.rs
@@ -380,11 +380,15 @@
             Ok(k) => {
                 match scheme {
                     SignatureScheme::Ed25519 => (),
-                    s => return Err(Error::IllegalArgument(format!(
-                        "Cannot use signature scheme {:?} with Ed25519 keys", s)))
+                    s => {
+                        return Err(Error::IllegalArgument(format!(
+                            "Cannot use signature scheme {:?} with Ed25519 keys",
+                            s
+                        )))
+                    }
                 };
                 Ok(k)
-            },
+            }
             Err(e1) => {
                 match Self::rsa_from_pkcs8(der_key, scheme) {
                     Ok(k) => Ok(k),
@@ -421,8 +425,11 @@
 
     fn rsa_from_pkcs8(der_key: &[u8], scheme: SignatureScheme) -> Result<Self> {
         match &scheme {
-            &SignatureScheme::Ed25519 => return Err(Error::IllegalArgument(
-                    "RSA keys do not support the Ed25519 signing scheme".into())),
+            &SignatureScheme::Ed25519 => {
+                return Err(Error::IllegalArgument(
+                    "RSA keys do not support the Ed25519 signing scheme".into(),
+                ))
+            }
             _ => (),
         }
 
@@ -560,7 +567,7 @@
     pub fn typ(&self) -> &KeyType {
         &self.typ
     }
-    
+
     /// An immutable referece to the key's authorized signing scheme.
     pub fn scheme(&self) -> &SignatureScheme {
         &self.scheme
@@ -635,9 +642,10 @@
             .decode(intermediate.public_key().as_bytes())
             .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))
-        })?;
+        let key = PublicKey::from_spki(&bytes, intermediate.scheme().clone())
+            .map_err(|e| {
+                DeserializeError::custom(format!("Couldn't parse key as SPKI: {:?}", e))
+            })?;
 
         if intermediate.typ() != &key.typ {
             return Err(DeserializeError::custom(
@@ -874,7 +882,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/metadata.rs b/src/metadata.rs
index ac6e9a7..22eae38 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -264,10 +264,7 @@
     /// SignedMetadata::<Json, TimestampMetadata>::new(&timestamp, &key).unwrap();
     /// # }
     /// ```
-    pub fn new(
-        metadata: &M,
-        private_key: &PrivateKey,
-    ) -> Result<SignedMetadata<D, M>> {
+    pub fn new(metadata: &M, private_key: &PrivateKey) -> Result<SignedMetadata<D, M>> {
         let raw = D::serialize(metadata)?;
         let bytes = D::canonicalize(&raw)?;
         let sig = private_key.sign(&bytes)?;
@@ -321,10 +318,7 @@
     /// assert_eq!(timestamp.signatures().len(), 2);
     /// # }
     /// ```
-    pub fn add_signature(
-        &mut self,
-        private_key: &PrivateKey,
-    ) -> Result<()> {
+    pub fn add_signature(&mut self, private_key: &PrivateKey) -> Result<()> {
         let raw = D::serialize(&self.signed)?;
         let bytes = D::canonicalize(&raw)?;
         let sig = private_key.sign(&bytes)?;
@@ -1571,7 +1565,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(),
@@ -1824,10 +1819,7 @@
 
         let key = PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519).unwrap();
 
-        let signed = SignedMetadata::<Json, SnapshotMetadata>::new(
-            &snapshot,
-            &key,
-        ).unwrap();
+        let signed = SignedMetadata::<Json, SnapshotMetadata>::new(&snapshot, &key).unwrap();
 
         let jsn = json!({
             "signatures": [
@@ -1879,28 +1871,32 @@
     //                                 `.___,'   `.__,'   `.__,'
     //
     ///////////////////////////////////////////////////////////////////////////////////////////////
-    
+
     // TODO test for mismatched ed25519/rsa keys/schemes
 
     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(
@@ -1908,10 +1904,14 @@
             Utc.ymd(2038, 1, 1).and_hms(0, 0, 0),
             false,
             vec!(
-                PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519).unwrap().public().clone(),
-                PrivateKey::from_pkcs8(ED25519_2_PK8, SignatureScheme::Ed25519).unwrap().public().clone(),
-                PrivateKey::from_pkcs8(ED25519_3_PK8, SignatureScheme::Ed25519).unwrap().public().clone(),
-                PrivateKey::from_pkcs8(ED25519_4_PK8, SignatureScheme::Ed25519).unwrap().public().clone(),
+                PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519)
+                    .unwrap().public().clone(),
+                PrivateKey::from_pkcs8(ED25519_2_PK8, SignatureScheme::Ed25519)
+                    .unwrap().public().clone(),
+                PrivateKey::from_pkcs8(ED25519_3_PK8, SignatureScheme::Ed25519)
+                    .unwrap().public().clone(),
+                PrivateKey::from_pkcs8(ED25519_4_PK8, SignatureScheme::Ed25519)
+                    .unwrap().public().clone(),
             ),
             root_def,
             snapshot_def,
@@ -2042,7 +2042,8 @@
     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();
@@ -2056,8 +2057,10 @@
         let role_def = RoleDefinition::new(
             2,
             hashset!(
-                PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519).unwrap().key_id().clone(),
-                PrivateKey::from_pkcs8(ED25519_2_PK8, SignatureScheme::Ed25519).unwrap().key_id().clone(),
+                PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519)
+                    .unwrap().key_id().clone(),
+                PrivateKey::from_pkcs8(ED25519_2_PK8, SignatureScheme::Ed25519)
+                    .unwrap().key_id().clone(),
             ),
         ).unwrap();
 
diff --git a/src/shims.rs b/src/shims.rs
index db2182a..286af1d 100644
--- a/src/shims.rs
+++ b/src/shims.rs
@@ -238,7 +238,11 @@
 }
 
 impl PublicKey {
-    pub fn new(typ: crypto::KeyType, scheme: crypto::SignatureScheme, public_key_bytes: &[u8]) -> Self {
+    pub fn new(
+        typ: crypto::KeyType,
+        scheme: crypto::SignatureScheme,
+        public_key_bytes: &[u8],
+    ) -> Self {
         PublicKey {
             typ: typ,
             scheme: scheme,
diff --git a/src/tuf.rs b/src/tuf.rs
index 8e06a3f..9b99384 100644
--- a/src/tuf.rs
+++ b/src/tuf.rs
@@ -588,7 +588,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()).collect()
+            keys.iter().map(|b| PrivateKey::from_pkcs8(b, SignatureScheme::Ed25519).unwrap())
+                .collect()
         };
     }
 
@@ -605,8 +606,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 +624,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 +642,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,12 +657,11 @@
             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();
+        root.add_signature(&KEYS[0]).unwrap();
 
         assert_eq!(tuf.update_root(root.clone()), Ok(true));
 
@@ -681,8 +681,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();
 
@@ -697,8 +697,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());
     }
@@ -715,8 +715,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[0]).unwrap();
+        let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
+            .unwrap();
 
         let mut tuf = Tuf::from_root(root).unwrap();
 
@@ -747,8 +747,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[0]).unwrap();
+        let root: SignedMetadata<Json, RootMetadata> = SignedMetadata::new(&root, &KEYS[0])
+            .unwrap();
 
         let mut tuf = Tuf::from_root(root).unwrap();
 
@@ -782,8 +782,8 @@
             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();
 
@@ -825,8 +825,8 @@
             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();
 
@@ -865,8 +865,8 @@
             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();
 
@@ -906,8 +906,8 @@
             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();
 
@@ -963,8 +963,8 @@
             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();
 
@@ -1017,8 +1017,8 @@
             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();
 
diff --git a/tests/integration.rs b/tests/integration.rs
index f97150d..ba8095c 100644
--- a/tests/integration.rs
+++ b/tests/integration.rs
@@ -52,9 +52,7 @@
         timestamp_def,
     ).unwrap();
 
-    let signed =
-        SignedMetadata::<Json, RootMetadata>::new(&root, &root_key)
-            .unwrap();
+    let signed = SignedMetadata::<Json, RootMetadata>::new(&root, &root_key).unwrap();
 
     let mut tuf = Tuf::<Json>::from_root_pinned(signed, &[root_key.key_id().clone()]).unwrap();
 
@@ -62,10 +60,8 @@
     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();
 
@@ -80,10 +76,7 @@
     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();
+    let signed = SignedMetadata::<Json, SnapshotMetadata>::new(&snapshot, &snapshot_key).unwrap();
 
     tuf.update_snapshot(signed).unwrap();
 
@@ -113,10 +106,7 @@
         Some(delegations),
     ).unwrap();
 
-    let signed = SignedMetadata::<Json, TargetsMetadata>::new(
-        &targets,
-        &targets_key,
-    ).unwrap();
+    let signed = SignedMetadata::<Json, TargetsMetadata>::new(&targets, &targets_key).unwrap();
 
     tuf.update_targets(signed).unwrap();
 
@@ -130,10 +120,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_key,
-    ).unwrap();
+    let signed = SignedMetadata::<Json, TargetsMetadata>::new(&delegation, &delegation_key)
+        .unwrap();
 
     tuf.update_delegation(&MetadataPath::new("delegation".into()).unwrap(), signed)
         .unwrap();
@@ -177,9 +165,7 @@
         timestamp_def,
     ).unwrap();
 
-    let signed =
-        SignedMetadata::<Json, RootMetadata>::new(&root, &root_key)
-            .unwrap();
+    let signed = SignedMetadata::<Json, RootMetadata>::new(&root, &root_key).unwrap();
 
     let mut tuf = Tuf::<Json>::from_root_pinned(signed, &[root_key.key_id().clone()]).unwrap();
 
@@ -187,10 +173,8 @@
     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();
 
@@ -207,10 +191,7 @@
     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();
+    let signed = SignedMetadata::<Json, SnapshotMetadata>::new(&snapshot, &snapshot_key).unwrap();
 
     tuf.update_snapshot(signed).unwrap();
 
@@ -240,10 +221,7 @@
         Some(delegations),
     ).unwrap();
 
-    let signed = SignedMetadata::<Json, TargetsMetadata>::new(
-        &targets,
-        &targets_key,
-    ).unwrap();
+    let signed = SignedMetadata::<Json, TargetsMetadata>::new(&targets, &targets_key).unwrap();
 
     tuf.update_targets(signed).unwrap();
 
@@ -273,10 +251,8 @@
         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();
@@ -292,10 +268,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 d767ced..a4c451a 100644
--- a/tests/simple_example.rs
+++ b/tests/simple_example.rs
@@ -72,8 +72,7 @@
         timestamp_def,
     )?;
 
-    let signed =
-        SignedMetadata::<Json, RootMetadata>::new(&root, &root_key)?;
+    let signed = SignedMetadata::<Json, RootMetadata>::new(&root, &root_key)?;
 
     remote.store_metadata(
         &Role::Root,
@@ -98,10 +97,7 @@
     let target_map = hashmap!(target_path => target_description);
     let targets = TargetsMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), target_map, None)?;
 
-    let signed = SignedMetadata::<Json, TargetsMetadata>::new(
-        &targets,
-        &targets_key,
-    )?;
+    let signed = SignedMetadata::<Json, TargetsMetadata>::new(&targets, &targets_key)?;
 
     remote.store_metadata(
         &Role::Targets,
@@ -126,10 +122,7 @@
     };
     let snapshot = SnapshotMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), meta_map)?;
 
-    let signed = SignedMetadata::<Json, SnapshotMetadata>::new(
-        &snapshot,
-        &snapshot_key,
-    )?;
+    let signed = SignedMetadata::<Json, SnapshotMetadata>::new(&snapshot, &snapshot_key)?;
 
     remote.store_metadata(
         &Role::Snapshot,
@@ -150,10 +143,7 @@
     let snap = MetadataDescription::from_reader(&*snapshot_bytes, 1, &[HashAlgorithm::Sha256])?;
     let timestamp = TimestampMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), snap)?;
 
-    let signed = SignedMetadata::<Json, TimestampMetadata>::new(
-        &timestamp,
-        &timestamp_key,
-    )?;
+    let signed = SignedMetadata::<Json, TimestampMetadata>::new(&timestamp, &timestamp_key)?;
 
     remote.store_metadata(
         &Role::Timestamp,