diff --git a/Cargo.toml b/Cargo.toml
index 23ee009..fa9cede 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,5 +1,6 @@
 [package]
 name = "tuf"
+edition = "2018"
 version = "0.3.0-alpha3"
 authors = [ "heartsucker <heartsucker@autistici.org>" ]
 description = "Library for The Update Framework (TUF)"
diff --git a/src/client.rs b/src/client.rs
index dd8debd..80c83c3 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -47,20 +47,20 @@
 //! }
 //! ```
 
+use chrono::offset::Utc;
 use std::io::{Read, Write};
 
-use chrono::offset::Utc;
-use crypto::{self, KeyId};
-use error::Error;
-use interchange::DataInterchange;
-use metadata::{
+use crate::crypto::{self, KeyId};
+use crate::error::Error;
+use crate::interchange::DataInterchange;
+use crate::metadata::{
     Metadata, MetadataPath, MetadataVersion, Role, RootMetadata, SignedMetadata, SnapshotMetadata,
     TargetDescription, TargetPath, TargetsMetadata, VirtualTargetPath,
 };
-use repository::Repository;
-use tuf::Tuf;
-use util::SafeReader;
-use Result;
+use crate::repository::Repository;
+use crate::tuf::Tuf;
+use crate::util::SafeReader;
+use crate::Result;
 
 /// Translates real paths (where a file is stored) into virtual paths (how it is addressed in TUF)
 /// and back.
@@ -175,7 +175,8 @@
                 &config.max_root_size,
                 config.min_bytes_per_second,
                 None,
-            ).or_else(|_| -> Result<SignedMetadata<_, RootMetadata>> {
+            )
+            .or_else(|_| -> Result<SignedMetadata<_, RootMetadata>> {
                 // FIXME: should we be fetching the latest version instead of version 1?
                 let root = remote.fetch_metadata(
                     &root_path,
@@ -338,7 +339,8 @@
         let snapshot_description = match self.tuf.timestamp() {
             Some(ts) => Ok(ts.snapshot()),
             None => Err(Error::MissingMetadata(Role::Timestamp)),
-        }?.clone();
+        }?
+        .clone();
 
         if snapshot_description.version() <= self.tuf.snapshot().map(|s| s.version()).unwrap_or(0) {
             return Ok(false);
@@ -383,7 +385,8 @@
                 )),
             },
             None => Err(Error::MissingMetadata(Role::Snapshot)),
-        }?.clone();
+        }?
+        .clone();
 
         if targets_description.version() <= self.tuf.targets().map(|t| t.version()).unwrap_or(0) {
             return Ok(false);
@@ -486,7 +489,7 @@
                     return (
                         default_terminate,
                         Err(Error::MissingMetadata(Role::Targets)),
-                    )
+                    );
                 }
             },
         };
@@ -534,7 +537,8 @@
                     &Some(role_meta.size()),
                     self.config.min_bytes_per_second(),
                     Some((alg, value.clone())),
-                ).or_else(|_| {
+                )
+                .or_else(|_| {
                     self.remote.fetch_metadata::<TargetsMetadata>(
                         delegation.role(),
                         &version,
@@ -762,14 +766,14 @@
 #[cfg(test)]
 mod test {
     use super::*;
-    use chrono::prelude::*;
-    use crypto::{HashAlgorithm, PrivateKey, SignatureScheme};
-    use interchange::Json;
-    use metadata::{
+    use crate::crypto::{HashAlgorithm, PrivateKey, SignatureScheme};
+    use crate::interchange::Json;
+    use crate::metadata::{
         MetadataPath, MetadataVersion, RootMetadataBuilder, SnapshotMetadataBuilder,
         TargetsMetadataBuilder, TimestampMetadataBuilder,
     };
-    use repository::EphemeralRepository;
+    use crate::repository::EphemeralRepository;
+    use chrono::prelude::*;
     use std::u32;
 
     lazy_static! {
@@ -863,49 +867,57 @@
             &MetadataPath::from_role(&Role::Root),
             &MetadataVersion::Number(1),
             &root1,
-        ).unwrap();
+        )
+        .unwrap();
 
         repo.store_metadata(
             &MetadataPath::from_role(&Role::Root),
             &MetadataVersion::None,
             &root1,
-        ).unwrap();
+        )
+        .unwrap();
 
         repo.store_metadata(
             &MetadataPath::from_role(&Role::Targets),
             &MetadataVersion::Number(1),
             &targets,
-        ).unwrap();
+        )
+        .unwrap();
 
         repo.store_metadata(
             &MetadataPath::from_role(&Role::Targets),
             &MetadataVersion::None,
             &targets,
-        ).unwrap();
+        )
+        .unwrap();
 
         repo.store_metadata(
             &MetadataPath::from_role(&Role::Snapshot),
             &MetadataVersion::Number(1),
             &snapshot,
-        ).unwrap();
+        )
+        .unwrap();
 
         repo.store_metadata(
             &MetadataPath::from_role(&Role::Snapshot),
             &MetadataVersion::None,
             &snapshot,
-        ).unwrap();
+        )
+        .unwrap();
 
         repo.store_metadata(
             &MetadataPath::from_role(&Role::Timestamp),
             &MetadataVersion::Number(1),
             &timestamp,
-        ).unwrap();
+        )
+        .unwrap();
 
         repo.store_metadata(
             &MetadataPath::from_role(&Role::Timestamp),
             &MetadataVersion::None,
             &timestamp,
-        ).unwrap();
+        )
+        .unwrap();
 
         ////
         // Now, make sure that the local metadata got version 1.
@@ -915,7 +927,8 @@
             Config::build().finish().unwrap(),
             EphemeralRepository::new(),
             repo,
-        ).unwrap();
+        )
+        .unwrap();
 
         assert_eq!(client.update(), Ok(true));
         assert_eq!(client.tuf.root().version(), 1);
@@ -930,7 +943,8 @@
                     &None,
                     u32::MAX,
                     None
-                ).unwrap(),
+                )
+                .unwrap(),
         );
 
         ////
@@ -942,7 +956,8 @@
                 &MetadataPath::from_role(&Role::Root),
                 &MetadataVersion::Number(2),
                 &root2,
-            ).unwrap();
+            )
+            .unwrap();
 
         client
             .remote
@@ -950,7 +965,8 @@
                 &MetadataPath::from_role(&Role::Root),
                 &MetadataVersion::None,
                 &root2,
-            ).unwrap();
+            )
+            .unwrap();
 
         client
             .remote
@@ -958,7 +974,8 @@
                 &MetadataPath::from_role(&Role::Root),
                 &MetadataVersion::Number(3),
                 &root3,
-            ).unwrap();
+            )
+            .unwrap();
 
         client
             .remote
@@ -966,7 +983,8 @@
                 &MetadataPath::from_role(&Role::Root),
                 &MetadataVersion::None,
                 &root3,
-            ).unwrap();
+            )
+            .unwrap();
 
         ////
         // Finally, check that the update brings us to version 3.
