Update Cargo.toml files with more metadata

6 files changed, 0 insertions, 914 deletions

diff --git a/src/format/binary.rs b/src/format/binary.rs
deleted file mode 100644
index 7cc4281..0000000
--- a/src/format/binary.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2015 Till Höppner
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::io::{BufRead, Write};
-use std::iter::Iterator;
-
-use event::Event;
-use context::Context;
-use format::{Decode, Encode};
-
-use bincode::{self, SizeLimit};
-
-pub struct Binary;
-
-pub struct Iter<'a> {
-    input: &'a mut BufRead,
-}
-
-impl<'a> Iterator for Iter<'a> {
-    type Item = ::Result<Event<'a>>;
-    fn next(&mut self) -> Option<::Result<Event<'a>>> {
-        Some(bincode::rustc_serialize::decode_from::<_, Event>(&mut self.input,
-                                                               SizeLimit::Infinite)
-                 .map_err(|_| ::IlcError::BincodeDecode))
-    }
-}
-
-impl Encode for Binary {
-    fn encode<'a>(&'a self,
-                  _context: &'a Context,
-                  mut output: &'a mut Write,
-                  event: &'a Event)
-                  -> ::Result<()> {
-        bincode::rustc_serialize::encode_into(event, &mut output, SizeLimit::Infinite)
-            .map_err(|_| ::IlcError::BincodeEncode)
-    }
-}
-
-impl Decode for Binary {
-    fn decode<'a>(&'a mut self,
-                  _context: &'a Context,
-                  input: &'a mut BufRead)
-                  -> Box<Iterator<Item = ::Result<Event<'a>>> + 'a> {
-        Box::new(Iter { input: input })
-    }
-}
diff --git a/src/format/energymech.rs b/src/format/energymech.rs
deleted file mode 100644
index e8dded6..0000000
--- a/src/format/energymech.rs
+++ /dev/null
@@ -1,255 +0,0 @@
-// Copyright 2015 Till Höppner
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::io::{BufRead, Write};
-use std::borrow::{Cow, ToOwned};
-use std::iter::Iterator;
-
-use event::{Event, Time, Type};
-use context::Context;
-use format::{Decode, Encode, rejoin, strip_one};
-
-use log::LogLevel::Info;
-
-use chrono::*;
-
-pub struct Energymech;
-
-static TIME_FORMAT: &'static str = "%H:%M:%S";
-
-pub struct Iter<'a> {
-    context: &'a Context,
-    input: &'a mut BufRead,
-    buffer: Vec<u8>,
-}
-
-impl<'a> Iterator for Iter<'a> {
-    type Item = ::Result<Event<'a>>;
-    fn next(&mut self) -> Option<::Result<Event<'a>>> {
-        fn parse_time(context: &Context, time: &str) -> Time {
-            let h = time[1..3].parse::<u32>().unwrap();
-            let m = time[4..6].parse::<u32>().unwrap();
-            let s = time[7..9].parse::<u32>().unwrap();
-            if let Some(date) = context.override_date {
-                Time::Timestamp(context.timezone
-                                       .from_local_date(&date)
-                                       .and_time(NaiveTime::from_hms(h, m, s))
-                                       .single()
-                                       .expect("Transformed log times can't be represented, due \
-                                                to timezone transitions")
-                                       .timestamp())
-            } else {
-                Time::Hms(h as u8, m as u8, s as u8)
-            }
-        }
-
-        loop {
-            self.buffer.clear();
-            match self.input.read_until(b'\n', &mut self.buffer) {
-                Ok(0) | Err(_) => return None,
-                Ok(_) => (),
-            }
-
-            let buffer = String::from_utf8_lossy(&self.buffer);
-
-            let mut split_tokens: Vec<char> = Vec::new();
-            let tokens = buffer.split(|c: char| {
-                                   if c.is_whitespace() {
-                                       split_tokens.push(c);
-                                       true
-                                   } else {
-                                       false
-                                   }
-                               })
-                               .collect::<Vec<_>>();
-
-            if log_enabled!(Info) {
-                info!("Original:  `{}`", buffer);
-                info!("Parsing:   {:?}", tokens);
-            }
-
-            match &tokens[..tokens.len() - 1] {
-                [time, "*", nick, content..] => {
-                    return Some(Ok(Event {
-                        ty: Type::Action {
-                            from: nick.to_owned().into(),
-                            content: rejoin(content, &split_tokens[3..]),
-                        },
-                        time: parse_time(&self.context, time),
-                        channel: self.context.channel.clone().map(Into::into),
-                    }))
-                }
-                [time, "***", old, "is", "now", "known", "as", new] => {
-                    return Some(Ok(Event {
-                        ty: Type::Nick {
-                            old_nick: old.to_owned().into(),
-                            new_nick: new.to_owned().into(),
-                        },
-                        time: parse_time(&self.context, time),
-                        channel: self.context.channel.clone().map(Into::into),
-                    }))
-                }
-                [time, "***", nick, "sets", "mode:", mode, masks..] => {
-                    return Some(Ok(Event {
-                        ty: Type::Mode {
-                            nick: Some(nick.to_owned().into()),
-                            mode: mode.to_owned().into(),
-                            masks: rejoin(&masks, &split_tokens[6..]).to_owned().into(),
-                        },
-                        time: parse_time(&self.context, time),
-                        channel: self.context.channel.clone().map(Into::into),
-                    }))
-                }
-                [time, "***", "Joins:", nick, host] => {
-                    return Some(Ok(Event {
-                        ty: Type::Join {
-                            nick: nick.to_owned().into(),
-                            mask: Some(strip_one(host).into()),
-                        },
-                        time: parse_time(&self.context, time),
-                        channel: self.context.channel.clone().map(Into::into),
-                    }))
-                }
-                [time, "***", "Parts:", nick, host, reason..] => {
-                    return Some(Ok(Event {
-                        ty: Type::Part {
-                            nick: nick.to_owned().into(),
-                            mask: Some(strip_one(host).into()),
-                            reason: Some(strip_one(&rejoin(reason, &split_tokens[5..])).into()),
-                        },
-                        time: parse_time(&self.context, time),
-                        channel: self.context.channel.clone().map(Into::into),
-                    }))
-                }
-                [time, "***", "Quits:", nick, host, reason..] => {
-                    return Some(Ok(Event {
-                        ty: Type::Quit {
-                            nick: nick.to_owned().into(),
-                            mask: Some(strip_one(host).into()),
-                            reason: Some(strip_one(&rejoin(reason, &split_tokens[5..])).into()),
-                        },
-                        time: parse_time(&self.context, time),
-                        channel: self.context.channel.clone().map(Into::into),
-                    }))
-                }
-                [time, "***", nick, "changes", "topic", "to", topic..] => {
-                    return Some(Ok(Event {
-                        ty: Type::TopicChange {
-                            nick: Some(nick.to_owned().into()),
-                            new_topic: strip_one(&rejoin(topic, &split_tokens[6..])).into(),
-                        },
-                        time: parse_time(&self.context, time),
-                        channel: self.context.channel.clone().map(Into::into),
-                    }))
-                }
-                [time, nick, content..] if nick.starts_with('<') && nick.ends_with('>') => {
-                    return Some(Ok(Event {
-                        ty: Type::Msg {
-                            from: strip_one(nick).into(),
-                            content: rejoin(content, &split_tokens[2..]),
-                        },
-                        time: parse_time(&self.context, time),
-                        channel: self.context.channel.clone().map(Into::into),
-                    }))
-                }
-                _ => (),
-            }
-        }
-    }
-}
-
-impl Decode for Energymech {
-    fn decode<'a>(&'a mut self,
-                  context: &'a Context,
-                  input: &'a mut BufRead)
-                  -> Box<Iterator<Item = ::Result<Event<'a>>> + 'a> {
-        Box::new(Iter {
-            context: context,
-            input: input,
-            buffer: Vec::new(),
-        })
-    }
-}
-
-impl Encode for Energymech {
-    fn encode<'a>(&'a self,
-                  context: &'a Context,
-                  mut output: &'a mut Write,
-                  event: &'a Event)
-                  -> ::Result<()> {
-        match event {
-            &Event { ty: Type::Msg { ref from, ref content }, ref time, .. } => {
-                try!(writeln!(&mut output,
-                              "[{}] <{}> {}",
-                              time.with_format(&context.timezone, TIME_FORMAT),
-                              from,
-                              content))
-            }
-            &Event { ty: Type::Action { ref from, ref content }, ref time, .. } => {
-                try!(writeln!(&mut output,
-                              "[{}] * {} {}",
-                              time.with_format(&context.timezone, TIME_FORMAT),
-                              from,
-                              content))
-            }
-            &Event { ty: Type::Nick { ref old_nick, ref new_nick }, ref time, .. } => {
-                try!(writeln!(&mut output,
-                              "[{}] *** {} is now known as {}",
-                              time.with_format(&context.timezone, TIME_FORMAT),
-                              old_nick,
-                              new_nick))
-            }
-            &Event { ty: Type::Mode { ref nick, ref mode, ref masks }, ref time, .. } => {
-                try!(writeln!(&mut output,
-                              "[{}] *** {} sets mode: {} {}",
-                              time.with_format(&context.timezone, TIME_FORMAT),
-                              nick.as_ref().expect("Nickname not present, but required."),
-                              mode,
-                              masks))
-            }
-            &Event { ty: Type::Join { ref nick, ref mask }, ref time, .. } => {
-                try!(writeln!(&mut output,
-                              "[{}] *** Joins: {} ({})",
-                              time.with_format(&context.timezone, TIME_FORMAT),
-                              nick,
-                              mask.as_ref().expect("Mask not present, but required.")))
-            }
-            &Event { ty: Type::Part { ref nick, ref mask, ref reason }, ref time, .. } => {
-                try!(writeln!(&mut output,
-                              "[{}] *** Parts: {} ({}) ({})",
-                              time.with_format(&context.timezone, TIME_FORMAT),
-                              nick,
-                              mask.as_ref().expect("Mask not present, but required."),
-                              reason.as_ref().unwrap_or(&Cow::Borrowed(""))))
-            }
-            &Event { ty: Type::Quit { ref nick, ref mask, ref reason }, ref time, .. } => {
-                try!(writeln!(&mut output,
-                              "[{}] *** Quits: {} ({}) ({})",
-                              time.with_format(&context.timezone, TIME_FORMAT),
-                              nick,
-                              mask.as_ref().expect("Mask not present, but required."),
-                              reason.as_ref().expect("Reason not present, but required.")))
-            }
-            &Event { ty: Type::TopicChange { ref nick, ref new_topic }, ref time, .. } => {
-                try!(writeln!(&mut output,
-                              "[{}] *** {} changes topic to '{}'",
-                              time.with_format(&context.timezone, TIME_FORMAT),
-                              nick.as_ref().expect("Nick not present, but required."),
-                              new_topic))
-            }
-            _ => (),
-        }
-        Ok(())
-    }
-}
diff --git a/src/format/irssi.rs b/src/format/irssi.rs
deleted file mode 100644
index 6afcd61..0000000
--- a/src/format/irssi.rs
+++ /dev/null
@@ -1,205 +0,0 @@
-// Copyright 2015 Till Höppner
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::io::{ BufRead, Write };
-use std::borrow::{ ToOwned };
-use std::iter::{ Iterator };
-
-use event::{ Event, Type, Time };
-use context::Context;
-use format::{ Encode, Decode, rejoin, strip_one };
-
-use l::LogLevel::Info;
-
-pub struct Irssi;
-
-static LOG_OPEN_FORMAT: &'static str = "%a %b %e %T %Y";
-static LINE_FORMAT: &'static str = "%H:%M";
-
-pub struct Iter<'a> {
-    context: &'a Context,
-    input: &'a mut BufRead,
-    buffer: Vec<u8>
-}
-
-impl<'a> Iterator for Iter<'a> {
-    type Item = ::Result<Event<'a>>;
-    fn next(&mut self) -> Option<::Result<Event<'a>>> {
-        fn parse_time(c: &Context, date: &str, time: &str) -> Time {
-            Time::from_format(&c.timezone, &format!("{} {}", date, time), TIME_DATE_FORMAT)
-        }
-
-        loop {
-            self.buffer.clear();
-            match self.input.read_until(b'\n', &mut self.buffer) {
-                Ok(0) | Err(_) => return None,
-                Ok(_) => ()
-            }
-
-            let buffer = String::from_utf8_lossy(&self.buffer);
-
-            let mut split_tokens: Vec<char> = Vec::new();
-            let tokens = buffer.split(|c: char| {
-                if c.is_whitespace() { split_tokens.push(c); true } else { false }
-            }).collect::<Vec<_>>();
-
-            if log_enabled!(Info) {
-                info!("Original:  `{}`", buffer);
-                info!("Parsing:   {:?}", tokens);
-            }
-
-            match &tokens[..tokens.len() - 1] {
-                ["---", "Log", "opened", day_of_week, month, day, time, year] => {
-                    year
-                },
-                ["---", "Log", "closed", day_of_week, month, day, time, year]
-                => return Some(Ok(Event {
-                    ty: Type::Disconnect,
-                    time: parse_time(&self.context, date, time),
-                    channel: self.context.channel.clone().map(Into::into)
-                })),
-                [time, "-!-", nick, host, "has", "joined", channel]
-                => return Some(Ok(Event {
-                    ty: Type::Join {
-                        nick: nick.to_owned().into(),
-                        mask: Some(strip_one(host).into()),
-                    },
-                    channel: Some(channel.to_owned().into()),
-                    time: parse_time(&self.context, date, time)
-                })),
-                [time, "-!-", nick, host, "has", "left", channel, reason..]
-                => return Some(Ok(Event {
-                    ty: Type::Part {
-                        nick: nick.to_owned().into(),
-                        mask: Some(strip_one(host).into()),
-                        reason: Some(strip_one(&rejoin(reason, &split_tokens[8..])).into()),
-                    },
-                    channel: Some(channel.to_owned().into()),
-                    time: parse_time(&self.context, date, time)
-                })),
-                [time, "-!-", nick, host, "has", "quit", reason..]
-                => return Some(Ok(Event {
-                    ty: Type::Quit {
-                        nick: nick.to_owned().into(),
-                        mask: Some(strip_one(host).into()),
-                        reason: Some(strip_one(&rejoin(reason, &split_tokens[7..])).into()),
-                    },
-                    time: parse_time(&self.context, date, time),
-                    channel: self.context.channel.clone().map(Into::into)
-                })),
-                // TODO: reorder
-                [date, time, "--", notice, content..]
-                    if notice.starts_with("Notice(")
-                => return Some(Ok(Event {
-                    ty: Type::Notice {
-                        from: notice["Notice(".len()..notice.len() - 2].to_owned().into(),
-                        content: rejoin(content, &split_tokens[4..]),
-                    },
-                    time: parse_time(&self.context, date, time),
-                    channel: self.context.channel.clone().map(Into::into)
-                })),
-                [date, time, "--", nick, verb, "now", "known", "as", new_nick]
-                    if verb == "is" || verb == "are"
-                => return Some(Ok(Event {
-                    ty: Type::Nick {
-                        old_nick: nick.to_owned().into(),
-                        new_nick: new_nick.to_owned().into()
-                    },
-                    time: parse_time(&self.context, date, time),
-                    channel: self.context.channel.clone().map(Into::into)
-                })),
-                [date, time, sp, "*", nick, msg..]
-                    if sp.clone().is_empty()
-                => return Some(Ok(Event {
-                    ty: Type::Action {
-                        from: nick.to_owned().into(),
-                        content: rejoin(msg, &split_tokens[5..]),
-                    },
-                    time: parse_time(&self.context, date, time),
-                    channel: self.context.channel.clone().map(Into::into)
-                })),
-                [date, time, nick, msg..]
-                => return Some(Ok(Event {
-                    ty: Type::Msg {
-                        from: nick.to_owned().into(),
-                        content: rejoin(msg, &split_tokens[3..]),
-                    },
-                    time: parse_time(&self.context, date, time),
-                    channel: self.context.channel.clone().map(Into::into)
-                })),
-                _ => ()
-            }
-        }
-    }
-}
-
-impl Decode for Irssi {
-    fn decode<'a>(&'a mut self, context: &'a Context, input: &'a mut BufRead) -> Box<Iterator<Item = ::Result<Event<'a>>> + 'a> {
-        Box::new(Iter {
-            context: context,
-            input: input,
-            buffer: Vec::new()
-        })
-    }
-}
-
-impl Encode for Irssi {
-    fn encode<'a>(&'a self, context: &'a Context, mut output: &'a mut Write, event: &'a Event) -> ::Result<()> {
-        match event {
-            &Event { ty: Type::Msg { ref from, ref content, .. }, ref time, .. } => {
-                try!(writeln!(&mut output, "{}\t{}\t{}",
-                    time.with_format(&context.timezone, TIME_DATE_FORMAT), from, content))
-            },
-            &Event { ty: Type::Action { ref from, ref content, .. }, ref time, .. } => {
-                try!(writeln!(&mut output, "{}\t *\t{} {}",
-                    time.with_format(&context.timezone, TIME_DATE_FORMAT), from, content))
-            },
-            &Event { ty: Type::Join { ref nick, ref mask, .. }, ref channel, ref time } => {
-                try!(writeln!(&mut output, "{}\t-->\t{} ({}) has joined {}",
-                    time.with_format(&context.timezone, TIME_DATE_FORMAT), nick,
-                    mask.as_ref().expect("Hostmask not present, but required."),
-                    channel.as_ref().expect("Channel not present, but required.")))
-            },
-            &Event { ty: Type::Part { ref nick, ref mask, ref reason }, ref channel, ref time } => {
-                try!(write!(&mut output, "{}\t<--\t{} ({}) has left {}",
-                    time.with_format(&context.timezone, TIME_DATE_FORMAT), nick,
-                    mask.as_ref().expect("Hostmask not present, but required."),
-                    channel.as_ref().expect("Channel not present, but required.")));
-                if reason.is_some() && reason.as_ref().unwrap().len() > 0 {
-                    try!(write!(&mut output, " ({})", reason.as_ref().unwrap()));
-                }
-                try!(write!(&mut output, "\n"))
-            },
-            &Event { ty: Type::Quit { ref nick, ref mask, ref reason }, ref time, .. } => {
-                try!(write!(&mut output, "{}\t<--\t{} ({}) has quit",
-                    time.with_format(&context.timezone, TIME_DATE_FORMAT), nick,
-                    mask.as_ref().expect("Hostmask not present, but required.")));
-                if reason.is_some() && reason.as_ref().unwrap().len() > 0 {
-                    try!(write!(&mut output, " ({})", reason.as_ref().unwrap()));
-                }
-                try!(write!(&mut output, "\n"))
-            },
-            &Event { ty: Type::Disconnect, ref time, .. } => {
-                try!(writeln!(&mut output, "{}\t--\tirc: disconnected from server",
-                    time.with_format(&context.timezone, TIME_DATE_FORMAT)))
-            },
-            &Event { ty: Type::Notice { ref from, ref content }, ref time, .. } => {
-                try!(writeln!(&mut output, "{}\t--\tNotice({}): {}",
-                    time.with_format(&context.timezone, TIME_DATE_FORMAT), from, content))
-            },
-            _ => ()
-        }
-        Ok(())
-    }
-}
diff --git a/src/format/mod.rs b/src/format/mod.rs
deleted file mode 100644
index 8873db8..0000000
--- a/src/format/mod.rs
+++ /dev/null
@@ -1,100 +0,0 @@
-// Copyright 2015 Till Höppner
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//! Traits and structs for conversion between various formats.
-//! As the source format may not provide the same information as the
-//! target format, all formats must allow for omittable information.
-
-use std::iter;
-use std::io::{BufRead, Write};
-use std::borrow::Cow;
-
-use event::Event;
-use context::Context;
-
-pub use self::energymech::Energymech;
-pub use self::weechat::Weechat;
-pub use self::binary::Binary;
-pub use self::msgpack::Msgpack;
-
-mod energymech;
-mod weechat;
-// pub mod irssi;
-mod binary;
-mod msgpack;
-
-pub trait Encode {
-    fn encode<'a>(&'a self,
-                  context: &'a Context,
-                  output: &'a mut Write,
-                  event: &'a Event)
-                  -> ::Result<()>;
-}
-
-pub trait Decode  {
-    fn decode<'a>(&'a mut self,
-                  context: &'a Context,
-                  input: &'a mut BufRead)
-                  -> Box<Iterator<Item = ::Result<Event<'a>>> + 'a>;
-}
-
-pub struct Dummy;
-
-impl Decode for Dummy {
-    fn decode<'a>(&'a mut self,
-                  _context: &'a Context,
-                  _input: &'a mut BufRead)
-                  -> Box<Iterator<Item = ::Result<Event<'a>>> + 'a> {
-        Box::new(iter::empty())
-    }
-}
-
-pub fn decoder(format: &str) -> Option<Box<Decode>> {
-    match format {
-        "energymech" | "em" => Some(Box::new(Energymech)),
-        "weechat" | "w" => Some(Box::new(Weechat)),
-        // "irssi" => Some(Box::new(irssi::Irssi)),
-        "binary" => Some(Box::new(Binary)),
-        "msgpack" => Some(Box::new(Msgpack)),
-        _ => None,
-    }
-}
-
-pub fn encoder(format: &str) -> Option<Box<Encode>> {
-    match format {
-        "energymech" | "em" => Some(Box::new(Energymech)),
-        "weechat" | "w" => Some(Box::new(Weechat)),
-        // "irssi" => Some(Box::new(irssi::Irssi)),
-        "binary" => Some(Box::new(Binary)),
-        "msgpack" => Some(Box::new(Msgpack)),
-        _ => None,
-    }
-}
-
-fn rejoin(s: &[&str], splits: &[char]) -> Cow<'static, str> {
-    let len = s.iter().map(|s| s.len()).fold(0, |a, b| a + b);
-    let mut out = s.iter()
-                   .zip(splits.iter())
-                   .fold(String::with_capacity(len), |mut s, (b, &split)| {
-                       s.push_str(b);
-                       s.push(split);
-                       s
-                   });
-    out.pop();
-    Cow::Owned(out)
-}
-
-fn strip_one(s: &str) -> String {
-    if s.len() >= 2 { s[1..(s.len() - 1)].to_owned() } else { String::new() }
-}
diff --git a/src/format/msgpack.rs b/src/format/msgpack.rs
deleted file mode 100644
index 36af1aa..0000000
--- a/src/format/msgpack.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright 2015 Till Höppner
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::io::{BufRead, Write};
-use std::iter::Iterator;
-
-use event::Event;
-use context::Context;
-use format::{Decode, Encode};
-
-use rustc_serialize::{Decodable, Encodable};
-use msgpack::{Decoder, Encoder};
-use rmp::decode::ReadError;
-
-pub struct Msgpack;
-
-pub struct Iter<'a> {
-    input: &'a mut BufRead,
-}
-
-impl<'a> Iterator for Iter<'a> {
-    type Item = ::Result<Event<'a>>;
-    fn next(&mut self) -> Option<::Result<Event<'a>>> {
-        use msgpack::decode;
-        match Event::decode(&mut Decoder::new(&mut self.input)) {
-            Ok(e) => Some(Ok(e)),
-            Err(decode::Error::InvalidMarkerRead(ReadError::UnexpectedEOF)) => None,
-            Err(e) => Some(Err(::IlcError::MsgpackDecode(e))),
-        }
-    }
-}
-
-impl Encode for Msgpack {
-    fn encode<'a>(&'a self,
-                  _context: &'a Context,
-                  output: &'a mut Write,
-                  event: &'a Event)
-                  -> ::Result<()> {
-        event.encode(&mut Encoder::new(output))
-             .map_err(|e| ::IlcError::MsgpackEncode(e))
-    }
-}
-
-impl Decode for Msgpack {
-    fn decode<'a>(&'a mut self,
-                  _context: &'a Context,
-                  input: &'a mut BufRead)
-                  -> Box<Iterator<Item = ::Result<Event<'a>>> + 'a> {
-        Box::new(Iter { input: input })
-    }
-}
diff --git a/src/format/weechat.rs b/src/format/weechat.rs
deleted file mode 100644
index ccb0726..0000000
--- a/src/format/weechat.rs
+++ /dev/null
@@ -1,235 +0,0 @@
-// Copyright 2015 Till Höppner
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::io::{BufRead, Write};
-use std::borrow::ToOwned;
-use std::iter::Iterator;
-
-use event::{Event, Time, Type};
-use context::Context;
-use format::{Decode, Encode, rejoin, strip_one};
-
-use log::LogLevel::Info;
-
-pub struct Weechat;
-
-static TIME_DATE_FORMAT: &'static str = "%Y-%m-%d %H:%M:%S";
-
-pub struct Iter<'a> {
-    context: &'a Context,
-    input: &'a mut BufRead,
-    buffer: Vec<u8>,
-}
-
-impl<'a> Iterator for Iter<'a> {
-    type Item = ::Result<Event<'a>>;
-    fn next(&mut self) -> Option<::Result<Event<'a>>> {
-        fn parse_time(c: &Context, date: &str, time: &str) -> Time {
-            Time::from_format(&c.timezone, &format!("{} {}", date, time), TIME_DATE_FORMAT)
-        }
-
-        loop {
-            self.buffer.clear();
-            match self.input.read_until(b'\n', &mut self.buffer) {
-                Ok(0) | Err(_) => return None,
-                Ok(_) => (),
-            }
-
-            let buffer = String::from_utf8_lossy(&self.buffer);
-
-            let mut split_tokens: Vec<char> = Vec::new();
-            let tokens = buffer.split(|c: char| {
-                                   if c.is_whitespace() {
-                                       split_tokens.push(c);
-                                       true
-                                   } else {
-                                       false
-                                   }
-                               })
-                               .collect::<Vec<_>>();
-
-            if log_enabled!(Info) {
-                info!("Original:  `{}`", buffer);
-                info!("Parsing:   {:?}", tokens);
-            }
-
-            match &tokens[..tokens.len() - 1] {
-                [date, time, "-->", nick, host, "has", "joined", channel, _..] => {
-                    return Some(Ok(Event {
-                        ty: Type::Join {
-                            nick: nick.to_owned().into(),
-                            mask: Some(strip_one(host).into()),
-                        },
-                        channel: Some(channel.to_owned().into()),
-                        time: parse_time(&self.context, date, time),
-                    }))
-                }
-                [date, time, "<--", nick, host, "has", "left", channel, reason..] => {
-                    return Some(Ok(Event {
-                        ty: Type::Part {
-                            nick: nick.to_owned().into(),
-                            mask: Some(strip_one(host).into()),
-                            reason: Some(strip_one(&rejoin(reason, &split_tokens[8..])).into()),
-                        },
-                        channel: Some(channel.to_owned().into()),
-                        time: parse_time(&self.context, date, time),
-                    }))
-                }
-                [date, time, "<--", nick, host, "has", "quit", reason..] => {
-                    return Some(Ok(Event {
-                        ty: Type::Quit {
-                            nick: nick.to_owned().into(),
-                            mask: Some(strip_one(host).into()),
-                            reason: Some(strip_one(&rejoin(reason, &split_tokens[7..])).into()),
-                        },
-                        time: parse_time(&self.context, date, time),
-                        channel: self.context.channel.clone().map(Into::into),
-                    }))
-                }
-                [date, time, "--", notice, content..] if notice.starts_with("Notice(") => {
-                    return Some(Ok(Event {
-                        ty: Type::Notice {
-                            from: notice["Notice(".len()..notice.len() - 2].to_owned().into(),
-                            content: rejoin(content, &split_tokens[4..]),
-                        },
-                        time: parse_time(&self.context, date, time),
-                        channel: self.context.channel.clone().map(Into::into),
-                    }))
-                }
-                [date, time, "--", "irc:", "disconnected", "from", "server", _..] => {
-                    return Some(Ok(Event {
-                        ty: Type::Disconnect,
-                        time: parse_time(&self.context, date, time),
-                        channel: self.context.channel.clone().map(Into::into),
-                    }))
-                }
-                [date, time, "--", nick, verb, "now", "known", "as", new_nick] if verb == "is" ||
-                                                                                  verb == "are" => {
-                    return Some(Ok(Event {
-                        ty: Type::Nick {
-                            old_nick: nick.to_owned().into(),
-                            new_nick: new_nick.to_owned().into(),
-                        },
-                        time: parse_time(&self.context, date, time),
-                        channel: self.context.channel.clone().map(Into::into),
-                    }))
-                }
-                [date, time, sp, "*", nick, msg..] if sp.clone().is_empty() => {
-                    return Some(Ok(Event {
-                        ty: Type::Action {
-                            from: nick.to_owned().into(),
-                            content: rejoin(msg, &split_tokens[5..]),
-                        },
-                        time: parse_time(&self.context, date, time),
-                        channel: self.context.channel.clone().map(Into::into),
-                    }))
-                }
-                [date, time, nick, msg..] => {
-                    return Some(Ok(Event {
-                        ty: Type::Msg {
-                            from: nick.to_owned().into(),
-                            content: rejoin(msg, &split_tokens[3..]),
-                        },
-                        time: parse_time(&self.context, date, time),
-                        channel: self.context.channel.clone().map(Into::into),
-                    }))
-                }
-                _ => (),
-            }
-        }
-    }
-}
-
-impl Decode for Weechat {
-    fn decode<'a>(&'a mut self,
-                  context: &'a Context,
-                  input: &'a mut BufRead)
-                  -> Box<Iterator<Item = ::Result<Event<'a>>> + 'a> {
-        Box::new(Iter {
-            context: context,
-            input: input,
-            buffer: Vec::new(),
-        })
-    }
-}
-
-impl Encode for Weechat {
-    fn encode<'a>(&'a self,
-                  context: &'a Context,
-                  mut output: &'a mut Write,
-                  event: &'a Event)
-                  -> ::Result<()> {
-        match event {
-            &Event { ty: Type::Msg { ref from, ref content, .. }, ref time, .. } => {
-                try!(writeln!(&mut output,
-                              "{}\t{}\t{}",
-                              time.with_format(&context.timezone, TIME_DATE_FORMAT),
-                              from,
-                              content))
-            }
-            &Event { ty: Type::Action { ref from, ref content, .. }, ref time, .. } => {
-                try!(writeln!(&mut output,
-                              "{}\t *\t{} {}",
-                              time.with_format(&context.timezone, TIME_DATE_FORMAT),
-                              from,
-                              content))
-            }
-            &Event { ty: Type::Join { ref nick, ref mask, .. }, ref channel, ref time } => {
-                try!(writeln!(&mut output,
-                              "{}\t-->\t{} ({}) has joined {}",
-                              time.with_format(&context.timezone, TIME_DATE_FORMAT),
-                              nick,
-                              mask.as_ref().expect("Hostmask not present, but required."),
-                              channel.as_ref().expect("Channel not present, but required.")))
-            }
-            &Event { ty: Type::Part { ref nick, ref mask, ref reason }, ref channel, ref time } => {
-                try!(write!(&mut output,
-                            "{}\t<--\t{} ({}) has left {}",
-                            time.with_format(&context.timezone, TIME_DATE_FORMAT),
-                            nick,
-                            mask.as_ref().expect("Hostmask not present, but required."),
-                            channel.as_ref().expect("Channel not present, but required.")));
-                if reason.is_some() && reason.as_ref().unwrap().len() > 0 {
-                    try!(write!(&mut output, " ({})", reason.as_ref().unwrap()));
-                }
-                try!(write!(&mut output, "\n"))
-            }
-            &Event { ty: Type::Quit { ref nick, ref mask, ref reason }, ref time, .. } => {
-                try!(write!(&mut output,
-                            "{}\t<--\t{} ({}) has quit",
-                            time.with_format(&context.timezone, TIME_DATE_FORMAT),
-                            nick,
-                            mask.as_ref().expect("Hostmask not present, but required.")));
-                if reason.is_some() && reason.as_ref().unwrap().len() > 0 {
-                    try!(write!(&mut output, " ({})", reason.as_ref().unwrap()));
-                }
-                try!(write!(&mut output, "\n"))
-            }
-            &Event { ty: Type::Disconnect, ref time, .. } => {
-                try!(writeln!(&mut output,
-                              "{}\t--\tirc: disconnected from server",
-                              time.with_format(&context.timezone, TIME_DATE_FORMAT)))
-            }
-            &Event { ty: Type::Notice { ref from, ref content }, ref time, .. } => {
-                try!(writeln!(&mut output,
-                              "{}\t--\tNotice({}): {}",
-                              time.with_format(&context.timezone, TIME_DATE_FORMAT),
-                              from,
-                              content))
-            }
-            _ => (),
-        }
-        Ok(())
-    }
-}