add support for "general" config in the module loader. The "general" config is found under the "general" heading and is passed to each module constructor.

src/modules/discord.rs

@@ -22,7 +22,7 @@ pub struct DiscordModule {
 const DEFAULT_PLAYING: &'static str = "tenquestionmarks 0.0.1";
 
 impl DiscordModule {
-    pub fn new (configuration: &Table) -> Box<Module> {
+    pub fn new (_: &Table, configuration: &Table) -> Box<Module> {
         let token = configuration.get("token")
                                  .and_then(|value| value.as_str())
                                  .unwrap_or("");

src/modules/echo.rs

@@ -13,7 +13,7 @@ pub struct EchoModule {
 }
 
 impl EchoModule {
-    pub fn new (configuration: &Table) -> Box<Module> {
+    pub fn new (_: &Table, configuration: &Table) -> Box<Module> {
         let prefix = configuration.get("prefix")
                                   .and_then(|value| value.as_str())
                                   .unwrap_or("!echo");

src/modules/echobox.rs

@@ -15,7 +15,7 @@ pub struct EchoboxModule {
 }
 
 impl EchoboxModule {
-    pub fn new (configuration: &Table) -> Box<Module> {
+    pub fn new (_: &Table, configuration: &Table) -> Box<Module> {
         let prefix = configuration.get("prefix")
                                   .and_then(|value| value.as_str())
                                   .unwrap_or("?echobox");

src/modules/loader.rs

@@ -14,31 +14,36 @@ use modules::pvn::PvnModule;
 use modules::echobox::EchoboxModule;
 
 pub struct ModuleLoader {
-    types: BTreeMap<&'static str, fn(&Table) -> Box<Module>>
+    types: BTreeMap<&'static str, fn(&Table, &Table) -> Box<Module>>
 }
 
 impl ModuleLoader {
     pub fn new () -> ModuleLoader {
         let mut types = BTreeMap::new();
-        types.insert("discord", DiscordModule::new as fn(&Table) -> Box<Module>);
+        types.insert("discord", DiscordModule::new as fn(&Table, &Table) -> Box<Module>);
-        types.insert("lua", LuaModule::new as fn(&Table) -> Box<Module>);
+        types.insert("lua", LuaModule::new as fn(&Table, &Table) -> Box<Module>);
-        types.insert("stdin", StdinModule::new as fn(&Table) -> Box<Module>);
+        types.insert("stdin", StdinModule::new as fn(&Table, &Table) -> Box<Module>);
-        types.insert("echo", EchoModule::new as fn(&Table) -> Box<Module>);
+        types.insert("echo", EchoModule::new as fn(&Table, &Table) -> Box<Module>);
-        types.insert("random", RandomModule::new as fn(&Table) -> Box<Module>);
+        types.insert("random", RandomModule::new as fn(&Table, &Table) -> Box<Module>);
-        types.insert("pvn", PvnModule::new as fn(&Table) -> Box<Module>);
+        types.insert("pvn", PvnModule::new as fn(&Table, &Table) -> Box<Module>);
-        types.insert("echobox", EchoboxModule::new as fn(&Table) -> Box<Module>);
+        types.insert("echobox", EchoboxModule::new as fn(&Table, &Table) -> Box<Module>);
         ModuleLoader {
             types: types
         }
     }
 
     pub fn load_from_configuration (&self, configuration: Table) -> Result<BTreeMap<String, Box<Module>>, ModuleLoaderError> {
+        let general_config = configuration.get("general")
+                                          .and_then(|value| value.as_table())
+                                          .map(|value| value.clone())
+                                          .unwrap_or_else(|| BTreeMap::new());
+
         configuration.into_iter().filter(|&(ref key, _)| {
             key != "general"
         }).map(|(key, value)| {
             match value.as_table() {
                 Some(table) => {
-                    let module = self.load_single_module(&key, table)?;
+                    let module = self.load_single_module(&key, &general_config, table)?;
                     Result::Ok((key, module))
                 },
                 None => Result::Err(ModuleLoaderError { message: format!("Bad configuration parameters for module instance: {}. Configuration for a Module must be a table.", key) })
@@ -46,17 +51,17 @@ impl ModuleLoader {
         }).collect()
     }
 
-    pub fn load_single_module (&self, name: &str, configuration: &Table) -> Result<Box<Module>, ModuleLoaderError> {
+    pub fn load_single_module (&self, name: &str, general_configuration: &Table, module_configuration: &Table) -> Result<Box<Module>, ModuleLoaderError> {
         /*
          * The Module type defaults to the instance name (in the tenquestionmarks configuration)
          * but can explicitly be set by using the special "type" parameter.
          */
-        let module_type: &str = configuration.get("type")
+        let module_type: &str = module_configuration.get("type")
                                              .and_then(|value| value.as_str())
                                              .unwrap_or(name);
 
         match self.types.get(module_type) {
-           Some(constructor) => Result::Ok(constructor(configuration)),
+           Some(constructor) => Result::Ok(constructor(general_configuration, module_configuration)),
            None => Result::Err(ModuleLoaderError { message: format!("No such module type: {}", module_type) })
         }
     }

src/modules/lua.rs

@@ -22,7 +22,7 @@ pub struct LuaModule {
 }
 
 impl LuaModule {
-    pub fn new (config: &Table) -> Box<Module> {
+    pub fn new (_: &Table, config: &Table) -> Box<Module> {
         Box::new(LuaModule {
             code: config.get("code").and_then(|value| value.as_str()).map(String::from),
             file: config.get("file").and_then(|value| value.as_str()).map(String::from),

src/modules/pvn.rs

@@ -17,7 +17,7 @@ use pvn::ninjas::{Ninja, Ninjas};
 pub struct PvnModule {}
 
 impl PvnModule {
-    pub fn new (_: &Table) -> Box<Module> {
+    pub fn new (_: &Table, _: &Table) -> Box<Module> {
         Box::new(PvnModule {})
     }
 }

src/modules/random.rs

@@ -15,10 +15,10 @@ pub struct RandomModule {
 }
 
 impl RandomModule {
-    pub fn new (configuration: &Table) -> Box<Module> {
+    pub fn new (_: &Table, configuration: &Table) -> Box<Module> {
         let prefix = configuration.get("prefix")
                                   .and_then(|value| value.as_str())
-                                  .unwrap_or("!random ");
+                                  .unwrap_or("?random");
 
         let responses = configuration.get("responses")
                                      .and_then(|value| value.as_slice())

src/modules/stdin.rs

@@ -25,7 +25,7 @@ impl MessageSender for StdinMessageSender {
 }
 
 impl StdinModule {
-    pub fn new (_: &Table) -> Box<Module> {
+    pub fn new (_: &Table, _: &Table) -> Box<Module> {
         Box::new(StdinModule {})
     }
 }