From 45e9dd4cdbc0c44589c59ca9ba280b4524c8cae9 Mon Sep 17 00:00:00 2001 From: Natalie Boehm Date: Mon, 25 Sep 2017 14:53:27 -0400 Subject: [PATCH 01/19] change insert into crate_owner table replicates what was previously done in the owner_add function of krate.rs, adding an upsert. looks like owners are never really removed, deleted field is just toggled. --- src/crate_owner_invitation.rs | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/src/crate_owner_invitation.rs b/src/crate_owner_invitation.rs index 1f609f6b91b..6631ed0f068 100644 --- a/src/crate_owner_invitation.rs +++ b/src/crate_owner_invitation.rs @@ -122,7 +122,9 @@ fn accept_invite( crate_invite: InvitationResponse, ) -> CargoResult { let user_id = req.user()?.id; - use diesel::{delete, insert}; + use diesel::{insert, delete}; + use diesel::pg::upsert::do_update; + use diesel::pg::upsert::OnConflictExtension; let pending_crate_owner = crate_owner_invitations::table .filter(crate_owner_invitations::crate_id.eq(crate_invite.crate_id)) .filter(crate_owner_invitations::invited_user_id.eq(user_id)) @@ -136,7 +138,11 @@ fn accept_invite( }; conn.transaction(|| { - insert(&owner).into(crate_owners::table).execute(conn)?; + insert(&owner.on_conflict( + crate_owners::table.primary_key(), + do_update().set(crate_owners::deleted.eq(false)), + )).into(crate_owners::table) + .execute(conn)?; delete( crate_owner_invitations::table .filter(crate_owner_invitations::crate_id.eq(crate_invite.crate_id)) From 071666d3f603edcacc9a799839b50a9b80be3cff Mon Sep 17 00:00:00 2001 From: Natalie Boehm Date: Tue, 26 Sep 2017 17:00:49 -0400 Subject: [PATCH 02/19] i don't know if this works but i should commit --- src/krate/mod.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/krate/mod.rs b/src/krate/mod.rs index f14e64f98b2..522800f14d7 100644 --- a/src/krate/mod.rs +++ b/src/krate/mod.rs @@ -460,7 +460,7 @@ impl Crate { conn: &PgConnection, req_user: &User, login: &str, - ) -> CargoResult<()> { + ) -> CargoResult { let owner = match Owner::find_by_login(conn, login) { Ok(owner @ Owner::User(_)) => owner, Ok(Owner::Team(team)) => if team.contains_user(app, req_user)? { @@ -491,7 +491,7 @@ impl Crate { )).into(crate_owners::table) .execute(conn)?; - Ok(()) + Ok(format!("User {} has been invited to be an owner of crate {}.", crate_owner.owner_id, crate_owner.crate_id)) } pub fn owner_remove( From 35d1f32a4f992bc45ff383efdce1ae00bcb70c4d Mon Sep 17 00:00:00 2001 From: Natalie Boehm Date: Wed, 27 Sep 2017 15:10:49 -0400 Subject: [PATCH 03/19] change owner_add to return a String message instead of boolean okay when successful, change query upsert an owner invitation instead of inserting a crate_owner --- src/krate/mod.rs | 34 ++++++++++++++++++---------------- 1 file changed, 18 insertions(+), 16 deletions(-) diff --git a/src/krate/mod.rs b/src/krate/mod.rs index 522800f14d7..99bbd2c6897 100644 --- a/src/krate/mod.rs +++ b/src/krate/mod.rs @@ -25,8 +25,9 @@ use db::RequestTransaction; use dependency::{self, EncodableDependency, ReverseDependency}; use download::{EncodableVersionDownload, VersionDownload}; use git; -use keyword::{CrateKeyword, EncodableKeyword}; -use owner::{rights, CrateOwner, EncodableOwner, Owner, OwnerKind, Rights, Team}; +use keyword::{EncodableKeyword, CrateKeyword}; +use owner::{EncodableOwner, Owner, Rights, OwnerKind, Team, rights, CrateOwner}; +use crate_owner_invitation::{NewCrateOwnerInvitation}; use pagination::Paginate; use render; use schema::*; @@ -479,19 +480,15 @@ impl Crate { }, }; - let crate_owner = CrateOwner { + let owner_invitation = NewCrateOwnerInvitation { + invited_user_id: owner.id(), + invited_by_user_id: req_user.id, crate_id: self.id, - owner_id: owner.id(), - created_by: req_user.id, - owner_kind: owner.kind() as i32, }; - diesel::insert(&crate_owner.on_conflict( - crate_owners::table.primary_key(), - do_update().set(crate_owners::deleted.eq(false)), - )).into(crate_owners::table) - .execute(conn)?; - Ok(format!("User {} has been invited to be an owner of crate {}.", crate_owner.owner_id, crate_owner.crate_id)) + diesel::insert(&owner_invitation.on_conflict_do_nothing()).into(crate_owner_invitations::table).execute(conn)?; + + Ok(format!("User {} has been invited to be an owner of crate {}", owner_invitation.invited_user_id, owner_invitation.crate_id)) } pub fn owner_remove( @@ -1388,12 +1385,15 @@ fn modify_owners(req: &mut Request, add: bool) -> CargoResult { .or(request.users) .ok_or_else(|| human("invalid json request"))?; + let mut msgs = Vec::new(); + for login in &logins { if add { if owners.iter().any(|owner| owner.login() == *login) { return Err(human(&format_args!("`{}` is already an owner", login))); } - krate.owner_add(req.app(), &conn, user, login)?; + let msg = krate.owner_add(req.app(), &conn, user, login)?; + msgs.push(msg); } else { // Removing the team that gives you rights is prevented because // team members only have Rights::Publish @@ -1402,13 +1402,15 @@ fn modify_owners(req: &mut Request, add: bool) -> CargoResult { } krate.owner_remove(&conn, user, login)?; } - } + }; + + let comma_sep_msg = msgs.join(","); #[derive(Serialize)] struct R { - ok: bool, + ok: String, } - Ok(req.json(&R { ok: true })) + Ok(req.json(&R { ok: comma_sep_msg })) } /// Handles the `GET /crates/:crate_id/reverse_dependencies` route. From 64c894e8b37fae120ba8ba74929e9ca90d5e2468 Mon Sep 17 00:00:00 2001 From: Natalie Boehm Date: Wed, 27 Sep 2017 15:26:21 -0400 Subject: [PATCH 04/19] cargo fmt --- src/crate_owner_invitation.rs | 4 ++-- src/krate/mod.rs | 14 ++++++++++---- 2 files changed, 12 insertions(+), 6 deletions(-) diff --git a/src/crate_owner_invitation.rs b/src/crate_owner_invitation.rs index 6631ed0f068..d4a4db84f3a 100644 --- a/src/crate_owner_invitation.rs +++ b/src/crate_owner_invitation.rs @@ -139,8 +139,8 @@ fn accept_invite( conn.transaction(|| { insert(&owner.on_conflict( - crate_owners::table.primary_key(), - do_update().set(crate_owners::deleted.eq(false)), + crate_owners::table.primary_key(), + do_update().set(crate_owners::deleted.eq(false)), )).into(crate_owners::table) .execute(conn)?; delete( diff --git a/src/krate/mod.rs b/src/krate/mod.rs index 99bbd2c6897..a1a76f99440 100644 --- a/src/krate/mod.rs +++ b/src/krate/mod.rs @@ -27,7 +27,7 @@ use download::{EncodableVersionDownload, VersionDownload}; use git; use keyword::{EncodableKeyword, CrateKeyword}; use owner::{EncodableOwner, Owner, Rights, OwnerKind, Team, rights, CrateOwner}; -use crate_owner_invitation::{NewCrateOwnerInvitation}; +use crate_owner_invitation::NewCrateOwnerInvitation; use pagination::Paginate; use render; use schema::*; @@ -486,9 +486,15 @@ impl Crate { crate_id: self.id, }; - diesel::insert(&owner_invitation.on_conflict_do_nothing()).into(crate_owner_invitations::table).execute(conn)?; + diesel::insert(&owner_invitation.on_conflict_do_nothing()) + .into(crate_owner_invitations::table) + .execute(conn)?; - Ok(format!("User {} has been invited to be an owner of crate {}", owner_invitation.invited_user_id, owner_invitation.crate_id)) + Ok(format!( + "User {} has been invited to be an owner of crate {}", + owner_invitation.invited_user_id, + owner_invitation.crate_id + )) } pub fn owner_remove( @@ -1402,7 +1408,7 @@ fn modify_owners(req: &mut Request, add: bool) -> CargoResult { } krate.owner_remove(&conn, user, login)?; } - }; + } let comma_sep_msg = msgs.join(","); From c24906f22da0e3f9c666eac9f998760a8bf57c33 Mon Sep 17 00:00:00 2001 From: Natalie Boehm Date: Wed, 27 Sep 2017 15:39:50 -0400 Subject: [PATCH 05/19] change message displayed from using id's to useful values --- src/krate/mod.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/krate/mod.rs b/src/krate/mod.rs index a1a76f99440..d8efd1ffc4e 100644 --- a/src/krate/mod.rs +++ b/src/krate/mod.rs @@ -492,8 +492,8 @@ impl Crate { Ok(format!( "User {} has been invited to be an owner of crate {}", - owner_invitation.invited_user_id, - owner_invitation.crate_id + owner.login(), + self.name )) } From 476dc03daab7a707dfe2f2f41472721654cca4e4 Mon Sep 17 00:00:00 2001 From: Natalie Boehm Date: Wed, 27 Sep 2017 15:43:45 -0400 Subject: [PATCH 06/19] consistant with capitalization --- src/krate/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/krate/mod.rs b/src/krate/mod.rs index d8efd1ffc4e..571178fd0e4 100644 --- a/src/krate/mod.rs +++ b/src/krate/mod.rs @@ -491,7 +491,7 @@ impl Crate { .execute(conn)?; Ok(format!( - "User {} has been invited to be an owner of crate {}", + "user {} has been invited to be an owner of crate {}", owner.login(), self.name )) From 0f5b7da5f18685c714a0b20bae2eb75922d64e22 Mon Sep 17 00:00:00 2001 From: Natalie Boehm Date: Thu, 28 Sep 2017 15:26:35 -0400 Subject: [PATCH 07/19] add boolean back to struct to support old versions of cargo modify publish message to describe error of publishing to a crate that you don't own with reference to invites --- src/krate/mod.rs | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/src/krate/mod.rs b/src/krate/mod.rs index 571178fd0e4..87ee1fbafda 100644 --- a/src/krate/mod.rs +++ b/src/krate/mod.rs @@ -943,8 +943,10 @@ pub fn new(req: &mut Request) -> CargoResult { let owners = krate.owners(&conn)?; if rights(req.app(), &owners, &user)? < Rights::Publish { return Err(human( - "crate name has already been claimed by \ - another user", + "this crate exists but you don't seem to be an owner. \ + If you believe this is a mistake, perhaps you need \ + to accept an invitation to be an owner before \ + publishing.", )); } @@ -1414,9 +1416,10 @@ fn modify_owners(req: &mut Request, add: bool) -> CargoResult { #[derive(Serialize)] struct R { - ok: String, + ok: bool, + msg: String, } - Ok(req.json(&R { ok: comma_sep_msg })) + Ok(req.json(&R { ok: true, msg: comma_sep_msg })) } /// Handles the `GET /crates/:crate_id/reverse_dependencies` route. From c79243fcdba4281f1f6e073152ab6d610047c79c Mon Sep 17 00:00:00 2001 From: Natalie Boehm Date: Fri, 29 Sep 2017 16:06:58 -0400 Subject: [PATCH 08/19] test functionality for addition of message field to struct returned by modify_owners --- src/tests/krate.rs | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/src/tests/krate.rs b/src/tests/krate.rs index 0cdab179180..6da67b53c0e 100644 --- a/src/tests/krate.rs +++ b/src/tests/krate.rs @@ -2003,6 +2003,46 @@ fn block_blacklisted_documentation_url() { assert_eq!(json.krate.documentation, None); } +// This is testing Cargo functionality! ! ! +// specifically functions modify_owners and add_owners +// which call the `PUT /crates/:crate_id/owners` route +#[test] +fn test_cargo_invite_owners() { + let (_b, app, middle) = ::app(); + let mut req = ::req(app.clone(), Method::Get, "/"); + + let new_user = { + let conn = app.diesel_database.get().unwrap(); + let owner = ::new_user("avocado").create_or_update(&conn).unwrap(); + ::sign_in_as(&mut req, &owner); + ::CrateBuilder::new("guacamole", owner.id).expect_build(&conn); + ::new_user("cilantro").create_or_update(&conn).unwrap() + }; + + #[derive(Serialize)] + struct OwnerReq { owners: Option> } + #[derive(Deserialize, Debug)] + struct OwnerResp { ok: bool, msg: String } + + let body = serde_json::to_string(&OwnerReq { owners: Some(vec![new_user.gh_login]) }); + let mut response = ok_resp!( + middle.call( + req.with_path("/api/v1/crates/guacamole/owners") + .with_method(Method::Put) + .with_body(body.unwrap().as_bytes()), + ) + ); + + let r = ::json::(&mut response); + // this ok:true field is what old versions of Cargo + // need - do not remove unless you're cool with + // dropping support for old versions + assert!(r.ok); + // msg field is what is sent and used in updated + // version of cargo + assert_eq!(r.msg, "user cilantro has been invited to be an owner of crate guacamole") +} + // #[test] // fn new_crate_bad_tarball() { // let (_b, app, middle) = ::app(); From 329cab31ec579e87f76a7400f094e3baf11f632e Mon Sep 17 00:00:00 2001 From: Natalie Boehm Date: Tue, 3 Oct 2017 16:13:20 -0400 Subject: [PATCH 09/19] update expected error message to match new error message --- src/tests/krate.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tests/krate.rs b/src/tests/krate.rs index 6da67b53c0e..a3917338d2d 100644 --- a/src/tests/krate.rs +++ b/src/tests/krate.rs @@ -699,7 +699,7 @@ fn new_krate_wrong_user() { let json = bad_resp!(middle.call(&mut req)); assert!( - json.errors[0].detail.contains("another user"), + json.errors[0].detail.contains("this crate exists but you don't seem to be an owner."), "{:?}", json.errors ); From 477933a36cf81bb70cdab4d5427bfc3d017b9ac1 Mon Sep 17 00:00:00 2001 From: Natalie Boehm Date: Wed, 4 Oct 2017 20:08:59 -0400 Subject: [PATCH 10/19] reorder statements at top of function --- src/crate_owner_invitation.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/crate_owner_invitation.rs b/src/crate_owner_invitation.rs index d4a4db84f3a..af59769246d 100644 --- a/src/crate_owner_invitation.rs +++ b/src/crate_owner_invitation.rs @@ -121,10 +121,10 @@ fn accept_invite( conn: &PgConnection, crate_invite: InvitationResponse, ) -> CargoResult { - let user_id = req.user()?.id; use diesel::{insert, delete}; - use diesel::pg::upsert::do_update; - use diesel::pg::upsert::OnConflictExtension; + use diesel::pg::upsert::{OnConflictExtension, do_update}; + + let user_id = req.user()?.id; let pending_crate_owner = crate_owner_invitations::table .filter(crate_owner_invitations::crate_id.eq(crate_invite.crate_id)) .filter(crate_owner_invitations::invited_user_id.eq(user_id)) From f6a93537b953236cb41dffbc4253e2a1e310b8db Mon Sep 17 00:00:00 2001 From: Natalie Boehm Date: Wed, 4 Oct 2017 20:09:29 -0400 Subject: [PATCH 11/19] add debug statements --- src/tests/all.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/tests/all.rs b/src/tests/all.rs index 7522bea4195..5da065f5033 100644 --- a/src/tests/all.rs +++ b/src/tests/all.rs @@ -100,7 +100,7 @@ mod token; mod user; mod version; -#[derive(Deserialize)] +#[derive(Deserialize, Debug)] struct GoodCrate { #[serde(rename = "crate")] krate: EncodableCrate, warnings: Warnings, @@ -110,7 +110,7 @@ struct CrateList { crates: Vec, meta: CrateMeta, } -#[derive(Deserialize)] +#[derive(Deserialize, Debug)] struct Warnings { invalid_categories: Vec, invalid_badges: Vec, From 641baf01d0611798190b9e1833e9c3f6120211c8 Mon Sep 17 00:00:00 2001 From: Natalie Boehm Date: Wed, 4 Oct 2017 20:12:48 -0400 Subject: [PATCH 12/19] change user login name to fix deadlock error between test_insert_into_email_table and test_insert_into_email_table_with_change --- src/tests/user.rs | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/tests/user.rs b/src/tests/user.rs index 0ba36ba3855..c460e331c05 100644 --- a/src/tests/user.rs +++ b/src/tests/user.rs @@ -544,8 +544,8 @@ fn test_insert_into_email_table() { let conn = app.diesel_database.get().unwrap(); let user = NewUser { gh_id: 1, - email: Some("potato@example.com"), - ..::new_user("potato") + email: Some("apple@example.com"), + ..::new_user("apple") }; let user = user.create_or_update(&conn).unwrap(); @@ -554,8 +554,8 @@ 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::(&mut response); - assert_eq!(r.user.email.unwrap(), "potato@example.com"); - assert_eq!(r.user.login, "potato"); + assert_eq!(r.user.email.unwrap(), "apple@example.com"); + assert_eq!(r.user.login, "apple"); ::logout(&mut req); @@ -565,7 +565,7 @@ fn test_insert_into_email_table() { let user = NewUser { gh_id: 1, email: Some("banana@example.com"), - ..::new_user("potato") + ..::new_user("apple") }; let user = user.create_or_update(&conn).unwrap(); @@ -574,8 +574,8 @@ 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::(&mut response); - assert_eq!(r.user.email.unwrap(), "potato@example.com"); - assert_eq!(r.user.login, "potato"); + assert_eq!(r.user.email.unwrap(), "apple@example.com"); + assert_eq!(r.user.login, "apple"); } /* Given a new user, check that when an email is added, From 89d291cf55af475e59ce709cea8402120923ccb9 Mon Sep 17 00:00:00 2001 From: Natalie Boehm Date: Wed, 4 Oct 2017 20:14:36 -0400 Subject: [PATCH 13/19] delete owner test as it's pretty redundant, fix new_crate_owner test such that the owner invitation is accepted and user is added as an owner to the crate --- src/tests/owners.rs | 100 +++++++++++++++++--------------------------- 1 file changed, 39 insertions(+), 61 deletions(-) diff --git a/src/tests/owners.rs b/src/tests/owners.rs index a0f47fcb360..216831b1cec 100644 --- a/src/tests/owners.rs +++ b/src/tests/owners.rs @@ -5,6 +5,7 @@ use cargo_registry::user::EncodablePublicUser; use cargo_registry::crate_owner_invitation::{EncodableCrateOwnerInvitation, InvitationResponse, NewCrateOwnerInvitation}; use cargo_registry::schema::crate_owner_invitations; +use cargo_registry::krate::Crate; use conduit::{Handler, Method}; use diesel; @@ -49,14 +50,49 @@ fn new_crate_owner() { ) ); assert!(::json::(&mut response).ok); - bad_resp!( + + let krate_id = { + let conn = app.diesel_database.get().unwrap(); + Crate::by_name("foo_owner").first::(&*conn).unwrap().id + }; + + let body = json!({ + "crate_owner_invite": { + "invited_by_username": "foo", + "crate_name": "foo_owner", + "crate_id": krate_id, + "created_at": "", + "accepted": true + } + }); + + ::logout(&mut req); + ::sign_in_as(&mut req, &u2); + + // accept invitation for user to be added as owner + let mut response = ok_resp!( middle.call( - req.with_path("/api/v1/crates/foo_owner/owners") + req.with_path(&format!("/api/v1/me/crate_owner_invitations/{}", krate_id)) .with_method(Method::Put) - .with_body(body.as_bytes()), + .with_body(body.to_string().as_bytes()), ) ); + #[derive(Deserialize)] + struct CrateOwnerInvitation { + crate_owner_invitation: InvitationResponse, + } + + #[derive(Deserialize)] + struct InvitationResponse { + crate_id: i32, + accepted: bool, + } + + let crate_owner_invite = ::json::(&mut response); + assert!(crate_owner_invite.crate_owner_invitation.accepted); + assert_eq!(crate_owner_invite.crate_owner_invitation.crate_id, krate_id); + // Make sure this shows up as one of their crates. let query = format!("user_id={}", u2.id); let mut response = ok_resp!( @@ -146,64 +182,6 @@ fn owners_can_remove_self() { ); } -#[test] -fn owners() { - #[derive(Deserialize)] - struct R { - users: Vec, - } - #[derive(Deserialize)] - struct O { - ok: bool, - } - - let (_b, app, middle) = ::app(); - let mut req = ::req(app.clone(), Method::Get, "/api/v1/crates/foo_owners/owners"); - { - let conn = app.diesel_database.get().unwrap(); - ::new_user("foobar").create_or_update(&conn).unwrap(); - let user = ::new_user("foo").create_or_update(&conn).unwrap(); - ::sign_in_as(&mut req, &user); - ::CrateBuilder::new("foo_owners", user.id).expect_build(&conn); - } - - let mut response = ok_resp!(middle.call(&mut req)); - let r: R = ::json(&mut response); - assert_eq!(r.users.len(), 1); - - let mut response = ok_resp!(middle.call(req.with_method(Method::Get))); - let r: R = ::json(&mut response); - assert_eq!(r.users.len(), 1); - - let body = r#"{"users":["foobar"]}"#; - let mut response = - ok_resp!(middle.call(req.with_method(Method::Put,).with_body(body.as_bytes(),),)); - assert!(::json::(&mut response).ok); - - let mut response = ok_resp!(middle.call(req.with_method(Method::Get))); - let r: R = ::json(&mut response); - assert_eq!(r.users.len(), 2); - - let body = r#"{"users":["foobar"]}"#; - let mut response = - ok_resp!(middle.call(req.with_method(Method::Delete,).with_body(body.as_bytes(),),)); - assert!(::json::(&mut response).ok); - - let mut response = ok_resp!(middle.call(req.with_method(Method::Get))); - let r: R = ::json(&mut response); - assert_eq!(r.users.len(), 1); - - let body = r#"{"users":["foo"]}"#; - let mut response = - ok_resp!(middle.call(req.with_method(Method::Delete,).with_body(body.as_bytes(),),)); - ::json::<::Bad>(&mut response); - - let body = r#"{"users":["foobar"]}"#; - let mut response = - ok_resp!(middle.call(req.with_method(Method::Put,).with_body(body.as_bytes(),),)); - assert!(::json::(&mut response).ok); -} - /* Testing the crate ownership between two crates and one team. Given two crates, one crate owned by both a team and a user, one only owned by a user, check that the CrateList returned From db114a2ac17c176e9b33235aac5a4a4400281a14 Mon Sep 17 00:00:00 2001 From: Natalie Boehm Date: Thu, 5 Oct 2017 16:29:49 -0400 Subject: [PATCH 14/19] fix test owners_can_remove_self such that a user is invited and invitation is accepted for the user to be added as an owner --- src/tests/owners.rs | 61 +++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 56 insertions(+), 5 deletions(-) diff --git a/src/tests/owners.rs b/src/tests/owners.rs index 216831b1cec..e51a67a096c 100644 --- a/src/tests/owners.rs +++ b/src/tests/owners.rs @@ -136,13 +136,14 @@ fn owners_can_remove_self() { Method::Get, "/api/v1/crates/owners_selfremove/owners", ); - { + let (first_owner, second_owner) = { let conn = app.diesel_database.get().unwrap(); - ::new_user("secondowner").create_or_update(&conn).unwrap(); let user = ::new_user("firstowner").create_or_update(&conn).unwrap(); + let user_two = ::new_user("secondowner").create_or_update(&conn).unwrap(); ::sign_in_as(&mut req, &user); ::CrateBuilder::new("owners_selfremove", user.id).expect_build(&conn); - } + (user, user_two) + }; let mut response = ok_resp!(middle.call(&mut req)); let r: R = ::json(&mut response); @@ -164,10 +165,60 @@ fn owners_can_remove_self() { ok_resp!(middle.call(req.with_method(Method::Put,).with_body(body.as_bytes(),),)); assert!(::json::(&mut response).ok); + // Need to accept owner invitation to add secondowner as owner + let krate_id = { + let conn = app.diesel_database.get().unwrap(); + Crate::by_name("owners_selfremove").first::(&*conn).unwrap().id + }; + + let body = json!({ + "crate_owner_invite": { + "invited_by_username": "foo", + "crate_name": "foo_owner", + "crate_id": krate_id, + "created_at": "", + "accepted": true + } + }); + + ::logout(&mut req); + ::sign_in_as(&mut req, &second_owner); + + let mut response = ok_resp!( + middle.call( + req.with_path(&format!("/api/v1/me/crate_owner_invitations/{}", krate_id)) + .with_method(Method::Put) + .with_body(body.to_string().as_bytes()) + ) + ); + + #[derive(Deserialize)] + struct CrateOwnerInvitation { + crate_owner_invitation: InvitationResponse, + } + + #[derive(Deserialize)] + struct InvitationResponse { + crate_id: i32, + accepted: bool, + } + + let crate_owner_invite = ::json::(&mut response); + assert!(crate_owner_invite.crate_owner_invitation.accepted); + assert_eq!(crate_owner_invite.crate_owner_invitation.crate_id, krate_id); + + ::logout(&mut req); + ::sign_in_as(&mut req, &first_owner); + // Deleting yourself when there are other owners is allowed. let body = r#"{"users":["firstowner"]}"#; - let mut response = - ok_resp!(middle.call(req.with_method(Method::Delete,).with_body(body.as_bytes(),),)); + let mut response = ok_resp!( + middle.call( + req.with_path("/api/v1/crates/owners_selfremove/owners") + .with_method(Method::Delete) + .with_body(body.as_bytes()) + ) + ); assert!(::json::(&mut response).ok); // After you delete yourself, you no longer have permisions to manage the crate. From 0eaedf29d6a269aa89f809cdda35f84ad596836d Mon Sep 17 00:00:00 2001 From: Natalie Boehm Date: Thu, 5 Oct 2017 16:38:47 -0400 Subject: [PATCH 15/19] update error message to match new error message returned --- src/tests/team.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/tests/team.rs b/src/tests/team.rs index 1ccee40685e..444d52164b9 100644 --- a/src/tests/team.rs +++ b/src/tests/team.rs @@ -200,7 +200,7 @@ fn remove_team_as_named_owner() { ) ); assert!( - json.errors[0].detail.contains("another user"), + json.errors[0].detail.contains("this crate exists but you don't seem to be an owner."), "{:?}", json.errors ); @@ -283,7 +283,7 @@ fn publish_not_owned() { ) ); assert!( - json.errors[0].detail.contains("another user"), + json.errors[0].detail.contains("this crate exists but you don't seem to be an owner."), "{:?}", json.errors ); From 04afe95ac3e70c82fba4eadfe1cff4749fe7e266 Mon Sep 17 00:00:00 2001 From: Natalie Boehm Date: Thu, 5 Oct 2017 16:44:15 -0400 Subject: [PATCH 16/19] ran cargo fmt but all of these changes seem a bit much? --- build.rs | 5 +- src/badge.rs | 3 +- src/bin/populate.rs | 6 +- src/bin/render-readmes.rs | 38 ++--- src/bin/transfer-crates.rs | 4 +- src/bin/update-downloads.rs | 20 ++- src/boot/categories.rs | 4 +- src/category.rs | 8 +- src/crate_owner_invitation.rs | 17 +- src/dependency.rs | 32 ++-- src/download.rs | 5 +- src/email.rs | 4 +- src/git.rs | 22 ++- src/github.rs | 6 +- src/http.rs | 8 +- src/keyword.rs | 16 +- src/krate/mod.rs | 237 ++++++++++++++------------ src/owner.rs | 44 ++--- src/render.rs | 4 +- src/tests/all.rs | 37 ++-- src/tests/badge.rs | 45 ++--- src/tests/category.rs | 4 +- src/tests/git.rs | 9 +- src/tests/krate.rs | 312 ++++++++++++++-------------------- src/tests/owners.rs | 19 ++- src/tests/record.rs | 12 +- src/tests/schema_details.rs | 20 ++- src/tests/team.rs | 32 ++-- src/tests/user.rs | 72 +++++--- src/tests/version.rs | 4 +- src/token.rs | 34 ++-- src/uploaders.rs | 4 +- src/user/middleware.rs | 17 +- src/user/mod.rs | 61 +++---- src/util/errors.rs | 18 +- src/util/io_util.rs | 8 +- src/util/mod.rs | 10 +- src/util/request_proxy.rs | 6 +- src/version/mod.rs | 49 +++--- 39 files changed, 637 insertions(+), 619 deletions(-) diff --git a/build.rs b/build.rs index c5d29ee8801..768f9792038 100644 --- a/build.rs +++ b/build.rs @@ -13,8 +13,9 @@ fn main() { if env::var("PROFILE") == Ok("debug".into()) { let _ = dotenv(); if let Ok(database_url) = env::var("TEST_DATABASE_URL") { - let connection = PgConnection::establish(&database_url) - .expect("Could not connect to TEST_DATABASE_URL"); + let connection = PgConnection::establish(&database_url).expect( + "Could not connect to TEST_DATABASE_URL", + ); run_pending_migrations(&connection).expect("Error running migrations"); } } diff --git a/src/badge.rs b/src/badge.rs index 89b35716ea6..a4918f85f68 100644 --- a/src/badge.rs +++ b/src/badge.rs @@ -111,7 +111,8 @@ impl Badge { } conn.transaction(|| { - delete(badges::table.filter(badges::crate_id.eq(krate.id))).execute(conn)?; + delete(badges::table.filter(badges::crate_id.eq(krate.id))) + .execute(conn)?; insert(&new_badges).into(badges::table).execute(conn)?; Ok(invalid_badges) }) diff --git a/src/bin/populate.rs b/src/bin/populate.rs index 43dee66f6fb..836606620b1 100644 --- a/src/bin/populate.rs +++ b/src/bin/populate.rs @@ -27,9 +27,9 @@ fn main() { } fn update(conn: &PgConnection) -> QueryResult<()> { - let ids = env::args() - .skip(1) - .filter_map(|arg| arg.parse::().ok()); + let ids = env::args().skip(1).filter_map( + |arg| arg.parse::().ok(), + ); for id in ids { let mut rng = StdRng::new().unwrap(); let mut dls = rng.gen_range(5000i32, 10000); diff --git a/src/bin/render-readmes.rs b/src/bin/render-readmes.rs index 6c4d58aa685..7d95739cf2d 100644 --- a/src/bin/render-readmes.rs +++ b/src/bin/render-readmes.rs @@ -65,8 +65,9 @@ fn main() { let start_time = Utc::now(); let older_than = if let Some(ref time) = args.flag_older_than { - Utc.datetime_from_str(&time, "%Y-%m-%d %H:%M:%S") - .expect("Could not parse --older-than argument as a time") + Utc.datetime_from_str(&time, "%Y-%m-%d %H:%M:%S").expect( + "Could not parse --older-than argument as a time", + ) } else { start_time }; @@ -77,11 +78,9 @@ fn main() { let mut query = versions::table .inner_join(crates::table) - .filter( - versions::readme_rendered_at - .lt(older_than) - .or(versions::readme_rendered_at.is_null()), - ) + .filter(versions::readme_rendered_at.lt(older_than).or( + versions::readme_rendered_at.is_null(), + )) .select(versions::id) .into_boxed(); @@ -90,9 +89,9 @@ fn main() { query = query.filter(crates::name.eq(crate_name)); } - let version_ids = query - .load::<(i32)>(&conn) - .expect("error loading version ids"); + let version_ids = query.load::<(i32)>(&conn).expect( + "error loading version ids", + ); let total_versions = version_ids.len(); println!("Rendering {} versions", total_versions); @@ -106,11 +105,12 @@ fn main() { total_pages + 1 }; - for (page_num, version_ids_chunk) in version_ids - .into_iter() - .chunks(page_size) - .into_iter() - .enumerate() + for (page_num, version_ids_chunk) in + version_ids + .into_iter() + .chunks(page_size) + .into_iter() + .enumerate() { println!( "= Page {} of {} ==================================", @@ -172,10 +172,10 @@ fn main() { /// Renders the readme of an uploaded crate version. fn get_readme(config: &Config, version: &Version, krate_name: &str) -> Option { let mut handle = Easy::new(); - let location = match config - .uploader - .crate_location(&krate_name, &version.num.to_string()) - { + let location = match config.uploader.crate_location( + &krate_name, + &version.num.to_string(), + ) { Some(l) => l, None => return None, }; diff --git a/src/bin/transfer-crates.rs b/src/bin/transfer-crates.rs index baa23ab8ec0..3d3b93f6875 100644 --- a/src/bin/transfer-crates.rs +++ b/src/bin/transfer-crates.rs @@ -73,7 +73,9 @@ fn transfer(conn: &PgConnection) { .filter(crate_owners::owner_id.eq(from.id)) .filter(crate_owners::owner_kind.eq(OwnerKind::User as i32)); let crates = Crate::all() - .filter(crates::id.eq_any(crate_owners.select(crate_owners::crate_id))) + .filter(crates::id.eq_any( + crate_owners.select(crate_owners::crate_id), + )) .load::(conn) .unwrap(); diff --git a/src/bin/update-downloads.rs b/src/bin/update-downloads.rs index da204529ee2..49388f193b7 100644 --- a/src/bin/update-downloads.rs +++ b/src/bin/update-downloads.rs @@ -85,7 +85,9 @@ fn collect(conn: &PgConnection, rows: &[VersionDownload]) -> QueryResult<()> { update(version_downloads::table.find(download.id)) .set(( version_downloads::processed.eq(download.date < cutoff), - version_downloads::counted.eq(version_downloads::counted + amt), + version_downloads::counted.eq( + version_downloads::counted + amt, + ), )) .execute(conn)?; @@ -107,8 +109,16 @@ fn collect(conn: &PgConnection, rows: &[VersionDownload]) -> QueryResult<()> { date: download.date, }; insert(&crate_download.on_conflict( - (crate_downloads::crate_id, crate_downloads::date), - do_update().set(crate_downloads::downloads.eq(crate_downloads::downloads + amt)), + ( + crate_downloads::crate_id, + crate_downloads::date, + ), + do_update().set( + crate_downloads::downloads.eq( + crate_downloads::downloads + + amt, + ), + ), )).into(crate_downloads::table) .execute(conn)?; } @@ -116,7 +126,9 @@ fn collect(conn: &PgConnection, rows: &[VersionDownload]) -> QueryResult<()> { // After everything else is done, update the global counter of total // downloads. update(metadata::table) - .set(metadata::total_downloads.eq(metadata::total_downloads + total)) + .set(metadata::total_downloads.eq( + metadata::total_downloads + total, + )) .execute(conn)?; Ok(()) diff --git a/src/boot/categories.rs b/src/boot/categories.rs index 57cfda69043..e1682b03141 100644 --- a/src/boot/categories.rs +++ b/src/boot/categories.rs @@ -122,7 +122,9 @@ pub fn sync_with_connection(toml_str: &str, conn: &PgConnection) -> CargoResult< categories::slug, do_update().set(( categories::category.eq(excluded(categories::category)), - categories::description.eq(excluded(categories::description)), + categories::description.eq( + excluded(categories::description), + ), )), ); diff --git a/src/category.rs b/src/category.rs index 1e50c9f5d2e..8d65724b039 100644 --- a/src/category.rs +++ b/src/category.rs @@ -239,9 +239,7 @@ pub fn show(req: &mut Request) -> CargoResult { struct R { category: EncodableCategoryWithSubcategories, } - Ok(req.json(&R { - category: cat_with_subcats, - })) + Ok(req.json(&R { category: cat_with_subcats })) } /// Handles the `GET /category_slugs` route. @@ -262,9 +260,7 @@ pub fn slugs(req: &mut Request) -> CargoResult { struct R { category_slugs: Vec, } - Ok(req.json(&R { - category_slugs: slugs, - })) + Ok(req.json(&R { category_slugs: slugs })) } #[cfg(test)] diff --git a/src/crate_owner_invitation.rs b/src/crate_owner_invitation.rs index af59769246d..d56f49b6c54 100644 --- a/src/crate_owner_invitation.rs +++ b/src/crate_owner_invitation.rs @@ -80,9 +80,7 @@ pub fn list(req: &mut Request) -> CargoResult { struct R { crate_owner_invitations: Vec, } - Ok(req.json(&R { - crate_owner_invitations, - })) + Ok(req.json(&R { crate_owner_invitations })) } #[derive(Deserialize)] @@ -104,8 +102,9 @@ pub fn handle_invite(req: &mut Request) -> CargoResult { let mut body = String::new(); req.body().read_to_string(&mut body)?; - let crate_invite: OwnerInvitation = - serde_json::from_str(&body).map_err(|_| human("invalid json request"))?; + let crate_invite: OwnerInvitation = serde_json::from_str(&body).map_err(|_| { + human("invalid json request") + })?; let crate_invite = crate_invite.crate_owner_invite; @@ -153,9 +152,7 @@ fn accept_invite( struct R { crate_owner_invitation: InvitationResponse, } - Ok(req.json(&R { - crate_owner_invitation: crate_invite, - })) + Ok(req.json(&R { crate_owner_invitation: crate_invite })) }) } @@ -178,7 +175,5 @@ fn decline_invite( crate_owner_invitation: InvitationResponse, } - Ok(req.json(&R { - crate_owner_invitation: crate_invite, - })) + Ok(req.json(&R { crate_owner_invitation: crate_invite })) } diff --git a/src/dependency.rs b/src/dependency.rs index 00d8018c7fa..8cdc9767b2d 100644 --- a/src/dependency.rs +++ b/src/dependency.rs @@ -88,8 +88,10 @@ impl Dependency { impl ReverseDependency { pub fn encodable(self, crate_name: &str) -> EncodableDependency { - self.dependency - .encodable(crate_name, Some(self.crate_downloads)) + self.dependency.encodable( + crate_name, + Some(self.crate_downloads), + ) } } @@ -102,11 +104,11 @@ pub fn add_dependencies( let git_and_new_dependencies = deps.iter() .map(|dep| { - let krate = Crate::by_name(&dep.name) - .first::(&*conn) - .map_err(|_| { + let krate = Crate::by_name(&dep.name).first::(&*conn).map_err( + |_| { human(&format_args!("no known crate named `{}`", &*dep.name)) - })?; + }, + )?; if dep.version_req == semver::VersionReq::parse("*").unwrap() { return Err(human( "wildcard (`*`) dependency constraints are not allowed \ @@ -152,17 +154,7 @@ pub fn add_dependencies( } impl Queryable for Dependency { - type Row = ( - i32, - i32, - i32, - String, - bool, - bool, - Vec, - Option, - i32, - ); + type Row = (i32, i32, i32, String, bool, bool, Vec, Option, i32); fn build(row: Self::Row) -> Self { Dependency { @@ -186,11 +178,7 @@ impl Queryable for Dependency { // FIXME: We can derive this in the next release of Diesel impl Queryable<(dependencies::SqlType, Integer, Text), Pg> for ReverseDependency { - type Row = ( - >::Row, - i32, - String, - ); + type Row = (>::Row, i32, String); fn build((dep_row, downloads, _name): Self::Row) -> Self { ReverseDependency { diff --git a/src/download.rs b/src/download.rs index 4eae51b134c..30200b87594 100644 --- a/src/download.rs +++ b/src/download.rs @@ -18,7 +18,10 @@ pub struct VersionDownload { #[derive(Insertable, Debug, Clone, Copy)] #[table_name = "version_downloads"] -struct NewVersionDownload(#[column_name(version_id)] i32); +struct NewVersionDownload( + #[column_name(version_id)] + i32 +); #[derive(Serialize, Deserialize, Debug)] pub struct EncodableVersionDownload { diff --git a/src/email.rs b/src/email.rs index 87a954ef857..c15b9bd58a8 100644 --- a/src/email.rs +++ b/src/email.rs @@ -74,7 +74,9 @@ pub fn send_email(recipient: &str, subject: &str, body: &str) -> CargoResult<()> None => { let mut sender = FileEmailTransport::new(Path::new("/tmp")); let result = sender.send(email.clone()); - result.map_err(|_| bad_request("Email file could not be generated"))?; + result.map_err( + |_| bad_request("Email file could not be generated"), + )?; } } diff --git a/src/git.rs b/src/git.rs index 996b6e5bd07..494e2b7c02f 100644 --- a/src/git.rs +++ b/src/git.rs @@ -56,7 +56,9 @@ pub fn add_crate(app: &App, krate: &Crate) -> CargoResult<()> { fs::create_dir_all(dst.parent().unwrap())?; let mut prev = String::new(); if fs::metadata(&dst).is_ok() { - File::open(&dst).and_then(|mut f| f.read_to_string(&mut prev))?; + File::open(&dst).and_then( + |mut f| f.read_to_string(&mut prev), + )?; } let s = serde_json::to_string(krate).unwrap(); let new = prev + &s; @@ -82,11 +84,14 @@ pub fn yank(app: &App, krate: &str, version: &semver::Version, yanked: bool) -> commit_and_push(&repo, || { let mut prev = String::new(); - File::open(&dst).and_then(|mut f| f.read_to_string(&mut prev))?; + File::open(&dst).and_then( + |mut f| f.read_to_string(&mut prev), + )?; let new = prev.lines() .map(|line| { - let mut git_crate = serde_json::from_str::(line) - .map_err(|_| internal(&format_args!("couldn't decode: `{}`", line)))?; + let mut git_crate = serde_json::from_str::(line).map_err(|_| { + internal(&format_args!("couldn't decode: `{}`", line)) + })?; if git_crate.name != krate || git_crate.vers != version.to_string() { return Ok(line.to_string()); } @@ -155,7 +160,14 @@ where let head = repo.head()?; let parent = repo.find_commit(head.target().unwrap())?; let sig = repo.signature()?; - repo.commit(Some("HEAD"), &sig, &sig, &msg, &tree, &[&parent])?; + repo.commit( + Some("HEAD"), + &sig, + &sig, + &msg, + &tree, + &[&parent], + )?; // git push let mut ref_status = None; diff --git a/src/github.rs b/src/github.rs index e47a46736a0..562c15a5e04 100644 --- a/src/github.rs +++ b/src/github.rs @@ -78,9 +78,9 @@ pub fn parse_github_response<'de, 'a: 'de, T: Deserialize<'de>>( } } - let json = str::from_utf8(data) - .ok() - .chain_error(|| internal("github didn't send a utf8-response"))?; + let json = str::from_utf8(data).ok().chain_error(|| { + internal("github didn't send a utf8-response") + })?; serde_json::from_str(json).chain_error(|| internal("github didn't send a valid json response")) } diff --git a/src/http.rs b/src/http.rs index 7bcadef7637..fe48c02f8dd 100644 --- a/src/http.rs +++ b/src/http.rs @@ -26,10 +26,12 @@ impl SecurityHeadersMiddleware { let s3_host = match *uploader { Uploader::S3 { ref bucket, .. } => bucket.host(), - _ => unreachable!( - "This middleware should only be used in the production environment, \ + _ => { + unreachable!( + "This middleware should only be used in the production environment, \ which should also require an S3 uploader, QED" - ), + ) + } }; // It would be better if we didn't have to have 'unsafe-eval' in the `script-src` diff --git a/src/keyword.rs b/src/keyword.rs index 00ca723b64d..202ab597915 100644 --- a/src/keyword.rs +++ b/src/keyword.rs @@ -77,10 +77,10 @@ impl Keyword { if name.is_empty() { return false; } - name.chars().next().unwrap().is_alphanumeric() - && name.chars() - .all(|c| c.is_alphanumeric() || c == '_' || c == '-') - && name.chars().all(|c| c.is_ascii()) + name.chars().next().unwrap().is_alphanumeric() && + name.chars().all( + |c| c.is_alphanumeric() || c == '_' || c == '-', + ) && name.chars().all(|c| c.is_ascii()) } pub fn encodable(self) -> EncodableKeyword { @@ -101,7 +101,9 @@ impl Keyword { pub fn update_crate(conn: &PgConnection, krate: &Crate, keywords: &[&str]) -> QueryResult<()> { conn.transaction(|| { let keywords = Keyword::find_or_create_all(conn, keywords)?; - diesel::delete(CrateKeyword::belonging_to(krate)).execute(conn)?; + diesel::delete(CrateKeyword::belonging_to(krate)).execute( + conn, + )?; let crate_keywords = keywords .into_iter() .map(|kw| { @@ -169,9 +171,7 @@ pub fn show(req: &mut Request) -> CargoResult { struct R { keyword: EncodableKeyword, } - Ok(req.json(&R { - keyword: kw.encodable(), - })) + Ok(req.json(&R { keyword: kw.encodable() })) } #[cfg(test)] diff --git a/src/krate/mod.rs b/src/krate/mod.rs index 87ee1fbafda..3238d8a7b42 100644 --- a/src/krate/mod.rs +++ b/src/krate/mod.rs @@ -70,20 +70,18 @@ pub struct Crate { /// We literally never want to select `textsearchable_index_col` /// so we provide this type and constant to pass to `.select` -type AllColumns = ( - crates::id, - crates::name, - crates::updated_at, - crates::created_at, - crates::downloads, - crates::description, - crates::homepage, - crates::documentation, - crates::readme, - crates::license, - crates::repository, - crates::max_upload_size, -); +type AllColumns = (crates::id, + crates::name, + crates::updated_at, + crates::created_at, + crates::downloads, + crates::description, + crates::homepage, + crates::documentation, + crates::readme, + crates::license, + crates::repository, + crates::max_upload_size); pub const ALL_COLUMNS: AllColumns = ( crates::id, @@ -168,8 +166,9 @@ impl<'a> NewCrate<'a> { return Ok(krate); } - let target = crates::table - .filter(canon_crate_name(crates::name).eq(canon_crate_name(self.name))); + let target = crates::table.filter(canon_crate_name(crates::name).eq( + canon_crate_name(self.name), + )); update(target) .set(&self) .returning(ALL_COLUMNS) @@ -243,7 +242,11 @@ impl<'a> NewCrate<'a> { use diesel::expression::dsl::exists; let reserved_name = select(exists( - reserved_crate_names.filter(canon_crate_name(name).eq(canon_crate_name(self.name))), + reserved_crate_names.filter(canon_crate_name(name).eq( + canon_crate_name( + self.name, + ), + )), )).get_result::(conn)?; if reserved_name { Err(human("cannot upload a crate with a reserved name")) @@ -298,10 +301,10 @@ impl Crate { if name.is_empty() { return false; } - name.chars().next().unwrap().is_alphabetic() - && name.chars() - .all(|c| c.is_alphanumeric() || c == '_' || c == '-') - && name.chars().all(|c| c.is_ascii()) + name.chars().next().unwrap().is_alphabetic() && + name.chars().all( + |c| c.is_alphanumeric() || c == '_' || c == '-', + ) && name.chars().all(|c| c.is_ascii()) } pub fn valid_feature_name(name: &str) -> bool { @@ -464,20 +467,24 @@ impl Crate { ) -> CargoResult { let owner = match Owner::find_by_login(conn, login) { Ok(owner @ Owner::User(_)) => owner, - Ok(Owner::Team(team)) => if team.contains_user(app, req_user)? { - Owner::Team(team) - } else { - return Err(human(&format_args!( - "only members of {} can add it as \ + Ok(Owner::Team(team)) => { + if team.contains_user(app, req_user)? { + Owner::Team(team) + } else { + return Err(human(&format_args!( + "only members of {} can add it as \ an owner", - login - ))); - }, - Err(err) => if login.contains(':') { - Owner::Team(Team::create(app, conn, login, req_user)?) - } else { - return Err(err); - }, + login + ))); + } + } + Err(err) => { + if login.contains(':') { + Owner::Team(Team::create(app, conn, login, req_user)?) + } else { + return Err(err); + } + } }; let owner_invitation = NewCrateOwnerInvitation { @@ -514,9 +521,9 @@ impl Crate { } pub fn badges(&self, conn: &PgConnection) -> QueryResult> { - badges::table - .filter(badges::crate_id.eq(self.id)) - .load(conn) + badges::table.filter(badges::crate_id.eq(self.id)).load( + conn, + ) } /// Returns (dependency, dependent crate name, dependent crate downloads) @@ -572,21 +579,18 @@ pub fn index(req: &mut Request) -> CargoResult { let conn = req.db_conn()?; let (offset, limit) = req.pagination(10, 100)?; let params = req.query(); - let sort = params - .get("sort") - .map(|s| &**s) - .unwrap_or("recent-downloads"); + let sort = params.get("sort").map(|s| &**s).unwrap_or( + "recent-downloads", + ); let recent_downloads = sql::>("SUM(crate_downloads.downloads)"); let mut query = crates::table - .left_join( - crate_downloads::table.on( - crates::id - .eq(crate_downloads::crate_id) - .and(crate_downloads::date.gt(date(now - 90.days()))), + .left_join(crate_downloads::table.on( + crates::id.eq(crate_downloads::crate_id).and( + crate_downloads::date.gt(date(now - 90.days())), ), - ) + )) .group_by(crates::id) .select(( ALL_COLUMNS, @@ -606,10 +610,11 @@ pub fn index(req: &mut Request) -> CargoResult { if let Some(q_string) = params.get("q") { let sort = params.get("sort").map(|s| &**s).unwrap_or("relevance"); let q = plainto_tsquery(q_string); - query = query.filter( - q.matches(crates::textsearchable_index_col) - .or(crates::name.eq(q_string)), - ); + query = query.filter(q.matches(crates::textsearchable_index_col).or( + crates::name.eq( + q_string, + ), + )); query = query.select(( ALL_COLUMNS, @@ -636,11 +641,10 @@ pub fn index(req: &mut Request) -> CargoResult { crates_categories::table .select(crates_categories::crate_id) .inner_join(categories::table) - .filter( - categories::slug - .eq(cat) - .or(categories::slug.like(format!("{}::%", cat))), - ), + .filter(categories::slug.eq(cat).or(categories::slug.like(format!( + "{}::%", + cat + )))), ), ); } @@ -686,13 +690,11 @@ pub fn index(req: &mut Request) -> CargoResult { ), ); } else if params.get("following").is_some() { - query = query.filter( - crates::id.eq_any( - follows::table - .select(follows::crate_id) - .filter(follows::user_id.eq(req.user()?.id)), + query = query.filter(crates::id.eq_any( + follows::table.select(follows::crate_id).filter( + follows::user_id.eq(req.user()?.id), ), - ); + )); } // The database query returns a tuple within a tuple , with the root @@ -723,21 +725,20 @@ pub fn index(req: &mut Request) -> CargoResult { .zip(crates) .zip(perfect_matches) .zip(recent_downloads) - .map( - |(((max_version, krate), perfect_match), recent_downloads)| { - // FIXME: If we add crate_id to the Badge enum we can eliminate - // this N+1 - let badges = badges::table - .filter(badges::crate_id.eq(krate.id)) - .load::(&*conn)?; - Ok(krate.minimal_encodable( - max_version, - Some(badges), - perfect_match, - Some(recent_downloads), - )) - }, - ) + .map(|(((max_version, krate), perfect_match), + recent_downloads)| { + // FIXME: If we add crate_id to the Badge enum we can eliminate + // this N+1 + let badges = badges::table + .filter(badges::crate_id.eq(krate.id)) + .load::(&*conn)?; + Ok(krate.minimal_encodable( + max_version, + Some(badges), + perfect_match, + Some(recent_downloads), + )) + }) .collect::>()?; #[derive(Serialize)] @@ -856,14 +857,15 @@ pub fn show(req: &mut Request) -> CargoResult { .select(sum(crate_downloads::downloads)) .get_result(&*conn)?; - let badges = badges::table - .filter(badges::crate_id.eq(krate.id)) - .load(&*conn)?; + let badges = badges::table.filter(badges::crate_id.eq(krate.id)).load( + &*conn, + )?; let max_version = krate.max_version(&conn)?; #[derive(Serialize)] struct R { - #[serde(rename = "crate")] krate: EncodableCrate, + #[serde(rename = "crate")] + krate: EncodableCrate, versions: Vec, keywords: Vec, categories: Vec, @@ -956,12 +958,13 @@ pub fn new(req: &mut Request) -> CargoResult { )); } - let length = req.content_length() - .chain_error(|| human("missing header: Content-Length"))?; - let max = krate - .max_upload_size - .map(|m| m as u64) - .unwrap_or(app.config.max_upload_size); + let length = req.content_length().chain_error(|| { + human("missing header: Content-Length") + })?; + let max = krate.max_upload_size.map(|m| m as u64).unwrap_or( + app.config + .max_upload_size, + ); if length > max { return Err(human(&format_args!("max upload size is: {}", max))); } @@ -997,10 +1000,13 @@ pub fn new(req: &mut Request) -> CargoResult { // Upload the crate, return way to delete the crate from the server // If the git commands fail below, we shouldn't keep the crate on the // server. - let (cksum, mut crate_bomb, mut readme_bomb) = - app.config - .uploader - .upload_crate(req, &krate, readme, max, vers)?; + let (cksum, mut crate_bomb, mut readme_bomb) = app.config.uploader.upload_crate( + req, + &krate, + readme, + max, + vers, + )?; version.record_readme_rendering(&conn)?; // Register this crate in our local git repo. @@ -1035,7 +1041,8 @@ pub fn new(req: &mut Request) -> CargoResult { #[derive(Serialize)] struct R<'a> { - #[serde(rename = "crate")] krate: EncodableCrate, + #[serde(rename = "crate")] + krate: EncodableCrate, warnings: Warnings<'a>, } Ok(req.json(&R { @@ -1059,9 +1066,12 @@ fn parse_new_headers(req: &mut Request) -> CargoResult<(upload::NewCrate, User)> } let mut json = vec![0; amt as usize]; read_fill(req.body(), &mut json)?; - let json = String::from_utf8(json).map_err(|_| human("json body was not valid utf-8"))?; - let new: upload::NewCrate = serde_json::from_str(&json) - .map_err(|e| human(&format_args!("invalid upload request: {}", e)))?; + let json = String::from_utf8(json).map_err(|_| { + human("json body was not valid utf-8") + })?; + let new: upload::NewCrate = serde_json::from_str(&json).map_err(|e| { + human(&format_args!("invalid upload request: {}", e)) + })?; // Make sure required fields are provided fn empty(s: Option<&String>) -> bool { @@ -1152,7 +1162,9 @@ fn increment_download_counts(req: &Request, crate_name: &str, version: &str) -> let conn = req.db_conn()?; let version_id = versions .select(id) - .filter(crate_id.eq_any(Crate::by_name(crate_name).select(crates::id))) + .filter(crate_id.eq_any( + Crate::by_name(crate_name).select(crates::id), + )) .filter(num.eq(version)) .first(&*conn)?; @@ -1206,9 +1218,7 @@ pub fn downloads(req: &mut Request) -> CargoResult { struct Meta { extra_downloads: Vec, } - let meta = Meta { - extra_downloads: extra, - }; + let meta = Meta { extra_downloads: extra }; Ok(req.json(&R { version_downloads: downloads, meta: meta, @@ -1267,14 +1277,13 @@ pub fn following(req: &mut Request) -> CargoResult { let follow = follow_target(req)?; let conn = req.db_conn()?; - let following = diesel::select(exists(follows::table.find(follow.id()))).get_result(&*conn)?; + let following = diesel::select(exists(follows::table.find(follow.id()))) + .get_result(&*conn)?; #[derive(Serialize)] struct R { following: bool, } - Ok(req.json(&R { - following: following, - })) + Ok(req.json(&R { following: following })) } /// Handles the `GET /crates/:crate_id/versions` route. @@ -1365,7 +1374,9 @@ fn modify_owners(req: &mut Request, add: bool) -> CargoResult { req.body().read_to_string(&mut body)?; let user = req.user()?; let conn = req.db_conn()?; - let krate = Crate::by_name(&req.params()["crate_id"]).first::(&*conn)?; + let krate = Crate::by_name(&req.params()["crate_id"]).first::( + &*conn, + )?; let owners = krate.owners(&conn)?; match rights(req.app(), &owners, user)? { @@ -1386,12 +1397,13 @@ fn modify_owners(req: &mut Request, add: bool) -> CargoResult { owners: Option>, } - 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 - .or(request.users) - .ok_or_else(|| human("invalid json request"))?; + let logins = request.owners.or(request.users).ok_or_else(|| { + human("invalid json request") + })?; let mut msgs = Vec::new(); @@ -1419,7 +1431,10 @@ fn modify_owners(req: &mut Request, add: bool) -> CargoResult { ok: bool, msg: String, } - Ok(req.json(&R { ok: true, msg: comma_sep_msg })) + Ok(req.json(&R { + ok: true, + msg: comma_sep_msg, + })) } /// Handles the `GET /crates/:crate_id/reverse_dependencies` route. @@ -1500,7 +1515,7 @@ mod tests { assert_eq!( Crate::remove_blacklisted_documentation_urls(Some(String::from( "http://rust-ci.org/crate/crate-0.1/doc/crate-0.1", - ),),), + ))), None ); } diff --git a/src/owner.rs b/src/owner.rs index 85f3b7fb3b9..5e03cf22bcf 100644 --- a/src/owner.rs +++ b/src/owner.rs @@ -176,8 +176,8 @@ impl Team { #[derive(Deserialize)] struct GithubTeam { - slug: String, // the name we want to find - id: i32, // unique GH id (needed for membership queries) + slug: String, // the name we want to find + id: i32, // unique GH id (needed for membership queries) name: Option, // Pretty name } @@ -339,12 +339,12 @@ impl Owner { pub fn encodable(self) -> EncodableOwner { match self { Owner::User(User { - id, - name, - gh_login, - gh_avatar, - .. - }) => { + id, + name, + gh_login, + gh_avatar, + .. + }) => { let url = format!("https://github.com/{}", gh_login); EncodableOwner { id: id, @@ -356,12 +356,12 @@ impl Owner { } } Owner::Team(Team { - id, - name, - login, - avatar, - .. - }) => { + id, + name, + login, + avatar, + .. + }) => { let url = Team::github_url(&login); EncodableOwner { id: id, @@ -388,12 +388,16 @@ pub fn rights(app: &App, owners: &[Owner], user: &User) -> CargoResult { let mut best = Rights::None; for owner in owners { match *owner { - Owner::User(ref other_user) => if other_user.id == user.id { - return Ok(Rights::Full); - }, - Owner::Team(ref team) => if team.contains_user(app, user)? { - best = Rights::Publish; - }, + Owner::User(ref other_user) => { + if other_user.id == user.id { + return Ok(Rights::Full); + } + } + Owner::Team(ref team) => { + if team.contains_user(app, user)? { + best = Rights::Publish; + } + } } } Ok(best) diff --git a/src/render.rs b/src/render.rs index bdc5456ebc1..42d003d55e0 100644 --- a/src/render.rs +++ b/src/render.rs @@ -102,9 +102,7 @@ impl<'a> MarkdownRenderer<'a> { allowed_classes: allowed_classes, ..Ammonia::default() }; - MarkdownRenderer { - html_sanitizer: html_sanitizer, - } + MarkdownRenderer { html_sanitizer: html_sanitizer } } /// Renders the given markdown to HTML using the current settings. diff --git a/src/tests/all.rs b/src/tests/all.rs index 5da065f5033..429e3f25dd7 100644 --- a/src/tests/all.rs +++ b/src/tests/all.rs @@ -102,7 +102,8 @@ mod version; #[derive(Deserialize, Debug)] struct GoodCrate { - #[serde(rename = "crate")] krate: EncodableCrate, + #[serde(rename = "crate")] + krate: EncodableCrate, warnings: Warnings, } #[derive(Deserialize)] @@ -120,11 +121,7 @@ struct CrateMeta { total: i32, } -fn app() -> ( - record::Bomb, - Arc, - conduit_middleware::MiddlewareBuilder, -) { +fn app() -> (record::Bomb, Arc, conduit_middleware::MiddlewareBuilder) { dotenv::dotenv().ok(); git::init(); @@ -306,7 +303,8 @@ impl<'a> VersionBuilder<'a> { &self.features, license, self.license_file, - )?.save(connection, &[])?; + )? + .save(connection, &[])?; let new_deps = self.dependencies .into_iter() @@ -320,9 +318,9 @@ impl<'a> VersionBuilder<'a> { } }) .collect::>(); - insert(&new_deps) - .into(dependencies::table) - .execute(connection)?; + insert(&new_deps).into(dependencies::table).execute( + connection, + )?; Ok(vers) } @@ -488,8 +486,9 @@ fn krate(name: &str) -> Crate { fn sign_in_as(req: &mut Request, user: &User) { req.mut_extensions().insert(user.clone()); - req.mut_extensions() - .insert(AuthenticationSource::SessionCookie); + req.mut_extensions().insert( + AuthenticationSource::SessionCookie, + ); } fn sign_in(req: &mut Request, app: &App) -> User { @@ -684,12 +683,14 @@ fn new_crate_to_body(new_crate: &u::NewCrate, files: &[(&str, &[u8])]) -> Vec> 0) as u8, - (tarball.len() >> 8) as u8, - (tarball.len() >> 16) as u8, - (tarball.len() >> 24) as u8, - ]); + body.extend( + &[ + (tarball.len() >> 0) as u8, + (tarball.len() >> 8) as u8, + (tarball.len() >> 16) as u8, + (tarball.len() >> 24) as u8, + ], + ); body.extend(tarball); body } diff --git a/src/tests/badge.rs b/src/tests/badge.rs index 95b954db4a8..515be0d7f67 100644 --- a/src/tests/badge.rs +++ b/src/tests/badge.rs @@ -61,19 +61,25 @@ fn set_up() -> (Arc, Crate, BadgeRef) { badge_attributes_gitlab.insert(String::from("branch"), String::from("beta")); badge_attributes_gitlab.insert(String::from("repository"), String::from("rust-lang/rust")); - let isitmaintained_issue_resolution = Badge::IsItMaintainedIssueResolution { - repository: String::from("rust-lang/rust"), - }; + let isitmaintained_issue_resolution = + Badge::IsItMaintainedIssueResolution { repository: String::from("rust-lang/rust") }; let mut badge_attributes_isitmaintained_issue_resolution = HashMap::new(); - badge_attributes_isitmaintained_issue_resolution - .insert(String::from("repository"), String::from("rust-lang/rust")); + badge_attributes_isitmaintained_issue_resolution.insert( + String::from("repository"), + String::from("rust-lang/rust"), + ); - let isitmaintained_open_issues = Badge::IsItMaintainedOpenIssues { - repository: String::from("rust-lang/rust"), - }; + let isitmaintained_open_issues = + Badge::IsItMaintainedOpenIssues { repository: String::from("rust-lang/rust") }; let mut badge_attributes_isitmaintained_open_issues = HashMap::new(); - badge_attributes_isitmaintained_open_issues - .insert(String::from("repository"), String::from("rust-lang/rust")); + badge_attributes_isitmaintained_open_issues.insert( + String::from( + "repository", + ), + String::from( + "rust-lang/rust", + ), + ); let codecov = Badge::Codecov { service: Some(String::from("github")), @@ -103,9 +109,7 @@ fn set_up() -> (Arc, Crate, BadgeRef) { badge_attributes_circle_ci.insert(String::from("branch"), String::from("beta")); badge_attributes_circle_ci.insert(String::from("repository"), String::from("rust-lang/rust")); - let maintenance = Badge::Maintenance { - status: MaintenanceStatus::LookingForMaintainer, - }; + let maintenance = Badge::Maintenance { status: MaintenanceStatus::LookingForMaintainer }; let mut maintenance_attributes = HashMap::new(); maintenance_attributes.insert( String::from("status"), @@ -435,9 +439,9 @@ fn isitmaintained_open_issues_required_keys() { let mut badges = HashMap::new(); // Repository is a required key - test_badges - .isitmaintained_open_issues_attributes - .remove("repository"); + test_badges.isitmaintained_open_issues_attributes.remove( + "repository", + ); badges.insert( String::from("isitmaintained_open_issues"), test_badges.isitmaintained_open_issues_attributes, @@ -533,9 +537,12 @@ fn maintenance_invalid_values() { let mut badges = HashMap::new(); // "totes broken" is not a recognized value - test_badges - .maintenance_attributes - .insert(String::from("status"), String::from("totes broken")); + test_badges.maintenance_attributes.insert( + String::from("status"), + String::from( + "totes broken", + ), + ); badges.insert( String::from("maintenance"), test_badges.maintenance_attributes, diff --git a/src/tests/category.rs b/src/tests/category.rs index 5fda3fb80df..377642fa5b2 100644 --- a/src/tests/category.rs +++ b/src/tests/category.rs @@ -157,7 +157,9 @@ fn update_crate() { // Add a category and its subcategory { let conn = t!(app.diesel_database.get()); - t!(::new_category("cat1::bar", "cat1::bar").create_or_update(&conn,)); + t!(::new_category("cat1::bar", "cat1::bar").create_or_update( + &conn, + )); Category::update_crate(&conn, &krate, &["cat1", "cat1::bar"]).unwrap(); } assert_eq!(cnt!(&mut req, "cat1"), 1); diff --git a/src/tests/git.rs b/src/tests/git.rs index 9ae8bc8cfcf..3b26cd18c2e 100644 --- a/src/tests/git.rs +++ b/src/tests/git.rs @@ -8,10 +8,11 @@ use git2; use url::Url; fn root() -> PathBuf { - env::current_dir() - .unwrap() - .join("tmp") - .join(thread::current().name().unwrap()) + env::current_dir().unwrap().join("tmp").join( + thread::current() + .name() + .unwrap(), + ) } pub fn checkout() -> PathBuf { diff --git a/src/tests/krate.rs b/src/tests/krate.rs index a3917338d2d..494a1138a6d 100644 --- a/src/tests/krate.rs +++ b/src/tests/krate.rs @@ -32,7 +32,8 @@ struct VersionsList { } #[derive(Deserialize)] struct CrateResponse { - #[serde(rename = "crate")] krate: EncodableCrate, + #[serde(rename = "crate")] + krate: EncodableCrate, versions: Vec, keywords: Vec, } @@ -237,7 +238,9 @@ fn exact_match_first_on_queries() { .expect_build(&conn); ::CrateBuilder::new("baz_exact", user.id) - .description("foo_exact bar_exact foo_exact bar_exact foo_exact bar_exact") + .description( + "foo_exact bar_exact foo_exact bar_exact foo_exact bar_exact", + ) .expect_build(&conn); ::CrateBuilder::new("other_exact", user.id) @@ -290,7 +293,9 @@ fn exact_match_on_queries_with_sort() { .expect_build(&conn); ::CrateBuilder::new("baz_sort", user.id) - .description("foo_sort bar_sort foo_sort bar_sort foo_sort bar_sort const") + .description( + "foo_sort bar_sort foo_sort bar_sort foo_sort bar_sort const", + ) .downloads(100000) .recent_downloads(10) .expect_build(&conn); @@ -333,7 +338,9 @@ fn exact_match_on_queries_with_sort() { assert_eq!(json.crates[3].name, "foo_sort"); // Sort by recent-downloads - let mut response = ok_resp!(middle.call(req.with_query("q=bar_sort&sort=recent-downloads"),)); + let mut response = ok_resp!(middle.call( + req.with_query("q=bar_sort&sort=recent-downloads"), + )); let json: CrateList = ::json(&mut response); assert_eq!(json.meta.total, 3); assert_eq!(json.crates[0].name, "bar_sort"); @@ -497,9 +504,9 @@ fn new_bd_names() { ::sign_in(&mut req, &app); let json = bad_resp!(middle.call(&mut req)); assert!( - json.errors[0] - .detail - .contains("expected a valid crate name",), + json.errors[0].detail.contains( + "expected a valid crate name", + ), "{:?}", json.errors ); @@ -546,11 +553,9 @@ fn new_krate_with_reserved_name() { let mut req = ::new_req(app.clone(), name, "1.0.0"); ::sign_in(&mut req, &app); let json = bad_resp!(middle.call(&mut req)); - assert!( - json.errors[0] - .detail - .contains("cannot upload a crate with a reserved name",) - ); + assert!(json.errors[0].detail.contains( + "cannot upload a crate with a reserved name", + )); } test_bad_name("std"); @@ -699,7 +704,9 @@ fn new_krate_wrong_user() { let json = bad_resp!(middle.call(&mut req)); assert!( - json.errors[0].detail.contains("this crate exists but you don't seem to be an owner."), + json.errors[0].detail.contains( + "this crate exists but you don't seem to be an owner.", + ), "{:?}", json.errors ); @@ -715,9 +722,9 @@ fn new_krate_bad_name() { ::sign_in_as(&mut req, &user); let json = bad_resp!(middle.call(&mut req)); assert!( - json.errors[0] - .detail - .contains("expected a valid crate name",), + json.errors[0].detail.contains( + "expected a valid crate name", + ), "{:?}", json.errors ); @@ -727,9 +734,9 @@ fn new_krate_bad_name() { ::sign_in_as(&mut req, &user); let json = bad_resp!(middle.call(&mut req)); assert!( - json.errors[0] - .detail - .contains("expected a valid crate name",), + json.errors[0].detail.contains( + "expected a valid crate name", + ), "{:?}", json.errors ); @@ -955,11 +962,9 @@ fn new_krate_dependency_missing() { ::sign_in(&mut req, &app); let mut response = ok_resp!(middle.call(&mut req)); let json = ::json::<::Bad>(&mut response); - assert!( - json.errors[0] - .detail - .contains("no known crate named `bar_missing`",) - ); + assert!(json.errors[0].detail.contains( + "no known crate named `bar_missing`", + )); } #[test] @@ -1205,21 +1210,15 @@ fn yank() { assert!(contents.contains("\"yanked\":false")); // make sure it's not yanked - let mut r = ok_resp!( - middle.call( - req.with_method(Method::Get,) - .with_path("/api/v1/crates/fyk/1.0.0",), - ) - ); + let mut r = ok_resp!(middle.call(req.with_method(Method::Get).with_path( + "/api/v1/crates/fyk/1.0.0", + ))); assert!(!::json::(&mut r).version.yanked); // yank it - let mut r = ok_resp!( - middle.call( - req.with_method(Method::Delete,) - .with_path("/api/v1/crates/fyk/1.0.0/yank",), - ) - ); + let mut r = ok_resp!(middle.call(req.with_method(Method::Delete).with_path( + "/api/v1/crates/fyk/1.0.0/yank", + ))); assert!(::json::(&mut r).ok); let mut contents = String::new(); File::open(&path) @@ -1227,21 +1226,15 @@ fn yank() { .read_to_string(&mut contents) .unwrap(); assert!(contents.contains("\"yanked\":true")); - let mut r = ok_resp!( - middle.call( - req.with_method(Method::Get,) - .with_path("/api/v1/crates/fyk/1.0.0",), - ) - ); + let mut r = ok_resp!(middle.call(req.with_method(Method::Get).with_path( + "/api/v1/crates/fyk/1.0.0", + ))); assert!(::json::(&mut r).version.yanked); // un-yank it - let mut r = ok_resp!( - middle.call( - req.with_method(Method::Put,) - .with_path("/api/v1/crates/fyk/1.0.0/unyank",), - ) - ); + let mut r = ok_resp!(middle.call(req.with_method(Method::Put).with_path( + "/api/v1/crates/fyk/1.0.0/unyank", + ))); assert!(::json::(&mut r).ok); let mut contents = String::new(); File::open(&path) @@ -1249,12 +1242,9 @@ fn yank() { .read_to_string(&mut contents) .unwrap(); assert!(contents.contains("\"yanked\":false")); - let mut r = ok_resp!( - middle.call( - req.with_method(Method::Get,) - .with_path("/api/v1/crates/fyk/1.0.0",), - ) - ); + let mut r = ok_resp!(middle.call(req.with_method(Method::Get).with_path( + "/api/v1/crates/fyk/1.0.0", + ))); assert!(!::json::(&mut r).version.yanked); } @@ -1263,8 +1253,9 @@ fn yank_not_owner() { let (_b, app, middle) = ::app(); let mut req = ::request_with_user_and_mock_crate(&app, ::new_user("bar"), "foo_not"); ::sign_in(&mut req, &app); - req.with_method(Method::Delete) - .with_path("/api/v1/crates/foo_not/1.0.0/yank"); + req.with_method(Method::Delete).with_path( + "/api/v1/crates/foo_not/1.0.0/yank", + ); let mut response = ok_resp!(middle.call(&mut req)); ::json::<::Bad>(&mut response); } @@ -1299,104 +1290,68 @@ fn yank_max_version() { assert_eq!(json.krate.max_version, "2.0.0"); // yank version 1.0.0 - let mut r = ok_resp!( - middle.call( - req.with_method(Method::Delete,) - .with_path("/api/v1/crates/fyk_max/1.0.0/yank",), - ) - ); + let mut r = ok_resp!(middle.call(req.with_method(Method::Delete).with_path( + "/api/v1/crates/fyk_max/1.0.0/yank", + ))); assert!(::json::(&mut r).ok); - let mut response = ok_resp!( - middle.call( - req.with_method(Method::Get,) - .with_path("/api/v1/crates/fyk_max",), - ) - ); + let mut response = ok_resp!(middle.call(req.with_method(Method::Get).with_path( + "/api/v1/crates/fyk_max", + ))); let json: CrateResponse = ::json(&mut response); assert_eq!(json.krate.max_version, "2.0.0"); // unyank version 1.0.0 - let mut r = ok_resp!( - middle.call( - req.with_method(Method::Put,) - .with_path("/api/v1/crates/fyk_max/1.0.0/unyank",), - ) - ); + let mut r = ok_resp!(middle.call(req.with_method(Method::Put).with_path( + "/api/v1/crates/fyk_max/1.0.0/unyank", + ))); assert!(::json::(&mut r).ok); - let mut response = ok_resp!( - middle.call( - req.with_method(Method::Get,) - .with_path("/api/v1/crates/fyk_max",), - ) - ); + let mut response = ok_resp!(middle.call(req.with_method(Method::Get).with_path( + "/api/v1/crates/fyk_max", + ))); let json: CrateResponse = ::json(&mut response); assert_eq!(json.krate.max_version, "2.0.0"); // yank version 2.0.0 - let mut r = ok_resp!( - middle.call( - req.with_method(Method::Delete,) - .with_path("/api/v1/crates/fyk_max/2.0.0/yank",), - ) - ); + let mut r = ok_resp!(middle.call(req.with_method(Method::Delete).with_path( + "/api/v1/crates/fyk_max/2.0.0/yank", + ))); assert!(::json::(&mut r).ok); - let mut response = ok_resp!( - middle.call( - req.with_method(Method::Get,) - .with_path("/api/v1/crates/fyk_max",), - ) - ); + let mut response = ok_resp!(middle.call(req.with_method(Method::Get).with_path( + "/api/v1/crates/fyk_max", + ))); let json: CrateResponse = ::json(&mut response); assert_eq!(json.krate.max_version, "1.0.0"); // yank version 1.0.0 - let mut r = ok_resp!( - middle.call( - req.with_method(Method::Delete,) - .with_path("/api/v1/crates/fyk_max/1.0.0/yank",), - ) - ); + let mut r = ok_resp!(middle.call(req.with_method(Method::Delete).with_path( + "/api/v1/crates/fyk_max/1.0.0/yank", + ))); assert!(::json::(&mut r).ok); - let mut response = ok_resp!( - middle.call( - req.with_method(Method::Get,) - .with_path("/api/v1/crates/fyk_max",), - ) - ); + let mut response = ok_resp!(middle.call(req.with_method(Method::Get).with_path( + "/api/v1/crates/fyk_max", + ))); let json: CrateResponse = ::json(&mut response); assert_eq!(json.krate.max_version, "0.0.0"); // unyank version 2.0.0 - let mut r = ok_resp!( - middle.call( - req.with_method(Method::Put,) - .with_path("/api/v1/crates/fyk_max/2.0.0/unyank",), - ) - ); + let mut r = ok_resp!(middle.call(req.with_method(Method::Put).with_path( + "/api/v1/crates/fyk_max/2.0.0/unyank", + ))); assert!(::json::(&mut r).ok); - let mut response = ok_resp!( - middle.call( - req.with_method(Method::Get,) - .with_path("/api/v1/crates/fyk_max",), - ) - ); + let mut response = ok_resp!(middle.call(req.with_method(Method::Get).with_path( + "/api/v1/crates/fyk_max", + ))); let json: CrateResponse = ::json(&mut response); assert_eq!(json.krate.max_version, "2.0.0"); // unyank version 1.0.0 - let mut r = ok_resp!( - middle.call( - req.with_method(Method::Put,) - .with_path("/api/v1/crates/fyk_max/1.0.0/unyank",), - ) - ); + let mut r = ok_resp!(middle.call(req.with_method(Method::Put).with_path( + "/api/v1/crates/fyk_max/1.0.0/unyank", + ))); assert!(::json::(&mut r).ok); - let mut response = ok_resp!( - middle.call( - req.with_method(Method::Get,) - .with_path("/api/v1/crates/fyk_max",), - ) - ); + let mut response = ok_resp!(middle.call(req.with_method(Method::Get).with_path( + "/api/v1/crates/fyk_max", + ))); let json: CrateResponse = ::json(&mut response); assert_eq!(json.krate.max_version, "2.0.0"); } @@ -1419,19 +1374,13 @@ fn publish_after_yank_max_version() { assert_eq!(json.krate.max_version, "1.0.0"); // yank version 1.0.0 - let mut r = ok_resp!( - middle.call( - req.with_method(Method::Delete,) - .with_path("/api/v1/crates/fyk_max/1.0.0/yank",), - ) - ); + let mut r = ok_resp!(middle.call(req.with_method(Method::Delete).with_path( + "/api/v1/crates/fyk_max/1.0.0/yank", + ))); assert!(::json::(&mut r).ok); - let mut response = ok_resp!( - middle.call( - req.with_method(Method::Get,) - .with_path("/api/v1/crates/fyk_max",), - ) - ); + let mut response = ok_resp!(middle.call(req.with_method(Method::Get).with_path( + "/api/v1/crates/fyk_max", + ))); let json: CrateResponse = ::json(&mut response); assert_eq!(json.krate.max_version, "0.0.0"); @@ -1448,19 +1397,13 @@ fn publish_after_yank_max_version() { assert_eq!(json.krate.max_version, "2.0.0"); // unyank version 1.0.0 - let mut r = ok_resp!( - middle.call( - req.with_method(Method::Put,) - .with_path("/api/v1/crates/fyk_max/1.0.0/unyank",), - ) - ); + let mut r = ok_resp!(middle.call(req.with_method(Method::Put).with_path( + "/api/v1/crates/fyk_max/1.0.0/unyank", + ))); assert!(::json::(&mut r).ok); - let mut response = ok_resp!( - middle.call( - req.with_method(Method::Get,) - .with_path("/api/v1/crates/fyk_max",), - ) - ); + let mut response = ok_resp!(middle.call(req.with_method(Method::Get).with_path( + "/api/v1/crates/fyk_max", + ))); let json: CrateResponse = ::json(&mut response); assert_eq!(json.krate.max_version, "2.0.0"); } @@ -1558,12 +1501,9 @@ fn good_badges() { assert_eq!(json.krate.name, "foobadger"); assert_eq!(json.krate.max_version, "1.0.0"); - let mut response = ok_resp!( - middle.call( - req.with_method(Method::Get,) - .with_path("/api/v1/crates/foobadger",), - ) - ); + let mut response = ok_resp!(middle.call(req.with_method(Method::Get).with_path( + "/api/v1/crates/foobadger", + ))); let json: CrateResponse = ::json(&mut response); @@ -1601,23 +1541,16 @@ fn ignored_badges() { assert_eq!(json.krate.name, "foo_ignored_badge"); assert_eq!(json.krate.max_version, "1.0.0"); assert_eq!(json.warnings.invalid_badges.len(), 2); - assert!( - json.warnings - .invalid_badges - .contains(&"travis-ci".to_string(),) - ); - assert!( - json.warnings - .invalid_badges - .contains(&"not-a-badge".to_string(),) - ); + assert!(json.warnings.invalid_badges.contains( + &"travis-ci".to_string(), + )); + assert!(json.warnings.invalid_badges.contains( + &"not-a-badge".to_string(), + )); - let mut response = ok_resp!( - middle.call( - req.with_method(Method::Get,) - .with_path("/api/v1/crates/foo_ignored_badge",), - ) - ); + let mut response = ok_resp!(middle.call(req.with_method(Method::Get).with_path( + "/api/v1/crates/foo_ignored_badge", + ))); let json: CrateResponse = ::json(&mut response); @@ -1805,8 +1738,8 @@ fn author_license_and_description_required() { req.with_body(&::new_crate_to_body(&new_crate, &[])); let json = bad_resp!(middle.call(&mut req)); assert!( - json.errors[0].detail.contains("author") && json.errors[0].detail.contains("description") - && json.errors[0].detail.contains("license"), + json.errors[0].detail.contains("author") && json.errors[0].detail.contains("description") && + json.errors[0].detail.contains("license"), "{:?}", json.errors ); @@ -1816,8 +1749,8 @@ fn author_license_and_description_required() { req.with_body(&::new_crate_to_body(&new_crate, &[])); let json = bad_resp!(middle.call(&mut req)); assert!( - json.errors[0].detail.contains("author") && json.errors[0].detail.contains("description") - && !json.errors[0].detail.contains("license"), + json.errors[0].detail.contains("author") && json.errors[0].detail.contains("description") && + !json.errors[0].detail.contains("license"), "{:?}", json.errors ); @@ -1828,8 +1761,9 @@ fn author_license_and_description_required() { req.with_body(&::new_crate_to_body(&new_crate, &[])); let json = bad_resp!(middle.call(&mut req)); assert!( - !json.errors[0].detail.contains("author") && json.errors[0].detail.contains("description") - && !json.errors[0].detail.contains("license"), + !json.errors[0].detail.contains("author") && + json.errors[0].detail.contains("description") && + !json.errors[0].detail.contains("license"), "{:?}", json.errors ); @@ -1992,7 +1926,9 @@ fn block_blacklisted_documentation_url() { let conn = app.diesel_database.get().unwrap(); let u = ::new_user("foo").create_or_update(&conn).unwrap(); ::CrateBuilder::new("foo_bad_doc_url", u.id) - .documentation("http://rust-ci.org/foo/foo_bad_doc_url/doc/foo_bad_doc_url/") + .documentation( + "http://rust-ci.org/foo/foo_bad_doc_url/doc/foo_bad_doc_url/", + ) .expect_build(&conn) }; @@ -2020,9 +1956,14 @@ fn test_cargo_invite_owners() { }; #[derive(Serialize)] - struct OwnerReq { owners: Option> } + struct OwnerReq { + owners: Option>, + } #[derive(Deserialize, Debug)] - struct OwnerResp { ok: bool, msg: String } + struct OwnerResp { + ok: bool, + msg: String, + } let body = serde_json::to_string(&OwnerReq { owners: Some(vec![new_user.gh_login]) }); let mut response = ok_resp!( @@ -2040,7 +1981,10 @@ fn test_cargo_invite_owners() { assert!(r.ok); // msg field is what is sent and used in updated // version of cargo - assert_eq!(r.msg, "user cilantro has been invited to be an owner of crate guacamole") + assert_eq!( + r.msg, + "user cilantro has been invited to be an owner of crate guacamole" + ) } // #[test] diff --git a/src/tests/owners.rs b/src/tests/owners.rs index e51a67a096c..5428dd747c1 100644 --- a/src/tests/owners.rs +++ b/src/tests/owners.rs @@ -53,7 +53,10 @@ fn new_crate_owner() { let krate_id = { let conn = app.diesel_database.get().unwrap(); - Crate::by_name("foo_owner").first::(&*conn).unwrap().id + Crate::by_name("foo_owner") + .first::(&*conn) + .unwrap() + .id }; let body = json!({ @@ -151,8 +154,7 @@ fn owners_can_remove_self() { // Deleting yourself when you're the only owner isn't allowed. let body = r#"{"users":["firstowner"]}"#; - let mut response = - ok_resp!(middle.call(req.with_method(Method::Delete,).with_body(body.as_bytes(),),)); + let mut response = ok_resp!(middle.call(req.with_method(Method::Delete,).with_body(body.as_bytes(),),)); let json = ::json::<::Bad>(&mut response); assert!( json.errors[0] @@ -161,14 +163,16 @@ fn owners_can_remove_self() { ); let body = r#"{"users":["secondowner"]}"#; - let mut response = - ok_resp!(middle.call(req.with_method(Method::Put,).with_body(body.as_bytes(),),)); + let mut response = ok_resp!(middle.call(req.with_method(Method::Put,).with_body(body.as_bytes(),),)); assert!(::json::(&mut response).ok); // Need to accept owner invitation to add secondowner as owner let krate_id = { let conn = app.diesel_database.get().unwrap(); - Crate::by_name("owners_selfremove").first::(&*conn).unwrap().id + Crate::by_name("owners_selfremove") + .first::(&*conn) + .unwrap() + .id }; let body = json!({ @@ -223,8 +227,7 @@ fn owners_can_remove_self() { // After you delete yourself, you no longer have permisions to manage the crate. let body = r#"{"users":["secondowner"]}"#; - let mut response = - ok_resp!(middle.call(req.with_method(Method::Delete,).with_body(body.as_bytes(),),)); + let mut response = ok_resp!(middle.call(req.with_method(Method::Delete,).with_body(body.as_bytes(),),)); let json = ::json::<::Bad>(&mut response); assert!( json.errors[0] diff --git a/src/tests/record.rs b/src/tests/record.rs index 059ef07ef03..edc8f3146f1 100644 --- a/src/tests/record.rs +++ b/src/tests/record.rs @@ -63,9 +63,11 @@ impl Drop for Bomb { .to_string(); match res { Err(..) if !thread::panicking() => panic!("server subtask failed: {}", stderr), - Err(e) => if stderr.len() > 0 { - println!("server subtask failed ({:?}): {}", e, stderr) - }, + Err(e) => { + if stderr.len() > 0 { + println!("server subtask failed ({:?}): {}", e, stderr) + } + } Ok(_) if thread::panicking() => {} Ok(None) => {} Ok(Some((data, file))) => { @@ -308,7 +310,9 @@ fn replay_http( }); let mut response = hyper::Response::new(); - response.set_status(hyper::StatusCode::try_from(exchange.response.status).unwrap()); + response.set_status( + hyper::StatusCode::try_from(exchange.response.status).unwrap(), + ); for (key, value) in exchange.response.headers.into_iter() { response.headers_mut().append_raw(key, value); } diff --git a/src/tests/schema_details.rs b/src/tests/schema_details.rs index d18b5622d90..c452a8e4aea 100644 --- a/src/tests/schema_details.rs +++ b/src/tests/schema_details.rs @@ -5,10 +5,12 @@ fn all_columns_called_crate_id_have_a_cascading_foreign_key() { for (table_name, constraint) in get_fk_constraint_definitions("crate_id") { let constraint = match constraint { Some(c) => c, - None => panic!( - "Column called crate_id on {} has no foreign key", - table_name - ), + None => { + panic!( + "Column called crate_id on {} has no foreign key", + table_name + ) + } }; if !constraint.definition.contains("ON DELETE CASCADE") { panic!( @@ -26,10 +28,12 @@ fn all_columns_called_version_id_have_a_cascading_foreign_key() { for (table_name, constraint) in get_fk_constraint_definitions("version_id") { let constraint = match constraint { Some(c) => c, - None => panic!( - "Column called version_id on {} has no foreign key", - table_name - ), + None => { + panic!( + "Column called version_id on {} has no foreign key", + table_name + ) + } }; if !constraint.definition.contains("ON DELETE CASCADE") { panic!( diff --git a/src/tests/team.rs b/src/tests/team.rs index 444d52164b9..35e83ad4923 100644 --- a/src/tests/team.rs +++ b/src/tests/team.rs @@ -71,9 +71,9 @@ fn weird_name() { ) ); assert!( - json.errors[0] - .detail - .contains("organization cannot contain",), + json.errors[0].detail.contains( + "organization cannot contain", + ), "{:?}", json.errors ); @@ -115,9 +115,9 @@ fn nonexistent_team() { ) ); assert!( - json.errors[0] - .detail - .contains("don't have permission to query a necessary property",), + json.errors[0].detail.contains( + "don't have permission to query a necessary property", + ), "{:?}", json.errors ); @@ -200,7 +200,9 @@ fn remove_team_as_named_owner() { ) ); assert!( - json.errors[0].detail.contains("this crate exists but you don't seem to be an owner."), + json.errors[0].detail.contains( + "this crate exists but you don't seem to be an owner.", + ), "{:?}", json.errors ); @@ -236,9 +238,9 @@ fn remove_team_as_team_owner() { ); assert!( - json.errors[0] - .detail - .contains("only owners have permission",), + json.errors[0].detail.contains( + "only owners have permission", + ), "{:?}", json.errors ); @@ -283,7 +285,9 @@ fn publish_not_owned() { ) ); assert!( - json.errors[0].detail.contains("this crate exists but you don't seem to be an owner."), + json.errors[0].detail.contains( + "this crate exists but you don't seem to be an owner.", + ), "{:?}", json.errors ); @@ -349,9 +353,9 @@ fn add_owners_as_team_owner() { ) ); assert!( - json.errors[0] - .detail - .contains("only owners have permission",), + json.errors[0].detail.contains( + "only owners have permission", + ), "{:?}", json.errors ); diff --git a/src/tests/user.rs b/src/tests/user.rs index c460e331c05..01a476a8e2e 100644 --- a/src/tests/user.rs +++ b/src/tests/user.rs @@ -170,12 +170,11 @@ fn following() { .expect_build(&conn); } - let mut response = ok_resp!( - middle.call( - req.with_path("/api/v1/me/updates",) - .with_method(Method::Get,), - ) - ); + let mut response = ok_resp!(middle.call( + req.with_path("/api/v1/me/updates").with_method( + Method::Get, + ), + )); let r = ::json::(&mut response); assert_eq!(r.versions.len(), 0); assert_eq!(r.meta.more, false); @@ -193,12 +192,11 @@ fn following() { ) ); - let mut response = ok_resp!( - middle.call( - req.with_path("/api/v1/me/updates",) - .with_method(Method::Get,), - ) - ); + let mut response = ok_resp!(middle.call( + req.with_path("/api/v1/me/updates").with_method( + Method::Get, + ), + )); let r = ::json::(&mut response); assert_eq!(r.versions.len(), 2); assert_eq!(r.meta.more, false); @@ -255,8 +253,8 @@ fn user_total_downloads() { let another_user = ::new_user("bar").create_or_update(&conn).unwrap(); - let mut another_krate = - ::CrateBuilder::new("bar_krate1", another_user.id).expect_build(&conn); + let mut another_krate = ::CrateBuilder::new("bar_krate1", another_user.id) + .expect_build(&conn); another_krate.downloads = 2; update(&another_krate) .set(&another_krate) @@ -351,7 +349,9 @@ fn test_github_login_does_not_overwrite_email() { user }; - let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),)); + let mut response = ok_resp!(middle.call( + req.with_path("/api/v1/me").with_method(Method::Get), + )); let r = ::json::(&mut response); assert_eq!(r.user.email, None); assert_eq!(r.user.login, "apricot"); @@ -379,7 +379,9 @@ fn test_github_login_does_not_overwrite_email() { ::sign_in_as(&mut req, &user); } - let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),)); + let mut response = ok_resp!(middle.call( + req.with_path("/api/v1/me").with_method(Method::Get), + )); let r = ::json::(&mut response); assert_eq!(r.user.email.unwrap(), "apricot@apricots.apricot"); assert_eq!(r.user.login, "apricot"); @@ -410,7 +412,9 @@ fn test_email_get_and_put() { user }; - let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),)); + let mut response = ok_resp!(middle.call( + req.with_path("/api/v1/me").with_method(Method::Get), + )); let r = ::json::(&mut response); assert_eq!(r.user.email, None); assert_eq!(r.user.login, "mango"); @@ -425,7 +429,9 @@ fn test_email_get_and_put() { ); assert!(::json::(&mut response).ok); - let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),)); + let mut response = ok_resp!(middle.call( + req.with_path("/api/v1/me").with_method(Method::Get), + )); let r = ::json::(&mut response); assert_eq!(r.user.email.unwrap(), "mango@mangos.mango"); assert_eq!(r.user.login, "mango"); @@ -517,9 +523,9 @@ fn test_this_user_cannot_change_that_user_email() { ); assert!( - json.errors[0] - .detail - .contains("current user does not match requested user",), + json.errors[0].detail.contains( + "current user does not match requested user", + ), "{:?}", json.errors ); @@ -552,7 +558,9 @@ fn test_insert_into_email_table() { ::sign_in_as(&mut req, &user); } - let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),)); + let mut response = ok_resp!(middle.call( + req.with_path("/api/v1/me").with_method(Method::Get), + )); let r = ::json::(&mut response); assert_eq!(r.user.email.unwrap(), "apple@example.com"); assert_eq!(r.user.login, "apple"); @@ -572,7 +580,9 @@ fn test_insert_into_email_table() { ::sign_in_as(&mut req, &user); } - let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),)); + let mut response = ok_resp!(middle.call( + req.with_path("/api/v1/me").with_method(Method::Get), + )); let r = ::json::(&mut response); assert_eq!(r.user.email.unwrap(), "apple@example.com"); assert_eq!(r.user.login, "apple"); @@ -610,7 +620,9 @@ fn test_insert_into_email_table_with_email_change() { user }; - let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),)); + let mut response = ok_resp!(middle.call( + req.with_path("/api/v1/me").with_method(Method::Get), + )); let r = ::json::(&mut response); assert_eq!(r.user.email.unwrap(), "potato@example.com"); assert_eq!(r.user.login, "potato"); @@ -642,7 +654,9 @@ fn test_insert_into_email_table_with_email_change() { ::sign_in_as(&mut req, &user); } - let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),)); + let mut response = ok_resp!(middle.call( + req.with_path("/api/v1/me").with_method(Method::Get), + )); let r = ::json::(&mut response); assert_eq!(r.user.email.unwrap(), "apricot@apricots.apricot"); assert!(!r.user.email_verified); @@ -705,7 +719,9 @@ fn test_confirm_user_email() { ); assert!(::json::(&mut response).ok); - let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),)); + let mut response = ok_resp!(middle.call( + req.with_path("/api/v1/me").with_method(Method::Get), + )); let r = ::json::(&mut response); assert_eq!(r.user.email.unwrap(), "potato@example.com"); assert_eq!(r.user.login, "potato"); @@ -752,7 +768,9 @@ fn test_existing_user_email() { ::sign_in_as(&mut req, &user); } - let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),)); + let mut response = ok_resp!(middle.call( + req.with_path("/api/v1/me").with_method(Method::Get), + )); let r = ::json::(&mut response); assert_eq!(r.user.email.unwrap(), "potahto@example.com"); assert!(!r.user.email_verified); diff --git a/src/tests/version.rs b/src/tests/version.rs index 0f29fa3fecc..8370685c8de 100644 --- a/src/tests/version.rs +++ b/src/tests/version.rs @@ -31,7 +31,9 @@ fn index() { let u = ::new_user("foo").create_or_update(&conn).unwrap(); ::CrateBuilder::new("foo_vers_index", u.id) .version(::VersionBuilder::new("2.0.0").license(Some("MIT"))) - .version(::VersionBuilder::new("2.0.1").license(Some("MIT/Apache-2.0"))) + .version(::VersionBuilder::new("2.0.1").license( + Some("MIT/Apache-2.0"), + )) .expect_build(&conn); let ids = versions::table .select(versions::id) diff --git a/src/token.rs b/src/token.rs index 0dcb0709efb..71a9fcd357a 100644 --- a/src/token.rs +++ b/src/token.rs @@ -15,8 +15,10 @@ use schema::api_tokens; #[belongs_to(User)] pub struct ApiToken { pub id: i32, - #[serde(skip)] pub user_id: i32, - #[serde(skip)] pub token: String, + #[serde(skip)] + pub user_id: i32, + #[serde(skip)] + pub token: String, pub name: String, pub created_at: NaiveDateTime, pub last_used_at: Option, @@ -101,8 +103,9 @@ pub fn new(req: &mut Request) -> CargoResult { } let max_post_size = 2000; - let length = req.content_length() - .chain_error(|| bad_request("missing header: Content-Length"))?; + let length = req.content_length().chain_error(|| { + bad_request("missing header: Content-Length") + })?; if length > max_post_size { return Err(bad_request(&format!("max post size is: {}", max_post_size))); @@ -111,7 +114,9 @@ pub fn new(req: &mut Request) -> CargoResult { 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)) @@ -125,9 +130,9 @@ pub fn new(req: &mut Request) -> CargoResult { let user = req.user()?; let max_token_per_user = 500; - let count = ApiToken::belonging_to(user) - .count() - .get_result::(&*req.db_conn()?)?; + let count = ApiToken::belonging_to(user).count().get_result::( + &*req.db_conn()?, + )?; if count >= max_token_per_user { return Err(bad_request(&format!( "maximum tokens per user is: {}", @@ -141,18 +146,17 @@ pub fn new(req: &mut Request) -> CargoResult { struct R { api_token: EncodableApiTokenWithToken, } - Ok(req.json(&R { - api_token: api_token.encodable_with_token(), - })) + Ok(req.json(&R { api_token: api_token.encodable_with_token() })) } /// Handles the `DELETE /me/tokens/:id` route. pub fn revoke(req: &mut Request) -> CargoResult { - let id = req.params()["id"] - .parse::() - .map_err(|e| bad_request(&format!("invalid token id: {:?}", e)))?; + let id = req.params()["id"].parse::().map_err(|e| { + bad_request(&format!("invalid token id: {:?}", e)) + })?; - diesel::delete(ApiToken::belonging_to(req.user()?).find(id)).execute(&*req.db_conn()?)?; + diesel::delete(ApiToken::belonging_to(req.user()?).find(id)) + .execute(&*req.db_conn()?)?; #[derive(Serialize)] struct R {} diff --git a/src/uploaders.rs b/src/uploaders.rs index 653813dfde8..c84b815abe2 100644 --- a/src/uploaders.rs +++ b/src/uploaders.rs @@ -150,7 +150,9 @@ impl Uploader { let path = Uploader::crate_path(&krate.name, &vers.to_string()); let length = read_le_u32(req.body())?; let mut body = Vec::new(); - LimitErrorReader::new(req.body(), max).read_to_end(&mut body)?; + LimitErrorReader::new(req.body(), max).read_to_end( + &mut body, + )?; verify_tarball(krate, vers, &body)?; self.upload( app.handle(), diff --git a/src/user/middleware.rs b/src/user/middleware.rs index fa87252e374..74ece70fcd3 100644 --- a/src/user/middleware.rs +++ b/src/user/middleware.rs @@ -23,9 +23,9 @@ impl conduit_middleware::Middleware for Middleware { fn before(&self, req: &mut Request) -> Result<(), Box> { // Check if the request has a session cookie with a `user_id` property inside let id = { - req.session() - .get("user_id") - .and_then(|s| s.parse::().ok()) + req.session().get("user_id").and_then( + |s| s.parse::().ok(), + ) }; let conn = req.db_conn().map_err(std_error)?; @@ -36,8 +36,9 @@ impl conduit_middleware::Middleware for Middleware { if let Ok(user) = maybe_user { // Attach the `User` model from the database to the request req.mut_extensions().insert(user); - req.mut_extensions() - .insert(AuthenticationSource::SessionCookie); + req.mut_extensions().insert( + AuthenticationSource::SessionCookie, + ); } } else { // Otherwise, look for an `Authorization` header on the request @@ -65,9 +66,9 @@ pub trait RequestUser { impl<'a> RequestUser for Request + 'a { fn user(&self) -> CargoResult<&User> { - self.extensions() - .find::() - .chain_error(|| Unauthorized) + self.extensions().find::().chain_error( + || Unauthorized, + ) } fn authentication_source(&self) -> CargoResult { diff --git a/src/user/mod.rs b/src/user/mod.rs index 68a4193af58..d567e09ba8a 100644 --- a/src/user/mod.rs +++ b/src/user/mod.rs @@ -97,7 +97,10 @@ impl NewToken { let new_token = Self::generate(id); insert(&new_token.on_conflict( email_id, - do_update().set((token.eq(&new_token.token), created_at.eq(now))), + do_update().set(( + token.eq(&new_token.token), + created_at.eq(now), + )), )).into(tokens) .returning(token) .get_result(conn) @@ -150,8 +153,10 @@ impl<'a> NewUser<'a> { // necessary for most fields in the database to be used as a conflict // target :) let conflict_target = sql::("(gh_id) WHERE gh_id > 0"); - let user = insert(&self.on_conflict(conflict_target, do_update().set(&update_user))) - .into(users::table) + let user = insert(&self.on_conflict( + conflict_target, + do_update().set(&update_user), + )).into(users::table) .get_result::(conn)?; // To send the user an account verification email... @@ -300,8 +305,10 @@ impl User { pub fn github_authorize(req: &mut Request) -> CargoResult { // Generate a random 16 char ASCII string let state: String = thread_rng().gen_ascii_chars().take(16).collect(); - req.session() - .insert("github_oauth_state".to_string(), state.clone()); + req.session().insert( + "github_oauth_state".to_string(), + state.clone(), + ); let url = req.app().github.authorize_url(state.clone()); @@ -370,10 +377,9 @@ pub fn github_access_token(req: &mut Request) -> CargoResult { } // Fetch the access token from github using the code we just got - let token = req.app() - .github - .exchange(code.clone()) - .map_err(|s| human(&s))?; + let token = req.app().github.exchange(code.clone()).map_err( + |s| human(&s), + )?; let (handle, resp) = github::github(req.app(), "/user", &token)?; let ghuser: GithubUser = github::parse_github_response(handle, &resp)?; @@ -386,8 +392,10 @@ pub fn github_access_token(req: &mut Request) -> CargoResult { ghuser.avatar_url.as_ref().map(|s| &s[..]), &token.access_token, ).create_or_update(&*req.db_conn()?)?; - req.session() - .insert("user_id".to_string(), user.id.to_string()); + req.session().insert( + "user_id".to_string(), + user.id.to_string(), + ); req.mut_extensions().insert(user); me(req) } @@ -460,17 +468,15 @@ pub fn show(req: &mut Request) -> CargoResult { let name = &req.params()["user_id"].to_lowercase(); let conn = req.db_conn()?; - let user = users - .filter(::lower(gh_login).eq(name)) - .first::(&*conn)?; + let user = users.filter(::lower(gh_login).eq(name)).first::( + &*conn, + )?; #[derive(Serialize)] struct R { user: EncodablePublicUser, } - Ok(req.json(&R { - user: user.encodable_public(), - })) + Ok(req.json(&R { user: user.encodable_public() })) } /// Handles the `GET /teams/:team_id` route. @@ -487,9 +493,7 @@ pub fn show_team(req: &mut Request) -> CargoResult { struct R { team: EncodableTeam, } - Ok(req.json(&R { - team: team.encodable(), - })) + Ok(req.json(&R { team: team.encodable() })) } /// Handles the `GET /me/updates` route. @@ -542,11 +546,9 @@ pub fn stats(req: &mut Request) -> CargoResult { let data = crate_owners::table .inner_join(crates::table) - .filter( - crate_owners::owner_id - .eq(user_id) - .and(crate_owners::owner_kind.eq(OwnerKind::User as i32)), - ) + .filter(crate_owners::owner_id.eq(user_id).and( + crate_owners::owner_kind.eq(OwnerKind::User as i32), + )) .select(sum(crates::downloads)) .first::>(&*conn)? .unwrap_or(0); @@ -555,9 +557,7 @@ pub fn stats(req: &mut Request) -> CargoResult { struct R { total_downloads: i64, } - Ok(req.json(&R { - total_downloads: data, - })) + Ok(req.json(&R { total_downloads: data })) } /// Handles the `PUT /user/:user_id` route. @@ -588,8 +588,9 @@ pub fn update_user(req: &mut Request) -> CargoResult { email: Option, } - let user_update: UserUpdate = - serde_json::from_str(&body).map_err(|_| human("invalid json request"))?; + let user_update: UserUpdate = serde_json::from_str(&body).map_err( + |_| human("invalid json request"), + )?; if user_update.user.email.is_none() { return Err(human("empty email rejected")); diff --git a/src/util/errors.rs b/src/util/errors.rs index 9075b207834..a17edd081a1 100644 --- a/src/util/errors.rs +++ b/src/util/errors.rs @@ -28,11 +28,7 @@ pub trait CargoError: Send + fmt::Display + 'static { fn response(&self) -> Option { if self.human() { Some(json_response(&Bad { - errors: vec![ - StringError { - detail: self.description().to_string(), - }, - ], + errors: vec![StringError { detail: self.description().to_string() }], })) } else { self.cause().and_then(|cause| cause.response()) @@ -237,11 +233,7 @@ impl CargoError for NotFound { fn response(&self) -> Option { let mut response = json_response(&Bad { - errors: vec![ - StringError { - detail: "Not Found".to_string(), - }, - ], + errors: vec![StringError { detail: "Not Found".to_string() }], }); response.status = (404, "Not Found"); Some(response) @@ -290,11 +282,7 @@ impl CargoError for BadRequest { fn response(&self) -> Option { let mut response = json_response(&Bad { - errors: vec![ - StringError { - detail: self.0.clone(), - }, - ], + errors: vec![StringError { detail: self.0.clone() }], }); response.status = (400, "Bad Request"); Some(response) diff --git a/src/util/io_util.rs b/src/util/io_util.rs index fe77100b946..08797f02b60 100644 --- a/src/util/io_util.rs +++ b/src/util/io_util.rs @@ -9,9 +9,7 @@ pub struct LimitErrorReader { impl LimitErrorReader { pub fn new(r: R, limit: u64) -> LimitErrorReader { - LimitErrorReader { - inner: r.take(limit), - } + LimitErrorReader { inner: r.take(limit) } } } @@ -30,7 +28,9 @@ impl Read for LimitErrorReader { pub fn read_le_u32(r: &mut R) -> io::Result { let mut b = [0; 4]; read_fill(r, &mut b)?; - Ok((b[0] as u32) | ((b[1] as u32) << 8) | ((b[2] as u32) << 16) | ((b[3] as u32) << 24)) + Ok( + (b[0] as u32) | ((b[1] as u32) << 8) | ((b[2] as u32) << 16) | ((b[3] as u32) << 24), + ) } pub fn read_fill(r: &mut R, mut slice: &mut [u8]) -> io::Result<()> { diff --git a/src/util/mod.rs b/src/util/mod.rs index 8d7831bce32..3aafc0f13ac 100644 --- a/src/util/mod.rs +++ b/src/util/mod.rs @@ -108,10 +108,12 @@ impl Handler for C { let C(f) = *self; match f(req) { Ok(resp) => Ok(resp), - Err(e) => match e.response() { - Some(response) => Ok(response), - None => Err(std_error(e)), - }, + Err(e) => { + match e.response() { + Some(response) => Ok(response), + None => Err(std_error(e)), + } + } } } } diff --git a/src/util/request_proxy.rs b/src/util/request_proxy.rs index 19bd99393e2..99c0fa54935 100644 --- a/src/util/request_proxy.rs +++ b/src/util/request_proxy.rs @@ -21,9 +21,9 @@ impl<'a> Request for RequestProxy<'a> { self.other.conduit_version() } fn method(&self) -> conduit::Method { - self.method - .clone() - .unwrap_or_else(|| self.other.method().clone()) + self.method.clone().unwrap_or_else( + || self.other.method().clone(), + ) } fn scheme(&self) -> conduit::Scheme { self.other.scheme() diff --git a/src/version/mod.rs b/src/version/mod.rs index 2afd9ce8f35..994f73815d1 100644 --- a/src/version/mod.rs +++ b/src/version/mod.rs @@ -50,7 +50,8 @@ pub struct NewVersion { #[derive(Serialize, Deserialize, Debug)] pub struct EncodableVersion { pub id: i32, - #[serde(rename = "crate")] pub krate: String, + #[serde(rename = "crate")] + pub krate: String, pub num: String, pub dl_path: String, pub readme_path: String, @@ -165,9 +166,9 @@ impl NewVersion { use diesel::expression::dsl::exists; use schema::versions::dsl::*; - let already_uploaded = versions - .filter(crate_id.eq(self.crate_id)) - .filter(num.eq(&self.num)); + let already_uploaded = versions.filter(crate_id.eq(self.crate_id)).filter( + num.eq(&self.num), + ); if select(exists(already_uploaded)).get_result(conn)? { return Err(human(&format_args!( "crate version `{}` is already \ @@ -189,9 +190,9 @@ impl NewVersion { }) .collect::>(); - insert(&new_authors) - .into(version_authors::table) - .execute(conn)?; + insert(&new_authors).into(version_authors::table).execute( + conn, + )?; Ok(version) }) } @@ -227,18 +228,16 @@ struct NewAuthor<'a> { impl Queryable for Version { #[cfg_attr(feature = "clippy", allow(type_complexity))] - type Row = ( - i32, - i32, - String, - NaiveDateTime, - NaiveDateTime, - i32, - Option, - bool, - Option, - Option, - ); + type Row = (i32, + i32, + String, + NaiveDateTime, + NaiveDateTime, + i32, + Option, + bool, + Option, + Option); fn build(row: Self::Row) -> Self { let features = row.6 @@ -310,9 +309,7 @@ pub fn show(req: &mut Request) -> CargoResult { struct R { version: EncodableVersion, } - Ok(req.json(&R { - version: version.encodable(&krate.name), - })) + Ok(req.json(&R { version: version.encodable(&krate.name) })) } fn version_and_crate(req: &mut Request) -> CargoResult<(Version, Crate)> { @@ -363,7 +360,9 @@ pub fn downloads(req: &mut Request) -> CargoResult { let cutoff_start_date = cutoff_end_date - Duration::days(89); let downloads = VersionDownload::belonging_to(&version) - .filter(version_downloads::date.between(cutoff_start_date..cutoff_end_date)) + .filter(version_downloads::date.between( + cutoff_start_date..cutoff_end_date, + )) .order(version_downloads::date) .load(&*conn)? .into_iter() @@ -374,9 +373,7 @@ pub fn downloads(req: &mut Request) -> CargoResult { struct R { version_downloads: Vec, } - Ok(req.json(&R { - version_downloads: downloads, - })) + Ok(req.json(&R { version_downloads: downloads })) } /// Handles the `GET /crates/:crate_id/:version/authors` route. From 31331a47ebcf9102f389ba4c34f4c6f488cd58ba Mon Sep 17 00:00:00 2001 From: Natalie Boehm Date: Fri, 6 Oct 2017 13:40:02 -0400 Subject: [PATCH 17/19] add link to pending invites route --- app/templates/application.hbs | 1 + 1 file changed, 1 insertion(+) diff --git a/app/templates/application.hbs b/app/templates/application.hbs index 297729e8673..74b4a1a290f 100644 --- a/app/templates/application.hbs +++ b/app/templates/application.hbs @@ -65,6 +65,7 @@ {{#rl-dropdown tagName="ul" class="dropdown current-user-links" closeOnChildClick="a:link"}}
  • {{#link-to 'dashboard'}}Dashboard{{/link-to}}
  • {{#link-to 'me'}}Account Settings{{/link-to}}
    • +
  • {{#link-to 'me.pending-invites'}}Owner Invites{{/link-to}}
  • {{#link-to 'logout'}}Sign Out{{/link-to}}
    • {{/rl-dropdown}} {{/rl-dropdown-container}} From d771e1f28711906d3569611b10d9eb7a07f33ef1 Mon Sep 17 00:00:00 2001 From: "Carol (Nichols || Goulding)" Date: Fri, 6 Oct 2017 15:35:33 -0400 Subject: [PATCH 18/19] Run rustfmt-nightly 0.2.7 --- build.rs | 5 +- src/badge.rs | 3 +- src/bin/populate.rs | 6 +- src/bin/render-readmes.rs | 38 ++--- src/bin/transfer-crates.rs | 4 +- src/bin/update-downloads.rs | 20 +-- src/boot/categories.rs | 4 +- src/category.rs | 8 +- src/crate_owner_invitation.rs | 21 ++- src/dependency.rs | 32 ++-- src/download.rs | 5 +- src/email.rs | 4 +- src/git.rs | 22 +-- src/github.rs | 6 +- src/http.rs | 8 +- src/keyword.rs | 16 +- src/krate/mod.rs | 236 +++++++++++++------------- src/owner.rs | 44 +++-- src/render.rs | 4 +- src/tests/all.rs | 37 ++--- src/tests/badge.rs | 45 +++-- src/tests/category.rs | 4 +- src/tests/git.rs | 9 +- src/tests/krate.rs | 304 +++++++++++++++++++++------------- src/tests/owners.rs | 13 +- src/tests/record.rs | 12 +- src/tests/schema_details.rs | 20 +-- src/tests/team.rs | 36 ++-- src/tests/user.rs | 72 +++----- src/tests/version.rs | 4 +- src/token.rs | 34 ++-- src/uploaders.rs | 4 +- src/user/middleware.rs | 17 +- src/user/mod.rs | 61 ++++--- src/util/errors.rs | 18 +- src/util/io_util.rs | 8 +- src/util/mod.rs | 10 +- src/util/request_proxy.rs | 6 +- src/version/mod.rs | 49 +++--- 39 files changed, 628 insertions(+), 621 deletions(-) diff --git a/build.rs b/build.rs index 768f9792038..c5d29ee8801 100644 --- a/build.rs +++ b/build.rs @@ -13,9 +13,8 @@ fn main() { if env::var("PROFILE") == Ok("debug".into()) { let _ = dotenv(); if let Ok(database_url) = env::var("TEST_DATABASE_URL") { - let connection = PgConnection::establish(&database_url).expect( - "Could not connect to TEST_DATABASE_URL", - ); + let connection = PgConnection::establish(&database_url) + .expect("Could not connect to TEST_DATABASE_URL"); run_pending_migrations(&connection).expect("Error running migrations"); } } diff --git a/src/badge.rs b/src/badge.rs index a4918f85f68..89b35716ea6 100644 --- a/src/badge.rs +++ b/src/badge.rs @@ -111,8 +111,7 @@ impl Badge { } conn.transaction(|| { - delete(badges::table.filter(badges::crate_id.eq(krate.id))) - .execute(conn)?; + delete(badges::table.filter(badges::crate_id.eq(krate.id))).execute(conn)?; insert(&new_badges).into(badges::table).execute(conn)?; Ok(invalid_badges) }) diff --git a/src/bin/populate.rs b/src/bin/populate.rs index 836606620b1..43dee66f6fb 100644 --- a/src/bin/populate.rs +++ b/src/bin/populate.rs @@ -27,9 +27,9 @@ fn main() { } fn update(conn: &PgConnection) -> QueryResult<()> { - let ids = env::args().skip(1).filter_map( - |arg| arg.parse::().ok(), - ); + let ids = env::args() + .skip(1) + .filter_map(|arg| arg.parse::().ok()); for id in ids { let mut rng = StdRng::new().unwrap(); let mut dls = rng.gen_range(5000i32, 10000); diff --git a/src/bin/render-readmes.rs b/src/bin/render-readmes.rs index 7d95739cf2d..6c4d58aa685 100644 --- a/src/bin/render-readmes.rs +++ b/src/bin/render-readmes.rs @@ -65,9 +65,8 @@ fn main() { let start_time = Utc::now(); let older_than = if let Some(ref time) = args.flag_older_than { - Utc.datetime_from_str(&time, "%Y-%m-%d %H:%M:%S").expect( - "Could not parse --older-than argument as a time", - ) + Utc.datetime_from_str(&time, "%Y-%m-%d %H:%M:%S") + .expect("Could not parse --older-than argument as a time") } else { start_time }; @@ -78,9 +77,11 @@ fn main() { let mut query = versions::table .inner_join(crates::table) - .filter(versions::readme_rendered_at.lt(older_than).or( - versions::readme_rendered_at.is_null(), - )) + .filter( + versions::readme_rendered_at + .lt(older_than) + .or(versions::readme_rendered_at.is_null()), + ) .select(versions::id) .into_boxed(); @@ -89,9 +90,9 @@ fn main() { query = query.filter(crates::name.eq(crate_name)); } - let version_ids = query.load::<(i32)>(&conn).expect( - "error loading version ids", - ); + let version_ids = query + .load::<(i32)>(&conn) + .expect("error loading version ids"); let total_versions = version_ids.len(); println!("Rendering {} versions", total_versions); @@ -105,12 +106,11 @@ fn main() { total_pages + 1 }; - for (page_num, version_ids_chunk) in - version_ids - .into_iter() - .chunks(page_size) - .into_iter() - .enumerate() + for (page_num, version_ids_chunk) in version_ids + .into_iter() + .chunks(page_size) + .into_iter() + .enumerate() { println!( "= Page {} of {} ==================================", @@ -172,10 +172,10 @@ fn main() { /// Renders the readme of an uploaded crate version. fn get_readme(config: &Config, version: &Version, krate_name: &str) -> Option { let mut handle = Easy::new(); - let location = match config.uploader.crate_location( - &krate_name, - &version.num.to_string(), - ) { + let location = match config + .uploader + .crate_location(&krate_name, &version.num.to_string()) + { Some(l) => l, None => return None, }; diff --git a/src/bin/transfer-crates.rs b/src/bin/transfer-crates.rs index 3d3b93f6875..baa23ab8ec0 100644 --- a/src/bin/transfer-crates.rs +++ b/src/bin/transfer-crates.rs @@ -73,9 +73,7 @@ fn transfer(conn: &PgConnection) { .filter(crate_owners::owner_id.eq(from.id)) .filter(crate_owners::owner_kind.eq(OwnerKind::User as i32)); let crates = Crate::all() - .filter(crates::id.eq_any( - crate_owners.select(crate_owners::crate_id), - )) + .filter(crates::id.eq_any(crate_owners.select(crate_owners::crate_id))) .load::(conn) .unwrap(); diff --git a/src/bin/update-downloads.rs b/src/bin/update-downloads.rs index 49388f193b7..da204529ee2 100644 --- a/src/bin/update-downloads.rs +++ b/src/bin/update-downloads.rs @@ -85,9 +85,7 @@ fn collect(conn: &PgConnection, rows: &[VersionDownload]) -> QueryResult<()> { update(version_downloads::table.find(download.id)) .set(( version_downloads::processed.eq(download.date < cutoff), - version_downloads::counted.eq( - version_downloads::counted + amt, - ), + version_downloads::counted.eq(version_downloads::counted + amt), )) .execute(conn)?; @@ -109,16 +107,8 @@ fn collect(conn: &PgConnection, rows: &[VersionDownload]) -> QueryResult<()> { date: download.date, }; insert(&crate_download.on_conflict( - ( - crate_downloads::crate_id, - crate_downloads::date, - ), - do_update().set( - crate_downloads::downloads.eq( - crate_downloads::downloads + - amt, - ), - ), + (crate_downloads::crate_id, crate_downloads::date), + do_update().set(crate_downloads::downloads.eq(crate_downloads::downloads + amt)), )).into(crate_downloads::table) .execute(conn)?; } @@ -126,9 +116,7 @@ fn collect(conn: &PgConnection, rows: &[VersionDownload]) -> QueryResult<()> { // After everything else is done, update the global counter of total // downloads. update(metadata::table) - .set(metadata::total_downloads.eq( - metadata::total_downloads + total, - )) + .set(metadata::total_downloads.eq(metadata::total_downloads + total)) .execute(conn)?; Ok(()) diff --git a/src/boot/categories.rs b/src/boot/categories.rs index e1682b03141..57cfda69043 100644 --- a/src/boot/categories.rs +++ b/src/boot/categories.rs @@ -122,9 +122,7 @@ pub fn sync_with_connection(toml_str: &str, conn: &PgConnection) -> CargoResult< categories::slug, do_update().set(( categories::category.eq(excluded(categories::category)), - categories::description.eq( - excluded(categories::description), - ), + categories::description.eq(excluded(categories::description)), )), ); diff --git a/src/category.rs b/src/category.rs index 8d65724b039..1e50c9f5d2e 100644 --- a/src/category.rs +++ b/src/category.rs @@ -239,7 +239,9 @@ pub fn show(req: &mut Request) -> CargoResult { struct R { category: EncodableCategoryWithSubcategories, } - Ok(req.json(&R { category: cat_with_subcats })) + Ok(req.json(&R { + category: cat_with_subcats, + })) } /// Handles the `GET /category_slugs` route. @@ -260,7 +262,9 @@ pub fn slugs(req: &mut Request) -> CargoResult { struct R { category_slugs: Vec, } - Ok(req.json(&R { category_slugs: slugs })) + Ok(req.json(&R { + category_slugs: slugs, + })) } #[cfg(test)] diff --git a/src/crate_owner_invitation.rs b/src/crate_owner_invitation.rs index d56f49b6c54..51b3499353a 100644 --- a/src/crate_owner_invitation.rs +++ b/src/crate_owner_invitation.rs @@ -80,7 +80,9 @@ pub fn list(req: &mut Request) -> CargoResult { struct R { crate_owner_invitations: Vec, } - Ok(req.json(&R { crate_owner_invitations })) + Ok(req.json(&R { + crate_owner_invitations, + })) } #[derive(Deserialize)] @@ -102,9 +104,8 @@ pub fn handle_invite(req: &mut Request) -> CargoResult { let mut body = String::new(); req.body().read_to_string(&mut body)?; - let crate_invite: OwnerInvitation = serde_json::from_str(&body).map_err(|_| { - human("invalid json request") - })?; + let crate_invite: OwnerInvitation = + serde_json::from_str(&body).map_err(|_| human("invalid json request"))?; let crate_invite = crate_invite.crate_owner_invite; @@ -120,8 +121,8 @@ fn accept_invite( conn: &PgConnection, crate_invite: InvitationResponse, ) -> CargoResult { - use diesel::{insert, delete}; - use diesel::pg::upsert::{OnConflictExtension, do_update}; + use diesel::{delete, insert}; + use diesel::pg::upsert::{do_update, OnConflictExtension}; let user_id = req.user()?.id; let pending_crate_owner = crate_owner_invitations::table @@ -152,7 +153,9 @@ fn accept_invite( struct R { crate_owner_invitation: InvitationResponse, } - Ok(req.json(&R { crate_owner_invitation: crate_invite })) + Ok(req.json(&R { + crate_owner_invitation: crate_invite, + })) }) } @@ -175,5 +178,7 @@ fn decline_invite( crate_owner_invitation: InvitationResponse, } - Ok(req.json(&R { crate_owner_invitation: crate_invite })) + Ok(req.json(&R { + crate_owner_invitation: crate_invite, + })) } diff --git a/src/dependency.rs b/src/dependency.rs index 8cdc9767b2d..00d8018c7fa 100644 --- a/src/dependency.rs +++ b/src/dependency.rs @@ -88,10 +88,8 @@ impl Dependency { impl ReverseDependency { pub fn encodable(self, crate_name: &str) -> EncodableDependency { - self.dependency.encodable( - crate_name, - Some(self.crate_downloads), - ) + self.dependency + .encodable(crate_name, Some(self.crate_downloads)) } } @@ -104,11 +102,11 @@ pub fn add_dependencies( let git_and_new_dependencies = deps.iter() .map(|dep| { - let krate = Crate::by_name(&dep.name).first::(&*conn).map_err( - |_| { + let krate = Crate::by_name(&dep.name) + .first::(&*conn) + .map_err(|_| { human(&format_args!("no known crate named `{}`", &*dep.name)) - }, - )?; + })?; if dep.version_req == semver::VersionReq::parse("*").unwrap() { return Err(human( "wildcard (`*`) dependency constraints are not allowed \ @@ -154,7 +152,17 @@ pub fn add_dependencies( } impl Queryable for Dependency { - type Row = (i32, i32, i32, String, bool, bool, Vec, Option, i32); + type Row = ( + i32, + i32, + i32, + String, + bool, + bool, + Vec, + Option, + i32, + ); fn build(row: Self::Row) -> Self { Dependency { @@ -178,7 +186,11 @@ impl Queryable for Dependency { // FIXME: We can derive this in the next release of Diesel impl Queryable<(dependencies::SqlType, Integer, Text), Pg> for ReverseDependency { - type Row = (>::Row, i32, String); + type Row = ( + >::Row, + i32, + String, + ); fn build((dep_row, downloads, _name): Self::Row) -> Self { ReverseDependency { diff --git a/src/download.rs b/src/download.rs index 30200b87594..4eae51b134c 100644 --- a/src/download.rs +++ b/src/download.rs @@ -18,10 +18,7 @@ pub struct VersionDownload { #[derive(Insertable, Debug, Clone, Copy)] #[table_name = "version_downloads"] -struct NewVersionDownload( - #[column_name(version_id)] - i32 -); +struct NewVersionDownload(#[column_name(version_id)] i32); #[derive(Serialize, Deserialize, Debug)] pub struct EncodableVersionDownload { diff --git a/src/email.rs b/src/email.rs index c15b9bd58a8..87a954ef857 100644 --- a/src/email.rs +++ b/src/email.rs @@ -74,9 +74,7 @@ pub fn send_email(recipient: &str, subject: &str, body: &str) -> CargoResult<()> None => { let mut sender = FileEmailTransport::new(Path::new("/tmp")); let result = sender.send(email.clone()); - result.map_err( - |_| bad_request("Email file could not be generated"), - )?; + result.map_err(|_| bad_request("Email file could not be generated"))?; } } diff --git a/src/git.rs b/src/git.rs index 494e2b7c02f..996b6e5bd07 100644 --- a/src/git.rs +++ b/src/git.rs @@ -56,9 +56,7 @@ pub fn add_crate(app: &App, krate: &Crate) -> CargoResult<()> { fs::create_dir_all(dst.parent().unwrap())?; let mut prev = String::new(); if fs::metadata(&dst).is_ok() { - File::open(&dst).and_then( - |mut f| f.read_to_string(&mut prev), - )?; + File::open(&dst).and_then(|mut f| f.read_to_string(&mut prev))?; } let s = serde_json::to_string(krate).unwrap(); let new = prev + &s; @@ -84,14 +82,11 @@ pub fn yank(app: &App, krate: &str, version: &semver::Version, yanked: bool) -> commit_and_push(&repo, || { let mut prev = String::new(); - File::open(&dst).and_then( - |mut f| f.read_to_string(&mut prev), - )?; + File::open(&dst).and_then(|mut f| f.read_to_string(&mut prev))?; let new = prev.lines() .map(|line| { - let mut git_crate = serde_json::from_str::(line).map_err(|_| { - internal(&format_args!("couldn't decode: `{}`", line)) - })?; + let mut git_crate = serde_json::from_str::(line) + .map_err(|_| internal(&format_args!("couldn't decode: `{}`", line)))?; if git_crate.name != krate || git_crate.vers != version.to_string() { return Ok(line.to_string()); } @@ -160,14 +155,7 @@ where let head = repo.head()?; let parent = repo.find_commit(head.target().unwrap())?; let sig = repo.signature()?; - repo.commit( - Some("HEAD"), - &sig, - &sig, - &msg, - &tree, - &[&parent], - )?; + repo.commit(Some("HEAD"), &sig, &sig, &msg, &tree, &[&parent])?; // git push let mut ref_status = None; diff --git a/src/github.rs b/src/github.rs index 562c15a5e04..e47a46736a0 100644 --- a/src/github.rs +++ b/src/github.rs @@ -78,9 +78,9 @@ pub fn parse_github_response<'de, 'a: 'de, T: Deserialize<'de>>( } } - let json = str::from_utf8(data).ok().chain_error(|| { - internal("github didn't send a utf8-response") - })?; + let json = str::from_utf8(data) + .ok() + .chain_error(|| internal("github didn't send a utf8-response"))?; serde_json::from_str(json).chain_error(|| internal("github didn't send a valid json response")) } diff --git a/src/http.rs b/src/http.rs index fe48c02f8dd..7bcadef7637 100644 --- a/src/http.rs +++ b/src/http.rs @@ -26,12 +26,10 @@ impl SecurityHeadersMiddleware { let s3_host = match *uploader { Uploader::S3 { ref bucket, .. } => bucket.host(), - _ => { - unreachable!( - "This middleware should only be used in the production environment, \ + _ => unreachable!( + "This middleware should only be used in the production environment, \ which should also require an S3 uploader, QED" - ) - } + ), }; // It would be better if we didn't have to have 'unsafe-eval' in the `script-src` diff --git a/src/keyword.rs b/src/keyword.rs index 202ab597915..00ca723b64d 100644 --- a/src/keyword.rs +++ b/src/keyword.rs @@ -77,10 +77,10 @@ impl Keyword { if name.is_empty() { return false; } - name.chars().next().unwrap().is_alphanumeric() && - name.chars().all( - |c| c.is_alphanumeric() || c == '_' || c == '-', - ) && name.chars().all(|c| c.is_ascii()) + name.chars().next().unwrap().is_alphanumeric() + && name.chars() + .all(|c| c.is_alphanumeric() || c == '_' || c == '-') + && name.chars().all(|c| c.is_ascii()) } pub fn encodable(self) -> EncodableKeyword { @@ -101,9 +101,7 @@ impl Keyword { pub fn update_crate(conn: &PgConnection, krate: &Crate, keywords: &[&str]) -> QueryResult<()> { conn.transaction(|| { let keywords = Keyword::find_or_create_all(conn, keywords)?; - diesel::delete(CrateKeyword::belonging_to(krate)).execute( - conn, - )?; + diesel::delete(CrateKeyword::belonging_to(krate)).execute(conn)?; let crate_keywords = keywords .into_iter() .map(|kw| { @@ -171,7 +169,9 @@ pub fn show(req: &mut Request) -> CargoResult { struct R { keyword: EncodableKeyword, } - Ok(req.json(&R { keyword: kw.encodable() })) + Ok(req.json(&R { + keyword: kw.encodable(), + })) } #[cfg(test)] diff --git a/src/krate/mod.rs b/src/krate/mod.rs index 3238d8a7b42..4c547bc071e 100644 --- a/src/krate/mod.rs +++ b/src/krate/mod.rs @@ -25,8 +25,8 @@ use db::RequestTransaction; use dependency::{self, EncodableDependency, ReverseDependency}; use download::{EncodableVersionDownload, VersionDownload}; use git; -use keyword::{EncodableKeyword, CrateKeyword}; -use owner::{EncodableOwner, Owner, Rights, OwnerKind, Team, rights, CrateOwner}; +use keyword::{CrateKeyword, EncodableKeyword}; +use owner::{rights, CrateOwner, EncodableOwner, Owner, OwnerKind, Rights, Team}; use crate_owner_invitation::NewCrateOwnerInvitation; use pagination::Paginate; use render; @@ -70,18 +70,20 @@ pub struct Crate { /// We literally never want to select `textsearchable_index_col` /// so we provide this type and constant to pass to `.select` -type AllColumns = (crates::id, - crates::name, - crates::updated_at, - crates::created_at, - crates::downloads, - crates::description, - crates::homepage, - crates::documentation, - crates::readme, - crates::license, - crates::repository, - crates::max_upload_size); +type AllColumns = ( + crates::id, + crates::name, + crates::updated_at, + crates::created_at, + crates::downloads, + crates::description, + crates::homepage, + crates::documentation, + crates::readme, + crates::license, + crates::repository, + crates::max_upload_size, +); pub const ALL_COLUMNS: AllColumns = ( crates::id, @@ -166,9 +168,8 @@ impl<'a> NewCrate<'a> { return Ok(krate); } - let target = crates::table.filter(canon_crate_name(crates::name).eq( - canon_crate_name(self.name), - )); + let target = crates::table + .filter(canon_crate_name(crates::name).eq(canon_crate_name(self.name))); update(target) .set(&self) .returning(ALL_COLUMNS) @@ -242,11 +243,7 @@ impl<'a> NewCrate<'a> { use diesel::expression::dsl::exists; let reserved_name = select(exists( - reserved_crate_names.filter(canon_crate_name(name).eq( - canon_crate_name( - self.name, - ), - )), + reserved_crate_names.filter(canon_crate_name(name).eq(canon_crate_name(self.name))), )).get_result::(conn)?; if reserved_name { Err(human("cannot upload a crate with a reserved name")) @@ -301,10 +298,10 @@ impl Crate { if name.is_empty() { return false; } - name.chars().next().unwrap().is_alphabetic() && - name.chars().all( - |c| c.is_alphanumeric() || c == '_' || c == '-', - ) && name.chars().all(|c| c.is_ascii()) + name.chars().next().unwrap().is_alphabetic() + && name.chars() + .all(|c| c.is_alphanumeric() || c == '_' || c == '-') + && name.chars().all(|c| c.is_ascii()) } pub fn valid_feature_name(name: &str) -> bool { @@ -467,24 +464,20 @@ impl Crate { ) -> CargoResult { let owner = match Owner::find_by_login(conn, login) { Ok(owner @ Owner::User(_)) => owner, - Ok(Owner::Team(team)) => { - if team.contains_user(app, req_user)? { - Owner::Team(team) - } else { - return Err(human(&format_args!( - "only members of {} can add it as \ + Ok(Owner::Team(team)) => if team.contains_user(app, req_user)? { + Owner::Team(team) + } else { + return Err(human(&format_args!( + "only members of {} can add it as \ an owner", - login - ))); - } - } - Err(err) => { - if login.contains(':') { - Owner::Team(Team::create(app, conn, login, req_user)?) - } else { - return Err(err); - } - } + login + ))); + }, + Err(err) => if login.contains(':') { + Owner::Team(Team::create(app, conn, login, req_user)?) + } else { + return Err(err); + }, }; let owner_invitation = NewCrateOwnerInvitation { @@ -521,9 +514,9 @@ impl Crate { } pub fn badges(&self, conn: &PgConnection) -> QueryResult> { - badges::table.filter(badges::crate_id.eq(self.id)).load( - conn, - ) + badges::table + .filter(badges::crate_id.eq(self.id)) + .load(conn) } /// Returns (dependency, dependent crate name, dependent crate downloads) @@ -579,18 +572,21 @@ pub fn index(req: &mut Request) -> CargoResult { let conn = req.db_conn()?; let (offset, limit) = req.pagination(10, 100)?; let params = req.query(); - let sort = params.get("sort").map(|s| &**s).unwrap_or( - "recent-downloads", - ); + let sort = params + .get("sort") + .map(|s| &**s) + .unwrap_or("recent-downloads"); let recent_downloads = sql::>("SUM(crate_downloads.downloads)"); let mut query = crates::table - .left_join(crate_downloads::table.on( - crates::id.eq(crate_downloads::crate_id).and( - crate_downloads::date.gt(date(now - 90.days())), + .left_join( + crate_downloads::table.on( + crates::id + .eq(crate_downloads::crate_id) + .and(crate_downloads::date.gt(date(now - 90.days()))), ), - )) + ) .group_by(crates::id) .select(( ALL_COLUMNS, @@ -610,11 +606,10 @@ pub fn index(req: &mut Request) -> CargoResult { if let Some(q_string) = params.get("q") { let sort = params.get("sort").map(|s| &**s).unwrap_or("relevance"); let q = plainto_tsquery(q_string); - query = query.filter(q.matches(crates::textsearchable_index_col).or( - crates::name.eq( - q_string, - ), - )); + query = query.filter( + q.matches(crates::textsearchable_index_col) + .or(crates::name.eq(q_string)), + ); query = query.select(( ALL_COLUMNS, @@ -641,10 +636,11 @@ pub fn index(req: &mut Request) -> CargoResult { crates_categories::table .select(crates_categories::crate_id) .inner_join(categories::table) - .filter(categories::slug.eq(cat).or(categories::slug.like(format!( - "{}::%", - cat - )))), + .filter( + categories::slug + .eq(cat) + .or(categories::slug.like(format!("{}::%", cat))), + ), ), ); } @@ -690,11 +686,13 @@ pub fn index(req: &mut Request) -> CargoResult { ), ); } else if params.get("following").is_some() { - query = query.filter(crates::id.eq_any( - follows::table.select(follows::crate_id).filter( - follows::user_id.eq(req.user()?.id), + query = query.filter( + crates::id.eq_any( + follows::table + .select(follows::crate_id) + .filter(follows::user_id.eq(req.user()?.id)), ), - )); + ); } // The database query returns a tuple within a tuple , with the root @@ -725,20 +723,21 @@ pub fn index(req: &mut Request) -> CargoResult { .zip(crates) .zip(perfect_matches) .zip(recent_downloads) - .map(|(((max_version, krate), perfect_match), - recent_downloads)| { - // FIXME: If we add crate_id to the Badge enum we can eliminate - // this N+1 - let badges = badges::table - .filter(badges::crate_id.eq(krate.id)) - .load::(&*conn)?; - Ok(krate.minimal_encodable( - max_version, - Some(badges), - perfect_match, - Some(recent_downloads), - )) - }) + .map( + |(((max_version, krate), perfect_match), recent_downloads)| { + // FIXME: If we add crate_id to the Badge enum we can eliminate + // this N+1 + let badges = badges::table + .filter(badges::crate_id.eq(krate.id)) + .load::(&*conn)?; + Ok(krate.minimal_encodable( + max_version, + Some(badges), + perfect_match, + Some(recent_downloads), + )) + }, + ) .collect::>()?; #[derive(Serialize)] @@ -857,15 +856,14 @@ pub fn show(req: &mut Request) -> CargoResult { .select(sum(crate_downloads::downloads)) .get_result(&*conn)?; - let badges = badges::table.filter(badges::crate_id.eq(krate.id)).load( - &*conn, - )?; + let badges = badges::table + .filter(badges::crate_id.eq(krate.id)) + .load(&*conn)?; let max_version = krate.max_version(&conn)?; #[derive(Serialize)] struct R { - #[serde(rename = "crate")] - krate: EncodableCrate, + #[serde(rename = "crate")] krate: EncodableCrate, versions: Vec, keywords: Vec, categories: Vec, @@ -958,13 +956,12 @@ pub fn new(req: &mut Request) -> CargoResult { )); } - let length = req.content_length().chain_error(|| { - human("missing header: Content-Length") - })?; - let max = krate.max_upload_size.map(|m| m as u64).unwrap_or( - app.config - .max_upload_size, - ); + let length = req.content_length() + .chain_error(|| human("missing header: Content-Length"))?; + let max = krate + .max_upload_size + .map(|m| m as u64) + .unwrap_or(app.config.max_upload_size); if length > max { return Err(human(&format_args!("max upload size is: {}", max))); } @@ -1000,13 +997,10 @@ pub fn new(req: &mut Request) -> CargoResult { // Upload the crate, return way to delete the crate from the server // If the git commands fail below, we shouldn't keep the crate on the // server. - let (cksum, mut crate_bomb, mut readme_bomb) = app.config.uploader.upload_crate( - req, - &krate, - readme, - max, - vers, - )?; + let (cksum, mut crate_bomb, mut readme_bomb) = + app.config + .uploader + .upload_crate(req, &krate, readme, max, vers)?; version.record_readme_rendering(&conn)?; // Register this crate in our local git repo. @@ -1041,8 +1035,7 @@ pub fn new(req: &mut Request) -> CargoResult { #[derive(Serialize)] struct R<'a> { - #[serde(rename = "crate")] - krate: EncodableCrate, + #[serde(rename = "crate")] krate: EncodableCrate, warnings: Warnings<'a>, } Ok(req.json(&R { @@ -1066,12 +1059,9 @@ fn parse_new_headers(req: &mut Request) -> CargoResult<(upload::NewCrate, User)> } let mut json = vec![0; amt as usize]; read_fill(req.body(), &mut json)?; - let json = String::from_utf8(json).map_err(|_| { - human("json body was not valid utf-8") - })?; - let new: upload::NewCrate = serde_json::from_str(&json).map_err(|e| { - human(&format_args!("invalid upload request: {}", e)) - })?; + let json = String::from_utf8(json).map_err(|_| human("json body was not valid utf-8"))?; + let new: upload::NewCrate = serde_json::from_str(&json) + .map_err(|e| human(&format_args!("invalid upload request: {}", e)))?; // Make sure required fields are provided fn empty(s: Option<&String>) -> bool { @@ -1162,9 +1152,7 @@ fn increment_download_counts(req: &Request, crate_name: &str, version: &str) -> let conn = req.db_conn()?; let version_id = versions .select(id) - .filter(crate_id.eq_any( - Crate::by_name(crate_name).select(crates::id), - )) + .filter(crate_id.eq_any(Crate::by_name(crate_name).select(crates::id))) .filter(num.eq(version)) .first(&*conn)?; @@ -1218,7 +1206,9 @@ pub fn downloads(req: &mut Request) -> CargoResult { struct Meta { extra_downloads: Vec, } - let meta = Meta { extra_downloads: extra }; + let meta = Meta { + extra_downloads: extra, + }; Ok(req.json(&R { version_downloads: downloads, meta: meta, @@ -1277,13 +1267,14 @@ pub fn following(req: &mut Request) -> CargoResult { let follow = follow_target(req)?; let conn = req.db_conn()?; - let following = diesel::select(exists(follows::table.find(follow.id()))) - .get_result(&*conn)?; + let following = diesel::select(exists(follows::table.find(follow.id()))).get_result(&*conn)?; #[derive(Serialize)] struct R { following: bool, } - Ok(req.json(&R { following: following })) + Ok(req.json(&R { + following: following, + })) } /// Handles the `GET /crates/:crate_id/versions` route. @@ -1374,9 +1365,7 @@ fn modify_owners(req: &mut Request, add: bool) -> CargoResult { req.body().read_to_string(&mut body)?; let user = req.user()?; let conn = req.db_conn()?; - let krate = Crate::by_name(&req.params()["crate_id"]).first::( - &*conn, - )?; + let krate = Crate::by_name(&req.params()["crate_id"]).first::(&*conn)?; let owners = krate.owners(&conn)?; match rights(req.app(), &owners, user)? { @@ -1397,13 +1386,12 @@ fn modify_owners(req: &mut Request, add: bool) -> CargoResult { owners: Option>, } - 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.or(request.users).ok_or_else(|| { - human("invalid json request") - })?; + let logins = request + .owners + .or(request.users) + .ok_or_else(|| human("invalid json request"))?; let mut msgs = Vec::new(); @@ -1515,7 +1503,7 @@ mod tests { assert_eq!( Crate::remove_blacklisted_documentation_urls(Some(String::from( "http://rust-ci.org/crate/crate-0.1/doc/crate-0.1", - ))), + ),),), None ); } diff --git a/src/owner.rs b/src/owner.rs index 5e03cf22bcf..85f3b7fb3b9 100644 --- a/src/owner.rs +++ b/src/owner.rs @@ -176,8 +176,8 @@ impl Team { #[derive(Deserialize)] struct GithubTeam { - slug: String, // the name we want to find - id: i32, // unique GH id (needed for membership queries) + slug: String, // the name we want to find + id: i32, // unique GH id (needed for membership queries) name: Option, // Pretty name } @@ -339,12 +339,12 @@ impl Owner { pub fn encodable(self) -> EncodableOwner { match self { Owner::User(User { - id, - name, - gh_login, - gh_avatar, - .. - }) => { + id, + name, + gh_login, + gh_avatar, + .. + }) => { let url = format!("https://github.com/{}", gh_login); EncodableOwner { id: id, @@ -356,12 +356,12 @@ impl Owner { } } Owner::Team(Team { - id, - name, - login, - avatar, - .. - }) => { + id, + name, + login, + avatar, + .. + }) => { let url = Team::github_url(&login); EncodableOwner { id: id, @@ -388,16 +388,12 @@ pub fn rights(app: &App, owners: &[Owner], user: &User) -> CargoResult { let mut best = Rights::None; for owner in owners { match *owner { - Owner::User(ref other_user) => { - if other_user.id == user.id { - return Ok(Rights::Full); - } - } - Owner::Team(ref team) => { - if team.contains_user(app, user)? { - best = Rights::Publish; - } - } + Owner::User(ref other_user) => if other_user.id == user.id { + return Ok(Rights::Full); + }, + Owner::Team(ref team) => if team.contains_user(app, user)? { + best = Rights::Publish; + }, } } Ok(best) diff --git a/src/render.rs b/src/render.rs index 42d003d55e0..bdc5456ebc1 100644 --- a/src/render.rs +++ b/src/render.rs @@ -102,7 +102,9 @@ impl<'a> MarkdownRenderer<'a> { allowed_classes: allowed_classes, ..Ammonia::default() }; - MarkdownRenderer { html_sanitizer: html_sanitizer } + MarkdownRenderer { + html_sanitizer: html_sanitizer, + } } /// Renders the given markdown to HTML using the current settings. diff --git a/src/tests/all.rs b/src/tests/all.rs index 429e3f25dd7..5da065f5033 100644 --- a/src/tests/all.rs +++ b/src/tests/all.rs @@ -102,8 +102,7 @@ mod version; #[derive(Deserialize, Debug)] struct GoodCrate { - #[serde(rename = "crate")] - krate: EncodableCrate, + #[serde(rename = "crate")] krate: EncodableCrate, warnings: Warnings, } #[derive(Deserialize)] @@ -121,7 +120,11 @@ struct CrateMeta { total: i32, } -fn app() -> (record::Bomb, Arc, conduit_middleware::MiddlewareBuilder) { +fn app() -> ( + record::Bomb, + Arc, + conduit_middleware::MiddlewareBuilder, +) { dotenv::dotenv().ok(); git::init(); @@ -303,8 +306,7 @@ impl<'a> VersionBuilder<'a> { &self.features, license, self.license_file, - )? - .save(connection, &[])?; + )?.save(connection, &[])?; let new_deps = self.dependencies .into_iter() @@ -318,9 +320,9 @@ impl<'a> VersionBuilder<'a> { } }) .collect::>(); - insert(&new_deps).into(dependencies::table).execute( - connection, - )?; + insert(&new_deps) + .into(dependencies::table) + .execute(connection)?; Ok(vers) } @@ -486,9 +488,8 @@ fn krate(name: &str) -> Crate { fn sign_in_as(req: &mut Request, user: &User) { req.mut_extensions().insert(user.clone()); - req.mut_extensions().insert( - AuthenticationSource::SessionCookie, - ); + req.mut_extensions() + .insert(AuthenticationSource::SessionCookie); } fn sign_in(req: &mut Request, app: &App) -> User { @@ -683,14 +684,12 @@ fn new_crate_to_body(new_crate: &u::NewCrate, files: &[(&str, &[u8])]) -> Vec> 0) as u8, - (tarball.len() >> 8) as u8, - (tarball.len() >> 16) as u8, - (tarball.len() >> 24) as u8, - ], - ); + body.extend(&[ + (tarball.len() >> 0) as u8, + (tarball.len() >> 8) as u8, + (tarball.len() >> 16) as u8, + (tarball.len() >> 24) as u8, + ]); body.extend(tarball); body } diff --git a/src/tests/badge.rs b/src/tests/badge.rs index 515be0d7f67..95b954db4a8 100644 --- a/src/tests/badge.rs +++ b/src/tests/badge.rs @@ -61,25 +61,19 @@ fn set_up() -> (Arc, Crate, BadgeRef) { badge_attributes_gitlab.insert(String::from("branch"), String::from("beta")); badge_attributes_gitlab.insert(String::from("repository"), String::from("rust-lang/rust")); - let isitmaintained_issue_resolution = - Badge::IsItMaintainedIssueResolution { repository: String::from("rust-lang/rust") }; + let isitmaintained_issue_resolution = Badge::IsItMaintainedIssueResolution { + repository: String::from("rust-lang/rust"), + }; let mut badge_attributes_isitmaintained_issue_resolution = HashMap::new(); - badge_attributes_isitmaintained_issue_resolution.insert( - String::from("repository"), - String::from("rust-lang/rust"), - ); + badge_attributes_isitmaintained_issue_resolution + .insert(String::from("repository"), String::from("rust-lang/rust")); - let isitmaintained_open_issues = - Badge::IsItMaintainedOpenIssues { repository: String::from("rust-lang/rust") }; + let isitmaintained_open_issues = Badge::IsItMaintainedOpenIssues { + repository: String::from("rust-lang/rust"), + }; let mut badge_attributes_isitmaintained_open_issues = HashMap::new(); - badge_attributes_isitmaintained_open_issues.insert( - String::from( - "repository", - ), - String::from( - "rust-lang/rust", - ), - ); + badge_attributes_isitmaintained_open_issues + .insert(String::from("repository"), String::from("rust-lang/rust")); let codecov = Badge::Codecov { service: Some(String::from("github")), @@ -109,7 +103,9 @@ fn set_up() -> (Arc, Crate, BadgeRef) { badge_attributes_circle_ci.insert(String::from("branch"), String::from("beta")); badge_attributes_circle_ci.insert(String::from("repository"), String::from("rust-lang/rust")); - let maintenance = Badge::Maintenance { status: MaintenanceStatus::LookingForMaintainer }; + let maintenance = Badge::Maintenance { + status: MaintenanceStatus::LookingForMaintainer, + }; let mut maintenance_attributes = HashMap::new(); maintenance_attributes.insert( String::from("status"), @@ -439,9 +435,9 @@ fn isitmaintained_open_issues_required_keys() { let mut badges = HashMap::new(); // Repository is a required key - test_badges.isitmaintained_open_issues_attributes.remove( - "repository", - ); + test_badges + .isitmaintained_open_issues_attributes + .remove("repository"); badges.insert( String::from("isitmaintained_open_issues"), test_badges.isitmaintained_open_issues_attributes, @@ -537,12 +533,9 @@ fn maintenance_invalid_values() { let mut badges = HashMap::new(); // "totes broken" is not a recognized value - test_badges.maintenance_attributes.insert( - String::from("status"), - String::from( - "totes broken", - ), - ); + test_badges + .maintenance_attributes + .insert(String::from("status"), String::from("totes broken")); badges.insert( String::from("maintenance"), test_badges.maintenance_attributes, diff --git a/src/tests/category.rs b/src/tests/category.rs index 377642fa5b2..5fda3fb80df 100644 --- a/src/tests/category.rs +++ b/src/tests/category.rs @@ -157,9 +157,7 @@ fn update_crate() { // Add a category and its subcategory { let conn = t!(app.diesel_database.get()); - t!(::new_category("cat1::bar", "cat1::bar").create_or_update( - &conn, - )); + t!(::new_category("cat1::bar", "cat1::bar").create_or_update(&conn,)); Category::update_crate(&conn, &krate, &["cat1", "cat1::bar"]).unwrap(); } assert_eq!(cnt!(&mut req, "cat1"), 1); diff --git a/src/tests/git.rs b/src/tests/git.rs index 3b26cd18c2e..9ae8bc8cfcf 100644 --- a/src/tests/git.rs +++ b/src/tests/git.rs @@ -8,11 +8,10 @@ use git2; use url::Url; fn root() -> PathBuf { - env::current_dir().unwrap().join("tmp").join( - thread::current() - .name() - .unwrap(), - ) + env::current_dir() + .unwrap() + .join("tmp") + .join(thread::current().name().unwrap()) } pub fn checkout() -> PathBuf { diff --git a/src/tests/krate.rs b/src/tests/krate.rs index 494a1138a6d..ad8e901df49 100644 --- a/src/tests/krate.rs +++ b/src/tests/krate.rs @@ -32,8 +32,7 @@ struct VersionsList { } #[derive(Deserialize)] struct CrateResponse { - #[serde(rename = "crate")] - krate: EncodableCrate, + #[serde(rename = "crate")] krate: EncodableCrate, versions: Vec, keywords: Vec, } @@ -238,9 +237,7 @@ fn exact_match_first_on_queries() { .expect_build(&conn); ::CrateBuilder::new("baz_exact", user.id) - .description( - "foo_exact bar_exact foo_exact bar_exact foo_exact bar_exact", - ) + .description("foo_exact bar_exact foo_exact bar_exact foo_exact bar_exact") .expect_build(&conn); ::CrateBuilder::new("other_exact", user.id) @@ -293,9 +290,7 @@ fn exact_match_on_queries_with_sort() { .expect_build(&conn); ::CrateBuilder::new("baz_sort", user.id) - .description( - "foo_sort bar_sort foo_sort bar_sort foo_sort bar_sort const", - ) + .description("foo_sort bar_sort foo_sort bar_sort foo_sort bar_sort const") .downloads(100000) .recent_downloads(10) .expect_build(&conn); @@ -338,9 +333,7 @@ fn exact_match_on_queries_with_sort() { assert_eq!(json.crates[3].name, "foo_sort"); // Sort by recent-downloads - let mut response = ok_resp!(middle.call( - req.with_query("q=bar_sort&sort=recent-downloads"), - )); + let mut response = ok_resp!(middle.call(req.with_query("q=bar_sort&sort=recent-downloads"),)); let json: CrateList = ::json(&mut response); assert_eq!(json.meta.total, 3); assert_eq!(json.crates[0].name, "bar_sort"); @@ -504,9 +497,9 @@ fn new_bd_names() { ::sign_in(&mut req, &app); let json = bad_resp!(middle.call(&mut req)); assert!( - json.errors[0].detail.contains( - "expected a valid crate name", - ), + json.errors[0] + .detail + .contains("expected a valid crate name",), "{:?}", json.errors ); @@ -553,9 +546,11 @@ fn new_krate_with_reserved_name() { let mut req = ::new_req(app.clone(), name, "1.0.0"); ::sign_in(&mut req, &app); let json = bad_resp!(middle.call(&mut req)); - assert!(json.errors[0].detail.contains( - "cannot upload a crate with a reserved name", - )); + assert!( + json.errors[0] + .detail + .contains("cannot upload a crate with a reserved name",) + ); } test_bad_name("std"); @@ -704,9 +699,9 @@ fn new_krate_wrong_user() { let json = bad_resp!(middle.call(&mut req)); assert!( - json.errors[0].detail.contains( - "this crate exists but you don't seem to be an owner.", - ), + json.errors[0] + .detail + .contains("this crate exists but you don't seem to be an owner.",), "{:?}", json.errors ); @@ -722,9 +717,9 @@ fn new_krate_bad_name() { ::sign_in_as(&mut req, &user); let json = bad_resp!(middle.call(&mut req)); assert!( - json.errors[0].detail.contains( - "expected a valid crate name", - ), + json.errors[0] + .detail + .contains("expected a valid crate name",), "{:?}", json.errors ); @@ -734,9 +729,9 @@ fn new_krate_bad_name() { ::sign_in_as(&mut req, &user); let json = bad_resp!(middle.call(&mut req)); assert!( - json.errors[0].detail.contains( - "expected a valid crate name", - ), + json.errors[0] + .detail + .contains("expected a valid crate name",), "{:?}", json.errors ); @@ -962,9 +957,11 @@ fn new_krate_dependency_missing() { ::sign_in(&mut req, &app); let mut response = ok_resp!(middle.call(&mut req)); let json = ::json::<::Bad>(&mut response); - assert!(json.errors[0].detail.contains( - "no known crate named `bar_missing`", - )); + assert!( + json.errors[0] + .detail + .contains("no known crate named `bar_missing`",) + ); } #[test] @@ -1210,15 +1207,21 @@ fn yank() { assert!(contents.contains("\"yanked\":false")); // make sure it's not yanked - let mut r = ok_resp!(middle.call(req.with_method(Method::Get).with_path( - "/api/v1/crates/fyk/1.0.0", - ))); + let mut r = ok_resp!( + middle.call( + req.with_method(Method::Get,) + .with_path("/api/v1/crates/fyk/1.0.0",), + ) + ); assert!(!::json::(&mut r).version.yanked); // yank it - let mut r = ok_resp!(middle.call(req.with_method(Method::Delete).with_path( - "/api/v1/crates/fyk/1.0.0/yank", - ))); + let mut r = ok_resp!( + middle.call( + req.with_method(Method::Delete,) + .with_path("/api/v1/crates/fyk/1.0.0/yank",), + ) + ); assert!(::json::(&mut r).ok); let mut contents = String::new(); File::open(&path) @@ -1226,15 +1229,21 @@ fn yank() { .read_to_string(&mut contents) .unwrap(); assert!(contents.contains("\"yanked\":true")); - let mut r = ok_resp!(middle.call(req.with_method(Method::Get).with_path( - "/api/v1/crates/fyk/1.0.0", - ))); + let mut r = ok_resp!( + middle.call( + req.with_method(Method::Get,) + .with_path("/api/v1/crates/fyk/1.0.0",), + ) + ); assert!(::json::(&mut r).version.yanked); // un-yank it - let mut r = ok_resp!(middle.call(req.with_method(Method::Put).with_path( - "/api/v1/crates/fyk/1.0.0/unyank", - ))); + let mut r = ok_resp!( + middle.call( + req.with_method(Method::Put,) + .with_path("/api/v1/crates/fyk/1.0.0/unyank",), + ) + ); assert!(::json::(&mut r).ok); let mut contents = String::new(); File::open(&path) @@ -1242,9 +1251,12 @@ fn yank() { .read_to_string(&mut contents) .unwrap(); assert!(contents.contains("\"yanked\":false")); - let mut r = ok_resp!(middle.call(req.with_method(Method::Get).with_path( - "/api/v1/crates/fyk/1.0.0", - ))); + let mut r = ok_resp!( + middle.call( + req.with_method(Method::Get,) + .with_path("/api/v1/crates/fyk/1.0.0",), + ) + ); assert!(!::json::(&mut r).version.yanked); } @@ -1253,9 +1265,8 @@ fn yank_not_owner() { let (_b, app, middle) = ::app(); let mut req = ::request_with_user_and_mock_crate(&app, ::new_user("bar"), "foo_not"); ::sign_in(&mut req, &app); - req.with_method(Method::Delete).with_path( - "/api/v1/crates/foo_not/1.0.0/yank", - ); + req.with_method(Method::Delete) + .with_path("/api/v1/crates/foo_not/1.0.0/yank"); let mut response = ok_resp!(middle.call(&mut req)); ::json::<::Bad>(&mut response); } @@ -1290,68 +1301,104 @@ fn yank_max_version() { assert_eq!(json.krate.max_version, "2.0.0"); // yank version 1.0.0 - let mut r = ok_resp!(middle.call(req.with_method(Method::Delete).with_path( - "/api/v1/crates/fyk_max/1.0.0/yank", - ))); + let mut r = ok_resp!( + middle.call( + req.with_method(Method::Delete,) + .with_path("/api/v1/crates/fyk_max/1.0.0/yank",), + ) + ); assert!(::json::(&mut r).ok); - let mut response = ok_resp!(middle.call(req.with_method(Method::Get).with_path( - "/api/v1/crates/fyk_max", - ))); + let mut response = ok_resp!( + middle.call( + req.with_method(Method::Get,) + .with_path("/api/v1/crates/fyk_max",), + ) + ); let json: CrateResponse = ::json(&mut response); assert_eq!(json.krate.max_version, "2.0.0"); // unyank version 1.0.0 - let mut r = ok_resp!(middle.call(req.with_method(Method::Put).with_path( - "/api/v1/crates/fyk_max/1.0.0/unyank", - ))); + let mut r = ok_resp!( + middle.call( + req.with_method(Method::Put,) + .with_path("/api/v1/crates/fyk_max/1.0.0/unyank",), + ) + ); assert!(::json::(&mut r).ok); - let mut response = ok_resp!(middle.call(req.with_method(Method::Get).with_path( - "/api/v1/crates/fyk_max", - ))); + let mut response = ok_resp!( + middle.call( + req.with_method(Method::Get,) + .with_path("/api/v1/crates/fyk_max",), + ) + ); let json: CrateResponse = ::json(&mut response); assert_eq!(json.krate.max_version, "2.0.0"); // yank version 2.0.0 - let mut r = ok_resp!(middle.call(req.with_method(Method::Delete).with_path( - "/api/v1/crates/fyk_max/2.0.0/yank", - ))); + let mut r = ok_resp!( + middle.call( + req.with_method(Method::Delete,) + .with_path("/api/v1/crates/fyk_max/2.0.0/yank",), + ) + ); assert!(::json::(&mut r).ok); - let mut response = ok_resp!(middle.call(req.with_method(Method::Get).with_path( - "/api/v1/crates/fyk_max", - ))); + let mut response = ok_resp!( + middle.call( + req.with_method(Method::Get,) + .with_path("/api/v1/crates/fyk_max",), + ) + ); let json: CrateResponse = ::json(&mut response); assert_eq!(json.krate.max_version, "1.0.0"); // yank version 1.0.0 - let mut r = ok_resp!(middle.call(req.with_method(Method::Delete).with_path( - "/api/v1/crates/fyk_max/1.0.0/yank", - ))); + let mut r = ok_resp!( + middle.call( + req.with_method(Method::Delete,) + .with_path("/api/v1/crates/fyk_max/1.0.0/yank",), + ) + ); assert!(::json::(&mut r).ok); - let mut response = ok_resp!(middle.call(req.with_method(Method::Get).with_path( - "/api/v1/crates/fyk_max", - ))); + let mut response = ok_resp!( + middle.call( + req.with_method(Method::Get,) + .with_path("/api/v1/crates/fyk_max",), + ) + ); let json: CrateResponse = ::json(&mut response); assert_eq!(json.krate.max_version, "0.0.0"); // unyank version 2.0.0 - let mut r = ok_resp!(middle.call(req.with_method(Method::Put).with_path( - "/api/v1/crates/fyk_max/2.0.0/unyank", - ))); + let mut r = ok_resp!( + middle.call( + req.with_method(Method::Put,) + .with_path("/api/v1/crates/fyk_max/2.0.0/unyank",), + ) + ); assert!(::json::(&mut r).ok); - let mut response = ok_resp!(middle.call(req.with_method(Method::Get).with_path( - "/api/v1/crates/fyk_max", - ))); + let mut response = ok_resp!( + middle.call( + req.with_method(Method::Get,) + .with_path("/api/v1/crates/fyk_max",), + ) + ); let json: CrateResponse = ::json(&mut response); assert_eq!(json.krate.max_version, "2.0.0"); // unyank version 1.0.0 - let mut r = ok_resp!(middle.call(req.with_method(Method::Put).with_path( - "/api/v1/crates/fyk_max/1.0.0/unyank", - ))); + let mut r = ok_resp!( + middle.call( + req.with_method(Method::Put,) + .with_path("/api/v1/crates/fyk_max/1.0.0/unyank",), + ) + ); assert!(::json::(&mut r).ok); - let mut response = ok_resp!(middle.call(req.with_method(Method::Get).with_path( - "/api/v1/crates/fyk_max", - ))); + let mut response = ok_resp!( + middle.call( + req.with_method(Method::Get,) + .with_path("/api/v1/crates/fyk_max",), + ) + ); let json: CrateResponse = ::json(&mut response); assert_eq!(json.krate.max_version, "2.0.0"); } @@ -1374,13 +1421,19 @@ fn publish_after_yank_max_version() { assert_eq!(json.krate.max_version, "1.0.0"); // yank version 1.0.0 - let mut r = ok_resp!(middle.call(req.with_method(Method::Delete).with_path( - "/api/v1/crates/fyk_max/1.0.0/yank", - ))); + let mut r = ok_resp!( + middle.call( + req.with_method(Method::Delete,) + .with_path("/api/v1/crates/fyk_max/1.0.0/yank",), + ) + ); assert!(::json::(&mut r).ok); - let mut response = ok_resp!(middle.call(req.with_method(Method::Get).with_path( - "/api/v1/crates/fyk_max", - ))); + let mut response = ok_resp!( + middle.call( + req.with_method(Method::Get,) + .with_path("/api/v1/crates/fyk_max",), + ) + ); let json: CrateResponse = ::json(&mut response); assert_eq!(json.krate.max_version, "0.0.0"); @@ -1397,13 +1450,19 @@ fn publish_after_yank_max_version() { assert_eq!(json.krate.max_version, "2.0.0"); // unyank version 1.0.0 - let mut r = ok_resp!(middle.call(req.with_method(Method::Put).with_path( - "/api/v1/crates/fyk_max/1.0.0/unyank", - ))); + let mut r = ok_resp!( + middle.call( + req.with_method(Method::Put,) + .with_path("/api/v1/crates/fyk_max/1.0.0/unyank",), + ) + ); assert!(::json::(&mut r).ok); - let mut response = ok_resp!(middle.call(req.with_method(Method::Get).with_path( - "/api/v1/crates/fyk_max", - ))); + let mut response = ok_resp!( + middle.call( + req.with_method(Method::Get,) + .with_path("/api/v1/crates/fyk_max",), + ) + ); let json: CrateResponse = ::json(&mut response); assert_eq!(json.krate.max_version, "2.0.0"); } @@ -1501,9 +1560,12 @@ fn good_badges() { assert_eq!(json.krate.name, "foobadger"); assert_eq!(json.krate.max_version, "1.0.0"); - let mut response = ok_resp!(middle.call(req.with_method(Method::Get).with_path( - "/api/v1/crates/foobadger", - ))); + let mut response = ok_resp!( + middle.call( + req.with_method(Method::Get,) + .with_path("/api/v1/crates/foobadger",), + ) + ); let json: CrateResponse = ::json(&mut response); @@ -1541,16 +1603,23 @@ fn ignored_badges() { assert_eq!(json.krate.name, "foo_ignored_badge"); assert_eq!(json.krate.max_version, "1.0.0"); assert_eq!(json.warnings.invalid_badges.len(), 2); - assert!(json.warnings.invalid_badges.contains( - &"travis-ci".to_string(), - )); - assert!(json.warnings.invalid_badges.contains( - &"not-a-badge".to_string(), - )); + assert!( + json.warnings + .invalid_badges + .contains(&"travis-ci".to_string(),) + ); + assert!( + json.warnings + .invalid_badges + .contains(&"not-a-badge".to_string(),) + ); - let mut response = ok_resp!(middle.call(req.with_method(Method::Get).with_path( - "/api/v1/crates/foo_ignored_badge", - ))); + let mut response = ok_resp!( + middle.call( + req.with_method(Method::Get,) + .with_path("/api/v1/crates/foo_ignored_badge",), + ) + ); let json: CrateResponse = ::json(&mut response); @@ -1738,8 +1807,8 @@ fn author_license_and_description_required() { req.with_body(&::new_crate_to_body(&new_crate, &[])); let json = bad_resp!(middle.call(&mut req)); assert!( - json.errors[0].detail.contains("author") && json.errors[0].detail.contains("description") && - json.errors[0].detail.contains("license"), + json.errors[0].detail.contains("author") && json.errors[0].detail.contains("description") + && json.errors[0].detail.contains("license"), "{:?}", json.errors ); @@ -1749,8 +1818,8 @@ fn author_license_and_description_required() { req.with_body(&::new_crate_to_body(&new_crate, &[])); let json = bad_resp!(middle.call(&mut req)); assert!( - json.errors[0].detail.contains("author") && json.errors[0].detail.contains("description") && - !json.errors[0].detail.contains("license"), + json.errors[0].detail.contains("author") && json.errors[0].detail.contains("description") + && !json.errors[0].detail.contains("license"), "{:?}", json.errors ); @@ -1761,9 +1830,8 @@ fn author_license_and_description_required() { req.with_body(&::new_crate_to_body(&new_crate, &[])); let json = bad_resp!(middle.call(&mut req)); assert!( - !json.errors[0].detail.contains("author") && - json.errors[0].detail.contains("description") && - !json.errors[0].detail.contains("license"), + !json.errors[0].detail.contains("author") && json.errors[0].detail.contains("description") + && !json.errors[0].detail.contains("license"), "{:?}", json.errors ); @@ -1926,9 +1994,7 @@ fn block_blacklisted_documentation_url() { let conn = app.diesel_database.get().unwrap(); let u = ::new_user("foo").create_or_update(&conn).unwrap(); ::CrateBuilder::new("foo_bad_doc_url", u.id) - .documentation( - "http://rust-ci.org/foo/foo_bad_doc_url/doc/foo_bad_doc_url/", - ) + .documentation("http://rust-ci.org/foo/foo_bad_doc_url/doc/foo_bad_doc_url/") .expect_build(&conn) }; @@ -1965,7 +2031,9 @@ fn test_cargo_invite_owners() { msg: String, } - let body = serde_json::to_string(&OwnerReq { owners: Some(vec![new_user.gh_login]) }); + let body = serde_json::to_string(&OwnerReq { + owners: Some(vec![new_user.gh_login]), + }); let mut response = ok_resp!( middle.call( req.with_path("/api/v1/crates/guacamole/owners") diff --git a/src/tests/owners.rs b/src/tests/owners.rs index 5428dd747c1..199848eca87 100644 --- a/src/tests/owners.rs +++ b/src/tests/owners.rs @@ -154,7 +154,8 @@ fn owners_can_remove_self() { // Deleting yourself when you're the only owner isn't allowed. let body = r#"{"users":["firstowner"]}"#; - let mut response = ok_resp!(middle.call(req.with_method(Method::Delete,).with_body(body.as_bytes(),),)); + let mut response = + ok_resp!(middle.call(req.with_method(Method::Delete,).with_body(body.as_bytes(),),)); let json = ::json::<::Bad>(&mut response); assert!( json.errors[0] @@ -163,7 +164,8 @@ fn owners_can_remove_self() { ); let body = r#"{"users":["secondowner"]}"#; - let mut response = ok_resp!(middle.call(req.with_method(Method::Put,).with_body(body.as_bytes(),),)); + let mut response = + ok_resp!(middle.call(req.with_method(Method::Put,).with_body(body.as_bytes(),),)); assert!(::json::(&mut response).ok); // Need to accept owner invitation to add secondowner as owner @@ -219,15 +221,16 @@ fn owners_can_remove_self() { let mut response = ok_resp!( middle.call( req.with_path("/api/v1/crates/owners_selfremove/owners") - .with_method(Method::Delete) - .with_body(body.as_bytes()) + .with_method(Method::Delete) + .with_body(body.as_bytes()) ) ); assert!(::json::(&mut response).ok); // After you delete yourself, you no longer have permisions to manage the crate. let body = r#"{"users":["secondowner"]}"#; - let mut response = ok_resp!(middle.call(req.with_method(Method::Delete,).with_body(body.as_bytes(),),)); + let mut response = + ok_resp!(middle.call(req.with_method(Method::Delete,).with_body(body.as_bytes(),),)); let json = ::json::<::Bad>(&mut response); assert!( json.errors[0] diff --git a/src/tests/record.rs b/src/tests/record.rs index edc8f3146f1..059ef07ef03 100644 --- a/src/tests/record.rs +++ b/src/tests/record.rs @@ -63,11 +63,9 @@ impl Drop for Bomb { .to_string(); match res { Err(..) if !thread::panicking() => panic!("server subtask failed: {}", stderr), - Err(e) => { - if stderr.len() > 0 { - println!("server subtask failed ({:?}): {}", e, stderr) - } - } + Err(e) => if stderr.len() > 0 { + println!("server subtask failed ({:?}): {}", e, stderr) + }, Ok(_) if thread::panicking() => {} Ok(None) => {} Ok(Some((data, file))) => { @@ -310,9 +308,7 @@ fn replay_http( }); let mut response = hyper::Response::new(); - response.set_status( - hyper::StatusCode::try_from(exchange.response.status).unwrap(), - ); + response.set_status(hyper::StatusCode::try_from(exchange.response.status).unwrap()); for (key, value) in exchange.response.headers.into_iter() { response.headers_mut().append_raw(key, value); } diff --git a/src/tests/schema_details.rs b/src/tests/schema_details.rs index c452a8e4aea..d18b5622d90 100644 --- a/src/tests/schema_details.rs +++ b/src/tests/schema_details.rs @@ -5,12 +5,10 @@ fn all_columns_called_crate_id_have_a_cascading_foreign_key() { for (table_name, constraint) in get_fk_constraint_definitions("crate_id") { let constraint = match constraint { Some(c) => c, - None => { - panic!( - "Column called crate_id on {} has no foreign key", - table_name - ) - } + None => panic!( + "Column called crate_id on {} has no foreign key", + table_name + ), }; if !constraint.definition.contains("ON DELETE CASCADE") { panic!( @@ -28,12 +26,10 @@ fn all_columns_called_version_id_have_a_cascading_foreign_key() { for (table_name, constraint) in get_fk_constraint_definitions("version_id") { let constraint = match constraint { Some(c) => c, - None => { - panic!( - "Column called version_id on {} has no foreign key", - table_name - ) - } + None => panic!( + "Column called version_id on {} has no foreign key", + table_name + ), }; if !constraint.definition.contains("ON DELETE CASCADE") { panic!( diff --git a/src/tests/team.rs b/src/tests/team.rs index 35e83ad4923..7861fee842f 100644 --- a/src/tests/team.rs +++ b/src/tests/team.rs @@ -71,9 +71,9 @@ fn weird_name() { ) ); assert!( - json.errors[0].detail.contains( - "organization cannot contain", - ), + json.errors[0] + .detail + .contains("organization cannot contain",), "{:?}", json.errors ); @@ -115,9 +115,9 @@ fn nonexistent_team() { ) ); assert!( - json.errors[0].detail.contains( - "don't have permission to query a necessary property", - ), + json.errors[0] + .detail + .contains("don't have permission to query a necessary property",), "{:?}", json.errors ); @@ -200,9 +200,9 @@ fn remove_team_as_named_owner() { ) ); assert!( - json.errors[0].detail.contains( - "this crate exists but you don't seem to be an owner.", - ), + json.errors[0] + .detail + .contains("this crate exists but you don't seem to be an owner.",), "{:?}", json.errors ); @@ -238,9 +238,9 @@ fn remove_team_as_team_owner() { ); assert!( - json.errors[0].detail.contains( - "only owners have permission", - ), + json.errors[0] + .detail + .contains("only owners have permission",), "{:?}", json.errors ); @@ -285,9 +285,9 @@ fn publish_not_owned() { ) ); assert!( - json.errors[0].detail.contains( - "this crate exists but you don't seem to be an owner.", - ), + json.errors[0] + .detail + .contains("this crate exists but you don't seem to be an owner.",), "{:?}", json.errors ); @@ -353,9 +353,9 @@ fn add_owners_as_team_owner() { ) ); assert!( - json.errors[0].detail.contains( - "only owners have permission", - ), + json.errors[0] + .detail + .contains("only owners have permission",), "{:?}", json.errors ); diff --git a/src/tests/user.rs b/src/tests/user.rs index 01a476a8e2e..c460e331c05 100644 --- a/src/tests/user.rs +++ b/src/tests/user.rs @@ -170,11 +170,12 @@ fn following() { .expect_build(&conn); } - let mut response = ok_resp!(middle.call( - req.with_path("/api/v1/me/updates").with_method( - Method::Get, - ), - )); + let mut response = ok_resp!( + middle.call( + req.with_path("/api/v1/me/updates",) + .with_method(Method::Get,), + ) + ); let r = ::json::(&mut response); assert_eq!(r.versions.len(), 0); assert_eq!(r.meta.more, false); @@ -192,11 +193,12 @@ fn following() { ) ); - let mut response = ok_resp!(middle.call( - req.with_path("/api/v1/me/updates").with_method( - Method::Get, - ), - )); + let mut response = ok_resp!( + middle.call( + req.with_path("/api/v1/me/updates",) + .with_method(Method::Get,), + ) + ); let r = ::json::(&mut response); assert_eq!(r.versions.len(), 2); assert_eq!(r.meta.more, false); @@ -253,8 +255,8 @@ fn user_total_downloads() { let another_user = ::new_user("bar").create_or_update(&conn).unwrap(); - let mut another_krate = ::CrateBuilder::new("bar_krate1", another_user.id) - .expect_build(&conn); + let mut another_krate = + ::CrateBuilder::new("bar_krate1", another_user.id).expect_build(&conn); another_krate.downloads = 2; update(&another_krate) .set(&another_krate) @@ -349,9 +351,7 @@ fn test_github_login_does_not_overwrite_email() { user }; - let mut response = ok_resp!(middle.call( - req.with_path("/api/v1/me").with_method(Method::Get), - )); + let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),)); let r = ::json::(&mut response); assert_eq!(r.user.email, None); assert_eq!(r.user.login, "apricot"); @@ -379,9 +379,7 @@ fn test_github_login_does_not_overwrite_email() { ::sign_in_as(&mut req, &user); } - let mut response = ok_resp!(middle.call( - req.with_path("/api/v1/me").with_method(Method::Get), - )); + let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),)); let r = ::json::(&mut response); assert_eq!(r.user.email.unwrap(), "apricot@apricots.apricot"); assert_eq!(r.user.login, "apricot"); @@ -412,9 +410,7 @@ fn test_email_get_and_put() { user }; - let mut response = ok_resp!(middle.call( - req.with_path("/api/v1/me").with_method(Method::Get), - )); + let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),)); let r = ::json::(&mut response); assert_eq!(r.user.email, None); assert_eq!(r.user.login, "mango"); @@ -429,9 +425,7 @@ fn test_email_get_and_put() { ); assert!(::json::(&mut response).ok); - let mut response = ok_resp!(middle.call( - req.with_path("/api/v1/me").with_method(Method::Get), - )); + let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),)); let r = ::json::(&mut response); assert_eq!(r.user.email.unwrap(), "mango@mangos.mango"); assert_eq!(r.user.login, "mango"); @@ -523,9 +517,9 @@ fn test_this_user_cannot_change_that_user_email() { ); assert!( - json.errors[0].detail.contains( - "current user does not match requested user", - ), + json.errors[0] + .detail + .contains("current user does not match requested user",), "{:?}", json.errors ); @@ -558,9 +552,7 @@ fn test_insert_into_email_table() { ::sign_in_as(&mut req, &user); } - let mut response = ok_resp!(middle.call( - req.with_path("/api/v1/me").with_method(Method::Get), - )); + let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),)); let r = ::json::(&mut response); assert_eq!(r.user.email.unwrap(), "apple@example.com"); assert_eq!(r.user.login, "apple"); @@ -580,9 +572,7 @@ fn test_insert_into_email_table() { ::sign_in_as(&mut req, &user); } - let mut response = ok_resp!(middle.call( - req.with_path("/api/v1/me").with_method(Method::Get), - )); + let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),)); let r = ::json::(&mut response); assert_eq!(r.user.email.unwrap(), "apple@example.com"); assert_eq!(r.user.login, "apple"); @@ -620,9 +610,7 @@ fn test_insert_into_email_table_with_email_change() { user }; - let mut response = ok_resp!(middle.call( - req.with_path("/api/v1/me").with_method(Method::Get), - )); + let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),)); let r = ::json::(&mut response); assert_eq!(r.user.email.unwrap(), "potato@example.com"); assert_eq!(r.user.login, "potato"); @@ -654,9 +642,7 @@ fn test_insert_into_email_table_with_email_change() { ::sign_in_as(&mut req, &user); } - let mut response = ok_resp!(middle.call( - req.with_path("/api/v1/me").with_method(Method::Get), - )); + let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),)); let r = ::json::(&mut response); assert_eq!(r.user.email.unwrap(), "apricot@apricots.apricot"); assert!(!r.user.email_verified); @@ -719,9 +705,7 @@ fn test_confirm_user_email() { ); assert!(::json::(&mut response).ok); - let mut response = ok_resp!(middle.call( - req.with_path("/api/v1/me").with_method(Method::Get), - )); + let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),)); let r = ::json::(&mut response); assert_eq!(r.user.email.unwrap(), "potato@example.com"); assert_eq!(r.user.login, "potato"); @@ -768,9 +752,7 @@ fn test_existing_user_email() { ::sign_in_as(&mut req, &user); } - let mut response = ok_resp!(middle.call( - req.with_path("/api/v1/me").with_method(Method::Get), - )); + let mut response = ok_resp!(middle.call(req.with_path("/api/v1/me").with_method(Method::Get),)); let r = ::json::(&mut response); assert_eq!(r.user.email.unwrap(), "potahto@example.com"); assert!(!r.user.email_verified); diff --git a/src/tests/version.rs b/src/tests/version.rs index 8370685c8de..0f29fa3fecc 100644 --- a/src/tests/version.rs +++ b/src/tests/version.rs @@ -31,9 +31,7 @@ fn index() { let u = ::new_user("foo").create_or_update(&conn).unwrap(); ::CrateBuilder::new("foo_vers_index", u.id) .version(::VersionBuilder::new("2.0.0").license(Some("MIT"))) - .version(::VersionBuilder::new("2.0.1").license( - Some("MIT/Apache-2.0"), - )) + .version(::VersionBuilder::new("2.0.1").license(Some("MIT/Apache-2.0"))) .expect_build(&conn); let ids = versions::table .select(versions::id) diff --git a/src/token.rs b/src/token.rs index 71a9fcd357a..0dcb0709efb 100644 --- a/src/token.rs +++ b/src/token.rs @@ -15,10 +15,8 @@ use schema::api_tokens; #[belongs_to(User)] pub struct ApiToken { pub id: i32, - #[serde(skip)] - pub user_id: i32, - #[serde(skip)] - pub token: String, + #[serde(skip)] pub user_id: i32, + #[serde(skip)] pub token: String, pub name: String, pub created_at: NaiveDateTime, pub last_used_at: Option, @@ -103,9 +101,8 @@ pub fn new(req: &mut Request) -> CargoResult { } let max_post_size = 2000; - let length = req.content_length().chain_error(|| { - bad_request("missing header: Content-Length") - })?; + let length = req.content_length() + .chain_error(|| bad_request("missing header: Content-Length"))?; if length > max_post_size { return Err(bad_request(&format!("max post size is: {}", max_post_size))); @@ -114,9 +111,7 @@ pub fn new(req: &mut Request) -> CargoResult { 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)) @@ -130,9 +125,9 @@ pub fn new(req: &mut Request) -> CargoResult { let user = req.user()?; let max_token_per_user = 500; - let count = ApiToken::belonging_to(user).count().get_result::( - &*req.db_conn()?, - )?; + let count = ApiToken::belonging_to(user) + .count() + .get_result::(&*req.db_conn()?)?; if count >= max_token_per_user { return Err(bad_request(&format!( "maximum tokens per user is: {}", @@ -146,17 +141,18 @@ pub fn new(req: &mut Request) -> CargoResult { struct R { api_token: EncodableApiTokenWithToken, } - Ok(req.json(&R { api_token: api_token.encodable_with_token() })) + Ok(req.json(&R { + api_token: api_token.encodable_with_token(), + })) } /// Handles the `DELETE /me/tokens/:id` route. pub fn revoke(req: &mut Request) -> CargoResult { - let id = req.params()["id"].parse::().map_err(|e| { - bad_request(&format!("invalid token id: {:?}", e)) - })?; + let id = req.params()["id"] + .parse::() + .map_err(|e| bad_request(&format!("invalid token id: {:?}", e)))?; - diesel::delete(ApiToken::belonging_to(req.user()?).find(id)) - .execute(&*req.db_conn()?)?; + diesel::delete(ApiToken::belonging_to(req.user()?).find(id)).execute(&*req.db_conn()?)?; #[derive(Serialize)] struct R {} diff --git a/src/uploaders.rs b/src/uploaders.rs index c84b815abe2..653813dfde8 100644 --- a/src/uploaders.rs +++ b/src/uploaders.rs @@ -150,9 +150,7 @@ impl Uploader { let path = Uploader::crate_path(&krate.name, &vers.to_string()); let length = read_le_u32(req.body())?; let mut body = Vec::new(); - LimitErrorReader::new(req.body(), max).read_to_end( - &mut body, - )?; + LimitErrorReader::new(req.body(), max).read_to_end(&mut body)?; verify_tarball(krate, vers, &body)?; self.upload( app.handle(), diff --git a/src/user/middleware.rs b/src/user/middleware.rs index 74ece70fcd3..fa87252e374 100644 --- a/src/user/middleware.rs +++ b/src/user/middleware.rs @@ -23,9 +23,9 @@ impl conduit_middleware::Middleware for Middleware { fn before(&self, req: &mut Request) -> Result<(), Box> { // Check if the request has a session cookie with a `user_id` property inside let id = { - req.session().get("user_id").and_then( - |s| s.parse::().ok(), - ) + req.session() + .get("user_id") + .and_then(|s| s.parse::().ok()) }; let conn = req.db_conn().map_err(std_error)?; @@ -36,9 +36,8 @@ impl conduit_middleware::Middleware for Middleware { if let Ok(user) = maybe_user { // Attach the `User` model from the database to the request req.mut_extensions().insert(user); - req.mut_extensions().insert( - AuthenticationSource::SessionCookie, - ); + req.mut_extensions() + .insert(AuthenticationSource::SessionCookie); } } else { // Otherwise, look for an `Authorization` header on the request @@ -66,9 +65,9 @@ pub trait RequestUser { impl<'a> RequestUser for Request + 'a { fn user(&self) -> CargoResult<&User> { - self.extensions().find::().chain_error( - || Unauthorized, - ) + self.extensions() + .find::() + .chain_error(|| Unauthorized) } fn authentication_source(&self) -> CargoResult { diff --git a/src/user/mod.rs b/src/user/mod.rs index d567e09ba8a..68a4193af58 100644 --- a/src/user/mod.rs +++ b/src/user/mod.rs @@ -97,10 +97,7 @@ impl NewToken { let new_token = Self::generate(id); insert(&new_token.on_conflict( email_id, - do_update().set(( - token.eq(&new_token.token), - created_at.eq(now), - )), + do_update().set((token.eq(&new_token.token), created_at.eq(now))), )).into(tokens) .returning(token) .get_result(conn) @@ -153,10 +150,8 @@ impl<'a> NewUser<'a> { // necessary for most fields in the database to be used as a conflict // target :) let conflict_target = sql::("(gh_id) WHERE gh_id > 0"); - let user = insert(&self.on_conflict( - conflict_target, - do_update().set(&update_user), - )).into(users::table) + let user = insert(&self.on_conflict(conflict_target, do_update().set(&update_user))) + .into(users::table) .get_result::(conn)?; // To send the user an account verification email... @@ -305,10 +300,8 @@ impl User { pub fn github_authorize(req: &mut Request) -> CargoResult { // Generate a random 16 char ASCII string let state: String = thread_rng().gen_ascii_chars().take(16).collect(); - req.session().insert( - "github_oauth_state".to_string(), - state.clone(), - ); + req.session() + .insert("github_oauth_state".to_string(), state.clone()); let url = req.app().github.authorize_url(state.clone()); @@ -377,9 +370,10 @@ pub fn github_access_token(req: &mut Request) -> CargoResult { } // Fetch the access token from github using the code we just got - let token = req.app().github.exchange(code.clone()).map_err( - |s| human(&s), - )?; + let token = req.app() + .github + .exchange(code.clone()) + .map_err(|s| human(&s))?; let (handle, resp) = github::github(req.app(), "/user", &token)?; let ghuser: GithubUser = github::parse_github_response(handle, &resp)?; @@ -392,10 +386,8 @@ pub fn github_access_token(req: &mut Request) -> CargoResult { ghuser.avatar_url.as_ref().map(|s| &s[..]), &token.access_token, ).create_or_update(&*req.db_conn()?)?; - req.session().insert( - "user_id".to_string(), - user.id.to_string(), - ); + req.session() + .insert("user_id".to_string(), user.id.to_string()); req.mut_extensions().insert(user); me(req) } @@ -468,15 +460,17 @@ pub fn show(req: &mut Request) -> CargoResult { let name = &req.params()["user_id"].to_lowercase(); let conn = req.db_conn()?; - let user = users.filter(::lower(gh_login).eq(name)).first::( - &*conn, - )?; + let user = users + .filter(::lower(gh_login).eq(name)) + .first::(&*conn)?; #[derive(Serialize)] struct R { user: EncodablePublicUser, } - Ok(req.json(&R { user: user.encodable_public() })) + Ok(req.json(&R { + user: user.encodable_public(), + })) } /// Handles the `GET /teams/:team_id` route. @@ -493,7 +487,9 @@ pub fn show_team(req: &mut Request) -> CargoResult { struct R { team: EncodableTeam, } - Ok(req.json(&R { team: team.encodable() })) + Ok(req.json(&R { + team: team.encodable(), + })) } /// Handles the `GET /me/updates` route. @@ -546,9 +542,11 @@ pub fn stats(req: &mut Request) -> CargoResult { let data = crate_owners::table .inner_join(crates::table) - .filter(crate_owners::owner_id.eq(user_id).and( - crate_owners::owner_kind.eq(OwnerKind::User as i32), - )) + .filter( + crate_owners::owner_id + .eq(user_id) + .and(crate_owners::owner_kind.eq(OwnerKind::User as i32)), + ) .select(sum(crates::downloads)) .first::>(&*conn)? .unwrap_or(0); @@ -557,7 +555,9 @@ pub fn stats(req: &mut Request) -> CargoResult { struct R { total_downloads: i64, } - Ok(req.json(&R { total_downloads: data })) + Ok(req.json(&R { + total_downloads: data, + })) } /// Handles the `PUT /user/:user_id` route. @@ -588,9 +588,8 @@ pub fn update_user(req: &mut Request) -> CargoResult { email: Option, } - let user_update: UserUpdate = serde_json::from_str(&body).map_err( - |_| human("invalid json request"), - )?; + let user_update: UserUpdate = + serde_json::from_str(&body).map_err(|_| human("invalid json request"))?; if user_update.user.email.is_none() { return Err(human("empty email rejected")); diff --git a/src/util/errors.rs b/src/util/errors.rs index a17edd081a1..9075b207834 100644 --- a/src/util/errors.rs +++ b/src/util/errors.rs @@ -28,7 +28,11 @@ pub trait CargoError: Send + fmt::Display + 'static { fn response(&self) -> Option { if self.human() { Some(json_response(&Bad { - errors: vec![StringError { detail: self.description().to_string() }], + errors: vec![ + StringError { + detail: self.description().to_string(), + }, + ], })) } else { self.cause().and_then(|cause| cause.response()) @@ -233,7 +237,11 @@ impl CargoError for NotFound { fn response(&self) -> Option { let mut response = json_response(&Bad { - errors: vec![StringError { detail: "Not Found".to_string() }], + errors: vec![ + StringError { + detail: "Not Found".to_string(), + }, + ], }); response.status = (404, "Not Found"); Some(response) @@ -282,7 +290,11 @@ impl CargoError for BadRequest { fn response(&self) -> Option { let mut response = json_response(&Bad { - errors: vec![StringError { detail: self.0.clone() }], + errors: vec![ + StringError { + detail: self.0.clone(), + }, + ], }); response.status = (400, "Bad Request"); Some(response) diff --git a/src/util/io_util.rs b/src/util/io_util.rs index 08797f02b60..fe77100b946 100644 --- a/src/util/io_util.rs +++ b/src/util/io_util.rs @@ -9,7 +9,9 @@ pub struct LimitErrorReader { impl LimitErrorReader { pub fn new(r: R, limit: u64) -> LimitErrorReader { - LimitErrorReader { inner: r.take(limit) } + LimitErrorReader { + inner: r.take(limit), + } } } @@ -28,9 +30,7 @@ impl Read for LimitErrorReader { pub fn read_le_u32(r: &mut R) -> io::Result { let mut b = [0; 4]; read_fill(r, &mut b)?; - Ok( - (b[0] as u32) | ((b[1] as u32) << 8) | ((b[2] as u32) << 16) | ((b[3] as u32) << 24), - ) + Ok((b[0] as u32) | ((b[1] as u32) << 8) | ((b[2] as u32) << 16) | ((b[3] as u32) << 24)) } pub fn read_fill(r: &mut R, mut slice: &mut [u8]) -> io::Result<()> { diff --git a/src/util/mod.rs b/src/util/mod.rs index 3aafc0f13ac..8d7831bce32 100644 --- a/src/util/mod.rs +++ b/src/util/mod.rs @@ -108,12 +108,10 @@ impl Handler for C { let C(f) = *self; match f(req) { Ok(resp) => Ok(resp), - Err(e) => { - match e.response() { - Some(response) => Ok(response), - None => Err(std_error(e)), - } - } + Err(e) => match e.response() { + Some(response) => Ok(response), + None => Err(std_error(e)), + }, } } } diff --git a/src/util/request_proxy.rs b/src/util/request_proxy.rs index 99c0fa54935..19bd99393e2 100644 --- a/src/util/request_proxy.rs +++ b/src/util/request_proxy.rs @@ -21,9 +21,9 @@ impl<'a> Request for RequestProxy<'a> { self.other.conduit_version() } fn method(&self) -> conduit::Method { - self.method.clone().unwrap_or_else( - || self.other.method().clone(), - ) + self.method + .clone() + .unwrap_or_else(|| self.other.method().clone()) } fn scheme(&self) -> conduit::Scheme { self.other.scheme() diff --git a/src/version/mod.rs b/src/version/mod.rs index 994f73815d1..2afd9ce8f35 100644 --- a/src/version/mod.rs +++ b/src/version/mod.rs @@ -50,8 +50,7 @@ pub struct NewVersion { #[derive(Serialize, Deserialize, Debug)] pub struct EncodableVersion { pub id: i32, - #[serde(rename = "crate")] - pub krate: String, + #[serde(rename = "crate")] pub krate: String, pub num: String, pub dl_path: String, pub readme_path: String, @@ -166,9 +165,9 @@ impl NewVersion { use diesel::expression::dsl::exists; use schema::versions::dsl::*; - let already_uploaded = versions.filter(crate_id.eq(self.crate_id)).filter( - num.eq(&self.num), - ); + let already_uploaded = versions + .filter(crate_id.eq(self.crate_id)) + .filter(num.eq(&self.num)); if select(exists(already_uploaded)).get_result(conn)? { return Err(human(&format_args!( "crate version `{}` is already \ @@ -190,9 +189,9 @@ impl NewVersion { }) .collect::>(); - insert(&new_authors).into(version_authors::table).execute( - conn, - )?; + insert(&new_authors) + .into(version_authors::table) + .execute(conn)?; Ok(version) }) } @@ -228,16 +227,18 @@ struct NewAuthor<'a> { impl Queryable for Version { #[cfg_attr(feature = "clippy", allow(type_complexity))] - type Row = (i32, - i32, - String, - NaiveDateTime, - NaiveDateTime, - i32, - Option, - bool, - Option, - Option); + type Row = ( + i32, + i32, + String, + NaiveDateTime, + NaiveDateTime, + i32, + Option, + bool, + Option, + Option, + ); fn build(row: Self::Row) -> Self { let features = row.6 @@ -309,7 +310,9 @@ pub fn show(req: &mut Request) -> CargoResult { struct R { version: EncodableVersion, } - Ok(req.json(&R { version: version.encodable(&krate.name) })) + Ok(req.json(&R { + version: version.encodable(&krate.name), + })) } fn version_and_crate(req: &mut Request) -> CargoResult<(Version, Crate)> { @@ -360,9 +363,7 @@ pub fn downloads(req: &mut Request) -> CargoResult { let cutoff_start_date = cutoff_end_date - Duration::days(89); let downloads = VersionDownload::belonging_to(&version) - .filter(version_downloads::date.between( - cutoff_start_date..cutoff_end_date, - )) + .filter(version_downloads::date.between(cutoff_start_date..cutoff_end_date)) .order(version_downloads::date) .load(&*conn)? .into_iter() @@ -373,7 +374,9 @@ pub fn downloads(req: &mut Request) -> CargoResult { struct R { version_downloads: Vec, } - Ok(req.json(&R { version_downloads: downloads })) + Ok(req.json(&R { + version_downloads: downloads, + })) } /// Handles the `GET /crates/:crate_id/:version/authors` route. From 0264e762af4fafb5c2ae9cd192ed04ce3bc33b1c Mon Sep 17 00:00:00 2001 From: "Carol (Nichols || Goulding)" Date: Fri, 6 Oct 2017 16:03:49 -0400 Subject: [PATCH 19/19] Oops, introduced a formatting error in the merge resolution --- src/krate/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/krate/mod.rs b/src/krate/mod.rs index a43daff1efe..b933a25ad83 100644 --- a/src/krate/mod.rs +++ b/src/krate/mod.rs @@ -484,7 +484,7 @@ impl Crate { owner.login(), self.name )) - }, + } // Teams are added as owners immediately owner @ Owner::Team(_) => { let crate_owner = CrateOwner {