refactor spawns to functions

2 files changed, 63 insertions, 46 deletions

diff --git a/src/discord.rs b/src/discord.rs
index b6a22ad..c451ad7 100644
--- a/src/discord.rs
+++ b/src/discord.rs
@@ -18,7 +18,7 @@ use tokio::{
 pub async fn handle(
     token: Option<String>,
     sender: mpsc::UnboundedSender<String>,
-    mut receiver: mpsc::UnboundedReceiver<String>,
+    receiver: mpsc::UnboundedReceiver<String>,
 ) {
     println!("Setting up Discord");
 
@@ -26,44 +26,56 @@ pub async fn handle(
     let client = Discord::from_bot_token(&token);
 
     if let Ok(client) = client {
-        let (mut connection, _) = client.connect().expect("discord connect failed"); //TODO
+        let (connection, _) = client.connect().expect("Discord connect failed"); //TODO
         let our_id = client.get_current_user().unwrap().id;
         println!("Discord ready");
 
         let (_, _) = join!( //TODO?
-            spawn_blocking(move || {
-                loop {
-                    match connection.recv_event() {
-                        Ok(Event::MessageCreate(message)) => {
-                            if message.author.id != our_id {
-                                sender.send(format!("{:?}:{} says: {}",
-                                                    message.channel_id,
-                                                    message.author.name,
-                                                    message.content))
-                                    .unwrap();
-                            }
-                        }
-                        Ok(_) => {}
-                        Err(Error::Closed(code, body)) => {
-                            println!("Discord closed with code {:?}: {}", code, body);
-                            break;
-                        }
-                        Err(e) => {
-                            println!("Error: {:?}", e);
-                        }
-                    }
-                }
-            }),
-            spawn(async move {
-                while let Some(s) = receiver.recv().await {
-                    println!("Discord received '{}'", s);
-                    client.send_message(ChannelId(697057150106599488), //TODO
-                                        &s,
-                                        "",
-                                        false
-                    );
+            spawn_blocking(move || receive_events(our_id, connection, sender)),
+            spawn(receive_from_slack(receiver, client))
+        );
+    }
+}
+
+fn receive_events(
+    our_id: discord::model::UserId,
+    mut connection: discord::Connection,
+    sender: mpsc::UnboundedSender<String>
+) {
+    loop {
+        match connection.recv_event() {
+            Ok(Event::MessageCreate(message)) => {
+                if message.author.id != our_id {
+                    sender.send(format!("{:?}:{} says: {}",
+                                        message.channel_id,
+                                        message.author.name,
+                                        message.content))
+                        .unwrap();
                 }
-            })
+            }
+            Ok(_) => {}
+            Err(Error::Closed(code, body)) => {
+                println!("Discord closed with code {:?}: {}", code, body);
+                break;
+            }
+            Err(e) => {
+                println!("Discord error: {:?}", e);
+            }
+        }
+    }
+}
+
+async fn receive_from_slack(
+    mut receiver: mpsc::UnboundedReceiver<String>,
+    client: discord::Discord,
+) {
+    while let Some(s) = receiver.recv().await {
+        println!("Discord received '{}'", s);
+        client.send_message(ChannelId(697057150106599488), //TODO
+                            &s,
+                            "",
+                            false
         );
     }
+
 }
diff --git a/src/slack.rs b/src/slack.rs
index feff430..c13fc47 100644
--- a/src/slack.rs
+++ b/src/slack.rs
@@ -59,7 +59,7 @@ impl slack::EventHandler for Handler {
 pub async fn handle(
     token: Option<String>,
     sender: mpsc::UnboundedSender<String>,
-    mut receiver: mpsc::UnboundedReceiver<String>,
+    receiver: mpsc::UnboundedReceiver<String>,
 ) {
     println!("Setting up Slack");
 
@@ -80,16 +80,21 @@ pub async fn handle(
                 }
             }
         }),
-        spawn(async move {
-            while let Some(s) = receiver.recv().await {
-                println!("Slack received '{}'", s);
-                //TODO Sending messages is very slow sometimes. Have seen delays
-                // from 5 up to 20(!) seconds.
-                slack_sender.send_typing("CPBAA5FA7").unwrap();
-                println!("Typing");
-                slack_sender.send_message("CPBAA5FA7", &s).unwrap();
-                println!("Sent");
-            }
-        })
+        spawn(receive_from_discord(receiver, slack_sender))
     );
 }
+
+async fn receive_from_discord(
+    mut receiver: mpsc::UnboundedReceiver<String>,
+    sender: slack::Sender,
+) {
+    while let Some(s) = receiver.recv().await {
+        println!("Slack received '{}'", s);
+        //TODO Sending messages is very slow sometimes. Have seen delays
+        // from 5 up to 20(!) seconds.
+        sender.send_typing("CPBAA5FA7").unwrap();
+        println!("Typing");
+        sender.send_message("CPBAA5FA7", &s).unwrap();
+        println!("Sent");
+    }
+}