Reformat with rustfmt 0.8.2-stable (08da30d7 2018-06-06)
diff --git a/src/client.rs b/src/client.rs
index 67c62cf..95ca100 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -134,14 +134,13 @@
     /// **WARNING**: This method offers weaker security guarantees than the related method
     /// `with_root_pinned`.
     pub fn new(config: Config<T>, local: L, remote: R) -> Result<Self> {
-        let root = local
-            .fetch_metadata(
-                &MetadataPath::from_role(&Role::Root),
-                &MetadataVersion::Number(1),
-                &config.max_root_size,
-                config.min_bytes_per_second,
-                None,
-            )?;
+        let root = local.fetch_metadata(
+            &MetadataPath::from_role(&Role::Root),
+            &MetadataVersion::Number(1),
+            &config.max_root_size,
+            config.min_bytes_per_second,
+            None,
+        )?;
 
         let tuf = Tuf::from_root(root)?;
 
@@ -557,7 +556,8 @@
 
         let virt = self.config.path_translator.real_to_virtual(target)?;
 
-        let snapshot = self.tuf
+        let snapshot = self
+            .tuf
             .snapshot()
             .ok_or_else(|| Error::MissingMetadata(Role::Snapshot))?
             .clone();
diff --git a/src/crypto.rs b/src/crypto.rs
index 3050122..4ba4710 100644
--- a/src/crypto.rs
+++ b/src/crypto.rs
@@ -671,7 +671,8 @@
     where
         S: Serializer,
     {
-        let bytes = self.as_spki()
+        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)
     }
diff --git a/src/interchange/cjson.rs b/src/interchange/cjson.rs
index b6e0095..f7c23a9 100644
--- a/src/interchange/cjson.rs
+++ b/src/interchange/cjson.rs
@@ -92,7 +92,8 @@
     match *jsn {
         json::Value::Null => Ok(Value::Null),
         json::Value::Bool(b) => Ok(Value::Bool(b)),
-        json::Value::Number(ref n) => n.as_i64()
+        json::Value::Number(ref n) => n
+            .as_i64()
             .map(Number::I64)
             .or_else(|| n.as_u64().map(Number::U64))
             .map(Value::Number)
diff --git a/src/metadata.rs b/src/metadata.rs
index dbc5770..5f49e43 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -15,12 +15,14 @@
 use shims;
 use Result;
 
+#[cfg_attr(rustfmt, rustfmt_skip)]
 static PATH_ILLEGAL_COMPONENTS: &'static [&str] = &[
     ".", // current dir
     "..", // parent dir
          // TODO ? "0", // may translate to nul in windows
 ];
 
+#[cfg_attr(rustfmt, rustfmt_skip)]
 static PATH_ILLEGAL_COMPONENTS_CASE_INSENSITIVE: &'static [&str] = &[
     // DOS device files
     "CON",
@@ -52,6 +54,7 @@
     "CONFIG$",
 ];
 
+#[cfg_attr(rustfmt, rustfmt_skip)]
 static PATH_ILLEGAL_STRINGS: &'static [&str] = &[
     ":", // for *nix compatibility
     "\\", // for windows compatibility
@@ -236,7 +239,7 @@
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct SignedMetadata<D, M> {
     signatures: Vec<Signature>,
-    #[serde(rename="signed")]
+    #[serde(rename = "signed")]
     metadata: M,
     #[serde(skip_serializing, skip_deserializing)]
     _interchage: PhantomData<D>,
@@ -334,7 +337,8 @@
             ));
         }
 
-        let key_ids = self.signatures
+        let key_ids = self
+            .signatures
             .iter()
             .map(|s| s.key_id().clone())
             .collect::<HashSet<KeyId>>();
@@ -608,28 +612,17 @@
             self.expires,
             self.consistent_snapshot,
             self.keys,
