Run cargo fmt on whole project (#272)

* Fix fallback in #270

Wrong order of arguments in `format!`.

* fmt: Remove invalid struct_lit_width option

* ci: Reformat travis config

* ci: Checking style before build

* fmt: Run cargo fmt on whole project

Author: tesuji

.travis.yml

@@ -3,7 +3,7 @@ notifications:
   email: false
 language: rust
 rust:
-- nightly
+  - nightly
 cache:
   cargo: true
   directories:
@@ -15,31 +15,34 @@ addons:
     - curl
     - libpq-dev
     - pkg-config
+before_install:
+  - rustup component add rustfmt
+  - cargo fmt --all -- --check
 install:
-- export RUST_LOG=debug,hyper=info,rustc=error,cargo=error,jobserver=error
-- export GITHUB_WEBHOOK_SECRETS=none
-- export GITHUB_ACCESS_TOKEN=
-- export GITHUB_SCRAPE_INTERVAL=6000
-- export GITHUB_USER_AGENT=none-agent-with-left-beef
-- export POST_COMMENTS=false
-- export RUST_BACKTRACE=1
-- export PATH=$PATH:$HOME/.cargo/bin
-- export DATABASE_URL=postgres://localhost/dashboard
-- export DATABASE_POOL_SIZE=5
-- rustup default $(cat rust-toolchain)
-- cargo install cargo-update || true
-- cargo install-update-config diesel_cli --default-features false --feature postgres
-- cargo install-update -i diesel_cli
+  - export RUST_LOG=debug,hyper=info,rustc=error,cargo=error,jobserver=error
+  - export GITHUB_WEBHOOK_SECRETS=none
+  - export GITHUB_ACCESS_TOKEN=
+  - export GITHUB_SCRAPE_INTERVAL=6000
+  - export GITHUB_USER_AGENT=none-agent-with-left-beef
+  - export POST_COMMENTS=false
+  - export RUST_BACKTRACE=1
+  - export PATH=$PATH:$HOME/.cargo/bin
+  - export DATABASE_URL=postgres://localhost/dashboard
+  - export DATABASE_POOL_SIZE=5
+  - rustup default $(cat rust-toolchain)
+  - cargo install cargo-update || true
+  - cargo install-update-config diesel_cli --default-features false --feature postgres
+  - cargo install-update -i diesel_cli
 before_script:
-- diesel setup
-- diesel migration run
-- psql -q -d $DATABASE_URL < githubuser-backup.pg
+  - diesel setup
+  - diesel migration run
+  - psql -q -d $DATABASE_URL < githubuser-backup.pg
 script:
-- cargo build
-- cargo test
+  - cargo build
+  - cargo test
 before_deploy:
-- DATABASE_URL=$(heroku config:get DATABASE_URL -a rfcbot-rs) diesel migration run
+  - DATABASE_URL=$(heroku config:get DATABASE_URL -a rfcbot-rs) diesel migration run
 deploy:
-  provider: heroku
-  api_key:
-    secure: "HgoF2n6pnzUhZ4oBNRo3gSoxj/o9x7QW0fKaj9sEYDNkTgak9IX3ha0antoYKB7dMw7IvB8oqVAHqldlGlG/kxUDKN8kaYA4O7CZgKP0auykTkmH61FP7MKV0hV0vyFfJLSraClVw/DL5tjYybs/rSBWFAvwttIB7QlcFv5sLIuwe5nHzftFfxba0H1+0oynO55FlmRzFBWydlFVNTsGVRddFHPgG3f2V9YYIjT18MKvn+BcV7WUq6QweB/3RjwTDYzws9mcWt6i3ju1D4nDTDVbtzeLs7Yt+NhnvrDeB+2FWSrV03LCjnnzv2zCUaROU522Vns0ZC/+2b9V3YbcCBJRA8QLBdo12JUCUzrdk8DOqIYKwlW6WbI3DcgRGz9Li7Dw2466+lsPidBfcdxnziTvc+r/2r6dKv3q7nwDpoZEyxnnTumPf50PJZs/lDu99Vo5C2NIdN2O5sqDHd8AJTLtWrY3FdN5MGKqTm0R9rVnObvUkTKbZJrDn39O5MU3mnHINUT+6ZCnNgra7rNn7Ai3tA1RKPB7kIZo41Td8j56iSLANXziCh0MikPfQv4x1scl3c1h5bR8ZqxVqH4IODjDJrJv43+hsbE9xGsmrC4OaqImLUpl/8zi6a4zZ8Na1AiFKVcdLZ9xt40/2yg7ysn53SCpQ5vty/j36clNwAE="
+  - provider: heroku
+    api_key:
+      secure: "HgoF2n6pnzUhZ4oBNRo3gSoxj/o9x7QW0fKaj9sEYDNkTgak9IX3ha0antoYKB7dMw7IvB8oqVAHqldlGlG/kxUDKN8kaYA4O7CZgKP0auykTkmH61FP7MKV0hV0vyFfJLSraClVw/DL5tjYybs/rSBWFAvwttIB7QlcFv5sLIuwe5nHzftFfxba0H1+0oynO55FlmRzFBWydlFVNTsGVRddFHPgG3f2V9YYIjT18MKvn+BcV7WUq6QweB/3RjwTDYzws9mcWt6i3ju1D4nDTDVbtzeLs7Yt+NhnvrDeB+2FWSrV03LCjnnzv2zCUaROU522Vns0ZC/+2b9V3YbcCBJRA8QLBdo12JUCUzrdk8DOqIYKwlW6WbI3DcgRGz9Li7Dw2466+lsPidBfcdxnziTvc+r/2r6dKv3q7nwDpoZEyxnnTumPf50PJZs/lDu99Vo5C2NIdN2O5sqDHd8AJTLtWrY3FdN5MGKqTm0R9rVnObvUkTKbZJrDn39O5MU3mnHINUT+6ZCnNgra7rNn7Ai3tA1RKPB7kIZo41Td8j56iSLANXziCh0MikPfQv4x1scl3c1h5bR8ZqxVqH4IODjDJrJv43+hsbE9xGsmrC4OaqImLUpl/8zi6a4zZ8Na1AiFKVcdLZ9xt40/2yg7ysn53SCpQ5vty/j36clNwAE="

rustfmt.toml

@@ -1,3 +1,2 @@
-struct_lit_width = 24
 fn_single_line = true
 format_strings = false

src/config.rs

@@ -12,11 +12,11 @@ lazy_static! {
             Ok(c) => {
                 info!("Configuration parsed from environment variables.");
                 c
-            },
+            }
             Err(missing) => {
                 error!("Unable to load environment variables {:?}", missing);
                 panic!("Unable to load environment variables {:?}", missing);
-            },
+            }
         }
     };
 }
