Don't error on long lines rustfmt can't handle; change width to 100

Author: carols10cents

.rustfmt.toml

@@ -6,4 +6,5 @@ generics_indent = "Block"
 fn_call_style = "Block"
 combine_control_expr = true
 fn_args_paren_newline = false
-max_width = 118
+max_width = 100
+error_on_line_overflow = false

build.rs

@@ -11,7 +11,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");
         }
     }

src/bin/update-downloads.rs

@@ -161,7 +161,8 @@ mod test {
     use cargo_registry::{Version, Crate, User, Model, env};
 
     fn conn() -> postgres::Connection {
-        postgres::Connection::connect(&env("TEST_DATABASE_URL")[..], postgres::TlsMode::None).unwrap()
+        postgres::Connection::connect(&env("TEST_DATABASE_URL")[..], postgres::TlsMode::None)
+            .unwrap()
     }
 
     fn user(conn: &postgres::transaction::Transaction) -> User {

src/categories.rs

@@ -13,7 +13,12 @@ struct Category {
 }
 
 impl Category {
-    fn from_parent(slug: &str, name: &str, description: &str, parent: Option<&Category>) -> Category {
+    fn from_parent(
+        slug: &str,
+        name: &str,
+        description: &str,
+        parent: Option<&Category>,
+    ) -> Category {
         match parent {
             Some(parent) => {
                 Category {
@@ -46,7 +51,10 @@ fn optional_string_from_toml<'a>(toml: &'a toml::Table, key: &str) -> &'a str {
     toml.get(key).and_then(toml::Value::as_str).unwrap_or("")
 }
 
-fn categories_from_toml(categories: &toml::Table, parent: Option<&Category>) -> CargoResult<Vec<Category>> {
+fn categories_from_toml(
+    categories: &toml::Table,
+    parent: Option<&Category>,
+) -> CargoResult<Vec<Category>> {
     let mut result = vec![];
 
     for (slug, details) in categories {
@@ -87,7 +95,8 @@ pub fn sync() -> CargoResult<()> {
         "Could not parse categories.toml",
     );
 
-    let categories = categories_from_toml(&toml, None).expect("Could not convert categories from TOML");
+    let categories =
+        categories_from_toml(&toml, None).expect("Could not convert categories from TOML");
 
     for category in &categories {
         tx.execute(

src/category.rs

@@ -98,7 +98,11 @@ impl Category {
         }
     }
 
-    pub fn update_crate<'a>(conn: &PgConnection, krate: &Crate, slugs: &[&'a str]) -> QueryResult<Vec<&'a str>> {
+    pub fn update_crate<'a>(
+        conn: &PgConnection,
+        krate: &Crate,
+        slugs: &[&'a str],
+    ) -> QueryResult<Vec<&'a str>> {
         use diesel::expression::dsl::any;
 
         conn.transaction(|| {
@@ -202,7 +206,12 @@ impl Category {
         Ok(rows.iter().next().unwrap().get("count"))
     }
 
-    pub fn toplevel(conn: &PgConnection, sort: &str, limit: i64, offset: i64) -> QueryResult<Vec<Category>> {
+    pub fn toplevel(
+        conn: &PgConnection,
+        sort: &str,
+        limit: i64,
+        offset: i64,
+    ) -> QueryResult<Vec<Category>> {
         use diesel::select;
         use diesel::expression::dsl::*;
 
@@ -227,7 +236,12 @@ impl Category {
         ))).load(conn)
     }
 
-    pub fn toplevel_old(conn: &GenericConnection, sort: &str, limit: i64, offset: i64) -> CargoResult<Vec<Category>> {
+    pub fn toplevel_old(
+        conn: &GenericConnection,
+        sort: &str,
+        limit: i64,
+        offset: i64,
+    ) -> CargoResult<Vec<Category>> {
 
         let sort_sql = match sort {
             "crates" => "ORDER BY crates_cnt DESC",
@@ -413,7 +427,8 @@ mod tests {
 
     fn pg_connection() -> PgConnection {
         let _ = dotenv();
-        let database_url = env::var("TEST_DATABASE_URL").expect("TEST_DATABASE_URL must be set to run tests");
+        let database_url =
+            env::var("TEST_DATABASE_URL").expect("TEST_DATABASE_URL must be set to run tests");
         let conn = PgConnection::establish(&database_url).unwrap();
         // These tests deadlock if run concurrently
         conn.batch_execute("BEGIN; LOCK categories IN ACCESS EXCLUSIVE MODE")

src/db.rs

@@ -59,7 +59,11 @@ pub fn tls_handshake() -> Box<TlsHandshake + Sync + Send> {
     // better solution in the future for certificate verification...
 
     impl TlsHandshake for MyHandshake {
-        fn tls_handshake(&self, _domain: &str, stream: Stream) -> Result<Box<TlsStream>, Box<Error + Send + Sync>> {
+        fn tls_handshake(
+            &self,
+            _domain: &str,
+            stream: Stream,
+        ) -> Result<Box<TlsStream>, Box<Error + Send + Sync>> {
             let stream = self.0
                 .danger_connect_without_providing_domain_for_certificate_verification_and_server_name_indication(
                     stream,
@@ -102,7 +106,10 @@ pub fn pool(url: &str, config: r2d2::Config<postgres::Connection, r2d2_postgres:
     r2d2::Pool::new(config, mgr).unwrap()
 }
 
-pub fn diesel_pool(url: &str, config: r2d2::Config<PgConnection, r2d2_diesel::Error>) -> DieselPool {
+pub fn diesel_pool(
+    url: &str,
+    config: r2d2::Config<PgConnection, r2d2_diesel::Error>,
+) -> DieselPool {
     let mut url = Url::parse(url).expect("Invalid database URL");
     if env::var("HEROKU").is_ok() && !url.query_pairs().any(|(k, _)| k == "sslmode") {
         url.query_pairs_mut().append_pair("sslmode", "require");
@@ -142,7 +149,9 @@ impl Transaction {
         }
     }
 
-    pub fn conn(&self) -> CargoResult<&r2d2::PooledConnection<r2d2_postgres::PostgresConnectionManager>> {
+    pub fn conn(
+        &self,
+    ) -> CargoResult<&r2d2::PooledConnection<r2d2_postgres::PostgresConnectionManager>> {
         if !self.slot.filled() {
             let conn = self.app.database.get().map_err(|e| {
                 internal(&format_args!("failed to get a database connection: {}", e))

src/dependency.rs

@@ -180,7 +180,8 @@ pub fn add_dependencies(
         })
         .collect::<Result<Vec<_>, _>>()?;
 
-    let (git_deps, new_dependencies): (Vec<_>, Vec<_>) = git_and_new_dependencies.into_iter().unzip();
+    let (git_deps, new_dependencies): (Vec<_>, Vec<_>) =
+        git_and_new_dependencies.into_iter().unzip();
 
     insert(&new_dependencies)
         .into(dependencies::table)

src/krate.rs

@@ -625,7 +625,13 @@ impl Crate {
         Ok(owners)
     }
 
-    pub fn owner_add(&self, app: &App, conn: &PgConnection, req_user: &User, login: &str) -> CargoResult<()> {
+    pub fn owner_add(
+        &self,
+        app: &App,
+        conn: &PgConnection,
+        req_user: &User,
+        login: &str,
+    ) -> CargoResult<()> {
         let owner = match Owner::find_by_login(conn, login) {
             Ok(owner @ Owner::User(_)) => owner,
             Ok(Owner::Team(team)) => {
@@ -663,7 +669,12 @@ impl Crate {
         Ok(())
     }
 
-    pub fn owner_remove(&self, conn: &PgConnection, _req_user: &User, login: &str) -> CargoResult<()> {
+    pub fn owner_remove(
+        &self,
+        conn: &PgConnection,
+        _req_user: &User,
+        login: &str,
+    ) -> CargoResult<()> {
         let owner = Owner::find_by_login(conn, login).map_err(|_| {
             human(&format_args!("could not find owner with login `{}`", login))
         })?;

src/owner.rs

@@ -74,7 +74,12 @@ pub enum Rights {
 
 impl Team {
     /// Tries to create the Team in the DB (assumes a `:` has already been found).
-    pub fn create(app: &App, conn: &PgConnection, login: &str, req_user: &User) -> CargoResult<Self> {
+    pub fn create(
+        app: &App,
+        conn: &PgConnection,
+        login: &str,
+        req_user: &User,
+    ) -> CargoResult<Self> {
         // must look like system:xxxxxxx
         let mut chunks = login.split(':');
         match chunks.next().unwrap() {

src/tests/all.rs

@@ -409,7 +409,12 @@ fn new_dependency(conn: &PgConnection, version: &Version, krate: &Crate) -> Depe
         .unwrap()
 }
 
-fn mock_dep(req: &mut Request, version: &Version, krate: &Crate, target: Option<&str>) -> Dependency {
+fn mock_dep(
+    req: &mut Request,
+    version: &Version,
+    krate: &Crate,
+    target: Option<&str>,
+) -> Dependency {
     Dependency::insert(
         req.tx().unwrap(),
         version.id,
@@ -462,7 +467,12 @@ fn new_req(app: Arc<App>, krate: &str, version: &str) -> MockRequest {
     new_req_full(app, ::krate(krate), version, Vec::new())
 }
 
-fn new_req_full(app: Arc<App>, krate: Crate, version: &str, deps: Vec<u::CrateDependency>) -> MockRequest {
+fn new_req_full(
+    app: Arc<App>,
+    krate: Crate,
+    version: &str,
+    deps: Vec<u::CrateDependency>,
+) -> MockRequest {
     let mut req = ::req(app, Method::Put, "/api/v1/crates/new");
     req.with_body(&new_req_body(
         krate,
@@ -475,7 +485,12 @@ fn new_req_full(app: Arc<App>, krate: Crate, version: &str, deps: Vec<u::CrateDe
     return req;
 }
 
-fn new_req_with_keywords(app: Arc<App>, krate: Crate, version: &str, kws: Vec<String>) -> MockRequest {
+fn new_req_with_keywords(
+    app: Arc<App>,
+    krate: Crate,
+    version: &str,
+    kws: Vec<String>,
+) -> MockRequest {
     let mut req = ::req(app, Method::Put, "/api/v1/crates/new");
     req.with_body(&new_req_body(
         krate,
@@ -488,7 +503,12 @@ fn new_req_with_keywords(app: Arc<App>, krate: Crate, version: &str, kws: Vec<St
     return req;
 }
 
-fn new_req_with_categories(app: Arc<App>, krate: Crate, version: &str, cats: Vec<String>) -> MockRequest {
+fn new_req_with_categories(
+    app: Arc<App>,
+    krate: Crate,
+    version: &str,
+    cats: Vec<String>,
+) -> MockRequest {
     let mut req = ::req(app, Method::Put, "/api/v1/crates/new");
     req.with_body(&new_req_body(
         krate,

src/tests/badge.rs

@@ -64,9 +64,17 @@ fn set_up() -> (Arc<App>, Crate, BadgeRef) {
         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")),
@@ -96,7 +104,8 @@ fn set_up() -> (Arc<App>, Crate, BadgeRef) {
         gitlab: gitlab,
         gitlab_attributes: badge_attributes_gitlab,
         isitmaintained_issue_resolution: isitmaintained_issue_resolution,
-        isitmaintained_issue_resolution_attributes: badge_attributes_isitmaintained_issue_resolution,
+        isitmaintained_issue_resolution_attributes:
+            badge_attributes_isitmaintained_issue_resolution,
         isitmaintained_open_issues: isitmaintained_open_issues,
         isitmaintained_open_issues_attributes: badge_attributes_isitmaintained_open_issues,
         codecov: codecov,

src/tests/team.rs

@@ -37,7 +37,8 @@ fn body_for_team_x() -> &'static str {
 #[test]
 fn not_github() {
     let (_b, app, middle) = ::app();
-    let mut req = ::request_with_user_and_mock_crate(&app, mock_user_on_x_and_y(), "foo_not_github");
+    let mut req =
+        ::request_with_user_and_mock_crate(&app, mock_user_on_x_and_y(), "foo_not_github");
 
     let body = r#"{"users":["dropbox:foo:foo"]}"#;
     let json = bad_resp!(
@@ -57,7 +58,8 @@ fn not_github() {
 #[test]
 fn weird_name() {
     let (_b, app, middle) = ::app();
-    let mut req = ::request_with_user_and_mock_crate(&app, mock_user_on_x_and_y(), "foo_weird_name");
+    let mut req =
+        ::request_with_user_and_mock_crate(&app, mock_user_on_x_and_y(), "foo_weird_name");
 
     let body = r#"{"users":["github:foo/../bar:wut"]}"#;
     let json = bad_resp!(
@@ -100,7 +102,8 @@ fn one_colon() {
 #[test]
 fn nonexistent_team() {
     let (_b, app, middle) = ::app();
-    let mut req = ::request_with_user_and_mock_crate(&app, mock_user_on_x_and_y(), "foo_nonexistent");
+    let mut req =
+        ::request_with_user_and_mock_crate(&app, mock_user_on_x_and_y(), "foo_nonexistent");
 
     let body = r#"{"users":["github:crates-test-org:this-does-not-exist"]}"#;
     let json = bad_resp!(
@@ -123,7 +126,8 @@ fn nonexistent_team() {
 #[test]
 fn add_team_as_member() {
     let (_b, app, middle) = ::app();
-    let mut req = ::request_with_user_and_mock_crate(&app, mock_user_on_x_and_y(), "foo_team_member");
+    let mut req =
+        ::request_with_user_and_mock_crate(&app, mock_user_on_x_and_y(), "foo_team_member");
 
     let body = body_for_team_x();
     ok_resp!(
@@ -139,7 +143,8 @@ fn add_team_as_member() {
 #[test]
 fn add_team_as_non_member() {
     let (_b, app, middle) = ::app();
-    let mut req = ::request_with_user_and_mock_crate(&app, mock_user_on_only_x(), "foo_team_non_member");
+    let mut req =
+        ::request_with_user_and_mock_crate(&app, mock_user_on_only_x(), "foo_team_non_member");
 
     let body = body_for_team_y();
     let json = bad_resp!(
@@ -159,7 +164,8 @@ fn add_team_as_non_member() {
 #[test]
 fn remove_team_as_named_owner() {
     let (_b, app, middle) = ::app();
-    let mut req = ::request_with_user_and_mock_crate(&app, mock_user_on_x_and_y(), "foo_remove_team");
+    let mut req =
+        ::request_with_user_and_mock_crate(&app, mock_user_on_x_and_y(), "foo_remove_team");
 
     let body = body_for_team_x();
     ok_resp!(
@@ -202,7 +208,8 @@ fn remove_team_as_named_owner() {
 #[test]
 fn remove_team_as_team_owner() {
     let (_b, app, middle) = ::app();
-    let mut req = ::request_with_user_and_mock_crate(&app, mock_user_on_x_and_y(), "foo_remove_team_owner");
+    let mut req =
+        ::request_with_user_and_mock_crate(&app, mock_user_on_x_and_y(), "foo_remove_team_owner");
 
     let body = body_for_team_x();
     ok_resp!(
@@ -283,7 +290,8 @@ fn publish_not_owned() {
 #[test]
 fn publish_owned() {
     let (_b, app, middle) = ::app();
-    let mut req = ::request_with_user_and_mock_crate(&app, mock_user_on_x_and_y(), "foo_team_owned");
+    let mut req =
+        ::request_with_user_and_mock_crate(&app, mock_user_on_x_and_y(), "foo_team_owned");
 
     let body = body_for_team_x();
     ok_resp!(

src/user/mod.rs

@@ -429,7 +429,8 @@ mod tests {
 
     fn connection() -> PgConnection {
         let _ = dotenv();
-        let database_url = env::var("TEST_DATABASE_URL").expect("TEST_DATABASE_URL must be set to run tests");
+        let database_url =
+            env::var("TEST_DATABASE_URL").expect("TEST_DATABASE_URL must be set to run tests");
         let conn = PgConnection::establish(&database_url).unwrap();
         conn.begin_test_transaction().unwrap();
         conn

src/util/errors.rs

@@ -255,7 +255,9 @@ impl CargoError for Unauthorized {
     fn response(&self) -> Option<Response> {
         let mut response = json_response(&Bad {
             errors: vec![
-                StringError { detail: "must be logged in to perform that action".to_string() },
+                StringError {
+                    detail: "must be logged in to perform that action".to_string(),
+                },
             ],
         });
         response.status = (403, "Forbidden");