cargo +nightly fmt to prepare for the next stable release

This diff was created from the latest nightly and passes checks on beta
(which will soon be stable).  As I understand it, Rust 1.29 will
include the rustfmt release candidate and we can expect stable
formatting from this point forward!

Author: jtgeibel

src/bin/populate.rs

@@ -39,8 +39,7 @@ fn update(conn: &PgConnection) -> QueryResult<()> {
                     version_downloads::version_id.eq(id),
                     version_downloads::downloads.eq(dls),
                     version_downloads::date.eq(date(now - day.days())),
-                ))
-                .execute(conn)?;
+                )).execute(conn)?;
         }
     }
     Ok(())

src/bin/render-readmes.rs

@@ -84,8 +84,7 @@ fn main() {
             readme_renderings::rendered_at
                 .lt(older_than)
                 .or(readme_renderings::version_id.is_null()),
-        )
-        .select(versions::id)
+        ).select(versions::id)
         .into_boxed();
 
     if let Some(crate_name) = args.flag_crate {
@@ -156,8 +155,7 @@ fn main() {
                         readme.as_bytes(),
                         "text/html",
                         readme_len as u64,
-                    )
-                    .unwrap_or_else(|_| {
+                    ).unwrap_or_else(|_| {
                         panic!(
                             "[{}-{}] Couldn't upload file to S3",
                             krate_name, version.num
@@ -289,16 +287,14 @@ fn find_file_by_path<R: Read>(
                 };
                 filepath == path
             }
-        })
-        .unwrap_or_else(|| {
+        }).unwrap_or_else(|| {
             panic!(
                 "[{}-{}] couldn't open file: {}",
                 krate_name,
                 version.num,
                 path.display()
             )
-        })
-        .unwrap_or_else(|_| {
+        }).unwrap_or_else(|_| {
             panic!(
                 "[{}-{}] file is not present: {}",
                 krate_name,

src/bin/update-downloads.rs

@@ -92,8 +92,7 @@ fn collect(conn: &PgConnection, rows: &[VersionDownload]) -> QueryResult<()> {
                     crate_downloads::crate_id.eq(crate_id),
                     crate_downloads::downloads.eq(amt),
                     crate_downloads::date.eq(download.date),
-                ))
-                .on_conflict(crate_downloads::table.primary_key())
+                )).on_conflict(crate_downloads::table.primary_key())
                 .do_update()
                 .set(crate_downloads::downloads.eq(crate_downloads::downloads + amt))
                 .execute(conn)?;
@@ -138,7 +137,7 @@ mod test {
             name: "foo",
             ..Default::default()
         }.create_or_update(&conn, None, user_id)
-            .unwrap();
+        .unwrap();
         let version = NewVersion::new(
             krate.id,
             &semver::Version::parse("1.0.0").unwrap(),
@@ -177,8 +176,7 @@ mod test {
                 version_downloads::version_id.eq(version.id),
                 version_downloads::date.eq(date(now - 1.day())),
                 version_downloads::processed.eq(true),
-            ))
-            .execute(&conn)
+            )).execute(&conn)
             .unwrap();
 
         ::update(&conn).unwrap();
@@ -215,8 +213,7 @@ mod test {
                 version_downloads::counted.eq(2),
                 version_downloads::date.eq(date(now - 2.days())),
                 version_downloads::processed.eq(false),
-            ))
-            .execute(&conn)
+            )).execute(&conn)
             .unwrap();
         ::update(&conn).unwrap();
         let processed = version_downloads::table
@@ -239,8 +236,7 @@ mod test {
                 version_downloads::counted.eq(2),
                 version_downloads::date.eq(date(now)),
                 version_downloads::processed.eq(false),
-            ))
-            .execute(&conn)
+            )).execute(&conn)
             .unwrap();
         ::update(&conn).unwrap();
         let processed = version_downloads::table