-            RoleDefinition::new(
-                self.root_threshold,
-                self.root_key_ids,
-            )?,
-            RoleDefinition::new(
-                self.snapshot_threshold,
-                self.snapshot_key_ids,
-            )?,
-            RoleDefinition::new(
-                self.targets_threshold,
-                self.targets_key_ids,
-            )?,
-            RoleDefinition::new(
-                self.timestamp_threshold,
-                self.timestamp_key_ids,
-            )?,
+            RoleDefinition::new(self.root_threshold, self.root_key_ids)?,
+            RoleDefinition::new(self.snapshot_threshold, self.snapshot_key_ids)?,
+            RoleDefinition::new(self.targets_threshold, self.targets_key_ids)?,
+            RoleDefinition::new(self.timestamp_threshold, self.timestamp_key_ids)?,
         )
     }
 
     /// Construct a new `SignedMetadata<D, RootMetadata>`.
     pub fn signed<D>(self, private_key: &PrivateKey) -> Result<SignedMetadata<D, RootMetadata>>
-        where D: DataInterchange,
+    where
+        D: DataInterchange,
     {
         Ok(SignedMetadata::new(self.build()?, private_key)?)
     }
@@ -939,11 +932,7 @@
         M: Metadata,
     {
         let bytes = D::canonicalize(&D::serialize(&snapshot)?)?;
-        let description = MetadataDescription::from_reader(
-            &*bytes,
-            snapshot.version(),
-            hash_algs,
-        )?;
+        let description = MetadataDescription::from_reader(&*bytes, snapshot.version(), hash_algs)?;
 
         Ok(Self::from_metadata_description(description))
     }
@@ -975,16 +964,13 @@
 
     /// Construct a new `TimestampMetadata`.
     pub fn build(self) -> Result<TimestampMetadata> {
-        TimestampMetadata::new(
-            self.version,
-            self.expires,
-            self.snapshot,
-        )
+        TimestampMetadata::new(self.version, self.expires, self.snapshot)
     }
 
     /// Construct a new `SignedMetadata<D, TimestampMetadata>`.
     pub fn signed<D>(self, private_key: &PrivateKey) -> Result<SignedMetadata<D, TimestampMetadata>>
-        where D: DataInterchange,
+    where
+        D: DataInterchange,
     {
         Ok(SignedMetadata::new(self.build()?, private_key)?)
     }
@@ -1183,14 +1169,10 @@
         hash_algs: &[HashAlgorithm],
     ) -> Result<Self>
     where
-          M: Metadata,
-          D: DataInterchange,
+        M: Metadata,
+        D: DataInterchange,
     {
-        self.insert_metadata_with_path(
-            M::ROLE.name(),
-            metadata,
-            hash_algs,
-        )
+        self.insert_metadata_with_path(M::ROLE.name(), metadata, hash_algs)
     }
 
     /// Add metadata to this snapshot metadata using a custom path.
@@ -1201,16 +1183,12 @@
         hash_algs: &[HashAlgorithm],
     ) -> Result<Self>
     where
-          P: Into<String>,
-          M: Metadata,
-          D: DataInterchange,
+        P: Into<String>,
+        M: Metadata,
+        D: DataInterchange,
     {
         let bytes = D::canonicalize(&D::serialize(metadata)?)?;
-        let description = MetadataDescription::from_reader(
-            &*bytes,
-            metadata.version(),
-            hash_algs,
-        )?;
+        let description = MetadataDescription::from_reader(&*bytes, metadata.version(), hash_algs)?;
         let path = MetadataPath::new(path.into())?;
         Ok(self.insert_metadata_description(path, description))
     }
@@ -1227,16 +1205,13 @@
 
     /// Construct a new `SnapshotMetadata`.
     pub fn build(self) -> Result<SnapshotMetadata> {
-        SnapshotMetadata::new(
-            self.version,
-            self.expires,
-            self.meta,
-        )
+        SnapshotMetadata::new(self.version, self.expires, self.meta)
     }
 
     /// Construct a new `SignedMetadata<D, SnapshotMetadata>`.
     pub fn signed<D>(self, private_key: &PrivateKey) -> Result<SignedMetadata<D, SnapshotMetadata>>
