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)]
extern crate irc;
@ -18,7 +19,7 @@ fn main() {
let irc_server = Arc::new(IrcServer::from_config(config).unwrap());
irc_server.conn().set_keepalive(Some(5)).unwrap();
// 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);
server.identify().unwrap();
loop {

3
examples/multithreaded.rs
View file

@ -1,3 +1,4 @@
#![allow(unstable)]
#![feature(slicing_syntax)]
extern crate irc;
@ -21,7 +22,7 @@ fn main() {
server.identify().unwrap();
let server = irc_server.clone();
// 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() {
print!("{}", msg.unwrap().into_string());
}

5
examples/simple.rs
View file

@ -1,3 +1,4 @@
#![allow(unstable)]
#![feature(slicing_syntax)]
extern crate irc;
@ -21,10 +22,10 @@ fn main() {
for message in server.iter() {
let message = message.unwrap(); // We'll just panic if there's an error.
print!("{}", message.into_string());
if message.command[] == "PRIVMSG" {
if &message.command[] == "PRIVMSG" {
if let Some(msg) = message.suffix {
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)]
extern crate irc;
@ -22,10 +23,10 @@ fn main() {
for message in server.iter() {
let message = message.unwrap(); // We'll just panic if there's an error.
print!("{}", message.into_string());
if message.command[] == "PRIVMSG" {
if &message.command[] == "PRIVMSG" {
if let Some(msg) = message.suffix {
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)]
#![allow(unstable)]
extern crate irc;
use std::default::Default;
@ -25,7 +26,7 @@ fn main() {
// Let's set up a loop that just prints the messages.
Thread::spawn(move || {
irc_server.iter().map(|m| print!("{}", m.unwrap().into_string())).count();
}).detach();
});
loop {
server.send_privmsg("#vana", "TWEET TWEET").unwrap();
sleep(Duration::seconds(10))

51
src/conn.rs
View file

@ -1,8 +1,9 @@
//! Thread-safe connections on IrcStreams.
#![experimental]
use std::sync::{Mutex, MutexGuard};
use std::error::Error;
use std::io::{BufferedReader, BufferedWriter, IoResult, TcpStream};
#[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::label::encoding_from_whatwg_label;
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.
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())),
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.
#[cfg(feature = "ssl")]
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_socket = try!(ssl_to_io(SslStream::new(&ssl, socket)));
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.
#[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))
}
@ -94,9 +95,9 @@ impl Connection<BufferedReader<NetStream>, BufferedWriter<NetStream>> {
/// Modifies the internal TcpStream using a function.
fn mod_stream<F>(&self, f: F) -> IoResult<()> where F: FnOnce(&mut TcpStream) -> IoResult<()> {
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")]
&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.
#[experimental]
#[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) {
Some(enc) => enc,
None => return Err(IoError {
@ -124,7 +125,7 @@ impl<T: IrcReader, U: IrcWriter> Connection<T, U> {
})
};
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,
Err(data) => return Err(IoError {
kind: IoErrorKind::InvalidInput,
@ -133,7 +134,7 @@ impl<T: IrcReader, U: IrcWriter> Connection<T, U> {
})
};
let mut writer = self.writer.lock().unwrap();
try!(writer.write(data[]));
try!(writer.write(&data[]));
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|
match encoding.decode(line[], DecoderTrap::Replace) {
match encoding.decode(&line[], DecoderTrap::Replace) {
Ok(data) => Ok(data),
Err(data) => Err(IoError {
kind: IoErrorKind::InvalidInput,
@ -198,7 +199,7 @@ fn ssl_to_io<T>(res: Result<T, SslError>) -> IoResult<T> {
Err(e) => Err(IoError {
kind: IoErrorKind::OtherIoError,
desc: "An SSL error occurred.",
detail: Some(format!("{}", e)),
detail: e.detail(),
}),
}
}
@ -215,11 +216,11 @@ pub enum 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 {
&NetStream::UnsecuredTcpStream(ref mut stream) => stream.read(buf),
&mut NetStream::UnsecuredTcpStream(ref mut stream) => stream.read(buf),
#[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 {
fn write(&mut self, buf: &[u8]) -> IoResult<()> {
match self {
&NetStream::UnsecuredTcpStream(ref mut stream) => stream.write(buf),
&mut NetStream::UnsecuredTcpStream(ref mut stream) => stream.write(buf),
#[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!"))
).is_ok());
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]
@ -261,7 +262,7 @@ mod test {
let conn = Connection::new(NullReader, MemWriter::new());
assert!(conn.send(exp).is_ok());
let data = String::from_utf8(conn.writer().get_ref().to_vec()).unwrap();
assert_eq!(data[], exp);
assert_eq!(&data[], exp);
}
#[test]
@ -272,7 +273,7 @@ mod test {
Message::new(None, "PRIVMSG", Some(vec!["test"]), Some("€ŠšŽžŒœŸ")), "UTF-8"
).is_ok());
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]
@ -282,7 +283,7 @@ mod test {
let conn = Connection::new(NullReader, MemWriter::new());
assert!(conn.send(exp, "UTF-8").is_ok());
let data = UTF_8.decode(conn.writer().get_ref(), DecoderTrap::Strict).unwrap();
assert_eq!(data[], exp);
assert_eq!(&data[], exp);
}
#[test]
@ -293,7 +294,7 @@ mod test {
Message::new(None, "PRIVMSG", Some(vec!["test"]), Some("€ŠšŽžŒœŸ")), "l9"
).is_ok());
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]
@ -303,7 +304,7 @@ mod test {
let conn = Connection::new(NullReader, MemWriter::new());
assert!(conn.send(exp, "l9").is_ok());
let data = ISO_8859_15.decode(conn.writer().get_ref(), DecoderTrap::Strict).unwrap();
assert_eq!(data[], exp);
assert_eq!(&data[], exp);
}
#[test]
@ -312,7 +313,7 @@ mod test {
let conn = Connection::new(
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]
@ -321,7 +322,7 @@ mod test {
let conn = Connection::new(
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]
@ -336,6 +337,6 @@ mod test {
vec
}), NullWriter
);
assert_eq!(conn.recv("l9").unwrap()[], "PRIVMSG test :€ŠšŽžŒœŸ\r\n");
assert_eq!(&conn.recv("l9").unwrap()[], "PRIVMSG test :€ŠšŽžŒœŸ\r\n");
}
}

376
src/data/command.rs
View file

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

27
src/data/config.rs
View file

@ -2,6 +2,7 @@
#![stable]
use std::borrow::ToOwned;
use std::collections::HashMap;
use std::error::Error;
use std::io::fs::File;
use std::io::{InvalidInput, IoError, IoResult};
use rustc_serialize::json::decode;
@ -48,10 +49,10 @@ impl Config {
pub fn load(path: Path) -> IoResult<Config> {
let mut file = try!(File::open(&path));
let data = try!(file.read_to_string());
decode(data[]).map_err(|e| IoError {
decode(&data[]).map_err(|e| IoError {
kind: InvalidInput,
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.
#[experimental]
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.
/// This defaults to an empty string when not specified.
#[experimental]
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.
/// This defaults to an empty vector when not specified.
#[experimental]
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.
#[experimental]
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.
/// This defaults to the user's nickname when not specified.
#[experimental]
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.
/// This panics when not specified.
#[experimental]
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.
@ -125,7 +126,7 @@ impl Config {
/// This defaults to a blank string when not specified.
#[experimental]
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.
@ -139,21 +140,21 @@ impl Config {
/// This defaults to UTF-8 when not specified.
#[experimental]
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.
/// This defaults to an empty vector if it's not specified.
#[experimental]
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.
/// This defaults to an empty string when not specified.
#[experimental]
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.
@ -161,7 +162,7 @@ impl Config {
/// This will also panic if used and there are no options.
#[experimental]
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.
#[experimental]
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.
@ -43,17 +43,17 @@ impl Message {
let mut ret = String::new();
if let Some(ref prefix) = self.prefix {
ret.push(':');
ret.push_str(prefix[]);
ret.push_str(&prefix[]);
ret.push(' ');
}
ret.push_str(self.command[]);
ret.push_str(&self.command[]);
for arg in self.args.iter() {
ret.push(' ');
ret.push_str(arg[]);
ret.push_str(&arg[]);
}
if let Some(ref suffix) = self.suffix {
ret.push_str(" :");
ret.push_str(suffix[]);
ret.push_str(&suffix[]);
}
ret.push_str("\r\n");
ret
@ -71,27 +71,27 @@ impl FromStr for Message {
let mut state = s.clone();
if s.len() == 0 { return None }
let prefix = if state.starts_with(":") {
let prefix = state.find(' ').map(|i| state[1..i]);
state = state.find(' ').map_or("", |i| state[i+1..]);
let prefix = state.find(' ').map(|i| &state[1..i]);
state = state.find(' ').map_or("", |i| &state[i+1..]);
prefix
} else {
None
};
let suffix = if state.contains(":") {
let suffix = state.find(':').map(|i| state[i+1..state.len()-2]);
state = state.find(':').map_or("", |i| state[..i]);
let suffix = state.find(':').map(|i| &state[i+1..state.len()-2]);
state = state.find(':').map_or("", |i| &state[..i]);
suffix
} else {
None
};
let command = match state.find(' ').map(|i| state[..i]) {
let command = match state.find(' ').map(|i| &state[..i]) {
Some(cmd) => {
state = state.find(' ').map_or("", |i| state[i+1..]);
state = state.find(' ').map_or("", |i| &state[i+1..]);
cmd
}
_ => 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();
Some(Message::new(prefix, command, if args.len() > 0 { Some(args) } else { None }, suffix))
}
@ -143,14 +143,14 @@ mod test {
args: vec![format!("test")],
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 {
prefix: Some(format!("test!test@test")),
command: format!("PRIVMSG"),
args: vec![format!("test")],
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]

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).
/// All commands are documented with their expected form from the RFC.
#[derive(Copy, Show, PartialEq, FromPrimitive)]
#[repr(uint)]
#[repr(u16)]
#[unstable]
pub enum Response {
// Expected replies
@ -303,14 +303,14 @@ impl Response {
/// Determines whether or not this response is an error response.
#[stable]
pub fn is_error(&self) -> bool {
*self as uint >= 400
*self as u16 >= 400
}
}
impl FromStr for Response {
fn from_str(s: &str) -> Option<Response> {
if let Some(respcode) = s.parse() {
FromPrimitive::from_uint(respcode)
FromPrimitive::from_u16(respcode)
} else {
None
}

4
src/data/user.rs
View file

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

1
src/lib.rs
View file

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

100
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.
chanlists: Mutex<HashMap<String, Vec<User>>>,
/// 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.
@ -59,7 +59,7 @@ impl IrcServer<BufferedReader<NetStream>, BufferedWriter<NetStream>> {
Connection::connect(config.server(), config.port())
});
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.
@ -98,7 +98,7 @@ impl<T: IrcReader, U: IrcWriter> IrcServer<T, U> {
#[experimental]
pub fn from_connection(config: Config, conn: Connection<T, U>) -> IrcServer<T, U> {
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.
@ -113,7 +113,7 @@ impl<T: IrcReader, U: IrcWriter> IrcServer<T, U> {
if let Some(resp) = Response::from_message(msg) {
if resp == Response::RPL_NAMREPLY {
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(" ") {
if match self.chanlists.lock().unwrap().get_mut(chan) {
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 {
if self.config.nick_password() != "" {
self.send(NICKSERV(
format!("IDENTIFY {}", self.config.nick_password())[]
&format!("IDENTIFY {}", self.config.nick_password())[]
)).unwrap();
}
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 ||
resp == Response::ERR_ERRONEOUSNICKNAME {
@ -147,30 +147,30 @@ impl<T: IrcReader, U: IrcWriter> IrcServer<T, U> {
}
return
}
if msg.command[] == "PING" {
self.send(PONG(msg.suffix.as_ref().unwrap()[], None)).unwrap();
} else if msg.command[] == "JOIN" || msg.command[] == "PART" {
if &msg.command[] == "PING" {
self.send(PONG(&msg.suffix.as_ref().unwrap()[], None)).unwrap();
} else if &msg.command[] == "JOIN" || &msg.command[] == "PART" {
let chan = match msg.suffix {
Some(ref suffix) => suffix[],
None => msg.args[0][],
Some(ref suffix) => &suffix[],
None => &msg.args[0][],
};
if let Some(vec) = self.chanlists.lock().unwrap().get_mut(&String::from_str(chan)) {
if let Some(ref src) = msg.prefix {
if let Some(i) = src.find('!') {
if msg.command[] == "JOIN" {
vec.push(User::new(src[..i]));
if &msg.command[] == "JOIN" {
vec.push(User::new(&src[..i]));
} 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);
}
}
}
}
}
} 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(n) = vec.as_slice().position_elem(&User::new(user[])) {
vec[n].update_access_level(mode[]);
if let Some(n) = vec.as_slice().position_elem(&User::new(&user[])) {
vec[n].update_access_level(&mode[]);
}
}
} else {
@ -183,11 +183,11 @@ impl<T: IrcReader, U: IrcWriter> IrcServer<T, U> {
#[cfg(feature = "ctcp")]
fn handle_ctcp(&self, msg: &Message) {
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 => "",
};
if let ("PRIVMSG", [ref target]) = (msg.command[], msg.args[]) {
let resp = if target.starts_with("#") { target[] } else { source };
if let ("PRIVMSG", [ref target]) = (&msg.command[], &msg.args[]) {
let resp = if target.starts_with("#") { &target[] } else { source };
match msg.suffix {
Some(ref msg) if msg.starts_with("\u{001}") => {
let tokens: Vec<_> = {
@ -199,7 +199,7 @@ impl<T: IrcReader, U: IrcWriter> IrcServer<T, U> {
msg[1..end].split_str(" ").collect()
};
match tokens[0] {
"FINGER" => self.send_ctcp(resp, format!("FINGER :{} ({})",
"FINGER" => self.send_ctcp(resp, &format!("FINGER :{} ({})",
self.config.real_name(),
self.config.username())[]),
"VERSION" => self.send_ctcp(resp, "VERSION irc:git:Rust"),
@ -207,9 +207,9 @@ impl<T: IrcReader, U: IrcWriter> IrcServer<T, U> {
self.send_ctcp(resp, "SOURCE https://github.com/aatxe/irc");
self.send_ctcp(resp, "SOURCE");
},
"PING" => self.send_ctcp(resp, format!("PING {}", tokens[1])[]),
"TIME" => self.send_ctcp(resp, format!("TIME :{}", now().rfc822z())[]),
"USERINFO" => self.send_ctcp(resp, format!("USERINFO :{}",
"PING" => self.send_ctcp(resp, &format!("PING {}", tokens[1])[]),
"TIME" => self.send_ctcp(resp, &format!("TIME :{}", now().rfc822z())[]),
"USERINFO" => self.send_ctcp(resp, &format!("USERINFO :{}",
self.config.user_info())[]),
_ => {}
}
@ -223,7 +223,7 @@ impl<T: IrcReader, U: IrcWriter> IrcServer<T, U> {
#[experimental]
#[cfg(feature = "ctcp")]
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.
@ -319,9 +319,9 @@ mod test {
));
let mut messages = String::new();
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]
@ -331,9 +331,9 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), MemWriter::new()
));
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");
}
@ -348,9 +348,9 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), MemWriter::new()
));
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");
}
@ -361,9 +361,9 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), MemWriter::new()
));
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]
@ -375,7 +375,7 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), MemWriter::new()
));
for message in server.iter() {
println!("{}", message);
println!("{:?}", message);
}
}
@ -385,7 +385,7 @@ mod test {
NullReader, MemWriter::new()
));
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]
@ -395,7 +395,7 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), NullWriter
));
for message in server.iter() {
println!("{}", message);
println!("{:?}", message);
}
assert_eq!(server.list_users("#test").unwrap(),
vec![User::new("test"), User::new("~owner"), User::new("&admin")])
@ -409,7 +409,7 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), NullWriter
));
for message in server.iter() {
println!("{}", message);
println!("{:?}", message);
}
assert_eq!(server.list_users("#test").unwrap(),
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
));
for message in server.iter() {
println!("{}", message);
println!("{:?}", message);
}
assert_eq!(server.list_users("#test").unwrap(),
vec![User::new("test"), User::new("&admin")])
@ -437,7 +437,7 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), NullWriter
));
for message in server.iter() {
println!("{}", message);
println!("{:?}", message);
}
assert_eq!(server.list_users("#test").unwrap(),
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()
));
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");
}
@ -474,9 +474,9 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), MemWriter::new()
));
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");
}
@ -488,9 +488,9 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), MemWriter::new()
));
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\u{001}\r\n");
}
@ -503,9 +503,9 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), MemWriter::new()
));
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]
@ -516,7 +516,7 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), MemWriter::new()
));
for message in server.iter() {
println!("{}", message);
println!("{:?}", message);
}
let val = get_server_value(server);
assert!(val.starts_with("NOTICE test :\u{001}TIME :"));
@ -531,9 +531,9 @@ mod test {
MemReader::new(value.as_bytes().to_vec()), MemWriter::new()
));
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");
}
}

