diff --git a/Cargo.toml b/Cargo.toml
index a8e484a1d55..971b26b48b2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,6 +5,7 @@ version = "0.2.2"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/rust-lang/crates.io"
 description = "Backend of crates.io"
+edition = "2018"
 
 [workspace]
 
diff --git a/build.rs b/build.rs
index 7f1cba2ea8d..604d405b1c0 100644
--- a/build.rs
+++ b/build.rs
@@ -1,7 +1,3 @@
-extern crate diesel;
-extern crate diesel_migrations;
-extern crate dotenv;
-
 use diesel::prelude::*;
 use diesel_migrations::run_pending_migrations;
 use dotenv::dotenv;
diff --git a/src/app.rs b/src/app.rs
index 6adb9e38a2b..bdc42eea0f5 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -1,19 +1,16 @@
 //! Application-wide components in a struct accessible from each request
 
-use std::env;
-use std::path::PathBuf;
-use std::sync::{Arc, Mutex};
-use std::time::Duration;
+use crate::{db, util::CargoResult, Config, Env};
+use std::{
+    env,
+    path::PathBuf,
+    sync::{Arc, Mutex},
+    time::Duration,
+};
 
 use diesel::r2d2;
-use git2;
-use oauth2;
-use reqwest;
 use scheduled_thread_pool::ScheduledThreadPool;
 
-use util::CargoResult;
-use {db, Config, Env};
-
 /// The `App` struct holds the main components of the application like
 /// the database connection pool and configurations
 // The db, oauth, and git2 types don't implement debug.
diff --git a/src/bin/delete-crate.rs b/src/bin/delete-crate.rs
index e215607bc1b..952c429bebc 100644
--- a/src/bin/delete-crate.rs
+++ b/src/bin/delete-crate.rs
@@ -7,19 +7,16 @@
 
 #![deny(warnings)]
 
-extern crate cargo_registry;
-extern crate diesel;
+use cargo_registry::{db, models::Crate, schema::crates};
+use std::{
+    env,
+    io::{self, prelude::*},
+};
 
 use diesel::prelude::*;