@@ -273,15 +269,13 @@ mod test {
                 version_downloads::counted.eq(1),
                 version_downloads::date.eq(date(now)),
                 version_downloads::processed.eq(false),
-            ))
-            .execute(&conn)
+            )).execute(&conn)
             .unwrap();
         insert_into(version_downloads::table)
             .values((
                 version_downloads::version_id.eq(version.id),
                 version_downloads::date.eq(date(now - 1.day())),
-            ))
-            .execute(&conn)
+            )).execute(&conn)
             .unwrap();
 
         let version_before = versions::table
@@ -337,8 +331,7 @@ mod test {
                 version_downloads::counted.eq(2),
                 version_downloads::date.eq(date(now - 2.days())),
                 version_downloads::processed.eq(false),
-            ))
-            .execute(&conn)
+            )).execute(&conn)
             .unwrap();
 
         ::update(&conn).unwrap();

src/boot/categories.rs

@@ -107,8 +107,7 @@ pub fn sync_with_connection(toml_str: &str, conn: &PgConnection) -> CargoResult<
                 category.eq(c.name),
                 description.eq(c.description),
             )
-        })
-        .collect::<Vec<_>>();
+        }).collect::<Vec<_>>();
 
     conn.transaction(|| {
         let slugs = diesel::insert_into(categories)
@@ -118,8 +117,7 @@ pub fn sync_with_connection(toml_str: &str, conn: &PgConnection) -> CargoResult<
             .set((
                 category.eq(excluded(category)),
                 description.eq(excluded(description)),
-            ))
-            .returning(slug)
+            )).returning(slug)
             .get_results::<String>(&*conn)?;
 
         diesel::delete(categories)

src/controllers/crate_owner_invitation.rs

@@ -71,8 +71,7 @@ fn accept_invite(
                 owner_id: user_id,
                 created_by: pending_crate_owner.invited_by_user_id,
                 owner_kind: OwnerKind::User as i32,
-            })
-            .on_conflict(crate_owners::table.primary_key())
+            }).on_conflict(crate_owners::table.primary_key())
             .do_update()
             .set(crate_owners::deleted.eq(false))
             .execute(conn)?;

src/controllers/krate/downloads.rs

@@ -39,8 +39,7 @@ pub fn downloads(req: &mut dyn Request) -> CargoResult<Response> {
         .select((
             to_char(version_downloads::date, "YYYY-MM-DD"),
             sum_downloads,
-        ))
-        .filter(version_downloads::date.gt(date(now - 90.days())))
+        )).filter(version_downloads::date.gt(date(now - 90.days())))
         .group_by(version_downloads::date)
         .order(version_downloads::date.asc())
         .load::<ExtraDownload>(&*conn)?;

src/controllers/krate/follow.rs

@@ -11,7 +11,9 @@ fn follow_target(req: &mut dyn Request) -> CargoResult<Follow> {
     let user = req.user()?;
     let conn = req.db_conn()?;
     let crate_name = &req.params()["crate_id"];
-    let crate_id = Crate::by_name(crate_name).select(crates::id).first(&*conn)?;
+    let crate_id = Crate::by_name(crate_name)
+        .select(crates::id)
+        .first(&*conn)?;
     Ok(Follow {
         user_id: user.id,
         crate_id,

src/controllers/krate/metadata.rs

@@ -34,8 +34,7 @@ pub fn summary(req: &mut dyn Request) -> CargoResult<Response> {
             .zip(krates)
             .map(|(max_version, krate)| {
                 Ok(krate.minimal_encodable(&max_version, None, false, None))
-            })
-            .collect()
+            }).collect()
     };
 
     let new_crates = crates

src/controllers/krate/owners.rs

@@ -95,7 +95,8 @@ fn modify_owners(req: &mut dyn Request, add: bool) -> CargoResult<Response> {
         owners: Option<Vec<String>>,
     }
 
-    let request: Request = serde_json::from_str(&body).map_err(|_| human("invalid json request"))?;
+    let request: Request =
+        serde_json::from_str(&body).map_err(|_| human("invalid json request"))?;
 
     let logins = request
         .owners

src/controllers/krate/publish.rs

@@ -53,8 +53,7 @@ pub fn publish(req: &mut dyn Request) -> CargoResult<Response> {
                 k[..].to_string(),
                 v.iter().map(|v| v[..].to_string()).collect(),
             )
-        })
-        .collect::<HashMap<String, Vec<String>>>();
+        }).collect::<HashMap<String, Vec<String>>>();
     let keywords = new_crate
         .keywords
         .as_ref()