56
src/server/utils.rs
View file

@ -171,7 +171,7 @@ impl<'a, T: IrcReader, U: IrcWriter> Wrapper<'a, T, U> {
#[experimental]
#[cfg(feature = "ctcp")]
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.
@ -179,7 +179,7 @@ impl<'a, T: IrcReader, U: IrcWriter> Wrapper<'a, T, U> {
#[experimental]
#[cfg(feature = "ctcp")]
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.
@ -220,7 +220,7 @@ impl<'a, T: IrcReader, U: IrcWriter> Wrapper<'a, T, U> {
#[cfg(feature = "ctcp")]
pub fn send_ctcp_ping(&self, target: &str) -> IoResult<()> {
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.
@ -251,7 +251,7 @@ mod test {
let wrapper = Wrapper::new(&server);
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");
}
@ -270,7 +270,7 @@ mod test {
let wrapper = Wrapper::new(&server);
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");
}
@ -282,7 +282,7 @@ mod test {
let wrapper = Wrapper::new(&server);
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");
}
@ -294,7 +294,7 @@ mod test {
let wrapper = Wrapper::new(&server);
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");
}
@ -306,7 +306,7 @@ mod test {
let wrapper = Wrapper::new(&server);
wrapper.send_oper("test", "test").unwrap();
}
assert_eq!(get_server_value(server)[],
assert_eq!(&get_server_value(server)[],
"OPER test :test\r\n");
}
@ -318,7 +318,7 @@ mod test {
let wrapper = Wrapper::new(&server);
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");
}
@ -330,7 +330,7 @@ mod test {
let wrapper = Wrapper::new(&server);
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");
}
@ -342,7 +342,7 @@ mod test {
let wrapper = Wrapper::new(&server);
wrapper.send_topic("#test", "").unwrap();
}
assert_eq!(get_server_value(server)[],
assert_eq!(&get_server_value(server)[],
"TOPIC #test\r\n");
}
@ -354,7 +354,7 @@ mod test {
let wrapper = Wrapper::new(&server);
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");
}
@ -366,7 +366,7 @@ mod test {
let wrapper = Wrapper::new(&server);
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");
}
@ -378,7 +378,7 @@ mod test {
let wrapper = Wrapper::new(&server);
wrapper.send_kick("#test", "test", "").unwrap();
}
assert_eq!(get_server_value(server)[],
assert_eq!(&get_server_value(server)[],
"KICK #test test\r\n");
}
@ -390,7 +390,7 @@ mod test {
let wrapper = Wrapper::new(&server);
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");
}
@ -402,7 +402,7 @@ mod test {
let wrapper = Wrapper::new(&server);
wrapper.send_mode("#test", "+i", "").unwrap();
}
assert_eq!(get_server_value(server)[],
assert_eq!(&get_server_value(server)[],
"MODE #test +i\r\n");
}
@ -414,7 +414,7 @@ mod test {
let wrapper = Wrapper::new(&server);
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");
}
@ -426,7 +426,7 @@ mod test {
let wrapper = Wrapper::new(&server);
wrapper.send_samode("#test", "+i", "").unwrap();
}
assert_eq!(get_server_value(server)[],
assert_eq!(&get_server_value(server)[],
"SAMODE #test +i\r\n");
}
@ -438,7 +438,7 @@ mod test {
let wrapper = Wrapper::new(&server);
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");
}
@ -450,7 +450,7 @@ mod test {
let wrapper = Wrapper::new(&server);
wrapper.send_sanick("test", "test2").unwrap();
}
assert_eq!(get_server_value(server)[],
assert_eq!(&get_server_value(server)[],
"SANICK test test2\r\n");
}
@ -462,7 +462,7 @@ mod test {
let wrapper = Wrapper::new(&server);
wrapper.send_invite("test", "#test").unwrap();
}
assert_eq!(get_server_value(server)[],
assert_eq!(&get_server_value(server)[],
"INVITE test #test\r\n");
}
@ -475,7 +475,7 @@ mod test {
let wrapper = Wrapper::new(&server);
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");
}
@ -488,7 +488,7 @@ mod test {
let wrapper = Wrapper::new(&server);
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");
}
@ -501,7 +501,7 @@ mod test {
let wrapper = Wrapper::new(&server);
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");
}
@ -514,7 +514,7 @@ mod test {
let wrapper = Wrapper::new(&server);
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");
}
@ -527,7 +527,7 @@ mod test {
let wrapper = Wrapper::new(&server);
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");
}
@ -540,7 +540,7 @@ mod test {
let wrapper = Wrapper::new(&server);
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");
}
@ -568,7 +568,7 @@ mod test {
let wrapper = Wrapper::new(&server);
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");
}
}