DGNum/rust-irc
6
0
Fork 0
Code Issues 1 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Simplified code with new syntax.

Browse source
This commit is contained in:
Aaron Weiss 2014-10-27 00:44:17 -04:00
parent 35af08ef7c
commit e48aca279d
3 changed files with 27 additions and 26 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

35
src/bot.rs
View file

@ -15,7 +15,7 @@ pub struct IrcBot<'a, T, U> where T: IrcWriter, U: IrcReader {
impl<'a> IrcBot<'a, BufferedWriter<TcpStream>, BufferedReader<TcpStream>> {
pub fn new(process: |&IrcBot<BufferedWriter<TcpStream>, BufferedReader<TcpStream>>, &str, &str, &[&str]|:'a -> IoResult<()>) -> IoResult<IrcBot<'a, BufferedWriter<TcpStream>, BufferedReader<TcpStream>>> {
let config = try!(Config::load());
let conn = try!(Connection::connect(config.server.as_slice(), config.port));
let conn = try!(Connection::connect(config.server[], config.port));
Ok(IrcBot {
conn: conn,
config: config,
@ -35,35 +35,35 @@ impl<'a, T, U> Bot for IrcBot<'a, T, U> where T: IrcWriter, U: IrcReader {
}
fn send_join(&self, chan: &str) -> IoResult<()> {
self.conn.send(Message::new(None, "JOIN", [chan.as_slice()]))
self.conn.send(Message::new(None, "JOIN", [chan[]]))
}
fn send_mode(&self, chan: &str, mode: &str) -> IoResult<()> {
self.conn.send(Message::new(None, "MODE", [chan.as_slice(), mode.as_slice()]))
self.conn.send(Message::new(None, "MODE", [chan[], mode[]]))
}
fn send_topic(&self, chan: &str, topic: &str) -> IoResult<()> {
self.conn.send(Message::new(None, "TOPIC", [chan.as_slice(), topic.as_slice()]))
self.conn.send(Message::new(None, "TOPIC", [chan[], topic[]]))
}
fn send_invite(&self, person: &str, chan: &str) -> IoResult<()> {
self.conn.send(Message::new(None, "INVITE", [person.as_slice(), chan.as_slice()]))
self.conn.send(Message::new(None, "INVITE", [person[], chan[]]))
}
fn send_kick(&self, chan: &str, user: &str, msg: &str) -> IoResult<()> {
self.conn.send(Message::new(None, "KICK", [chan.as_slice(), user.as_slice(), msg.as_slice()]))
self.conn.send(Message::new(None, "KICK", [chan[], user[], msg[]]))
}
fn send_privmsg(&self, chan: &str, msg: &str) -> IoResult<()> {
for line in msg.split_str("\r\n") {
try!(self.conn.send(Message::new(None, "PRIVMSG", [chan.as_slice(), line.as_slice()])));
try!(self.conn.send(Message::new(None, "PRIVMSG", [chan[], line[]])));
}
Ok(())
}
fn identify(&self) -> IoResult<()> {
try!(self.send_nick(self.config.nickname.as_slice()));
self.send_user(self.config.username.as_slice(), self.config.realname.as_slice())
try!(self.send_nick(self.config.nickname[]));
self.send_user(self.config.username[], self.config.realname[])
}
fn output(&mut self) -> IoResult<()> {
@ -71,8 +71,8 @@ impl<'a, T, U> Bot for IrcBot<'a, T, U> where T: IrcWriter, U: IrcReader {
for line in reader.lines() {
match line {
Ok(ln) => {
let (source, command, args) = try!(process(ln.as_slice()));
try!(self.handle_command(source, command, args.as_slice()));
let (source, command, args) = try!(process(ln[]));
try!(self.handle_command(source, command, args[]));
println!("{}", ln)
},
Err(e) => {
@ -110,24 +110,21 @@ impl<'a, T, U> IrcBot<'a, T, U> where T: IrcWriter, U: IrcReader {
},
("376", _) => { // End of MOTD
for chan in self.config.channels.iter() {
try!(self.send_join(chan.as_slice()));
try!(self.send_join(chan[]));
}
},
("422", _) => { // Missing MOTD
for chan in self.config.channels.iter() {
try!(self.send_join(chan.as_slice()));
try!(self.send_join(chan[]));
}
},
("353", [_, _, chan, users]) => { // /NAMES
for user in users.split_str(" ") {
if !match self.chanlists.borrow_mut().find_mut(&String::from_str(chan)) {
Some(vec) => {
vec.push(User::new(user));
true
},
Some(vec) => { vec.push(User::new(user)); true },
None => false,
} {
self.chanlists.borrow_mut().insert(String::from_str(chan), vec!(User::new(user)));
self.chanlists.borrow_mut().insert(chan.into_string(), vec!(User::new(user)));
}
}
},
@ -243,7 +240,7 @@ mod test {
let c = Connection::new(MemWriter::new(), NullReader).unwrap();
let b = IrcBot::from_connection(c, |_, _, _, _| { Ok(()) }).unwrap();
b.send_privmsg("#test", "This is a test message.\r\nIt has two lines.").unwrap();
let mut exp = String::from_str("PRIVMSG #test :This is a test message.\r\n");
let mut exp = format!("PRIVMSG #test :This is a test message.\r\n");
exp.push_str("PRIVMSG #test :It has two lines.\r\n");
assert_eq!(data(b.conn), format!("{}", exp));

14
src/conn.rs
View file

@ -32,12 +32,12 @@ impl<T, U> Connection<T, U> where T: IrcWriter, U: IrcReader {
let mut send = msg.command.to_string();
if msg.args.init().len() > 0 {
send.push_str(" ");
send.push_str(msg.args.init().connect(" ").as_slice());
send.push_str(msg.args.init().connect(" ")[]);
}
send.push_str(" :");
send.push_str(*msg.args.last().unwrap());
send.push_str("\r\n");
self.send_internal(send.as_slice())
self.send_internal(send[])
}
pub fn writer<'a>(&'a self) -> RefMut<'a, T> {
@ -54,7 +54,11 @@ mod test {
use super::Connection;
use std::io::MemWriter;
use std::io::util::NullReader;
use data::Message;
use data::{IrcReader, Message};
fn data<U>(conn: Connection<MemWriter, U>) -> String where U: IrcReader {
String::from_utf8(conn.writer().deref_mut().get_ref().to_vec()).unwrap()
}
#[test]
fn new_connection() {
@ -65,7 +69,7 @@ mod test {
fn send_internal() {
let c = Connection::new(MemWriter::new(), NullReader).unwrap();
c.send_internal("string of text").unwrap();
assert_eq!(c.writer().deref_mut().get_ref(), "string of text".as_bytes());
assert_eq!(data(c), format!("string of text"));
}
#[test]
@ -73,6 +77,6 @@ mod test {
let c = Connection::new(MemWriter::new(), NullReader).unwrap();
let args = ["flare.to.ca.fyrechat.net"];
c.send(Message::new(None, "PING", args)).unwrap();
assert_eq!(c.writer().deref_mut().get_ref(), "PING :flare.to.ca.fyrechat.net\r\n".as_bytes());
assert_eq!(data(c), format!("PING :flare.to.ca.fyrechat.net\r\n"));
}
}

4
src/data.rs
View file

@ -83,7 +83,7 @@ impl Config {
pub fn load() -> IoResult<Config> {
let mut file = try!(File::open(&Path::new("config.json")));
let data = try!(file.read_to_string());
decode(data.as_slice()).map_err(|e| IoError {
decode(data[]).map_err(|e| IoError {
kind: InvalidInput,
desc: "Decoder error",
detail: Some(e.to_string()),
@ -91,7 +91,7 @@ impl Config {
}
pub fn is_owner(&self, nickname: &str) -> bool {
self.owners.as_slice().contains(&String::from_str(nickname))
self.owners[].contains(&String::from_str(nickname))
}
}