@@ -984,7 +1002,8 @@
                     &None,
                     u32::MAX,
                     None
-                ).unwrap(),
+                )
+                .unwrap(),
         );
     }
 }
diff --git a/src/crypto.rs b/src/crypto.rs
index 2c9623d..288ea72 100644
--- a/src/crypto.rs
+++ b/src/crypto.rs
@@ -21,9 +21,9 @@
 use std::sync::Arc;
 use untrusted::Input;
 
-use error::Error;
-use shims;
-use Result;
+use crate::error::Error;
+use crate::shims;
+use crate::Result;
 
 const HASH_ALG_PREFS: &[HashAlgorithm] = &[HashAlgorithm::Sha512, HashAlgorithm::Sha256];
 
@@ -82,7 +82,7 @@
                 return Err(Error::IllegalArgument(format!(
                     "Unknown hash algorithm: {}",
                     s
-                )))
+                )));
             }
         };
 
@@ -409,7 +409,7 @@
                         return Err(Error::IllegalArgument(format!(
                             "Cannot use signature scheme {:?} with Ed25519 keys",
                             s
-                        )))
+                        )));
                     }
                 };
                 Ok(k)
@@ -499,7 +499,7 @@
                 return Err(Error::IllegalArgument(format!(
                     "Key {:?} can't be used with scheme {:?}",
                     k, s
-                )))
+                )));
             }
         };
 
@@ -521,12 +521,14 @@
                 "rsa_keygen_pubexp:65537",
                 "-outform",
                 "der",
-            ]).output()?;
+            ])
+            .output()?;
 
         let mut pk8 = Command::new("openssl")
             .args(&[
                 "pkcs8", "-inform", "der", "-topk8", "-nocrypt", "-outform", "der",
-            ]).stdin(Stdio::piped())
+            ])
+            .stdin(Stdio::piped())
             .stdout(Stdio::piped())
             .spawn()?;
 
@@ -623,7 +625,7 @@
                 return Err(Error::IllegalArgument(format!(
                     "Unknown signature scheme: {}",
                     s
-                )))
+                )));
             }
         };
 
@@ -632,7 +634,8 @@
             Input::from(&self.value.0),
             Input::from(msg),
             Input::from(&sig.value.0),
-        ).map_err(|_| Error::BadSignature)
+        )
+        .map_err(|_| Error::BadSignature)
     }
 }
 
@@ -856,7 +859,7 @@
 #[cfg(test)]
 mod test {
     use super::*;
-    use json;
+    use serde_json::{self, json};
 
     const RSA_2048_PK8: &'static [u8] = include_bytes!("../tests/rsa/rsa-2048.pk8.der");
     const RSA_2048_SPKI: &'static [u8] = include_bytes!("../tests/rsa/rsa-2048.spki.der");
@@ -935,9 +938,9 @@
     fn serde_key_id() {
         let s = "T5vfRrM1iHpgzGwAHe7MbJH_7r4chkOAphV3OPCCv0I=";
         let jsn = json!(s);
-        let parsed: KeyId = json::from_str(&format!("\"{}\"", s)).unwrap();
+        let parsed: KeyId = serde_json::from_str(&format!("\"{}\"", s)).unwrap();
         assert_eq!(parsed, KeyId::from_string(s).unwrap());
-        let encoded = json::to_value(&parsed).unwrap();
+        let encoded = serde_json::to_value(&parsed).unwrap();
         assert_eq!(encoded, jsn);
     }
 
@@ -945,9 +948,9 @@
     fn serde_signature_value() {
         let s = "T5vfRrM1iHpgzGwAHe7MbJH_7r4chkOAphV3OPCCv0I=";
         let jsn = json!(s);
-        let parsed: SignatureValue = json::from_str(&format!("\"{}\"", s)).unwrap();
+        let parsed: SignatureValue = serde_json::from_str(&format!("\"{}\"", s)).unwrap();
         assert_eq!(parsed, SignatureValue::from_string(s).unwrap());
-        let encoded = json::to_value(&parsed).unwrap();
+        let encoded = serde_json::to_value(&parsed).unwrap();
         assert_eq!(encoded, jsn);
     }
 
@@ -955,14 +958,14 @@
     fn serde_rsa_public_key() {
         let der = RSA_2048_SPKI;
         let pub_key = PublicKey::from_spki(der, SignatureScheme::RsaSsaPssSha256).unwrap();
-        let encoded = json::to_value(&pub_key).unwrap();
+        let encoded = serde_json::to_value(&pub_key).unwrap();
         let jsn = json!({
             "type": "rsa",
             "scheme": "rsassa-pss-sha256",
             "public_key": BASE64URL.encode(der),
         });
         assert_eq!(encoded, jsn);
-        let decoded: PublicKey = json::from_value(encoded).unwrap();
+        let decoded: PublicKey = serde_json::from_value(encoded).unwrap();
         assert_eq!(decoded, pub_key);
     }
 
@@ -970,14 +973,14 @@
     fn serde_ed25519_public_key() {
         let der = ED25519_SPKI;
         let pub_key = PublicKey::from_spki(der, SignatureScheme::Ed25519).unwrap();
-        let encoded = json::to_value(&pub_key).unwrap();
+        let encoded = serde_json::to_value(&pub_key).unwrap();
         let jsn = json!({
             "type": "ed25519",
             "scheme": "ed25519",
             "public_key": BASE64URL.encode(der),
         });
         assert_eq!(encoded, jsn);
-        let decoded: PublicKey = json::from_value(encoded).unwrap();
+        let decoded: PublicKey = serde_json::from_value(encoded).unwrap();
         assert_eq!(decoded, pub_key);
     }
 
@@ -986,15 +989,15 @@
         let key = PrivateKey::from_pkcs8(ED25519_PK8, SignatureScheme::Ed25519).unwrap();
         let msg = b"test";
         let sig = key.sign(msg).unwrap();
-        let encoded = json::to_value(&sig).unwrap();
+        let encoded = serde_json::to_value(&sig).unwrap();
         let jsn = json!({
-            "key_id": "qfrfBrkB4lBBSDEBlZgaTGS_SrE6UfmON9kP4i3dJFY=",
-            "value": "_k0Tsqc8Azod5_UQeyBfx7oOFWbLlbkjScrmqkU4lWATv-D3v5d8sHK7Z\
-                eh4K18zoFc_54gWKZoBfKW6VZ45DA==",
+        "key_id": "qfrfBrkB4lBBSDEBlZgaTGS_SrE6UfmON9kP4i3dJFY=",
+        "value": "_k0Tsqc8Azod5_UQeyBfx7oOFWbLlbkjScrmqkU4lWATv-D3v5d8sHK7Z\
+            eh4K18zoFc_54gWKZoBfKW6VZ45DA==",
         });
         assert_eq!(encoded, jsn);
 
-        let decoded: Signature = json::from_value(encoded).unwrap();
+        let decoded: Signature = serde_json::from_value(encoded).unwrap();
         assert_eq!(decoded, sig);
     }
 
