begin fleshing out discord module. Implement sender/channel as struct for now, there might be a performance hit from copying so much data around but we can look at optimization later

src/event/mod.rs

@@ -1,8 +1,8 @@
 use {Channel, User};
 
 #[derive(Debug, Clone)]
-pub enum Event<'a> {
+pub enum Event {
-    Message { sender: &'a User, channel: Option<&'a Channel>, content: String },
+    Message { sender: User, channel: Option<Channel>, content: String },
-    Join { channel: &'a Channel },
+    Join { channel: Channel },
-    Quit { channel: &'a Channel }
+    Quit { channel: Channel }
 }

src/lib.rs

@@ -1,5 +1,6 @@
 extern crate toml;
 extern crate crossbeam;
+extern crate discord;
 
 use std::collections::BTreeMap;
 use toml::Table;

src/plugins/discord.rs

@@ -1,19 +1,54 @@
+use discord;
+use discord::Discord;
+use discord::model::Event;
+
 use plugins::Plugin;
 use toml::Table;
 
-pub struct DiscordPlugin {
+use event;
+use std::sync::mpsc::Sender;
 
+use User;
+use Channel;
+
+use std::collections::BTreeMap;
+
+pub struct DiscordPlugin {
+    token: String
 }
 
 impl DiscordPlugin {
     pub fn new (configuration: &Table) -> Box<Plugin> {
-        match configuration.get("channel") {
+        let token = configuration.get("token")
-            Some(channel) => println!("Using channel: {}", channel),
+                                 .and_then(|value| value.as_str())
-            None => println!("No channel specified")
+                                 .unwrap_or("");
-        }
 
-        Box::new(DiscordPlugin {})
+        Box::new(DiscordPlugin {
+            token: String::from(token)
+        })
     }
 }
 
-impl Plugin for DiscordPlugin {}
+impl Plugin for DiscordPlugin {
+    fn produce_events<'a>(&'a self, sender: Sender<event::Event>) {
+        let discord = Discord::from_bot_token(&self.token[..]).expect("Login failed");
+        let (mut connection, _) = discord.connect().expect("Connection failed");
+        loop {
+            match connection.recv_event() {
+                Ok(Event::MessageCreate(message)) => {
+                    let author = User {
+                        name: message.author.name
+                    };
+
+                    sender.send(event::Event::Message { sender: author, content: message.content, channel: None });
+                }
+    			Ok(_) => {}
+    			Err(discord::Error::Closed(code, body)) => {
+	                println!("Gateway closed on us with code {:?}: {}", code, body);
+    				break
+    			}
+    			Err(err) => println!("Receive error: {:?}", err)
+            }
+        }
+    }
+}

src/plugins/mod.rs

@@ -14,5 +14,5 @@ use std::sync::mpsc::{Sender, Receiver};
 pub trait Plugin : Sync {
     fn register (&self, tenquestionmarks: &Tenquestionmarks) {}
     fn consume_events (&self, receiver: Receiver<Event>) {}
-    fn produce_events<'a>(&'a self, sender: Sender<Event<'a>>) {}
+    fn produce_events<'a>(&'a self, sender: Sender<Event>) {}
 }

src/plugins/stdin.rs

@@ -23,14 +23,14 @@ impl StdinPlugin {
 }
 
 impl Plugin for StdinPlugin {
-    fn produce_events<'a>(&'a self, sender: Sender<Event<'a>>) {
+    fn produce_events<'a>(&'a self, sender: Sender<Event>) {
         let user = &self.user;
 
         loop {
             let mut input = String::new();
             match io::stdin().read_line(&mut input) {
                 Ok(n) => {
-                    let message = Event::Message { sender: user, content: input, channel: None };
+                    let message = Event::Message { sender: user.clone(), content: input, channel: None };
                     sender.send(message);
                 }
                 Err(error) => println!("error: {}", error),