Test CI

1 files changed, 89 insertions, 49 deletions

diff --git a/src/app/mod.rs b/src/app/mod.rs
index 3221ec9..9b02b1e 100644
--- a/src/app/mod.rs
+++ b/src/app/mod.rs
@@ -7,16 +7,16 @@ use glob::glob;
 
 use std::process;
 use std::str::FromStr;
-use std::path::{ Path, PathBuf };
-use std::io::{ self, Write, BufWriter, BufRead, BufReader };
+use std::path::{Path, PathBuf};
+use std::io::{self, BufRead, BufReader, BufWriter, Write};
 use std::fs::File;
 use std::error::Error;
 use std::ffi::OsStr;
 
 use ilc::context::Context;
-use ilc::format::{ self, Encode, Decode };
+use ilc::format::{self, Decode, Encode};
 
-use ::chain;
+use chain;
 
 pub mod freq;
 
@@ -38,43 +38,47 @@ pub fn die(s: &str) -> ! {
 pub fn force_decoder(s: Option<&str>) -> Box<Decode> {
     let inf = match s {
         Some(s) => s,
-        None => die("You didn't specify the input format")
+        None => die("You didn't specify the input format"),
     };
     match format::decoder(&inf) {
         Some(d) => d,
-        None => die(&format!("The format `{}` is unknown to me", inf))
+        None => die(&format!("The format `{}` is unknown to me", inf)),
     }
 }
 
 pub fn force_encoder<'a>(s: Option<&str>) -> Box<Encode> {
     let outf = match s {
         Some(s) => s,
-        None => die("You didn't specify the output format")
+        None => die("You didn't specify the output format"),
     };
     match format::encoder(&outf) {
         Some(e) => e,
-        None => die(&format!("The format `{}` is unknown to me", outf))
+        None => die(&format!("The format `{}` is unknown to me", outf)),
     }
 }
 
 pub fn build_context(args: &ArgMatches) -> Context {
     let mut context = Context {
-        timezone: FixedOffset::west(args.value_of("timezone").and_then(|s| s.parse().ok()).unwrap_or(0)),
+        timezone: FixedOffset::west(args.value_of("timezone")
+                                        .and_then(|s| s.parse().ok())
+                                        .unwrap_or(0)),
         override_date: args.value_of("date").and_then(|d| NaiveDate::from_str(&d).ok()),
-        channel: args.value_of("channel").map(str::to_owned).clone()
+        channel: args.value_of("channel").map(str::to_owned).clone(),
     };
     if args.is_present("infer_date") {
         let input_files = gather_input(args);
         match input_files.len() {
             0 => die("No input files given, can't infer date"),
-            1 => if let Some(date) = input_files.get(0)
-                .map(PathBuf::as_path)
-                .and_then(Path::file_stem)
-                .and_then(OsStr::to_str)
-                .and_then(|s: &str| NaiveDate::from_str(s).ok()) {
-                context.override_date = Some(date);
-            },
-            _n => die("Too many input files, can't infer date")
+            1 => {
+                if let Some(date) = input_files.get(0)
+                                               .map(PathBuf::as_path)
+                                               .and_then(Path::file_stem)
+                                               .and_then(OsStr::to_str)
+                                               .and_then(|s: &str| NaiveDate::from_str(s).ok()) {
+                    context.override_date = Some(date);
+                }
+            }
+            _n => die("Too many input files, can't infer date"),
         }
     }
     context
@@ -83,17 +87,23 @@ pub fn build_context(args: &ArgMatches) -> Context {
 pub fn gather_input(args: &ArgMatches) -> Vec<PathBuf> {
     if let Some(iter) = args.values_of("input_files") {
         iter.flat_map(|p| {
-            match glob(p) {
-                Ok(paths) => paths,
-                Err(e) => die(&format!("{}", e.msg))
-            }
-        }).filter_map(Result::ok).collect()
-    } else { Vec::new() }
+                match glob(p) {
+                    Ok(paths) => paths,
+                    Err(e) => die(&format!("{}", e.msg)),
+                }
+            })
+            .filter_map(Result::ok)
+            .collect()
+    } else {
+        Vec::new()
+    }
 }
 
 pub fn open_files(files: Vec<PathBuf>) -> Box<BufRead> {
     if files.len() > 0 {
-        Box::new(BufReader::new(chain::Chain::new(files.iter().map(|p| File::open(p).unwrap()).collect())))
+        Box::new(BufReader::new(chain::Chain::new(files.iter()
+                                                       .map(|p| File::open(p).unwrap())
+                                                       .collect())))
     } else {
         Box::new(BufReader::new(io::stdin()))
     }
@@ -103,7 +113,7 @@ pub fn open_output(args: &ArgMatches) -> Box<Write> {
     if let Some(out) = args.value_of("output_file") {
         match File::create(out) {
             Ok(f) => Box::new(BufWriter::new(f)),
-            Err(e) => error(Box::new(e))
+            Err(e) => error(Box::new(e)),
         }
     } else {
         Box::new(BufWriter::new(io::stdout()))
@@ -113,11 +123,21 @@ pub fn open_output(args: &ArgMatches) -> Box<Write> {
 pub struct Environment<'a>(pub &'a ArgMatches<'a>);
 
 impl<'a> Environment<'a> {
-    pub fn context(&self) -> Context { build_context(self.0) }
-    pub fn input(&self) -> Box<BufRead> { open_files(gather_input(self.0)) }
-    pub fn output(&self) -> Box<Write> { open_output(self.0) }
-    pub fn decoder(&self) -> Box<Decode> { force_decoder(self.0.value_of("input_format")) }
-    pub fn encoder(&self) -> Box<Encode> { force_encoder(self.0.value_of("output_format")) }
+    pub fn context(&self) -> Context {
+        build_context(self.0)
+    }
+    pub fn input(&self) -> Box<BufRead> {
+        open_files(gather_input(self.0))
+    }
+    pub fn output(&self) -> Box<Write> {
+        open_output(self.0)
+    }
+    pub fn decoder(&self) -> Box<Decode> {
+        force_decoder(self.0.value_of("format").or(self.0.value_of("input_format")))
+    }
+    pub fn encoder(&self) -> Box<Encode> {
+        force_encoder(self.0.value_of("format").or(self.0.value_of("output_format")))
+    }
 }
 
 pub mod parse {
@@ -128,8 +148,11 @@ pub mod parse {
         let (context, mut decoder, mut input) = (env.context(), env.decoder(), env.input());
         for e in decoder.decode(&context, &mut input) {
             match e {
-                Err(e) => { println!("Foo!"); error(Box::new(e)) },
-                _ => ()
+                Err(e) => {
+                    println!("Foo!");
+                    error(Box::new(e))
+                }
+                _ => (),
             }
         }
     }
@@ -140,13 +163,18 @@ pub mod convert {
     use super::*;
     pub fn convert(args: &ArgMatches) {
         let env = Environment(args);
-        let (context, mut decoder, mut input, encoder, mut output) =
-            (env.context(), env.decoder(), env.input(), env.encoder(), env.output());
+        let (context, mut decoder, mut input, encoder, mut output) = (env.context(),
+                                                                      env.decoder(),
+                                                                      env.input(),
+                                                                      env.encoder(),
+                                                                      env.output());
 
         for e in decoder.decode(&context, &mut input) {
             match e {
-                Ok(e) => { let _ = encoder.encode(&context, &mut output, &e); },
-                Err(e) => error(Box::new(e))
+                Ok(e) => {
+                    let _ = encoder.encode(&context, &mut output, &e);
+                }
+                Err(e) => error(Box::new(e)),
             }
         }
     }
@@ -155,11 +183,14 @@ pub mod convert {
 pub mod seen {
     use clap::ArgMatches;
     use ilc::event::Event;
-    use ilc::format::{ self, Encode };
+    use ilc::format::{self, Encode};
     use super::*;
     pub fn seen(args: &ArgMatches) {
         let env = Environment(args);
-        let (context, mut decoder, mut input, mut output) = (env.context(), env.decoder(), env.input(), env.output());
+        let (context, mut decoder, mut input, mut output) = (env.context(),
+                                                             env.decoder(),
+                                                             env.input(),
+                                                             env.output());
 
         let nick = args.value_of("nick").expect("Required argument <nick> not present");
 
@@ -167,11 +198,14 @@ pub mod seen {
         for e in decoder.decode(&context, &mut input) {
             let m = match e {
                 Ok(m) => m,
-                Err(err) => error(Box::new(err))
+                Err(err) => error(Box::new(err)),
             };
 
-            if m.ty.involves(nick)
-            && last.as_ref().map_or(true, |last| m.time.as_timestamp() > last.time.as_timestamp()) { last = Some(m) }
+            if m.ty.involves(nick) &&
+               last.as_ref().map_or(true,
+                                    |last| m.time.as_timestamp() > last.time.as_timestamp()) {
+                last = Some(m)
+            }
         }
         let encoder = format::Weechat;
         if let Some(ref m) = last {
@@ -186,12 +220,15 @@ pub mod sort {
     use super::*;
     pub fn sort(args: &ArgMatches) {
         let env = Environment(args);
-        let (context, mut decoder, mut input, encoder, mut output) =
-            (env.context(), env.decoder(), env.input(), env.encoder(), env.output());
+        let (context, mut decoder, mut input, encoder, mut output) = (env.context(),
+                                                                      env.decoder(),
+                                                                      env.input(),
+                                                                      env.encoder(),
+                                                                      env.output());
 
         let mut events: Vec<Event> = decoder.decode(&context, &mut input)
-            .flat_map(Result::ok)
-            .collect();
+                                            .flat_map(Result::ok)
+                                            .collect();
 
         events.sort_by(|a, b| a.time.cmp(&b.time));
         for e in events {
@@ -203,12 +240,15 @@ pub mod sort {
 pub mod dedup {
     use clap::ArgMatches;
     use ilc::event::NoTimeHash;
-    use ::ageset::AgeSet;
+    use ageset::AgeSet;
     use super::*;
     pub fn dedup(args: &ArgMatches) {
         let env = Environment(args);
-        let (context, mut decoder, mut input, encoder, mut output) =
-            (env.context(), env.decoder(), env.input(), env.encoder(), env.output());
+        let (context, mut decoder, mut input, encoder, mut output) = (env.context(),
+                                                                      env.decoder(),
+                                                                      env.input(),
+                                                                      env.encoder(),
+                                                                      env.output());
 
         let mut backlog = AgeSet::new();