diff --git a/src/error.rs b/src/error.rs
index 45cc70b..e708598 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -3,13 +3,13 @@
 use data_encoding::DecodeError;
 use derp;
 use hyper;
-use json;
+use serde_json;
 use std::fmt;
 use std::io;
 use std::path::Path;
 use tempfile;
 
-use metadata::Role;
+use crate::metadata::Role;
 
 /// Error type for all TUF related errors.
 #[derive(Debug, PartialEq, Eq)]
@@ -70,8 +70,8 @@
     }
 }
 
-impl From<json::error::Error> for Error {
-    fn from(err: json::error::Error) -> Error {
+impl From<serde_json::error::Error> for Error {
+    fn from(err: serde_json::error::Error) -> Error {
         Error::Encoding(format!("JSON: {:?}", err))
     }
 }
diff --git a/src/interchange/cjson.rs b/src/interchange/cjson.rs
index f7c23a9..3fea747 100644
--- a/src/interchange/cjson.rs
+++ b/src/interchange/cjson.rs
@@ -1,8 +1,8 @@
 use itoa;
-use json;
+use serde_json;
 use std::collections::BTreeMap;
 
-pub fn canonicalize(jsn: &json::Value) -> Result<Vec<u8>, String> {
+pub fn canonicalize(jsn: &serde_json::Value) -> Result<Vec<u8>, String> {
     let converted = convert(jsn)?;
     let mut buf = Vec::new();
     let _ = converted.write(&mut buf); // Vec<u8> impl always succeeds (or panics).
@@ -41,8 +41,8 @@
                 .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());
-                let s = json::to_string(&s).map_err(|e| format!("{:?}", e))?;
+                let s = serde_json::Value::String(s.clone());
+                let s = serde_json::to_string(&s).map_err(|e| format!("{:?}", e))?;
                 buf.extend(s.as_bytes());
                 Ok(())
             }
@@ -69,8 +69,8 @@
                     first = false;
 
                     // this mess is abusing serde_json to get json escaping
-                    let k = json::Value::String(k.clone());
-                    let k = json::to_string(&k).map_err(|e| format!("{:?}", e))?;
+                    let k = serde_json::Value::String(k.clone());
+                    let k = serde_json::to_string(&k).map_err(|e| format!("{:?}", e))?;
                     buf.extend(k.as_bytes());
 
                     buf.push(b':');
@@ -88,31 +88,31 @@
     U64(u64),
 }
 
-fn convert(jsn: &json::Value) -> Result<Value, String> {
+fn convert(jsn: &serde_json::Value) -> Result<Value, String> {
     match *jsn {
-        json::Value::Null => Ok(Value::Null),
-        json::Value::Bool(b) => Ok(Value::Bool(b)),
-        json::Value::Number(ref n) => n
+        serde_json::Value::Null => Ok(Value::Null),
+        serde_json::Value::Bool(b) => Ok(Value::Bool(b)),
+        serde_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) => {
+        serde_json::Value::Array(ref arr) => {
             let mut out = Vec::new();
             for res in arr.iter().map(|v| convert(v)) {
                 out.push(res?)
             }
             Ok(Value::Array(out))
         }
-        json::Value::Object(ref obj) => {
+        serde_json::Value::Object(ref obj) => {
             let mut out = BTreeMap::new();
             for (k, v) in obj.iter() {
                 let _ = out.insert(k.clone(), convert(v)?);
             }
             Ok(Value::Object(out))
         }
-        json::Value::String(ref s) => Ok(Value::String(s.clone())),
+        serde_json::Value::String(ref s) => Ok(Value::String(s.clone())),
     }
 }
 
diff --git a/src/interchange/mod.rs b/src/interchange/mod.rs
index 7f6dbd6..8bdcb6f 100644
--- a/src/interchange/mod.rs
+++ b/src/interchange/mod.rs
@@ -2,14 +2,14 @@
 
 mod cjson;
 
-use json;
 use serde::de::DeserializeOwned;
 use serde::ser::Serialize;
+use serde_json;
 use std::fmt::Debug;
 use std::io::{Read, Write};
 
-use error::Error;
-use Result;
+use crate::error::Error;
+use crate::Result;
 
 /// The format used for data interchange, serialization, and deserialization.
 pub trait DataInterchange: Debug + PartialEq + Clone {
@@ -219,7 +219,7 @@
 #[derive(Debug, Clone, PartialEq)]
 pub struct Json {}
 impl DataInterchange for Json {
-    type RawData = json::Value;
+    type RawData = serde_json::Value;
 
     /// ```
     /// # use tuf::interchange::{DataInterchange, Json};
@@ -267,7 +267,7 @@
     where
         T: DeserializeOwned,
     {
-        Ok(json::from_value(raw_data.clone())?)
+        Ok(serde_json::from_value(raw_data.clone())?)
     }
 
     /// ```
@@ -296,7 +296,7 @@
     where
         T: Serialize,
     {
-        Ok(json::to_value(data)?)
+        Ok(serde_json::to_value(data)?)
     }
 
     /// ```
@@ -327,6 +327,6 @@
         R: Read,
         T: DeserializeOwned,
     {
-        Ok(json::from_reader(rdr)?)
+        Ok(serde_json::from_reader(rdr)?)
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index a93a655..1d6f125 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -130,12 +130,7 @@
 extern crate serde;
 #[macro_use]
 extern crate serde_derive;
-
-#[cfg(not(test))]
-extern crate serde_json as json;
-#[cfg(test)]
-#[macro_use]
-extern crate serde_json as json;
+extern crate serde_json;
 
 extern crate tempfile;
 extern crate untrusted;
@@ -154,6 +149,6 @@
 pub mod tuf;
 mod util;
 
-pub use error::*;
-pub use tuf::*;
-pub use util::*;
+pub use crate::error::*;
+pub use crate::tuf::*;
+pub use crate::util::*;
diff --git a/src/metadata.rs b/src/metadata.rs
index 0e0fb91..a25db77 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -9,11 +9,11 @@
 use std::io::Read;
 use std::marker::PhantomData;
 
-use crypto::{self, HashAlgorithm, HashValue, KeyId, PrivateKey, PublicKey, Signature};
-use error::Error;
-use interchange::DataInterchange;
-use shims;
-use Result;
+use crate::crypto::{self, HashAlgorithm, HashValue, KeyId, PrivateKey, PublicKey, Signature};
+use crate::error::Error;
+use crate::interchange::DataInterchange;
+use crate::shims;
+use crate::Result;
 
 #[cfg_attr(rustfmt, rustfmt_skip)]
 static PATH_ILLEGAL_COMPONENTS: &'static [&str] = &[
@@ -1377,9 +1377,11 @@
                         parents[0]
                             .iter()
                             .any(|p| parent.is_child(p) || parent == &p)
-                    }).cloned()
+                    })
+                    .cloned()
                     .collect::<HashSet<_>>()
-            }).collect::<Vec<_>>();
+            })
+            .collect::<Vec<_>>();
         self.matches_chain(&*new)
     }
 
