From 19a778d004de584a09fa1d4c6c4bd8803ca80048 Mon Sep 17 00:00:00 2001 From: Till Hoeppner Date: Thu, 11 Jun 2015 12:39:45 +0200 Subject: Some inbetween state of confusion --- src/format/energymech.rs | 135 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 135 insertions(+) create mode 100644 src/format/energymech.rs (limited to 'src/format/energymech.rs') diff --git a/src/format/energymech.rs b/src/format/energymech.rs new file mode 100644 index 0000000..a044344 --- /dev/null +++ b/src/format/energymech.rs @@ -0,0 +1,135 @@ +// 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, rejoin }; +use context::Context; +use format::{ Encode, Decode }; + +use l::LogLevel::Info; + +use chrono::*; + +pub struct Energymech; + +static TIME_FORMAT: &'static str = "%H:%M:%S"; + +pub struct Iter<'a, R: 'a> where R: BufRead { + context: &'a Context, + input: R, + buffer: String +} + +impl<'a, R: 'a> Iterator for Iter<'a, R> where R: BufRead { + type Item = ::Result>; + fn next(&mut self) -> Option<::Result>> { + fn timestamp(context: &Context, time: &str) -> i64 { + context.timezone.from_local_date(&context.override_date) + .and_time(NaiveTime::from_hms(time[0..2].parse::().unwrap(), + time[3..5].parse::().unwrap(), + time[6..8].parse::().unwrap())) + .single() + .expect("Transformed log times can't be represented, due to timezone transitions") + .timestamp() + } + fn join(s: &[&str], splits: &[char]) -> String { + let len = s.iter().map(|s| s.len()).sum(); + 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(); out + } + fn mask(s: &str) -> String { + if s.len() >= 2 { s[1..(s.len() - 1)].to_owned() } else { String::new() } + } + + loop { + self.buffer.clear(); + match self.input.read_line(&mut self.buffer) { + Ok(0) | Err(_) => return None, + Ok(_) => () + } + + let mut split_tokens: Vec = Vec::new(); + let tokens = self.buffer.split( |c: char| { + if c.is_whitespace() { split_tokens.push(c); true } else { false } + }).collect::>(); + if log_enabled!(Info) { + info!("Original: `{}`", self.buffer); + info!("Parsing: {:?}", tokens); + } + match tokens[..tokens.len() - 1].as_ref() { + [time, "*", nick, content..] => return Some(Ok(Event::Action { + from: nick.to_owned(), content: join(content, &split_tokens[3..]), + time: timestamp(&self.context, &mask(time)) + })), + [time, "***", old, "is", "now", "known", "as", new] => return Some(Ok(Event::Nick { + old: old.to_owned(), new: new.to_owned(), + time: timestamp(&self.context, &mask(time)) + })), + [time, "***", "Joins:", nick, host] => return Some(Ok(Event::Join { + nick: nick.to_owned(), mask: mask(host) + })), + [time, "***", "Quits:", nick, host, reason..] => return Some(Ok(Event::Quit { + nick: nick.to_owned(), mask: mask(host), + reason: mask(&join(reason, &split_tokens[5..])), + time: timestamp(&self.context, &mask(time)) + })), + [time, nick, content..] + if nick.starts_with('<') && nick.ends_with('>') + => return Some(Ok(Event::Msg { + from: mask(nick), content: join(content, &split_tokens[2..]), + time: timestamp(&self.context, &mask(time)) + })), + _ => () + } + } + } +} + +impl<'a, R: 'a> Decode<'a, R, Iter<'a, R>> for Energymech where R: BufRead { + fn decode(&'a mut self, context: &'a Context, input: R) -> Iter { + Iter { + context: context, + input: input, + buffer: String::new() + } + } +} + +impl<'a, W> Encode<'a, W> for Energymech where W: Write { + fn encode(&'a self, context: &'a Context, mut output: W, event: &'a Event) -> ::Result<()> { + fn date(t: i64) -> String { + format!("[{}]", UTC.timestamp(t, 0).format(TIME_FORMAT)) + } + match event { + &Event::Msg { ref from, ref content, ref time } => { + try!(writeln!(&mut output, "{} <{}> {}", date(*time), from, content)) + }, + &Event::Action { ref from, ref content, ref time } => { + try!(writeln!(&mut output, "{} * {} {}", date(*time), from, content)) + }, + &Event::Nick { ref old, ref new, ref time } => { + try!(writeln!(&mut output, "{} *** {} is now known as {}", date(*time), old, new)) + }, + &Event::Quit { ref nick, ref mask, ref reason, ref time } => { + try!(writeln!(&mut output, "{} *** Quits: {} ({}) ({})", date(*time), nick, mask, reason)) + }, + _ => () + } + Ok(()) + } +} -- cgit v1.2.3 From 27e53e57777fac2fe47f1a2610d0122dc60ed97d Mon Sep 17 00:00:00 2001 From: Till Hoeppner Date: Thu, 11 Jun 2015 18:28:44 +0200 Subject: Adapt energymech to new Event API --- src/format/energymech.rs | 100 ++++++++++++++++++++++++++++------------------- 1 file changed, 59 insertions(+), 41 deletions(-) (limited to 'src/format/energymech.rs') diff --git a/src/format/energymech.rs b/src/format/energymech.rs index a044344..c52a654 100644 --- a/src/format/energymech.rs +++ b/src/format/energymech.rs @@ -13,12 +13,12 @@ // limitations under the License. use std::io::{ BufRead, Write }; -use std::borrow::ToOwned; +use std::borrow::{ ToOwned, Cow }; use std::iter::{ Iterator }; -use event::{ Event, rejoin }; +use event::{ Event, Type, Time }; use context::Context; -use format::{ Encode, Decode }; +use format::{ Encode, Decode, rejoin, strip_one }; use l::LogLevel::Info; @@ -37,23 +37,14 @@ pub struct Iter<'a, R: 'a> where R: BufRead { impl<'a, R: 'a> Iterator for Iter<'a, R> where R: BufRead { type Item = ::Result>; fn next(&mut self) -> Option<::Result>> { - fn timestamp(context: &Context, time: &str) -> i64 { - context.timezone.from_local_date(&context.override_date) - .and_time(NaiveTime::from_hms(time[0..2].parse::().unwrap(), - time[3..5].parse::().unwrap(), - time[6..8].parse::().unwrap())) + fn parse_time(context: &Context, time: &str) -> Time { + Time::Timestamp(context.timezone.from_local_date(&context.override_date) + .and_time(NaiveTime::from_hms(time[1..3].parse::().unwrap(), + time[4..6].parse::().unwrap(), + time[7..9].parse::().unwrap())) .single() .expect("Transformed log times can't be represented, due to timezone transitions") - .timestamp() - } - fn join(s: &[&str], splits: &[char]) -> String { - let len = s.iter().map(|s| s.len()).sum(); - 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(); out - } - fn mask(s: &str) -> String { - if s.len() >= 2 { s[1..(s.len() - 1)].to_owned() } else { String::new() } + .timestamp()) } loop { @@ -72,27 +63,48 @@ impl<'a, R: 'a> Iterator for Iter<'a, R> where R: BufRead { info!("Parsing: {:?}", tokens); } match tokens[..tokens.len() - 1].as_ref() { - [time, "*", nick, content..] => return Some(Ok(Event::Action { - from: nick.to_owned(), content: join(content, &split_tokens[3..]), - time: timestamp(&self.context, &mask(time)) + [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: None })), - [time, "***", old, "is", "now", "known", "as", new] => return Some(Ok(Event::Nick { - old: old.to_owned(), new: new.to_owned(), - time: timestamp(&self.context, &mask(time)) + [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: None })), - [time, "***", "Joins:", nick, host] => return Some(Ok(Event::Join { - nick: nick.to_owned(), mask: mask(host) + [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: None })), - [time, "***", "Quits:", nick, host, reason..] => return Some(Ok(Event::Quit { - nick: nick.to_owned(), mask: mask(host), - reason: mask(&join(reason, &split_tokens[5..])), - time: timestamp(&self.context, &mask(time)) + [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: None })), [time, nick, content..] if nick.starts_with('<') && nick.ends_with('>') - => return Some(Ok(Event::Msg { - from: mask(nick), content: join(content, &split_tokens[2..]), - time: timestamp(&self.context, &mask(time)) + => 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: None })), _ => () } @@ -116,17 +128,23 @@ impl<'a, W> Encode<'a, W> for Energymech where W: Write { format!("[{}]", UTC.timestamp(t, 0).format(TIME_FORMAT)) } match event { - &Event::Msg { ref from, ref content, ref time } => { - try!(writeln!(&mut output, "{} <{}> {}", date(*time), from, content)) + &Event { ty: Type::Msg { ref from, ref content }, ref time, .. } => { + try!(writeln!(&mut output, "{} <{}> {}", + time.with_format(&context.timezone, TIME_FORMAT), from, content)) }, - &Event::Action { ref from, ref content, ref time } => { - try!(writeln!(&mut output, "{} * {} {}", date(*time), 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::Nick { ref old, ref new, ref time } => { - try!(writeln!(&mut output, "{} *** {} is now known as {}", date(*time), old, new)) + &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::Quit { ref nick, ref mask, ref reason, ref time } => { - try!(writeln!(&mut output, "{} *** Quits: {} ({}) ({})", date(*time), nick, mask, reason)) + &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."))) }, _ => () } -- cgit v1.2.3 From ccc9f5e8eaa84579da610ea0d90d18596078bac7 Mon Sep 17 00:00:00 2001 From: Till Hoeppner Date: Thu, 11 Jun 2015 20:56:59 +0200 Subject: Fix binaries and eliminate warnings --- src/format/energymech.rs | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) (limited to 'src/format/energymech.rs') diff --git a/src/format/energymech.rs b/src/format/energymech.rs index c52a654..e6f7d80 100644 --- a/src/format/energymech.rs +++ b/src/format/energymech.rs @@ -13,7 +13,7 @@ // limitations under the License. use std::io::{ BufRead, Write }; -use std::borrow::{ ToOwned, Cow }; +use std::borrow::{ ToOwned }; use std::iter::{ Iterator }; use event::{ Event, Type, Time }; @@ -62,7 +62,7 @@ impl<'a, R: 'a> Iterator for Iter<'a, R> where R: BufRead { info!("Original: `{}`", self.buffer); info!("Parsing: {:?}", tokens); } - match tokens[..tokens.len() - 1].as_ref() { + match &tokens[..tokens.len() - 1] { [time, "*", nick, content..] => return Some(Ok(Event { ty: Type::Action { from: nick.to_owned().into(), @@ -124,24 +124,21 @@ impl<'a, R: 'a> Decode<'a, R, Iter<'a, R>> for Energymech where R: BufRead { impl<'a, W> Encode<'a, W> for Energymech where W: Write { fn encode(&'a self, context: &'a Context, mut output: W, event: &'a Event) -> ::Result<()> { - fn date(t: i64) -> String { - format!("[{}]", UTC.timestamp(t, 0).format(TIME_FORMAT)) - } match event { &Event { ty: Type::Msg { ref from, ref content }, ref time, .. } => { - try!(writeln!(&mut output, "{} <{}> {}", + 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, "{} * {} {}", + 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 {}", + try!(writeln!(&mut output, "[{}] *** {} is now known as {}", time.with_format(&context.timezone, TIME_FORMAT), old_nick, new_nick)) }, &Event { ty: Type::Quit { ref nick, ref mask, ref reason }, ref time, .. } => { - try!(writeln!(&mut output, "{} *** Quits: {} ({}) ({})", + 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."))) -- cgit v1.2.3