1 files changed, 171 insertions, 0 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());
+}