rustfmt

Author: sgrif

src/app.rs

@@ -1,12 +1,7 @@
 //! Application-wide components in a struct accessible from each request
 
 use crate::{db, util::CargoResult, Config, Env};
-use std::{
-    env,
-    path::PathBuf,
-    sync::Arc,
-    time::Duration,
-};
+use std::{env, path::PathBuf, sync::Arc, time::Duration};
 
 use diesel::r2d2;
 use scheduled_thread_pool::ScheduledThreadPool;

src/background/job.rs

@@ -1,5 +1,5 @@
 use diesel::PgConnection;
-use serde::{Serialize, de::DeserializeOwned};
+use serde::{de::DeserializeOwned, Serialize};
 
 use super::storage;
 use crate::util::CargoResult;

src/background/registry.rs

@@ -6,7 +6,8 @@ use super::Job;
 use crate::util::CargoResult;
 
 #[doc(hidden)]
-pub type PerformFn<Env> = Box<dyn Fn(serde_json::Value, &Env) -> CargoResult<()> + RefUnwindSafe + Send + Sync>;
+pub type PerformFn<Env> =
+    Box<dyn Fn(serde_json::Value, &Env) -> CargoResult<()> + RefUnwindSafe + Send + Sync>;
 
 #[derive(Default)]
 #[allow(missing_debug_implementations)] // Can't derive debug
@@ -32,9 +33,12 @@ impl<Env> Registry<Env> {
     /// Register a new background job. This will override any existing
     /// registries with the same `JOB_TYPE`, if one exists.
     pub fn register<T: Job<Environment = Env>>(&mut self) {
-        self.job_types.insert(T::JOB_TYPE, Box::new(|data, env| {
-            let data = serde_json::from_value(data)?;
-            T::perform(data, env)
-        }));
+        self.job_types.insert(
+            T::JOB_TYPE,
+            Box::new(|data, env| {
+                let data = serde_json::from_value(data)?;
+                T::perform(data, env)
+            }),
+        );
     }
 }

src/background/runner.rs

@@ -1,12 +1,12 @@
 #![allow(dead_code)]
 use diesel::prelude::*;
 use std::any::Any;
-use std::panic::{catch_unwind, UnwindSafe, RefUnwindSafe, PanicInfo};
+use std::panic::{catch_unwind, PanicInfo, RefUnwindSafe, UnwindSafe};
 use std::sync::Arc;
 use threadpool::ThreadPool;
 
+use super::{storage, Job, Registry};
 use crate::db::{DieselPool, DieselPooledConn};
-use super::{storage, Registry, Job};
 use crate::util::errors::*;
 
 #[allow(missing_debug_implementations)]
@@ -68,7 +68,8 @@ impl<Env: RefUnwindSafe + Send + Sync + 'static> Runner<Env> {
         let environment = Arc::clone(&self.environment);
         let registry = Arc::clone(&self.registry);
         self.get_single_job(move |job| {
-            let perform_fn = registry.get(&job.job_type)
+            let perform_fn = registry
+                .get(&job.job_type)
                 .ok_or_else(|| internal(&format_args!("Unknown job type {}", job.job_type)))?;
             perform_fn(job.data, &environment)
         })
@@ -100,7 +101,8 @@ impl<Env: RefUnwindSafe + Send + Sync + 'static> Runner<Env> {
                     }
                 }
                 Ok(())
-            }).expect("Could not retrieve or update job")
+            })
+            .expect("Could not retrieve or update job")
         })
     }
 
