From 9271c39ce2e11893a680b627d24a6c9ba7daeb07 Mon Sep 17 00:00:00 2001
From: Adrian Malacoda <adrian.malacoda@monarch-pass.net>
Date: Sun, 6 May 2018 04:03:37 -0500
Subject: [PATCH] update irc module

---
 src/modules/irc.rs | 83 +++++++++++++++++++++++-----------------------
 1 file changed, 41 insertions(+), 42 deletions(-)

diff --git a/src/modules/irc.rs b/src/modules/irc.rs
index abaeee4..3fc0262 100644
--- a/src/modules/irc.rs
+++ b/src/modules/irc.rs
@@ -1,5 +1,4 @@
 use irc::client::prelude::*;
-use irc::client::data::command::Command;
 
 use modules::EventLoop;
 use toml::value::Table;
@@ -50,7 +49,7 @@ impl IrcHandler {
 }
 
 pub struct IrcMessageSender {
-    irc: IrcServerWrapper,
+    irc: IrcClientWrapper,
     channel: String
 }
 
@@ -70,49 +69,51 @@ impl Debug for IrcMessageSender {
     }
 }
 
-fn make_user (prefix: &Option<String>, server: &IrcServer) -> Option<User> {
+fn make_user (prefix: &Option<String>, server: &IrcClient) -> Option<User> {
     prefix.as_ref().and_then(|prefix| prefix.split("!").next()).map(|name| User {
         name: name.to_owned(),
         sender: Box::new(IrcMessageSender {
-            irc: IrcServerWrapper::new(&server),
+            irc: IrcClientWrapper::new(&server),
             channel: name.to_owned()
         })
     })
 }
 
-struct IrcServerWrapper {
-    server: IrcServer,
-    thread_local: CachedThreadLocal<IrcServer>
+struct IrcClientWrapper {
+    client: IrcClient,
+    thread_local: CachedThreadLocal<IrcClient>
 }
 
-impl IrcServerWrapper {
-    pub fn new (server: &IrcServer) -> IrcServerWrapper {
-        IrcServerWrapper {
-            server: server.clone(),
+impl IrcClientWrapper {
+    pub fn new (client: &IrcClient) -> IrcClientWrapper {
+        IrcClientWrapper {
+            client: client.clone(),
             thread_local: CachedThreadLocal::new()
         }
     }
 
-    pub fn get (&self) -> &IrcServer {
-        self.thread_local.get_or(|| Box::new(self.server.clone()))
+    pub fn get (&self) -> &IrcClient {
+        self.thread_local.get_or(|| Box::new(self.client.clone()))
     }
 }
 
-unsafe impl Sync for IrcServerWrapper {}
+unsafe impl Sync for IrcClientWrapper {}
 
 impl EventLoop for IrcHandler {
     fn run (&self, sender: Box<ExtSender<event::Event>>, receiver: Receiver<Arc<event::Envelope>>) {
-        let server = IrcServer::from_config(self.config.clone()).unwrap();
-        server.identify().unwrap();
+        let client = IrcClient::from_config(self.config.clone()).unwrap();
+        client.identify().unwrap();
 
         crossbeam::scope(|scope| {
-            let server_sender = server.clone();
+            let client_sender = client.clone();
             scope.spawn(move || {
                 loop {
                     if let Ok(envelope) = receiver.recv() {
                         if let event::Event::Message { ref message } = envelope.event {
                             if let Some(ref channel) = message.channel {
-                                server_sender.send_privmsg(&channel.name, &message.content);
+                                if let Err(error) = client_sender.send_privmsg(&channel.name, &message.content) {
+                                    error!("Failed to send IRC message: {}", error);
+                                }
                             }
                         }
                     } else {
@@ -121,34 +122,32 @@ impl EventLoop for IrcHandler {
                 }
             });
 
-            for server_message in server.iter() {
-                if let Ok(irc_message) = server_message {
-                    match irc_message.command {
-                        Command::PRIVMSG(channel, message) => {
-                            if let Some(author) = make_user(&irc_message.prefix, &server) {
-                                let message = Message {
-                                    author: author,
-                                    content: message,
-                                    channel: Some(Channel {
-                                        name: channel.clone(),
-                                        description: "".to_owned(),
-                                        topic: "".to_owned(),
-                                        sender: Box::new(IrcMessageSender {
-                                            irc: IrcServerWrapper::new(&server),
-                                            channel: channel.clone()
-                                        })
+            client.for_each_incoming(|irc_message| {
+                match irc_message.command {
+                    Command::PRIVMSG(channel, message) => {
+                        if let Some(author) = make_user(&irc_message.prefix, &client) {
+                            let message = Message {
+                                author: author,
+                                content: message,
+                                channel: Some(Channel {
+                                    name: channel.clone(),
+                                    description: "".to_owned(),
+                                    topic: "".to_owned(),
+                                    sender: Box::new(IrcMessageSender {
+                                        irc: IrcClientWrapper::new(&client),
+                                        channel: channel.clone()
                                     })
-                                };
+                                })
+                            };
 
-                                if let Err(err) = sender.send(event::Event::Message { message: message }) {
-                                    error!("Error sending message event: {:?}", err)
-                                }
+                            if let Err(err) = sender.send(event::Event::Message { message: message }) {
+                                error!("Error sending message event: {:?}", err)
                             }
-                        },
-                        _ => {}
-                    }
+                        }
+                    },
+                    _ => {}
                 }
-            }
+            }).unwrap();
         });
     }
 }