cargo fmt

4 files changed, 124 insertions, 112 deletions

diff --git a/src/agenda.rs b/src/agenda.rs
index dc57775..2543daa 100644
--- a/src/agenda.rs
+++ b/src/agenda.rs
@@ -1,11 +1,5 @@
-use serde::{
-    Deserialize,
-    Serialize,
-};
-use std::{
-    fmt,
-    fs,
-};
+use serde::{Deserialize, Serialize};
+use std::{fmt, fs};
 use tokio::sync::mpsc;
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
@@ -33,9 +27,11 @@ pub struct Agenda {
 
 impl Agenda {
     fn write(&self) {
-        fs::write(std::path::Path::new("agenda.json"),
-                serde_json::to_string_pretty(&self).expect("Can't serialize agenda"))
-            .expect("Can't write agenda.json");
+        fs::write(
+            std::path::Path::new("agenda.json"),
+            serde_json::to_string_pretty(&self).expect("Can't serialize agenda"),
+        )
+        .expect("Can't write agenda.json");
     }
 }
 
@@ -49,8 +45,11 @@ pub fn parse_message<F>(
     message: &str,
     sender: &str,
     send_message: F,
-    point_sender: &mpsc::UnboundedSender<AgendaPoint>
-) -> Option<Emoji> where F: FnOnce(String) {
+    point_sender: &mpsc::UnboundedSender<AgendaPoint>,
+) -> Option<Emoji>
+where
+    F: FnOnce(String),
+{
     if message.starts_with("!add ") {
         let mut agenda = read_agenda();
         let agenda_point = AgendaPoint {
@@ -63,20 +62,18 @@ pub fn parse_message<F>(
         Some(Emoji::Ok)
     } else if message.starts_with("!agenda") {
         let s = read_agenda()
-                .points
-                .iter()
-                .map(|p| p.to_string())
-                .collect::<Vec<_>>()
-                .join("\n");
+            .points
+            .iter()
+            .map(|p| p.to_string())
+            .collect::<Vec<_>>()
+            .join("\n");
         send_message(match s.as_str() {
             "" => "Agenda is empty".to_string(),
-            _ => s
+            _ => s,
         });
         None
     } else if message.starts_with("!clear") {
-        Agenda {
-            points: Vec::new(),
-        }.write();
+        Agenda { points: Vec::new() }.write();
         Some(Emoji::Ok)
     } else if message.starts_with("!help") {
         send_message("Available commands:\n```!add    -- Add something\n!agenda -- Print the agenda\n!clear  -- Remove all items\n!help```".to_string());
@@ -90,7 +87,7 @@ pub fn parse_message<F>(
 
 fn read_agenda() -> Agenda {
     serde_json::from_str::<Agenda>(
-        &fs::read_to_string("agenda.json")
-            .expect("Can't read agenda.json"))
-        .expect("Error parsing agenda.json")
+        &fs::read_to_string("agenda.json").expect("Can't read agenda.json"),
+    )
+    .expect("Error parsing agenda.json")
 }
diff --git a/src/discord.rs b/src/discord.rs
index 0cca552..e0119a4 100644
--- a/src/discord.rs
+++ b/src/discord.rs
@@ -2,8 +2,7 @@ use crate::agenda::{parse_message, AgendaPoint, Emoji};
 
 use discord::{
     model::{ChannelId, Event, PossibleServer, ReactionEmoji, UserId},
-    Discord,
-    Error,
+    Discord, Error,
 };
 use futures::join;
 use std::{
@@ -66,26 +65,25 @@ fn receive_events(handler: &mut Handler) {
             Ok(Event::ServerCreate(server)) => {
                 if let PossibleServer::Online(server) = server {
                     if handler.channel.is_none() {
-                        println!("Discord channels in {}: {:#?}",
-                                 server.name,
-                                 server
-                                 .channels
-                                 .iter()
-                                 .map(|channel|
-                                      format!("{}: {} ({:?})",
-                                              channel.name,
-                                              channel.id,
-                                              channel.kind))
-                                 .collect::<Vec<_>>());
+                        println!(
+                            "Discord channels in {}: {:#?}",
+                            server.name,
+                            server
+                                .channels
+                                .iter()
+                                .map(|channel| format!(
+                                    "{}: {} ({:?})",
+                                    channel.name, channel.id, channel.kind
+                                ))
+                                .collect::<Vec<_>>()
+                        );
                     }
                     for member in server.members {
                         if let Some(nick) = member.nick {
                             handler.display_names.insert(member.user.id, nick);
                         }
                     }
-
-                }
-                else if let PossibleServer::Offline(server) = server {
+                } else if let PossibleServer::Offline(server) = server {
                     if handler.channel.is_none() {
                         println!("Server {} is offline", server);
                     }
@@ -97,7 +95,9 @@ fn receive_events(handler: &mut Handler) {
                     if channel == message.channel_id {
                         match parse_message(
                             &message.content,
-                            if let Some(display_name) = handler.display_names.get(&message.author.id) {
+                            if let Some(display_name) =
+                                handler.display_names.get(&message.author.id)
+                            {
                                 display_name
                             } else {
                                 println!("Missing display name for '{}' (see 'Discord display names' in the readme)",
@@ -105,20 +105,26 @@ fn receive_events(handler: &mut Handler) {
                                 &message.author.name
                             },
                             |s: String| {
-                                handler.client
+                                handler
+                                    .client
                                     .lock()
                                     .unwrap()
                                     .send_message(channel, &s, "", false)
                                     .unwrap();
                             },
-                            &handler.sender
+                            &handler.sender,
                         ) {
                             Some(Emoji::Ok) => {
-                                handler.client.lock().unwrap().add_reaction(
-                                    channel,
-                                    message.id,
-                                    ReactionEmoji::Unicode("👍".to_string())
-                                ).unwrap();
+                                handler
+                                    .client
+                                    .lock()
+                                    .unwrap()
+                                    .add_reaction(
+                                        channel,
+                                        message.id,
+                                        ReactionEmoji::Unicode("👍".to_string()),
+                                    )
+                                    .unwrap();
                             }
                             _ => {}
                         }
@@ -140,18 +146,16 @@ fn receive_events(handler: &mut Handler) {
 async fn receive_from_slack(
     mut receiver: mpsc::UnboundedReceiver<AgendaPoint>,
     client: Arc<Mutex<discord::Discord>>,
-    channel: Option<ChannelId>
+    channel: Option<ChannelId>,
 ) {
     if let Some(channel) = channel {
         while let Some(point) = receiver.recv().await {
             println!("Discord received '{}'", point);
-            client.lock().unwrap().send_message(
-                channel,
-                &point.to_add_message(),
-                "",
-                false
-            ).unwrap();
+            client
+                .lock()
+                .unwrap()
+                .send_message(channel, &point.to_add_message(), "", false)
+                .unwrap();
         }
     }
-
 }
diff --git a/src/main.rs b/src/main.rs
index 0bcf53c..47daed8 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -18,4 +18,3 @@ async fn main() {
         slack::handle(from_slack, to_slack),
     );
 }
-
diff --git a/src/slack.rs b/src/slack.rs
index 0dfef52..49c8cfa 100644
--- a/src/slack.rs
+++ b/src/slack.rs
@@ -42,7 +42,6 @@ impl Handler {
             display_names: Arc::new(Mutex::new(HashMap::new())),
         }
     }
-
 }
 
 async fn get_or_insert_display_name(
@@ -54,19 +53,18 @@ async fn get_or_insert_display_name(
         Entry::Occupied(o) => o.get().to_string(),
         Entry::Vacant(v) => {
             let client = slack_api::requests::default_client().unwrap();
-            if let Some(user) = users::list(
-                &client,
-                slack_token,
-                &users::ListRequest {presence: None}
-            ).compat()
-             .await
-             .unwrap()
-             .members
-             .unwrap()
-             .iter()
-             .find(|user| user.id.is_some() && user.id.as_deref().unwrap() == user_id)
+            if let Some(user) =
+                users::list(&client, slack_token, &users::ListRequest { presence: None })
+                    .compat()
+                    .await
+                    .unwrap()
+                    .members
+                    .unwrap()
+                    .iter()
+                    .find(|user| user.id.is_some() && user.id.as_deref().unwrap() == user_id)
             {
-                v.insert(user.real_name.as_ref().unwrap().clone()).to_string()
+                v.insert(user.real_name.as_ref().unwrap().clone())
+                    .to_string()
             } else {
                 user_id
             }
@@ -79,36 +77,39 @@ impl slack::EventHandler for Handler {
         match event {
             Event::Hello => {
                 if self.print_channels {
-                    println!("Slack channels found: {:#?}",
-                             cli
-                             .start_response()
-                             .channels
-                             .as_ref()
-                             .map(|channels| {
-                                 channels
-                                     .iter()
-                                     .map(|channel| format!(
-                                         "{}: {}",
-                                         channel.name.as_deref().unwrap_or("??"),
-                                         channel.id.as_deref().unwrap_or("??"),
-                                     ))
-                                     .collect::<Vec<_>>()
-                             }));
+                    println!(
+                        "Slack channels found: {:#?}",
+                        cli.start_response().channels.as_ref().map(|channels| {
+                            channels
+                                .iter()
+                                .map(|channel| {
+                                    format!(
+                                        "{}: {}",
+                                        channel.name.as_deref().unwrap_or("??"),
+                                        channel.id.as_deref().unwrap_or("??"),
+                                    )
+                                })
+                                .collect::<Vec<_>>()
+                        })
+                    );
                 }
             }
             Event::Message(msg) => {
                 if let Some(channel) = &self.slack_channel.clone() {
                     match *msg {
                         Message::Standard(msg) => {
-                            if msg.channel.is_some() && *channel == msg.channel.unwrap() { //TODO
+                            if msg.channel.is_some() && *channel == msg.channel.unwrap() {
+                                //TODO
                                 let user = match msg.user {
                                     Some(s) => Runtime::new().unwrap().block_on(
                                         get_or_insert_display_name(
                                             Arc::clone(&self.display_names),
                                             s,
                                             &self.slack_token,
-                                        ).compat()),
-                                    None => "??".to_string()
+                                        )
+                                        .compat(),
+                                    ),
+                                    None => "??".to_string(),
                                 };
                                 match parse_message(
                                     &msg.text.unwrap_or("".to_string()),
@@ -122,18 +123,23 @@ impl slack::EventHandler for Handler {
                                 ) {
                                     Some(Emoji::Ok) => {
                                         let client = slack_api::requests::default_client().unwrap();
-                                        Runtime::new().unwrap().block_on(
-                                            reactions::add(
-                                                &client,
-                                                &self.slack_token,
-                                                &reactions::AddRequest{
-                                                    name: "+1",
-                                                    file: None,
-                                                    file_comment: None,
-                                                    channel: Some(channel.as_str()),
-                                                    timestamp: Some(msg.ts.unwrap()),
-                                                }).compat()
-                                        ).unwrap();
+                                        Runtime::new()
+                                            .unwrap()
+                                            .block_on(
+                                                reactions::add(
+                                                    &client,
+                                                    &self.slack_token,
+                                                    &reactions::AddRequest {
+                                                        name: "+1",
+                                                        file: None,
+                                                        file_comment: None,
+                                                        channel: Some(channel.as_str()),
+                                                        timestamp: Some(msg.ts.unwrap()),
+                                                    },
+                                                )
+                                                .compat(),
+                                            )
+                                            .unwrap();
                                     }
                                     _ => {}
                                 }
@@ -158,29 +164,33 @@ pub async fn handle(
 ) {
     println!("Setting up Slack");
 
-    let token = std::env::var("SLACK_API_TOKEN").unwrap_or_else(|_| TOKEN.expect("Missing slack token").to_string());
+    let token = std::env::var("SLACK_API_TOKEN")
+        .unwrap_or_else(|_| TOKEN.expect("Missing slack token").to_string());
     let channel = match std::env::var("SLACK_CHANNEL") {
         Ok(channel) => Some(channel),
         Err(_) => match CHANNEL {
             Some(channel) => Some(channel.to_string()),
-            None => None
-        }
+            None => None,
+        },
     };
     let slack_token = token.to_string();
-    let client = spawn_blocking(move || {
-        slack::RtmClient::login(&token).unwrap()
-    }).await.unwrap();
+    let client = spawn_blocking(move || slack::RtmClient::login(&token).unwrap())
+        .await
+        .unwrap();
 
-    let mut handler = Handler::new(sender, client.sender().clone(), channel.clone(), slack_token);
+    let mut handler = Handler::new(
+        sender,
+        client.sender().clone(),
+        channel.clone(),
+        slack_token,
+    );
     let slack_sender = client.sender().clone();
 
     let (_, _) = join!(
         spawn_blocking(move || {
             match client.run(&mut handler) {
                 Ok(_) => {}
-                Err(e) => {
-                    println!("Error: {}", e)
-                }
+                Err(e) => println!("Error: {}", e),
             }
         }),
         spawn(receive_from_discord(receiver, slack_sender, channel))
@@ -197,7 +207,9 @@ async fn receive_from_discord(
             //TODO Sending messages is very slow sometimes. Have seen delays
             // from 5 up to 20(!) seconds.
             sender.send_typing(&channel).unwrap();
-            sender.send_message(&channel, &point.to_add_message()).unwrap();
+            sender
+                .send_message(&channel, &point.to_add_message())
+                .unwrap();
             println!("Slack message sent");
         }
     }