simplify even more; just return an EventLoop (will probably be renamed something like Handler)

src/modules/autolink.rs

@@ -1,4 +1,4 @@
-use modules::{Module, EventLoop};
+use modules::EventLoop;
 use toml::value::Table;
 
 use std::sync::Arc;
@@ -19,12 +19,8 @@ use regex::Regex;
 pub struct AutolinkModule {}
 
 impl AutolinkModule {
-    pub fn new (_: &Table, config: &Table) -> Module {
+    pub fn new (_: &Table, config: &Table) -> Box<EventLoop> {
-        Module {
+        Box::new(AutolinkModule {})
-            event_loop: Box::new(AutolinkModule {}),
-            module_type: String::from("autolink"),
-            config: config.clone()
-        }
     }
 }
 

src/modules/discord.rs

@@ -2,12 +2,10 @@ use discord;
 use discord::Discord;
 use discord::model::{Event, PossibleServer};
 
-use modules::Module;
 use modules::EventLoop;
 use toml::value::Table;
 
 use event;
-use event::Envelope;
 
 use std::sync::Arc;
 use std::sync::mpsc::Receiver;
@@ -26,7 +24,7 @@ pub struct DiscordModule {
 const DEFAULT_PLAYING: &'static str = "tenquestionmarks 0.0.2";
 
 impl DiscordModule {
-    pub fn new (_: &Table, configuration: &Table) -> Module {
+    pub fn new (_: &Table, configuration: &Table) -> Box<EventLoop> {
         let token = configuration.get("token")
                                  .and_then(|value| value.as_str())
                                  .unwrap_or("");
@@ -35,14 +33,10 @@ impl DiscordModule {
                                    .and_then(|value| value.as_str())
                                    .unwrap_or(DEFAULT_PLAYING);
 
-        Module {
+        Box::new(DiscordModule {
-            module_type: String::from("Discord"),
+            token: String::from(token),
-            event_loop: Box::new(DiscordModule {
+            playing: String::from(playing)
-                token: String::from(token),
+        })
-                playing: String::from(playing)
-            }),
-            config: configuration.clone()
-        }
     }
 }
 

src/modules/echo.rs

@@ -1,4 +1,4 @@
-use modules::{Module, EventLoop};
+use modules::EventLoop;
 use toml::value::Table;
 
 use std::sync::Arc;
@@ -13,18 +13,14 @@ pub struct EchoModule {
 }
 
 impl EchoModule {
-    pub fn new (_: &Table, configuration: &Table) -> Module {
+    pub fn new (_: &Table, configuration: &Table) -> Box<EventLoop> {
         let prefix = configuration.get("prefix")
                                   .and_then(|value| value.as_str())
                                   .unwrap_or("!echo");
 
-        Module {
+        Box::new(EchoModule {
-            module_type: String::from("echo"),
+            prefix: String::from(prefix)
-            event_loop: Box::new(EchoModule {
+        })
-                prefix: String::from(prefix)
-            }),
-            config: configuration.clone()
-        }
     }
 }
 

src/modules/echobox.rs

@@ -1,4 +1,4 @@
-use modules::{Module, EventLoop};
+use modules::EventLoop;
 use toml::value::Table;
 
 use std::sync::Arc;
@@ -15,7 +15,7 @@ pub struct EchoboxModule {
 }
 
 impl EchoboxModule {
-    pub fn new (_: &Table, configuration: &Table) -> Module {
+    pub fn new (_: &Table, configuration: &Table) -> Box<EventLoop> {
         let prefix = configuration.get("prefix")
                                   .and_then(|value| value.as_str())
                                   .unwrap_or("?echobox");
@@ -24,14 +24,10 @@ impl EchoboxModule {
                                 .and_then(|value| value.as_str())
                                 .unwrap_or("echobox.db");
 
-        Module {
+        Box::new(EchoboxModule {
-            module_type: String::from("echo"),
+            prefix: String::from(prefix),
-            event_loop: Box::new(EchoboxModule {
+            file: String::from(file)
-                prefix: String::from(prefix),
+        })
-                file: String::from(file)
-            }),
-            config: configuration.clone()
-        }
     }
 }
 

src/modules/loader.rs

@@ -4,7 +4,7 @@ use std::fmt;
 
 use toml::value::Table;
 
-use modules::Module;
+use modules::{Module, EventLoop};
 use modules::discord::DiscordModule;
 use modules::lua::LuaModule;
 use modules::stdin::StdinModule;
@@ -16,21 +16,21 @@ use modules::autolink::AutolinkModule;
 use modules::logger::LoggerModule;
 
 pub struct ModuleLoader {
-    types: BTreeMap<&'static str, fn(&Table, &Table) -> Module>
+    types: BTreeMap<&'static str, fn(&Table, &Table) -> Box<EventLoop>>
 }
 
 impl ModuleLoader {
     pub fn new () -> ModuleLoader {
         let mut types = BTreeMap::new();
-        types.insert("discord", DiscordModule::new as fn(&Table, &Table) -> Module);
+        types.insert("discord", DiscordModule::new as fn(&Table, &Table) -> Box<EventLoop>);
-        types.insert("lua", LuaModule::new as fn(&Table, &Table) -> Module);
+        types.insert("lua", LuaModule::new as fn(&Table, &Table) -> Box<EventLoop>);
-        types.insert("stdin", StdinModule::new as fn(&Table, &Table) -> Module);
+        types.insert("stdin", StdinModule::new as fn(&Table, &Table) -> Box<EventLoop>);
-        types.insert("echo", EchoModule::new as fn(&Table, &Table) -> Module);
+        types.insert("echo", EchoModule::new as fn(&Table, &Table) -> Box<EventLoop>);
-        types.insert("random", RandomModule::new as fn(&Table, &Table) -> Module);
+        types.insert("random", RandomModule::new as fn(&Table, &Table) -> Box<EventLoop>);
-        types.insert("pvn", PvnModule::new as fn(&Table, &Table) -> Module);
+        types.insert("pvn", PvnModule::new as fn(&Table, &Table) -> Box<EventLoop>);
-        types.insert("echobox", EchoboxModule::new as fn(&Table, &Table) -> Module);
+        types.insert("echobox", EchoboxModule::new as fn(&Table, &Table) -> Box<EventLoop>);
-        types.insert("autolink", AutolinkModule::new as fn(&Table, &Table) -> Module);
+        types.insert("autolink", AutolinkModule::new as fn(&Table, &Table) -> Box<EventLoop>);
-        types.insert("logger", LoggerModule::new as fn(&Table, &Table) -> Module);
+        types.insert("logger", LoggerModule::new as fn(&Table, &Table) -> Box<EventLoop>);
         ModuleLoader {
             types: types
         }
@@ -65,7 +65,11 @@ impl ModuleLoader {
                                              .unwrap_or(name);
 
         match self.types.get(module_type) {
-           Some(constructor) => Result::Ok(constructor(general_configuration, module_configuration)),
+           Some(constructor) => Result::Ok(Module {
+               module_type: module_type.to_owned(),
+               config: module_configuration.clone(),
+               event_loop: constructor(general_configuration, module_configuration)
+           }),
            None => Result::Err(ModuleLoaderError { message: format!("No such module type: {}", module_type) })
         }
     }

src/modules/logger.rs

@@ -1,22 +1,17 @@
-use modules::{Module, EventLoop};
+use modules::EventLoop;
 use toml::value::Table;
 
 use std::sync::Arc;
 use std::sync::mpsc::Receiver;
 use transformable_channels::mpsc::ExtSender;
 
-use helpers::command::split_command;
 use event::{Event, Envelope};
 
 pub struct LoggerModule {}
 
 impl LoggerModule {
-    pub fn new (_: &Table, configuration: &Table) -> Module {
+    pub fn new (_: &Table, configuration: &Table) -> Box<EventLoop> {
-        Module {
+        Box::new(LoggerModule {})
-            module_type: String::from("logger"),
-            event_loop: Box::new(LoggerModule {}),
-            config: configuration.clone()
-        }
     }
 }
 

src/modules/lua.rs

@@ -1,4 +1,4 @@
-use modules::{Module, EventLoop};
+use modules::EventLoop;
 
 use toml::Value;
 use toml::value::Table;
@@ -23,16 +23,12 @@ pub struct LuaModule {
 }
 
 impl LuaModule {
-    pub fn new (_: &Table, config: &Table) -> Module {
+    pub fn new (_: &Table, config: &Table) -> Box<EventLoop> {
-        Module {
+        Box::new(LuaModule {
-            module_type: String::from("lua"),
+            code: config.get("code").and_then(|value| value.as_str()).map(String::from),
-            event_loop: Box::new(LuaModule {
+            file: config.get("file").and_then(|value| value.as_str()).map(String::from),
-                code: config.get("code").and_then(|value| value.as_str()).map(String::from),
+            variables: config.clone()
-                file: config.get("file").and_then(|value| value.as_str()).map(String::from),
+        })
-                variables: config.clone()
-            }),
-            config: config.clone()
-        }
     }
 }
 

src/modules/pvn.rs

@@ -1,4 +1,4 @@
-use modules::{Module, EventLoop};
+use modules::EventLoop;
 use toml::value::Table;
 
 use std::sync::Arc;
@@ -17,12 +17,8 @@ use pvn::ninjas::{Ninja, Ninjas};
 pub struct PvnModule {}
 
 impl PvnModule {
-    pub fn new (_: &Table, configuration: &Table) -> Module {
+    pub fn new (_: &Table, configuration: &Table) -> Box<EventLoop> {
-        Module {
+        Box::new(PvnModule {})
-            module_type: String::from("pvn"),
-            event_loop: Box::new(PvnModule {}),
-            config: configuration.clone()
-        }
     }
 }
 

src/modules/random.rs

@@ -1,4 +1,4 @@
-use modules::{Module, EventLoop};
+use modules::EventLoop;
 use toml::value::Table;
 
 use std::sync::Arc;
@@ -15,7 +15,7 @@ pub struct RandomModule {
 }
 
 impl RandomModule {
-    pub fn new (_: &Table, configuration: &Table) -> Module {
+    pub fn new (_: &Table, configuration: &Table) -> Box<EventLoop> {
         let prefix = configuration.get("prefix")
                                   .and_then(|value| value.as_str())
                                   .unwrap_or("?random");
@@ -28,14 +28,10 @@ impl RandomModule {
                                      .map(|value| { String::from(value.as_str().unwrap()) })
                                      .collect();
 
-        Module {
+        Box::new(RandomModule {
-            module_type: String::from("random"),
+            prefix: String::from(prefix),
-            event_loop: Box::new(RandomModule {
+            responses: responses
-                prefix: String::from(prefix),
+        })
-                responses: responses
-            }),
-            config: configuration.clone()
-        }
     }
 }
 

src/modules/stdin.rs

@@ -1,6 +1,6 @@
 use std::io;
 
-use modules::{Module, EventLoop};
+use modules::EventLoop;
 use toml::value::Table;
 
 use {MessageSender, Message, User};
@@ -26,12 +26,8 @@ impl MessageSender for StdinMessageSender {
 }
 
 impl StdinModule {
-    pub fn new (_: &Table, config: &Table) -> Module {
+    pub fn new (_: &Table, config: &Table) -> Box<EventLoop> {
-        Module {
+        Box::new(StdinModule {})
-            module_type: String::from("stdin"),
-            event_loop: Box::new(StdinModule {}),
-            config: config.clone()
-        }
     }
 }