Refactored utilities into a Server Wrapper that provides added functionality.

examples/simple.rs

@@ -5,7 +5,7 @@ extern crate irc;
 use std::collections::HashMap;
 use irc::data::config::Config;
 use irc::server::{IrcServer, Server};
-use irc::server::utils::{identify, send_privmsg};
+use irc::server::utils::Wrapper;
 
 fn main() {
     let config = Config {
@@ -19,14 +19,15 @@ fn main() {
         channels: vec!("#vana".into_string()),
         options: HashMap::new(),
     };
-    let server = IrcServer::from_config(config).unwrap();
+    let ircserver = IrcServer::from_config(config).unwrap();
-    identify(&server).unwrap();
+    let server = Wrapper::new(&ircserver);
+    server.identify().unwrap();
     for message in server.iter() {
         print!("{}", message.into_string());
         if message.command[] == "PRIVMSG" {
             if let Some(msg) = message.suffix {
                 if msg.contains("pickles") {
-                    send_privmsg(&server, message.args[0][], "Hi!").unwrap();
+                    server.send_privmsg(message.args[0][], "Hi!").unwrap();
                 }
             }
         }

src/server/mod.rs

@@ -2,7 +2,7 @@
 #![experimental]
 use std::io::{BufferedReader, BufferedWriter, IoResult, TcpStream};
 use conn::Connection;
-use data::command::Command;
+use data::command::{Command, JOIN, PONG};
 use data::config::Config;
 use data::kinds::{IrcReader, IrcWriter};
 use data::message::Message;
@@ -73,10 +73,10 @@ impl<'a, T, U> IrcServer<'a, T, U> where T: IrcWriter, U: IrcReader {
     /// Handles messages internally for basic bot functionality
     fn handle_message(&self, message: &Message) {
         if message.command[] == "PING" {
-            utils::send_pong(self, message.suffix.as_ref().unwrap()[]).unwrap();
+            self.send(PONG(message.suffix.as_ref().unwrap()[], None)).unwrap();
         } else if message.command[] == "376" || message.command[] == "422" {
             for chan in self.config.channels.iter() {
-                utils::send_join(self, chan[]).unwrap();
+                self.send(JOIN(chan[], None)).unwrap();
             }
         }
         /* TODO: implement more message handling */

src/server/utils.rs

@@ -2,40 +2,73 @@
 #![experimental]
 
 use std::io::IoResult;
-use data::command::{JOIN, KILL, NICK, OPER, PONG, PRIVMSG, SAMODE, SANICK, USER};
+use data::command::{Command, JOIN, KILL, NICK, OPER, PONG, PRIVMSG, SAMODE, SANICK, USER};
+use data::config::Config;
 use data::kinds::{IrcReader, IrcWriter};
-use server::Server;
+use server::{IrcServer, Server, ServerIterator};
 
-/// Sends a NICK and USER to identify
+
-pub fn identify<'a, T, U>(server: &Server<'a, T, U>) -> IoResult<()> where T: IrcWriter, U: IrcReader {
+pub struct Wrapper<'a, T, U> where T: IrcWriter, U: IrcReader {
-    try!(server.send(NICK(server.config().nickname[])));
+    server: &'a Server<'a, T, U> + 'a
-    server.send(USER(server.config().username[], "0", server.config().realname[]))
 }
 
-pub fn send_pong<'a, T, U>(server: &Server<'a, T, U>, msg: &str) -> IoResult<()> where T: IrcWriter, U: IrcReader {
+impl<'a, T, U> Server<'a, T, U> for Wrapper<'a, T, U> where T: IrcWriter, U: IrcReader {
-    server.send(PONG(msg, None))
+    fn config(&self) -> &Config {
+        self.server.config()
+    }
+
+    fn send(&self, command: Command) -> IoResult<()> {
+        self.server.send(command)
+    }
+
+    fn iter(&'a self) -> ServerIterator<'a, T, U> {
+        self.server.iter()
+    }
 }
 
-pub fn send_join<'a, T, U>(server: &Server<'a, T, U>, chanlist: &str) -> IoResult<()> where T: IrcWriter, U: IrcReader {
+impl<'a, T, U> Wrapper<'a, T, U> where T: IrcWriter, U: IrcReader {
-    server.send(JOIN(chanlist, None))
+    pub fn new(server: &'a IrcServer<'a, T, U>) -> Wrapper<'a, T, U> {
-}
+        Wrapper { server: server }
+    }
 
-pub fn send_oper<'a, T, U>(server: &Server<'a, T, U>, username: &str, password: &str) -> IoResult<()> where T: IrcWriter, U: IrcReader {
+    /// Sends a NICK and USER to identify
-    server.send(OPER(username, password))
+    pub fn identify(&self) -> IoResult<()> {
-}
+        try!(self.server.send(NICK(self.server.config().nickname[])));
+        self.server.send(USER(self.server.config().username[], "0", self.server.config().realname[]))
+    }
 
-pub fn send_privmsg<'a, T, U>(server: &Server<'a, T, U>, target: &str, message: &str) -> IoResult<()> where T: IrcWriter, U: IrcReader {
+    /// Sends a PONG with the specified message
-    server.send(PRIVMSG(target, message))
+    pub fn send_pong(&self, msg: &str) -> IoResult<()> {
-}
+        self.server.send(PONG(msg, None))
+    }
 
-pub fn send_kill<'a, T, U>(server: &Server<'a, T, U>, target: &str, message: &str) -> IoResult<()> where T: IrcWriter, U: IrcReader {
+    /// Joins the specified channel or chanlist
-    server.send(KILL(target, message))
+    pub fn send_join(&self, chanlist: &str) -> IoResult<()> {
-}
+        self.server.send(JOIN(chanlist, None))
+    }
 
-pub fn send_samode<'a, T, U>(server: &Server<'a, T, U>, target: &'a str, mode: &'a str, modeparams: Option<&'a str>) -> IoResult<()> where T: IrcWriter, U: IrcReader {
+    /// Attempts to oper up using the specified username and password
-    server.send(SAMODE(target, mode, modeparams))
+    pub fn send_oper(&self, username: &str, password: &str) -> IoResult<()> {
-}
+        self.server.send(OPER(username, password))
+    }
 
-pub fn send_sanick<'a, T, U>(server: &Server<'a, T, U>, old_nick: &str, new_nick: &str) -> IoResult<()> where T: IrcWriter, U: IrcReader {
+    /// Sends a message to the specified target
-    server.send(SANICK(old_nick, new_nick))
+    pub fn send_privmsg(&self, target: &str, message: &str) -> IoResult<()> {
+        self.server.send(PRIVMSG(target, message))
+    }
+
+    /// Kills the target with the provided message
+    pub fn send_kill(&self, target: &str, message: &str) -> IoResult<()> {
+        self.server.send(KILL(target, message))
+    }
+
+    /// Changes the mode of the target
+    pub fn send_samode(&self, target: &'a str, mode: &'a str, modeparams: Option<&'a str>) -> IoResult<()> {
+        self.server.send(SAMODE(target, mode, modeparams))
+    }
+
+    /// Forces a user to change from the old nickname to the new nickname
+    pub fn send_sanick(&self, old_nick: &str, new_nick: &str) -> IoResult<()> {
+        self.server.send(SANICK(old_nick, new_nick))
+    }
 }