@@ -34,8 +34,9 @@ pub struct Config {
 
 impl Config {
     pub fn check(&self) -> bool {
-        !self.db_url.is_empty() && !self.github_access_token.is_empty() &&
-        !self.github_user_agent.is_empty()
+        !self.db_url.is_empty()
+            && !self.github_access_token.is_empty()
+            && !self.github_user_agent.is_empty()
     }
 }
 
@@ -50,22 +51,24 @@ const POST_COMMENTS: &'static str = "POST_COMMENTS";
 // this is complex, but we'll shortly need a lot more config items
 // so checking them automagically seems like a nice solution
 pub fn init() -> Result<Config, Vec<&'static str>> {
-
     let mut vars: BTreeMap<&'static str, Result<String, _>> = BTreeMap::new();
-    let keys = vec![DB_URL,
-                    DB_POOL_SIZE,
-                    GITHUB_TOKEN,
-                    GITHUB_WEBHOOK_SECRETS,
-                    GITHUB_UA,
-                    POST_COMMENTS];
+    let keys = vec![
+        DB_URL,
+        DB_POOL_SIZE,
+        GITHUB_TOKEN,
+        GITHUB_WEBHOOK_SECRETS,
+        GITHUB_UA,
+        POST_COMMENTS,
+    ];
 
     for var in keys {
         vars.insert(var, env::var(var));
     }
 
     let all_found = vars.iter().all(|(_, v)| v.is_ok());
     if all_found {
-        let mut vars = vars.into_iter()
+        let mut vars = vars
+            .into_iter()
             .map(|(k, v)| (k, v.unwrap()))
             .collect::<BTreeMap<_, _>>();
 
@@ -89,19 +92,19 @@ pub fn init() -> Result<Config, Vec<&'static str>> {
         let webhook_secrets = webhook_secrets.split(',').map(String::from).collect();
 
         Ok(Config {
-               db_url: db_url,
-               db_pool_size: db_pool_size,
-               github_access_token: gh_token,
-               github_user_agent: gh_ua,
-               github_webhook_secrets: webhook_secrets,
-               github_interval_mins: gh_interval,
-               post_comments: post_comments,
-           })
-
+            db_url: db_url,
+            db_pool_size: db_pool_size,
+            github_access_token: gh_token,
+            github_user_agent: gh_ua,
+            github_webhook_secrets: webhook_secrets,
+            github_interval_mins: gh_interval,
+            post_comments: post_comments,
+        })
     } else {
-        Err(vars.iter()
-                .filter(|&(_, v)| v.is_err())
-                .map(|(&k, _)| k)
-                .collect())
+        Err(vars
+            .iter()
+            .filter(|&(_, v)| v.is_err())
+            .map(|(&k, _)| k)
+            .collect())
     }
 }

src/domain/github.rs

@@ -5,7 +5,7 @@ use chrono::NaiveDateTime;
 use super::schema::*;
 
 #[derive(AsChangeset, Clone, Debug, Queryable)]
-#[table_name="githubsync"]
+#[table_name = "githubsync"]
 pub struct GitHubSync {
     pub id: i32,
     pub successful: bool,
@@ -14,24 +14,36 @@ pub struct GitHubSync {
 }
 
 #[derive(Clone, Debug, Insertable)]
-#[table_name="githubsync"]
+#[table_name = "githubsync"]
 pub struct GitHubSyncPartial {
     pub successful: bool,
     pub ran_at: NaiveDateTime,
     pub message: Option<String>,
 }
 
-#[derive(AsChangeset, Clone, Debug, Deserialize, Eq, Insertable,
-         Ord, PartialEq, PartialOrd, Queryable, Serialize)]
-#[table_name="githubuser"]
+#[derive(
+    AsChangeset,
+    Clone,
+    Debug,
+    Deserialize,
+    Eq,
+    Insertable,
+    Ord,
+    PartialEq,
+    PartialOrd,
+    Queryable,
+    Serialize,
+)]
+#[table_name = "githubuser"]
 pub struct GitHubUser {
     pub id: i32,
     pub login: String,
 }
 
-#[derive(AsChangeset, Clone, Debug, Deserialize, Eq, Insertable,
-         Ord, PartialEq, PartialOrd, Queryable)]
-#[table_name="milestone"]
+#[derive(
+    AsChangeset, Clone, Debug, Deserialize, Eq, Insertable, Ord, PartialEq, PartialOrd, Queryable,
+)]
+#[table_name = "milestone"]
 #[changeset_options(treat_none_as_null = "true")]
 pub struct Milestone {
     pub id: i32,
@@ -49,9 +61,20 @@ pub struct Milestone {
     pub repository: String,
 }
 
-#[derive(AsChangeset, Clone, Debug, Deserialize, Eq, Insertable,
-         Ord, PartialEq, PartialOrd, Queryable, Serialize)]
-#[table_name="issue"]
+#[derive(
+    AsChangeset,
+    Clone,
+    Debug,
+    Deserialize,
+    Eq,
+    Insertable,
+    Ord,
+    PartialEq,
+    PartialOrd,
+    Queryable,
+    Serialize,
+)]
+#[table_name = "issue"]
 pub struct IssuePartial {
     pub number: i32,
     pub fk_milestone: Option<i32>,
@@ -91,9 +114,10 @@ impl IssuePartial {
     }
 }
 
