Move business logic out of main.

2 files changed, 176 insertions, 141 deletions

diff --git a/src/icaltool.rs b/src/icaltool.rs
new file mode 100644
index 0000000..6776c0b
--- /dev/null
+++ b/src/icaltool.rs
@@ -0,0 +1,171 @@
+// icaltool - a tool to get information out of ical/ics files.
+// Copyright (C) 2018  Harald Eilertsen <haraldei@anduin.net>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use chrono::{DateTime, TimeZone, Utc};
+use ical::{
+    IcalParser,
+    parser::ical::component::{
+        IcalCalendar,
+        IcalEvent,
+    },
+};
+use regex::RegexBuilder;
+use std::error::Error;
+use std::fs::File;
+use std::io::BufReader;
+use std::path::PathBuf;
+
+pub struct Icaltool {
+    filename: PathBuf,
+    pattern: String,
+}
+
+impl Icaltool {
+    pub fn run() -> Result<(), Box<dyn Error>> {
+        let icaltool = Self::parse_args()?;
+
+        let calendars = icaltool.read_icalendar_from_file()?;
+        println!("Found {} calendard in file...", calendars.len());
+
+        for c in calendars {
+            for e in c.events.iter().filter(|e| match_event(&e, &icaltool.pattern)) {
+                print_event(&e);
+            }
+        }
+
+        Ok(())
+    }
+
+    fn parse_args() -> Result<Icaltool, Box<dyn Error>> {
+        let mut args = std::env::args().skip(1);
+
+        let filename = args.next().ok_or("Missing filename")?.into();
+        let pattern = args.next().ok_or("Missing pattern.")?;
+
+        Ok(Icaltool{ filename, pattern })
+    }
+
+    fn read_icalendar_from_file(&self) -> std::io::Result<Vec<IcalCalendar>> {
+        let buf = BufReader::new(File::open(&self.filename)?);
+        Ok(IcalParser::new(buf)
+            .filter_map(|c| c.ok())
+            .collect())
+    }
+}
+
+fn parse_datetime(datetime: Option<String>) -> Option<DateTime<Utc>> {
+    if let Some(mut dt) = datetime {
+        if dt.is_empty() {
+            return None;
+        }
+
+        if !dt.contains('T') {
+            dt += "T000000";
+        }
+        Utc.datetime_from_str(&dt, "%Y%m%dT%H%M%S").ok()
+    }
+    else {
+        None
+    }
+}
+
+fn print_event(event: &IcalEvent) {
+    let mut start: Option<DateTime<Utc>> = None;
+    let mut end: Option<DateTime<Utc>> = None;
+    let mut summary = String::new();
+
+    for p in &event.properties {
+        match p.name.as_ref() {
+            "DTSTART" => start = parse_datetime(p.value.clone()),
+            "DTEND"   => end = parse_datetime(p.value.clone()),
+            "SUMMARY" => summary = p.value.clone().unwrap_or_default(),
+            _ => (),
+        }
+    }
+
+    println!("---> {} - {}: {}",
+        start.unwrap_or_else(Utc::now),
+        end.unwrap_or_else(Utc::now),
+        summary);
+}
+
+fn match_event(event: &IcalEvent, pattern: &str) -> bool {
+    if pattern == "*" {
+        true
+    }
+    else {
+        let parts: Vec<&str> = pattern.split(':').collect();
+
+        let (key, pat) = if parts.len() == 2 {
+            (parts[0].to_uppercase(), parts[1])
+        } else {
+            (String::from("*"), parts[0])
+        };
+
+        let re = RegexBuilder::new(&pat)
+            .case_insensitive(true)
+            .build()
+            .unwrap();
+
+        event.properties.iter()
+            .filter(|ref p| (&key == "*" || p.name == key) && re.is_match(&p.value.clone().unwrap()))
+            .count() > 0
+    }
+}
+
+#[cfg(test)]
+fn test_match_event_helper(pattern: &str) -> Vec<IcalEvent> {
+    let icaltool = Icaltool {
+        filename: PathBuf::from("test/fixtures/events.ics"),
+        pattern: String::new(),
+    };
+
+    let cal = icaltool.read_icalendar_from_file().unwrap();
+    cal[0].events.iter()
+        .filter_map(|event| {
+            if match_event(&event, pattern) {
+                Some(event.clone())
+            }
+            else {
+                None
+            }
+        })
+        .collect()
+}
+
+#[test]
+fn match_all_events() {
+    let events:Vec<_> = test_match_event_helper("*");
+    assert_eq!(3, events.len());
+}
+
+#[test]
+fn match_events_by_summary() {
+    let events:Vec<_> = test_match_event_helper("summary:All");
+    assert_eq!(2, events.len());
+}
+
+#[test]
+fn match_events_by_regex() {
+    let events:Vec<_> = test_match_event_helper("summary:^All.+1$");
+    assert_eq!(1, events.len());
+}
+
+#[test]
+fn match_events_regardless_of_case() {
+    let events:Vec<_> = test_match_event_helper("summary:^aLl.+1$");
+    assert_eq!(1, events.len());
+}
diff --git a/src/main.rs b/src/main.rs
index 30534dc..5030857 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -14,149 +14,13 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-use ical;
-use chrono::{DateTime, TimeZone, Utc};
-use regex::RegexBuilder;
-use std::error::Error;
-use std::fs::File;
-use std::io::BufReader;
-use std::path::{Path, PathBuf};
+mod icaltool;
 
