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

Updated for Rust master.

Browse source
This commit is contained in:
Aaron Weiss 2015-01-09 17:38:46 -05:00
parent 4e661b47fa
commit d0b54f8119
14 changed files with 343 additions and 335 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
examples/autoreconnect.rs
View file

@ -1,3 +1,4 @@
#![allow(unstable)]
#![feature(slicing_syntax)] #![feature(slicing_syntax)]
extern crate irc; extern crate irc;
@ -18,7 +19,7 @@ fn main() {
let irc_server = Arc::new(IrcServer::from_config(config).unwrap()); let irc_server = Arc::new(IrcServer::from_config(config).unwrap());
irc_server.conn().set_keepalive(Some(5)).unwrap(); irc_server.conn().set_keepalive(Some(5)).unwrap();
// The wrapper provides us with methods like send_privmsg(...) and identify(...) // The wrapper provides us with methods like send_privmsg(...) and identify(...)
let _ = Thread::spawn(move || { let _ = Thread::scoped(move || {
let server = Wrapper::new(&*irc_server); let server = Wrapper::new(&*irc_server);
server.identify().unwrap(); server.identify().unwrap();
loop { loop {

3
examples/multithreaded.rs
View file

@ -1,3 +1,4 @@
#![allow(unstable)]
#![feature(slicing_syntax)] #![feature(slicing_syntax)]
extern crate irc; extern crate irc;
@ -21,7 +22,7 @@ fn main() {
server.identify().unwrap(); server.identify().unwrap();
let server = irc_server.clone(); let server = irc_server.clone();
// We won't use a wrapper here because we don't need the added functionality. // We won't use a wrapper here because we don't need the added functionality.
let _ = Thread::spawn(move || { let _ = Thread::scoped(move || {
for msg in server.iter() { for msg in server.iter() {
print!("{}", msg.unwrap().into_string()); print!("{}", msg.unwrap().into_string());
} }

5
examples/simple.rs
View file

@ -1,3 +1,4 @@
#![allow(unstable)]
#![feature(slicing_syntax)] #![feature(slicing_syntax)]
extern crate irc; extern crate irc;
@ -21,10 +22,10 @@ fn main() {
for message in server.iter() { for message in server.iter() {
let message = message.unwrap(); // We'll just panic if there's an error. let message = message.unwrap(); // We'll just panic if there's an error.
print!("{}", message.into_string()); print!("{}", message.into_string());
if message.command[] == "PRIVMSG" { if &message.command[] == "PRIVMSG" {
if let Some(msg) = message.suffix { if let Some(msg) = message.suffix {
if msg.contains("pickles") { if msg.contains("pickles") {
server.send_privmsg(message.args[0][], "Hi!").unwrap(); server.send_privmsg(&message.args[0][], "Hi!").unwrap();
} }
} }
} }

5
examples/simple_ssl.rs
View file

@ -1,3 +1,4 @@
#![allow(unstable)]
#![feature(slicing_syntax)] #![feature(slicing_syntax)]
extern crate irc; extern crate irc;
@ -22,10 +23,10 @@ fn main() {
for message in server.iter() { for message in server.iter() {
let message = message.unwrap(); // We'll just panic if there's an error. let message = message.unwrap(); // We'll just panic if there's an error.
print!("{}", message.into_string()); print!("{}", message.into_string());
if message.command[] == "PRIVMSG" { if &message.command[] == "PRIVMSG" {
if let Some(msg) = message.suffix { if let Some(msg) = message.suffix {
if msg.contains("pickles") { if msg.contains("pickles") {
server.send_privmsg(message.args[0][], "Hi!").unwrap(); server.send_privmsg(&message.args[0][], "Hi!").unwrap();
} }
} }
} }

3
examples/tweeter.rs
View file

@ -1,4 +1,5 @@
#![feature(slicing_syntax)] #![feature(slicing_syntax)]
#![allow(unstable)]
extern crate irc; extern crate irc;
use std::default::Default; use std::default::Default;
@ -25,7 +26,7 @@ fn main() {
// Let's set up a loop that just prints the messages. // Let's set up a loop that just prints the messages.
Thread::spawn(move || { Thread::spawn(move || {
irc_server.iter().map(|m| print!("{}", m.unwrap().into_string())).count(); irc_server.iter().map(|m| print!("{}", m.unwrap().into_string())).count();
}).detach(); });
loop { loop {
server.send_privmsg("#vana", "TWEET TWEET").unwrap(); server.send_privmsg("#vana", "TWEET TWEET").unwrap();
sleep(Duration::seconds(10)) sleep(Duration::seconds(10))

51
src/conn.rs
View file

@ -1,8 +1,9 @@
//! Thread-safe connections on IrcStreams. //! Thread-safe connections on IrcStreams.
#![experimental] #![experimental]
use std::sync::{Mutex, MutexGuard}; use std::error::Error;
use std::io::{BufferedReader, BufferedWriter, IoResult, TcpStream}; use std::io::{BufferedReader, BufferedWriter, IoResult, TcpStream};
#[cfg(any(feature = "encode", feature = "ssl"))] use std::io::{IoError, IoErrorKind}; #[cfg(any(feature = "encode", feature = "ssl"))] use std::io::{IoError, IoErrorKind};
use std::sync::{Mutex, MutexGuard};
#[cfg(feature = "encode")] use encoding::{DecoderTrap, EncoderTrap, Encoding}; #[cfg(feature = "encode")] use encoding::{DecoderTrap, EncoderTrap, Encoding};
#[cfg(feature = "encode")] use encoding::label::encoding_from_whatwg_label; #[cfg(feature = "encode")] use encoding::label::encoding_from_whatwg_label;
use data::kinds::{IrcReader, IrcWriter}; use data::kinds::{IrcReader, IrcWriter};
@ -33,7 +34,7 @@ impl Connection<BufferedReader<NetStream>, BufferedWriter<NetStream>> {
/// connects to the specified server and returns a reader-writer pair. /// connects to the specified server and returns a reader-writer pair.
fn connect_internal(host: &str, port: u16) -> IoResult<NetReaderWriterPair> { fn connect_internal(host: &str, port: u16) -> IoResult<NetReaderWriterPair> {
let socket = try!(TcpStream::connect(format!("{}:{}", host, port)[])); let socket = try!(TcpStream::connect(&format!("{}:{}", host, port)[]));
Ok((BufferedReader::new(NetStream::UnsecuredTcpStream(socket.clone())), Ok((BufferedReader::new(NetStream::UnsecuredTcpStream(socket.clone())),
BufferedWriter::new(NetStream::UnsecuredTcpStream(socket)))) BufferedWriter::new(NetStream::UnsecuredTcpStream(socket))))
} }
@ -49,7 +50,7 @@ impl Connection<BufferedReader<NetStream>, BufferedWriter<NetStream>> {
/// Connects over SSL to the specified server and returns a reader-writer pair. /// Connects over SSL to the specified server and returns a reader-writer pair.
#[cfg(feature = "ssl")] #[cfg(feature = "ssl")]
fn connect_ssl_internal(host: &str, port: u16) -> IoResult<NetReaderWriterPair> { fn connect_ssl_internal(host: &str, port: u16) -> IoResult<NetReaderWriterPair> {
let socket = try!(TcpStream::connect(format!("{}:{}", host, port)[])); let socket = try!(TcpStream::connect(&format!("{}:{}", host, port)[]));
let ssl = try!(ssl_to_io(SslContext::new(SslMethod::Tlsv1))); let ssl = try!(ssl_to_io(SslContext::new(SslMethod::Tlsv1)));
let ssl_socket = try!(ssl_to_io(SslStream::new(&ssl, socket))); let ssl_socket = try!(ssl_to_io(SslStream::new(&ssl, socket)));
Ok((BufferedReader::new(NetStream::SslTcpStream(ssl_socket.clone())), Ok((BufferedReader::new(NetStream::SslTcpStream(ssl_socket.clone())),
@ -81,7 +82,7 @@ impl Connection<BufferedReader<NetStream>, BufferedWriter<NetStream>> {
/// Sets the keepalive for the network stream. /// Sets the keepalive for the network stream.
#[experimental] #[experimental]
pub fn set_keepalive(&self, delay_in_seconds: Option<uint>) -> IoResult<()> { pub fn set_keepalive(&self, delay_in_seconds: Option<usize>) -> IoResult<()> {
self.mod_stream(|tcp| tcp.set_keepalive(delay_in_seconds)) self.mod_stream(|tcp| tcp.set_keepalive(delay_in_seconds))
} }
@ -94,9 +95,9 @@ impl Connection<BufferedReader<NetStream>, BufferedWriter<NetStream>> {
/// Modifies the internal TcpStream using a function. /// Modifies the internal TcpStream using a function.
fn mod_stream<F>(&self, f: F) -> IoResult<()> where F: FnOnce(&mut TcpStream) -> IoResult<()> { fn mod_stream<F>(&self, f: F) -> IoResult<()> where F: FnOnce(&mut TcpStream) -> IoResult<()> {
match self.reader.lock().unwrap().get_mut() { match self.reader.lock().unwrap().get_mut() {
&NetStream::UnsecuredTcpStream(ref mut tcp) => f(tcp), &mut NetStream::UnsecuredTcpStream(ref mut tcp) => f(tcp),
#[cfg(feature = "ssl")] #[cfg(feature = "ssl")]
&NetStream::SslTcpStream(ref mut ssl) => f(ssl.get_mut()), &mut NetStream::SslTcpStream(ref mut ssl) => f(ssl.get_mut()),
} }
} }
} }
@ -114,7 +115,7 @@ impl<T: IrcReader, U: IrcWriter> Connection<T, U> {
/// Sends a Message over this connection. /// Sends a Message over this connection.
#[experimental] #[experimental]
#[cfg(feature = "encode")] #[cfg(feature = "encode")]
pub fn send<T: ToMessage>(&self, to_msg: T, encoding: &str) -> IoResult<()> { pub fn send<M: ToMessage>(&self, to_msg: M, encoding: &str) -> IoResult<()> {
let encoding = match encoding_from_whatwg_label(encoding) { let encoding = match encoding_from_whatwg_label(encoding) {
Some(enc) => enc, Some(enc) => enc,
None => return Err(IoError { None => return Err(IoError {
@ -124,7 +125,7 @@ impl<T: IrcReader, U: IrcWriter> Connection<T, U> {
}) })
}; };
let msg = to_msg.to_message(); let msg = to_msg.to_message();
let data = match encoding.encode(msg.into_string()[], EncoderTrap::Replace) { let data = match encoding.encode(&msg.into_string()[], EncoderTrap::Replace) {
Ok(data) => data, Ok(data) => data,
Err(data) => return Err(IoError { Err(data) => return Err(IoError {
kind: IoErrorKind::InvalidInput, kind: IoErrorKind::InvalidInput,
@ -133,7 +134,7 @@ impl<T: IrcReader, U: IrcWriter> Connection<T, U> {
}) })
}; };
let mut writer = self.writer.lock().unwrap(); let mut writer = self.writer.lock().unwrap();
try!(writer.write(data[])); try!(writer.write(&data[]));
writer.flush() writer.flush()
} }
@ -159,7 +160,7 @@ impl<T: IrcReader, U: IrcWriter> Connection<T, U> {
}) })
}; };
self.reader.lock().unwrap().read_until(b'\n').and_then(|line| self.reader.lock().unwrap().read_until(b'\n').and_then(|line|
match encoding.decode(line[], DecoderTrap::Replace) { match encoding.decode(&line[], DecoderTrap::Replace) {
Ok(data) => Ok(data), Ok(data) => Ok(data),
Err(data) => Err(IoError { Err(data) => Err(IoError {
kind: IoErrorKind::InvalidInput, kind: IoErrorKind::InvalidInput,
@ -198,7 +199,7 @@ fn ssl_to_io<T>(res: Result<T, SslError>) -> IoResult<T> {
Err(e) => Err(IoError { Err(e) => Err(IoError {
kind: IoErrorKind::OtherIoError, kind: IoErrorKind::OtherIoError,
desc: "An SSL error occurred.", desc: "An SSL error occurred.",
detail: Some(format!("{}", e)), detail: e.detail(),
}), }),
} }
} }
@ -215,11 +216,11 @@ pub enum NetStream {
} }
impl Reader for NetStream { impl Reader for NetStream {
fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> { fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
match self { match self {
&NetStream::UnsecuredTcpStream(ref mut stream) => stream.read(buf), &mut NetStream::UnsecuredTcpStream(ref mut stream) => stream.read(buf),
#[cfg(feature = "ssl")] #[cfg(feature = "ssl")]
&NetStream::SslTcpStream(ref mut stream) => stream.read(buf), &mut NetStream::SslTcpStream(ref mut stream) => stream.read(buf),
} }
} }
} }
@ -227,9 +228,9 @@ impl Reader for NetStream {
impl Writer for NetStream { impl Writer for NetStream {
fn write(&mut self, buf: &[u8]) -> IoResult<()> { fn write(&mut self, buf: &[u8]) -> IoResult<()> {
match self { match self {
&NetStream::UnsecuredTcpStream(ref mut stream) => stream.write(buf), &mut NetStream::UnsecuredTcpStream(ref mut stream) => stream.write(buf),
#[cfg(feature = "ssl")] #[cfg(feature = "ssl")]
&NetStream::SslTcpStream(ref mut stream) => stream.write(buf), &mut NetStream::SslTcpStream(ref mut stream) => stream.write(buf),
} }
} }
} }
@ -251,7 +252,7 @@ mod test {
Message::new(None, "PRIVMSG", Some(vec!["test"]), Some("Testing!")) Message::new(None, "PRIVMSG", Some(vec!["test"]), Some("Testing!"))
).is_ok()); ).is_ok());
let data = String::from_utf8(conn.writer().get_ref().to_vec()).unwrap(); let data = String::from_utf8(conn.writer().get_ref().to_vec()).unwrap();
assert_eq!(data[], "PRIVMSG test :Testing!\r\n"); assert_eq!(&data[], "PRIVMSG test :Testing!\r\n");
} }
#[test] #[test]
@ -261,7 +262,7 @@ mod test {
let conn = Connection::new(NullReader, MemWriter::new()); let conn = Connection::new(NullReader, MemWriter::new());
assert!(conn.send(exp).is_ok()); assert!(conn.send(exp).is_ok());
let data = String::from_utf8(conn.writer().get_ref().to_vec()).unwrap(); let data = String::from_utf8(conn.writer().get_ref().to_vec()).unwrap();
assert_eq!(data[], exp); assert_eq!(&data[], exp);
} }
#[test] #[test]
@ -272,7 +273,7 @@ mod test {
Message::new(None, "PRIVMSG", Some(vec!["test"]), Some("€ŠšŽžŒœŸ")), "UTF-8" Message::new(None, "PRIVMSG", Some(vec!["test"]), Some("€ŠšŽžŒœŸ")), "UTF-8"
).is_ok()); ).is_ok());
let data = UTF_8.decode(conn.writer().get_ref(), DecoderTrap::Strict).unwrap(); let data = UTF_8.decode(conn.writer().get_ref(), DecoderTrap::Strict).unwrap();
assert_eq!(data[], "PRIVMSG test :€ŠšŽžŒœŸ\r\n"); assert_eq!(&data[], "PRIVMSG test :€ŠšŽžŒœŸ\r\n");
} }
#[test] #[test]
@ -282,7 +283,7 @@ mod test {
let conn = Connection::new(NullReader, MemWriter::new()); let conn = Connection::new(NullReader, MemWriter::new());
assert!(conn.send(exp, "UTF-8").is_ok()); assert!(conn.send(exp, "UTF-8").is_ok());
let data = UTF_8.decode(conn.writer().get_ref(), DecoderTrap::Strict).unwrap(); let data = UTF_8.decode(conn.writer().get_ref(), DecoderTrap::Strict).unwrap();
assert_eq!(data[], exp); assert_eq!(&data[], exp);
} }
#[test] #[test]
@ -293,7 +294,7 @@ mod test {
Message::new(None, "PRIVMSG", Some(vec!["test"]), Some("€ŠšŽžŒœŸ")), "l9" Message::new(None, "PRIVMSG", Some(vec!["test"]), Some("€ŠšŽžŒœŸ")), "l9"
).is_ok()); ).is_ok());
let data = ISO_8859_15.decode(conn.writer().get_ref(), DecoderTrap::Strict).unwrap(); let data = ISO_8859_15.decode(conn.writer().get_ref(), DecoderTrap::Strict).unwrap();
assert_eq!(data[], "PRIVMSG test :€ŠšŽžŒœŸ\r\n"); assert_eq!(&data[], "PRIVMSG test :€ŠšŽžŒœŸ\r\n");
} }
#[test] #[test]
@ -303,7 +304,7 @@ mod test {
let conn = Connection::new(NullReader, MemWriter::new()); let conn = Connection::new(NullReader, MemWriter::new());
assert!(conn.send(exp, "l9").is_ok()); assert!(conn.send(exp, "l9").is_ok());
let data = ISO_8859_15.decode(conn.writer().get_ref(), DecoderTrap::Strict).unwrap(); let data = ISO_8859_15.decode(conn.writer().get_ref(), DecoderTrap::Strict).unwrap();
assert_eq!(data[], exp); assert_eq!(&data[], exp);
} }
#[test] #[test]
@ -312,7 +313,7 @@ mod test {
let conn = Connection::new( let conn = Connection::new(
MemReader::new("PRIVMSG test :Testing!\r\n".as_bytes().to_vec()), NullWriter MemReader::new("PRIVMSG test :Testing!\r\n".as_bytes().to_vec()), NullWriter
); );
assert_eq!(conn.recv().unwrap()[], "PRIVMSG test :Testing!\r\n"); assert_eq!(&conn.recv().unwrap()[], "PRIVMSG test :Testing!\r\n");
} }
#[test] #[test]
@ -321,7 +322,7 @@ mod test {
let conn = Connection::new( let conn = Connection::new(
MemReader::new(b"PRIVMSG test :Testing!\r\n".to_vec()), NullWriter MemReader::new(b"PRIVMSG test :Testing!\r\n".to_vec()), NullWriter
); );
assert_eq!(conn.recv("UTF-8").unwrap()[], "PRIVMSG test :Testing!\r\n"); assert_eq!(&conn.recv("UTF-8").unwrap()[], "PRIVMSG test :Testing!\r\n");
} }
#[test] #[test]
@ -336,6 +337,6 @@ mod test {
vec vec
}), NullWriter }), NullWriter
); );
assert_eq!(conn.recv("l9").unwrap()[], "PRIVMSG test :€ŠšŽžŒœŸ\r\n"); assert_eq!(&conn.recv("l9").unwrap()[], "PRIVMSG test :€ŠšŽžŒœŸ\r\n");
} }
} }

380
src/data/command.rs
View file

@ -161,8 +161,8 @@ impl<'a> ToMessage for Command<'a> {
Command::OPER(u, p) => Message::new(None, "OPER", Some(vec![u]), Some(p)), Command::OPER(u, p) => Message::new(None, "OPER", Some(vec![u]), Some(p)),
Command::MODE(t, m, Some(p)) => Message::new(None, "MODE", Some(vec![t, m, p]), None), Command::MODE(t, m, Some(p)) => Message::new(None, "MODE", Some(vec![t, m, p]), None),
Command::MODE(t, m, None) => Message::new(None, "MODE", Some(vec![t, m]), None), Command::MODE(t, m, None) => Message::new(None, "MODE", Some(vec![t, m]), None),
Command::SERVICE(n, r, d, t, re, i) => Message::new(None, "SERVICE", Command::SERVICE(n, r, d, t, re, i) => Message::new(None, "SERVICE",
Some(vec![n, r, d, t, re]), Some(vec![n, r, d, t, re]),
Some(i)), Some(i)),
Command::QUIT(Some(m)) => Message::new(None, "QUIT", None, Some(m)), Command::QUIT(Some(m)) => Message::new(None, "QUIT", None, Some(m)),
Command::QUIT(None) => Message::new(None, "QUIT", None, None), Command::QUIT(None) => Message::new(None, "QUIT", None, None),
@ -268,277 +268,277 @@ impl<'a> Command<'a> {
/// Converts a Message into a Command. /// Converts a Message into a Command.
#[stable] #[stable]
pub fn from_message(m: &'a Message) -> IoResult<Command<'a>> { pub fn from_message(m: &'a Message) -> IoResult<Command<'a>> {
Ok(if let "PASS" = m.command[] { Ok(if let "PASS" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 0 { return Err(invalid_input()) } if m.args.len() != 0 { return Err(invalid_input()) }
Command::PASS(suffix[]) Command::PASS(&suffix[])
}, },
None => { None => {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
Command::PASS(m.args[0][]) Command::PASS(&m.args[0][])
} }
} }
} else if let "NICK" = m.command[] { } else if let "NICK" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 0 { return Err(invalid_input()) } if m.args.len() != 0 { return Err(invalid_input()) }
Command::NICK(suffix[]) Command::NICK(&suffix[])
}, },
None => { None => {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
Command::NICK(m.args[0][]) Command::NICK(&m.args[0][])
} }
} }
} else if let "USER" = m.command[] { } else if let "USER" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 2 { return Err(invalid_input()) } if m.args.len() != 2 { return Err(invalid_input()) }
Command::USER(m.args[0][], m.args[1][], suffix[]) Command::USER(&m.args[0][], &m.args[1][], &suffix[])
}, },
None => { None => {
if m.args.len() != 3 { return Err(invalid_input()) } if m.args.len() != 3 { return Err(invalid_input()) }
Command::USER(m.args[0][], m.args[1][], m.args[2][]) Command::USER(&m.args[0][], &m.args[1][], &m.args[2][])
} }
} }
} else if let "OPER" = m.command[] { } else if let "OPER" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
Command::OPER(m.args[0][], suffix[]) Command::OPER(&m.args[0][], &suffix[])
}, },
None => { None => {
if m.args.len() != 2 { return Err(invalid_input()) } if m.args.len() != 2 { return Err(invalid_input()) }
Command::OPER(m.args[0][], m.args[1][]) Command::OPER(&m.args[0][], &m.args[1][])
} }
} }
} else if let "MODE" = m.command[] { } else if let "MODE" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 2 { return Err(invalid_input()) } if m.args.len() != 2 { return Err(invalid_input()) }
Command::MODE(m.args[0][], m.args[1][], Some(suffix[])) Command::MODE(&m.args[0][], &m.args[1][], Some(&suffix[]))
} }
None => if m.args.len() == 3 { None => if m.args.len() == 3 {
Command::MODE(m.args[0][], m.args[1][], Some(m.args[2][])) Command::MODE(&m.args[0][], &m.args[1][], Some(&m.args[2][]))
} else if m.args.len() == 2 { } else if m.args.len() == 2 {
Command::MODE(m.args[0][], m.args[1][], None) Command::MODE(&m.args[0][], &m.args[1][], None)
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
} }
} }
} else if let "SERVICE" = m.command[] { } else if let "SERVICE" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 5 { return Err(invalid_input()) } if m.args.len() != 5 { return Err(invalid_input()) }
Command::SERVICE(m.args[0][], m.args[1][], m.args[2][], m.args[3][], Command::SERVICE(&m.args[0][], &m.args[1][], &m.args[2][], &m.args[3][],
m.args[4][], suffix[]) &m.args[4][], &suffix[])
}, },
None => { None => {
if m.args.len() != 6 { return Err(invalid_input()) } if m.args.len() != 6 { return Err(invalid_input()) }
Command::SERVICE(m.args[0][], m.args[1][], m.args[2][], m.args[3][], Command::SERVICE(&m.args[0][], &m.args[1][], &m.args[2][], &m.args[3][],
m.args[4][], m.args[5][]) &m.args[4][], &m.args[5][])
} }
} }
} else if let "QUIT" = m.command[] { } else if let "QUIT" = &m.command[] {
if m.args.len() != 0 { return Err(invalid_input()) } if m.args.len() != 0 { return Err(invalid_input()) }
match m.suffix { match m.suffix {
Some(ref suffix) => Command::QUIT(Some(suffix[])), Some(ref suffix) => Command::QUIT(Some(&suffix[])),
None => Command::QUIT(None) None => Command::QUIT(None)
} }
} else if let "SQUIT" = m.command[] { } else if let "SQUIT" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
Command::SQUIT(m.args[0][], suffix[]) Command::SQUIT(&m.args[0][], &suffix[])
}, },
None => { None => {
if m.args.len() != 2 { return Err(invalid_input()) } if m.args.len() != 2 { return Err(invalid_input()) }
Command::SQUIT(m.args[0][], m.args[1][]) Command::SQUIT(&m.args[0][], &m.args[1][])
} }
} }
} else if let "JOIN" = m.command[] { } else if let "JOIN" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => if m.args.len() == 0 { Some(ref suffix) => if m.args.len() == 0 {
Command::JOIN(suffix[], None) Command::JOIN(&suffix[], None)
} else if m.args.len() == 1 { } else if m.args.len() == 1 {
Command::JOIN(m.args[0][], Some(suffix[])) Command::JOIN(&m.args[0][], Some(&suffix[]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
}, },
None => if m.args.len() == 1 { None => if m.args.len() == 1 {
Command::JOIN(m.args[0][], None) Command::JOIN(&m.args[0][], None)
} else if m.args.len() == 2 { } else if m.args.len() == 2 {
Command::JOIN(m.args[0][], Some(m.args[1][])) Command::JOIN(&m.args[0][], Some(&m.args[1][]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
} }
} }
} else if let "PART" = m.command[] { } else if let "PART" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => if m.args.len() == 0 { Some(ref suffix) => if m.args.len() == 0 {
Command::PART(suffix[], None) Command::PART(&suffix[], None)
} else if m.args.len() == 1 { } else if m.args.len() == 1 {
Command::PART(m.args[0][], Some(suffix[])) Command::PART(&m.args[0][], Some(&suffix[]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
}, },
None => if m.args.len() == 1 { None => if m.args.len() == 1 {
Command::PART(m.args[0][], None) Command::PART(&m.args[0][], None)
} else if m.args.len() == 2 { } else if m.args.len() == 2 {
Command::PART(m.args[0][], Some(m.args[1][])) Command::PART(&m.args[0][], Some(&m.args[1][]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
} }
} }
} else if let "TOPIC" = m.command[] { } else if let "TOPIC" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => if m.args.len() == 0 { Some(ref suffix) => if m.args.len() == 0 {
Command::TOPIC(suffix[], None) Command::TOPIC(&suffix[], None)
} else if m.args.len() == 1 { } else if m.args.len() == 1 {
Command::TOPIC(m.args[0][], Some(suffix[])) Command::TOPIC(&m.args[0][], Some(&suffix[]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
}, },
None => if m.args.len() == 1 { None => if m.args.len() == 1 {
Command::TOPIC(m.args[0][], None) Command::TOPIC(&m.args[0][], None)
} else if m.args.len() == 2 { } else if m.args.len() == 2 {
Command::TOPIC(m.args[0][], Some(m.args[1][])) Command::TOPIC(&m.args[0][], Some(&m.args[1][]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
} }
} }
} else if let "NAMES" = m.command[] { } else if let "NAMES" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => if m.args.len() == 0 { Some(ref suffix) => if m.args.len() == 0 {
Command::NAMES(Some(suffix[]), None) Command::NAMES(Some(&suffix[]), None)
} else if m.args.len() == 1 { } else if m.args.len() == 1 {
Command::NAMES(Some(m.args[0][]), Some(suffix[])) Command::NAMES(Some(&m.args[0][]), Some(&suffix[]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
}, },
None => if m.args.len() == 0 { None => if m.args.len() == 0 {
Command::NAMES(None, None) Command::NAMES(None, None)
} else if m.args.len() == 1 { } else if m.args.len() == 1 {
Command::NAMES(Some(m.args[0][]), None) Command::NAMES(Some(&m.args[0][]), None)
} else if m.args.len() == 2 { } else if m.args.len() == 2 {
Command::NAMES(Some(m.args[0][]), Some(m.args[1][])) Command::NAMES(Some(&m.args[0][]), Some(&m.args[1][]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
} }
} }
} else if let "LIST" = m.command[] { } else if let "LIST" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => if m.args.len() == 0 { Some(ref suffix) => if m.args.len() == 0 {
Command::LIST(Some(suffix[]), None) Command::LIST(Some(&suffix[]), None)
} else if m.args.len() == 1 { } else if m.args.len() == 1 {
Command::LIST(Some(m.args[0][]), Some(suffix[])) Command::LIST(Some(&m.args[0][]), Some(&suffix[]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
}, },
None => if m.args.len() == 0 { None => if m.args.len() == 0 {
Command::LIST(None, None) Command::LIST(None, None)
} else if m.args.len() == 1 { } else if m.args.len() == 1 {
Command::LIST(Some(m.args[0][]), None) Command::LIST(Some(&m.args[0][]), None)
} else if m.args.len() == 2 { } else if m.args.len() == 2 {
Command::LIST(Some(m.args[0][]), Some(m.args[1][])) Command::LIST(Some(&m.args[0][]), Some(&m.args[1][]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
} }
} }
} else if let "INVITE" = m.command[] { } else if let "INVITE" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
Command::INVITE(m.args[0][], suffix[]) Command::INVITE(&m.args[0][], &suffix[])
}, },
None => { None => {
if m.args.len() != 2 { return Err(invalid_input()) } if m.args.len() != 2 { return Err(invalid_input()) }
Command::INVITE(m.args[0][], m.args[1][]) Command::INVITE(&m.args[0][], &m.args[1][])
} }
} }
} else if let "KICK" = m.command[] { } else if let "KICK" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 2 { return Err(invalid_input()) } if m.args.len() != 2 { return Err(invalid_input()) }
Command::KICK(m.args[0][], m.args[1][], Some(suffix[])) Command::KICK(&m.args[0][], &m.args[1][], Some(&suffix[]))
}, },
None => { None => {
if m.args.len() != 2 { return Err(invalid_input()) } if m.args.len() != 2 { return Err(invalid_input()) }
Command::KICK(m.args[0][], m.args[1][], None) Command::KICK(&m.args[0][], &m.args[1][], None)
}, },
} }
} else if let "PRIVMSG" = m.command[] { } else if let "PRIVMSG" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
Command::PRIVMSG(m.args[0][], suffix[]) Command::PRIVMSG(&m.args[0][], &suffix[])
}, },
None => return Err(invalid_input()) None => return Err(invalid_input())
} }
} else if let "NOTICE" = m.command[] { } else if let "NOTICE" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
Command::NOTICE(m.args[0][], suffix[]) Command::NOTICE(&m.args[0][], &suffix[])
}, },
None => return Err(invalid_input()) None => return Err(invalid_input())
} }
} else if let "MOTD" = m.command[] { } else if let "MOTD" = &m.command[] {
if m.args.len() != 0 { return Err(invalid_input()) } if m.args.len() != 0 { return Err(invalid_input()) }
match m.suffix { match m.suffix {
Some(ref suffix) => Command::MOTD(Some(suffix[])), Some(ref suffix) => Command::MOTD(Some(&suffix[])),
None => Command::MOTD(None) None => Command::MOTD(None)
} }
} else if let "LUSERS" = m.command[] { } else if let "LUSERS" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => if m.args.len() == 0 { Some(ref suffix) => if m.args.len() == 0 {
Command::LUSERS(Some(suffix[]), None) Command::LUSERS(Some(&suffix[]), None)
} else if m.args.len() == 1 { } else if m.args.len() == 1 {
Command::LUSERS(Some(m.args[0][]), Some(suffix[])) Command::LUSERS(Some(&m.args[0][]), Some(&suffix[]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
}, },
None => if m.args.len() == 0 { None => if m.args.len() == 0 {
Command::LUSERS(None, None) Command::LUSERS(None, None)
} else if m.args.len() == 1 { } else if m.args.len() == 1 {
Command::LUSERS(Some(m.args[0][]), None) Command::LUSERS(Some(&m.args[0][]), None)
} else if m.args.len() == 2 { } else if m.args.len() == 2 {
Command::LUSERS(Some(m.args[0][]), Some(m.args[1][])) Command::LUSERS(Some(&m.args[0][]), Some(&m.args[1][]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
} }
} }
} else if let "VERSION" = m.command[] { } else if let "VERSION" = &m.command[] {
if m.args.len() != 0 { return Err(invalid_input()) } if m.args.len() != 0 { return Err(invalid_input()) }
match m.suffix { match m.suffix {
Some(ref suffix) => Command::VERSION(Some(suffix[])), Some(ref suffix) => Command::VERSION(Some(&suffix[])),
None => Command::VERSION(None) None => Command::VERSION(None)
} }
} else if let "STATS" = m.command[] { } else if let "STATS" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => if m.args.len() == 0 { Some(ref suffix) => if m.args.len() == 0 {
Command::STATS(Some(suffix[]), None) Command::STATS(Some(&suffix[]), None)
} else if m.args.len() == 1 { } else if m.args.len() == 1 {
Command::STATS(Some(m.args[0][]), Some(suffix[])) Command::STATS(Some(&m.args[0][]), Some(&suffix[]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
}, },
None => if m.args.len() == 0 { None => if m.args.len() == 0 {
Command::STATS(None, None) Command::STATS(None, None)
} else if m.args.len() == 1 { } else if m.args.len() == 1 {
Command::STATS(Some(m.args[0][]), None) Command::STATS(Some(&m.args[0][]), None)
} else if m.args.len() == 2 { } else if m.args.len() == 2 {
Command::STATS(Some(m.args[0][]), Some(m.args[1][])) Command::STATS(Some(&m.args[0][]), Some(&m.args[1][]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
} }
} }
} else if let "LINKS" = m.command[] { } else if let "LINKS" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => if m.args.len() == 0 { Some(ref suffix) => if m.args.len() == 0 {
Command::LINKS(None, Some(suffix[])) Command::LINKS(None, Some(&suffix[]))
} else if m.args.len() == 1 { } else if m.args.len() == 1 {
Command::LINKS(Some(m.args[0][]), Some(suffix[])) Command::LINKS(Some(&m.args[0][]), Some(&suffix[]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
}, },
@ -548,396 +548,396 @@ impl<'a> Command<'a> {
return Err(invalid_input()) return Err(invalid_input())
} }
} }
} else if let "TIME" = m.command[] { } else if let "TIME" = &m.command[] {
if m.args.len() != 0 { return Err(invalid_input()) } if m.args.len() != 0 { return Err(invalid_input()) }
match m.suffix { match m.suffix {
Some(ref suffix) => Command::TIME(Some(suffix[])), Some(ref suffix) => Command::TIME(Some(&suffix[])),
None => Command::TIME(None) None => Command::TIME(None)
} }
} else if let "CONNECT" = m.command[] { } else if let "CONNECT" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 2 { return Err(invalid_input()) } if m.args.len() != 2 { return Err(invalid_input()) }
Command::CONNECT(m.args[0][], m.args[1][], Some(suffix[])) Command::CONNECT(&m.args[0][], &m.args[1][], Some(&suffix[]))
}, },
None => { None => {
if m.args.len() != 2 { return Err(invalid_input()) } if m.args.len() != 2 { return Err(invalid_input()) }
Command::CONNECT(m.args[0][], m.args[1][], None) Command::CONNECT(&m.args[0][], &m.args[1][], None)
} }
} }
} else if let "TRACE" = m.command[] { } else if let "TRACE" = &m.command[] {
if m.args.len() != 0 { return Err(invalid_input()) } if m.args.len() != 0 { return Err(invalid_input()) }
match m.suffix { match m.suffix {
Some(ref suffix) => Command::TRACE(Some(suffix[])), Some(ref suffix) => Command::TRACE(Some(&suffix[])),
None => Command::TRACE(None) None => Command::TRACE(None)
} }
} else if let "ADMIN" = m.command[] { } else if let "ADMIN" = &m.command[] {
if m.args.len() != 0 { return Err(invalid_input()) } if m.args.len() != 0 { return Err(invalid_input()) }
match m.suffix { match m.suffix {
Some(ref suffix) => Command::ADMIN(Some(suffix[])), Some(ref suffix) => Command::ADMIN(Some(&suffix[])),
None => Command::ADMIN(None) None => Command::ADMIN(None)
} }
} else if let "INFO" = m.command[] { } else if let "INFO" = &m.command[] {
if m.args.len() != 0 { return Err(invalid_input()) } if m.args.len() != 0 { return Err(invalid_input()) }
match m.suffix { match m.suffix {
Some(ref suffix) => Command::INFO(Some(suffix[])), Some(ref suffix) => Command::INFO(Some(&suffix[])),
None => Command::INFO(None) None => Command::INFO(None)
} }
} else if let "SERVLIST" = m.command[] { } else if let "SERVLIST" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => if m.args.len() == 0 { Some(ref suffix) => if m.args.len() == 0 {
Command::SERVLIST(Some(suffix[]), None) Command::SERVLIST(Some(&suffix[]), None)
} else if m.args.len() == 1 { } else if m.args.len() == 1 {
Command::SERVLIST(Some(m.args[0][]), Some(suffix[])) Command::SERVLIST(Some(&m.args[0][]), Some(&suffix[]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
}, },
None => if m.args.len() == 0 { None => if m.args.len() == 0 {
Command::SERVLIST(None, None) Command::SERVLIST(None, None)
} else if m.args.len() == 1 { } else if m.args.len() == 1 {
Command::SERVLIST(Some(m.args[0][]), None) Command::SERVLIST(Some(&m.args[0][]), None)
} else if m.args.len() == 2 { } else if m.args.len() == 2 {
Command::SERVLIST(Some(m.args[0][]), Some(m.args[1][])) Command::SERVLIST(Some(&m.args[0][]), Some(&m.args[1][]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
} }
} }
} else if let "SQUERY" = m.command[] { } else if let "SQUERY" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
Command::SQUERY(m.args[0][], suffix[]) Command::SQUERY(&m.args[0][], &suffix[])
}, },
None => { None => {
if m.args.len() != 2 { return Err(invalid_input()) } if m.args.len() != 2 { return Err(invalid_input()) }
Command::SQUERY(m.args[0][], m.args[1][]) Command::SQUERY(&m.args[0][], &m.args[1][])
} }
} }
} else if let "WHO" = m.command[] { } else if let "WHO" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => if m.args.len() == 0 { Some(ref suffix) => if m.args.len() == 0 {
Command::WHO(Some(suffix[]), None) Command::WHO(Some(&suffix[]), None)
} else if m.args.len() == 1 { } else if m.args.len() == 1 {
Command::WHO(Some(m.args[0][]), Some(suffix[] == "o")) Command::WHO(Some(&m.args[0][]), Some(&suffix[] == "o"))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
}, },
None => if m.args.len() == 0 { None => if m.args.len() == 0 {
Command::WHO(None, None) Command::WHO(None, None)
} else if m.args.len() == 1 { } else if m.args.len() == 1 {
Command::WHO(Some(m.args[0][]), None) Command::WHO(Some(&m.args[0][]), None)
} else if m.args.len() == 2 { } else if m.args.len() == 2 {
Command::WHO(Some(m.args[0][]), Some(m.args[1][] == "o")) Command::WHO(Some(&m.args[0][]), Some(&m.args[1][] == "o"))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
} }
} }
} else if let "WHOIS" = m.command[] { } else if let "WHOIS" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => if m.args.len() == 0 { Some(ref suffix) => if m.args.len() == 0 {
Command::WHOIS(None, suffix[]) Command::WHOIS(None, &suffix[])
} else if m.args.len() == 1 { } else if m.args.len() == 1 {
Command::WHOIS(Some(m.args[0][]), suffix[]) Command::WHOIS(Some(&m.args[0][]), &suffix[])
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
}, },
None => if m.args.len() == 1 { None => if m.args.len() == 1 {
Command::WHOIS(None, m.args[0][]) Command::WHOIS(None, &m.args[0][])
} else if m.args.len() == 2 { } else if m.args.len() == 2 {
Command::WHOIS(Some(m.args[0][]), m.args[1][]) Command::WHOIS(Some(&m.args[0][]), &m.args[1][])
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
} }
} }
} else if let "WHOWAS" = m.command[] { } else if let "WHOWAS" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => if m.args.len() == 0 { Some(ref suffix) => if m.args.len() == 0 {
Command::WHOWAS(suffix[], None, None) Command::WHOWAS(&suffix[], None, None)
} else if m.args.len() == 1 { } else if m.args.len() == 1 {
Command::WHOWAS(m.args[0][], None, Some(suffix[])) Command::WHOWAS(&m.args[0][], None, Some(&suffix[]))
} else if m.args.len() == 2 { } else if m.args.len() == 2 {
Command::WHOWAS(m.args[0][], Some(m.args[1][]), Some(suffix[])) Command::WHOWAS(&m.args[0][], Some(&m.args[1][]), Some(&suffix[]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
}, },
None => if m.args.len() == 1 { None => if m.args.len() == 1 {
Command::WHOWAS(m.args[0][], None, None) Command::WHOWAS(&m.args[0][], None, None)
} else if m.args.len() == 2 { } else if m.args.len() == 2 {
Command::WHOWAS(m.args[0][], None, Some(m.args[1][])) Command::WHOWAS(&m.args[0][], None, Some(&m.args[1][]))
} else if m.args.len() == 3 { } else if m.args.len() == 3 {
Command::WHOWAS(m.args[0][], Some(m.args[1][]), Some(m.args[2][])) Command::WHOWAS(&m.args[0][], Some(&m.args[1][]), Some(&m.args[2][]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
} }
} }
} else if let "KILL" = m.command[] { } else if let "KILL" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
Command::KILL(m.args[0][], suffix[]) Command::KILL(&m.args[0][], &suffix[])
}, },
None => { None => {
if m.args.len() != 2 { return Err(invalid_input()) } if m.args.len() != 2 { return Err(invalid_input()) }
Command::KILL(m.args[0][], m.args[1][]) Command::KILL(&m.args[0][], &m.args[1][])
} }
} }
} else if let "PING" = m.command[] { } else if let "PING" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => if m.args.len() == 0 { Some(ref suffix) => if m.args.len() == 0 {
Command::PING(suffix[], None) Command::PING(&suffix[], None)
} else if m.args.len() == 1 { } else if m.args.len() == 1 {
Command::PING(m.args[0][], Some(suffix[])) Command::PING(&m.args[0][], Some(&suffix[]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
}, },
None => if m.args.len() == 1 { None => if m.args.len() == 1 {
Command::PING(m.args[0][], None) Command::PING(&m.args[0][], None)
} else if m.args.len() == 2 { } else if m.args.len() == 2 {
Command::PING(m.args[0][], Some(m.args[1][])) Command::PING(&m.args[0][], Some(&m.args[1][]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
} }
} }
} else if let "PONG" = m.command[] { } else if let "PONG" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => if m.args.len() == 0 { Some(ref suffix) => if m.args.len() == 0 {
Command::PONG(suffix[], None) Command::PONG(&suffix[], None)
} else if m.args.len() == 1 { } else if m.args.len() == 1 {
Command::PONG(m.args[0][], Some(suffix[])) Command::PONG(&m.args[0][], Some(&suffix[]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
}, },
None => if m.args.len() == 1 { None => if m.args.len() == 1 {
Command::PONG(m.args[0][], None) Command::PONG(&m.args[0][], None)
} else if m.args.len() == 2 { } else if m.args.len() == 2 {
Command::PONG(m.args[0][], Some(m.args[1][])) Command::PONG(&m.args[0][], Some(&m.args[1][]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
} }
} }
} else if let "ERROR" = m.command[] { } else if let "ERROR" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => if m.args.len() == 0 { Some(ref suffix) => if m.args.len() == 0 {
Command::ERROR(suffix[]) Command::ERROR(&suffix[])
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
}, },
None => return Err(invalid_input()) None => return Err(invalid_input())
} }
} else if let "AWAY" = m.command[] { } else if let "AWAY" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => if m.args.len() == 0 { Some(ref suffix) => if m.args.len() == 0 {
Command::AWAY(Some(suffix[])) Command::AWAY(Some(&suffix[]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
}, },
None => return Err(invalid_input()) None => return Err(invalid_input())
} }
} else if let "REHASH" = m.command[] { } else if let "REHASH" = &m.command[] {
if m.args.len() == 0 { if m.args.len() == 0 {
Command::REHASH Command::REHASH
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
} }
} else if let "DIE" = m.command[] { } else if let "DIE" = &m.command[] {
if m.args.len() == 0 { if m.args.len() == 0 {
Command::DIE Command::DIE
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
} }
} else if let "RESTART" = m.command[] { } else if let "RESTART" = &m.command[] {
if m.args.len() == 0 { if m.args.len() == 0 {
Command::RESTART Command::RESTART
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
} }
} else if let "SUMMON" = m.command[] { } else if let "SUMMON" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => if m.args.len() == 0 { Some(ref suffix) => if m.args.len() == 0 {
Command::SUMMON(suffix[], None, None) Command::SUMMON(&suffix[], None, None)
} else if m.args.len() == 1 { } else if m.args.len() == 1 {
Command::SUMMON(m.args[0][], Some(suffix[]), None) Command::SUMMON(&m.args[0][], Some(&suffix[]), None)
} else if m.args.len() == 2 { } else if m.args.len() == 2 {
Command::SUMMON(m.args[0][], Some(m.args[1][]), Some(suffix[])) Command::SUMMON(&m.args[0][], Some(&m.args[1][]), Some(&suffix[]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
}, },
None => if m.args.len() == 1 { None => if m.args.len() == 1 {
Command::SUMMON(m.args[0][], None, None) Command::SUMMON(&m.args[0][], None, None)
} else if m.args.len() == 2 { } else if m.args.len() == 2 {
Command::SUMMON(m.args[0][], Some(m.args[1][]), None) Command::SUMMON(&m.args[0][], Some(&m.args[1][]), None)
} else if m.args.len() == 3 { } else if m.args.len() == 3 {
Command::SUMMON(m.args[0][], Some(m.args[1][]), Some(m.args[2][])) Command::SUMMON(&m.args[0][], Some(&m.args[1][]), Some(&m.args[2][]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
} }
} }
} else if let "USERS" = m.command[] { } else if let "USERS" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 0 { return Err(invalid_input()) } if m.args.len() != 0 { return Err(invalid_input()) }
Command::USERS(Some(suffix[])) Command::USERS(Some(&suffix[]))
}, },
None => { None => {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
Command::USERS(Some(m.args[0][])) Command::USERS(Some(&m.args[0][]))
} }
} }
} else if let "WALLOPS" = m.command[] { } else if let "WALLOPS" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 0 { return Err(invalid_input()) } if m.args.len() != 0 { return Err(invalid_input()) }
Command::WALLOPS(suffix[]) Command::WALLOPS(&suffix[])
}, },
None => { None => {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
Command::WALLOPS(m.args[0][]) Command::WALLOPS(&m.args[0][])
} }
} }
} else if let "USERHOST" = m.command[] { } else if let "USERHOST" = &m.command[] {
if m.suffix.is_none() { if m.suffix.is_none() {
Command::USERHOST(m.args.iter().map(|s| s[]).collect()) Command::USERHOST(m.args.iter().map(|s| &s[]).collect())
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
} }
} else if let "ISON" = m.command[] { } else if let "ISON" = &m.command[] {
if m.suffix.is_none() { if m.suffix.is_none() {
Command::USERHOST(m.args.iter().map(|s| s[]).collect()) Command::USERHOST(m.args.iter().map(|s| &s[]).collect())
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
} }
} else if let "SAJOIN" = m.command[] { } else if let "SAJOIN" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
Command::SAJOIN(m.args[0][], suffix[]) Command::SAJOIN(&m.args[0][], &suffix[])
}, },
None => { None => {
if m.args.len() != 2 { return Err(invalid_input()) } if m.args.len() != 2 { return Err(invalid_input()) }
Command::SAJOIN(m.args[0][], m.args[1][]) Command::SAJOIN(&m.args[0][], &m.args[1][])
} }
} }
} else if let "SAMODE" = m.command[] { } else if let "SAMODE" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => if m.args.len() == 1 { Some(ref suffix) => if m.args.len() == 1 {
Command::SAMODE(m.args[0][], suffix[], None) Command::SAMODE(&m.args[0][], &suffix[], None)
} else if m.args.len() == 2 { } else if m.args.len() == 2 {
Command::SAMODE(m.args[0][], m.args[1][], Some(suffix[])) Command::SAMODE(&m.args[0][], &m.args[1][], Some(&suffix[]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
}, },
None => if m.args.len() == 2 { None => if m.args.len() == 2 {
Command::SAMODE(m.args[0][], m.args[1][], None) Command::SAMODE(&m.args[0][], &m.args[1][], None)
} else if m.args.len() == 3 { } else if m.args.len() == 3 {
Command::SAMODE(m.args[0][], m.args[1][], Some(m.args[2][])) Command::SAMODE(&m.args[0][], &m.args[1][], Some(&m.args[2][]))
} else { } else {
return Err(invalid_input()) return Err(invalid_input())
} }
} }
} else if let "SANICK" = m.command[] { } else if let "SANICK" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
Command::SANICK(m.args[0][], suffix[]) Command::SANICK(&m.args[0][], &suffix[])
}, },
None => { None => {
if m.args.len() != 2 { return Err(invalid_input()) } if m.args.len() != 2 { return Err(invalid_input()) }
Command::SANICK(m.args[0][], m.args[1][]) Command::SANICK(&m.args[0][], &m.args[1][])
} }
} }
} else if let "SAPART" = m.command[] { } else if let "SAPART" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
Command::SAPART(m.args[0][], suffix[]) Command::SAPART(&m.args[0][], &suffix[])
}, },
None => { None => {
if m.args.len() != 2 { return Err(invalid_input()) } if m.args.len() != 2 { return Err(invalid_input()) }
Command::SAPART(m.args[0][], m.args[1][]) Command::SAPART(&m.args[0][], &m.args[1][])
} }
} }
} else if let "SAQUIT" = m.command[] { } else if let "SAQUIT" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
Command::SAQUIT(m.args[0][], suffix[]) Command::SAQUIT(&m.args[0][], &suffix[])
}, },
None => { None => {
if m.args.len() != 2 { return Err(invalid_input()) } if m.args.len() != 2 { return Err(invalid_input()) }
Command::SAQUIT(m.args[0][], m.args[1][]) Command::SAQUIT(&m.args[0][], &m.args[1][])
} }
} }
} else if let "NICKSERV" = m.command[] { } else if let "NICKSERV" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 0 { return Err(invalid_input()) } if m.args.len() != 0 { return Err(invalid_input()) }
Command::NICKSERV(suffix[]) Command::NICKSERV(&suffix[])
}, },
None => { None => {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
Command::NICKSERV(m.args[0][]) Command::NICKSERV(&m.args[0][])
} }
} }
} else if let "CHANSERV" = m.command[] { } else if let "CHANSERV" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 0 { return Err(invalid_input()) } if m.args.len() != 0 { return Err(invalid_input()) }
Command::CHANSERV(suffix[]) Command::CHANSERV(&suffix[])
}, },
None => { None => {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
Command::CHANSERV(m.args[0][]) Command::CHANSERV(&m.args[0][])
} }
} }
} else if let "OPERSERV" = m.command[] { } else if let "OPERSERV" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 0 { return Err(invalid_input()) } if m.args.len() != 0 { return Err(invalid_input()) }
Command::OPERSERV(suffix[]) Command::OPERSERV(&suffix[])
}, },
None => { None => {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
Command::OPERSERV(m.args[0][]) Command::OPERSERV(&m.args[0][])
} }
} }
} else if let "BOTSERV" = m.command[] { } else if let "BOTSERV" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 0 { return Err(invalid_input()) } if m.args.len() != 0 { return Err(invalid_input()) }
Command::BOTSERV(suffix[]) Command::BOTSERV(&suffix[])
}, },
None => { None => {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
Command::BOTSERV(m.args[0][]) Command::BOTSERV(&m.args[0][])
} }
} }
} else if let "HOSTSERV" = m.command[] { } else if let "HOSTSERV" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 0 { return Err(invalid_input()) } if m.args.len() != 0 { return Err(invalid_input()) }
Command::HOSTSERV(suffix[]) Command::HOSTSERV(&suffix[])
}, },
None => { None => {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
Command::HOSTSERV(m.args[0][]) Command::HOSTSERV(&m.args[0][])
} }
} }
} else if let "MEMOSERV" = m.command[] { } else if let "MEMOSERV" = &m.command[] {
match m.suffix { match m.suffix {
Some(ref suffix) => { Some(ref suffix) => {
if m.args.len() != 0 { return Err(invalid_input()) } if m.args.len() != 0 { return Err(invalid_input()) }
Command::MEMOSERV(suffix[]) Command::MEMOSERV(&suffix[])
}, },
None => { None => {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
Command::MEMOSERV(m.args[0][]) Command::MEMOSERV(&m.args[0][])
} }
} }
} else if let "CAP" = m.command[] { } else if let "CAP" = &m.command[] {
if m.args.len() != 1 { return Err(invalid_input()) } if m.args.len() != 1 { return Err(invalid_input()) }
if let Some(cmd) = m.args[0].parse() { if let Some(cmd) = m.args[0].parse() {
match m.suffix { match m.suffix {
Some(ref suffix) => Command::CAP(cmd, Some(suffix[])), Some(ref suffix) => Command::CAP(cmd, Some(&suffix[])),
None => Command::CAP(cmd, None), None => Command::CAP(cmd, None),
} }
} else { } else {

27
src/data/config.rs
View file

@ -2,6 +2,7 @@
#![stable] #![stable]
use std::borrow::ToOwned; use std::borrow::ToOwned;
use std::collections::HashMap; use std::collections::HashMap;
use std::error::Error;
use std::io::fs::File; use std::io::fs::File;
use std::io::{InvalidInput, IoError, IoResult}; use std::io::{InvalidInput, IoError, IoResult};
use rustc_serialize::json::decode; use rustc_serialize::json::decode;
@ -48,10 +49,10 @@ impl Config {
pub fn load(path: Path) -> IoResult<Config> { pub fn load(path: Path) -> IoResult<Config> {
let mut file = try!(File::open(&path)); let mut file = try!(File::open(&path));
let data = try!(file.read_to_string()); let data = try!(file.read_to_string());
decode(data[]).map_err(|e| IoError { decode(&data[]).map_err(|e| IoError {
kind: InvalidInput, kind: InvalidInput,
desc: "Failed to decode configuration file.", desc: "Failed to decode configuration file.",
detail: Some(e.to_string()), detail: e.detail(),
}) })
} }
@ -71,21 +72,21 @@ impl Config {
/// This will panic if not specified. /// This will panic if not specified.
#[experimental] #[experimental]
pub fn nickname(&self) -> &str { pub fn nickname(&self) -> &str {
self.nickname.as_ref().map(|s| s[]).unwrap() self.nickname.as_ref().map(|s| &s[]).unwrap()
} }
/// Gets the bot's nickserv password specified in the configuration. /// Gets the bot's nickserv password specified in the configuration.
/// This defaults to an empty string when not specified. /// This defaults to an empty string when not specified.
#[experimental] #[experimental]
pub fn nick_password(&self) -> &str { pub fn nick_password(&self) -> &str {
self.nick_password.as_ref().map(|s| s[]).unwrap_or("") self.nick_password.as_ref().map(|s| &s[]).unwrap_or("")
} }
/// Gets the alternate nicknames specified in the configuration. /// Gets the alternate nicknames specified in the configuration.
/// This defaults to an empty vector when not specified. /// This defaults to an empty vector when not specified.
#[experimental] #[experimental]
pub fn get_alternate_nicknames(&self) -> Vec<&str> { pub fn get_alternate_nicknames(&self) -> Vec<&str> {
self.alt_nicks.as_ref().map(|v| v.iter().map(|s| s[]).collect()).unwrap_or(vec![]) self.alt_nicks.as_ref().map(|v| v.iter().map(|s| &s[]).collect()).unwrap_or(vec![])
} }
@ -93,21 +94,21 @@ impl Config {
/// This defaults to the user's nickname when not specified. /// This defaults to the user's nickname when not specified.
#[experimental] #[experimental]
pub fn username(&self) -> &str { pub fn username(&self) -> &str {
self.username.as_ref().map(|s| s[]).unwrap_or(self.nickname()) self.username.as_ref().map(|s| &s[]).unwrap_or(self.nickname())
} }
/// Gets the real name specified in the configuration. /// Gets the real name specified in the configuration.
/// This defaults to the user's nickname when not specified. /// This defaults to the user's nickname when not specified.
#[experimental] #[experimental]
pub fn real_name(&self) -> &str { pub fn real_name(&self) -> &str {
self.realname.as_ref().map(|s| s[]).unwrap_or(self.nickname()) self.realname.as_ref().map(|s| &s[]).unwrap_or(self.nickname())
} }
/// Gets the address of the server specified in the configuration. /// Gets the address of the server specified in the configuration.
/// This panics when not specified. /// This panics when not specified.
#[experimental] #[experimental]
pub fn server(&self) -> &str { pub fn server(&self) -> &str {
self.server.as_ref().map(|s| s[]).unwrap() self.server.as_ref().map(|s| &s[]).unwrap()
} }
/// Gets the port of the server specified in the configuration. /// Gets the port of the server specified in the configuration.
@ -125,7 +126,7 @@ impl Config {
/// This defaults to a blank string when not specified. /// This defaults to a blank string when not specified.
#[experimental] #[experimental]
pub fn password(&self) -> &str { pub fn password(&self) -> &str {
self.password.as_ref().map(|s| s[]).unwrap_or("") self.password.as_ref().map(|s| &s[]).unwrap_or("")
} }
/// Gets whether or not to use SSL with this connection. /// Gets whether or not to use SSL with this connection.
@ -139,21 +140,21 @@ impl Config {
/// This defaults to UTF-8 when not specified. /// This defaults to UTF-8 when not specified.
#[experimental] #[experimental]
pub fn encoding(&self) -> &str { pub fn encoding(&self) -> &str {
self.encoding.as_ref().map(|s| s[]).unwrap_or("UTF-8") self.encoding.as_ref().map(|s| &s[]).unwrap_or("UTF-8")
} }
/// Gets the channels to join upon connection. /// Gets the channels to join upon connection.
/// This defaults to an empty vector if it's not specified. /// This defaults to an empty vector if it's not specified.
#[experimental] #[experimental]
pub fn channels(&self) -> Vec<&str> { pub fn channels(&self) -> Vec<&str> {
self.channels.as_ref().map(|v| v.iter().map(|s| s[]).collect()).unwrap_or(vec![]) self.channels.as_ref().map(|v| v.iter().map(|s| &s[]).collect()).unwrap_or(vec![])
} }
/// Gets the string to be sent in response to CTCP USERINFO requests. /// Gets the string to be sent in response to CTCP USERINFO requests.
/// This defaults to an empty string when not specified. /// This defaults to an empty string when not specified.
#[experimental] #[experimental]
pub fn user_info(&self) -> &str { pub fn user_info(&self) -> &str {
self.user_info.as_ref().map(|s| s[]).unwrap_or("") self.user_info.as_ref().map(|s| &s[]).unwrap_or("")
} }
/// Looks up the specified string in the options map. /// Looks up the specified string in the options map.
@ -161,7 +162,7 @@ impl Config {
/// This will also panic if used and there are no options. /// This will also panic if used and there are no options.
#[experimental] #[experimental]
pub fn get_option(&self, option: &str) -> &str { pub fn get_option(&self, option: &str) -> &str {
self.options.as_ref().map(|o| o[option.to_owned()][]).unwrap() self.options.as_ref().map(|o| &o[option.to_owned()][]).unwrap()
} }
} }

28
src/data/message.rs
View file

@ -34,7 +34,7 @@ impl Message {
/// Gets the nickname of the message source, if it exists. /// Gets the nickname of the message source, if it exists.
#[experimental] #[experimental]
pub fn get_source_nickname(&self) -> Option<&str> { pub fn get_source_nickname(&self) -> Option<&str> {
self.prefix.as_ref().and_then(|s| s.find('!').map(|i| s[..i])) self.prefix.as_ref().and_then(|s| s.find('!').map(|i| &s[..i]))
} }
/// Converts a Message into a String according to the IRC protocol. /// Converts a Message into a String according to the IRC protocol.
@ -43,17 +43,17 @@ impl Message {
let mut ret = String::new(); let mut ret = String::new();
if let Some(ref prefix) = self.prefix { if let Some(ref prefix) = self.prefix {
ret.push(':'); ret.push(':');
ret.push_str(prefix[]); ret.push_str(&prefix[]);
ret.push(' '); ret.push(' ');
} }
ret.push_str(self.command[]); ret.push_str(&self.command[]);
for arg in self.args.iter() { for arg in self.args.iter() {
ret.push(' '); ret.push(' ');
ret.push_str(arg[]); ret.push_str(&arg[]);
} }
if let Some(ref suffix) = self.suffix { if let Some(ref suffix) = self.suffix {
ret.push_str(" :"); ret.push_str(" :");
ret.push_str(suffix[]); ret.push_str(&suffix[]);
} }
ret.push_str("\r\n"); ret.push_str("\r\n");
ret ret
@ -71,27 +71,27 @@ impl FromStr for Message {
let mut state = s.clone(); let mut state = s.clone();
if s.len() == 0 { return None } if s.len() == 0 { return None }
let prefix = if state.starts_with(":") { let prefix = if state.starts_with(":") {
let prefix = state.find(' ').map(|i| state[1..i]); let prefix = state.find(' ').map(|i| &state[1..i]);
state = state.find(' ').map_or("", |i| state[i+1..]); state = state.find(' ').map_or("", |i| &state[i+1..]);
prefix prefix
} else { } else {
None None
}; };
let suffix = if state.contains(":") { let suffix = if state.contains(":") {
let suffix = state.find(':').map(|i| state[i+1..state.len()-2]); let suffix = state.find(':').map(|i| &state[i+1..state.len()-2]);
state = state.find(':').map_or("", |i| state[..i]); state = state.find(':').map_or("", |i| &state[..i]);
suffix suffix
} else { } else {
None None
}; };
let command = match state.find(' ').map(|i| state[..i]) { let command = match state.find(' ').map(|i| &state[..i]) {
Some(cmd) => { Some(cmd) => {
state = state.find(' ').map_or("", |i| state[i+1..]); state = state.find(' ').map_or("", |i| &state[i+1..]);
cmd cmd
} }
_ => return None _ => return None
}; };
if suffix.is_none() { state = state[..state.len() - 2] } if suffix.is_none() { state = &state[..state.len() - 2] }
let args: Vec<_> = state.splitn(14, ' ').filter(|s| s.len() != 0).collect(); let args: Vec<_> = state.splitn(14, ' ').filter(|s| s.len() != 0).collect();
Some(Message::new(prefix, command, if args.len() > 0 { Some(args) } else { None }, suffix)) Some(Message::new(prefix, command, if args.len() > 0 { Some(args) } else { None }, suffix))
} }
@ -143,14 +143,14 @@ mod test {
args: vec![format!("test")], args: vec![format!("test")],
suffix: Some(format!("Testing!")), suffix: Some(format!("Testing!")),
}; };
assert_eq!(message.into_string()[], "PRIVMSG test :Testing!\r\n"); assert_eq!(&message.into_string()[], "PRIVMSG test :Testing!\r\n");
let message = Message { let message = Message {
prefix: Some(format!("test!test@test")), prefix: Some(format!("test!test@test")),
command: format!("PRIVMSG"), command: format!("PRIVMSG"),
args: vec![format!("test")], args: vec![format!("test")],
suffix: Some(format!("Still testing!")), suffix: Some(format!("Still testing!")),
}; };
assert_eq!(message.into_string()[], ":test!test@test PRIVMSG test :Still testing!\r\n"); assert_eq!(&message.into_string()[], ":test!test@test PRIVMSG test :Still testing!\r\n");
} }
#[test] #[test]

6
src/data/response.rs
View file

@ -8,7 +8,7 @@ use data::message::Message;
/// List of all server responses as defined in [RFC 2812](http://tools.ietf.org/html/rfc2812). /// List of all server responses as defined in [RFC 2812](http://tools.ietf.org/html/rfc2812).
/// All commands are documented with their expected form from the RFC. /// All commands are documented with their expected form from the RFC.
#[derive(Copy, Show, PartialEq, FromPrimitive)] #[derive(Copy, Show, PartialEq, FromPrimitive)]
#[repr(uint)] #[repr(u16)]
#[unstable] #[unstable]
pub enum Response { pub enum Response {
// Expected replies // Expected replies
@ -303,14 +303,14 @@ impl Response {
/// Determines whether or not this response is an error response. /// Determines whether or not this response is an error response.
#[stable] #[stable]
pub fn is_error(&self) -> bool { pub fn is_error(&self) -> bool {
*self as uint >= 400 *self as u16 >= 400
} }
} }
impl FromStr for Response { impl FromStr for Response {
fn from_str(s: &str) -> Option<Response> { fn from_str(s: &str) -> Option<Response> {
if let Some(respcode) = s.parse() { if let Some(respcode) = s.parse() {
FromPrimitive::from_uint(respcode) FromPrimitive::from_u16(respcode)
} else { } else {
None None
} }

4
src/data/user.rs
View file

@ -44,7 +44,7 @@ impl User {
/// Gets the nickname of the user. /// Gets the nickname of the user.
#[stable] #[stable]
pub fn get_name(&self) -> &str { pub fn get_name(&self) -> &str {
self.name[] &self.name[]
} }
/// Gets the user's highest access level. /// Gets the user's highest access level.
@ -194,7 +194,7 @@ impl<'a> Iterator for AccessLevelIterator<'a> {
fn next(&mut self) -> Option<AccessLevel> { fn next(&mut self) -> Option<AccessLevel> {
let ret = self.value.parse(); let ret = self.value.parse();
if self.value.len() > 0 { if self.value.len() > 0 {
self.value = self.value[1..]; self.value = &self.value[1..];
} }
ret ret
} }

1
src/lib.rs
View file

@ -2,6 +2,7 @@
#![crate_name = "irc"] #![crate_name = "irc"]
#![crate_type = "lib"] #![crate_type = "lib"]
#![unstable] #![unstable]
#![allow(unstable)]
#![warn(missing_docs)] #![warn(missing_docs)]
#![feature(slicing_syntax)] #![feature(slicing_syntax)]

106
src/server/mod.rs
View file

@ -35,7 +35,7 @@ pub struct IrcServer<T: IrcReader, U: IrcWriter> {
/// A thread-safe map of channels to the list of users in them. /// A thread-safe map of channels to the list of users in them.
chanlists: Mutex<HashMap<String, Vec<User>>>, chanlists: Mutex<HashMap<String, Vec<User>>>,
/// A thread-safe index to track the current alternative nickname being used. /// A thread-safe index to track the current alternative nickname being used.
alt_nick_index: RwLock<uint>, alt_nick_index: RwLock<usize>,
} }
/// An IrcServer over a buffered NetStream. /// An IrcServer over a buffered NetStream.
@ -59,7 +59,7 @@ impl IrcServer<BufferedReader<NetStream>, BufferedWriter<NetStream>> {
Connection::connect(config.server(), config.port()) Connection::connect(config.server(), config.port())
}); });
Ok(IrcServer { config: config, conn: conn, chanlists: Mutex::new(HashMap::new()), Ok(IrcServer { config: config, conn: conn, chanlists: Mutex::new(HashMap::new()),
alt_nick_index: RwLock::new(0u) }) alt_nick_index: RwLock::new(0) })
} }
/// Reconnects to the IRC server. /// Reconnects to the IRC server.
@ -98,7 +98,7 @@ impl<T: IrcReader, U: IrcWriter> IrcServer<T, U> {
#[experimental] #[experimental]
pub fn from_connection(config: Config, conn: Connection<T, U>) -> IrcServer<T, U> { pub fn from_connection(config: Config, conn: Connection<T, U>) -> IrcServer<T, U> {
IrcServer { conn: conn, config: config, chanlists: Mutex::new(HashMap::new()), IrcServer { conn: conn, config: config, chanlists: Mutex::new(HashMap::new()),
alt_nick_index: RwLock::new(0u) } alt_nick_index: RwLock::new(0) }
} }
/// Gets a reference to the IRC server's connection. /// Gets a reference to the IRC server's connection.
@ -113,7 +113,7 @@ impl<T: IrcReader, U: IrcWriter> IrcServer<T, U> {
if let Some(resp) = Response::from_message(msg) { if let Some(resp) = Response::from_message(msg) {
if resp == Response::RPL_NAMREPLY { if resp == Response::RPL_NAMREPLY {
if let Some(users) = msg.suffix.clone() { if let Some(users) = msg.suffix.clone() {
if let [_, _, ref chan] = msg.args[] { if let [_, _, ref chan] = &msg.args[] {
for user in users.split_str(" ") { for user in users.split_str(" ") {
if match self.chanlists.lock().unwrap().get_mut(chan) { if match self.chanlists.lock().unwrap().get_mut(chan) {
Some(vec) => { vec.push(User::new(user)); false }, Some(vec) => { vec.push(User::new(user)); false },
@ -128,11 +128,11 @@ impl<T: IrcReader, U: IrcWriter> IrcServer<T, U> {
} else if resp == Response::RPL_ENDOFMOTD || resp == Response::ERR_NOMOTD { } else if resp == Response::RPL_ENDOFMOTD || resp == Response::ERR_NOMOTD {
if self.config.nick_password() != "" { if self.config.nick_password() != "" {
self.send(NICKSERV( self.send(NICKSERV(
format!("IDENTIFY {}", self.config.nick_password())[] &format!("IDENTIFY {}", self.config.nick_password())[]
)).unwrap(); )).unwrap();
} }
for chan in self.config.channels().into_iter() { for chan in self.config.channels().into_iter() {
self.send(JOIN(chan[], None)).unwrap(); self.send(JOIN(&chan[], None)).unwrap();
} }
} else if resp == Response::ERR_NICKNAMEINUSE || } else if resp == Response::ERR_NICKNAMEINUSE ||
resp == Response::ERR_ERRONEOUSNICKNAME { resp == Response::ERR_ERRONEOUSNICKNAME {
@ -147,30 +147,30 @@ impl<T: IrcReader, U: IrcWriter> IrcServer<T, U> {
} }
return return
} }
if msg.command[] == "PING" { if &msg.command[] == "PING" {
self.send(PONG(msg.suffix.as_ref().unwrap()[], None)).unwrap(); self.send(PONG(&msg.suffix.as_ref().unwrap()[], None)).unwrap();
} else if msg.command[] == "JOIN" || msg.command[] == "PART" { } else if &msg.command[] == "JOIN" || &msg.command[] == "PART" {
let chan = match msg.suffix { let chan = match msg.suffix {
Some(ref suffix) => suffix[], Some(ref suffix) => &suffix[],
None => msg.args[0][], None => &msg.args[0][],
}; };
if let Some(vec) = self.chanlists.lock().unwrap().get_mut(&String::from_str(chan)) { if let Some(vec) = self.chanlists.lock().unwrap().get_mut(&String::from_str(chan)) {
if let Some(ref src) = msg.prefix { if let Some(ref src) = msg.prefix {
if let Some(i) = src.find('!') { if let Some(i) = src.find('!') {
if msg.command[] == "JOIN" { if &msg.command[] == "JOIN" {
vec.push(User::new(src[..i])); vec.push(User::new(&src[..i]));
} else { } else {
if let Some(n) = vec.as_slice().position_elem(&User::new(src[..i])) { if let Some(n) = vec.as_slice().position_elem(&User::new(&src[..i])) {
vec.swap_remove(n); vec.swap_remove(n);
} }
} }
} }
} }
} }
} else if let ("MODE", [ref chan, ref mode, ref user]) = (msg.command[], msg.args[]) { } else if let ("MODE", [ref chan, ref mode, ref user]) = (&msg.command[], &msg.args[]) {
if let Some(vec) = self.chanlists.lock().unwrap().get_mut(chan) { if let Some(vec) = self.chanlists.lock().unwrap().get_mut(chan) {
if let Some(n) = vec.as_slice().position_elem(&User::new(user[])) { if let Some(n) = vec.as_slice().position_elem(&User::new(&user[])) {
vec[n].update_access_level(mode[]); vec[n].update_access_level(&mode[]);
} }
} }
} else { } else {
@ -183,11 +183,11 @@ impl<T: IrcReader, U: IrcWriter> IrcServer<T, U> {
#[cfg(feature = "ctcp")] #[cfg(feature = "ctcp")]
fn handle_ctcp(&self, msg: &Message) { fn handle_ctcp(&self, msg: &Message) {
let source = match msg.prefix { let source = match msg.prefix {
Some(ref source) => source.find('!').map_or(source[], |i| source[..i]), Some(ref source) => source.find('!').map_or(&source[], |i| &source[..i]),
None => "", None => "",
}; };
if let ("PRIVMSG", [ref target]) = (msg.command[], msg.args[]) { if let ("PRIVMSG", [ref target]) = (&msg.command[], &msg.args[]) {
let resp = if target.starts_with("#") { target[] } else { source }; let resp = if target.starts_with("#") { &target[] } else { source };
match msg.suffix { match msg.suffix {
Some(ref msg) if msg.starts_with("\u{001}") => { Some(ref msg) if msg.starts_with("\u{001}") => {
let tokens: Vec<_> = { let tokens: Vec<_> = {
@ -199,18 +199,18 @@ impl<T: IrcReader, U: IrcWriter> IrcServer<T, U> {
msg[1..end].split_str(" ").collect() msg[1..end].split_str(" ").collect()
}; };
match tokens[0] { match tokens[0] {
"FINGER" => self.send_ctcp(resp, format!("FINGER :{} ({})", "FINGER" => self.send_ctcp(resp, &format!("FINGER :{} ({})",
self.config.real_name(), self.config.real_name(),
self.config.username())[]), self.config.username())[]),
"VERSION" => self.send_ctcp(resp, "VERSION irc:git:Rust"), "VERSION" => self.send_ctcp(resp, "VERSION irc:git:Rust"),
"SOURCE" => { "SOURCE" => {
self.send_ctcp(resp, "SOURCE https://github.com/aatxe/irc"); self.send_ctcp(resp, "SOURCE https://github.com/aatxe/irc");
self.send_ctcp(resp, "SOURCE"); self.send_ctcp(resp, "SOURCE");
}, },
"PING" => self.send_ctcp(resp, format!("PING {}", tokens[1])[]), "PING" => self.send_ctcp(resp, &format!("PING {}", tokens[1])[]),
"TIME" => self.send_ctcp(resp, format!("TIME :{}", now().rfc822z())[]), "TIME" => self.send_ctcp(resp, &format!("TIME :{}", now().rfc822z())[]),
"USERINFO" => self.send_ctcp(resp, format!("USERINFO :{}", "USERINFO" => self.send_ctcp(resp, &format!("USERINFO :{}",
self.config.user_info())[]), self.config.user_info())[]),
_ => {} _ => {}
} }
}, },
@ -223,7 +223,7 @@ impl<T: IrcReader, U: IrcWriter> IrcServer<T, U> {
#[experimental] #[experimental]
#[cfg(feature = "ctcp")] #[cfg(feature = "ctcp")]
fn send_ctcp(&self, target: &str, msg: &str) { fn send_ctcp(&self, target: &str, msg: &str) {
self.send(Command::NOTICE(target, format!("\u{001}{}\u{001}", msg)[])).unwrap(); self.send(Command::NOTICE(target, &format!("\u{001}{}\u{001}", msg)[])).unwrap();
} }
/// Handles CTCP requests if the CTCP feature is enabled. /// Handles CTCP requests if the CTCP feature is enabled.
@ -319,9 +319,9 @@ mod test {
)); ));
let mut messages = String::new(); let mut messages = String::new();
for message in server.iter() { for message in server.iter() {
messages.push_str(message.unwrap().into_string()[]); messages.push_str(&message.unwrap().into_string()[]);
} }
assert_eq!(messages[], exp); assert_eq!(&messages[], exp);
} }
#[test] #[test]
@ -331,9 +331,9 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), MemWriter::new() MemReader::new(value.as_bytes().to_vec()), MemWriter::new()
)); ));
for message in server.iter() { for message in server.iter() {
println!("{}", message); println!("{:?}", message);
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"PONG :irc.test.net\r\nJOIN #test\r\nJOIN #test2\r\n"); "PONG :irc.test.net\r\nJOIN #test\r\nJOIN #test2\r\n");
} }
@ -348,9 +348,9 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), MemWriter::new() MemReader::new(value.as_bytes().to_vec()), MemWriter::new()
)); ));
for message in server.iter() { for message in server.iter() {
println!("{}", message); println!("{:?}", message);
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"NICKSERV IDENTIFY password\r\nJOIN #test\r\nJOIN #test2\r\n"); "NICKSERV IDENTIFY password\r\nJOIN #test\r\nJOIN #test2\r\n");
} }
@ -361,9 +361,9 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), MemWriter::new() MemReader::new(value.as_bytes().to_vec()), MemWriter::new()
)); ));
for message in server.iter() { for message in server.iter() {
println!("{}", message); println!("{:?}", message);
} }
assert_eq!(get_server_value(server)[], "NICK :test2\r\n"); assert_eq!(&get_server_value(server)[], "NICK :test2\r\n");
} }
#[test] #[test]
@ -375,7 +375,7 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), MemWriter::new() MemReader::new(value.as_bytes().to_vec()), MemWriter::new()
)); ));
for message in server.iter() { for message in server.iter() {
println!("{}", message); println!("{:?}", message);
} }
} }
@ -385,7 +385,7 @@ mod test {
NullReader, MemWriter::new() NullReader, MemWriter::new()
)); ));
assert!(server.send(PRIVMSG("#test", "Hi there!")).is_ok()); assert!(server.send(PRIVMSG("#test", "Hi there!")).is_ok());
assert_eq!(get_server_value(server)[], "PRIVMSG #test :Hi there!\r\n"); assert_eq!(&get_server_value(server)[], "PRIVMSG #test :Hi there!\r\n");
} }
#[test] #[test]
@ -395,7 +395,7 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), NullWriter MemReader::new(value.as_bytes().to_vec()), NullWriter
)); ));
for message in server.iter() { for message in server.iter() {
println!("{}", message); println!("{:?}", message);
} }
assert_eq!(server.list_users("#test").unwrap(), assert_eq!(server.list_users("#test").unwrap(),
vec![User::new("test"), User::new("~owner"), User::new("&admin")]) vec![User::new("test"), User::new("~owner"), User::new("&admin")])
@ -409,7 +409,7 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), NullWriter MemReader::new(value.as_bytes().to_vec()), NullWriter
)); ));
for message in server.iter() { for message in server.iter() {
println!("{}", message); println!("{:?}", message);
} }
assert_eq!(server.list_users("#test").unwrap(), assert_eq!(server.list_users("#test").unwrap(),
vec![User::new("test"), User::new("~owner"), User::new("&admin"), User::new("test2")]) vec![User::new("test"), User::new("~owner"), User::new("&admin"), User::new("test2")])
@ -423,7 +423,7 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), NullWriter MemReader::new(value.as_bytes().to_vec()), NullWriter
)); ));
for message in server.iter() { for message in server.iter() {
println!("{}", message); println!("{:?}", message);
} }
assert_eq!(server.list_users("#test").unwrap(), assert_eq!(server.list_users("#test").unwrap(),
vec![User::new("test"), User::new("&admin")]) vec![User::new("test"), User::new("&admin")])
@ -437,7 +437,7 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), NullWriter MemReader::new(value.as_bytes().to_vec()), NullWriter
)); ));
for message in server.iter() { for message in server.iter() {
println!("{}", message); println!("{:?}", message);
} }
assert_eq!(server.list_users("#test").unwrap(), assert_eq!(server.list_users("#test").unwrap(),
vec![User::new("@test"), User::new("~owner"), User::new("&admin")]); vec![User::new("@test"), User::new("~owner"), User::new("&admin")]);
@ -460,9 +460,9 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), MemWriter::new() MemReader::new(value.as_bytes().to_vec()), MemWriter::new()
)); ));
for message in server.iter() { for message in server.iter() {
println!("{}", message); println!("{:?}", message);
} }
assert_eq!(get_server_value(server)[], "NOTICE test :\u{001}FINGER :test (test)\u{001}\ assert_eq!(&get_server_value(server)[], "NOTICE test :\u{001}FINGER :test (test)\u{001}\
\r\n"); \r\n");
} }
@ -474,9 +474,9 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), MemWriter::new() MemReader::new(value.as_bytes().to_vec()), MemWriter::new()
)); ));
for message in server.iter() { for message in server.iter() {
println!("{}", message); println!("{:?}", message);
} }
assert_eq!(get_server_value(server)[], "NOTICE test :\u{001}VERSION irc:git:Rust\u{001}\ assert_eq!(&get_server_value(server)[], "NOTICE test :\u{001}VERSION irc:git:Rust\u{001}\
\r\n"); \r\n");
} }
@ -488,9 +488,9 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), MemWriter::new() MemReader::new(value.as_bytes().to_vec()), MemWriter::new()
)); ));
for message in server.iter() { for message in server.iter() {
println!("{}", message); println!("{:?}", message);
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"NOTICE test :\u{001}SOURCE https://github.com/aatxe/irc\u{001}\r\n\ "NOTICE test :\u{001}SOURCE https://github.com/aatxe/irc\u{001}\r\n\
NOTICE test :\u{001}SOURCE\u{001}\r\n"); NOTICE test :\u{001}SOURCE\u{001}\r\n");
} }
@ -503,9 +503,9 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), MemWriter::new() MemReader::new(value.as_bytes().to_vec()), MemWriter::new()
)); ));
for message in server.iter() { for message in server.iter() {
println!("{}", message); println!("{:?}", message);
} }
assert_eq!(get_server_value(server)[], "NOTICE test :\u{001}PING test\u{001}\r\n"); assert_eq!(&get_server_value(server)[], "NOTICE test :\u{001}PING test\u{001}\r\n");
} }
#[test] #[test]
@ -516,7 +516,7 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), MemWriter::new() MemReader::new(value.as_bytes().to_vec()), MemWriter::new()
)); ));
for message in server.iter() { for message in server.iter() {
println!("{}", message); println!("{:?}", message);
} }
let val = get_server_value(server); let val = get_server_value(server);
assert!(val.starts_with("NOTICE test :\u{001}TIME :")); assert!(val.starts_with("NOTICE test :\u{001}TIME :"));
@ -531,9 +531,9 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), MemWriter::new() MemReader::new(value.as_bytes().to_vec()), MemWriter::new()
)); ));
for message in server.iter() { for message in server.iter() {
println!("{}", message); println!("{:?}", message);
} }
assert_eq!(get_server_value(server)[], "NOTICE test :\u{001}USERINFO :Testing.\u{001}\ assert_eq!(&get_server_value(server)[], "NOTICE test :\u{001}USERINFO :Testing.\u{001}\
\r\n"); \r\n");
} }
} }

