refactor spawns to functions

1 files changed, 46 insertions, 34 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
         );
     }
+
 }