-#[derive(AsChangeset, Clone, Debug, Deserialize, Eq, Ord,
-         PartialEq, PartialOrd, Queryable, Serialize)]
-#[table_name="issue"]
+#[derive(
+    AsChangeset, Clone, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd, Queryable, Serialize,
+)]
+#[table_name = "issue"]
 #[changeset_options(treat_none_as_null = "true")]
 pub struct Issue {
     pub id: i32,
@@ -113,9 +137,20 @@ pub struct Issue {
     pub repository: String,
 }
 
-#[derive(AsChangeset, Clone, Debug, Deserialize, Eq, Insertable,
-         Ord, PartialEq, PartialOrd, Queryable, Serialize)]
-#[table_name="issuecomment"]
+#[derive(
+    AsChangeset,
+    Clone,
+    Debug,
+    Deserialize,
+    Eq,
+    Insertable,
+    Ord,
+    PartialEq,
+    PartialOrd,
+    Queryable,
+    Serialize,
+)]
+#[table_name = "issuecomment"]
 #[changeset_options(treat_none_as_null = "true")]
 pub struct IssueComment {
     pub id: i32,
@@ -127,9 +162,10 @@ pub struct IssueComment {
     pub repository: String,
 }
 
-#[derive(AsChangeset, Clone, Debug, Deserialize, Eq, Insertable,
-         Ord, PartialEq, PartialOrd, Queryable)]
-#[table_name="pullrequest"]
+#[derive(
+    AsChangeset, Clone, Debug, Deserialize, Eq, Insertable, Ord, PartialEq, PartialOrd, Queryable,
+)]
+#[table_name = "pullrequest"]
 #[changeset_options(treat_none_as_null = "true")]
 pub struct PullRequest {
     pub number: i32,

src/domain/rfcbot.rs

@@ -3,7 +3,7 @@ use chrono::NaiveDateTime;
 use super::schema::*;
 
 #[derive(Clone, Debug, Eq, Ord, Insertable, PartialEq, PartialOrd)]
-#[table_name="poll"]
+#[table_name = "poll"]
 pub struct NewPoll<'a> {
     pub fk_issue: i32,
     pub fk_initiator: i32,
@@ -15,9 +15,10 @@ pub struct NewPoll<'a> {
     pub poll_teams: &'a str,
 }
 
-#[derive(AsChangeset, Clone, Debug, Deserialize, Eq, Ord,
-         PartialEq, PartialOrd, Queryable, Serialize)]
-#[table_name="poll"]
+#[derive(
+    AsChangeset, Clone, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd, Queryable, Serialize,
+)]
+#[table_name = "poll"]
 pub struct Poll {
     pub id: i32,
     pub fk_issue: i32,
@@ -31,7 +32,7 @@ pub struct Poll {
 }
 
 #[derive(Clone, Debug, Eq, Ord, Insertable, PartialEq, PartialOrd)]
-#[table_name="fcp_proposal"]
+#[table_name = "fcp_proposal"]
 pub struct NewFcpProposal<'a> {
     pub fk_issue: i32,
     pub fk_initiator: i32,
@@ -43,27 +44,29 @@ pub struct NewFcpProposal<'a> {
 }
 
 #[derive(Clone, Debug, Eq, Insertable, Ord, PartialEq, PartialOrd, Serialize)]
-#[table_name="poll_response_request"]
+#[table_name = "poll_response_request"]
 pub struct NewPollResponseRequest {
     pub fk_poll: i32,
     pub fk_respondent: i32,
     pub responded: bool,
 }
 
-#[derive(AsChangeset, Clone, Debug, Deserialize, Eq, Ord,
-         PartialEq, PartialOrd, Queryable, Serialize)]
-#[table_name="poll_response_request"]
+#[derive(
+    AsChangeset, Clone, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd, Queryable, Serialize,
+)]
+#[table_name = "poll_response_request"]
 pub struct PollResponseRequest {
     pub id: i32,
     pub fk_poll: i32,
     pub fk_respondent: i32,
     pub responded: bool,
 }
 
-#[derive(AsChangeset, Clone, Debug, Deserialize, Eq, Ord,
-         PartialEq, PartialOrd, Queryable, Serialize)]
-#[table_name="fcp_proposal"]
-#[changeset_options(treat_none_as_null="true")]
+#[derive(
+    AsChangeset, Clone, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd, Queryable, Serialize,
+)]
+#[table_name = "fcp_proposal"]
+#[changeset_options(treat_none_as_null = "true")]
 pub struct FcpProposal {
     pub id: i32,
     pub fk_issue: i32,
@@ -76,16 +79,17 @@ pub struct FcpProposal {
 }
 
 #[derive(Clone, Debug, Eq, Insertable, Ord, PartialEq, PartialOrd, Serialize)]
-#[table_name="fcp_review_request"]
+#[table_name = "fcp_review_request"]
 pub struct NewFcpReviewRequest {
     pub fk_proposal: i32,
     pub fk_reviewer: i32,
     pub reviewed: bool,
 }
 
-#[derive(AsChangeset, Clone, Debug, Deserialize, Eq, Ord,
-         PartialEq, PartialOrd, Queryable, Serialize)]
-#[table_name="fcp_review_request"]
+#[derive(
+    AsChangeset, Clone, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd, Queryable, Serialize,
+)]
+#[table_name = "fcp_review_request"]
 pub struct FcpReviewRequest {
     pub id: i32,
     pub fk_proposal: i32,
@@ -94,7 +98,7 @@ pub struct FcpReviewRequest {
 }
 
 #[derive(Clone, Debug, Eq, Insertable, Ord, PartialEq, PartialOrd)]
-#[table_name="fcp_concern"]
+#[table_name = "fcp_concern"]
 pub struct NewFcpConcern<'a> {
     pub fk_proposal: i32,
     pub fk_initiator: i32,
@@ -104,7 +108,7 @@ pub struct NewFcpConcern<'a> {
 }
 
 #[derive(AsChangeset, Clone, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd, Queryable)]
