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

Applied a bunch of clippy lints.

Browse source
This commit is contained in:
Aaron Weiss 2017-06-19 13:46:01 -04:00
parent c4888ed76c
commit 388628d62a
No known key found for this signature in database
GPG key ID: 0237035D9BF03AE2
10 changed files with 168 additions and 171 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
examples/multithreaded.rs
View file

@ -6,9 +6,9 @@ use irc::client::prelude::*;
fn main() { fn main() {
let config = Config { let config = Config {
nickname: Some(format!("pickles")), nickname: Some("pickles".to_owned()),
server: Some(format!("irc.fyrechat.net")), server: Some("irc.fyrechat.net".to_owned()),
channels: Some(vec![format!("#vana")]), channels: Some(vec!["#vana".to_owned()]),
.. Default::default() .. Default::default()
}; };
let server = IrcServer::from_config(config).unwrap(); let server = IrcServer::from_config(config).unwrap();

8
examples/simple.rs
View file

@ -5,10 +5,10 @@ use irc::client::prelude::*;
fn main() { fn main() {
let config = Config { let config = Config {
nickname: Some(format!("pickles")), nickname: Some("pickles".to_owned()),
alt_nicks: Some(vec![format!("bananas"), format!("apples")]), alt_nicks: Some(vec!["bananas".to_owned(), "apples".to_owned()]),
server: Some(format!("irc.fyrechat.net")), server: Some("irc.fyrechat.net".to_owned()),
channels: Some(vec![format!("#vana")]), channels: Some(vec!["#vana".to_owned()]),
.. Default::default() .. Default::default()
}; };
let server = IrcServer::from_config(config).unwrap(); let server = IrcServer::from_config(config).unwrap();

6
examples/simple_ssl.rs
View file

@ -5,9 +5,9 @@ use irc::client::prelude::*;
fn main() { fn main() {
let config = Config { let config = Config {
nickname: Some(format!("pickles")), nickname: Some("pickles".to_owned()),
server: Some(format!("irc.fyrechat.net")), server: Some("irc.fyrechat.net".to_owned()),
channels: Some(vec![format!("#vana")]), channels: Some(vec!["#vana".to_owned()]),
port: Some(6697), port: Some(6697),
use_ssl: Some(true), use_ssl: Some(true),
.. Default::default() .. Default::default()

6
examples/tweeter.rs
View file

@ -7,9 +7,9 @@ use irc::client::prelude::*;
fn main() { fn main() {
let config = Config { let config = Config {
nickname: Some(format!("pickles")), nickname: Some("pickles".to_owned()),
server: Some(format!("irc.fyrechat.net")), server: Some("irc.fyrechat.net".to_owned()),
channels: Some(vec![format!("#vana")]), channels: Some(vec!["#vana".to_owned()]),
.. Default::default() .. Default::default()
}; };
let server = IrcServer::from_config(config).unwrap(); let server = IrcServer::from_config(config).unwrap();

6
src/client/conn.rs
View file

@ -1,4 +1,4 @@
//! Thread-safe connections on IrcStreams. //! Thread-safe connections on `IrcStreams`.
#[cfg(feature = "ssl")] use std::error::Error as StdError; #[cfg(feature = "ssl")] use std::error::Error as StdError;
use std::io::prelude::*; use std::io::prelude::*;
use std::io::{BufReader, BufWriter, Cursor, Result}; use std::io::{BufReader, BufWriter, Cursor, Result};
@ -50,7 +50,7 @@ type NetReader = BufReader<NetStream>;
type NetWriter = BufWriter<NetStream>; type NetWriter = BufWriter<NetStream>;
type NetReadWritePair = (NetReader, NetWriter); type NetReadWritePair = (NetReader, NetWriter);
/// A thread-safe connection over a buffered NetStream. /// A thread-safe connection over a buffered `NetStream`.
pub struct NetConnection { pub struct NetConnection {
host: Mutex<String>, host: Mutex<String>,
port: Mutex<u16>, port: Mutex<u16>,
@ -105,7 +105,7 @@ impl NetConnection {
} }
} }
/// Converts a Result<T, SslError> into an Result<T>. /// Converts a `Result<T, SslError>` into an `io::Result<T>`.
#[cfg(feature = "ssl")] #[cfg(feature = "ssl")]
fn ssl_to_io<T>(res: StdResult<T, SslError>) -> Result<T> { fn ssl_to_io<T>(res: StdResult<T, SslError>) -> Result<T> {
match res { match res {

256
src/client/data/command.rs
View file

@ -175,7 +175,7 @@ pub enum Command {
Raw(String, Vec<String>, Option<String>), Raw(String, Vec<String>, Option<String>),
} }
fn stringify(cmd: &str, args: Vec<&str>, suffix: Option<&str>) -> String { fn stringify(cmd: &str, args: &[&str], suffix: Option<&str>) -> String {
let args = args.join(" "); let args = args.join(" ");
let sp = if args.is_empty() { "" } else { " " }; let sp = if args.is_empty() { "" } else { " " };
match suffix { match suffix {
@ -188,236 +188,236 @@ fn stringify(cmd: &str, args: Vec<&str>, suffix: Option<&str>) -> String {
impl<'a> From<&'a Command> for String { impl<'a> From<&'a Command> for String {
fn from(cmd: &'a Command) -> String { fn from(cmd: &'a Command) -> String {
match *cmd { match *cmd {
Command::PASS(ref p) => stringify("PASS", vec![], Some(p)), Command::PASS(ref p) => stringify("PASS", &[], Some(p)),
Command::NICK(ref n) => stringify("NICK", vec![], Some(n)), Command::NICK(ref n) => stringify("NICK", &[], Some(n)),
Command::USER(ref u, ref m, ref r) => Command::USER(ref u, ref m, ref r) =>
stringify("USER", vec![u, m, "*"], Some(r)), stringify("USER", &[u, m, "*"], Some(r)),
Command::OPER(ref u, ref p) => Command::OPER(ref u, ref p) =>
stringify("OPER", vec![u], Some(p)), stringify("OPER", &[u], Some(p)),
Command::MODE(ref t, ref m, Some(ref p)) => Command::MODE(ref t, ref m, Some(ref p)) =>
stringify("MODE", vec![t, m, p], None), stringify("MODE", &[t, m, p], None),
Command::MODE(ref t, ref m, None) => Command::MODE(ref t, ref m, None) =>
stringify("MODE", vec![t, m], None), stringify("MODE", &[t, m], None),
Command::SERVICE(ref n, ref r, ref d, ref t, ref re, ref i) => Command::SERVICE(ref n, ref r, ref d, ref t, ref re, ref i) =>
stringify("SERVICE", vec![n, r, d, t, re], Some(i)), stringify("SERVICE", &[n, r, d, t, re], Some(i)),
Command::QUIT(Some(ref m)) => stringify("QUIT", vec![], Some(m)), Command::QUIT(Some(ref m)) => stringify("QUIT", &[], Some(m)),
Command::QUIT(None) => stringify("QUIT", vec![], None), Command::QUIT(None) => stringify("QUIT", &[], None),
Command::SQUIT(ref s, ref c) => Command::SQUIT(ref s, ref c) =>
stringify("SQUIT", vec![s], Some(c)), stringify("SQUIT", &[s], Some(c)),
Command::JOIN(ref c, Some(ref k), Some(ref n)) => Command::JOIN(ref c, Some(ref k), Some(ref n)) =>
stringify("JOIN", vec![c, k], Some(n)), stringify("JOIN", &[c, k], Some(n)),
Command::JOIN(ref c, Some(ref k), None) => Command::JOIN(ref c, Some(ref k), None) =>
stringify("JOIN", vec![c, k], None), stringify("JOIN", &[c, k], None),
Command::JOIN(ref c, None, Some(ref n)) => Command::JOIN(ref c, None, Some(ref n)) =>
stringify("JOIN", vec![c], Some(n)), stringify("JOIN", &[c], Some(n)),
Command::JOIN(ref c, None, None) => Command::JOIN(ref c, None, None) =>
stringify("JOIN", vec![c], None), stringify("JOIN", &[c], None),
Command::PART(ref c, Some(ref m)) => Command::PART(ref c, Some(ref m)) =>
stringify("PART", vec![c], Some(m)), stringify("PART", &[c], Some(m)),
Command::PART(ref c, None) => Command::PART(ref c, None) =>
stringify("PART", vec![c], None), stringify("PART", &[c], None),
Command::TOPIC(ref c, Some(ref t)) => Command::TOPIC(ref c, Some(ref t)) =>
stringify("TOPIC", vec![c], Some(t)), stringify("TOPIC", &[c], Some(t)),
Command::TOPIC(ref c, None) => Command::TOPIC(ref c, None) =>
stringify("TOPIC", vec![c], None), stringify("TOPIC", &[c], None),
Command::NAMES(Some(ref c), Some(ref t)) => Command::NAMES(Some(ref c), Some(ref t)) =>
stringify("NAMES", vec![c], Some(t)), stringify("NAMES", &[c], Some(t)),
Command::NAMES(Some(ref c), None) => Command::NAMES(Some(ref c), None) =>
stringify("NAMES", vec![c], None), stringify("NAMES", &[c], None),
Command::NAMES(None, _) => stringify("NAMES", vec![], None), Command::NAMES(None, _) => stringify("NAMES", &[], None),
Command::LIST(Some(ref c), Some(ref t)) => Command::LIST(Some(ref c), Some(ref t)) =>
stringify("LIST", vec![c], Some(t)), stringify("LIST", &[c], Some(t)),
Command::LIST(Some(ref c), None) => Command::LIST(Some(ref c), None) =>
stringify("LIST", vec![c], None), stringify("LIST", &[c], None),
Command::LIST(None, _) => stringify("LIST", vec![], None), Command::LIST(None, _) => stringify("LIST", &[], None),
Command::INVITE(ref n, ref c) => Command::INVITE(ref n, ref c) =>
stringify("INVITE", vec![n, c], None), stringify("INVITE", &[n, c], None),
Command::KICK(ref c, ref n, Some(ref r)) => Command::KICK(ref c, ref n, Some(ref r)) =>
stringify("KICK", vec![c, n], Some(r)), stringify("KICK", &[c, n], Some(r)),
Command::KICK(ref c, ref n, None) => Command::KICK(ref c, ref n, None) =>
stringify("KICK", vec![c, n], None), stringify("KICK", &[c, n], None),
Command::PRIVMSG(ref t, ref m) => Command::PRIVMSG(ref t, ref m) =>
stringify("PRIVMSG", vec![t], Some(m)), stringify("PRIVMSG", &[t], Some(m)),
Command::NOTICE(ref t, ref m) => Command::NOTICE(ref t, ref m) =>
stringify("NOTICE", vec![t], Some(m)), stringify("NOTICE", &[t], Some(m)),
Command::MOTD(Some(ref t)) => stringify("MOTD", vec![], Some(t)), Command::MOTD(Some(ref t)) => stringify("MOTD", &[], Some(t)),
Command::MOTD(None) => stringify("MOTD", vec![], None), Command::MOTD(None) => stringify("MOTD", &[], None),
Command::LUSERS(Some(ref m), Some(ref t)) => Command::LUSERS(Some(ref m), Some(ref t)) =>
stringify("LUSERS", vec![m], Some(t)), stringify("LUSERS", &[m], Some(t)),
Command::LUSERS(Some(ref m), None) => Command::LUSERS(Some(ref m), None) =>
stringify("LUSERS", vec![m], None), stringify("LUSERS", &[m], None),
Command::LUSERS(None, _) => stringify("LUSERS", vec![], None), Command::LUSERS(None, _) => stringify("LUSERS", &[], None),
Command::VERSION(Some(ref t)) => Command::VERSION(Some(ref t)) =>
stringify("VERSION", vec![], Some(t)), stringify("VERSION", &[], Some(t)),
Command::VERSION(None) => stringify("VERSION", vec![], None), Command::VERSION(None) => stringify("VERSION", &[], None),
Command::STATS(Some(ref q), Some(ref t)) => Command::STATS(Some(ref q), Some(ref t)) =>
stringify("STATS", vec![q], Some(t)), stringify("STATS", &[q], Some(t)),
Command::STATS(Some(ref q), None) => Command::STATS(Some(ref q), None) =>
stringify("STATS", vec![q], None), stringify("STATS", &[q], None),
Command::STATS(None, _) => stringify("STATS", vec![], None), Command::STATS(None, _) => stringify("STATS", &[], None),
Command::LINKS(Some(ref r), Some(ref s)) => Command::LINKS(Some(ref r), Some(ref s)) =>
stringify("LINKS", vec![r], Some(s)), stringify("LINKS", &[r], Some(s)),
Command::LINKS(None, Some(ref s)) => Command::LINKS(None, Some(ref s)) =>
stringify("LINKS", vec![], Some(s)), stringify("LINKS", &[], Some(s)),
Command::LINKS(_, None) => stringify("LINKS", vec![], None), Command::LINKS(_, None) => stringify("LINKS", &[], None),
Command::TIME(Some(ref t)) => stringify("TIME", vec![], Some(t)), Command::TIME(Some(ref t)) => stringify("TIME", &[], Some(t)),
Command::TIME(None) => stringify("TIME", vec![], None), Command::TIME(None) => stringify("TIME", &[], None),
Command::CONNECT(ref t, ref p, Some(ref r)) => Command::CONNECT(ref t, ref p, Some(ref r)) =>
stringify("CONNECT", vec![t, p], Some(r)), stringify("CONNECT", &[t, p], Some(r)),
Command::CONNECT(ref t, ref p, None) => Command::CONNECT(ref t, ref p, None) =>
stringify("CONNECT", vec![t, p], None), stringify("CONNECT", &[t, p], None),
Command::TRACE(Some(ref t)) => stringify("TRACE", vec![], Some(t)), Command::TRACE(Some(ref t)) => stringify("TRACE", &[], Some(t)),
Command::TRACE(None) => stringify("TRACE", vec![], None), Command::TRACE(None) => stringify("TRACE", &[], None),
Command::ADMIN(Some(ref t)) => stringify("ADMIN", vec![], Some(t)), Command::ADMIN(Some(ref t)) => stringify("ADMIN", &[], Some(t)),
Command::ADMIN(None) => stringify("ADMIN", vec![], None), Command::ADMIN(None) => stringify("ADMIN", &[], None),
Command::INFO(Some(ref t)) => stringify("INFO", vec![], Some(t)), Command::INFO(Some(ref t)) => stringify("INFO", &[], Some(t)),
Command::INFO(None) => stringify("INFO", vec![], None), Command::INFO(None) => stringify("INFO", &[], None),
Command::SERVLIST(Some(ref m), Some(ref t)) => Command::SERVLIST(Some(ref m), Some(ref t)) =>
stringify("SERVLIST", vec![m], Some(t)), stringify("SERVLIST", &[m], Some(t)),
Command::SERVLIST(Some(ref m), None) => Command::SERVLIST(Some(ref m), None) =>
stringify("SERVLIST", vec![m], None), stringify("SERVLIST", &[m], None),
Command::SERVLIST(None, _) => Command::SERVLIST(None, _) =>
stringify("SERVLIST", vec![], None), stringify("SERVLIST", &[], None),
Command::SQUERY(ref s, ref t) => Command::SQUERY(ref s, ref t) =>
stringify("SQUERY", vec![s, t], None), stringify("SQUERY", &[s, t], None),
Command::WHO(Some(ref s), Some(true)) => Command::WHO(Some(ref s), Some(true)) =>
stringify("WHO", vec![s, "o"], None), stringify("WHO", &[s, "o"], None),
Command::WHO(Some(ref s), _) => Command::WHO(Some(ref s), _) =>
stringify("WHO", vec![s], None), stringify("WHO", &[s], None),
Command::WHO(None, _) => stringify("WHO", vec![], None), Command::WHO(None, _) => stringify("WHO", &[], None),
Command::WHOIS(Some(ref t), ref m) => Command::WHOIS(Some(ref t), ref m) =>
stringify("WHOIS", vec![t, m], None), stringify("WHOIS", &[t, m], None),
Command::WHOIS(None, ref m) => Command::WHOIS(None, ref m) =>
stringify("WHOIS", vec![m], None), stringify("WHOIS", &[m], None),
Command::WHOWAS(ref n, Some(ref c), Some(ref t)) => Command::WHOWAS(ref n, Some(ref c), Some(ref t)) =>
stringify("WHOWAS", vec![n, c], Some(t)), stringify("WHOWAS", &[n, c], Some(t)),
Command::WHOWAS(ref n, Some(ref c), None) => Command::WHOWAS(ref n, Some(ref c), None) =>
stringify("WHOWAS", vec![n, c], None), stringify("WHOWAS", &[n, c], None),
Command::WHOWAS(ref n, None, _) => Command::WHOWAS(ref n, None, _) =>
stringify("WHOWAS", vec![n], None), stringify("WHOWAS", &[n], None),
Command::KILL(ref n, ref c) => Command::KILL(ref n, ref c) =>
stringify("KILL", vec![n], Some(c)), stringify("KILL", &[n], Some(c)),
Command::PING(ref s, Some(ref t)) => Command::PING(ref s, Some(ref t)) =>
stringify("PING", vec![s], Some(t)), stringify("PING", &[s], Some(t)),
Command::PING(ref s, None) => stringify("PING", vec![], Some(s)), Command::PING(ref s, None) => stringify("PING", &[], Some(s)),
Command::PONG(ref s, Some(ref t)) => Command::PONG(ref s, Some(ref t)) =>
stringify("PONG", vec![s], Some(t)), stringify("PONG", &[s], Some(t)),
Command::PONG(ref s, None) => stringify("PONG", vec![], Some(s)), Command::PONG(ref s, None) => stringify("PONG", &[], Some(s)),
Command::ERROR(ref m) => stringify("ERROR", vec![], Some(m)), Command::ERROR(ref m) => stringify("ERROR", &[], Some(m)),
Command::AWAY(Some(ref m)) => stringify("AWAY", vec![], Some(m)), Command::AWAY(Some(ref m)) => stringify("AWAY", &[], Some(m)),
Command::AWAY(None) => stringify("AWAY", vec![], None), Command::AWAY(None) => stringify("AWAY", &[], None),
Command::REHASH => stringify("REHASH", vec![], None), Command::REHASH => stringify("REHASH", &[], None),
Command::DIE => stringify("DIE", vec![], None), Command::DIE => stringify("DIE", &[], None),
Command::RESTART => stringify("RESTART", vec![], None), Command::RESTART => stringify("RESTART", &[], None),
Command::SUMMON(ref u, Some(ref t), Some(ref c)) => Command::SUMMON(ref u, Some(ref t), Some(ref c)) =>
stringify("SUMMON", vec![u, t], Some(c)), stringify("SUMMON", &[u, t], Some(c)),
Command::SUMMON(ref u, Some(ref t), None) => Command::SUMMON(ref u, Some(ref t), None) =>
stringify("SUMMON", vec![u, t], None), stringify("SUMMON", &[u, t], None),
Command::SUMMON(ref u, None, _) => Command::SUMMON(ref u, None, _) =>
stringify("SUMMON", vec![u], None), stringify("SUMMON", &[u], None),
Command::USERS(Some(ref t)) => stringify("USERS", vec![], Some(t)), Command::USERS(Some(ref t)) => stringify("USERS", &[], Some(t)),
Command::USERS(None) => stringify("USERS", vec![], None), Command::USERS(None) => stringify("USERS", &[], None),
Command::WALLOPS(ref t) => stringify("WALLOPS", vec![], Some(t)), Command::WALLOPS(ref t) => stringify("WALLOPS", &[], Some(t)),
Command::USERHOST(ref u) => stringify("USERHOST", u.iter().map(|s| &s[..]).collect(), None), Command::USERHOST(ref u) => stringify("USERHOST", &u.iter().map(|s| &s[..]).collect::<Vec<_>>(), None),
Command::ISON(ref u) => stringify("ISON", u.iter().map(|s| &s[..]).collect(), None), Command::ISON(ref u) => stringify("ISON", &u.iter().map(|s| &s[..]).collect::<Vec<_>>(), None),
Command::SAJOIN(ref n, ref c) => Command::SAJOIN(ref n, ref c) =>
stringify("SAJOIN", vec![n, c], None), stringify("SAJOIN", &[n, c], None),
Command::SAMODE(ref t, ref m, Some(ref p)) => Command::SAMODE(ref t, ref m, Some(ref p)) =>
stringify("SAMODE", vec![t, m, p], None), stringify("SAMODE", &[t, m, p], None),
Command::SAMODE(ref t, ref m, None) => Command::SAMODE(ref t, ref m, None) =>
stringify("SAMODE", vec![t, m], None), stringify("SAMODE", &[t, m], None),
Command::SANICK(ref o, ref n) => Command::SANICK(ref o, ref n) =>
stringify("SANICK", vec![o, n], None), stringify("SANICK", &[o, n], None),
Command::SAPART(ref c, ref r) => Command::SAPART(ref c, ref r) =>
stringify("SAPART", vec![c], Some(r)), stringify("SAPART", &[c], Some(r)),
Command::SAQUIT(ref c, ref r) => Command::SAQUIT(ref c, ref r) =>
stringify("SAQUIT", vec![c], Some(r)), stringify("SAQUIT", &[c], Some(r)),
Command::NICKSERV(ref m) => Command::NICKSERV(ref m) =>
stringify("NICKSERV", vec![m], None), stringify("NICKSERV", &[m], None),
Command::CHANSERV(ref m) => Command::CHANSERV(ref m) =>
stringify("CHANSERV", vec![m], None), stringify("CHANSERV", &[m], None),
Command::OPERSERV(ref m) => Command::OPERSERV(ref m) =>
stringify("OPERSERV", vec![m], None), stringify("OPERSERV", &[m], None),
Command::BOTSERV(ref m) => Command::BOTSERV(ref m) =>
stringify("BOTSERV", vec![m], None), stringify("BOTSERV", &[m], None),
Command::HOSTSERV(ref m) => Command::HOSTSERV(ref m) =>
stringify("HOSTSERV", vec![m], None), stringify("HOSTSERV", &[m], None),
Command::MEMOSERV(ref m) => Command::MEMOSERV(ref m) =>
stringify("MEMOSERV", vec![m], None), stringify("MEMOSERV", &[m], None),
Command::CAP(None, ref s, None, Some(ref p)) => Command::CAP(None, ref s, None, Some(ref p)) =>
stringify("CAP", vec![s.to_str()], Some(p)), stringify("CAP", &[s.to_str()], Some(p)),
Command::CAP(None, ref s, None, None) => Command::CAP(None, ref s, None, None) =>
stringify("CAP", vec![s.to_str()], None), stringify("CAP", &[s.to_str()], None),
Command::CAP(Some(ref k), ref s, None, Some(ref p)) => Command::CAP(Some(ref k), ref s, None, Some(ref p)) =>
stringify("CAP", vec![k, s.to_str()], Some(p)), stringify("CAP", &[k, s.to_str()], Some(p)),
Command::CAP(Some(ref k), ref s, None, None) => Command::CAP(Some(ref k), ref s, None, None) =>
stringify("CAP", vec![k, s.to_str()], None), stringify("CAP", &[k, s.to_str()], None),
Command::CAP(None, ref s, Some(ref c), Some(ref p)) => Command::CAP(None, ref s, Some(ref c), Some(ref p)) =>
stringify("CAP", vec![s.to_str(), c], Some(p)), stringify("CAP", &[s.to_str(), c], Some(p)),
Command::CAP(None, ref s, Some(ref c), None) => Command::CAP(None, ref s, Some(ref c), None) =>
stringify("CAP", vec![s.to_str(), c], None), stringify("CAP", &[s.to_str(), c], None),
Command::CAP(Some(ref k), ref s, Some(ref c), Some(ref p)) => Command::CAP(Some(ref k), ref s, Some(ref c), Some(ref p)) =>
stringify("CAP", vec![k, s.to_str(), c], Some(p)), stringify("CAP", &[k, s.to_str(), c], Some(p)),
Command::CAP(Some(ref k), ref s, Some(ref c), None) => Command::CAP(Some(ref k), ref s, Some(ref c), None) =>
stringify("CAP", vec![k, s.to_str(), c], None), stringify("CAP", &[k, s.to_str(), c], None),
Command::AUTHENTICATE(ref d) => Command::AUTHENTICATE(ref d) =>
stringify("AUTHENTICATE", vec![d], None), stringify("AUTHENTICATE", &[d], None),
Command::ACCOUNT(ref a) => Command::ACCOUNT(ref a) =>
stringify("ACCOUNT", vec![a], None), stringify("ACCOUNT", &[a], None),
Command::METADATA(ref t, Some(ref c), None, Some(ref p)) => Command::METADATA(ref t, Some(ref c), None, Some(ref p)) =>
stringify("METADATA", vec![&t[..], c.to_str()], Some(p)), stringify("METADATA", &[&t[..], c.to_str()], Some(p)),
Command::METADATA(ref t, Some(ref c), None, None) => Command::METADATA(ref t, Some(ref c), None, None) =>
stringify("METADATA", vec![&t[..], c.to_str()], None), stringify("METADATA", &[&t[..], c.to_str()], None),
Command::METADATA(ref t, Some(ref c), Some(ref a), Some(ref p)) => stringify( Command::METADATA(ref t, Some(ref c), Some(ref a), Some(ref p)) => stringify(
"METADATA", "METADATA",
vec![t, &c.to_str().to_owned()].iter().map(|s| &s[..]) &vec![t, &c.to_str().to_owned()].iter().map(|s| &s[..])
.chain(a.iter().map(|s| &s[..])).collect(), .chain(a.iter().map(|s| &s[..])).collect::<Vec<_>>(),
Some(p)), Some(p)),
Command::METADATA(ref t, Some(ref c), Some(ref a), None) => Command::METADATA(ref t, Some(ref c), Some(ref a), None) =>
stringify("METADATA", stringify("METADATA",
vec![t, &c.to_str().to_owned()].iter().map(|s| &s[..]) &vec![t, &c.to_str().to_owned()].iter().map(|s| &s[..])
.chain(a.iter().map(|s| &s[..])).collect(), .chain(a.iter().map(|s| &s[..])).collect::<Vec<_>>(),
None), None),
Command::METADATA(ref t, None, None, Some(ref p)) => Command::METADATA(ref t, None, None, Some(ref p)) =>
stringify("METADATA", vec![t], Some(p)), stringify("METADATA", &[t], Some(p)),
Command::METADATA(ref t, None, None, None) => Command::METADATA(ref t, None, None, None) =>
stringify("METADATA", vec![t], None), stringify("METADATA", &[t], None),
Command::METADATA(ref t, None, Some(ref a), Some(ref p)) => Command::METADATA(ref t, None, Some(ref a), Some(ref p)) =>
stringify("METADATA", vec![t].iter().map(|s| &s[..]).chain(a.iter().map(|s| &s[..])).collect(), Some(p)), stringify("METADATA", &vec![t].iter().map(|s| &s[..]).chain(a.iter().map(|s| &s[..])).collect::<Vec<_>>(), Some(p)),
Command::METADATA(ref t, None, Some(ref a), None) => Command::METADATA(ref t, None, Some(ref a), None) =>
stringify("METADATA", vec![t].iter().map(|s| &s[..]).chain(a.iter().map(|s| &s[..])).collect(), None), stringify("METADATA", &vec![t].iter().map(|s| &s[..]).chain(a.iter().map(|s| &s[..])).collect::<Vec<_>>(), None),
Command::MONITOR(ref c, Some(ref t)) => Command::MONITOR(ref c, Some(ref t)) =>
stringify("MONITOR", vec![c, t], None), stringify("MONITOR", &[c, t], None),
Command::MONITOR(ref c, None) => Command::MONITOR(ref c, None) =>
stringify("MONITOR", vec![c], None), stringify("MONITOR", &[c], None),
Command::BATCH(ref t, Some(ref c), Some(ref a)) => stringify( Command::BATCH(ref t, Some(ref c), Some(ref a)) => stringify(
"BATCH", vec![t, &c.to_str().to_owned()].iter().map(|s| &s[..]).chain(a.iter().map(|s| &s[..])).collect(), "BATCH", &vec![t, &c.to_str().to_owned()].iter().map(|s| &s[..]).chain(a.iter().map(|s| &s[..])).collect::<Vec<_>>(),
None None
), ),
Command::BATCH(ref t, Some(ref c), None) => Command::BATCH(ref t, Some(ref c), None) =>
stringify("BATCH", vec![t, c.to_str()], None), stringify("BATCH", &[t, c.to_str()], None),
Command::BATCH(ref t, None, Some(ref a)) => Command::BATCH(ref t, None, Some(ref a)) =>
stringify("BATCH", stringify("BATCH",
vec![t].iter().map(|s| &s[..]).chain(a.iter().map(|s| &s[..])).collect(), None), &vec![t].iter().map(|s| &s[..]).chain(a.iter().map(|s| &s[..])).collect::<Vec<_>>(), None),
Command::BATCH(ref t, None, None) => Command::BATCH(ref t, None, None) =>
stringify("BATCH", vec![t], None), stringify("BATCH", &[t], None),
Command::CHGHOST(ref u, ref h) => Command::CHGHOST(ref u, ref h) =>
stringify("CHGHOST", vec![u, h], None), stringify("CHGHOST", &[u, h], None),
Command::Response(ref resp, ref a, Some(ref s)) => Command::Response(ref resp, ref a, Some(ref s)) =>
stringify(&format!("{}", *resp as u16), a.iter().map(|s| &s[..]).collect(), Some(s)), stringify(&format!("{}", *resp as u16), &a.iter().map(|s| &s[..]).collect::<Vec<_>>(), Some(s)),
Command::Response(ref resp, ref a, None) => Command::Response(ref resp, ref a, None) =>
stringify(&format!("{}", *resp as u16), a.iter().map(|s| &s[..]).collect(), None), stringify(&format!("{}", *resp as u16), &a.iter().map(|s| &s[..]).collect::<Vec<_>>(), None),
Command::Raw(ref c, ref a, Some(ref s)) => Command::Raw(ref c, ref a, Some(ref s)) =>
stringify(c, a.iter().map(|s| &s[..]).collect(), Some(s)), stringify(c, &a.iter().map(|s| &s[..]).collect::<Vec<_>>(), Some(s)),
Command::Raw(ref c, ref a, None) => Command::Raw(ref c, ref a, None) =>
stringify(c, a.iter().map(|s| &s[..]).collect(), None), stringify(c, &a.iter().map(|s| &s[..]).collect::<Vec<_>>(), None),
} }
} }
} }
@ -1448,7 +1448,7 @@ impl BatchSubCommand {
match *self { match *self {
BatchSubCommand::NETSPLIT => "NETSPLIT", BatchSubCommand::NETSPLIT => "NETSPLIT",
BatchSubCommand::NETJOIN => "NETJOIN", BatchSubCommand::NETJOIN => "NETJOIN",
BatchSubCommand::CUSTOM(ref s) => &s, BatchSubCommand::CUSTOM(ref s) => s,
} }
} }
} }

4
src/client/data/message.rs
View file

@ -41,7 +41,7 @@ impl Message {
match (s.find('!'), s.find('@'), s.find('.')) { match (s.find('!'), s.find('@'), s.find('.')) {
(Some(i), _, _) => Some(&s[..i]), // <nick> '!' <user> [ '@' <host> ] (Some(i), _, _) => Some(&s[..i]), // <nick> '!' <user> [ '@' <host> ]
(None, Some(i), _) => Some(&s[..i]), // <nick> '@' <host> (None, Some(i), _) => Some(&s[..i]), // <nick> '@' <host>
(None, None, None) => Some(&s), // <nick> (None, None, None) => Some(s), // <nick>
_ => None // <servername> _ => None // <servername>
} }
) )
@ -53,7 +53,7 @@ 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(' ');
} }
let cmd: String = From::from(&self.command); let cmd: String = From::from(&self.command);

10
src/client/data/response.rs
View file

@ -28,15 +28,15 @@ macro_rules! make_response {
make_response! { make_response! {
// Expected replies // Expected replies
/// `001 Welcome to the Internet Relay Network <nick>!<user>@<host>` /// `001 Welcome to the Internet Relay Network <nick>!<user>@<host>`
RPL_WELCOME = 001, RPL_WELCOME = 1,
/// `002 Your host is <servername>, running version <ver>` /// `002 Your host is <servername>, running version <ver>`
RPL_YOURHOST = 002, RPL_YOURHOST = 2,
/// `003 This server was created <date>` /// `003 This server was created <date>`
RPL_CREATED = 003, RPL_CREATED = 3,
/// `004 <servername> <version> <available user modes> available channel modes>` /// `004 <servername> <version> <available user modes> available channel modes>`
RPL_MYINFO = 004, RPL_MYINFO = 4,
/// `005 Try server <server name>, port <port number>` /// `005 Try server <server name>, port <port number>`
RPL_BOUNCE = 005, RPL_BOUNCE = 5,
/// `302 :*1<reply> *( " " <reply> )` /// `302 :*1<reply> *( " " <reply> )`
RPL_USERHOST = 302, RPL_USERHOST = 302,
/// `303 :*1<nick> *( " " <nick> )` /// `303 :*1<nick> *( " " <nick> )`

2
src/client/data/user.rs
View file

@ -39,7 +39,7 @@ impl User {
}, },
highest_access_level: { highest_access_level: {
let mut max = AccessLevel::Member; let mut max = AccessLevel::Member;
for rank in ranks.into_iter() { for rank in ranks {
if rank > max { if rank > max {
max = rank max = rank
} }

35
src/client/server/mod.rs
View file

@ -6,6 +6,7 @@ use std::error::Error as StdError;
use std::io::{Error, ErrorKind, Result}; use std::io::{Error, ErrorKind, Result};
use std::path::Path; use std::path::Path;
use std::sync::{Arc, Mutex, RwLock}; use std::sync::{Arc, Mutex, RwLock};
use std::sync::atomic::{AtomicBool, Ordering};
use std::thread::{spawn, sleep}; use std::thread::{spawn, sleep};
use std::time::Duration as StdDuration; use std::time::Duration as StdDuration;
use client::conn::{Connection, NetConnection}; use client::conn::{Connection, NetConnection};
@ -61,7 +62,7 @@ struct ServerState {
/// A thread-safe store for the last ping data. /// A thread-safe store for the last ping data.
last_ping_data: Mutex<Option<Timespec>>, last_ping_data: Mutex<Option<Timespec>>,
/// A thread-safe check of pong reply. /// A thread-safe check of pong reply.
waiting_pong_reply: Mutex<bool>, waiting_pong_reply: AtomicBool,
} }
impl ServerState { impl ServerState {
@ -74,15 +75,14 @@ impl ServerState {
reconnect_count: Mutex::new(0), reconnect_count: Mutex::new(0),
last_action_time: Mutex::new(now()), last_action_time: Mutex::new(now()),
last_ping_data: Mutex::new(None), last_ping_data: Mutex::new(None),
waiting_pong_reply: Mutex::new(false), waiting_pong_reply: AtomicBool::new(false),
} }
} }
fn reconnect(&self) -> Result<()> { fn reconnect(&self) -> Result<()> {
let mut ping_data = self.last_ping_data.lock().unwrap(); let mut ping_data = self.last_ping_data.lock().unwrap();
*ping_data = None; *ping_data = None;
let mut waiting_pong_reply = self.waiting_pong_reply.lock().unwrap(); self.waiting_pong_reply.store(false, Ordering::SeqCst);
*waiting_pong_reply = false;
self.conn.reconnect() self.conn.reconnect()
} }
@ -103,8 +103,7 @@ impl ServerState {
fn update_ping_data(&self, data: Timespec) { fn update_ping_data(&self, data: Timespec) {
let mut ping_data = self.last_ping_data.lock().unwrap(); let mut ping_data = self.last_ping_data.lock().unwrap();
*ping_data = Some(data); *ping_data = Some(data);
let mut waiting_pong_reply = self.waiting_pong_reply.lock().unwrap(); self.waiting_pong_reply.store(true, Ordering::SeqCst);
*waiting_pong_reply = true;
} }
fn last_ping_data(&self) -> Option<Timespec> { fn last_ping_data(&self) -> Option<Timespec> {
@ -112,7 +111,7 @@ impl ServerState {
} }
fn waiting_pong_reply(&self) -> bool { fn waiting_pong_reply(&self) -> bool {
*self.waiting_pong_reply.lock().unwrap() self.waiting_pong_reply.load(Ordering::SeqCst)
} }
fn check_pong(&self, data: &str) { fn check_pong(&self, data: &str) {
@ -120,8 +119,7 @@ impl ServerState {
let fmt = format!("{}", time.sec); let fmt = format!("{}", time.sec);
if fmt == data { if fmt == data {
// found matching pong reply // found matching pong reply
let mut waiting_reply = self.waiting_pong_reply.lock().unwrap(); self.waiting_pong_reply.store(false, Ordering::SeqCst);
*waiting_reply = false;
} }
} }
} }
@ -364,9 +362,8 @@ impl IrcServer {
/// Handles received messages internally for basic client functionality. /// Handles received messages internally for basic client functionality.
fn handle_message(&self, msg: &Message) -> Result<()> { fn handle_message(&self, msg: &Message) -> Result<()> {
match msg.command { match msg.command {
PING(ref data, _) => try!(self.send_pong(&data)), PING(ref data, _) => try!(self.send_pong(data)),
PONG(_, Some(ref pingdata)) => self.state.check_pong(&pingdata), PONG(ref pingdata, None) | PONG(_, Some(ref pingdata)) => self.state.check_pong(pingdata),
PONG(ref pingdata, None) => self.state.check_pong(&pingdata),
JOIN(ref chan, _, _) => self.handle_join(msg.source_nickname().unwrap_or(""), chan), JOIN(ref chan, _, _) => self.handle_join(msg.source_nickname().unwrap_or(""), chan),
PART(ref chan, _) => self.handle_part(msg.source_nickname().unwrap_or(""), chan), PART(ref chan, _) => self.handle_part(msg.source_nickname().unwrap_or(""), chan),
QUIT(_) => self.handle_quit(msg.source_nickname().unwrap_or("")), QUIT(_) => self.handle_quit(msg.source_nickname().unwrap_or("")),
@ -382,7 +379,7 @@ impl IrcServer {
body[1..end].split(' ').collect() body[1..end].split(' ').collect()
}; };
if target.starts_with('#') { if target.starts_with('#') {
try!(self.handle_ctcp(&target, tokens)) try!(self.handle_ctcp(target, tokens))
} else if let Some(user) = msg.source_nickname() { } else if let Some(user) = msg.source_nickname() {
try!(self.handle_ctcp(user, tokens)) try!(self.handle_ctcp(user, tokens))
} }
@ -396,7 +393,7 @@ impl IrcServer {
try!(self.send_umodes()); try!(self.send_umodes());
let config_chans = self.config().channels(); let config_chans = self.config().channels();
for chan in config_chans.iter() { for chan in &config_chans {
match self.config().channel_key(chan) { match self.config().channel_key(chan) {
Some(key) => try!(self.send_join_with_keys(chan, key)), Some(key) => try!(self.send_join_with_keys(chan, key)),
None => try!(self.send_join(chan)) None => try!(self.send_join(chan))
@ -501,9 +498,9 @@ impl IrcServer {
let mut chanlists = self.chanlists().lock().unwrap(); let mut chanlists = self.chanlists().lock().unwrap();
for channel in chanlists.clone().keys() { for channel in chanlists.clone().keys() {
if let Some(vec) = chanlists.get_mut(&channel.to_owned()) { if let Some(vec) = chanlists.get_mut(&channel.to_owned()) {
for p in vec.iter().position(|x| x.get_nickname() == old_nick) { if let Some(n) = vec.iter().position(|x| x.get_nickname() == old_nick) {
let new_entry = User::new(new_nick); let new_entry = User::new(new_nick);
vec[p] = new_entry; vec[n] = new_entry;
} }
} }
} }
@ -516,7 +513,7 @@ impl IrcServer {
fn handle_mode(&self, chan: &str, mode: &str, user: &str) { fn handle_mode(&self, chan: &str, mode: &str, user: &str) {
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.iter().position(|x| x.get_nickname() == user) { if let Some(n) = vec.iter().position(|x| x.get_nickname() == user) {
vec[n].update_access_level(&mode) vec[n].update_access_level(mode)
} }
} }
} }
@ -541,7 +538,7 @@ impl IrcServer {
/// Handles CTCP requests if the CTCP feature is enabled. /// Handles CTCP requests if the CTCP feature is enabled.
#[cfg(feature = "ctcp")] #[cfg(feature = "ctcp")]
fn handle_ctcp(&self, resp: &str, tokens: Vec<&str>) -> Result<()> { fn handle_ctcp(&self, resp: &str, tokens: Vec<&str>) -> Result<()> {
if tokens.len() == 0 { return Ok(()) } if tokens.is_empty() { return Ok(()) }
match tokens[0] { match tokens[0] {
"FINGER" => self.send_ctcp_internal(resp, &format!( "FINGER" => self.send_ctcp_internal(resp, &format!(
"FINGER :{} ({})", self.config().real_name(), self.config().username() "FINGER :{} ({})", self.config().real_name(), self.config().username()
@ -579,7 +576,7 @@ impl IrcServer {
} }
} }
/// An Iterator over an IrcServer's incoming Messages. /// An `Iterator` over an `IrcServer`'s incoming `Messages`.
pub struct ServerIterator<'a> { pub struct ServerIterator<'a> {
server: &'a IrcServer server: &'a IrcServer
} }