@@ -1684,11 +1686,12 @@
             return Err(Error::IllegalArgument("Roles cannot be empty.".into()));
         }
 
-        if roles.len() != roles
-            .iter()
-            .map(|r| &r.role)
-            .collect::<HashSet<&MetadataPath>>()
-            .len()
+        if roles.len()
+            != roles
+                .iter()
+                .map(|r| &r.role)
+                .collect::<HashSet<&MetadataPath>>()
+                .len()
         {
             return Err(Error::IllegalArgument(
                 "Cannot have duplicated roles in delegations.".into(),
@@ -1827,10 +1830,10 @@
 #[cfg(test)]
 mod test {
     use super::*;
+    use crate::crypto::SignatureScheme;
+    use crate::interchange::Json;
     use chrono::prelude::*;
-    use crypto::SignatureScheme;
-    use interchange::Json;
-    use json;
+    use serde_json::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");
@@ -1895,7 +1898,8 @@
                         .iter()
                         .map(|p| VirtualTargetPath::new(p.to_string()).unwrap())
                         .collect::<HashSet<_>>()
-                }).collect::<Vec<_>>();
+                })
+                .collect::<Vec<_>>();
             println!(
                 "CASE: expect: {} path: {:?} parents: {:?}",
                 expected, target, parents
@@ -1907,32 +1911,32 @@
     #[test]
     fn serde_target_path() {
         let s = "foo/bar";
-        let t = json::from_str::<VirtualTargetPath>(&format!("\"{}\"", s)).unwrap();
+        let t = serde_json::from_str::<VirtualTargetPath>(&format!("\"{}\"", s)).unwrap();
         assert_eq!(t.to_string().as_str(), s);
-        assert_eq!(json::to_value(t).unwrap(), json!("foo/bar"));
+        assert_eq!(serde_json::to_value(t).unwrap(), json!("foo/bar"));
     }
 
     #[test]
     fn serde_metadata_path() {
         let s = "foo/bar";
-        let m = json::from_str::<MetadataPath>(&format!("\"{}\"", s)).unwrap();
+        let m = serde_json::from_str::<MetadataPath>(&format!("\"{}\"", s)).unwrap();
         assert_eq!(m.to_string().as_str(), s);
-        assert_eq!(json::to_value(m).unwrap(), json!("foo/bar"));
+        assert_eq!(serde_json::to_value(m).unwrap(), json!("foo/bar"));
     }
 
     #[test]
     fn serde_target_description() {
         let s: &[u8] = b"from water does all life begin";
         let description = TargetDescription::from_reader(s, &[HashAlgorithm::Sha256]).unwrap();
-        let jsn_str = json::to_string(&description).unwrap();
+        let jsn_str = serde_json::to_string(&description).unwrap();
         let jsn = json!({
             "size": 30,
             "hashes": {
                 "sha256": "_F10XHEryG6poxJk2sDJVu61OFf2d-7QWCm7cQE8rhg=",
             },
         });
-        let parsed_str: TargetDescription = json::from_str(&jsn_str).unwrap();
-        let parsed_jsn: TargetDescription = json::from_value(jsn).unwrap();
+        let parsed_str: TargetDescription = serde_json::from_str(&jsn_str).unwrap();
+        let parsed_jsn: TargetDescription = serde_json::from_value(jsn).unwrap();
         assert_eq!(parsed_str, parsed_jsn);
     }
 
@@ -1941,7 +1945,8 @@
         let hashes = hashset!(
             "diNfThTFm0PI8R-Bq7NztUIvZbZiaC_weJBgcqaHlWw=",
             "ar9AgoRsmeEcf6Ponta_1TZu1ds5uXbDemBig30O7ck=",
-        ).iter()
+        )
+        .iter()
         .map(|k| KeyId::from_string(*k).unwrap())
         .collect();
         let role_def = RoleDefinition::new(2, hashes).unwrap();
@@ -1953,9 +1958,9 @@
                 "diNfThTFm0PI8R-Bq7NztUIvZbZiaC_weJBgcqaHlWw=",
             ],
         });
-        let encoded = json::to_value(&role_def).unwrap();
+        let encoded = serde_json::to_value(&role_def).unwrap();
         assert_eq!(encoded, jsn);
-        let decoded: RoleDefinition = json::from_value(encoded).unwrap();
+        let decoded: RoleDefinition = serde_json::from_value(encoded).unwrap();
         assert_eq!(decoded, role_def);
 
         let jsn = json!({
@@ -1964,7 +1969,7 @@
                 "diNfThTFm0PI8R-Bq7NztUIvZbZiaC_weJBgcqaHlWw=",
             ],
         });
-        assert!(json::from_value::<RoleDefinition>(jsn).is_err());
+        assert!(serde_json::from_value::<RoleDefinition>(jsn).is_err());
 
         let jsn = json!({
             "threshold": -1,
@@ -1972,7 +1977,7 @@
                 "diNfThTFm0PI8R-Bq7NztUIvZbZiaC_weJBgcqaHlWw=",
             ],
         });
-        assert!(json::from_value::<RoleDefinition>(jsn).is_err());
+        assert!(serde_json::from_value::<RoleDefinition>(jsn).is_err());
     }
 
     #[test]
@@ -2041,9 +2046,9 @@
             },
         });
 
-        let encoded = json::to_value(&root).unwrap();
+        let encoded = serde_json::to_value(&root).unwrap();
         assert_eq!(encoded, jsn);
-        let decoded: RootMetadata = json::from_value(encoded).unwrap();
+        let decoded: RootMetadata = serde_json::from_value(encoded).unwrap();
         assert_eq!(decoded, root);
     }
 
@@ -2053,7 +2058,8 @@
             1,
             100,
             hashmap! { HashAlgorithm::Sha256 => HashValue::new(vec![]) },
-        ).unwrap();
+        )
+        .unwrap();
 
         let timestamp = TimestampMetadataBuilder::from_metadata_description(description)
             .expires(Utc.ymd(2017, 1, 1).and_hms(0, 0, 0))
@@ -2073,9 +2079,9 @@
             },
         });
 
-        let encoded = json::to_value(&timestamp).unwrap();
+        let encoded = serde_json::to_value(&timestamp).unwrap();
         assert_eq!(encoded, jsn);
-        let decoded: TimestampMetadata = json::from_value(encoded).unwrap();
+        let decoded: TimestampMetadata = serde_json::from_value(encoded).unwrap();
         assert_eq!(decoded, timestamp);
     }
 
@@ -2089,8 +2095,10 @@
                     1,
                     100,
                     hashmap! { HashAlgorithm::Sha256 => HashValue::new(vec![]) },
-                ).unwrap(),
-            ).build()
+                )
+                .unwrap(),
+            )
+            .build()
             .unwrap();
 
         let jsn = json!({
@@ -2108,9 +2116,9 @@
             },
         });
 
