Run format

Author: Mauricio Cassola

parser/src/command.rs

@@ -5,6 +5,7 @@ use regex::Regex;
 
 pub mod assign;
 pub mod close;
+pub mod decision;
 pub mod glacier;
 pub mod nominate;
 pub mod note;
@@ -13,7 +14,6 @@ pub mod prioritize;
 pub mod relabel;
 pub mod second;
 pub mod shortcut;
-pub mod decision;
 
 #[derive(Debug, PartialEq)]
 pub enum Command<'a> {

parser/src/command/decision.rs

@@ -8,34 +8,35 @@
 //! Command: `@bot merge`, `@bot hold`, `@bot restart`, `@bot dissent`, `@bot stabilize` or `@bot close`.
 //! ```
 
-use crate::token::{Token, Tokenizer};
 use crate::error::Error;
-use serde::{Deserialize, Serialize};
+use crate::token::{Token, Tokenizer};
 use postgres_types::{FromSql, ToSql};
+use serde::{Deserialize, Serialize};
 
 /// A command as parsed and received from calling the bot with some arguments,
 /// like `@rustbot merge`
 #[derive(Debug, Eq, PartialEq)]
 pub struct DecisionCommand {
     pub resolution: Resolution,
-    pub reversibility: Reversibility
+    pub reversibility: Reversibility,
 }
 
 impl DecisionCommand {
     pub fn parse<'a>(input: &mut Tokenizer<'a>) -> Result<Option<Self>, Error<'a>> {
         if let Some(Token::Word("merge")) = input.peek_token()? {
-        Ok(Some(Self {
-            resolution: Resolution::Merge,
-            reversibility: Reversibility::Reversible
-        })) } else {
+            Ok(Some(Self {
+                resolution: Resolution::Merge,
+                reversibility: Reversibility::Reversible,
+            }))
+        } else {
             Ok(None)
         }
     }
 }
 
 #[derive(Debug, Eq, PartialEq)]
 pub enum ParseError {
-    InvalidFirstCommand
+    InvalidFirstCommand,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, ToSql, FromSql, Eq, PartialEq)]

src/db.rs

@@ -8,8 +8,8 @@ use std::sync::{Arc, Mutex};
 use tokio::sync::{OwnedSemaphorePermit, Semaphore};
 use tokio_postgres::Client as DbClient;
 
-pub mod issue_decision_state;
 pub mod issue_data;
+pub mod issue_decision_state;
 pub mod jobs;
 pub mod notifications;
 pub mod rustc_commits;
@@ -280,7 +280,7 @@ CREATE TYPE reversibility AS ENUM ('reversible', 'irreversible');
     "
 CREATE TYPE resolution AS ENUM ('hold', 'merge');
 ",
-"CREATE TABLE issue_decision_state (
+    "CREATE TABLE issue_decision_state (
     issue_id BIGINT PRIMARY KEY,
     initiator TEXT NOT NULL,
     start_date TIMESTAMP WITH TIME ZONE NOT NULL,

src/db/issue_decision_state.rs

@@ -1,11 +1,11 @@
-//! The issue decision state table provides a way to store 
+//! The issue decision state table provides a way to store
 //! the decision process state of each issue
 
-use serde::{Deserialize, Serialize};
+use anyhow::{Context as _, Result};
 use chrono::{DateTime, FixedOffset};
-use std::collections::BTreeMap;
 use parser::command::decision::{Resolution, Reversibility};