-fn parse_datetime(datetime: Option<String>) -> Option<DateTime<Utc>> {
-    if let Some(mut dt) = datetime {
-        if dt.is_empty() {
-            return None;
-        }
-
-        if !dt.contains('T') {
-            dt += "T000000";
-        }
-        Utc.datetime_from_str(&dt, "%Y%m%dT%H%M%S").ok()
-    }
-    else {
-        None
-    }
-}
-
-fn print_event(event: &ical::parser::ical::component::IcalEvent) {
-    let mut start: Option<DateTime<Utc>> = None;
-    let mut end: Option<DateTime<Utc>> = None;
-    let mut summary = String::new();
-
-    for p in &event.properties {
-        match p.name.as_ref() {
-            "DTSTART" => start = parse_datetime(p.value.clone()),
-            "DTEND"   => end = parse_datetime(p.value.clone()),
-            "SUMMARY" => summary = p.value.clone().unwrap_or_default(),
-            _ => (),
-        }
-    }
-
-    println!("---> {} - {}: {}",
-        start.unwrap_or_else(Utc::now),
-        end.unwrap_or_else(Utc::now),
-        summary);
-}
-
-fn read_icalendar_from_file(filename: &Path) -> std::io::Result<Vec<ical::parser::ical::component::IcalCalendar>> {
-    let buf = BufReader::new(File::open(filename)?);
-    Ok(ical::IcalParser::new(buf)
-        .filter_map(|c| c.ok())
-        .collect())
-}
-
-fn match_event(event: &ical::parser::ical::component::IcalEvent, pattern: &str) -> bool {
-    if pattern == "*" {
-        true
-    }
-    else {
-        let parts: Vec<&str> = pattern.split(':').collect();
-
-        let (key, pat) = if parts.len() == 2 {
-            (parts[0].to_uppercase(), parts[1])
-        } else {
-            (String::from("*"), parts[0])
-        };
-
-        let re = RegexBuilder::new(&pat)
-            .case_insensitive(true)
-            .build()
-            .unwrap();
-
-        event.properties.iter()
-            .filter(|ref p| (&key == "*" || p.name == key) && re.is_match(&p.value.clone().unwrap()))
-            .count() > 0
-    }
-}
-
-#[cfg(test)]
-fn test_match_event_helper(pattern: &str) -> Vec<ical::parser::ical::component::IcalEvent> {
-    let cal = read_icalendar_from_file(&PathBuf::from("test/fixtures/events.ics")).unwrap();
-    cal[0].events.iter()
-        .filter_map(|event| {
-            if match_event(&event, pattern) {
-                Some(event.clone())
-            }
-            else {
-                None
-            }
-        })
-        .collect()
-}
-
-#[test]
-fn match_all_events() {
-    let events:Vec<_> = test_match_event_helper("*");
-    assert_eq!(3, events.len());
-}
-
-#[test]
-fn match_events_by_summary() {
-    let events:Vec<_> = test_match_event_helper("summary:All");
-    assert_eq!(2, events.len());
-}
-
-#[test]
-fn match_events_by_regex() {
-    let events:Vec<_> = test_match_event_helper("summary:^All.+1$");
-    assert_eq!(1, events.len());
-}
-
-#[test]
-fn match_events_regardless_of_case() {
-    let events:Vec<_> = test_match_event_helper("summary:^aLl.+1$");
-    assert_eq!(1, events.len());
-}
-
-struct IcaltoolArgs {
-    filename: PathBuf,
-    pattern: String,
-}
-
-fn parse_args() -> Result<IcaltoolArgs, Box<dyn Error>> {
-    let mut args = std::env::args().skip(1);
-
-    let filename = args.next().ok_or("Missing filename")?.into();
-    let pattern = args.next().ok_or("Missing pattern.")?;
-
-    Ok(IcaltoolArgs{ filename, pattern })
-}
+use icaltool::Icaltool;
 
 fn main() {
-    match parse_args() {
-        Ok(args) => {
-            let calendars = read_icalendar_from_file(&args.filename).unwrap();
-            println!("Found {} calendard in file...", calendars.len());
-
-            for c in calendars {
-                for e in c.events.iter().filter(|e| match_event(&e, &args.pattern)) {
-                    print_event(&e);
-                }
-            }
-        },
-        Err(e) => {
-            println!("[-] Error: {}", e);
-            println!("Usage: icaltool <filename> <patterns>");
-        }
+    if let Err(e) = Icaltool::run() {
+        println!("[-] Error: {}", e);
+        println!("Usage: icaltool <filename> <patterns>");
     }
 }