56
src/server/utils.rs
View file

@ -171,7 +171,7 @@ impl<'a, T: IrcReader, U: IrcWriter> Wrapper<'a, T, U> {
#[experimental] #[experimental]
#[cfg(feature = "ctcp")] #[cfg(feature = "ctcp")]
pub fn send_ctcp(&self, target: &str, msg: &str) -> IoResult<()> { pub fn send_ctcp(&self, target: &str, msg: &str) -> IoResult<()> {
self.send_privmsg(target, format!("\u{001}{}\u{001}", msg)[]) self.send_privmsg(target, &format!("\u{001}{}\u{001}", msg)[])
} }
/// Sends an action command to the specified target. /// Sends an action command to the specified target.
@ -179,7 +179,7 @@ impl<'a, T: IrcReader, U: IrcWriter> Wrapper<'a, T, U> {
#[experimental] #[experimental]
#[cfg(feature = "ctcp")] #[cfg(feature = "ctcp")]
pub fn send_action(&self, target: &str, msg: &str) -> IoResult<()> { pub fn send_action(&self, target: &str, msg: &str) -> IoResult<()> {
self.send_ctcp(target, format!("ACTION {}", msg)[]) self.send_ctcp(target, &format!("ACTION {}", msg)[])
} }
/// Sends a finger request to the specified target. /// Sends a finger request to the specified target.
@ -220,7 +220,7 @@ impl<'a, T: IrcReader, U: IrcWriter> Wrapper<'a, T, U> {
#[cfg(feature = "ctcp")] #[cfg(feature = "ctcp")]
pub fn send_ctcp_ping(&self, target: &str) -> IoResult<()> { pub fn send_ctcp_ping(&self, target: &str) -> IoResult<()> {
let time = get_time(); let time = get_time();
self.send_ctcp(target, format!("PING {}.{}", time.sec, time.nsec)[]) self.send_ctcp(target, &format!("PING {}.{}", time.sec, time.nsec)[])
} }
/// Sends a time request to the specified target. /// Sends a time request to the specified target.
@ -251,7 +251,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.identify().unwrap(); wrapper.identify().unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"CAP REQ :multi-prefix\r\nCAP END\r\nNICK :test\r\nUSER test 0 * :test\r\n"); "CAP REQ :multi-prefix\r\nCAP END\r\nNICK :test\r\nUSER test 0 * :test\r\n");
} }
@ -270,7 +270,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.identify().unwrap(); wrapper.identify().unwrap();
} }
assert_eq!(get_server_value(server)[], "CAP REQ :multi-prefix\r\nCAP END\r\n\ assert_eq!(&get_server_value(server)[], "CAP REQ :multi-prefix\r\nCAP END\r\n\
PASS :password\r\nNICK :test\r\nUSER test 0 * :test\r\n"); PASS :password\r\nNICK :test\r\nUSER test 0 * :test\r\n");
} }
@ -282,7 +282,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_pong("irc.test.net").unwrap(); wrapper.send_pong("irc.test.net").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"PONG :irc.test.net\r\n"); "PONG :irc.test.net\r\n");
} }
@ -294,7 +294,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_join("#test,#test2,#test3").unwrap(); wrapper.send_join("#test,#test2,#test3").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"JOIN #test,#test2,#test3\r\n"); "JOIN #test,#test2,#test3\r\n");
} }
@ -306,7 +306,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_oper("test", "test").unwrap(); wrapper.send_oper("test", "test").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"OPER test :test\r\n"); "OPER test :test\r\n");
} }
@ -318,7 +318,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_privmsg("#test", "Hi, everybody!").unwrap(); wrapper.send_privmsg("#test", "Hi, everybody!").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"PRIVMSG #test :Hi, everybody!\r\n"); "PRIVMSG #test :Hi, everybody!\r\n");
} }
@ -330,7 +330,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_notice("#test", "Hi, everybody!").unwrap(); wrapper.send_notice("#test", "Hi, everybody!").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"NOTICE #test :Hi, everybody!\r\n"); "NOTICE #test :Hi, everybody!\r\n");
} }
@ -342,7 +342,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_topic("#test", "").unwrap(); wrapper.send_topic("#test", "").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"TOPIC #test\r\n"); "TOPIC #test\r\n");
} }
@ -354,7 +354,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_topic("#test", "Testing stuff.").unwrap(); wrapper.send_topic("#test", "Testing stuff.").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"TOPIC #test :Testing stuff.\r\n"); "TOPIC #test :Testing stuff.\r\n");
} }
@ -366,7 +366,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_kill("test", "Testing kills.").unwrap(); wrapper.send_kill("test", "Testing kills.").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"KILL test :Testing kills.\r\n"); "KILL test :Testing kills.\r\n");
} }
@ -378,7 +378,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_kick("#test", "test", "").unwrap(); wrapper.send_kick("#test", "test", "").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"KICK #test test\r\n"); "KICK #test test\r\n");
} }
@ -390,7 +390,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_kick("#test", "test", "Testing kicks.").unwrap(); wrapper.send_kick("#test", "test", "Testing kicks.").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"KICK #test test :Testing kicks.\r\n"); "KICK #test test :Testing kicks.\r\n");
} }
@ -402,7 +402,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_mode("#test", "+i", "").unwrap(); wrapper.send_mode("#test", "+i", "").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"MODE #test +i\r\n"); "MODE #test +i\r\n");
} }
@ -414,7 +414,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_mode("#test", "+o", "test").unwrap(); wrapper.send_mode("#test", "+o", "test").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"MODE #test +o test\r\n"); "MODE #test +o test\r\n");
} }
@ -426,7 +426,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_samode("#test", "+i", "").unwrap(); wrapper.send_samode("#test", "+i", "").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"SAMODE #test +i\r\n"); "SAMODE #test +i\r\n");
} }
@ -438,7 +438,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_samode("#test", "+o", "test").unwrap(); wrapper.send_samode("#test", "+o", "test").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"SAMODE #test +o test\r\n"); "SAMODE #test +o test\r\n");
} }
@ -450,7 +450,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_sanick("test", "test2").unwrap(); wrapper.send_sanick("test", "test2").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"SANICK test test2\r\n"); "SANICK test test2\r\n");
} }
@ -462,7 +462,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_invite("test", "#test").unwrap(); wrapper.send_invite("test", "#test").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"INVITE test #test\r\n"); "INVITE test #test\r\n");
} }
@ -475,7 +475,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_ctcp("test", "MESSAGE").unwrap(); wrapper.send_ctcp("test", "MESSAGE").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"PRIVMSG test :\u{001}MESSAGE\u{001}\r\n"); "PRIVMSG test :\u{001}MESSAGE\u{001}\r\n");
} }
@ -488,7 +488,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_action("test", "tests.").unwrap(); wrapper.send_action("test", "tests.").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"PRIVMSG test :\u{001}ACTION tests.\u{001}\r\n"); "PRIVMSG test :\u{001}ACTION tests.\u{001}\r\n");
} }
@ -501,7 +501,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_finger("test").unwrap(); wrapper.send_finger("test").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"PRIVMSG test :\u{001}FINGER\u{001}\r\n"); "PRIVMSG test :\u{001}FINGER\u{001}\r\n");
} }
@ -514,7 +514,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_version("test").unwrap(); wrapper.send_version("test").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"PRIVMSG test :\u{001}VERSION\u{001}\r\n"); "PRIVMSG test :\u{001}VERSION\u{001}\r\n");
} }
@ -527,7 +527,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_source("test").unwrap(); wrapper.send_source("test").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"PRIVMSG test :\u{001}SOURCE\u{001}\r\n"); "PRIVMSG test :\u{001}SOURCE\u{001}\r\n");
} }
@ -540,7 +540,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_user_info("test").unwrap(); wrapper.send_user_info("test").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"PRIVMSG test :\u{001}USERINFO\u{001}\r\n"); "PRIVMSG test :\u{001}USERINFO\u{001}\r\n");
} }
@ -568,7 +568,7 @@ mod test {
let wrapper = Wrapper::new(&server); let wrapper = Wrapper::new(&server);
wrapper.send_time("test").unwrap(); wrapper.send_time("test").unwrap();
} }
assert_eq!(get_server_value(server)[], assert_eq!(&get_server_value(server)[],
"PRIVMSG test :\u{001}TIME\u{001}\r\n"); "PRIVMSG test :\u{001}TIME\u{001}\r\n");
} }
} }