-        let encoded = json::to_value(&snapshot).unwrap();
+        let encoded = serde_json::to_value(&snapshot).unwrap();
         assert_eq!(encoded, jsn);
-        let decoded: SnapshotMetadata = json::from_value(encoded).unwrap();
+        let decoded: SnapshotMetadata = serde_json::from_value(encoded).unwrap();
         assert_eq!(decoded, snapshot);
     }
 
@@ -2121,7 +2129,8 @@
             .insert_target_description(
                 VirtualTargetPath::new("foo".into()).unwrap(),
                 TargetDescription::from_reader(&b"foo"[..], &[HashAlgorithm::Sha256]).unwrap(),
-            ).build()
+            )
+            .build()
             .unwrap();
 
         let jsn = json!({
@@ -2138,9 +2147,9 @@
             },
         });
 
-        let encoded = json::to_value(&targets).unwrap();
+        let encoded = serde_json::to_value(&targets).unwrap();
         assert_eq!(encoded, jsn);
-        let decoded: TargetsMetadata = json::from_value(encoded).unwrap();
+        let decoded: TargetsMetadata = serde_json::from_value(encoded).unwrap();
         assert_eq!(decoded, targets);
     }
 
@@ -2149,16 +2158,16 @@
         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(),
-            ],
-        ).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 = TargetsMetadataBuilder::new()
             .expires(Utc.ymd(2017, 1, 1).and_hms(0, 0, 0))
@@ -2192,9 +2201,9 @@
             }
         });
 
-        let encoded = json::to_value(&targets).unwrap();
+        let encoded = serde_json::to_value(&targets).unwrap();
         assert_eq!(encoded, jsn);
-        let decoded: TargetsMetadata = json::from_value(encoded).unwrap();
+        let decoded: TargetsMetadata = serde_json::from_value(encoded).unwrap();
         assert_eq!(decoded, targets);
     }
 
@@ -2208,8 +2217,10 @@
                     1,
                     100,
                     hashmap! { HashAlgorithm::Sha256 => HashValue::new(vec![]) },
-                ).unwrap(),
-            ).build()
+                )
+                .unwrap(),
+            )
+            .build()
             .unwrap();
 
         let key = PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519).unwrap();
@@ -2240,9 +2251,10 @@
             },
         });
 
-        let encoded = json::to_value(&signed).unwrap();
+        let encoded = serde_json::to_value(&signed).unwrap();
         assert_eq!(encoded, jsn, "{:#?} != {:#?}", encoded, jsn);
-        let decoded: SignedMetadata<Json, SnapshotMetadata> = json::from_value(encoded).unwrap();
+        let decoded: SignedMetadata<Json, SnapshotMetadata> =
+            serde_json::from_value(encoded).unwrap();
         assert_eq!(decoded, signed);
     }
 
@@ -2269,7 +2281,7 @@
 
     // TODO test for mismatched ed25519/rsa keys/schemes
 
-    fn make_root() -> json::Value {
+    fn make_root() -> serde_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();
@@ -2285,19 +2297,19 @@
             .build()
             .unwrap();
 
-        json::to_value(&root).unwrap()
+        serde_json::to_value(&root).unwrap()
     }
 
-    fn make_snapshot() -> json::Value {
+    fn make_snapshot() -> serde_json::Value {
         let snapshot = SnapshotMetadataBuilder::new()
             .expires(Utc.ymd(2038, 1, 1).and_hms(0, 0, 0))
             .build()
             .unwrap();
 
-        json::to_value(&snapshot).unwrap()
+        serde_json::to_value(&snapshot).unwrap()
     }
 
-    fn make_timestamp() -> json::Value {
+    fn make_timestamp() -> serde_json::Value {
         let description =
             MetadataDescription::from_reader(&[][..], 1, &[HashAlgorithm::Sha256]).unwrap();
 
@@ -2306,39 +2318,39 @@
             .build()
             .unwrap();
 
-        json::to_value(&timestamp).unwrap()
+        serde_json::to_value(&timestamp).unwrap()
     }
 
-    fn make_targets() -> json::Value {
+    fn make_targets() -> serde_json::Value {
         let targets =
             TargetsMetadata::new(1, Utc.ymd(2038, 1, 1).and_hms(0, 0, 0), hashmap!(), None)
                 .unwrap();
 
-        json::to_value(&targets).unwrap()
+        serde_json::to_value(&targets).unwrap()
     }
 
-    fn make_delegations() -> json::Value {
+    fn make_delegations() -> serde_json::Value {
         let key = PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519)
             .unwrap()
             .public()
             .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(),
-            ],
-        ).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()
+        serde_json::to_value(&delegations).unwrap()
     }
 
-    fn make_delegation() -> json::Value {
+    fn make_delegation() -> serde_json::Value {
         let key = PrivateKey::from_pkcs8(ED25519_1_PK8, SignatureScheme::Ed25519)
             .unwrap()
             .public()
@@ -2349,12 +2361,13 @@
             1,
             hashset!(key.key_id().clone()),
             hashset!(VirtualTargetPath::new("bar".into()).unwrap()),
-        ).unwrap();
+        )
+        .unwrap();
 
-        json::to_value(&delegation).unwrap()
+        serde_json::to_value(&delegation).unwrap()
     }
 
-    fn set_version(value: &mut json::Value, version: i64) {
+    fn set_version(value: &mut serde_json::Value, version: i64) {
         match value.as_object_mut() {
             Some(obj) => {
                 let _ = obj.insert("version".into(), json!(version));
@@ -2368,11 +2381,11 @@
     fn deserialize_json_root_illegal_version() {
         let mut root_json = make_root();
         set_version(&mut root_json, 0);
-        assert!(json::from_value::<RootMetadata>(root_json.clone()).is_err());
+        assert!(serde_json::from_value::<RootMetadata>(root_json.clone()).is_err());
 
         let mut root_json = make_root();
         set_version(&mut root_json, -1);
-        assert!(json::from_value::<RootMetadata>(root_json).is_err());
+        assert!(serde_json::from_value::<RootMetadata>(root_json).is_err());
     }
 
     // Refuse to deserialize root metadata if it contains duplicate keys
@@ -2395,10 +2408,10 @@
             .as_array_mut()
             .unwrap()
             .push(dupe);
-        assert!(json::from_value::<RootMetadata>(root_json).is_err());
+        assert!(serde_json::from_value::<RootMetadata>(root_json).is_err());
     }
 
-    fn set_threshold(value: &mut json::Value, threshold: i32) {
+    fn set_threshold(value: &mut serde_json::Value, threshold: i32) {
         match value.as_object_mut() {
             Some(obj) => {
                 let _ = obj.insert("threshold".into(), json!(threshold));
@@ -2418,15 +2431,16 @@
                     .key_id()
                     .clone()
             ),
-        ).unwrap();
+        )
+        .unwrap();
 
-        let mut jsn = json::to_value(&role_def).unwrap();
+        let mut jsn = serde_json::to_value(&role_def).unwrap();
         set_threshold(&mut jsn, 0);
-        assert!(json::from_value::<RoleDefinition>(jsn).is_err());
+        assert!(serde_json::from_value::<RoleDefinition>(jsn).is_err());
 
-        let mut jsn = json::to_value(&role_def).unwrap();
+        let mut jsn = serde_json::to_value(&role_def).unwrap();
         set_threshold(&mut jsn, -1);
-        assert!(json::from_value::<RoleDefinition>(jsn).is_err());
+        assert!(serde_json::from_value::<RoleDefinition>(jsn).is_err());
 
         let role_def = RoleDefinition::new(
             2,
@@ -2440,11 +2454,12 @@
                     .key_id()
                     .clone(),
             ),
-        ).unwrap();
+        )
+        .unwrap();
 
-        let mut jsn = json::to_value(&role_def).unwrap();
+        let mut jsn = serde_json::to_value(&role_def).unwrap();
         set_threshold(&mut jsn, 3);
-        assert!(json::from_value::<RoleDefinition>(jsn).is_err());
+        assert!(serde_json::from_value::<RoleDefinition>(jsn).is_err());
     }
 
     // Refuse to deserialilze root metadata with wrong type field
@@ -2455,7 +2470,7 @@
             .as_object_mut()
             .unwrap()
             .insert("type".into(), json!("snapshot"));
-        assert!(json::from_value::<RootMetadata>(root).is_err());
+        assert!(serde_json::from_value::<RootMetadata>(root).is_err());
     }
 
     // Refuse to deserialize role definitions with duplicated key ids