-#[table_name="fcp_concern"]
+#[table_name = "fcp_concern"]
 pub struct FcpConcern {
     pub id: i32,
     pub fk_proposal: i32,
@@ -115,7 +119,7 @@ pub struct FcpConcern {
 }
 
 #[derive(Clone, Debug, Eq, Insertable, Ord, PartialEq, PartialOrd)]
-#[table_name="rfc_feedback_request"]
+#[table_name = "rfc_feedback_request"]
 pub struct NewFeedbackRequest {
     pub fk_initiator: i32,
     pub fk_requested: i32,
@@ -124,7 +128,7 @@ pub struct NewFeedbackRequest {
 }
 
 #[derive(AsChangeset, Clone, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd, Queryable)]
-#[table_name="rfc_feedback_request"]
+#[table_name = "rfc_feedback_request"]
 pub struct FeedbackRequest {
     pub id: i32,
     pub fk_initiator: i32,

src/domain/schema.rs

@@ -171,7 +171,6 @@ joinable!(poll -> issue (fk_issue));
 joinable!(poll_response_request -> poll (fk_poll));
 joinable!(poll_response_request -> githubuser (fk_respondent));
 
-
 allow_tables_to_appear_in_same_query!(fcp_concern, githubuser);
 allow_tables_to_appear_in_same_query!(fcp_concern, fcp_proposal);
 allow_tables_to_appear_in_same_query!(fcp_proposal, githubuser);

src/error.rs

@@ -5,8 +5,8 @@ use std::convert::From;
 use std::io;
 
 use diesel;
-use serde_json;
 use rocket_contrib::templates::handlebars;
+use serde_json;
 
 pub type DashResult<T> = std::result::Result<T, DashError>;
 

src/github/client.rs

@@ -6,14 +6,14 @@ use std::time::Duration;
 use std::u32;
 
 use chrono::{DateTime, Utc};
+use reqwest::{self, header::HeaderMap, Response, StatusCode};
 use serde::de::DeserializeOwned;
 use serde_json;
-use reqwest::{self, StatusCode, Response, header::HeaderMap};
 
 use config::CONFIG;
+use domain::github::GitHubUser;
 use error::{DashError, DashResult};
 use github::models::{CommentFromJson, IssueFromJson, PullRequestFromJson, PullRequestUrls};
-use domain::github::GitHubUser;
 
 pub const BASE_URL: &'static str = "https://api.github.com";
 
@@ -36,15 +36,20 @@ impl Client {
         if !CONFIG.github_access_token.trim().is_empty() {
             headers.insert(
                 "Authorization",
-                format!("token {}", CONFIG.github_access_token).parse().unwrap(),
+                format!("token {}", CONFIG.github_access_token)
+                    .parse()
+                    .unwrap(),
             );
         }
         headers.insert("User-Agent", CONFIG.github_user_agent.parse().unwrap());
         headers.insert("Time-Zone", "UTC".parse().unwrap());
         headers.insert("Accept", "application/vnd.github.v3".parse().unwrap());
         headers.insert("Connection", "close".parse().unwrap());
         Client {
-            client: reqwest::Client::builder().default_headers(headers).build().unwrap(),
+            client: reqwest::Client::builder()
+                .default_headers(headers)
+                .build()
+                .unwrap(),
             rate_limit: u32::MAX,
             rate_limit_timeout: Utc::now(),
         }
@@ -65,39 +70,43 @@ impl Client {
                 }
             }
             throw!(DashError::Misc(None))
-
         }
         Ok(repos)
     }
 
     pub fn issues_since(&self, repo: &str, start: DateTime<Utc>) -> DashResult<Vec<IssueFromJson>> {
-        self.get_models(&format!("{}/repos/{}/issues", BASE_URL, repo),
+        self.get_models(
+            &format!("{}/repos/{}/issues", BASE_URL, repo),
             Some(&btreemap! {
                 "state" => "all".to_string(),
                 "since" => format!("{:?}", start),
                 "per_page" => format!("{}", PER_PAGE),
-                "direction" => "asc".to_string()    
-            }))
-    }
-
-    pub fn comments_since(&self,
-                          repo: &str,
-                          start: DateTime<Utc>)
-                          -> DashResult<Vec<CommentFromJson>> {
-        self.get_models(&format!("{}/repos/{}/issues/comments", BASE_URL, repo),
+                "direction" => "asc".to_string()
+            }),
+        )
+    }
+
+    pub fn comments_since(
+        &self,
+        repo: &str,
+        start: DateTime<Utc>,
+    ) -> DashResult<Vec<CommentFromJson>> {
+        self.get_models(
+            &format!("{}/repos/{}/issues/comments", BASE_URL, repo),
             Some(&btreemap! {
                 "sort" => "created".to_string(),
                 "direction" => "asc".to_string(),
                 "since" => format!("{:?}", start),
                 "per_page" => format!("{}", PER_PAGE)
-            }))
+            }),
+        )
     }
 