@@ -144,10 +146,10 @@ mod tests {
     use diesel::prelude::*;
     use diesel::r2d2;
 
+    use super::*;
     use crate::schema::background_jobs::dsl::*;
-    use std::sync::{Mutex, MutexGuard, Barrier, Arc};
     use std::panic::AssertUnwindSafe;
-    use super::*;
+    use std::sync::{Arc, Barrier, Mutex, MutexGuard};
 
     #[test]
     fn jobs_are_locked_when_fetched() {
@@ -185,12 +187,11 @@ mod tests {
         let runner = runner();
         create_dummy_job(&runner);
 
-        runner.get_single_job(|_| {
-            Ok(())
-        });
+        runner.get_single_job(|_| Ok(()));
         runner.wait_for_jobs();
 
-        let remaining_jobs = background_jobs.count()
+        let remaining_jobs = background_jobs
+            .count()
             .get_result(&runner.connection().unwrap());
         assert_eq!(Ok(0), remaining_jobs);
     }
@@ -243,9 +244,7 @@ mod tests {
         let runner = runner();
         let job_id = create_dummy_job(&runner).id;
 
-        runner.get_single_job(|_| {
-            panic!()
-        });
+        runner.get_single_job(|_| panic!());
         runner.wait_for_jobs();
 
         let tries = background_jobs
@@ -289,14 +288,9 @@ mod tests {
         let database_url =
             dotenv::var("TEST_DATABASE_URL").expect("TEST_DATABASE_URL must be set to run tests");
         let manager = r2d2::ConnectionManager::new(database_url);
-        let pool = r2d2::Pool::builder()
-            .max_size(2)
-            .build(manager)
-            .unwrap();
+        let pool = r2d2::Pool::builder().max_size(2).build(manager).unwrap();
 
-        Runner::builder(pool, ())
-            .thread_count(2)
-            .build()
+        Runner::builder(pool, ()).thread_count(2).build()
     }
 
     fn create_dummy_job(runner: &Runner<()>) -> storage::BackgroundJob {

src/background/storage.rs

@@ -1,12 +1,12 @@
 use diesel::dsl::now;
 use diesel::pg::Pg;
 use diesel::prelude::*;
-use diesel::{delete, insert_into, update};
 use diesel::sql_types::{Bool, Integer, Interval};
+use diesel::{delete, insert_into, update};
 use serde_json;
 
-use crate::schema::background_jobs;
 use super::Job;
+use crate::schema::background_jobs;
 use crate::util::CargoResult;
 
 #[derive(Queryable, Identifiable, Debug, Clone)]
@@ -22,10 +22,7 @@ pub fn enqueue_job<T: Job>(conn: &PgConnection, job: T) -> CargoResult<()> {
 
     let job_data = serde_json::to_value(job)?;
     insert_into(background_jobs)
-        .values((
-            job_type.eq(T::JOB_TYPE),
-            data.eq(job_data),
-        ))
+        .values((job_type.eq(T::JOB_TYPE), data.eq(job_data)))
         .execute(conn)?;
     Ok(())
 }
@@ -67,10 +64,7 @@ pub fn failed_job_count(conn: &PgConnection) -> QueryResult<i64> {
 pub fn available_job_count(conn: &PgConnection) -> QueryResult<i64> {
     use crate::schema::background_jobs::dsl::*;
 
-    background_jobs
-        .count()
-        .filter(retriable())
-        .get_result(conn)
+    background_jobs.count().filter(retriable()).get_result(conn)
 }
 
 /// Deletes a job that has successfully completed running
@@ -89,9 +83,6 @@ pub fn update_failed_job(conn: &PgConnection, job_id: i64) {
     use crate::schema::background_jobs::dsl::*;
 
     let _ = update(background_jobs.find(job_id))
-        .set((
-            retries.eq(retries + 1),
-            last_retry.eq(now),
-        ))
+        .set((retries.eq(retries + 1), last_retry.eq(now)))
         .execute(conn);
 }

src/background_jobs.rs

@@ -1,13 +1,10 @@
 use url::Url;
 
-use crate::background::{Runner, Builder};
+use crate::background::{Builder, Runner};
 use crate::git::{AddCrate, Yank};
 
 pub fn job_runner(config: Builder<Environment>) -> Runner<Environment> {
-    config
-        .register::<AddCrate>()
-        .register::<Yank>()
-        .build()
+    config.register::<AddCrate>().register::<Yank>().build()
 }
 
 #[allow(missing_debug_implementations)]
@@ -18,6 +15,8 @@ pub struct Environment {
 
 impl Environment {
     pub fn credentials(&self) -> Option<(&str, &str)> {
-        self.credentials.as_ref().map(|(u, p)| (u.as_str(), p.as_str()))
+        self.credentials
+            .as_ref()
+            .map(|(u, p)| (u.as_str(), p.as_str()))
     }
 }

src/git.rs

@@ -10,8 +10,8 @@ use url::Url;
 
 use crate::background::Job;
 use crate::background_jobs::Environment;
-use crate::util::{internal, CargoResult};
 use crate::models::DependencyKind;
+use crate::util::{internal, CargoResult};
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct Crate {
@@ -61,7 +61,8 @@ impl Repository {
     }
 
     fn index_file(&self, name: &str) -> PathBuf {
-        self.checkout_path.path()
+        self.checkout_path
+            .path()
             .join(self.relative_index_file(name))
     }
 
@@ -75,7 +76,12 @@ impl Repository {
         }
     }
 
-    fn commit_and_push(&self, msg: &str, modified_file: &Path, credentials: Option<(&str, &str)>) -> CargoResult<()> {
+    fn commit_and_push(
+        &self,
+        msg: &str,
+        modified_file: &Path,
+        credentials: Option<(&str, &str)>,
+    ) -> CargoResult<()> {
         // git add $file
         let mut index = self.repository.index()?;
         index.add_path(modified_file)?;
@@ -87,14 +93,19 @@ impl Repository {
         let head = self.repository.head()?;
         let parent = self.repository.find_commit(head.target().unwrap())?;
         let sig = self.repository.signature()?;
-        self.repository.commit(Some("HEAD"), &sig, &sig, &msg, &tree, &[&parent])?;
+        self.repository
+            .commit(Some("HEAD"), &sig, &sig, &msg, &tree, &[&parent])?;
 
         // git push
         let mut ref_status = Ok(());
         {
             let mut origin = self.repository.find_remote("origin")?;
             let mut callbacks = git2::RemoteCallbacks::new();
-            callbacks.credentials(|_, _, _| credentials.ok_or_else(|| git2::Error::from_str("no authentication set")).and_then(|(u, p)| git2::Cred::userpass_plaintext(u, p)));
+            callbacks.credentials(|_, _, _| {
+                credentials
+                    .ok_or_else(|| git2::Error::from_str("no authentication set"))
+                    .and_then(|(u, p)| git2::Cred::userpass_plaintext(u, p))
+            });
             callbacks.push_update_reference(|refname, status| {
                 assert_eq!(refname, "refs/heads/master");
                 if let Some(s) = status {
@@ -138,9 +149,7 @@ impl Job for AddCrate {
 }
 
 pub fn add_crate(conn: &PgConnection, krate: Crate) -> CargoResult<()> {
-    AddCrate { krate }
-        .enqueue(conn)
-        .map_err(Into::into)
+    AddCrate { krate }.enqueue(conn).map_err(Into::into)
 }
 
 #[derive(Serialize, Deserialize)]
@@ -169,7 +178,8 @@ impl Job for Yank {
                 }
                 git_crate.yanked = Some(self.yanked);
                 Ok(serde_json::to_string(&git_crate)?)
-            }).collect::<CargoResult<Vec<String>>>();
+            })
+            .collect::<CargoResult<Vec<String>>>();
         let new = new?.join("\n") + "\n";
         fs::write(&dst, new.as_bytes())?;
 
@@ -190,8 +200,17 @@ impl Job for Yank {
 /// file, deserlialise the crate from JSON, change the yank boolean to
 /// `true` or `false`, write all the lines back out, and commit and
 /// push the changes.
-pub fn yank(conn: &PgConnection, krate: String, version: semver::Version, yanked: bool) -> CargoResult<()> {
-    Yank { krate, version: version.to_string(), yanked }
-        .enqueue(conn)
-        .map_err(Into::into)
+pub fn yank(
+    conn: &PgConnection,
+    krate: String,
+    version: semver::Version,
+    yanked: bool,
+) -> CargoResult<()> {
+    Yank {
+        krate,
+        version: version.to_string(),
+        yanked,
+    }
+    .enqueue(conn)
+    .map_err(Into::into)
 }

src/middleware/run_pending_background_jobs.rs

@@ -1,7 +1,7 @@
-use crate::background::Runner;
-use crate::background_jobs::*;
 use super::app::RequestApp;
 use super::prelude::*;
+use crate::background::Runner;
+use crate::background_jobs::*;
 
 pub struct RunPendingBackgroundJobs;
 
@@ -22,7 +22,9 @@ impl Middleware for RunPendingBackgroundJobs {
         let runner = job_runner(config);
 
         runner.run_all_pending_jobs().expect("Could not run jobs");
-        runner.assert_no_failed_jobs().expect("Could not determine if jobs failed");
+        runner
+            .assert_no_failed_jobs()
+            .expect("Could not determine if jobs failed");
         res
     }
 }