path: root/src/icaltool.rs

// 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::{NaiveDateTime, 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<NaiveDateTime> {
    if let Some(mut dt) = datetime {
        if dt.is_empty() {
            return None;
        }

        if !dt.contains('T') {
            dt += "T000000";
        }
        NaiveDateTime::parse_from_str(&dt, "%Y%m%dT%H%M%S").ok()
    }
    else {
        None
    }
}

fn print_event(event: &IcalEvent) {
    let mut start: Option<NaiveDateTime> = None;
    let mut end: Option<NaiveDateTime> = None;
    let mut summary = String::new();
    let mut description = 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(),
            "DESCRIPTION" => description = p.value.clone().unwrap_or_default(),
            _ => (),
        }
    }

    println!("---> {} - {}: {}",
        start.unwrap_or_else(|| Utc::now().naive_utc()),
        end.unwrap_or_else(|| Utc::now().naive_utc()),
        summary);

    if description.len() > 0 {
        println!("{}", description);
    }

}

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(|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());
}