135 lines
3.1 KiB
Rust
135 lines
3.1 KiB
Rust
use std::collections::HashMap;
|
|
use std::io::fs::File;
|
|
use std::io::{InvalidInput, IoError, IoResult};
|
|
use serialize::json::{decode};
|
|
|
|
pub trait IrcWriter: Writer + Sized + 'static {}
|
|
impl<T> IrcWriter for T where T: Writer + Sized + 'static {}
|
|
pub trait IrcReader: Buffer + Sized + 'static {}
|
|
impl<T> IrcReader for T where T: Buffer + Sized + 'static {}
|
|
|
|
#[deriving(PartialEq, Clone, Show)]
|
|
pub struct User {
|
|
name: String,
|
|
access_level: AccessLevel,
|
|
}
|
|
|
|
impl User {
|
|
pub fn new(name: &str) -> User {
|
|
let rank = AccessLevel::from_str(name);
|
|
User {
|
|
name: if let Member = rank {
|
|
name.into_string()
|
|
} else {
|
|
name[1..].into_string()
|
|
},
|
|
access_level: rank,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[deriving(PartialEq, Clone, Show)]
|
|
pub enum AccessLevel {
|
|
Owner,
|
|
Admin,
|
|
Oper,
|
|
HalfOp,
|
|
Voice,
|
|
Member,
|
|
}
|
|
|
|
impl AccessLevel {
|
|
pub fn from_str(s: &str) -> AccessLevel {
|
|
if s.len() == 0 { Member } else {
|
|
match s.char_at(0) {
|
|
'~' => Owner,
|
|
'&' => Admin,
|
|
'@' => Oper,
|
|
'%' => HalfOp,
|
|
'+' => Voice,
|
|
_ => Member,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[deriving(Show, PartialEq)]
|
|
pub struct Message<'a> {
|
|
pub source: Option<&'a str>,
|
|
pub command: &'a str,
|
|
pub args: &'a [&'a str],
|
|
pub colon_flag: bool,
|
|
}
|
|
|
|
impl<'a> Message<'a> {
|
|
pub fn new(source: Option<&'a str>, command: &'a str, args: &'a [&'a str], colon_flag: bool) -> Message<'a> {
|
|
Message {
|
|
source: source,
|
|
command: command,
|
|
args: args,
|
|
colon_flag: colon_flag,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[deriving(Clone, Decodable)]
|
|
pub struct Config {
|
|
pub owners: Vec<String>,
|
|
pub nickname: String,
|
|
pub username: String,
|
|
pub realname: String,
|
|
pub password: String,
|
|
pub server: String,
|
|
pub port: u16,
|
|
pub channels: Vec<String>,
|
|
pub options: HashMap<String, String>,
|
|
}
|
|
|
|
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 {
|
|
kind: InvalidInput,
|
|
desc: "Decoder error",
|
|
detail: Some(e.to_string()),
|
|
})
|
|
}
|
|
|
|
pub fn load_utf8(path: &str) -> IoResult<Config> {
|
|
Config::load(Path::new(path))
|
|
}
|
|
|
|
pub fn is_owner(&self, nickname: &str) -> bool {
|
|
self.owners[].contains(&String::from_str(nickname))
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::{Config, Message};
|
|
|
|
#[test]
|
|
fn new_message() {
|
|
let args = ["flare.to.ca.fyrechat.net"];
|
|
let m = Message::new(None, "PING", args, true);
|
|
assert_eq!(m, Message {
|
|
source: None,
|
|
command: "PING",
|
|
args: args,
|
|
colon_flag: true,
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn load_config() {
|
|
assert!(Config::load_utf8("config.json").is_ok());
|
|
}
|
|
|
|
#[test]
|
|
fn is_owner() {
|
|
let cfg = Config::load_utf8("config.json").unwrap();
|
|
assert!(cfg.is_owner("test"));
|
|
assert!(!cfg.is_owner("test2"));
|
|
}
|
|
}
|