@@ -2466,7 +2481,7 @@
             .key_id()
             .clone();
         let role_def = RoleDefinition::new(1, hashset!(key_id.clone())).unwrap();
-        let mut jsn = json::to_value(&role_def).unwrap();
+        let mut jsn = serde_json::to_value(&role_def).unwrap();
 
         match jsn.as_object_mut() {
             Some(obj) => match obj.get_mut("key_ids").unwrap().as_array_mut() {
@@ -2476,7 +2491,7 @@
             None => panic!(),
         }
 
-        assert!(json::from_value::<RoleDefinition>(jsn).is_err());
+        assert!(serde_json::from_value::<RoleDefinition>(jsn).is_err());
     }
 
     // Refuse to deserialize snapshot metadata with illegal versions
@@ -2484,11 +2499,11 @@
     fn deserialize_json_snapshot_illegal_version() {
         let mut snapshot = make_snapshot();
         set_version(&mut snapshot, 0);
-        assert!(json::from_value::<SnapshotMetadata>(snapshot).is_err());
+        assert!(serde_json::from_value::<SnapshotMetadata>(snapshot).is_err());
 
         let mut snapshot = make_snapshot();
         set_version(&mut snapshot, -1);
-        assert!(json::from_value::<SnapshotMetadata>(snapshot).is_err());
+        assert!(serde_json::from_value::<SnapshotMetadata>(snapshot).is_err());
     }
 
     // Refuse to deserialilze snapshot metadata with wrong type field
@@ -2499,7 +2514,7 @@
             .as_object_mut()
             .unwrap()
             .insert("type".into(), json!("root"));
-        assert!(json::from_value::<SnapshotMetadata>(snapshot).is_err());
+        assert!(serde_json::from_value::<SnapshotMetadata>(snapshot).is_err());
     }
 
     // Refuse to deserialize timestamp metadata with illegal versions
@@ -2507,11 +2522,11 @@
     fn deserialize_json_timestamp_illegal_version() {
         let mut timestamp = make_timestamp();
         set_version(&mut timestamp, 0);
-        assert!(json::from_value::<TimestampMetadata>(timestamp).is_err());
+        assert!(serde_json::from_value::<TimestampMetadata>(timestamp).is_err());
 
         let mut timestamp = make_timestamp();
         set_version(&mut timestamp, -1);
-        assert!(json::from_value::<TimestampMetadata>(timestamp).is_err());
+        assert!(serde_json::from_value::<TimestampMetadata>(timestamp).is_err());
     }
 
     // Refuse to deserialilze timestamp metadata with wrong type field
@@ -2522,7 +2537,7 @@
             .as_object_mut()
             .unwrap()
             .insert("type".into(), json!("root"));
-        assert!(json::from_value::<TimestampMetadata>(timestamp).is_err());
+        assert!(serde_json::from_value::<TimestampMetadata>(timestamp).is_err());
     }
 
     // Refuse to deserialize targets metadata with illegal versions
@@ -2530,11 +2545,11 @@
     fn deserialize_json_targets_illegal_version() {
         let mut targets = make_targets();
         set_version(&mut targets, 0);
-        assert!(json::from_value::<TargetsMetadata>(targets).is_err());
+        assert!(serde_json::from_value::<TargetsMetadata>(targets).is_err());
 
         let mut targets = make_targets();
         set_version(&mut targets, -1);
-        assert!(json::from_value::<TargetsMetadata>(targets).is_err());
+        assert!(serde_json::from_value::<TargetsMetadata>(targets).is_err());
     }
 
     // Refuse to deserialilze targets metadata with wrong type field
@@ -2545,7 +2560,7 @@
             .as_object_mut()
             .unwrap()
             .insert("type".into(), json!("root"));
-        assert!(json::from_value::<TargetsMetadata>(targets).is_err());
+        assert!(serde_json::from_value::<TargetsMetadata>(targets).is_err());
     }
 
     // Refuse to deserialize delegations with no keys
@@ -2560,7 +2575,7 @@
             .as_array_mut()
             .unwrap()
             .clear();
-        assert!(json::from_value::<Delegations>(delegations).is_err());
+        assert!(serde_json::from_value::<Delegations>(delegations).is_err());
     }
 
     // Refuse to deserialize delegations with no roles
@@ -2575,7 +2590,7 @@
             .as_array_mut()
             .unwrap()
             .clear();
-        assert!(json::from_value::<Delegations>(delegations).is_err());
+        assert!(serde_json::from_value::<Delegations>(delegations).is_err());
     }
 
     // Refuse to deserialize delegations with duplicated roles
@@ -2598,7 +2613,7 @@
             .as_array_mut()
             .unwrap()
             .push(dupe);
-        assert!(json::from_value::<Delegations>(delegations).is_err());
+        assert!(serde_json::from_value::<Delegations>(delegations).is_err());
     }
 
     // Refuse to deserialize a delegation with insufficient threshold
@@ -2606,11 +2621,11 @@
     fn deserialize_json_delegation_bad_threshold() {
         let mut delegation = make_delegation();
         set_threshold(&mut delegation, 0);
-        assert!(json::from_value::<Delegation>(delegation).is_err());
+        assert!(serde_json::from_value::<Delegation>(delegation).is_err());
 
         let mut delegation = make_delegation();
         set_threshold(&mut delegation, 2);
-        assert!(json::from_value::<Delegation>(delegation).is_err());
+        assert!(serde_json::from_value::<Delegation>(delegation).is_err());
     }
 
     // Refuse to deserialize a delegation with duplicate key IDs
