replace Sender with ExtSender from transformable_channels. Now we can tag each outgoing envelope with the name of its sender

Cargo.toml

@@ -11,5 +11,6 @@ crossbeam = "0.2"
 rand = "0.3"
 log = "0.3.6"
 env_logger = "0.4.0"
+transformable_channels = "0.1.1"
 pvn = { git = "http://gitlab.monarch-pass.net/malacoda/pvn.git" }
 echobox = { git = "http://gitlab.monarch-pass.net/malacoda/echobox.git" }

src/lib.rs

@@ -4,6 +4,7 @@ extern crate discord;
 extern crate rand;
 extern crate pvn;
 extern crate echobox;
+extern crate transformable_channels;
 
 use std::collections::BTreeMap;
 use toml::Table;
@@ -19,6 +20,8 @@ use std::sync::Arc;
 use std::sync::mpsc;
 use std::sync::mpsc::Sender;
 
+use transformable_channels::mpsc::TransformableSender;
+
 mod helpers;
 
 #[macro_use]
@@ -51,7 +54,7 @@ impl Tenquestionmarks {
         crossbeam::scope(|scope| {
             // Our main event channel.
             // Modules push events to tenquestionmarks using this channel.
-            let (ref main_sender, ref main_receiver) = mpsc::channel();
+            let (ref main_sender, ref main_receiver) = transformable_channels::mpsc::channel();
 
             // Module threads.
             // Each Module will produce events which tenquestionmarks will push
@@ -59,11 +62,19 @@ impl Tenquestionmarks {
             // tenquestionmarks propagates all events to each Module through these
             // channels.
             let module_senders: BTreeMap<&str, Sender<Arc<Envelope>>> = self.modules.iter().map(|(key, module)| {
-                let main_sender_clone = main_sender.clone();
+                let from = key.clone();
+                let main_sender_mapped = main_sender.map(move |envelope: Envelope| {
+                    Envelope {
+                        from: Some(from.clone()),
+                        event: envelope.event,
+                        to: envelope.to
+                    }
+                });
+
                 let (module_sender, module_receiver) = mpsc::channel();
                 info!("Spawning thread for \"{}\"", key);
                 scope.spawn(move || {
-                    module.run(main_sender_clone, module_receiver);
+                    module.run(Box::new(main_sender_mapped), module_receiver);
                     info!("Thread for \"{}\" is exiting", key);
                 });
                 (&key[..], module_sender)

src/modules/discord.rs

@@ -8,7 +8,8 @@ use toml::Table;
 use event;
 
 use std::sync::Arc;
-use std::sync::mpsc::{Sender, Receiver};
+use std::sync::mpsc::Receiver;
+use transformable_channels::mpsc::ExtSender;
 
 use {MessageSender, Message, User, Channel};
 
@@ -52,7 +53,7 @@ impl MessageSender for DiscordMessageSender {
 }
 
 impl Module for DiscordModule {
-    fn run (&self, sender: Sender<event::Envelope>, _: Receiver<Arc<event::Envelope>>) {
+    fn run (&self, sender: Box<ExtSender<event::Envelope>>, _: Receiver<Arc<event::Envelope>>) {
         let discord = Arc::new(Discord::from_bot_token(&self.token[..]).expect("Discord module: Login failed"));
         let (mut connection, _) = discord.connect().expect("Discord module: Connection failed");
 

src/modules/echo.rs

@@ -2,7 +2,8 @@ use modules::Module;
 use toml::Table;
 
 use std::sync::Arc;
-use std::sync::mpsc::{Sender, Receiver};
+use std::sync::mpsc::Receiver;
+use transformable_channels::mpsc::ExtSender;
 
 use helpers::command::split_command;
 use event::{Event, Envelope};
@@ -24,13 +25,13 @@ impl EchoModule {
 }
 
 impl Module for EchoModule {
-    fn run(&self, _: Sender<Envelope>, receiver: Receiver<Arc<Envelope>>) {
+    fn run(&self, _: Box<ExtSender<Envelope>>, receiver: Receiver<Arc<Envelope>>) {
         loop {
             match receiver.recv() {
                 Ok(envelope) => {
                     match envelope.event {
                         Event::Message { ref message } => {
-                            debug!("Received message... {:?}", message.content);
+                            debug!("Received message from module {:?}... {:?}", envelope.from, message.content);
                             match split_command(&message.content) {
                                 Some((command, argument)) => {
                                     if command == self.prefix {

src/modules/echobox.rs

@@ -2,7 +2,8 @@ use modules::Module;
 use toml::Table;
 
 use std::sync::Arc;
-use std::sync::mpsc::{Sender, Receiver};
+use std::sync::mpsc::Receiver;
+use transformable_channels::mpsc::ExtSender;
 
 use helpers::command::split_command;
 use event::{Event, Envelope};
@@ -31,7 +32,7 @@ impl EchoboxModule {
 }
 
 impl Module for EchoboxModule {
-    fn run(&self, _: Sender<Envelope>, receiver: Receiver<Arc<Envelope>>) {
+    fn run(&self, _: Box<ExtSender<Envelope>>, receiver: Receiver<Arc<Envelope>>) {
         let echobox = Echobox::with_file(&self.file).unwrap();
 
         loop {
@@ -39,7 +40,7 @@ impl Module for EchoboxModule {
                 Ok(envelope) => {
                     match envelope.event {
                         Event::Message { ref message } => {
-                            debug!("Received message... {:?}", message.content);
+                            debug!("Received message from module {:?}... {:?}", envelope.from, message.content);
                             match split_command(&message.content) {
                                 Some((command, in_quote)) => {
                                     if command == self.prefix {

src/modules/mod.rs

@@ -12,9 +12,10 @@ use Tenquestionmarks;
 use event::Envelope;
 
 use std::sync::Arc;
-use std::sync::mpsc::{Sender, Receiver};
+use std::sync::mpsc::Receiver;
+use transformable_channels::mpsc::ExtSender;
 
 pub trait Module : Sync {
     fn register (&self, _: &Tenquestionmarks) {}
-    fn run (&self, _: Sender<Envelope>, _: Receiver<Arc<Envelope>>) {}
+    fn run (&self, _: Box<ExtSender<Envelope>>, _: Receiver<Arc<Envelope>>) {}
 }

src/modules/pvn.rs

@@ -2,7 +2,9 @@ use modules::Module;
 use toml::Table;
 
 use std::sync::Arc;
-use std::sync::mpsc::{Sender, Receiver};
+use std::sync::mpsc::Receiver;
+use transformable_channels::mpsc::ExtSender;
+
 use event::{Event, Envelope};
 
 use Message;
@@ -135,7 +137,7 @@ impl PirateVsNinja {
 }
 
 impl Module for PvnModule {
-    fn run(&self, _: Sender<Envelope>, receiver: Receiver<Arc<Envelope>>) {
+    fn run(&self, _: Box<ExtSender<Envelope>>, receiver: Receiver<Arc<Envelope>>) {
         let mut pvn = PirateVsNinja {
             pirates: Pirates::new(),
             ninjas: Ninjas::new()
@@ -147,7 +149,7 @@ impl Module for PvnModule {
                     match envelope.event {
                         Event::Message { ref message } => {
                             let command = split_command(&message.content);
-                            debug!("Received message... {:?}", &message.content);
+                            debug!("Received message from module {:?}... {:?}", envelope.from, message.content);
                             match command {
                                 Some(("?pvn", argument)) => { pvn.pvn_command(argument, message) },
                                 Some(("?pirate", name)) => { pvn.pirate_command(name, message) },

src/modules/random.rs

@@ -2,7 +2,8 @@ use modules::Module;
 use toml::Table;
 
 use std::sync::Arc;
-use std::sync::mpsc::{Sender, Receiver};
+use std::sync::mpsc::Receiver;
+use transformable_channels::mpsc::ExtSender;
 
 use helpers::command::split_command;
 use event::{Event, Envelope};
@@ -35,7 +36,7 @@ impl RandomModule {
 }
 
 impl Module for RandomModule {
-    fn run(&self, _: Sender<Envelope>, receiver: Receiver<Arc<Envelope>>) {
+    fn run(&self, _: Box<ExtSender<Envelope>>, receiver: Receiver<Arc<Envelope>>) {
         let mut rng = rand::thread_rng();
 
         loop {
@@ -43,7 +44,7 @@ impl Module for RandomModule {
                 Ok(envelope) => {
                     match envelope.event {
                         Event::Message { ref message } => {
-                            debug!("Received message... {:?}", message.content);
+                            debug!("Received message from module {:?}... {:?}", envelope.from, message.content);
                             match split_command(&message.content) {
                                 Some((command, _)) => {
                                     if command == self.prefix {

src/modules/stdin.rs

@@ -6,7 +6,9 @@ use toml::Table;
 use {MessageSender, Message, User};
 
 use std::sync::Arc;
-use std::sync::mpsc::{Sender, Receiver};
+use std::sync::mpsc::Receiver;
+use transformable_channels::mpsc::ExtSender;
+
 use event::{Event, Envelope};
 
 pub struct StdinModule {}
@@ -29,7 +31,7 @@ impl StdinModule {
 }
 
 impl Module for StdinModule {
-    fn run(&self, sender: Sender<Envelope>, _: Receiver<Arc<Envelope>>) {
+    fn run(&self, sender: Box<ExtSender<Envelope>>, _: Receiver<Arc<Envelope>>) {
         loop {
             let mut input = String::new();
             match io::stdin().read_line(&mut input) {