-use std::env;
-use std::io;
-use std::io::prelude::*;
-
-use cargo_registry::models::Crate;
-use cargo_registry::schema::crates;
 
 fn main() {
-    let conn = cargo_registry::db::connect_now().unwrap();
+    let conn = db::connect_now().unwrap();
     conn.transaction::<_, diesel::result::Error, _>(|| {
         delete(&conn);
         Ok(())
diff --git a/src/bin/delete-version.rs b/src/bin/delete-version.rs
index ec6ac74f828..07f0ee4cde4 100644
--- a/src/bin/delete-version.rs
+++ b/src/bin/delete-version.rs
@@ -7,19 +7,20 @@
 
 #![deny(warnings)]
 
-extern crate cargo_registry;
-extern crate diesel;
+use cargo_registry::{
+    db,
+    models::{Crate, Version},
+    schema::versions,
+};
+use std::{
+    env,
+    io::{self, prelude::*},
+};
 
 use diesel::prelude::*;
-use std::env;
-use std::io;
-use std::io::prelude::*;
-
-use cargo_registry::models::{Crate, Version};
-use cargo_registry::schema::versions;
 
 fn main() {
-    let conn = cargo_registry::db::connect_now().unwrap();
+    let conn = db::connect_now().unwrap();
     conn.transaction::<_, diesel::result::Error, _>(|| {
         delete(&conn);
         Ok(())
diff --git a/src/bin/on_call/mod.rs b/src/bin/on_call/mod.rs
index c120ca2d819..39bedfecf0b 100644
--- a/src/bin/on_call/mod.rs
+++ b/src/bin/on_call/mod.rs
@@ -1,10 +1,7 @@
-extern crate cargo_registry;
-extern crate reqwest;
-
-use self::reqwest::{header, StatusCode as Status};
+use cargo_registry::util::{internal, CargoResult};
 use std::env;
 
-use self::cargo_registry::util::*;
+use reqwest::{header, StatusCode as Status};
 
 #[derive(Serialize, Debug)]
 #[serde(rename_all = "snake_case", tag = "event_type")]
diff --git a/src/bin/populate.rs b/src/bin/populate.rs
index b699d03083b..d9e067b278b 100644
--- a/src/bin/populate.rs
+++ b/src/bin/populate.rs
@@ -6,18 +6,14 @@
 
 #![deny(warnings)]
 
-extern crate cargo_registry;
-extern crate diesel;
-extern crate rand;
+use cargo_registry::{db, schema::version_downloads};
+use std::env;
 
 use diesel::prelude::*;
 use rand::{Rng, StdRng};
-use std::env;
-
-use cargo_registry::schema::version_downloads;
 
 fn main() {
-    let conn = cargo_registry::db::connect_now().unwrap();
+    let conn = db::connect_now().unwrap();
     conn.transaction(|| update(&conn)).unwrap();
 }
 
diff --git a/src/bin/render-readmes.rs b/src/bin/render-readmes.rs
index 5d414b1eb32..66238804a38 100644
--- a/src/bin/render-readmes.rs
+++ b/src/bin/render-readmes.rs
@@ -8,32 +8,21 @@
 #[macro_use]
 extern crate serde_derive;
 
-extern crate cargo_registry;
-extern crate chrono;
-extern crate diesel;
-extern crate docopt;
-extern crate flate2;
-extern crate itertools;
-extern crate reqwest;
-extern crate tar;
-extern crate toml;
+use cargo_registry::{
+    db,
+    models::Version,
+    render::readme_to_html,
+    schema::{crates, readme_renderings, versions},
+    Config,
+};
+use std::{io::Read, path::Path, thread};
 
 use chrono::{TimeZone, Utc};
-use diesel::dsl::any;
-use diesel::prelude::*;
+use diesel::{dsl::any, prelude::*};
 use docopt::Docopt;
 use flate2::read::GzDecoder;
 use itertools::Itertools;
-use std::io::Read;
-use std::path::Path;
-use std::thread;
-use tar::Archive;
-
-use cargo_registry::render::readme_to_html;
-use cargo_registry::Config;
-
-use cargo_registry::models::Version;
-use cargo_registry::schema::*;
+use tar::{self, Archive};
 
 const DEFAULT_PAGE_SIZE: usize = 25;
 const USAGE: &str = "
@@ -59,7 +48,7 @@ fn main() {
         .and_then(|d| d.deserialize())
         .unwrap_or_else(|e| e.exit());
     let config = Config::default();
-    let conn = cargo_registry::db::connect_now().unwrap();
+    let conn = db::connect_now().unwrap();
 
     let start_time = Utc::now();
 
diff --git a/src/bin/server.rs b/src/bin/server.rs
index 2337db51ef3..0e78527fae6 100644
--- a/src/bin/server.rs
+++ b/src/bin/server.rs
@@ -1,21 +1,18 @@
 #![deny(warnings)]
 
-extern crate cargo_registry;
-extern crate civet;
-extern crate env_logger;
-extern crate git2;
+use cargo_registry::{boot, build_handler, env, git, App, Config, Env};
+use std::{
+    env,
+    fs::{self, File},
+    sync::{mpsc::channel, Arc},
+};
 
-use cargo_registry::{env, Env};
 use civet::Server;
-use std::env;
-use std::fs::{self, File};
-use std::sync::mpsc::channel;
-use std::sync::Arc;
 
 fn main() {
     // Initialize logging
     env_logger::init();
-    let config = cargo_registry::Config::default();
+    let config = Config::default();
 
     // If there isn't a git checkout containing the crate index repo at the path specified
     // by `GIT_REPO_CHECKOUT`, delete that directory and clone the repo specified by `GIT_REPO_URL`
@@ -28,7 +25,7 @@ fn main() {
             let _ = fs::remove_dir_all(&config.git_repo_checkout);
             fs::create_dir_all(&config.git_repo_checkout).unwrap();
             let mut cb = git2::RemoteCallbacks::new();
-            cb.credentials(cargo_registry::git::credentials);
+            cb.credentials(git::credentials);
             let mut opts = git2::FetchOptions::new();
             opts.remote_callbacks(cb);
             git2::build::RepoBuilder::new()
@@ -44,13 +41,13 @@ fn main() {
     cfg.set_str("user.name", "bors").unwrap();
     cfg.set_str("user.email", "bors@rust-lang.org").unwrap();
 
-    let app = cargo_registry::App::new(&config);
-    let app = cargo_registry::build_handler(Arc::new(app));
+    let app = App::new(&config);
+    let app = build_handler(Arc::new(app));
 
     // On every server restart, ensure the categories available in the database match
     // the information in *src/categories.toml*.
     let categories_toml = include_str!("../boot/categories.toml");
-    cargo_registry::boot::categories::sync(categories_toml).unwrap();
+    boot::categories::sync(categories_toml).unwrap();
 
     let heroku = env::var("HEROKU").is_ok();
     let port = if heroku {
diff --git a/src/bin/transfer-crates.rs b/src/bin/transfer-crates.rs
index 6c7a6f749d5..369317c0ddf 100644
--- a/src/bin/transfer-crates.rs
+++ b/src/bin/transfer-crates.rs
@@ -5,19 +5,21 @@
 
 #![deny(warnings)]
 
-extern crate cargo_registry;
-extern crate diesel;
+use cargo_registry::{
+    db,
+    models::{Crate, OwnerKind, User},
+    schema::{crate_owners, crates, users},
+};
+use std::{
+    env,
+    io::{self, prelude::*},
+    process::exit,
+};
 
 use diesel::prelude::*;
-use std::env;
-use std::io;
-use std::io::prelude::*;
-
-use cargo_registry::models::{Crate, OwnerKind, User};
-use cargo_registry::schema::*;
 
 fn main() {
-    let conn = cargo_registry::db::connect_now().unwrap();
+    let conn = db::connect_now().unwrap();
     conn.transaction::<_, diesel::result::Error, _>(|| {
         transfer(&conn);
         Ok(())
@@ -97,6 +99,6 @@ fn get_confirm(msg: &str) {
     let mut line = String::new();
     io::stdin().read_line(&mut line).unwrap();
     if !line.starts_with('y') {
-        std::process::exit(0);
+        exit(0);
     }
 }
diff --git a/src/bin/update-downloads.rs b/src/bin/update-downloads.rs
index 2d816b7f0f4..f67a1f411d8 100644
--- a/src/bin/update-downloads.rs
+++ b/src/bin/update-downloads.rs
@@ -1,16 +1,17 @@
 #![deny(warnings)]
 #![allow(unknown_lints, proc_macro_derive_resolution_fallback)] // This can be removed after diesel-1.4
 
-extern crate cargo_registry;
 #[macro_use]
 extern crate diesel;
 
-use diesel::prelude::*;
-use std::env;
-use std::time::Duration;
+use cargo_registry::{
+    db,
+    models::VersionDownload,
+    schema::{crate_downloads, crates, metadata, version_downloads, versions},
+};
+use std::{env, thread, time::Duration};
 
-use cargo_registry::models::VersionDownload;
-use cargo_registry::schema::*;
+use diesel::prelude::*;
 
 static LIMIT: i64 = 1000;
 
@@ -18,11 +19,11 @@ fn main() {
     let daemon = env::args().nth(1).as_ref().map(|s| &s[..]) == Some("daemon");
     let sleep = env::args().nth(2).map(|s| s.parse().unwrap());
     loop {
-        let conn = cargo_registry::db::connect_now().unwrap();
+        let conn = db::connect_now().unwrap();
         update(&conn).unwrap();
         drop(conn);
         if daemon {
-            std::thread::sleep(Duration::new(sleep.unwrap(), 0));
+            thread::sleep(Duration::new(sleep.unwrap(), 0));
         } else {
             break;
         }
@@ -30,9 +31,9 @@ fn main() {
 }
 
 fn update(conn: &PgConnection) -> QueryResult<()> {
+    use crate::version_downloads::dsl::*;
     use diesel::dsl::now;
     use diesel::select;
-    use version_downloads::dsl::*;
 
     let mut max = Some(0);
     while let Some(m) = max {
@@ -113,13 +114,12 @@ fn collect(conn: &PgConnection, rows: &[VersionDownload]) -> QueryResult<()> {
 
 #[cfg(test)]
 mod test {
-    extern crate semver;
-
-    use std::collections::HashMap;
-
     use super::*;
-    use cargo_registry::env;
-    use cargo_registry::models::{Crate, NewCrate, NewUser, NewVersion, User, Version};
+    use cargo_registry::{
+        env,
+        models::{Crate, NewCrate, NewUser, NewVersion, User, Version},
+    };
+    use std::collections::HashMap;
 
     fn conn() -> PgConnection {
         let conn = PgConnection::establish(&env("TEST_DATABASE_URL")).unwrap();
@@ -183,7 +183,7 @@ mod test {
             .execute(&conn)
             .unwrap();
 
-        ::update(&conn).unwrap();
+        crate::update(&conn).unwrap();
         let version_downloads = versions::table
             .find(version.id)
             .select(versions::downloads)
@@ -195,7 +195,7 @@ mod test {
             .first(&conn);
         assert_eq!(Ok(1), crate_downloads);
         crate_downloads!(&conn, krate.id, 1);
-        ::update(&conn).unwrap();
+        crate::update(&conn).unwrap();
         let version_downloads = versions::table
             .find(version.id)
             .select(versions::downloads)
@@ -220,7 +220,7 @@ mod test {
             ))
             .execute(&conn)
             .unwrap();
-        ::update(&conn).unwrap();
+        crate::update(&conn).unwrap();
         let processed = version_downloads::table
             .filter(version_downloads::version_id.eq(version.id))
             .select(version_downloads::processed)
@@ -244,7 +244,7 @@ mod test {
             ))
             .execute(&conn)
             .unwrap();
-        ::update(&conn).unwrap();
+        crate::update(&conn).unwrap();
         let processed = version_downloads::table
             .filter(version_downloads::version_id.eq(version.id))
             .select(version_downloads::processed)
@@ -294,7 +294,7 @@ mod test {
             .filter(crates::id.eq(krate.id))
             .first::<Crate>(&conn)
             .unwrap();
-        ::update(&conn).unwrap();
+        crate::update(&conn).unwrap();
         let version2 = versions::table
             .find(version.id)
             .first::<Version>(&conn)
@@ -308,7 +308,7 @@ mod test {
         assert_eq!(krate2.downloads, 2);
         assert_eq!(krate2.updated_at, krate_before.updated_at);
         crate_downloads!(&conn, krate.id, 1);
-        ::update(&conn).unwrap();
+        crate::update(&conn).unwrap();
         let version3 = versions::table
             .find(version.id)
             .first::<Version>(&conn)
@@ -343,7 +343,7 @@ mod test {
             .execute(&conn)
             .unwrap();
 
-        ::update(&conn).unwrap();
+        crate::update(&conn).unwrap();
         let versions_changed = versions::table
             .select(versions::updated_at.ne(now - 2.days()))
             .get_result(&conn);
diff --git a/src/boot/categories.rs b/src/boot/categories.rs
index a64a506003f..b001baa2c44 100644
--- a/src/boot/categories.rs
+++ b/src/boot/categories.rs
@@ -1,12 +1,12 @@
 // Sync available crate categories from `src/categories.toml`.
 // Runs when the server is started.
 
-use diesel;
-use diesel::prelude::*;
-use toml;
+use crate::{
+    db,
+    util::errors::{internal, CargoResult, ChainError},
+};
 
-use db;
-use util::errors::{internal, CargoResult, ChainError};
+use diesel::prelude::*;
 
 #[derive(Debug)]
 struct Category {
@@ -91,9 +91,9 @@ pub fn sync(toml_str: &str) -> CargoResult<()> {
 }
 
 pub fn sync_with_connection(toml_str: &str, conn: &PgConnection) -> CargoResult<()> {
+    use crate::schema::categories::dsl::*;
     use diesel::dsl::all;
     use diesel::pg::upsert::excluded;
-    use schema::categories::dsl::*;
 
     let toml: toml::value::Table =
         toml::from_str(toml_str).expect("Could not parse categories toml");
diff --git a/src/config.rs b/src/config.rs
index 03561ba1113..c86f7affcc7 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,9 +1,5 @@
-use s3;
-
-use std::env;
-use std::path::PathBuf;
-
-use {env, Env, Replica, Uploader};
+use crate::{env, uploaders::Uploader, Env, Replica};
+use std::{env, path::PathBuf};
 
 #[derive(Clone, Debug)]
 pub struct Config {
diff --git a/src/controllers/category.rs b/src/controllers/category.rs
index e14838d94fa..30860203a4e 100644
--- a/src/controllers/category.rs
+++ b/src/controllers/category.rs
@@ -1,8 +1,8 @@
 use super::prelude::*;
 
-use models::Category;
-use schema::categories;
-use views::{EncodableCategory, EncodableCategoryWithSubcategories};
+use crate::models::Category;
+use crate::schema::categories;
+use crate::views::{EncodableCategory, EncodableCategoryWithSubcategories};
 
 /// Handles the `GET /categories` route.
 pub fn index(req: &mut dyn Request) -> CargoResult<Response> {
diff --git a/src/controllers/crate_owner_invitation.rs b/src/controllers/crate_owner_invitation.rs
index 26fc8ed1d0f..df5a9b2b1dd 100644
--- a/src/controllers/crate_owner_invitation.rs
+++ b/src/controllers/crate_owner_invitation.rs
@@ -1,10 +1,8 @@
 use super::prelude::*;
 
-use serde_json;
-
-use models::{CrateOwner, CrateOwnerInvitation, OwnerKind};
-use schema::{crate_owner_invitations, crate_owners};
-use views::{EncodableCrateOwnerInvitation, InvitationResponse};
+use crate::models::{CrateOwner, CrateOwnerInvitation, OwnerKind};
+use crate::schema::{crate_owner_invitations, crate_owners};
+use crate::views::{EncodableCrateOwnerInvitation, InvitationResponse};
 
 /// Handles the `GET /me/crate_owner_invitations` route.
 pub fn list(req: &mut dyn Request) -> CargoResult<Response> {
diff --git a/src/controllers/helpers/mod.rs b/src/controllers/helpers/mod.rs
index 11fc7bfcc47..3fc53e213a9 100644
--- a/src/controllers/helpers/mod.rs
+++ b/src/controllers/helpers/mod.rs
@@ -1,5 +1,5 @@
+use crate::util::{json_response, CargoResult};
 use conduit::Response;
-use util::{json_response, CargoResult};
 
 pub mod pagination;
 
diff --git a/src/controllers/keyword.rs b/src/controllers/keyword.rs
index 947275662d4..b1aaf00deed 100644
--- a/src/controllers/keyword.rs
+++ b/src/controllers/keyword.rs
@@ -1,12 +1,12 @@
 use super::prelude::*;
 
-use controllers::helpers::Paginate;
-use models::Keyword;
-use views::EncodableKeyword;
+use crate::controllers::helpers::Paginate;
+use crate::models::Keyword;
+use crate::views::EncodableKeyword;
 
 /// Handles the `GET /keywords` route.
 pub fn index(req: &mut dyn Request) -> CargoResult<Response> {
-    use schema::keywords;
+    use crate::schema::keywords;
 
     let conn = req.db_conn()?;
     let (offset, limit) = req.pagination(10, 100)?;
diff --git a/src/controllers/krate/downloads.rs b/src/controllers/krate/downloads.rs
index 1af10e71b50..c556df57ee7 100644
--- a/src/controllers/krate/downloads.rs
+++ b/src/controllers/krate/downloads.rs
@@ -5,13 +5,13 @@
 
 use std::cmp;
 
-use controllers::prelude::*;
+use crate::controllers::prelude::*;
 
-use models::{Crate, CrateVersions, Version, VersionDownload};
-use schema::version_downloads;
-use views::EncodableVersionDownload;
+use crate::models::{Crate, CrateVersions, Version, VersionDownload};
+use crate::schema::version_downloads;
+use crate::views::EncodableVersionDownload;
 
-use models::krate::to_char;
+use crate::models::krate::to_char;
 
 /// Handles the `GET /crates/:crate_id/downloads` route.
 pub fn downloads(req: &mut dyn Request) -> CargoResult<Response> {
diff --git a/src/controllers/krate/follow.rs b/src/controllers/krate/follow.rs
index 86fe8c3a676..a9b554d1856 100644
--- a/src/controllers/krate/follow.rs
+++ b/src/controllers/krate/follow.rs
@@ -1,11 +1,10 @@
 //! Endpoints for managing a per user list of followed crates
 
-use diesel;
 use diesel::associations::Identifiable;
 
-use controllers::prelude::*;
-use models::{Crate, Follow};
-use schema::*;
+use crate::controllers::prelude::*;
+use crate::models::{Crate, Follow};
+use crate::schema::*;
 
 fn follow_target(req: &mut dyn Request) -> CargoResult<Follow> {
     let user = req.user()?;
diff --git a/src/controllers/krate/metadata.rs b/src/controllers/krate/metadata.rs
index 723456d58e3..c1991d4c9ad 100644
--- a/src/controllers/krate/metadata.rs
+++ b/src/controllers/krate/metadata.rs
@@ -4,20 +4,20 @@
 //! index or cached metadata which was extracted (client side) from the
 //! `Cargo.toml` file.
 
-use controllers::prelude::*;
-use models::{
+use crate::controllers::prelude::*;
+use crate::models::{
     Category, Crate, CrateCategory, CrateDownload, CrateKeyword, CrateVersions, Keyword, Version,
 };
-use schema::*;
-use views::{
+use crate::schema::*;
+use crate::views::{
     EncodableCategory, EncodableCrate, EncodableDependency, EncodableKeyword, EncodableVersion,
 };
 
-use models::krate::ALL_COLUMNS;
+use crate::models::krate::ALL_COLUMNS;
 
 /// Handles the `GET /summary` route.
 pub fn summary(req: &mut dyn Request) -> CargoResult<Response> {
-    use schema::crates::dsl::*;
+    use crate::schema::crates::dsl::*;
 
     let conn = req.db_conn()?;
     let num_crates = crates.count().get_result(&*conn)?;
@@ -116,7 +116,7 @@ pub fn show(req: &mut dyn Request) -> CargoResult<Response> {
         .load(&*conn)?;
     let cats = CrateCategory::belonging_to(&krate)
         .inner_join(categories::table)
-        .select(::models::category::ALL_COLUMNS)
+        .select(crate::models::category::ALL_COLUMNS)
         .load(&*conn)?;
     let recent_downloads = CrateDownload::belonging_to(&krate)
         .filter(crate_downloads::date.gt(date(now - 90.days())))
diff --git a/src/controllers/krate/owners.rs b/src/controllers/krate/owners.rs
index 01d9d773d41..8a5cca6e471 100644
--- a/src/controllers/krate/owners.rs
+++ b/src/controllers/krate/owners.rs
@@ -2,9 +2,9 @@
 
 use serde_json;
 
-use controllers::prelude::*;
-use models::{Crate, Owner, Rights, Team, User};
-use views::EncodableOwner;
+use crate::controllers::prelude::*;
+use crate::models::{Crate, Owner, Rights, Team, User};
+use crate::views::EncodableOwner;
 
 /// Handles the `GET /crates/:crate_id/owners` route.
 pub fn owners(req: &mut dyn Request) -> CargoResult<Response> {
diff --git a/src/controllers/krate/publish.rs b/src/controllers/krate/publish.rs
index f7490f8fb32..c7f94f85554 100644
--- a/src/controllers/krate/publish.rs
+++ b/src/controllers/krate/publish.rs
@@ -4,17 +4,16 @@ use std::collections::HashMap;
 use std::sync::Arc;
 
 use hex::ToHex;
-use serde_json;
 
-use git;
-use render;
-use util::{internal, ChainError, Maximums};
-use util::{read_fill, read_le_u32};
+use crate::git;
+use crate::render;
+use crate::util::{internal, ChainError, Maximums};
+use crate::util::{read_fill, read_le_u32};
 
-use controllers::prelude::*;
-use models::dependency;
-use models::{Badge, Category, Keyword, NewCrate, NewVersion, Rights, User};
-use views::{EncodableCrateUpload, GoodCrate, PublishWarnings};
+use crate::controllers::prelude::*;
+use crate::models::dependency;
+use crate::models::{Badge, Category, Keyword, NewCrate, NewVersion, Rights, User};
+use crate::views::{EncodableCrateUpload, GoodCrate, PublishWarnings};
 
 /// Handles the `PUT /crates/new` route.
 /// Used by `cargo publish` to publish a new crate or to publish a new version of an
diff --git a/src/controllers/krate/search.rs b/src/controllers/krate/search.rs
index 1f966969644..5dd9b5419ee 100644
--- a/src/controllers/krate/search.rs
+++ b/src/controllers/krate/search.rs
@@ -2,13 +2,13 @@
 
 use diesel_full_text_search::*;
 
-use controllers::helpers::Paginate;
-use controllers::prelude::*;
-use models::{Crate, CrateBadge, CrateVersions, OwnerKind, Version};
-use schema::*;
-use views::EncodableCrate;
+use crate::controllers::helpers::Paginate;
+use crate::controllers::prelude::*;
+use crate::models::{Crate, CrateBadge, CrateVersions, OwnerKind, Version};
+use crate::schema::*;
+use crate::views::EncodableCrate;
 
-use models::krate::{canon_crate_name, ALL_COLUMNS};
+use crate::models::krate::{canon_crate_name, ALL_COLUMNS};
 
 /// Handles the `GET /crates` route.
 /// Returns a list of crates. Called in a variety of scenarios in the
@@ -95,7 +95,7 @@ pub fn search(req: &mut dyn Request) -> CargoResult<Response> {
                 crates_keywords::table
                     .select(crates_keywords::crate_id)
                     .inner_join(keywords::table)
-                    .filter(::lower(keywords::keyword).eq(::lower(kw))),
+                    .filter(crate::lower(keywords::keyword).eq(crate::lower(kw))),
             ),
         );
     } else if let Some(letter) = params.get("letter") {
diff --git a/src/controllers/mod.rs b/src/controllers/mod.rs
index bea01e9b64b..5fa23bb3cb6 100644
--- a/src/controllers/mod.rs
+++ b/src/controllers/mod.rs
@@ -5,11 +5,11 @@ mod prelude {
     pub use conduit::{Request, Response};
     pub use conduit_router::RequestParams;
 
-    pub use db::RequestTransaction;
-    pub use util::{human, CargoResult};
+    pub use crate::db::RequestTransaction;
+    pub use crate::util::{human, CargoResult};
 
-    pub use middleware::app::RequestApp;
-    pub use middleware::current_user::RequestUser;
+    pub use crate::middleware::app::RequestApp;
+    pub use crate::middleware::current_user::RequestUser;
 
     use std::collections::HashMap;
     use std::io;
@@ -28,7 +28,7 @@ mod prelude {
 
     impl<'a> RequestUtils for dyn Request + 'a {
         fn json<T: Serialize>(&self, t: &T) -> Response {
-            ::util::json_response(t)
+            crate::util::json_response(t)
         }
 
         fn query(&self) -> HashMap<String, String> {
diff --git a/src/controllers/team.rs b/src/controllers/team.rs
index 4f95fd295a8..eb16bdb6ba3 100644
--- a/src/controllers/team.rs
+++ b/src/controllers/team.rs
@@ -1,8 +1,8 @@
-use controllers::prelude::*;
+use crate::controllers::prelude::*;
 
-use models::Team;
-use schema::teams;
-use views::EncodableTeam;
+use crate::models::Team;
+use crate::schema::teams;
+use crate::views::EncodableTeam;
 
 /// Handles the `GET /teams/:team_id` route.
 pub fn show_team(req: &mut dyn Request) -> CargoResult<Response> {
diff --git a/src/controllers/token.rs b/src/controllers/token.rs
index e6ecc1cded7..12ed47537c1 100644
--- a/src/controllers/token.rs
+++ b/src/controllers/token.rs
@@ -1,13 +1,12 @@
 use super::prelude::*;
 
-use diesel;
-use middleware::current_user::AuthenticationSource;
-use serde_json as json;
-use util::{bad_request, read_fill, ChainError};
+use crate::middleware::current_user::AuthenticationSource;
+use crate::models::ApiToken;
+use crate::schema::api_tokens;
+use crate::util::{bad_request, read_fill, ChainError};
+use crate::views::EncodableApiTokenWithToken;
 
-use models::ApiToken;
-use schema::api_tokens;
-use views::EncodableApiTokenWithToken;
+use serde_json as json;
 
 /// Handles the `GET /me/tokens` route.
 pub fn list(req: &mut dyn Request) -> CargoResult<Response> {
diff --git a/src/controllers/user/me.rs b/src/controllers/user/me.rs
index 58a8a07b63d..b185c9fa669 100644
--- a/src/controllers/user/me.rs
+++ b/src/controllers/user/me.rs
@@ -1,14 +1,12 @@
-use controllers::prelude::*;
+use crate::controllers::prelude::*;
 
-use serde_json;
+use crate::controllers::helpers::Paginate;
+use crate::email;
+use crate::util::bad_request;
 
-use controllers::helpers::Paginate;
-use email;
-use util::bad_request;
-
-use models::{Email, Follow, NewEmail, User, Version};
-use schema::{crates, emails, follows, users, versions};
-use views::{EncodableMe, EncodableVersion};
+use crate::models::{Email, Follow, NewEmail, User, Version};
+use crate::schema::{crates, emails, follows, users, versions};
+use crate::views::{EncodableMe, EncodableVersion};
 
 /// Handles the `GET /me` route.
 pub fn me(req: &mut dyn Request) -> CargoResult<Response> {
@@ -148,7 +146,7 @@ pub fn update_user(req: &mut dyn Request) -> CargoResult<Response> {
             .get_result::<String>(&*conn)
             .map_err(|_| human("Error in creating token"))?;
 
-        ::email::send_user_confirm_email(user_email, &user.gh_login, &token)
+        crate::email::send_user_confirm_email(user_email, &user.gh_login, &token)
             .map_err(|_| bad_request("Email could not be sent"))
     })?;
 
diff --git a/src/controllers/user/other.rs b/src/controllers/user/other.rs
index 9823a3eeef4..cbdf4180010 100644
--- a/src/controllers/user/other.rs
+++ b/src/controllers/user/other.rs
@@ -1,8 +1,8 @@
-use controllers::prelude::*;
+use crate::controllers::prelude::*;
 
-use models::{OwnerKind, User};
-use schema::{crate_owners, crates, users};
-use views::EncodablePublicUser;
+use crate::models::{OwnerKind, User};
+use crate::schema::{crate_owners, crates, users};
+use crate::views::EncodablePublicUser;
 
 /// Handles the `GET /users/:user_id` route.
 pub fn show(req: &mut dyn Request) -> CargoResult<Response> {
@@ -11,7 +11,7 @@ pub fn show(req: &mut dyn Request) -> CargoResult<Response> {
     let name = &req.params()["user_id"].to_lowercase();
     let conn = req.db_conn()?;
     let user = users
-        .filter(::lower(gh_login).eq(name))
+        .filter(crate::lower(gh_login).eq(name))
         .order(id.desc())
         .first::<User>(&*conn)?;
 
diff --git a/src/controllers/user/session.rs b/src/controllers/user/session.rs
index 6fc6f4e810c..bbe9c5786fc 100644
--- a/src/controllers/user/session.rs
+++ b/src/controllers/user/session.rs
@@ -1,10 +1,10 @@
-use controllers::prelude::*;
+use crate::controllers::prelude::*;
 
+use crate::github;
 use conduit_cookie::RequestSession;
-use github;
 use rand::{thread_rng, Rng};
 
-use models::NewUser;
+use crate::models::NewUser;
 
 /// Handles the `GET /authorize_url` route.
 ///
diff --git a/src/controllers/version/deprecated.rs b/src/controllers/version/deprecated.rs
index 70b3c84eb6c..6d2538d4724 100644
--- a/src/controllers/version/deprecated.rs
+++ b/src/controllers/version/deprecated.rs
@@ -5,13 +5,11 @@
 //! period of time to ensure there are no external users of an endpoint before
 //! it is removed.
 
-use controllers::prelude::*;
+use crate::controllers::prelude::*;
 
-use url;
-
-use models::Version;
-use schema::*;
-use views::EncodableVersion;
+use crate::models::Version;
+use crate::schema::*;
+use crate::views::EncodableVersion;
 
 use super::version_and_crate;
 
@@ -60,7 +58,7 @@ pub fn show(req: &mut dyn Request) -> CargoResult<Response> {
             versions::table
                 .find(id)
                 .inner_join(crates::table)
-                .select((versions::all_columns, ::models::krate::ALL_COLUMNS))
+                .select((versions::all_columns, crate::models::krate::ALL_COLUMNS))
                 .first(&*conn)?
         }
     };
diff --git a/src/controllers/version/downloads.rs b/src/controllers/version/downloads.rs
index 7b7ad5e8b16..681ada3eb91 100644
--- a/src/controllers/version/downloads.rs
+++ b/src/controllers/version/downloads.rs
@@ -2,15 +2,15 @@
 //!
 //! Crate level functionality is located in `krate::downloads`.
 
-use controllers::prelude::*;
+use crate::controllers::prelude::*;
 
 use chrono::{Duration, NaiveDate, Utc};
 
-use Replica;
+use crate::Replica;
 
-use models::{Crate, VersionDownload};
-use schema::*;
-use views::EncodableVersionDownload;
+use crate::models::{Crate, VersionDownload};
+use crate::schema::*;
+use crate::views::EncodableVersionDownload;
 
 use super::version_and_crate;
 
diff --git a/src/controllers/version/metadata.rs b/src/controllers/version/metadata.rs
index 0acc40ce0e2..8ee06557492 100644
--- a/src/controllers/version/metadata.rs
+++ b/src/controllers/version/metadata.rs
@@ -4,10 +4,10 @@
 //! index or cached metadata which was extracted (client side) from the
 //! `Cargo.toml` file.
 
-use controllers::prelude::*;
+use crate::controllers::prelude::*;
 
-use schema::*;
-use views::{EncodableDependency, EncodablePublicUser};
+use crate::schema::*;
+use crate::views::{EncodableDependency, EncodablePublicUser};
 
 use super::version_and_crate;
 
diff --git a/src/controllers/version/mod.rs b/src/controllers/version/mod.rs
index 46a4896fce8..5c1195882ca 100644
--- a/src/controllers/version/mod.rs
+++ b/src/controllers/version/mod.rs
@@ -4,10 +4,9 @@ pub mod metadata;
 pub mod yank;
 
 use super::prelude::*;
-use semver;
 
-use models::{Crate, CrateVersions, Version};
-use schema::versions;
+use crate::models::{Crate, CrateVersions, Version};
+use crate::schema::versions;
 
 fn version_and_crate(req: &mut dyn Request) -> CargoResult<(Version, Crate)> {
     let crate_name = &req.params()["crate_id"];
diff --git a/src/controllers/version/yank.rs b/src/controllers/version/yank.rs
index 893a17ebcb4..a413ad68e1c 100644
--- a/src/controllers/version/yank.rs
+++ b/src/controllers/version/yank.rs
@@ -1,14 +1,12 @@
 //! Endpoints for yanking and unyanking specific versions of crates
 
-use controllers::prelude::*;
+use crate::controllers::prelude::*;
 
-use diesel;
+use crate::git;
+use crate::util::errors::CargoError;
 
-use git;
-use util::errors::CargoError;
-
-use models::Rights;
-use schema::*;
+use crate::models::Rights;
+use crate::schema::*;
 
 use super::version_and_crate;
 
diff --git a/src/db.rs b/src/db.rs
index e49b9c9fcf2..cc966d3f893 100644
--- a/src/db.rs
+++ b/src/db.rs
@@ -5,15 +5,15 @@ use diesel::prelude::*;
 use diesel::r2d2::{self, ConnectionManager, CustomizeConnection};
 use url::Url;
 
-use middleware::app::RequestApp;
-use util::CargoResult;
+use crate::middleware::app::RequestApp;
+use crate::util::CargoResult;
 
 pub type DieselPool = r2d2::Pool<ConnectionManager<PgConnection>>;
 type DieselPooledConn = r2d2::PooledConnection<ConnectionManager<PgConnection>>;
 
 pub fn connect_now() -> ConnectionResult<PgConnection> {
     use diesel::Connection;
-    let mut url = Url::parse(&::env("DATABASE_URL")).expect("Invalid database URL");
+    let mut url = Url::parse(&crate::env("DATABASE_URL")).expect("Invalid database URL");
     if env::var("HEROKU").is_ok() && !url.query_pairs().any(|(k, _)| k == "sslmode") {
         url.query_pairs_mut().append_pair("sslmode", "require");
     }
diff --git a/src/email.rs b/src/email.rs
index 6f496c69294..0865fa09ea9 100644
--- a/src/email.rs
+++ b/src/email.rs
@@ -1,8 +1,8 @@
 use std::env;
 use std::path::Path;
 
+use crate::util::{bad_request, CargoResult};
 use dotenv::dotenv;
-use util::{bad_request, CargoResult};
 
 use lettre::file::FileEmailTransport;
 use lettre::smtp::authentication::{Credentials, Mechanism};
diff --git a/src/git.rs b/src/git.rs
index 994dacdfef1..6d7dfa0bf5e 100644
--- a/src/git.rs
+++ b/src/git.rs
@@ -4,14 +4,10 @@ use std::fs::{self, File};
 use std::io::prelude::*;
 use std::path::{Path, PathBuf};
 
-use git2;
-use semver;
-use serde_json;
+use crate::app::App;
+use crate::util::{internal, CargoResult};
 
-use app::App;
-use util::{internal, CargoResult};
-
-use models::DependencyKind;
+use crate::models::DependencyKind;
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct Crate {
diff --git a/src/github.rs b/src/github.rs
index a8467f6b1eb..731010bf2a7 100644
--- a/src/github.rs
+++ b/src/github.rs
@@ -7,8 +7,8 @@ use serde::de::DeserializeOwned;
 
 use std::str;
 
-use app::App;
-use util::{errors::NotFound, human, internal, CargoError, CargoResult};
+use crate::app::App;
+use crate::util::{errors::NotFound, human, internal, CargoError, CargoResult};
 
 /// Does all the nonsense for sending a GET to Github. Doesn't handle parsing
 /// because custom error-code handling may be desirable. Use
diff --git a/src/lib.rs b/src/lib.rs
index af543888d30..5f06c604e2c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -9,61 +9,25 @@
 #![recursion_limit = "256"]
 #![allow(unknown_lints, proc_macro_derive_resolution_fallback)] // TODO: This can be removed after diesel-1.4
 
-extern crate ammonia;
-extern crate chrono;
-extern crate comrak;
 #[macro_use]
 extern crate derive_deref;
 #[macro_use]
 extern crate diesel;
-extern crate diesel_full_text_search;
-extern crate diesel_ltree;
-extern crate dotenv;
-extern crate flate2;
-extern crate git2;
-extern crate hex;
-extern crate htmlescape;
-extern crate lettre;
-extern crate lettre_email;
-extern crate license_exprs;
 #[macro_use]
 extern crate log;
-extern crate oauth2;
-extern crate openssl;
-extern crate rand;
-extern crate reqwest;
-extern crate s3;
-extern crate scheduled_thread_pool;
-extern crate semver;
-extern crate serde;
 #[macro_use]
 extern crate serde_derive;
 #[macro_use]
 extern crate serde_json;
-extern crate tar;
-extern crate toml;
-extern crate url;
-
-extern crate conduit;
-extern crate conduit_conditional_get;
-extern crate conduit_cookie;
-extern crate conduit_git_http_backend;
-extern crate conduit_middleware;
-extern crate conduit_router;
-extern crate conduit_static;
-extern crate cookie;
-
-pub use self::uploaders::{Bomb, Uploader};
-pub use app::App;
-pub use config::Config;
 
+pub use crate::{app::App, config::Config, uploaders::Uploader};
 use std::sync::Arc;
 
 use conduit_middleware::MiddlewareBuilder;
 
-pub mod app;
+mod app;
 pub mod boot;
-pub mod config;
+mod config;
 pub mod db;
 pub mod email;
 pub mod git;
diff --git a/src/middleware/app.rs b/src/middleware/app.rs
index 49c9a7b930f..3f60b7f2791 100644
--- a/src/middleware/app.rs
+++ b/src/middleware/app.rs
@@ -1,7 +1,7 @@
 use super::prelude::*;
 
+use crate::App;
 use std::sync::Arc;
-use App;
 
 /// Middleware that injects the `App` instance into the `Request` extensions
 // Can't derive Debug because `App` can't.
diff --git a/src/middleware/current_user.rs b/src/middleware/current_user.rs
index 14028bb076b..6ff9c05e64a 100644
--- a/src/middleware/current_user.rs
+++ b/src/middleware/current_user.rs
@@ -3,11 +3,11 @@ use super::prelude::*;
 use conduit_cookie::RequestSession;
 use diesel::prelude::*;
 
-use db::RequestTransaction;
-use util::errors::{std_error, CargoResult, ChainError, Unauthorized};
+use crate::db::RequestTransaction;
+use crate::util::errors::{std_error, CargoResult, ChainError, Unauthorized};
 
-use models::User;
-use schema::users;
+use crate::models::User;
+use crate::schema::users;
 
 #[derive(Debug, Clone, Copy)]
 pub struct CurrentUser;
diff --git a/src/middleware/ember_index_rewrite.rs b/src/middleware/ember_index_rewrite.rs
index e87f24c5c42..8daadb1289d 100644
--- a/src/middleware/ember_index_rewrite.rs
+++ b/src/middleware/ember_index_rewrite.rs
@@ -3,7 +3,7 @@
 
 use super::prelude::*;
 
-use util::RequestProxy;
+use crate::util::RequestProxy;
 
 // Can't derive debug because of Handler and Static.
 #[allow(missing_debug_implementations)]
diff --git a/src/middleware/head.rs b/src/middleware/head.rs
index 7c7328a57e3..04f26a57ddd 100644
--- a/src/middleware/head.rs
+++ b/src/middleware/head.rs
@@ -2,9 +2,9 @@
 
 use super::prelude::*;
 
+use crate::util::RequestProxy;
 use conduit::Method;
 use std::io;
-use util::RequestProxy;
 
 // Can't derive debug because of Handler.
 #[allow(missing_debug_implementations)]
diff --git a/src/middleware/log_request.rs b/src/middleware/log_request.rs
index f4fc63af051..2958a224024 100644
--- a/src/middleware/log_request.rs
+++ b/src/middleware/log_request.rs
@@ -2,10 +2,10 @@
 //! information that we care about like User-Agent and Referer
 
 use super::prelude::*;
+use crate::util::request_header;
 use conduit::Request;
 use std::fmt;
 use std::time::Instant;
-use util::request_header;
 
 #[allow(missing_debug_implementations)] // We can't
 #[derive(Default)]
diff --git a/src/middleware/mod.rs b/src/middleware/mod.rs
index 9ff2c453035..7fc05595e68 100644
--- a/src/middleware/mod.rs
+++ b/src/middleware/mod.rs
@@ -28,12 +28,11 @@ use conduit_conditional_get::ConditionalGet;
 use conduit_cookie::{Middleware as Cookie, SessionMiddleware};
 use conduit_middleware::MiddlewareBuilder;
 
-use cookie;
 use std::env;
 use std::sync::Arc;
 
-use router::R404;
-use {App, Env};
+use crate::router::R404;
+use crate::{App, Env};
 
 pub fn build_middleware(app: Arc<App>, endpoints: R404) -> MiddlewareBuilder {
     let mut m = MiddlewareBuilder::new(endpoints);
diff --git a/src/middleware/require_user_agent.rs b/src/middleware/require_user_agent.rs
index bb4cfa05855..0228f748182 100644
--- a/src/middleware/require_user_agent.rs
+++ b/src/middleware/require_user_agent.rs
@@ -2,9 +2,9 @@
 
 use super::prelude::*;
 
+use crate::util::request_header;
 use std::collections::HashMap;
 use std::io::Cursor;
-use util::request_header;
 
 // Can't derive debug because of Handler.
 #[allow(missing_debug_implementations)]
diff --git a/src/middleware/security_headers.rs b/src/middleware/security_headers.rs
index bc3b4646ef6..98a60c94abb 100644
--- a/src/middleware/security_headers.rs
+++ b/src/middleware/security_headers.rs
@@ -1,10 +1,9 @@
 //! Middleware that adds secuirty headers to http responses in production.
 
 use super::prelude::*;
+use crate::Uploader;
 use std::collections::HashMap;
 
-use Uploader;
-
 #[derive(Clone, Debug)]
 pub struct SecurityHeaders {
     headers: HashMap<String, Vec<String>>,
diff --git a/src/models/badge.rs b/src/models/badge.rs
index 9d451ae2ade..936466fc180 100644
--- a/src/models/badge.rs
+++ b/src/models/badge.rs
@@ -1,12 +1,11 @@
 use diesel::associations::HasTable;
 use diesel::pg::Pg;
 use diesel::prelude::*;
-use serde_json;
 use std::collections::HashMap;
 
-use models::Crate;
-use schema::badges;
-use views::EncodableBadge;
+use crate::models::Crate;
+use crate::schema::badges;
+use crate::views::EncodableBadge;
 
 /// A combination of a `Badge` and a crate ID.
 ///
diff --git a/src/models/category.rs b/src/models/category.rs
index b3d0f24d746..dccc16f7005 100644
--- a/src/models/category.rs
+++ b/src/models/category.rs
@@ -1,9 +1,9 @@
 use chrono::NaiveDateTime;
 use diesel::{self, *};
 
-use models::Crate;
-use schema::*;
-use views::EncodableCategory;
+use crate::models::Crate;
+use crate::schema::*;
+use crate::views::EncodableCategory;
 
 #[derive(Clone, Identifiable, Queryable, QueryableByName, Debug)]
 #[table_name = "categories"]
@@ -37,7 +37,7 @@ pub const ALL_COLUMNS: AllColumns = (
 );
 
 type All = diesel::dsl::Select<categories::table, AllColumns>;
-type WithSlug<'a> = diesel::dsl::Eq<categories::slug, ::lower::HelperType<&'a str>>;
+type WithSlug<'a> = diesel::dsl::Eq<categories::slug, crate::lower::HelperType<&'a str>>;
 type BySlug<'a> = diesel::dsl::Filter<All, WithSlug<'a>>;
 type WithSlugsCaseSensitive<'a> = diesel::dsl::Eq<
     categories::slug,
@@ -61,11 +61,11 @@ pub struct CrateCategory {
 }
 
 impl Category {
-    pub fn with_slug(slug: &str) -> WithSlug {
-        categories::slug.eq(::lower(slug))
+    pub fn with_slug(slug: &str) -> WithSlug<'_> {
+        categories::slug.eq(crate::lower(slug))
     }
 
-    pub fn by_slug(slug: &str) -> BySlug {
+    pub fn by_slug(slug: &str) -> BySlug<'_> {
         Category::all().filter(Self::with_slug(slug))
     }
 
@@ -194,7 +194,7 @@ pub struct NewCategory<'a> {
 impl<'a> NewCategory<'a> {
     /// Inserts the category into the database, or updates an existing one.
     pub fn create_or_update(&self, conn: &PgConnection) -> QueryResult<Category> {
-        use schema::categories::dsl::*;
+        use crate::schema::categories::dsl::*;
 
         insert_into(categories)
             .values(self)
diff --git a/src/models/crate_owner_invitation.rs b/src/models/crate_owner_invitation.rs
index 36e9e9dbbf1..2ede8fbe18d 100644
--- a/src/models/crate_owner_invitation.rs
+++ b/src/models/crate_owner_invitation.rs
@@ -1,8 +1,8 @@
 use chrono::NaiveDateTime;
 use diesel::prelude::*;
 
-use schema::{crate_owner_invitations, crates, users};
-use views::EncodableCrateOwnerInvitation;
+use crate::schema::{crate_owner_invitations, crates, users};
+use crate::views::EncodableCrateOwnerInvitation;
 
 /// The model representing a row in the `crate_owner_invitations` database table.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Identifiable, Queryable)]
diff --git a/src/models/dependency.rs b/src/models/dependency.rs
index 868f75bcf48..be416e3c5f8 100644
--- a/src/models/dependency.rs
+++ b/src/models/dependency.rs
@@ -1,12 +1,11 @@
 use diesel::prelude::*;
-use semver;
 
-use git;
-use util::{human, CargoResult};
+use crate::git;
+use crate::util::{human, CargoResult};
 
-use models::{Crate, Version};
-use schema::*;
-use views::{EncodableCrateDependency, EncodableDependency};
+use crate::models::{Crate, Version};
+use crate::schema::*;
+use crate::views::{EncodableCrateDependency, EncodableDependency};
 
 #[derive(Identifiable, Associations, Debug, Queryable, QueryableByName)]
 #[belongs_to(Version)]
diff --git a/src/models/download.rs b/src/models/download.rs
index 3f85666da5d..e15db4c62bd 100644
--- a/src/models/download.rs
+++ b/src/models/download.rs
@@ -1,10 +1,9 @@
 use chrono::NaiveDate;
-use diesel;
 use diesel::prelude::*;
 
-use models::Version;
-use schema::version_downloads;
-use views::EncodableVersionDownload;
+use crate::models::Version;
+use crate::schema::version_downloads;
+use crate::views::EncodableVersionDownload;
 
 #[derive(Queryable, Identifiable, Associations, Debug, Clone, Copy)]
 #[belongs_to(Version)]
diff --git a/src/models/email.rs b/src/models/email.rs
index 5d247da6194..00d9191aaff 100644
--- a/src/models/email.rs
+++ b/src/models/email.rs
@@ -1,7 +1,7 @@
 use chrono::NaiveDateTime;
 
-use models::User;
-use schema::emails;
+use crate::models::User;
+use crate::schema::emails;
 
 #[derive(Debug, Queryable, AsChangeset, Identifiable, Associations)]
 #[belongs_to(User)]
diff --git a/src/models/follow.rs b/src/models/follow.rs
index 62aba05b29f..ebe98e703e3 100644
--- a/src/models/follow.rs
+++ b/src/models/follow.rs
@@ -1,5 +1,5 @@
-use models::User;
-use schema::follows;
+use crate::models::User;
+use crate::schema::follows;
 
 #[derive(Insertable, Queryable, Identifiable, Associations, Clone, Copy, Debug)]
 #[belongs_to(User)]
diff --git a/src/models/keyword.rs b/src/models/keyword.rs
index 807cc1df18b..fc121fc5754 100644
--- a/src/models/keyword.rs
+++ b/src/models/keyword.rs
@@ -1,10 +1,9 @@
 use chrono::NaiveDateTime;
-use diesel;
 use diesel::prelude::*;
 
-use models::Crate;
-use schema::*;
-use views::EncodableKeyword;
+use crate::models::Crate;
+use crate::schema::*;
+use crate::views::EncodableKeyword;
 
 #[derive(Clone, Identifiable, Queryable, Debug)]
 pub struct Keyword {
@@ -27,7 +26,7 @@ pub struct CrateKeyword {
 impl Keyword {
     pub fn find_by_keyword(conn: &PgConnection, name: &str) -> QueryResult<Keyword> {
         keywords::table
-            .filter(keywords::keyword.eq(::lower(name)))
+            .filter(keywords::keyword.eq(crate::lower(name)))
             .first(&*conn)
     }
 
diff --git a/src/models/krate.rs b/src/models/krate.rs
index 2b6d19f8080..030c6c39911 100644
--- a/src/models/krate.rs
+++ b/src/models/krate.rs
@@ -1,23 +1,20 @@
 use chrono::{NaiveDate, NaiveDateTime};
-use diesel;
 use diesel::associations::Identifiable;
 use diesel::pg::Pg;
 use diesel::prelude::*;
-use license_exprs;
-use semver;
 use url::Url;
 
-use app::App;
-use util::{human, CargoResult};
+use crate::app::App;
+use crate::util::{human, CargoResult};
 
-use models::{
+use crate::models::{
     Badge, Category, CrateOwner, Keyword, NewCrateOwnerInvitation, Owner, OwnerKind,
     ReverseDependency, User, Version,
 };
-use views::{EncodableCrate, EncodableCrateLinks};
+use crate::views::{EncodableCrate, EncodableCrateLinks};
 
-use models::helpers::with_count::*;
-use schema::*;
+use crate::models::helpers::with_count::*;
+use crate::schema::*;
 
 /// Hosts in this list are known to not be hosting documentation,
 /// and are possibly of malicious intent e.g. ad tracking networks, etc.
@@ -194,9 +191,9 @@ impl<'a> NewCrate<'a> {
     }
 
     fn ensure_name_not_reserved(&self, conn: &PgConnection) -> CargoResult<()> {
+        use crate::schema::reserved_crate_names::dsl::*;
         use diesel::dsl::exists;
         use diesel::select;
-        use schema::reserved_crate_names::dsl::*;
 
         let reserved_name = select(exists(
             reserved_crate_names.filter(canon_crate_name(name).eq(canon_crate_name(self.name))),
@@ -210,7 +207,7 @@ impl<'a> NewCrate<'a> {
     }
 
     fn save_new_crate(&self, conn: &PgConnection, user_id: i32) -> QueryResult<Option<Crate>> {
-        use schema::crates::dsl::*;
+        use crate::schema::crates::dsl::*;
 
         conn.transaction(|| {
             let maybe_inserted = diesel::insert_into(crates)
@@ -396,7 +393,7 @@ impl Crate {
     }
 
     pub fn max_version(&self, conn: &PgConnection) -> CargoResult<semver::Version> {
-        use schema::versions::dsl::*;
+        use crate::schema::versions::dsl::*;
 
         let vs = self
             .versions()
@@ -526,7 +523,7 @@ sql_function!(fn to_char(a: Date, b: Text) -> Text);
 
 #[cfg(test)]
 mod tests {
-    use models::Crate;
+    use crate::models::Crate;
 
     #[test]
     fn documentation_blocked_no_url_provided() {
diff --git a/src/models/owner.rs b/src/models/owner.rs
index 10dd01974d8..46611336c2a 100644
--- a/src/models/owner.rs
+++ b/src/models/owner.rs
@@ -1,12 +1,12 @@
 use diesel::prelude::*;
 
-use app::App;
-use github;
-use util::{human, CargoResult};
+use crate::app::App;
+use crate::github;
+use crate::util::{human, CargoResult};
 
-use models::{Crate, Team, User};
-use schema::{crate_owners, users};
-use views::EncodableOwner;
+use crate::models::{Crate, Team, User};
+use crate::schema::{crate_owners, users};
+use crate::views::EncodableOwner;
 
 #[derive(Insertable, Associations, Identifiable, Debug, Clone, Copy)]
 #[belongs_to(Crate)]
diff --git a/src/models/team.rs b/src/models/team.rs
index 5d3164b1776..dd3162cb4e0 100644
--- a/src/models/team.rs
+++ b/src/models/team.rs
@@ -1,12 +1,12 @@
 use diesel::prelude::*;
 
-use app::App;
-use github;
-use util::{errors::NotFound, human, CargoResult};
+use crate::app::App;
+use crate::github;
+use crate::util::{errors::NotFound, human, CargoResult};
 
-use models::{Crate, CrateOwner, Owner, OwnerKind, User};
-use schema::{crate_owners, teams};
-use views::EncodableTeam;
+use crate::models::{Crate, CrateOwner, Owner, OwnerKind, User};
+use crate::schema::{crate_owners, teams};
+use crate::views::EncodableTeam;
 
 /// For now, just a Github Team. Can be upgraded to other teams
 /// later if desirable.
@@ -52,8 +52,8 @@ impl<'a> NewTeam<'a> {
     }
 
     pub fn create_or_update(&self, conn: &PgConnection) -> QueryResult<Team> {
+        use crate::schema::teams::dsl::*;
         use diesel::insert_into;
-        use schema::teams::dsl::*;
 
         insert_into(teams)
             .values(self)
@@ -118,7 +118,7 @@ impl Team {
         // "sanitization"
         fn whitelist(c: char) -> bool {
             match c {
-                'a'...'z' | 'A'...'Z' | '0'...'9' | '-' | '_' => false,
+                'a'..='z' | 'A'..='Z' | '0'..='9' | '-' | '_' => false,
                 _ => true,
             }
         }
diff --git a/src/models/token.rs b/src/models/token.rs
index c705c73a44e..1c71d932db5 100644
--- a/src/models/token.rs
+++ b/src/models/token.rs
@@ -1,11 +1,10 @@
 use chrono::NaiveDateTime;
-use diesel;
 use diesel::prelude::*;
 
-use models::User;
-use schema::api_tokens;
-use util::rfc3339;
-use views::EncodableApiTokenWithToken;
+use crate::models::User;
+use crate::schema::api_tokens;
+use crate::util::rfc3339;
+use crate::views::EncodableApiTokenWithToken;
 
 /// The model representing a row in the `api_tokens` database table.
 #[derive(Clone, Debug, PartialEq, Eq, Identifiable, Queryable, Associations, Serialize)]
diff --git a/src/models/user.rs b/src/models/user.rs
index 2e6f2086bcc..83ee9b96d5d 100644
--- a/src/models/user.rs
+++ b/src/models/user.rs
@@ -2,12 +2,12 @@ use diesel::dsl::now;
 use diesel::prelude::*;
 use std::borrow::Cow;
 
-use app::App;
-use util::CargoResult;
+use crate::app::App;
+use crate::util::CargoResult;
 
-use models::{Crate, CrateOwner, NewEmail, Owner, OwnerKind, Rights};
-use schema::{crate_owners, emails, users};
-use views::{EncodablePrivateUser, EncodablePublicUser};
+use crate::models::{Crate, CrateOwner, NewEmail, Owner, OwnerKind, Rights};
+use crate::schema::{crate_owners, emails, users};
+use crate::views::{EncodablePrivateUser, EncodablePublicUser};
 
 /// The model representing a row in the `users` database table.
 #[derive(Clone, Debug, PartialEq, Eq, Queryable, Identifiable, AsChangeset, Associations)]
@@ -53,12 +53,12 @@ impl<'a> NewUser<'a> {
 
     /// Inserts the user into the database, or updates an existing one.
     pub fn create_or_update(&self, conn: &PgConnection) -> QueryResult<User> {
+        use crate::schema::users::dsl::*;
         use diesel::dsl::sql;
         use diesel::insert_into;
         use diesel::pg::upsert::excluded;
         use diesel::sql_types::Integer;
         use diesel::NotFound;
-        use schema::users::dsl::*;
 
         conn.transaction(|| {
             let user = insert_into(users)
@@ -96,7 +96,7 @@ impl<'a> NewUser<'a> {
                     .optional()?;
 
                 if let Some(token) = token {
-                    ::email::send_user_confirm_email(user_email, &user.gh_login, &token)
+                    crate::email::send_user_confirm_email(user_email, &user.gh_login, &token)
                         .map_err(|_| NotFound)?;
                 }
             }
@@ -109,9 +109,9 @@ impl<'a> NewUser<'a> {
 impl User {
     /// Queries the database for a user with a certain `api_token` value.
     pub fn find_by_api_token(conn: &PgConnection, token_: &str) -> CargoResult<User> {
+        use crate::schema::api_tokens::dsl::{api_tokens, last_used_at, revoked, token, user_id};
+        use crate::schema::users::dsl::{id, users};
         use diesel::update;
-        use schema::api_tokens::dsl::{api_tokens, last_used_at, revoked, token, user_id};
-        use schema::users::dsl::{id, users};
         let tokens = api_tokens
             .filter(token.eq(token_))
             .filter(revoked.eq(false));
diff --git a/src/models/version.rs b/src/models/version.rs
index 68c7ce52a08..6efa01bc6c5 100644
--- a/src/models/version.rs
+++ b/src/models/version.rs
@@ -1,17 +1,13 @@
 use std::collections::HashMap;
 
 use chrono::NaiveDateTime;
-use diesel;
 use diesel::prelude::*;
-use semver;
-use serde_json;
 
-use license_exprs;
-use util::{human, CargoResult};
+use crate::util::{human, CargoResult};
 
-use models::{Crate, Dependency};
-use schema::*;
-use views::{EncodableVersion, EncodableVersionLinks};
+use crate::models::{Crate, Dependency};
+use crate::schema::*;
+use crate::views::{EncodableVersion, EncodableVersionLinks};
 
 // Queryable has a custom implementation below
 #[derive(Clone, Identifiable, Associations, Debug, Queryable)]
@@ -101,8 +97,8 @@ impl Version {
     }
 
     pub fn record_readme_rendering(&self, conn: &PgConnection) -> QueryResult<usize> {
+        use crate::schema::readme_renderings::dsl::*;
         use diesel::dsl::now;
-        use schema::readme_renderings::dsl::*;
 
         diesel::insert_into(readme_renderings)
             .values(version_id.eq(self.id))
@@ -139,10 +135,10 @@ impl NewVersion {
     }
 
     pub fn save(&self, conn: &PgConnection, authors: &[String]) -> CargoResult<Version> {
+        use crate::schema::version_authors::{name, version_id};
+        use crate::schema::versions::dsl::*;
         use diesel::dsl::exists;
         use diesel::{insert_into, select};
-        use schema::version_authors::{name, version_id};
-        use schema::versions::dsl::*;
 
         conn.transaction(|| {
             let already_uploaded = versions
diff --git a/src/render.rs b/src/render.rs
index 7e5f5ce5289..e2c5f532b5e 100644
--- a/src/render.rs
+++ b/src/render.rs
@@ -1,11 +1,10 @@
 use ammonia::{Builder, UrlRelative};
-use comrak;
 use htmlescape::encode_minimal;
 use std::borrow::Cow;
 use std::path::Path;
 use url::Url;
 
-use util::CargoResult;
+use crate::util::CargoResult;
 
 /// Context for markdown to HTML rendering.
 #[allow(missing_debug_implementations)]
diff --git a/src/router.rs b/src/router.rs
index 9bc5ace463d..7f4d86573d6 100644
--- a/src/router.rs
+++ b/src/router.rs
@@ -2,13 +2,12 @@ use std::error::Error;
 use std::sync::Arc;
 
 use conduit::{Handler, Request, Response};
-use conduit_git_http_backend;
 use conduit_router::{RequestParams, RouteBuilder};
 
-use controllers::*;
-use util::errors::{std_error, CargoError, CargoResult, NotFound};
-use util::RequestProxy;
-use {App, Env};
+use crate::controllers::*;
+use crate::util::errors::{std_error, CargoError, CargoResult, NotFound};
+use crate::util::RequestProxy;
+use crate::{App, Env};
 
 pub fn build_router(app: &App) -> R404 {
     let mut api_router = RouteBuilder::new();
@@ -174,12 +173,11 @@ impl Handler for R404 {
 
 #[cfg(test)]
 mod tests {
-    extern crate conduit_test;
-
-    use self::conduit_test::MockRequest;
     use super::*;
+    use crate::util::errors::{bad_request, human, internal, NotFound, Unauthorized};
+
+    use conduit_test::MockRequest;
     use diesel::result::Error as DieselError;
-    use util::errors::*;
 
     fn err<E: CargoError>(err: E) -> CargoResult<Response> {
         Err(Box::new(err))
diff --git a/src/tests/all.rs b/src/tests/all.rs
index e351cc4c59a..dae2d6fa184 100644
--- a/src/tests/all.rs
+++ b/src/tests/all.rs
@@ -1,48 +1,37 @@
 #![deny(warnings)]
 #![allow(unknown_lints, proc_macro_derive_resolution_fallback)] // TODO: This can be removed after diesel-1.4
 
-extern crate cargo_registry;
-extern crate chrono;
-extern crate conduit;
-extern crate conduit_middleware;
-extern crate conduit_test;
 #[macro_use]
 extern crate diesel;
-extern crate dotenv;
-extern crate flate2;
-extern crate git2;
 #[macro_use]
 extern crate lazy_static;
-extern crate s3;
-extern crate semver;
-extern crate serde;
 #[macro_use]
 extern crate serde_derive;
 #[macro_use]
 extern crate serde_json;
-extern crate tar;
-extern crate url;
 
-use std::borrow::Cow;
-use std::env;
-use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
-use std::sync::Arc;
+use crate::util::{Bad, RequestHelper, TestApp};
+use cargo_registry::{
+    middleware::current_user::AuthenticationSource,
+    models::{Crate, CrateOwner, Dependency, NewCategory, NewTeam, NewUser, Team, User, Version},
+    schema::crate_owners,
+    util::CargoResult,
+    views::{EncodableCrate, EncodableKeyword, EncodableOwner, EncodableVersion, GoodCrate},
+    App, Config, Env, Replica, Uploader,
+};
+use std::{
+    borrow::Cow,
+    env,
+    sync::{
+        atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT},
+        Arc,
+    },
+};
 
-use cargo_registry::app::App;
-use cargo_registry::middleware::current_user::AuthenticationSource;
-use cargo_registry::Replica;
 use conduit::Request;
 use conduit_test::MockRequest;
 use diesel::prelude::*;
 
-use cargo_registry::{models, schema, views};
-use util::{Bad, RequestHelper, TestApp};
-
-use models::{Crate, CrateOwner, Dependency, Team, User, Version};
-use models::{NewCategory, NewTeam, NewUser};
-use schema::*;
-use views::{EncodableCrate, EncodableKeyword, EncodableOwner, EncodableVersion, GoodCrate};
-
 macro_rules! t {
     ($e:expr) => {
         match $e {
@@ -55,7 +44,7 @@ macro_rules! t {
 macro_rules! ok_resp {
     ($e:expr) => {{
         let resp = t!($e);
-        if !::ok_resp(&resp) {
+        if !crate::ok_resp(&resp) {
             panic!("bad response: {:?}", resp.status);
         }
         resp
@@ -65,7 +54,7 @@ macro_rules! ok_resp {
 macro_rules! bad_resp {
     ($e:expr) => {{
         let mut resp = t!($e);
-        match ::bad_resp(&mut resp) {
+        match crate::bad_resp(&mut resp) {
             None => panic!("ok response: {:?}", resp.status),
             Some(b) => b,
         }
@@ -126,7 +115,7 @@ fn app() -> (
     dotenv::dotenv().ok();
 
     let (proxy, bomb) = record::proxy();
-    let uploader = cargo_registry::Uploader::S3 {
+    let uploader = Uploader::S3 {
         bucket: s3::Bucket::new(
             String::from("alexcrichton-test"),
             None,
@@ -144,18 +133,16 @@ fn app() -> (
     (bomb, app, handler)
 }
 
-fn simple_app(
-    uploader: cargo_registry::Uploader,
-) -> (Arc<App>, conduit_middleware::MiddlewareBuilder) {
+fn simple_app(uploader: Uploader) -> (Arc<App>, conduit_middleware::MiddlewareBuilder) {
     git::init();
-    let config = cargo_registry::Config {
+    let config = Config {
         uploader,
         session_key: "test this has to be over 32 bytes long".to_string(),
         git_repo_checkout: git::checkout(),
         gh_client_id: env::var("GH_CLIENT_ID").unwrap_or_default(),
         gh_client_secret: env::var("GH_CLIENT_SECRET").unwrap_or_default(),
         db_url: env("TEST_DATABASE_URL"),
-        env: cargo_registry::Env::Test,
+        env: Env::Test,
         max_upload_size: 3000,
         max_unpack_size: 2000,
         mirror: Replica::Primary,
@@ -253,9 +240,7 @@ fn add_team_to_crate(t: &Team, krate: &Crate, u: &User, conn: &PgConnection) ->
     Ok(())
 }
 
-use cargo_registry::util::CargoResult;
-
-fn sign_in_as(req: &mut Request, user: &User) {
+fn sign_in_as(req: &mut dyn Request, user: &User) {
     req.mut_extensions().insert(user.clone());
     req.mut_extensions()
         .insert(AuthenticationSource::SessionCookie);
@@ -286,6 +271,6 @@ fn new_category<'a>(category: &'a str, slug: &'a str, description: &'a str) -> N
     }
 }
 
-fn logout(req: &mut Request) {
+fn logout(req: &mut dyn Request) {
     req.mut_extensions().pop::<User>();
 }
diff --git a/src/tests/badge.rs b/src/tests/badge.rs
index e3e5aecf2e4..21f90b73ce8 100644
--- a/src/tests/badge.rs
+++ b/src/tests/badge.rs
@@ -1,9 +1,7 @@
+use crate::{builders::CrateBuilder, TestApp};
+use cargo_registry::models::{Badge, Crate, MaintenanceStatus};
 use std::collections::HashMap;
 
-use builders::CrateBuilder;
-use models::{Badge, Crate, MaintenanceStatus};
-use TestApp;
-
 struct BadgeRef {
     appveyor: Badge,
     appveyor_attributes: HashMap<String, String>,
diff --git a/src/tests/builders.rs b/src/tests/builders.rs
index 532e26f872f..cbe6d53bb96 100644
--- a/src/tests/builders.rs
+++ b/src/tests/builders.rs
@@ -1,21 +1,16 @@
 //! Structs using the builder pattern that make it easier to create records in tests.
 
-use std::collections::HashMap;
-use std::io::Read;
+use cargo_registry::{
+    models::{Crate, CrateDownload, Keyword, NewCrate, NewVersion, Version},
+    schema::{crate_downloads, dependencies, versions},
+    util::CargoResult,
+    views::krate_publish as u,
+};
+use std::{collections::HashMap, io::Read};
 
-use chrono;
 use chrono::Utc;
 use diesel::prelude::*;
-use flate2::write::GzEncoder;
-use flate2::Compression;
-use semver;
-use tar;
-
-use cargo_registry::util::CargoResult;
-
-use models::{Crate, CrateDownload, Keyword, NewCrate, NewVersion, Version};
-use schema::*;
-use views::krate_publish as u;
+use flate2::{write::GzEncoder, Compression};
 
 /// A builder to create version records for the purpose of inserting directly into the database.
 pub struct VersionBuilder<'a> {
@@ -363,7 +358,7 @@ impl PublishBuilder {
             .zip(&mut slices)
             .map(|(&(name, _), data)| {
                 let len = data.len() as u64;
-                (name, data as &mut Read, len)
+                (name, data as &mut dyn Read, len)
             })
             .collect::<Vec<_>>();
 
@@ -371,7 +366,7 @@ impl PublishBuilder {
     }
 
     /// Set the tarball from a Read trait object
-    pub fn files_with_io(mut self, files: &mut [(&str, &mut Read, u64)]) -> Self {
+    pub fn files_with_io(mut self, files: &mut [(&str, &mut dyn Read, u64)]) -> Self {
         let mut tarball = Vec::new();
         {
             let mut ar = tar::Builder::new(GzEncoder::new(&mut tarball, Compression::default()));
diff --git a/src/tests/categories.rs b/src/tests/categories.rs
index 11d92047226..bcb854e0caa 100644
--- a/src/tests/categories.rs
+++ b/src/tests/categories.rs
@@ -1,10 +1,9 @@
+use cargo_registry::schema::categories;
 use std::env;
 
 use diesel::*;
 use dotenv::dotenv;
 
-use schema::categories;
-
 const ALGORITHMS: &str = r#"
 [algorithms]
 name = "Algorithms"
diff --git a/src/tests/category.rs b/src/tests/category.rs
index 670ddd28aa4..249d8018bec 100644
--- a/src/tests/category.rs
+++ b/src/tests/category.rs
@@ -1,9 +1,10 @@
-use conduit::{Handler, Method};
+use crate::{app, builders::CrateBuilder, new_category, new_user, req, RequestHelper, TestApp};
+use cargo_registry::{
+    models::Category,
+    views::{EncodableCategory, EncodableCategoryWithSubcategories},
+};
 
-use builders::CrateBuilder;
-use models::Category;
-use views::{EncodableCategory, EncodableCategoryWithSubcategories};
-use {app, new_category, new_user, req, RequestHelper, TestApp};
+use conduit::{Handler, Method};
 
 #[derive(Deserialize)]
 struct CategoryList {
@@ -81,7 +82,9 @@ fn update_crate() {
         ($req:expr, $cat:expr) => {{
             $req.with_path(&format!("/api/v1/categories/{}", $cat));
             let mut response = ok_resp!(middle.call($req));
-            ::json::<GoodCategory>(&mut response).category.crates_cnt as usize
+            crate::json::<GoodCategory>(&mut response)
+                .category
+                .crates_cnt as usize
         }};
     }
 
@@ -143,7 +146,7 @@ fn update_crate() {
     // (unlike the behavior of keywords)
     req.with_path("/api/v1/categories");
     let mut response = ok_resp!(middle.call(&mut req));
-    let json: CategoryList = ::json(&mut response);
+    let json: CategoryList = crate::json(&mut response);
     assert_eq!(json.categories.len(), 2);
     assert_eq!(json.meta.total, 2);
 
diff --git a/src/tests/git.rs b/src/tests/git.rs
index a1fbd40f1c7..fc82624178f 100644
--- a/src/tests/git.rs
+++ b/src/tests/git.rs
@@ -4,7 +4,6 @@ use std::path::PathBuf;
 use std::sync::{Once, ONCE_INIT};
 use std::thread;
 
-use git2;
 use url::Url;
 
 fn root() -> PathBuf {
diff --git a/src/tests/keyword.rs b/src/tests/keyword.rs
index 95c1eb1b56f..b1d411bdf9f 100644
--- a/src/tests/keyword.rs
+++ b/src/tests/keyword.rs
@@ -1,7 +1,5 @@
-use builders::CrateBuilder;
-use models::Keyword;
-use views::EncodableKeyword;
-use {RequestHelper, TestApp};
+use crate::{builders::CrateBuilder, RequestHelper, TestApp};
+use cargo_registry::{models::Keyword, views::EncodableKeyword};
 
 #[derive(Deserialize)]
 struct KeywordList {
diff --git a/src/tests/krate.rs b/src/tests/krate.rs
index 31d61c50328..f3fb03b76ea 100644
--- a/src/tests/krate.rs
+++ b/src/tests/krate.rs
@@ -1,36 +1,27 @@
-extern crate diesel;
-extern crate tempdir;
-
-use std::collections::HashMap;
-use std::fs::{self, File};
-use std::io;
-use std::io::prelude::*;
-
-use self::diesel::prelude::*;
-use self::tempdir::TempDir;
-use chrono::Utc;
-use diesel::dsl::*;
-use diesel::update;
-use flate2::write::GzEncoder;
-use flate2::Compression;
-use git2;
-use serde_json;
-use tar;
-
-use cargo_registry::git;
-use cargo_registry::models::krate::MAX_NAME_LENGTH;
-
-use builders::{CrateBuilder, DependencyBuilder, PublishBuilder, VersionBuilder};
-use models::{Category, Crate};
-use schema::{api_tokens, crates, emails, metadata, versions};
-use views::{
-    EncodableCategory, EncodableCrate, EncodableDependency, EncodableKeyword, EncodableVersion,
-    EncodableVersionDownload,
-};
-use {
+use crate::{
+    builders::{CrateBuilder, DependencyBuilder, PublishBuilder, VersionBuilder},
     new_category, new_dependency, new_user, CrateMeta, CrateResponse, GoodCrate, OkBool,
     RequestHelper, TestApp,
 };
+use cargo_registry::{
+    git,
+    models::{krate::MAX_NAME_LENGTH, Category, Crate},
+    schema::{api_tokens, crates, emails, metadata, versions},
+    views::{
+        EncodableCategory, EncodableCrate, EncodableDependency, EncodableKeyword, EncodableVersion,
+        EncodableVersionDownload,
+    },
+};
+use std::{
+    collections::HashMap,
+    fs::{self, File},
+    io::{self, prelude::*},
+};
+
+use chrono::Utc;
+use diesel::{dsl::*, prelude::*, update};
+use flate2::{write::GzEncoder, Compression};
+use tempdir::TempDir;
 
 #[derive(Deserialize)]
 struct VersionsList {
@@ -63,22 +54,22 @@ struct SummaryResponse {
     popular_categories: Vec<EncodableCategory>,
 }
 
-impl ::util::MockAnonymousUser {
+impl crate::util::MockAnonymousUser {
     fn reverse_dependencies(&self, krate_name: &str) -> RevDeps {
         let url = format!("/api/v1/crates/{}/reverse_dependencies", krate_name);
         self.get(&url).good()
     }
 }
 
-impl ::util::MockTokenUser {
+impl crate::util::MockTokenUser {
     /// Yank the specified version of the specified crate.
-    fn yank(&self, krate_name: &str, version: &str) -> ::util::Response<OkBool> {
+    fn yank(&self, krate_name: &str, version: &str) -> crate::util::Response<OkBool> {
         let url = format!("/api/v1/crates/{}/{}/yank", krate_name, version);
         self.delete(&url)
     }
 
     /// Unyank the specified version of the specified crate.
-    fn unyank(&self, krate_name: &str, version: &str) -> ::util::Response<OkBool> {
+    fn unyank(&self, krate_name: &str, version: &str) -> crate::util::Response<OkBool> {
         let url = format!("/api/v1/crates/{}/{}/unyank", krate_name, version);
         self.put(&url, &[])
     }
@@ -977,8 +968,8 @@ fn new_krate_git_upload_appends() {
 #[test]
 fn new_krate_git_upload_with_conflicts() {
     {
-        ::git::init();
-        let repo = git2::Repository::open(&::git::bare()).unwrap();
+        crate::git::init();
+        let repo = git2::Repository::open(&crate::git::bare()).unwrap();
         let target = repo.head().unwrap().target().unwrap();
         let sig = repo.signature().unwrap();
         let parent = repo.find_commit(target).unwrap();
@@ -2006,7 +1997,7 @@ fn clone_remote_repo() -> TempDir {
     use url::Url;
 
     let tempdir = TempDir::new("tests").unwrap();
-    let url = Url::from_file_path(::git::bare()).unwrap();
+    let url = Url::from_file_path(crate::git::bare()).unwrap();
     git2::Repository::clone(url.as_str(), tempdir.path()).unwrap();
     tempdir
 }
diff --git a/src/tests/owners.rs b/src/tests/owners.rs
index 7f461e982fe..1a43a22ce98 100644
--- a/src/tests/owners.rs
+++ b/src/tests/owners.rs
@@ -1,16 +1,21 @@
+use crate::{
+    add_team_to_crate, app,
+    builders::{CrateBuilder, PublishBuilder},
+    new_team, new_user, req, sign_in_as,
+    util::RequestHelper,
+    TestApp,
+};
+use cargo_registry::{
+    models::{Crate, NewCrateOwnerInvitation},
+    schema::crate_owner_invitations,
+    views::{
+        EncodableCrateOwnerInvitation, EncodableOwner, EncodablePublicUser, InvitationResponse,
+    },
+};
+
 use conduit::{Handler, Method};
-use diesel;
 use diesel::prelude::*;
 
-use builders::{CrateBuilder, PublishBuilder};
-use models::{Crate, NewCrateOwnerInvitation};
-use schema::crate_owner_invitations;
-use util::RequestHelper;
-use views::{
-    EncodableCrateOwnerInvitation, EncodableOwner, EncodablePublicUser, InvitationResponse,
-};
-use {add_team_to_crate, app, new_team, new_user, req, sign_in_as, TestApp};
-
 #[derive(Deserialize)]
 struct TeamResponse {
     teams: Vec<EncodableOwner>,
@@ -25,11 +30,11 @@ struct InvitationListResponse {
 }
 
 // Implementing locally for now, unless these are needed elsewhere
-impl ::util::MockCookieUser {
+impl crate::util::MockCookieUser {
     /// As the currently logged in user, accept an invitation to become an owner of the named
     /// crate.
     fn accept_ownership_invitation(&self, krate_name: &str, krate_id: i32) {
-        use views::InvitationResponse;
+        use cargo_registry::views::InvitationResponse;
 
         let body = json!({
             "crate_owner_invite": {
@@ -270,7 +275,7 @@ fn test_accept_invitation() {
             .with_body(body.to_string().as_bytes()),
     ));
 
-    let json: T = ::json(&mut response);
+    let json: T = crate::json(&mut response);
     assert_eq!(json.crate_owner_invitation.accepted, true);
     assert_eq!(json.crate_owner_invitation.crate_id, krate.id);
 
@@ -281,7 +286,7 @@ fn test_accept_invitation() {
         req.with_path("api/v1/me/crate_owner_invitations")
             .with_method(Method::Get)
     ));
-    let json: InvitationListResponse = ::json(&mut response);
+    let json: InvitationListResponse = crate::json(&mut response);
     assert_eq!(json.crate_owner_invitations.len(), 0);
 
     // new crate owner was inserted
@@ -289,7 +294,7 @@ fn test_accept_invitation() {
         req.with_path("/api/v1/crates/invited_crate/owners")
             .with_method(Method::Get)
     ));
-    let json: Q = ::json(&mut response);
+    let json: Q = crate::json(&mut response);
     assert_eq!(json.users.len(), 2);
 }
 
@@ -350,7 +355,7 @@ fn test_decline_invitation() {
             .with_body(body.to_string().as_bytes()),
     ));
 
-    let json: T = ::json(&mut response);
+    let json: T = crate::json(&mut response);
     assert_eq!(json.crate_owner_invitation.accepted, false);
     assert_eq!(json.crate_owner_invitation.crate_id, krate.id);
 
@@ -361,7 +366,7 @@ fn test_decline_invitation() {
         req.with_path("api/v1/me/crate_owner_invitations")
             .with_method(Method::Get)
     ));
-    let json: InvitationListResponse = ::json(&mut response);
+    let json: InvitationListResponse = crate::json(&mut response);
     assert_eq!(json.crate_owner_invitations.len(), 0);
 
     // new crate owner was not inserted
@@ -369,6 +374,6 @@ fn test_decline_invitation() {
         req.with_path("/api/v1/crates/invited_crate/owners")
             .with_method(Method::Get)
     ));
-    let json: Q = ::json(&mut response);
+    let json: Q = crate::json(&mut response);
     assert_eq!(json.users.len(), 1);
 }
diff --git a/src/tests/record.rs b/src/tests/record.rs
index 3a5fc1e6a74..aedb813831e 100644
--- a/src/tests/record.rs
+++ b/src/tests/record.rs
@@ -1,31 +1,20 @@
-extern crate base64;
-extern crate futures;
-extern crate hyper;
-extern crate hyper_tls;
-extern crate reqwest;
-extern crate tokio_core;
-extern crate tokio_service;
-
-use std::borrow::Cow;
-use std::collections::HashSet;
-use std::env;
-use std::fs::{self, File};
-use std::io;
-use std::io::prelude::*;
-use std::net;
-use std::path::PathBuf;
-use std::str;
-use std::sync::{Arc, Mutex, Once};
-use std::thread;
-
-use self::futures::sync::oneshot;
-use self::futures::{future, Future, Stream};
-use self::tokio_core::net::TcpListener;
-use self::tokio_core::reactor::Core;
-use serde_json;
-
-use models::NewUser;
-use new_user;
+use crate::new_user;
+use cargo_registry::models::NewUser;
+use std::{
+    borrow::Cow,
+    collections::HashSet,
+    env,
+    fs::{self, File},
+    io::{self, prelude::*},
+    net,
+    path::PathBuf,
+    str,
+    sync::{Arc, Mutex, Once},
+    thread,
+};
+
+use futures::{future, sync::oneshot, Future, Stream};
+use tokio_core::{net::TcpListener, reactor::Core};
 
 // A "bomb" so when the test task exists we know when to shut down
 // the server and fail if the subtask failed.
@@ -161,7 +150,8 @@ impl hyper::service::Service for Proxy {
     type ReqBody = hyper::Body;
     type ResBody = hyper::Body;
     type Error = hyper::Error;
-    type Future = Box<Future<Item = hyper::Response<Self::ResBody>, Error = Self::Error> + Send>;
+    type Future =
+        Box<dyn Future<Item = hyper::Response<Self::ResBody>, Error = Self::Error> + Send>;
 
     fn call(&mut self, req: hyper::Request<Self::ReqBody>) -> Self::Future {
         let record2 = self.record.clone();
@@ -186,7 +176,7 @@ impl hyper::service::NewService for Proxy {
     type ResBody = hyper::Body;
     type Error = hyper::Error;
     type Service = Proxy;
-    type Future = Box<Future<Item = Self::Service, Error = Self::InitError> + Send>;
+    type Future = Box<dyn Future<Item = Self::Service, Error = Self::InitError> + Send>;
     type InitError = hyper::Error;
 
     fn new_service(&self) -> Self::Future {
@@ -220,7 +210,7 @@ type Client = hyper::Client<hyper_tls::HttpsConnector<hyper::client::HttpConnect
 fn record_http(
     req: hyper::Request<hyper::Body>,
     client: &Client,
-) -> Box<Future<Item = (hyper::Response<hyper::Body>, Exchange), Error = hyper::Error> + Send> {
+) -> Box<dyn Future<Item = (hyper::Response<hyper::Body>, Exchange), Error = hyper::Error> + Send> {
     let (header_parts, body) = req.into_parts();
     let method = header_parts.method;
     let uri = header_parts.uri;
@@ -277,8 +267,8 @@ fn record_http(
 fn replay_http(
     req: hyper::Request<hyper::Body>,
     mut exchange: Exchange,
-    stdout: &mut Write,
-) -> Box<Future<Item = hyper::Response<hyper::Body>, Error = hyper::Error> + Send> {
+    stdout: &mut dyn Write,
+) -> Box<dyn Future<Item = hyper::Response<hyper::Body>, Error = hyper::Error> + Send> {
     static IGNORED_HEADERS: &[&str] = &["authorization", "date", "user-agent"];
 
     assert_eq!(req.uri().to_string(), exchange.request.uri);
@@ -350,7 +340,7 @@ impl GhUser {
             return;
         }
 
-        let password = ::env(&format!("GH_PASS_{}", self.login.replace("-", "_")));
+        let password = crate::env(&format!("GH_PASS_{}", self.login.replace("-", "_")));
         #[derive(Serialize)]
         struct Authorization {
             scopes: Vec<String>,
@@ -364,8 +354,8 @@ impl GhUser {
             .json(&Authorization {
                 scopes: vec!["read:org".to_string()],
                 note: "crates.io test".to_string(),
-                client_id: ::env("GH_CLIENT_ID"),
-                client_secret: ::env("GH_CLIENT_SECRET"),
+                client_id: crate::env("GH_CLIENT_ID"),
+                client_secret: crate::env("GH_CLIENT_SECRET"),
             })
             .basic_auth(self.login, Some(password));
 
diff --git a/src/tests/schema_details.rs b/src/tests/schema_details.rs
index 6d82073e8fa..a3d180638df 100644
--- a/src/tests/schema_details.rs
+++ b/src/tests/schema_details.rs
@@ -1,7 +1,7 @@
 use diesel::prelude::*;
 use diesel::sql_types::Text;
 
-use TestApp;
+use crate::TestApp;
 
 #[test]
 fn all_columns_called_crate_id_have_a_cascading_foreign_key() {
diff --git a/src/tests/team.rs b/src/tests/team.rs
index 63ad301635a..3248bbbe398 100644
--- a/src/tests/team.rs
+++ b/src/tests/team.rs
@@ -1,15 +1,18 @@
-use diesel::*;
+use crate::{
+    add_team_to_crate,
+    builders::{CrateBuilder, PublishBuilder},
+    new_team,
+    record::GhUser,
+    OwnerTeamsResponse, RequestHelper, TestApp,
+};
+use cargo_registry::models::{Crate, NewUser};
 use std::sync::ONCE_INIT;
 
-use super::OwnerTeamsResponse;
-use builders::{CrateBuilder, PublishBuilder};
-use models::{Crate, NewUser};
-use record::GhUser;
-use {add_team_to_crate, new_team, RequestHelper, TestApp};
+use diesel::*;
 
-impl ::util::MockAnonymousUser {
+impl crate::util::MockAnonymousUser {
     /// List the team owners of the specified crate.
-    fn crate_owner_teams(&self, krate_name: &str) -> ::util::Response<OwnerTeamsResponse> {
+    fn crate_owner_teams(&self, krate_name: &str) -> crate::util::Response<OwnerTeamsResponse> {
         let url = format!("/api/v1/crates/{}/owner_team", krate_name);
         self.get(&url)
     }
diff --git a/src/tests/token.rs b/src/tests/token.rs
index 11e7a693d5c..e878f96de84 100644
--- a/src/tests/token.rs
+++ b/src/tests/token.rs
@@ -1,12 +1,13 @@
+use crate::{user::UserShowPrivateResponse, RequestHelper, TestApp};
+use cargo_registry::{
+    models::ApiToken,
+    schema::api_tokens,
+    views::{EncodableApiTokenWithToken, EncodableMe},
+};
 use std::collections::HashSet;
 
 use diesel::prelude::*;
 
-use models::ApiToken;
-use schema::api_tokens;
-use views::{EncodableApiTokenWithToken, EncodableMe};
-use {user::UserShowPrivateResponse, RequestHelper, TestApp};
-
 #[derive(Deserialize)]
 struct DecodableApiToken {
     name: String,
diff --git a/src/tests/user.rs b/src/tests/user.rs
index 68d24563090..d6d0fbb1871 100644
--- a/src/tests/user.rs
+++ b/src/tests/user.rs
@@ -1,12 +1,18 @@
+use crate::{
+    app,
+    builders::{CrateBuilder, VersionBuilder},
+    logout, new_user, req, sign_in_as,
+    util::RequestHelper,
+    OkBool, TestApp,
+};
+use cargo_registry::{
+    models::{Email, NewUser, User},
+    views::{EncodablePrivateUser, EncodablePublicUser, EncodableVersion},
+};
+
 use conduit::{Handler, Method};
 use diesel::prelude::*;
 
-use builders::{CrateBuilder, VersionBuilder};
-use models::{Email, NewUser, User};
-use util::RequestHelper;
-use views::{EncodablePrivateUser, EncodablePublicUser, EncodableVersion};
-use {app, logout, new_user, req, sign_in_as, OkBool, TestApp};
-
 #[derive(Deserialize)]
 struct AuthResponse {
     url: String,
@@ -275,7 +281,7 @@ fn test_github_login_does_not_overwrite_email() {
     };
 
     let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),));
-    let r = ::json::<UserShowPrivateResponse>(&mut response);
+    let r = crate::json::<UserShowPrivateResponse>(&mut response);
     assert_eq!(r.user.email, None);
     assert_eq!(r.user.login, "apricot");
 
@@ -286,7 +292,7 @@ fn test_github_login_does_not_overwrite_email() {
             .with_method(Method::Put)
             .with_body(body.as_bytes()),
     ));
-    assert!(::json::<OkBool>(&mut response).ok);
+    assert!(crate::json::<OkBool>(&mut response).ok);
 
     logout(&mut req);
 
@@ -302,7 +308,7 @@ fn test_github_login_does_not_overwrite_email() {
     }
 
     let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),));
-    let r = ::json::<UserShowPrivateResponse>(&mut response);
+    let r = crate::json::<UserShowPrivateResponse>(&mut response);
     assert_eq!(r.user.email.unwrap(), "apricot@apricots.apricot");
     assert_eq!(r.user.login, "apricot");
 }
@@ -323,7 +329,7 @@ fn test_email_get_and_put() {
     };
 
     let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),));
-    let r = ::json::<UserShowPrivateResponse>(&mut response);
+    let r = crate::json::<UserShowPrivateResponse>(&mut response);
     assert_eq!(r.user.email, None);
     assert_eq!(r.user.login, "mango");
 
@@ -334,10 +340,10 @@ fn test_email_get_and_put() {
             .with_method(Method::Put)
             .with_body(body.as_bytes()),
     ));
-    assert!(::json::<OkBool>(&mut response).ok);
+    assert!(crate::json::<OkBool>(&mut response).ok);
 
     let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),));
-    let r = ::json::<UserShowPrivateResponse>(&mut response);
+    let r = crate::json::<UserShowPrivateResponse>(&mut response);
     assert_eq!(r.user.email.unwrap(), "mango@mangos.mango");
     assert_eq!(r.user.login, "mango");
     assert!(!r.user.email_verified);
@@ -456,7 +462,7 @@ fn test_insert_into_email_table() {
     }
 
     let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),));
-    let r = ::json::<UserShowPrivateResponse>(&mut response);
+    let r = crate::json::<UserShowPrivateResponse>(&mut response);
     assert_eq!(r.user.email.unwrap(), "apple@example.com");
     assert_eq!(r.user.login, "apple");
 
@@ -476,7 +482,7 @@ fn test_insert_into_email_table() {
     }
 
     let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),));
-    let r = ::json::<UserShowPrivateResponse>(&mut response);
+    let r = crate::json::<UserShowPrivateResponse>(&mut response);
     assert_eq!(r.user.email.unwrap(), "apple@example.com");
     assert_eq!(r.user.login, "apple");
 }
@@ -504,7 +510,7 @@ fn test_insert_into_email_table_with_email_change() {
     };
 
     let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),));
-    let r = ::json::<UserShowPrivateResponse>(&mut response);
+    let r = crate::json::<UserShowPrivateResponse>(&mut response);
     assert_eq!(r.user.email.unwrap(), "test_insert_with_change@example.com");
     assert_eq!(r.user.login, "potato");
     assert!(!r.user.email_verified);
@@ -517,7 +523,7 @@ fn test_insert_into_email_table_with_email_change() {
             .with_method(Method::Put)
             .with_body(body.as_bytes()),
     ));
-    assert!(::json::<OkBool>(&mut response).ok);
+    assert!(crate::json::<OkBool>(&mut response).ok);
 
     logout(&mut req);
 
@@ -535,7 +541,7 @@ fn test_insert_into_email_table_with_email_change() {
     }
 
     let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),));
-    let r = ::json::<UserShowPrivateResponse>(&mut response);
+    let r = crate::json::<UserShowPrivateResponse>(&mut response);
     assert_eq!(r.user.email.unwrap(), "apricot@apricots.apricot");
     assert!(!r.user.email_verified);
     assert!(r.user.email_verification_sent);
@@ -578,10 +584,10 @@ fn test_confirm_user_email() {
         req.with_path(&format!("/api/v1/confirm/{}", email_token))
             .with_method(Method::Put),
     ));
-    assert!(::json::<OkBool>(&mut response).ok);
+    assert!(crate::json::<OkBool>(&mut response).ok);
 
     let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),));
-    let r = ::json::<UserShowPrivateResponse>(&mut response);
+    let r = crate::json::<UserShowPrivateResponse>(&mut response);
     assert_eq!(r.user.email.unwrap(), "potato2@example.com");
     assert_eq!(r.user.login, "potato");
     assert!(r.user.email_verified);
@@ -617,7 +623,7 @@ fn test_existing_user_email() {
     }
 
     let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),));
-    let r = ::json::<UserShowPrivateResponse>(&mut response);
+    let r = crate::json::<UserShowPrivateResponse>(&mut response);
     assert_eq!(r.user.email.unwrap(), "potahto@example.com");
     assert!(!r.user.email_verified);
     assert!(!r.user.email_verification_sent);
diff --git a/src/tests/util.rs b/src/tests/util.rs
index c5e7f6ebccf..7af49eec111 100644
--- a/src/tests/util.rs
+++ b/src/tests/util.rs
@@ -19,20 +19,21 @@
 //! `MockCookieUser` and `MockTokenUser` provide an `as_model` function which returns a reference
 //! to the underlying database model value (`User` and `ApiToken` respectively).
 
-use std::{self, rc::Rc, sync::Arc};
-
-use {cargo_registry, conduit, conduit_middleware, diesel, dotenv, serde};
+use crate::{
+    app, builders::PublishBuilder, record, CrateList, CrateResponse, GoodCrate, OkBool,
+    VersionResponse,
+};
+use cargo_registry::{
+    middleware::current_user::AuthenticationSource,
+    models::{ApiToken, User},
+    uploaders::Uploader,
+    App,
+};
+use std::{rc::Rc, sync::Arc};
 
 use conduit::{Handler, Method, Request};
 use conduit_test::MockRequest;
 
-use builders::PublishBuilder;
-use cargo_registry::app::App;
-use cargo_registry::middleware::current_user::AuthenticationSource;
-use models::{ApiToken, User};
-
-use super::{app, record, CrateList, CrateResponse, GoodCrate, OkBool, VersionResponse};
-
 struct TestAppInner {
     app: Arc<App>,
     // The bomb (if created) needs to be held in scope until the end of the test.
@@ -47,7 +48,7 @@ impl TestApp {
     /// Initialize an application with an `Uploader` that panics
     pub fn init() -> TestAppBuilder {
         dotenv::dotenv().ok();
-        let (app, middle) = ::simple_app(cargo_registry::Uploader::Panic);
+        let (app, middle) = crate::simple_app(Uploader::Panic);
         let inner = Rc::new(TestAppInner {
             app,
             _bomb: None,
@@ -81,7 +82,7 @@ impl TestApp {
     ///
     /// This method updates the database directly
     pub fn db_new_user(&self, user: &str) -> MockCookieUser {
-        let user = self.db(|conn| ::new_user(user).create_or_update(conn).unwrap());
+        let user = self.db(|conn| crate::new_user(user).create_or_update(conn).unwrap());
         MockCookieUser {
             app: TestApp(Rc::clone(&self.0)),
             user,
@@ -214,7 +215,7 @@ pub struct MockAnonymousUser {
 
 impl RequestHelper for MockAnonymousUser {
     fn request_builder(&self, method: Method, path: &str) -> MockRequest {
-        ::req(method, path)
+        crate::req(method, path)
     }
 
     fn app(&self) -> &TestApp {
@@ -233,7 +234,7 @@ pub struct MockCookieUser {
 
 impl RequestHelper for MockCookieUser {
     fn request_builder(&self, method: Method, path: &str) -> MockRequest {
-        let mut request = ::req(method, path);
+        let mut request = crate::req(method, path);
         request.mut_extensions().insert(self.user.clone());
         request
             .mut_extensions()
@@ -274,7 +275,7 @@ pub struct MockTokenUser {
 
 impl RequestHelper for MockTokenUser {
     fn request_builder(&self, method: Method, path: &str) -> MockRequest {
-        let mut request = ::req(method, path);
+        let mut request = crate::req(method, path);
         request.header("Authorization", &self.token.token);
         request
     }
@@ -322,13 +323,13 @@ pub struct Bad {
 
 pub type DieselConnection =
     diesel::r2d2::PooledConnection<diesel::r2d2::ConnectionManager<diesel::PgConnection>>;
-type ResponseResult = Result<conduit::Response, Box<std::error::Error + Send>>;
+type ResponseResult = Result<conduit::Response, Box<dyn std::error::Error + Send>>;
 
 /// A type providing helper methods for working with responses
 #[must_use]
 pub struct Response<T> {
     response: conduit::Response,
-    callback_on_good: Option<Box<Fn(&T)>>,
+    callback_on_good: Option<Box<dyn Fn(&T)>>,
 }
 
 impl<T> Response<T>
@@ -342,7 +343,7 @@ where
         }
     }
 
-    fn with_callback(self, callback_on_good: Box<Fn(&T)>) -> Self {
+    fn with_callback(self, callback_on_good: Box<dyn Fn(&T)>) -> Self {
         Self {
             response: self.response,
             callback_on_good: Some(callback_on_good),
@@ -351,10 +352,10 @@ where
 
     /// Assert that the response is good and deserialize the message
     pub fn good(mut self) -> T {
-        if !::ok_resp(&self.response) {
+        if !crate::ok_resp(&self.response) {
             panic!("bad response: {:?}", self.response.status);
         }
-        let good = ::json(&mut self.response);
+        let good = crate::json(&mut self.response);
         if let Some(callback) = self.callback_on_good {
             callback(&good)
         }
@@ -366,7 +367,7 @@ where
     /// Cargo endpoints return a status 200 on error instead of 400.
     pub fn bad_with_status(&mut self, code: u32) -> Bad {
         assert_eq!(self.response.status.0, code);
-        match ::bad_resp(&mut self.response) {
+        match crate::bad_resp(&mut self.response) {
             None => panic!("ok response: {:?}", self.response.status),
             Some(b) => b,
         }
diff --git a/src/tests/version.rs b/src/tests/version.rs
index 7eeadc1d043..26f8bb9aa45 100644
--- a/src/tests/version.rs
+++ b/src/tests/version.rs
@@ -1,11 +1,11 @@
-use serde_json::Value;
+use crate::{
+    builders::{CrateBuilder, PublishBuilder, VersionBuilder},
+    RequestHelper, TestApp, VersionResponse,
+};
+use cargo_registry::{schema::versions, views::EncodableVersion};
 
 use diesel::prelude::*;
-
-use builders::{CrateBuilder, PublishBuilder, VersionBuilder};
-use schema::versions;
-use views::EncodableVersion;
-use {RequestHelper, TestApp, VersionResponse};
+use serde_json::Value;
 
 #[derive(Deserialize)]
 struct VersionList {
diff --git a/src/uploaders.rs b/src/uploaders.rs
index 59d34070fda..0da8a7026de 100644
--- a/src/uploaders.rs
+++ b/src/uploaders.rs
@@ -1,22 +1,18 @@
 use conduit::Request;
 use flate2::read::GzDecoder;
 use openssl::hash::{Hasher, MessageDigest};
-use reqwest;
-use s3;
-use semver;
-use tar;
 
-use util::LimitErrorReader;
-use util::{human, internal, CargoResult, ChainError, Maximums};
+use crate::util::LimitErrorReader;
+use crate::util::{human, internal, CargoResult, ChainError, Maximums};
 
 use std::env;
 use std::fs::{self, File};
 use std::io::{Read, Write};
 use std::sync::Arc;
 
-use app::App;
-use middleware::app::RequestApp;
-use models::Crate;
+use crate::app::App;
+use crate::middleware::app::RequestApp;
+use crate::models::Crate;
 
 fn require_test_app_with_proxy() -> ! {
     panic!("No uploader is configured.  In tests, use `TestApp::with_proxy()`.");
diff --git a/src/util/errors.rs b/src/util/errors.rs
index 30377993c71..c03f70988ae 100644
--- a/src/util/errors.rs
+++ b/src/util/errors.rs
@@ -5,7 +5,7 @@ use std::fmt;
 use conduit::Response;
 use diesel::result::Error as DieselError;
 
-use util::json_response;
+use crate::util::json_response;
 
 #[derive(Serialize)]
 struct StringError {
diff --git a/src/util/mod.rs b/src/util/mod.rs
index b0d18524278..a622deab011 100644
--- a/src/util/mod.rs
+++ b/src/util/mod.rs
@@ -2,10 +2,8 @@ use std::cmp;
 use std::collections::HashMap;
 use std::io::Cursor;
 
-use serde::Serialize;
-use serde_json;
-
 use conduit::Response;
+use serde::Serialize;
 
 pub use self::errors::{bad_request, human, internal, internal_error, CargoError, CargoResult};
 pub use self::errors::{std_error, ChainError};
diff --git a/src/util/request_proxy.rs b/src/util/request_proxy.rs
index 840c4d742a3..3fa0f7717d8 100644
--- a/src/util/request_proxy.rs
+++ b/src/util/request_proxy.rs
@@ -1,11 +1,7 @@
-extern crate old_semver;
+use std::{io::Read, net::SocketAddr};
 
-use std::io::Read;
-use std::net::SocketAddr;
-
-use self::old_semver::semver;
-use conduit;
 use conduit::Request;
+use old_semver::semver;
 
 // Can't derive Debug because of Request.
 #[allow(missing_debug_implementations)]
diff --git a/src/views/krate_publish.rs b/src/views/krate_publish.rs
index 5643b9aaa75..da9d0c1a0c6 100644
--- a/src/views/krate_publish.rs
+++ b/src/views/krate_publish.rs
@@ -4,14 +4,13 @@
 //! integration tests.
 use std::collections::HashMap;
 
-use semver;
 use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
 
-use models::krate::MAX_NAME_LENGTH;
+use crate::models::krate::MAX_NAME_LENGTH;
 
-use models::Crate;
-use models::DependencyKind;
-use models::Keyword as CrateKeyword;
+use crate::models::Crate;
+use crate::models::DependencyKind;
+use crate::models::Keyword as CrateKeyword;
 
 #[derive(Deserialize, Serialize, Debug)]
 pub struct EncodableCrateUpload {
diff --git a/src/views/mod.rs b/src/views/mod.rs
index 5a514e25012..bcb9ee4d8a1 100644
--- a/src/views/mod.rs
+++ b/src/views/mod.rs
@@ -1,9 +1,8 @@
 use chrono::NaiveDateTime;
-use serde_json;
 use std::collections::HashMap;
 
-use models::DependencyKind;
-use util::rfc3339;
+use crate::models::DependencyKind;
+use crate::util::rfc3339;
 
 #[derive(PartialEq, Debug, Serialize, Deserialize)]
 pub struct EncodableBadge {