-    fn get_models<M: DeserializeOwned>(&self,
-                                       start_url: &str,
-                                       params: Option<&ParameterMap>)
-                                       -> DashResult<Vec<M>> {
-
+    fn get_models<M: DeserializeOwned>(
+        &self,
+        start_url: &str,
+        params: Option<&ParameterMap>,
+    ) -> DashResult<Vec<M>> {
         let mut res = self.get(start_url, params)?;
         let mut models: Vec<M> = res.json()?;
         while let Some(url) = Self::next_page(res.headers()) {
@@ -120,7 +129,6 @@ impl Client {
         if let Some(lh) = h.get("Link") {
             let lh = &lh.to_str().unwrap();
             for link in (**lh).split(',').map(|s| s.trim()) {
-
                 let tokens = link.split(';').map(|s| s.trim()).collect::<Vec<_>>();
 
                 if tokens.len() != 2 {
@@ -166,11 +174,10 @@ impl Client {
     }
 
     pub fn remove_label(&self, repo: &str, issue_num: i32, label: &str) -> DashResult<()> {
-        let url = format!("{}/repos/{}/issues/{}/labels/{}",
-                          BASE_URL,
-                          repo,
-                          issue_num,
-                          label);
+        let url = format!(
+            "{}/repos/{}/issues/{}/labels/{}",
+            BASE_URL, repo, issue_num, label
+        );
         let mut res = self.delete(&url)?;
 
         if StatusCode::NO_CONTENT != res.status() {
@@ -180,25 +187,27 @@ impl Client {
         Ok(())
     }
 
-    pub fn new_comment(&self,
-                       repo: &str,
-                       issue_num: i32,
-                       text: &str)
-                       -> DashResult<CommentFromJson> {
+    pub fn new_comment(
+        &self,
+        repo: &str,
+        issue_num: i32,
+        text: &str,
+    ) -> DashResult<CommentFromJson> {
         let url = format!("{}/repos/{}/issues/{}/comments", BASE_URL, repo, issue_num);
         let payload = serde_json::to_string(&btreemap!("body" => text))?;
         Ok(self.post(&url, &payload)?.error_for_status()?.json()?)
     }
 
-    pub fn edit_comment(&self,
-                        repo: &str,
-                        comment_num: i32,
-                        text: &str)
-                        -> DashResult<CommentFromJson> {
-        let url = format!("{}/repos/{}/issues/comments/{}",
-                          BASE_URL,
-                          repo,
-                          comment_num);
+    pub fn edit_comment(
+        &self,
+        repo: &str,
+        comment_num: i32,
+        text: &str,
+    ) -> DashResult<CommentFromJson> {
+        let url = format!(
+            "{}/repos/{}/issues/comments/{}",
+            BASE_URL, repo, comment_num
+        );
         let payload = serde_json::to_string(&btreemap!("body" => text))?;
         Ok(self.patch(&url, &payload)?.error_for_status()?.json()?)
     }

src/github/command.rs

@@ -1,21 +1,20 @@
 // Copyright 2016 Adam Perry. Dual-licensed MIT and Apache 2.0 (see LICENSE files for details).
 
-
 pub mod client;
-pub mod models;
 mod command;
+pub mod models;
 mod nag;
 pub mod webhooks;
 
 use chrono::{DateTime, NaiveDate, NaiveDateTime, NaiveTime, Utc};
-use diesel::prelude::*;
-use diesel::pg::PgConnection;
 use diesel;
+use diesel::pg::PgConnection;
+use diesel::prelude::*;
 
-use DB_POOL;
 use domain::github::*;
 use domain::schema::*;
 use error::DashResult;
+use DB_POOL;
 
 use self::client::Client;
 use self::models::{CommentFromJson, IssueFromJson, PullRequestFromJson};
@@ -27,8 +26,10 @@ lazy_static! {
 pub fn most_recent_update() -> DashResult<DateTime<Utc>> {
     info!("finding most recent github updates");
 
-    let default_date = NaiveDateTime::new(NaiveDate::from_ymd(2015, 5, 15),
-                                          NaiveTime::from_hms(0, 0, 0));
+    let default_date = NaiveDateTime::new(
+        NaiveDate::from_ymd(2015, 5, 15),
+        NaiveTime::from_hms(0, 0, 0),
+    );
 
     let conn = &*DB_POOL.get()?;
 
@@ -55,7 +56,9 @@ pub fn record_successful_update(ingest_start: NaiveDateTime) -> DashResult<()> {
         message: None,
     };
 
-    diesel::insert_into(githubsync).values(&sync_record).execute(conn)?;
+    diesel::insert_into(githubsync)
+        .values(&sync_record)
+        .execute(conn)?;
     Ok(())
 }
 
@@ -77,19 +80,22 @@ pub fn ingest_since(repo: &str, start: DateTime<Utc>) -> DashResult<()> {
         }
     }
 
-    debug!("num pull requests updated since {}: {:#?}",
-           &start,
-           prs.len());
+    debug!(
+        "num pull requests updated since {}: {:#?}",
+        &start,
+        prs.len()
+    );
 
     debug!("num issues updated since {}: {:?}", &start, issues.len());
-    debug!("num comments updated since {}: {:?}",
-           &start,
-           comments.len());
+    debug!(
+        "num comments updated since {}: {:?}",
+        &start,
+        comments.len()
+    );
 
     let conn = &*DB_POOL.get()?;
     debug!("let's insert some stuff in the database");
 
-
     // make sure we have all of the users to ensure referential integrity
     for issue in issues {
         let issue_number = issue.number;
@@ -141,9 +147,10 @@ pub fn handle_comment(conn: &PgConnection, comment: CommentFromJson, repo: &str)
     // We only want to run `nag::update_nags` on insert to avoid
     // double-processing commits, so we can't use upsert here
     if issuecomment::table
-           .find(comment.id)
-           .get_result::<IssueComment>(conn)
-           .is_ok() {
+        .find(comment.id)
+        .get_result::<IssueComment>(conn)
+        .is_ok()
+    {
         diesel::update(issuecomment::table.find(comment.id))
             .set(&comment)
             .execute(conn)?;
@@ -216,8 +223,8 @@ mod tests {
     fn test_handle_user() {
         ::utils::setup_test_env();
         let db_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
-        let conn = PgConnection::establish(&db_url)
-            .expect(&format!("Error connecting to {}", db_url));
+        let conn =
+            PgConnection::establish(&db_url).expect(&format!("Error connecting to {}", db_url));
 
         let user = GitHubUser {
             id: -1,

src/github/mod.rs

@@ -5,9 +5,9 @@ use std::i32;
 
 use chrono::{DateTime, Utc};
 
-use DB_POOL;
-use domain::github::{IssueComment, IssuePartial, Milestone, PullRequest, GitHubUser};
+use domain::github::{GitHubUser, IssueComment, IssuePartial, Milestone, PullRequest};
 use error::DashResult;
+use DB_POOL;
 
 #[derive(Clone, Debug, Deserialize)]
 pub struct MilestoneFromJson {
@@ -82,7 +82,8 @@ impl IssueFromJson {
             open: self.state == "open",
             is_pull_request: self.pull_request.is_some(),
             title: self.title.replace(0x00 as char, ""),
-            body: self.body
+            body: self
+                .body
                 .unwrap_or_else(String::new)
                 .replace(0x00 as char, ""),
             locked: self.locked,
@@ -115,7 +116,8 @@ impl CommentFromJson {
         use diesel::prelude::*;
         use domain::schema::issue::dsl::*;
 
-        let issue_number = self.html_url
+        let issue_number = self
+            .html_url
             .split('#')
             .next()
             .map(|r| r.split('/').last().map(|n| n.parse::<i32>()));
@@ -131,20 +133,21 @@ impl CommentFromJson {
 
         let conn = DB_POOL.get()?;
 
-        let issue_id = issue.select(id)
-                            .filter(number.eq(issue_number))
-                            .filter(repository.eq(repo))
-                            .first::<i32>(&*conn)?;
+        let issue_id = issue
+            .select(id)
+            .filter(number.eq(issue_number))
+            .filter(repository.eq(repo))
+            .first::<i32>(&*conn)?;
 
         Ok(IssueComment {
-               id: self.id,
-               fk_issue: issue_id,
-               fk_user: self.user.id,
-               body: self.body.replace(0x00 as char, ""),
-               created_at: self.created_at.naive_utc(),
-               updated_at: self.updated_at.naive_utc(),
-               repository: repo.to_string(),
-           })
+            id: self.id,
+            fk_issue: issue_id,
+            fk_user: self.user.id,
+            body: self.body.replace(0x00 as char, ""),
+            created_at: self.created_at.naive_utc(),
+            updated_at: self.updated_at.naive_utc(),
+            repository: repo.to_string(),
+        })
     }
 }
 

src/github/models.rs

@@ -5,10 +5,10 @@ use crypto::mac::Mac;
 use crypto::mac::MacResult;
 use crypto::sha1::Sha1;
 use hex::FromHex;
-use rocket::http::Status;
 use rocket::data::{self, Data, FromDataSimple};
-use rocket::request::Request;
+use rocket::http::Status;
 use rocket::outcome::Outcome::*;
+use rocket::request::Request;
 use serde_json;
 
 use config::CONFIG;
@@ -59,13 +59,17 @@ impl FromDataSimple for Event {
                     Ok(p) => p,
                     Err(DashError::Serde(why)) => {
                         info!("failed to parse webhook payload: {:?}", why);
-                        return Failure((Status::BadRequest,
-                                        "failed to deserialize request payload"));
+                        return Failure((
+                            Status::BadRequest,
+                            "failed to deserialize request payload",
+                        ));
                     }
                     Err(why) => {
                         error!("non-json-parsing error with webhook payload: {:?}", why);
-                        return Failure((Status::InternalServerError,
-                                        "unknown failure, check the logs"));
+                        return Failure((
+                            Status::InternalServerError,
+                            "unknown failure, check the logs",
+                        ));
                     }
                 };
 
@@ -75,17 +79,21 @@ impl FromDataSimple for Event {
                     payload: payload,
                 };
 
-                info!("Received valid webhook ({} id {})",
-                      full_event.event_name,
-                      full_event.delivery_id);
+                info!(
+                    "Received valid webhook ({} id {})",
+                    full_event.event_name, full_event.delivery_id
+                );
 
                 return Success(full_event);
             }
         }
 
         warn!("Received invalid webhook: {:?}", request);
         warn!("Invalid webhook body: `{}`", body);
-        warn!("Tried {} webhook secrets", CONFIG.github_webhook_secrets.len());
+        warn!(
+            "Tried {} webhook secrets",
+            CONFIG.github_webhook_secrets.len()
+        );
         Failure((Status::Forbidden, "unable to authenticate webhook"))
     }
 }
@@ -109,42 +117,43 @@ fn parse_event(event_name: &str, body: &str) -> DashResult<Payload> {
         "issues" => Ok(Payload::Issues(serde_json::from_str(body)?)),
         "pull_request" => Ok(Payload::PullRequest(serde_json::from_str(body)?)),
 
-        "commit_comment" |
-        "create" |
-        "delete" |
-        "deployment" |
-        "deployment_status" |
-        "fork" |
-        "gollum" |
-        "label" |
-        "member" |
-        "membership" |
-        "milestone" |
-        "organization" |
-        "page_build" |
-        "public" |
-        "pull_request_review_comment" |
-        "pull_request_review" |
-        "push" |
-        "repository" |
-        "release" |
-        "status" |
-        "team" |
-        "team_add" |
-        "watch" => {
+        "commit_comment"
+        | "create"
+        | "delete"
+        | "deployment"
+        | "deployment_status"
+        | "fork"
+        | "gollum"
+        | "label"
+        | "member"
+        | "membership"
+        | "milestone"
+        | "organization"
+        | "page_build"
+        | "public"
+        | "pull_request_review_comment"
+        | "pull_request_review"
+        | "push"
+        | "repository"
+        | "release"
+        | "status"
+        | "team"
+        | "team_add"
+        | "watch" => {
             info!("Received {} event, ignoring...", event_name);
             Ok(Payload::Unsupported)
         }
 
         _ => {
-            warn!("Received unrecognized event {}, check GitHub's API to see what's updated.",
-                  event_name);
+            warn!(
+                "Received unrecognized event {}, check GitHub's API to see what's updated.",
+                event_name
+            );
             Ok(Payload::Unsupported)
         }
     }
 }
 
-
 #[derive(Debug)]
 pub enum Payload {
     Issues(IssuesEvent),

src/github/nag.rs

@@ -43,8 +43,8 @@ mod utils;
 
 use chrono::Local;
 use diesel::pg::PgConnection;
-use diesel::r2d2::Pool;
 use diesel::r2d2::ConnectionManager;
+use diesel::r2d2::Pool;
 use env_logger::LogBuilder;
 use log::LogRecord;
 
@@ -57,12 +57,14 @@ fn main() {
     LogBuilder::new()
         .format(|rec: &LogRecord| {
             let loc = rec.location();
-            format!("[{} {}:{} {}] {}",
-                    rec.level(),
-                    loc.module_path(),
-                    loc.line(),
-                    Local::now().format("%Y-%m-%d %H:%M:%S"),
-                    rec.args())
+            format!(
+                "[{} {}:{} {}] {}",
+                rec.level(),
+                loc.module_path(),
+                loc.line(),
+                Local::now().format("%Y-%m-%d %H:%M:%S"),
+                rec.args()
+            )
         })
         .parse(&std::env::var("RUST_LOG").unwrap_or_else(|_| "info".to_string()))
         .init()
@@ -96,14 +98,11 @@ lazy_static! {
 
         let manager = ConnectionManager::<PgConnection>::new(CONFIG.db_url.clone());
 
-        match Pool::builder()
-            .max_size(CONFIG.db_pool_size)
-            .build(manager)
-        {
+        match Pool::builder().max_size(CONFIG.db_pool_size).build(manager) {
             Ok(p) => {
                 info!("DB connection pool established.");
                 p
-            },
+            }
             Err(why) => {
                 error!("Failed to establish DB connection pool: {}", why);
                 panic!("Error creating connection pool.");

src/github/webhooks.rs

@@ -1,9 +1,9 @@
 use diesel::prelude::*;
 
-use DB_POOL;
 use domain::github::{GitHubUser, Issue, IssueComment};
 use domain::rfcbot::{FcpProposal, FcpReviewRequest};
 use error::DashResult;
+use DB_POOL;
 
 #[derive(Serialize)]
 pub struct FcpWithInfo {
@@ -76,7 +76,7 @@ pub fn individual_nags(username: &str) -> DashResult<(GitHubUser, Vec<Individual
 
     let review_requests = fcp_review_request::table
         .inner_join(fcp_proposal::table)
-            .filter(fcp_proposal::fcp_start.is_null())
+        .filter(fcp_proposal::fcp_start.is_null())
         .filter(fcp_review_request::fk_reviewer.eq(user.id))
         .filter(fcp_review_request::reviewed.eq(false))
         .load::<(FcpReviewRequest, FcpProposal)>(conn)?;

src/main.rs

@@ -6,10 +6,14 @@ use config::{CONFIG, GH_ORGS};
 use github;
 
 pub fn start_scraping() -> Option<JoinHandle<()>> {
-    Some(::utils::spawn_thread("GitHub scraper", CONFIG.github_interval_mins?, || {
-        scrape_github(github::most_recent_update()?);
-        Ok(())
-    }))
+    Some(::utils::spawn_thread(
+        "GitHub scraper",
+        CONFIG.github_interval_mins?,
+        || {
+            scrape_github(github::most_recent_update()?);
+            Ok(())
+        },
+    ))
 }
 
 pub fn scrape_github(since: DateTime<Utc>) {

src/nag.rs

@@ -1,6 +1,6 @@
-use std::panic::catch_unwind;
 use rocket;
 use rocket_contrib::templates::handlebars::Handlebars;
+use std::panic::catch_unwind;
 
 pub fn serve() {
     // in debug builds this will force an init, good enough for testing
@@ -24,11 +24,11 @@ pub fn serve() {
 }
 
 mod html {
-    use std::collections::BTreeMap;
-    use rocket::response::content;
+    use super::TEMPLATES;
     use error::DashResult;
     use nag;
-    use super::TEMPLATES;
+    use rocket::response::content;
+    use std::collections::BTreeMap;
 
     type Html = content::Html<String>;
 
@@ -70,9 +70,9 @@ mod html {
             .into_iter()
             .map(|(team_label, fcps)| {
                 json!({
-                "team": team_label,
-                "fcps": fcps,
-            })
+                    "team": team_label,
+                    "fcps": fcps,
+                })
             })
             .collect::<Vec<_>>();
 
@@ -97,13 +97,13 @@ mod html {
 }
 
 mod api {
-    use rocket_contrib::json::Json;
-    use DB_POOL;
     use domain::github::GitHubUser;
     use error::DashResult;
-    use github::{handle_comment, handle_issue, handle_pr};
     use github::webhooks::{Event, Payload};
+    use github::{handle_comment, handle_issue, handle_pr};
     use nag;
+    use rocket_contrib::json::Json;
+    use DB_POOL;
 
     #[get("/all")]
     pub fn all_fcps() -> DashResult<Json<Vec<nag::FcpWithInfo>>> { Ok(Json(nag::all_fcps()?)) }
@@ -165,9 +165,11 @@ lazy_static! {
         let user_fcps_fragment = include_str!("templates/fcp-user.hbs");
         let user_fcps_template = root_template.replace("{{content}}", user_fcps_fragment);
 
-        hbars.register_template_string("all", &all_fcps_template)
+        hbars
+            .register_template_string("all", &all_fcps_template)
             .expect("unable to register all-fcps template");
-        hbars.register_template_string("user", &user_fcps_template)
+        hbars
+            .register_template_string("user", &user_fcps_template)
             .expect("unable to register user fcps template");
 
         hbars

src/scraper.rs

@@ -18,7 +18,8 @@ const UPDATE_CONFIG_EVERY_MIN: u64 = 5;
 type TeamsMap = BTreeMap<TeamLabel, Team>;
 
 lazy_static! {
-    pub static ref SETUP: Arc<RwLock<RfcbotConfig>> = Arc::new(RwLock::new(read_rfcbot_cfg_validated()));
+    pub static ref SETUP: Arc<RwLock<RfcbotConfig>> =
+        Arc::new(RwLock::new(read_rfcbot_cfg_validated()));
 }
 
 #[derive(Debug, Deserialize)]
@@ -33,9 +34,7 @@ pub struct RfcbotConfig {
 
 impl RfcbotConfig {
     /// Retrive an iterator over all the team labels.
-    pub fn team_labels(&self) -> impl Iterator<Item = &TeamLabel> {
-        self.teams().map(|(k, _)| k)
-    }
+    pub fn team_labels(&self) -> impl Iterator<Item = &TeamLabel> { self.teams().map(|(k, _)| k) }
 
     /// Retrive an iterator over all the (team label, team) pairs.
     pub fn teams(&self) -> impl Iterator<Item = (&TeamLabel, &Team)> {
@@ -47,12 +46,18 @@ impl RfcbotConfig {
 
     /// Are we allowed to auto-close issues after F-FCP in this repo?
     pub fn should_ffcp_auto_close(&self, repo: &str) -> bool {
-        self.fcp_behaviors.get(repo).map(|fcp| fcp.close).unwrap_or_default()
+        self.fcp_behaviors
+            .get(repo)
+            .map(|fcp| fcp.close)
+            .unwrap_or_default()
     }
 
     /// Are we allowed to auto-postpone issues after F-FCP in this repo?
     pub fn should_ffcp_auto_postpone(&self, repo: &str) -> bool {
-        self.fcp_behaviors.get(repo).map(|fcp| fcp.postpone).unwrap_or_default()
+        self.fcp_behaviors
+            .get(repo)
+            .map(|fcp| fcp.postpone)
+            .unwrap_or_default()
     }
 
     // Update the list of teams from external sources, if needed
@@ -62,9 +67,7 @@ impl RfcbotConfig {
             teams: TeamsMap,
         }
         if let RfcbotTeams::Remote { ref url } = &self.teams {
-            let de: ToDeserialize = ::reqwest::get(url)?
-                .error_for_status()?
-                .json()?;
+            let de: ToDeserialize = ::reqwest::get(url)?.error_for_status()?.json()?;
             self.cached_teams = de.teams;
         }
         Ok(())
@@ -87,9 +90,7 @@ pub struct FcpBehavior {
 #[serde(untagged)]
 enum RfcbotTeams {
     Local(TeamsMap),
-    Remote {
-        url: String,
-    }
+    Remote { url: String },
 }
 
 #[derive(Debug, Deserialize)]
@@ -100,9 +101,7 @@ pub struct Team {
 }
 
 impl Team {
-    pub fn ping(&self) -> &str {
-        &self.ping
-    }
+    pub fn ping(&self) -> &str { &self.ping }
 
     pub fn member_logins(&self) -> impl Iterator<Item = &str> {
         self.members.iter().map(|s| s.as_str())
@@ -132,19 +131,22 @@ pub fn start_updater_thread() {
 fn read_rfcbot_cfg_validated() -> RfcbotConfig {
     let cfg = read_rfcbot_cfg();
 
-    cfg.teams().map(|(_, v)| v).for_each(|team|
-        team.validate()
-            .expect("unable to verify team member from database.
-if you're running this for tests, make sure you've pulled github users from prod")
-    );
+    cfg.teams().map(|(_, v)| v).for_each(|team| {
+        team.validate().expect(
+            "unable to verify team member from database.
+if you're running this for tests, make sure you've pulled github users from prod",
+        )
+    });
 
     cfg
 }
 
 /// Read the unprocessed `rfcbot.toml` configuration file.
 fn read_rfcbot_cfg() -> RfcbotConfig {
-    let mut config = read_rfcbot_cfg_from(
-        include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/rfcbot.toml")));
+    let mut config = read_rfcbot_cfg_from(include_str!(concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/rfcbot.toml"
+    )));
     config.update().expect("couldn't update the configuration!");
     config
 }
@@ -161,7 +163,11 @@ impl Team {
 
         // bail if they don't exist, but we don't want to actually keep the id in ram
         for member_login in self.member_logins() {
-            if githubuser.filter(login.eq(member_login)).first::<GitHubUser>(conn).is_err() {
+            if githubuser
+                .filter(login.eq(member_login))
+                .first::<GitHubUser>(conn)
+                .is_err()
+            {
                 ::github::handle_user(&conn, &gh.get_user(member_login)?)?;
                 info!("loaded into the database user {}", member_login);
             }
@@ -180,8 +186,8 @@ pub mod test {
     use super::*;
 
     lazy_static! {
-        pub static ref TEST_SETUP: RfcbotConfig =
-            read_rfcbot_cfg_from(r#"
+        pub static ref TEST_SETUP: RfcbotConfig = read_rfcbot_cfg_from(
+            r#"
 [fcp_behaviors]
 
 [fcp_behaviors."rust-lang/alpha"]
@@ -220,33 +226,45 @@ members = [
   "batman",
   "theflash"
 ]
-"#);
+"#
+        );
     }
 
     #[test]
     fn setup_parser_correct() {
         let cfg = &*TEST_SETUP;
 
         // Labels are correct:
-        assert_eq!(cfg.team_labels().map(|tl| tl.0.clone()).collect::<Vec<_>>(),
-                   vec!["T-avengers", "justice-league"]);
+        assert_eq!(
+            cfg.team_labels().map(|tl| tl.0.clone()).collect::<Vec<_>>(),
+            vec!["T-avengers", "justice-league"]
+        );
 
         // Teams are correct:
-        let map: BTreeMap<_, _> =
-            cfg.teams().map(|(k, v)| (k.0.clone(), v.clone())).collect();
+        let map: BTreeMap<_, _> = cfg.teams().map(|(k, v)| (k.0.clone(), v.clone())).collect();
 
         let avengers = map.get("T-avengers").unwrap();
         //assert_eq!(avengers.name, "The Avengers");
         //assert_eq!(avengers.ping, "marvel/avengers");
-        assert_eq!(avengers.member_logins().collect::<Vec<_>>(),
-            vec!["hulk", "thor", "thevision", "blackwidow",
-                 "spiderman", "captainamerica"]);
+        assert_eq!(
+            avengers.member_logins().collect::<Vec<_>>(),
+            vec![
+                "hulk",
+                "thor",
+                "thevision",
+                "blackwidow",
+                "spiderman",
+                "captainamerica"
+            ]
+        );
 
         let jsa = map.get("justice-league").unwrap();
         //assert_eq!(jsa.name, "Justice League of America");
         //assert_eq!(jsa.ping, "dc-comics/justice-league");
-        assert_eq!(jsa.member_logins().collect::<Vec<_>>(),
-            vec!["superman", "wonderwoman", "aquaman", "batman", "theflash"]);
+        assert_eq!(
+            jsa.member_logins().collect::<Vec<_>>(),
+            vec!["superman", "wonderwoman", "aquaman", "batman", "theflash"]
+        );
 
         // Random non-existent team does not exist:
         assert!(map.get("random").is_none());

src/server.rs

@@ -1,27 +1,29 @@
-use std::time::Duration;
-use std::thread::{self, JoinHandle};
 use error::DashResult;
+use std::thread::{self, JoinHandle};
+use std::time::Duration;
 
 pub(crate) fn spawn_thread<F>(name: &'static str, interval_minutes: u64, f: F) -> JoinHandle<()>
 where
     F: Fn() -> DashResult<()> + Send + 'static,
 {
     let duration = Duration::from_secs(interval_minutes * 60);
-    thread::spawn(move || {
-        loop {
-            if let Err(err) = f() {
-                error!("the {} thread failed an iteration: {:?}", name, err);
-            }
-            info!("{} thread sleeping for {} seconds", name, duration.as_secs());
-            thread::sleep(duration);
+    thread::spawn(move || loop {
+        if let Err(err) = f() {
+            error!("the {} thread failed an iteration: {:?}", name, err);
         }
+        info!(
+            "{} thread sleeping for {} seconds",
+            name,
+            duration.as_secs()
+        );
+        thread::sleep(duration);
     })
 }
 
 #[cfg(test)]
 pub(crate) fn setup_test_env() {
-    use std::sync::Once;
     use std::path::Path;
+    use std::sync::Once;
 
     static ONCE: Once = Once::new();
     ONCE.call_once(|| {