Refactor... everything.

10 files changed, 865 insertions, 0 deletions

diff --git a/formats/binary/Cargo.toml b/formats/binary/Cargo.toml
new file mode 100644
index 0000000..a4dc9e7
--- /dev/null
+++ b/formats/binary/Cargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "ilc-format-binary"
+version = "0.1.0"
+authors = ["Till Höppner <till@hoeppner.ws>"]
+
+[dependencies]
diff --git a/formats/binary/src/lib.rs b/formats/binary/src/lib.rs
new file mode 100644
index 0000000..7cc4281
--- /dev/null
+++ b/formats/binary/src/lib.rs
@@ -0,0 +1,57 @@
+// 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/formats/energymech/Cargo.toml b/formats/energymech/Cargo.toml
new file mode 100644
index 0000000..7abcb49
--- /dev/null
+++ b/formats/energymech/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "ilc-format-energymech"
+version = "0.1.0"
+authors = ["Till Höppner <till@hoeppner.ws>"]
+
+[dependencies]
+log = "0.3.5"
+chrono = "0.2.19"
+# ilc-base = "*"
+ilc-base = { path = "../../base" }
diff --git a/formats/energymech/src/lib.rs b/formats/energymech/src/lib.rs
new file mode 100644
index 0000000..16795cf
--- /dev/null
+++ b/formats/energymech/src/lib.rs
@@ -0,0 +1,262 @@
+// 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.
+
+#![feature(slice_patterns)]
+
+#[macro_use]
+extern crate log;
+extern crate ilc_base;
+extern crate chrono;
+
+use std::io::{BufRead, Write};
+use std::borrow::{Cow, ToOwned};
+use std::iter::Iterator;
+
+use ilc_base::event::{Event, Time, Type};
+use ilc_base::format::{rejoin, strip_one};
+use ilc_base::{Context, Decode, Encode};
+
+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 = ilc_base::Result<Event<'a>>;
+    fn next(&mut self) -> Option<ilc_base::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 = ilc_base::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)
+                  -> ilc_base::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/formats/irssi/Cargo.toml b/formats/irssi/Cargo.toml
new file mode 100644
index 0000000..d59ecf2
--- /dev/null
+++ b/formats/irssi/Cargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "ilc-format-irssi"
+version = "0.1.0"
+authors = ["Till Höppner <till@hoeppner.ws>"]
+
+[dependencies]
diff --git a/formats/irssi/src/lib.rs b/formats/irssi/src/lib.rs
new file mode 100644
index 0000000..6afcd61
--- /dev/null
+++ b/formats/irssi/src/lib.rs
@@ -0,0 +1,205 @@
+// 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/formats/msgpack/Cargo.toml b/formats/msgpack/Cargo.toml
new file mode 100644
index 0000000..1e336ca
--- /dev/null
+++ b/formats/msgpack/Cargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "ilc-format-msgpack"
+version = "0.1.0"
+authors = ["Till Höppner <till@hoeppner.ws>"]
+
+[dependencies]
diff --git a/formats/msgpack/src/lib.rs b/formats/msgpack/src/lib.rs
new file mode 100644
index 0000000..36af1aa
--- /dev/null
+++ b/formats/msgpack/src/lib.rs
@@ -0,0 +1,62 @@
+// 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/formats/weechat/Cargo.toml b/formats/weechat/Cargo.toml
new file mode 100644
index 0000000..5b0ef3f
--- /dev/null
+++ b/formats/weechat/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "ilc-format-weechat"
+version = "0.1.0"
+authors = ["Till Höppner <till@hoeppner.ws>"]
+
+[dependencies]
+log = "0.3.5"
+chrono = "0.2.19"
+# ilc-base = "*"
+ilc-base = { path = "../../base" }
diff --git a/formats/weechat/src/lib.rs b/formats/weechat/src/lib.rs
new file mode 100644
index 0000000..09ad58a
--- /dev/null
+++ b/formats/weechat/src/lib.rs
@@ -0,0 +1,241 @@
+// 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.
+
+#![feature(slice_patterns)]
+
+#[macro_use]
+extern crate log;
+extern crate ilc_base;
+
+use std::io::{BufRead, Write};
+use std::borrow::ToOwned;
+use std::iter::Iterator;
+
+use ilc_base::event::{Event, Time, Type};
+use ilc_base::{Context, Decode, Encode};
+use ilc_base::format::{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 = ilc_base::Result<Event<'a>>;
+    fn next(&mut self) -> Option<ilc_base::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 = ilc_base::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)
+                  -> ilc_base::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(())
+    }
+}