Run cargo +stable fix --edition, then cargo +stable fmt

The only remaining changes were to add the `crate` keyword to the front
of absolute paths.

Author: jtgeibel

src/app.rs

@@ -11,8 +11,8 @@ use oauth2;
 use reqwest;
 use scheduled_thread_pool::ScheduledThreadPool;
 
-use util::CargoResult;
-use {db, Config, Env};
+use crate::util::CargoResult;
+use crate::{db, Config, Env};
 
 /// The `App` struct holds the main components of the application like
 /// the database connection pool and configurations

src/bin/update-downloads.rs

@@ -30,9 +30,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 {
@@ -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);

src/boot/categories.rs

@@ -5,8 +5,8 @@ use diesel;
 use diesel::prelude::*;
 use toml;
 
-use db;
-use util::errors::{internal, CargoResult, ChainError};
+use crate::db;
+use crate::util::errors::{internal, CargoResult, ChainError};
 
 #[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");

src/config.rs

@@ -3,7 +3,7 @@ use s3;
 use std::env;
 use std::path::PathBuf;
 
-use {env, Env, Replica, Uploader};
+use crate::{env, Env, Replica, Uploader};
 
 #[derive(Clone, Debug)]
 pub struct Config {

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> {

src/controllers/crate_owner_invitation.rs

@@ -2,9 +2,9 @@ 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> {

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;
 

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)?;

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> {

src/controllers/krate/follow.rs

@@ -3,9 +3,9 @@
 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()?;

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())))

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> {

src/controllers/krate/publish.rs

@@ -6,15 +6,15 @@ 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 controllers::prelude::*;
-use models::dependency;
-use models::{Badge, Category, Keyword, NewCrate, NewVersion, Rights, User};
-use views::{EncodableCrateUpload, GoodCrate, PublishWarnings};
+use crate::git;
+use crate::render;
+use crate::util::{internal, ChainError, Maximums};
+use crate::util::{read_fill, read_le_u32};
+
+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

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") {

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> {

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> {

src/controllers/token.rs

@@ -1,13 +1,13 @@
 use super::prelude::*;
 
+use crate::middleware::current_user::AuthenticationSource;
+use crate::util::{bad_request, read_fill, ChainError};
 use diesel;
-use middleware::current_user::AuthenticationSource;
 use serde_json as json;
-use util::{bad_request, read_fill, ChainError};
 
-use models::ApiToken;
-use schema::api_tokens;
-use views::EncodableApiTokenWithToken;
+use crate::models::ApiToken;
+use crate::schema::api_tokens;
+use crate::views::EncodableApiTokenWithToken;
 
 /// Handles the `GET /me/tokens` route.
 pub fn list(req: &mut dyn Request) -> CargoResult<Response> {

src/controllers/user/me.rs

@@ -1,14 +1,14 @@
-use controllers::prelude::*;
+use crate::controllers::prelude::*;
 
 use serde_json;
 
-use controllers::helpers::Paginate;
-use email;
-use util::bad_request;
+use crate::controllers::helpers::Paginate;
+use crate::email;
+use crate::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 +148,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"))
     })?;