@@ -2633,7 +2648,7 @@
             .as_array_mut()
             .unwrap()
             .push(dupe);
-        assert!(json::from_value::<Delegation>(delegation).is_err());
+        assert!(serde_json::from_value::<Delegation>(delegation).is_err());
     }
 
     // Refuse to deserialize a delegation with duplicate paths
@@ -2656,7 +2671,7 @@
             .as_array_mut()
             .unwrap()
             .push(dupe);
-        assert!(json::from_value::<Delegation>(delegation).is_err());
+        assert!(serde_json::from_value::<Delegation>(delegation).is_err());
     }
 
     // Refuse to deserialize a Delegations struct with duplicate keys
@@ -2668,17 +2683,17 @@
             .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(),
-            ],
-        ).unwrap();
-        let mut delegations = json::to_value(delegations).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 = serde_json::to_value(delegations).unwrap();
 
         let dupe = delegations
             .as_object()
@@ -2696,6 +2711,6 @@
             .as_array_mut()
             .unwrap()
             .push(dupe);
-        assert!(json::from_value::<Delegations>(delegations).is_err());
+        assert!(serde_json::from_value::<Delegations>(delegations).is_err());
     }
 }
diff --git a/src/repository.rs b/src/repository.rs
index 7304d79..3d68917 100644
--- a/src/repository.rs
+++ b/src/repository.rs
@@ -12,14 +12,14 @@
 use std::sync::{Arc, RwLock};
 use tempfile::NamedTempFile;
 
-use crypto::{self, HashAlgorithm, HashValue};
-use error::Error;
-use interchange::DataInterchange;
-use metadata::{
+use crate::crypto::{self, HashAlgorithm, HashValue};
+use crate::error::Error;
+use crate::interchange::DataInterchange;
+use crate::metadata::{
     Metadata, MetadataPath, MetadataVersion, SignedMetadata, TargetDescription, TargetPath,
 };
-use util::SafeReader;
-use Result;
+use crate::util::SafeReader;
+use crate::Result;
 
 /// Top-level trait that represents a TUF repository and contains all the ways it can be interacted
 /// with.
@@ -504,7 +504,7 @@
 #[cfg(test)]
 mod test {
     use super::*;
-    use interchange::Json;
+    use crate::interchange::Json;
     use tempfile;
 
     #[test]
@@ -546,15 +546,13 @@
             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 294474e..88072a2 100644
--- a/src/shims.rs
+++ b/src/shims.rs
@@ -4,10 +4,10 @@
 use std::collections::{HashMap, HashSet};
 use std::iter::FromIterator;
 
-use crypto;
-use error::Error;
-use metadata::{self, Metadata};
-use Result;
+use crate::crypto;
+use crate::error::Error;
+use crate::metadata::{self, Metadata};
+use crate::Result;
 
 fn parse_datetime(ts: &str) -> Result<DateTime<Utc>> {
     Utc.datetime_from_str(ts, "%FT%TZ")
diff --git a/src/tuf.rs b/src/tuf.rs
index 1fa84fa..26f2297 100644
--- a/src/tuf.rs
+++ b/src/tuf.rs
@@ -4,14 +4,14 @@
 use std::collections::{HashMap, HashSet};
 use std::marker::PhantomData;
 
-use crypto::KeyId;
-use error::Error;
-use interchange::DataInterchange;
-use metadata::{
+use crate::crypto::KeyId;
+use crate::error::Error;
+use crate::interchange::DataInterchange;
+use crate::metadata::{
     Delegations, Metadata, MetadataPath, Role, RootMetadata, SignedMetadata, SnapshotMetadata,
     TargetDescription, TargetsMetadata, TimestampMetadata, VirtualTargetPath,
 };
-use Result;
+use crate::Result;
 
 /// Contains trusted TUF metadata and can be used to verify other metadata and targets.
 #[derive(Debug)]
@@ -411,7 +411,7 @@
                 None => {
                     return Err(Error::VerificationFailure(
                         "Delegations not authorized".into(),
-                    ))
+                    ));
                 }
             };
 
@@ -421,7 +421,7 @@
                     return Err(Error::VerificationFailure(format!(
                         "The degated role {:?} was not present in the snapshot metadata.",
                         role
-                    )))
+                    )));
                 }
             };
 
@@ -622,9 +622,9 @@
 #[cfg(test)]
 mod test {
     use super::*;
-    use crypto::{HashAlgorithm, PrivateKey, SignatureScheme};
-    use interchange::Json;
-    use metadata::{
+    use crate::crypto::{HashAlgorithm, PrivateKey, SignatureScheme};
+    use crate::interchange::Json;
+    use crate::metadata::{
         RootMetadataBuilder, SnapshotMetadataBuilder, TargetsMetadataBuilder,
         TimestampMetadataBuilder,
     };
diff --git a/src/util.rs b/src/util.rs
index c6ba957..d0deb81 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -3,9 +3,9 @@
 use ring::digest::{self, SHA256, SHA512};
 use std::io::{self, ErrorKind, Read};
 
-use crypto::{HashAlgorithm, HashValue};
-use error::Error;
-use Result;
+use crate::crypto::{HashAlgorithm, HashValue};
+use crate::error::Error;
+use crate::Result;
 
 /// Wrapper to verify a byte stream as it is read.
 ///
@@ -48,7 +48,7 @@
                         return Err(Error::IllegalArgument(format!(
                             "Unknown hash algorithm: {}",
                             s
-                        )))
+                        )));
                     }
                 };
                 Some((ctx, value))
@@ -181,7 +181,8 @@
             bytes.len() as u64,
             0,
             Some((&HashAlgorithm::Sha256, hash_value)),
-        ).unwrap();
+        )
+        .unwrap();
         let mut buf = Vec::new();
         assert!(reader.read_to_end(&mut buf).is_ok());
         assert_eq!(buf, bytes);
@@ -199,7 +200,8 @@
             bytes.len() as u64,
             0,
             Some((&HashAlgorithm::Sha256, hash_value)),
-        ).unwrap();
+        )
+        .unwrap();
         let mut buf = Vec::new();
         assert!(reader.read_to_end(&mut buf).is_err());
     }
@@ -215,7 +217,8 @@
             bytes.len() as u64,
             0,
             Some((&HashAlgorithm::Sha256, hash_value)),
-        ).unwrap();
+        )
+        .unwrap();
         let mut buf = Vec::new();
         assert!(reader.read_to_end(&mut buf).is_ok());
         assert_eq!(buf, bytes);
@@ -233,7 +236,8 @@
             bytes.len() as u64,
             0,
             Some((&HashAlgorithm::Sha256, hash_value)),
-        ).unwrap();
+        )
+        .unwrap();
         let mut buf = Vec::new();
         assert!(reader.read_to_end(&mut buf).is_err());
     }