src/controllers/krate/search.rs

@@ -48,8 +48,7 @@ pub fn search(req: &mut dyn Request) -> CargoResult<Response> {
             ALL_COLUMNS,
             false.into_sql::<Bool>(),
             recent_crate_downloads::downloads.nullable(),
-        ))
-        .into_boxed();
+        )).into_boxed();
 
     if let Some(q_string) = params.get("q") {
         if !q_string.is_empty() {
@@ -190,8 +189,7 @@ pub fn search(req: &mut dyn Request) -> CargoResult<Response> {
                     Some(recent_downloads),
                 )
             },
-        )
-        .collect();
+        ).collect();
 
     #[derive(Serialize)]
     struct R {

src/controllers/token.rs

@@ -53,7 +53,8 @@ pub fn new(req: &mut dyn Request) -> CargoResult<Response> {
     let mut json = vec![0; length as usize];
     read_fill(req.body(), &mut json)?;
 
-    let json = String::from_utf8(json).map_err(|_| bad_request(&"json body was not valid utf-8"))?;
+    let json =
+        String::from_utf8(json).map_err(|_| bad_request(&"json body was not valid utf-8"))?;
 
     let new: NewApiTokenRequest = json::from_str(&json)
         .map_err(|e| bad_request(&format!("invalid new token request: {:?}", e)))?;

src/controllers/user/me.rs

@@ -34,8 +34,7 @@ pub fn me(req: &mut dyn Request) -> CargoResult<Response> {
             emails::verified.nullable(),
             emails::email.nullable(),
             emails::token_generated_at.nullable().is_not_null(),
-        ))
-        .first::<(User, Option<bool>, Option<String>, bool)>(&*conn)?;
+        )).first::<(User, Option<bool>, Option<String>, bool)>(&*conn)?;
 
     let verified = verified.unwrap_or(false);
     let verification_sent = verified || verification_sent;

src/controllers/user/other.rs

@@ -37,8 +37,7 @@ pub fn stats(req: &mut dyn Request) -> CargoResult<Response> {
             crate_owners::owner_id
                 .eq(user_id)
                 .and(crate_owners::owner_kind.eq(OwnerKind::User as i32)),
-        )
-        .select(sum(crates::downloads))
+        ).select(sum(crates::downloads))
         .first::<Option<i64>>(&*conn)?
         .unwrap_or(0);
 

src/email.rs

@@ -82,8 +82,7 @@ fn send_email(recipient: &str, subject: &str, body: &str) -> CargoResult<()> {
                 .credentials(Credentials::new(
                     mailgun_config.smtp_login,
                     mailgun_config.smtp_password,
-                ))
-                .smtp_utf8(true)
+                )).smtp_utf8(true)
                 .authentication_mechanism(Mechanism::Plain)
                 .build();
 

src/git.rs

@@ -97,8 +97,7 @@ pub fn yank(app: &App, krate: &str, version: &semver::Version, yanked: bool) ->
                 }
                 git_crate.yanked = Some(yanked);
                 Ok(serde_json::to_string(&git_crate).unwrap())
-            })
-            .collect::<CargoResult<Vec<String>>>();
+            }).collect::<CargoResult<Vec<String>>>();
         let new = new?.join("\n");
         let mut f = File::create(&dst)?;
         f.write_all(new.as_bytes())?;

src/github.rs

@@ -41,8 +41,7 @@ pub fn github(app: &App, url: &str, auth: &Token) -> Result<(Easy, Vec<u8>), cur
             .write_function(|buf| {
                 data.extend_from_slice(buf);
                 Ok(buf.len())
-            })
-            .unwrap();
+            }).unwrap();
         transfer.perform()?;
     }
     Ok((handle, data))

src/models/badge.rs