-        where D: DataInterchange,
+    where
+        D: DataInterchange,
     {
         Ok(SignedMetadata::new(self.build()?, private_key)?)
     }
@@ -1655,7 +1630,7 @@
         hash_algs: &[HashAlgorithm],
     ) -> Result<Self>
     where
-          R: Read,
+        R: Read,
     {
         let description = TargetDescription::from_reader(read, hash_algs)?;
         Ok(self.insert_target_description(path, description))
@@ -1679,17 +1654,13 @@
 
     /// Construct a new `TargetsMetadata`.
     pub fn build(self) -> Result<TargetsMetadata> {
-        TargetsMetadata::new(
-            self.version,
-            self.expires,
-            self.targets,
-            self.delegations,
-        )
+        TargetsMetadata::new(self.version, self.expires, self.targets, self.delegations)
     }
 
     /// Construct a new `SignedMetadata<D, TargetsMetadata>`.
     pub fn signed<D>(self, private_key: &PrivateKey) -> Result<SignedMetadata<D, TargetsMetadata>>
-        where D: DataInterchange,
+    where
+        D: DataInterchange,
     {
         Ok(SignedMetadata::new(self.build()?, private_key)?)
     }
@@ -1728,7 +1699,8 @@
         }
 
         Ok(Delegations {
-            keys: keys.iter()
+            keys: keys
+                .iter()
                 .cloned()
                 .map(|k| (k.key_id().clone(), k))
                 .collect(),
@@ -1918,7 +1890,8 @@
         for case in test_cases {
             let expected = case.0;
             let target = VirtualTargetPath::new(case.1.into()).unwrap();
-            let parents = case.2
+            let parents = case
+                .2
                 .iter()
                 .map(|group| {
                     group
@@ -2152,10 +2125,7 @@
             .expires(Utc.ymd(2017, 1, 1).and_hms(0, 0, 0))
             .insert_target_description(
                 VirtualTargetPath::new("foo".into()).unwrap(),
-                TargetDescription::from_reader(
-                    &b"foo"[..],
-                    &[HashAlgorithm::Sha256],
-                ).unwrap(),
+                TargetDescription::from_reader(&b"foo"[..], &[HashAlgorithm::Sha256]).unwrap(),
             )
             .build()
             .unwrap();
@@ -2307,20 +2277,15 @@
     // TODO test for mismatched ed25519/rsa keys/schemes
 
     fn make_root() -> json::Value {
-        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 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 root = RootMetadataBuilder::new()
             .expires(Utc.ymd(2038, 1, 1).and_hms(0, 0, 0))
-            .root_key(
-                root_key.public().clone()
-            )
+            .root_key(root_key.public().clone())
             .snapshot_key(snapshot_key.public().clone())
             .targets_key(targets_key.public().clone())
             .timestamp_key(timestamp_key.public().clone())
@@ -2340,11 +2305,8 @@
     }
 
     fn make_timestamp() -> json::Value {
-        let description = MetadataDescription::from_reader(
-            &[][..],
-            1,
-            &[HashAlgorithm::Sha256],
-        ).unwrap();
+        let description =
+            MetadataDescription::from_reader(&[][..], 1, &[HashAlgorithm::Sha256]).unwrap();
 
         let timestamp = TimestampMetadataBuilder::from_metadata_description(description)
             .expires(Utc.ymd(2017, 1, 1).and_hms(0, 0, 0))
@@ -2496,7 +2458,8 @@
     #[test]
     fn deserialize_json_root_bad_type() {
         let mut root = make_root();
-        let _ = root.as_object_mut()
+        let _ = root
+            .as_object_mut()
             .unwrap()
             .insert("type".into(), json!("snapshot"));
         assert!(json::from_value::<RootMetadata>(root).is_err());
diff --git a/src/repository.rs b/src/repository.rs
index 8c851f7..7304d79 100644
--- a/src/repository.rs
+++ b/src/repository.rs
@@ -530,7 +530,10 @@
 
     #[test]
     fn file_system_repo_targets() {
-        let temp_dir = tempfile::Builder::new().prefix("rust-tuf").tempdir().unwrap();
+        let temp_dir = tempfile::Builder::new()
+            .prefix("rust-tuf")
+            .tempdir()
+            .unwrap();
         let repo = FileSystemRepository::<Json>::new(temp_dir.path().to_path_buf()).unwrap();
 
         // test that init worked
diff --git a/src/shims.rs b/src/shims.rs
index 890c0b8..294474e 100644
--- a/src/shims.rs
+++ b/src/shims.rs
@@ -42,7 +42,8 @@
 
 impl RootMetadata {
     pub fn from(meta: &metadata::RootMetadata) -> Result<Self> {
-        let mut keys = meta.keys()
+        let mut keys = meta
+            .keys()
             .iter()
             .map(|(_, v)| v.clone())
             .collect::<Vec<crypto::PublicKey>>();
@@ -97,7 +98,8 @@
 
 impl RoleDefinition {
     pub fn from(role: &metadata::RoleDefinition) -> Result<Self> {
-        let mut key_ids = role.key_ids()
+        let mut key_ids = role
+            .key_ids()
             .iter()
             .cloned()
             .collect::<Vec<crypto::KeyId>>();
@@ -281,12 +283,14 @@
 
 impl Delegation {
     pub fn from(meta: &metadata::Delegation) -> Self {
-        let mut paths = meta.paths()
+        let mut paths = meta
+            .paths()
             .iter()
             .cloned()
             .collect::<Vec<metadata::VirtualTargetPath>>();
         paths.sort();
-        let mut key_ids = meta.key_ids()
+        let mut key_ids = meta
+            .key_ids()
             .iter()
             .cloned()
             .collect::<Vec<crypto::KeyId>>();
@@ -302,7 +306,8 @@
     }
 
     pub fn try_into(self) -> Result<metadata::Delegation> {
-        let paths = self.paths
+        let paths = self
+            .paths
             .iter()
             .cloned()
             .collect::<HashSet<metadata::VirtualTargetPath>>();
@@ -310,7 +315,8 @@
             return Err(Error::Encoding("Non-unique delegation paths.".into()));
         }
 
-        let key_ids = self.key_ids
+        let key_ids = self
+            .key_ids
             .iter()
             .cloned()
             .collect::<HashSet<crypto::KeyId>>();
diff --git a/src/tuf.rs b/src/tuf.rs
index a5c60d6..5ddbc8c 100644
--- a/src/tuf.rs
+++ b/src/tuf.rs
@@ -116,25 +116,29 @@
     }
 
     fn current_timestamp_version(&self) -> u32 {
-        self.timestamp.as_ref()
+        self.timestamp
+            .as_ref()
             .map(|t| t.as_ref().version())
             .unwrap_or(0)
     }
 
     fn current_snapshot_version(&self) -> u32 {
-        self.snapshot.as_ref()
+        self.snapshot
+            .as_ref()
             .map(|t| t.as_ref().version())
             .unwrap_or(0)
     }
 
     fn current_targets_version(&self) -> u32 {
-        self.targets.as_ref()
+        self.targets
+            .as_ref()
             .map(|t| t.as_ref().version())
             .unwrap_or(0)
     }
 
     fn current_delegation_version(&self, role: &MetadataPath) -> u32 {
-        self.delegations.get(role)
+        self.delegations
+            .get(role)
             .map(|t| t.as_ref().version())
             .unwrap_or(0)
     }
@@ -161,7 +165,7 @@
             if new_root.version() == old_root.version() {
                 info!(
                     "Attempted to update root to new metadata with the same version. \
-                    Refusing to update."
+                     Refusing to update."
                 );
                 return Ok(false);
             } else if new_root.version() < old_root.version() {
@@ -285,8 +289,13 @@
             // regardless so we can prevent rollback attacks againsts targets/delegations.
         };
 
-        if self.targets.as_ref().map(|s| s.as_ref().version()).unwrap_or(0)
-            != signed_snapshot.as_ref()
+        if self
+            .targets
+            .as_ref()
+            .map(|s| s.as_ref().version())
+            .unwrap_or(0)
+            != signed_snapshot
+                .as_ref()
                 .meta()
                 .get(&MetadataPath::from_role(&Role::Targets))
                 .map(|m| m.version())
@@ -372,7 +381,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()
                 )));
@@ -457,7 +466,7 @@
             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(),
@@ -616,10 +625,8 @@
     use crypto::{HashAlgorithm, PrivateKey, SignatureScheme};
     use interchange::Json;
     use metadata::{
-        RootMetadataBuilder,
-        SnapshotMetadataBuilder,
+        RootMetadataBuilder, SnapshotMetadataBuilder, TargetsMetadataBuilder,
         TimestampMetadataBuilder,
-        TargetsMetadataBuilder,
     };
 
     lazy_static! {
@@ -734,10 +741,11 @@
             .signed::<Json>(&KEYS[1])
             .unwrap();
 
-        let timestamp = TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
-            .unwrap()
-            .signed::<Json>(&KEYS[1])
-            .unwrap();
+        let timestamp =
+            TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
+                .unwrap()
+                .signed::<Json>(&KEYS[1])
+                .unwrap();
 
         assert_eq!(tuf.update_timestamp(timestamp.clone()), Ok(true));
 
@@ -782,14 +790,13 @@
 
         let mut tuf = Tuf::from_root(root).unwrap();
 
-        let snapshot = SnapshotMetadataBuilder::new()
-            .signed(&KEYS[1])
-            .unwrap();
+        let snapshot = SnapshotMetadataBuilder::new().signed(&KEYS[1]).unwrap();
 
-        let timestamp = TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
-            .unwrap()
-            .signed::<Json>(&KEYS[2])
-            .unwrap();
+        let timestamp =
+            TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
+                .unwrap()
+                .signed::<Json>(&KEYS[2])
+                .unwrap();
 
         tuf.update_timestamp(timestamp).unwrap();
 
@@ -843,10 +850,11 @@
             .signed::<Json>(&KEYS[2])
             .unwrap();
 
-        let timestamp = TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
-            .unwrap()
-            .signed::<Json>(&KEYS[2])
-            .unwrap();
+        let timestamp =
+            TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
+                .unwrap()
+                .signed::<Json>(&KEYS[2])
+                .unwrap();
 
         tuf.update_timestamp(timestamp).unwrap();
 
@@ -873,14 +881,16 @@
             .unwrap();
 
         let snapshot = SnapshotMetadataBuilder::new()
-            .insert_metadata(&targets, &[HashAlgorithm::Sha256]).unwrap()
+            .insert_metadata(&targets, &[HashAlgorithm::Sha256])
+            .unwrap()
             .signed::<Json>(&KEYS[1])
             .unwrap();
 
-        let timestamp = TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
-            .unwrap()
-            .signed::<Json>(&KEYS[3])
-            .unwrap();
+        let timestamp =
+            TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
+                .unwrap()
+                .signed::<Json>(&KEYS[3])
+                .unwrap();
 
         let mut tuf = Tuf::from_root(root).unwrap();
 
@@ -911,14 +921,16 @@
             .unwrap();
 
         let snapshot = SnapshotMetadataBuilder::new()
-            .insert_metadata(&targets, &[HashAlgorithm::Sha256]).unwrap()
+            .insert_metadata(&targets, &[HashAlgorithm::Sha256])
+            .unwrap()
             .signed::<Json>(&KEYS[1])
             .unwrap();
 
-        let timestamp = TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
-            .unwrap()
-            .signed::<Json>(&KEYS[3])
-            .unwrap();
+        let timestamp =
+            TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
+                .unwrap()
+                .signed::<Json>(&KEYS[3])
+                .unwrap();
 
         tuf.update_timestamp(timestamp).unwrap();
         tuf.update_snapshot(snapshot).unwrap();
@@ -944,14 +956,16 @@
             .unwrap();
 
         let snapshot = SnapshotMetadataBuilder::new()
-            .insert_metadata(&targets, &[HashAlgorithm::Sha256]).unwrap()
+            .insert_metadata(&targets, &[HashAlgorithm::Sha256])
+            .unwrap()
             .signed::<Json>(&KEYS[1])
             .unwrap();
 
-        let timestamp = TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
-            .unwrap()
-            .signed::<Json>(&KEYS[3])
-            .unwrap();
+        let timestamp =
+            TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
+                .unwrap()
+                .signed::<Json>(&KEYS[3])
+                .unwrap();
 
         tuf.update_timestamp(timestamp).unwrap();
         tuf.update_snapshot(snapshot).unwrap();
diff --git a/tests/integration.rs b/tests/integration.rs
index ac0dcd6..d00c64d 100644
--- a/tests/integration.rs
+++ b/tests/integration.rs
@@ -5,10 +5,8 @@
 use tuf::crypto::{HashAlgorithm, PrivateKey, SignatureScheme};
 use tuf::interchange::Json;
 use tuf::metadata::{
-    Delegation, Delegations, MetadataDescription, MetadataPath,
-    RootMetadataBuilder, SnapshotMetadataBuilder,
-    TargetsMetadataBuilder, TimestampMetadataBuilder,
-    VirtualTargetPath,
+    Delegation, Delegations, MetadataDescription, MetadataPath, RootMetadataBuilder,
+    SnapshotMetadataBuilder, TargetsMetadataBuilder, TimestampMetadataBuilder, VirtualTargetPath,
 };
 use tuf::Tuf;
 
@@ -94,7 +92,8 @@
             VirtualTargetPath::new("foo".into()).unwrap(),
             target_file,
             &[HashAlgorithm::Sha256],
-        ).unwrap()
+        )
+        .unwrap()
         .signed::<Json>(&delegation_key)
         .unwrap();
 
@@ -207,8 +206,10 @@
         .signed::<Json>(&delegation_a_key)
         .unwrap();
 
-    tuf.update_delegation(&MetadataPath::new("delegation-a".into()).unwrap(), delegation)
-        .unwrap();
+    tuf.update_delegation(
+        &MetadataPath::new("delegation-a".into()).unwrap(),
+        delegation,
+    ).unwrap();
 
     //// build delegation B ////
 
@@ -219,12 +220,15 @@
             VirtualTargetPath::new("foo".into()).unwrap(),
             target_file,
             &[HashAlgorithm::Sha256],
-        ).unwrap()
+        )
+        .unwrap()
         .signed::<Json>(&delegation_b_key)
         .unwrap();
 
-    tuf.update_delegation(&MetadataPath::new("delegation-b".into()).unwrap(), delegation)
-        .unwrap();
+    tuf.update_delegation(
+        &MetadataPath::new("delegation-b".into()).unwrap(),
+        delegation,
+    ).unwrap();
 
     assert!(
         tuf.target_description(&VirtualTargetPath::new("foo".into()).unwrap())
diff --git a/tests/simple_example.rs b/tests/simple_example.rs
index 2b1d639..5416c5c 100644
--- a/tests/simple_example.rs
+++ b/tests/simple_example.rs
@@ -5,9 +5,8 @@
 use tuf::crypto::{HashAlgorithm, KeyId, PrivateKey, SignatureScheme};
 use tuf::interchange::Json;
 use tuf::metadata::{
-    MetadataPath, MetadataVersion, RootMetadataBuilder,
-    SnapshotMetadataBuilder, TargetPath, TargetsMetadataBuilder,
-    TimestampMetadataBuilder, VirtualTargetPath,
+    MetadataPath, MetadataVersion, RootMetadataBuilder, SnapshotMetadataBuilder, TargetPath,
+    TargetsMetadataBuilder, TimestampMetadataBuilder, VirtualTargetPath,
 };
 use tuf::repository::{EphemeralRepository, Repository};
 use tuf::Result;