tenquestionmarks/src/modules/stdin.rs

use std::io;

use modules::{Module, EventLoop};
use toml::Table;

use {MessageSender, Message, User};

use std::sync::Arc;
use std::sync::mpsc::Receiver;
use transformable_channels::mpsc::ExtSender;

use event::{Event, Envelope};

pub struct StdinModule {}

pub struct StdinMessageSender {
    name: String
}

impl MessageSender for StdinMessageSender {
    fn send_message (&self, message: &str) {
        debug!("Send message to stdout: {:?}", message);
        println!("{}: {}", self.name, message);
    }
}

impl StdinModule {
    pub fn new (_: &Table, config: &Table) -> Module {
        Module {
            module_type: String::from("stdin"),
            event_loop: Box::new(StdinModule {}),
            config: config.clone()
        }
    }
}

impl EventLoop for StdinModule {
    fn run(&self, sender: Box<ExtSender<Envelope>>, _: Receiver<Arc<Envelope>>) {
        loop {
            let mut input = String::new();
            match io::stdin().read_line(&mut input) {
                Ok(_) => {
                    let message = Message {
                        author: User {
                            name: String::from("Dave"),
                            sender: Box::new(StdinMessageSender {
                                name: String::from("Dave")
                            })
                        },
                        content: input,
                        channel: None
                    };

                    match sender.send(Envelope::new(Event::Message { message: message })) {
                        Err(err) => error!("Error sending message event: {:?}", err),
                        Ok(_) => {}
                    }
                }
                Err(error) => error!("error: {}", error),
            }
        }
    }
}