@@ -22,7 +22,11 @@ pub struct CrateBadge {
 }
 
 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case", tag = "badge_type", content = "attributes")]
+#[serde(
+    rename_all = "kebab-case",
+    tag = "badge_type",
+    content = "attributes"
+)]
 pub enum Badge {
     TravisCi {
         repository: String,

src/models/category.rs

@@ -118,8 +118,7 @@ impl Category {
                 .map(|c| CrateCategory {
                     category_id: c.id,
                     crate_id: krate.id,
-                })
-                .collect::<Vec<_>>();
+                }).collect::<Vec<_>>();
 
             delete(CrateCategory::belonging_to(krate)).execute(conn)?;
             insert_into(crates_categories::table)
@@ -232,8 +231,7 @@ mod tests {
                 (category.eq("Cat 2"), slug.eq("cat2")),
                 (category.eq("Cat 1"), slug.eq("cat1")),
                 (category.eq("Cat 1::sub"), slug.eq("cat1::sub")),
-            ])
-            .execute(&conn)
+            ]).execute(&conn)
             .unwrap();
 
         let cats = Category::toplevel(&conn, "", 10, 0)
@@ -254,8 +252,7 @@ mod tests {
                 (category.eq("Cat 1"), slug.eq("cat1"), crates_cnt.eq(0)),
                 (category.eq("Cat 2"), slug.eq("cat2"), crates_cnt.eq(2)),
                 (category.eq("Cat 3"), slug.eq("cat3"), crates_cnt.eq(1)),
-            ])
-            .execute(&conn)
+            ]).execute(&conn)
             .unwrap();
 
         let cats = Category::toplevel(&conn, "crates", 10, 0)
@@ -279,8 +276,7 @@ mod tests {
             .values(&vec![
                 (category.eq("Cat 1"), slug.eq("cat1")),
                 (category.eq("Cat 2"), slug.eq("cat2")),
-            ])
-            .execute(&conn)
+            ]).execute(&conn)
             .unwrap();
 
         let cats = Category::toplevel(&conn, "", 1, 0)
@@ -324,8 +320,7 @@ mod tests {
                     crates_cnt.eq(5),
                 ),
                 (category.eq("Cat 3"), slug.eq("cat3"), crates_cnt.eq(6)),
-            ])
-            .execute(&conn)
+            ]).execute(&conn)
             .unwrap();
 
         let cats = Category::toplevel(&conn, "crates", 10, 0)
@@ -365,8 +360,7 @@ mod tests {
                     crates_cnt.eq(5),
                 ),
                 (category.eq("Cat 3"), slug.eq("cat3"), crates_cnt.eq(6)),
-            ])
-            .execute(&conn)
+            ]).execute(&conn)
             .unwrap();
 
         let cats = Category::toplevel(&conn, "crates", 2, 0)
@@ -420,8 +414,7 @@ mod tests {
                     crates_cnt.eq(5),
                 ),
                 (category.eq("Cat 3"), slug.eq("cat3"), crates_cnt.eq(200)),
-            ])
-            .execute(&conn)
+            ]).execute(&conn)
             .unwrap();
 
         let cat = Category::by_slug("cat1::sub1")

src/models/dependency.rs

@@ -117,8 +117,7 @@ pub fn add_dependencies(
                     target.eq(dep.target.as_ref().map(|s| &**s)),
                 ),
             ))
-        })
-        .collect::<Result<Vec<_>, _>>()?;
+        }).collect::<Result<Vec<_>, _>>()?;
 
     let (git_deps, new_dependencies): (Vec<_>, Vec<_>) =
         git_and_new_dependencies.into_iter().unzip();

src/models/keyword.rs

@@ -85,8 +85,7 @@ impl Keyword {
                 .map(|kw| CrateKeyword {
                     crate_id: krate.id,
                     keyword_id: kw.id,
-                })
-                .collect::<Vec<_>>();
+                }).collect::<Vec<_>>();
             diesel::insert_into(crates_keywords::table)
                 .values(&crate_keywords)
                 .execute(conn)?;