-use anyhow::{Context as _, Result};
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
 use tokio_postgres::Client as DbClient;
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -54,13 +54,13 @@ pub async fn insert_issue_decision_state(
 }
 
 pub async fn update_issue_decision_state(
-    db: &DbClient, 
+    db: &DbClient,
     issue_number: &u64,
     end_date: &DateTime<FixedOffset>,
     current: &BTreeMap<String, UserStatus>,
     history: &BTreeMap<String, Vec<UserStatus>>,
     reversibility: &Reversibility,
-    resolution: &Resolution
+    resolution: &Resolution,
 ) -> Result<()> {
     tracing::trace!("update_issue_decision_state(issue_id={})", issue_number);
     let issue_id = *issue_number as i64;
@@ -74,18 +74,21 @@ pub async fn update_issue_decision_state(
     Ok(())
 }
 
-pub async fn get_issue_decision_state(db: &DbClient, issue_number: &u64) -> Result<IssueDecisionState> {
+pub async fn get_issue_decision_state(
+    db: &DbClient,
+    issue_number: &u64,
+) -> Result<IssueDecisionState> {
     tracing::trace!("get_issue_decision_state(issue_id={})", issue_number);
     let issue_id = *issue_number as i64;
 
     let state = db
         .query_one(
             "SELECT * FROM issue_decision_state WHERE issue_id = $1",
-            &[&issue_id]
+            &[&issue_id],
         )
         .await
         .context("Getting decision state data")?;
-    
+
     deserialize_issue_decision_state(&state)
 }
 
@@ -95,7 +98,8 @@ fn deserialize_issue_decision_state(row: &tokio_postgres::row::Row) -> Result<Is
     let start_date: DateTime<FixedOffset> = row.try_get(2)?;
     let end_date: DateTime<FixedOffset> = row.try_get(3)?;
     let current: BTreeMap<String, UserStatus> = serde_json::from_value(row.try_get(4).unwrap())?;
-    let history: BTreeMap<String, Vec<UserStatus>> = serde_json::from_value(row.try_get(5).unwrap())?;
+    let history: BTreeMap<String, Vec<UserStatus>> =
+        serde_json::from_value(row.try_get(5).unwrap())?;
     let reversibility: Reversibility = row.try_get(6)?;
     let resolution: Resolution = row.try_get(7)?;
 

src/handlers.rs

@@ -26,6 +26,7 @@ impl fmt::Display for HandlerError {
 mod assign;
 mod autolabel;
 mod close;
+mod decision;
 pub mod docs_update;
 mod github_releases;
 mod glacier;
@@ -45,7 +46,6 @@ mod review_submitted;
 mod rfc_helper;
 pub mod rustc_commits;
 mod shortcut;
-mod decision;
 
 pub async fn handle(ctx: &Context, event: &Event) -> Vec<HandlerError> {
     let config = config::get(&ctx.github, event.repo()).await;

src/handlers/decision.rs

@@ -1,15 +1,11 @@
-use anyhow::Context as Ctx;
 use crate::{
-    config::DecisionConfig,
-    github::{Event},
-    handlers::Context,
+    config::DecisionConfig, db::issue_decision_state::*, github::Event, handlers::Context,
     interactions::ErrorComment,
-    db::issue_decision_state::*
 };
+use anyhow::Context as Ctx;
 use chrono::{DateTime, Duration, FixedOffset};
 use parser::command::decision::{DecisionCommand, Resolution::*, Reversibility::*};
 use std::collections::BTreeMap;
-use chrono::{DateTime, FixedOffset, Duration};
 
 // get state for issue_id from db
 // if no state (first call)
@@ -33,20 +29,19 @@ pub(super) async fn handle_command(
 
     let DecisionCommand {
         resolution,
-        reversibility
+        reversibility,
     } = cmd;
 
     let issue = event.issue().unwrap();
     let user = event.user();
 
-    let is_team_member = 
-        user
-        .is_team_member(&ctx.github)
-        .await
-        .unwrap_or(false);
+    let is_team_member = user.is_team_member(&ctx.github).await.unwrap_or(false);
 
     if !is_team_member {
-        let cmnt = ErrorComment::new(&issue, "Only team members can be part of the decision process.");
+        let cmnt = ErrorComment::new(
+            &issue,
+            "Only team members can be part of the decision process.",
+        );
         cmnt.post(&ctx.github).await?;
         return Ok(());
     }
@@ -57,41 +52,45 @@ pub(super) async fn handle_command(
             //     Hold => "hold".into(),
             //     Custom(name) => name,
             // };
-    
+
             // let mut current_statuses = state.current_statuses;
             // let mut status_history = state.status_history;
-    
+
             // if let Some(entry) = current_statuses.get_mut(&user) {
             //     let past = status_history.entry(user).or_insert(Vec::new());
-    
+
             //     past.push(entry.clone());
-    
+
             //     *entry = UserStatus::new(name, issue_id, comment_id);
             // } else {
             //     current_statuses.insert(user, UserStatus::new("hold".into(), issue_id, comment_id));
             // }
-    
+
             // Ok(State {
             //     current_statuses,
             //     status_history,
             //     ..state
             // })
             Ok(())
-        },
+        }
         _ => {
             match resolution {
                 Hold => Ok(()), // change me!
                 Merge => {
                     let start_date: DateTime<FixedOffset> = chrono::Utc::now().into();
-                    let end_date: DateTime<FixedOffset> = start_date.checked_add_signed(Duration::days(10)).unwrap();
+                    let end_date: DateTime<FixedOffset> =
+                        start_date.checked_add_signed(Duration::days(10)).unwrap();
 
                     let mut current: BTreeMap<String, UserStatus> = BTreeMap::new();
-                    current.insert("mcass19".to_string(), UserStatus{
-                        comment_id: "comment_id".to_string(),
-                        text: "something".to_string(),
-                        reversibility: Reversible,
-                        resolution: Merge,
-                    });
+                    current.insert(
+                        "mcass19".to_string(),
+                        UserStatus {
+                            comment_id: "comment_id".to_string(),
+                            text: "something".to_string(),
+                            reversibility: Reversible,
+                            resolution: Merge,
+                        },
+                    );
                     let history: BTreeMap<String, Vec<UserStatus>> = BTreeMap::new();
 
                     insert_issue_decision_state(
@@ -104,15 +103,16 @@ pub(super) async fn handle_command(
                         &history,
                         &reversibility,
                         &Merge,
-                    ).await?;
+                    )
+                    .await?;
 
                     // let team = github::get_team(&ctx.github, &"T-lang"); // change this to be configurable in toml?
-                
+
                     let comment = format!(
                         "Wow, it looks like you want to merge this, {}.\n| Team member | State |\n|-------------|-------|\n| julmontesdeoca | merge |\n| mcass19 |  |",
                         user.login
                     );
-                
+
                     issue
                         .post_comment(&ctx.github, &comment)
                         .await