diff --git a/tests/integration.rs b/tests/integration.rs
index ad495f0..ed63c04 100644
--- a/tests/integration.rs
+++ b/tests/integration.rs
@@ -43,10 +43,12 @@
         .insert_metadata_description(
             MetadataPath::new("targets".into()).unwrap(),
             MetadataDescription::from_reader(&*vec![0u8], 1, &[HashAlgorithm::Sha256]).unwrap(),
-        ).insert_metadata_description(
+        )
+        .insert_metadata_description(
             MetadataPath::new("delegation".into()).unwrap(),
             MetadataDescription::from_reader(&*vec![0u8], 1, &[HashAlgorithm::Sha256]).unwrap(),
-        ).signed::<Json>(&snapshot_key)
+        )
+        .signed::<Json>(&snapshot_key)
         .unwrap();
 
     let timestamp = TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
@@ -60,22 +62,22 @@
     //// build the targets ////
     let delegations = Delegations::new(
         &hashset![delegation_key.public().clone()],
-        vec![
-            Delegation::new(
-                MetadataPath::new("delegation".into()).unwrap(),
-                false,
-                1,
-                vec![delegation_key.key_id().clone()]
-                    .iter()
-                    .cloned()
-                    .collect(),
-                vec![VirtualTargetPath::new("foo".into()).unwrap()]
-                    .iter()
-                    .cloned()
-                    .collect(),
-            ).unwrap(),
-        ],
-    ).unwrap();
+        vec![Delegation::new(
+            MetadataPath::new("delegation".into()).unwrap(),
+            false,
+            1,
+            vec![delegation_key.key_id().clone()]
+                .iter()
+                .cloned()
+                .collect(),
+            vec![VirtualTargetPath::new("foo".into()).unwrap()]
+                .iter()
+                .cloned()
+                .collect(),
+        )
+        .unwrap()],
+    )
+    .unwrap();
     let targets = TargetsMetadataBuilder::new()
         .delegations(delegations)
         .signed::<Json>(&targets_key)
@@ -90,17 +92,17 @@
             VirtualTargetPath::new("foo".into()).unwrap(),
             target_file,
             &[HashAlgorithm::Sha256],
-        ).unwrap()
+        )
+        .unwrap()
         .signed::<Json>(&delegation_key)
         .unwrap();
 
     tuf.update_delegation(&MetadataPath::new("delegation".into()).unwrap(), delegation)
         .unwrap();
 
-    assert!(
-        tuf.target_description(&VirtualTargetPath::new("foo".into()).unwrap())
-            .is_ok()
-    );
+    assert!(tuf
+        .target_description(&VirtualTargetPath::new("foo".into()).unwrap())
+        .is_ok());
 }
 
 #[test]
@@ -130,13 +132,16 @@
         .insert_metadata_description(
             MetadataPath::new("targets".into()).unwrap(),
             MetadataDescription::from_reader(&*vec![0u8], 1, &[HashAlgorithm::Sha256]).unwrap(),
-        ).insert_metadata_description(
+        )
+        .insert_metadata_description(
             MetadataPath::new("delegation-a".into()).unwrap(),
             MetadataDescription::from_reader(&*vec![0u8], 1, &[HashAlgorithm::Sha256]).unwrap(),
-        ).insert_metadata_description(
+        )
+        .insert_metadata_description(
             MetadataPath::new("delegation-b".into()).unwrap(),
             MetadataDescription::from_reader(&*vec![0u8], 1, &[HashAlgorithm::Sha256]).unwrap(),
-        ).signed::<Json>(&snapshot_key)
+        )
+        .signed::<Json>(&snapshot_key)
         .unwrap();
 
     let timestamp = TimestampMetadataBuilder::from_snapshot(&snapshot, &[HashAlgorithm::Sha256])
@@ -151,22 +156,22 @@
 
     let delegations = Delegations::new(
         &hashset![delegation_a_key.public().clone()],
-        vec![
-            Delegation::new(
-                MetadataPath::new("delegation-a".into()).unwrap(),
-                false,
-                1,
-                vec![delegation_a_key.key_id().clone()]
-                    .iter()
-                    .cloned()
-                    .collect(),
-                vec![VirtualTargetPath::new("foo".into()).unwrap()]
-                    .iter()
-                    .cloned()
-                    .collect(),
-            ).unwrap(),
-        ],
-    ).unwrap();
+        vec![Delegation::new(
+            MetadataPath::new("delegation-a".into()).unwrap(),
+            false,
+            1,
+            vec![delegation_a_key.key_id().clone()]
+                .iter()
+                .cloned()
+                .collect(),
+            vec![VirtualTargetPath::new("foo".into()).unwrap()]
+                .iter()
+                .cloned()
+                .collect(),
+        )
+        .unwrap()],
+    )
+    .unwrap();
     let targets = TargetsMetadataBuilder::new()
         .delegations(delegations)
         .signed::<Json>(&targets_key)
@@ -178,22 +183,22 @@
 
     let delegations = Delegations::new(
         &hashset![delegation_b_key.public().clone()],
-        vec![
-            Delegation::new(
-                MetadataPath::new("delegation-b".into()).unwrap(),
-                false,
-                1,
-                vec![delegation_b_key.key_id().clone()]
-                    .iter()
-                    .cloned()
-                    .collect(),
-                vec![VirtualTargetPath::new("foo".into()).unwrap()]
-                    .iter()
-                    .cloned()
-                    .collect(),
-            ).unwrap(),
-        ],
-    ).unwrap();
+        vec![Delegation::new(
+            MetadataPath::new("delegation-b".into()).unwrap(),
+            false,
+            1,
+            vec![delegation_b_key.key_id().clone()]
+                .iter()
+                .cloned()
+                .collect(),
+            vec![VirtualTargetPath::new("foo".into()).unwrap()]
+                .iter()
+                .cloned()
+                .collect(),
+        )
+        .unwrap()],
+    )
+    .unwrap();
 
     let delegation = TargetsMetadataBuilder::new()
         .delegations(delegations)
@@ -203,7 +208,8 @@
     tuf.update_delegation(
         &MetadataPath::new("delegation-a".into()).unwrap(),
         delegation,
-    ).unwrap();
+    )
+    .unwrap();
 
     //// build delegation B ////
 
@@ -214,17 +220,18 @@
             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();
+    )
+    .unwrap();
 
-    assert!(
-        tuf.target_description(&VirtualTargetPath::new("foo".into()).unwrap())
-            .is_ok()
-    );
+    assert!(tuf
+        .target_description(&VirtualTargetPath::new("foo".into()).unwrap())
+        .is_ok());
 }
diff --git a/tests/simple_example.rs b/tests/simple_example.rs
index 8eaea1c..ff7707c 100644
--- a/tests/simple_example.rs
+++ b/tests/simple_example.rs
@@ -105,7 +105,8 @@
             config.path_translator().real_to_virtual(&target_path)?,
             target_file,
             &[HashAlgorithm::Sha256],
-        )?.signed::<Json>(&targets_key)?;
+        )?
+        .signed::<Json>(&targets_key)?;
 
     remote.store_metadata(
         &MetadataPath::new("targets".into())?,