start extracting khevent

10 files changed, 82 insertions, 51 deletions

diff --git a/src/actions/agenda.rs b/src/actions/agenda.rs
index 22e27c2..b56d274 100644
--- a/src/actions/agenda.rs
+++ b/src/actions/agenda.rs
@@ -7,6 +7,7 @@ use crate::cursorfile;
 use crate::icalwrap::*;
 use crate::input;
 use crate::config::{Config,CalendarConfig};
+use crate::khevent::KhEvent;
 use crate::khline::KhLine;
 use crate::KhResult;
 
@@ -44,7 +45,7 @@ pub fn show_events_cursor(
   let start_day = match cals_iter.peek() {
     Some((_, event, _)) => {
       event
-        .get_dtstart()
+        .get_start()
         .map(|dtstart| dtstart.into())
         .unwrap_or_else(|| Local.timestamp(0, 0))
         .date()
@@ -143,7 +144,7 @@ pub fn event_line(
     Ok(format!("{:3}             {}", cursor_icon, summary))
   } else {
     let mut time_sep = " ";
-    let dtstart: DateTime<Local> = event.get_dtstart().ok_or("Invalid DTSTART")?.into();
+    let dtstart: DateTime<Local> = event.get_start().ok_or("Invalid DTSTART")?.into();
     let start_string = if dtstart.date() != cur_day {
       "".to_string()
     } else {
@@ -151,7 +152,7 @@ pub fn event_line(
       format!("{}", dtstart.format("%H:%M"))
     };
 
-    let dtend: DateTime<Local> = event.get_dtend().ok_or("Invalid DTEND")?.into();
+    let dtend: DateTime<Local> = event.get_end().ok_or("Invalid DTEND")?.into();
     let end_string = if dtend.date() != cur_day {
       "".to_string()
     } else {
@@ -165,12 +166,12 @@ pub fn event_line(
 
 impl IcalVEvent {
   fn starts_on(&self, date: Date<Local>) -> bool {
-    let dtstart: Date<Local> = self.get_dtstart().unwrap().into();
+    let dtstart: Date<Local> = self.get_start().unwrap().into();
     dtstart == date
   }
 
   fn relevant_on(&self, date: Date<Local>) -> bool {
-    let dtstart: Option<Date<Local>> = self.get_dtstart().map(|date| date.into());
+    let dtstart: Option<Date<Local>> = self.get_start().map(|date| date.into());
     let last_relevant_date: Option<Date<Local>> = self.get_last_relevant_date().map(|date| date.into());
 
     dtstart.map(|dtstart| dtstart <= date).unwrap_or(false) &&
diff --git a/src/actions/index/bucketable.rs b/src/actions/index/bucketable.rs
index 9eaa812..299d055 100644
--- a/src/actions/index/bucketable.rs
+++ b/src/actions/index/bucketable.rs
@@ -5,6 +5,7 @@ use std::{hash, cmp};
 use crate::icalwrap::{IcalVEvent, IcalVCalendar};
 use crate::utils::misc;
 use crate::khline::KhLine;
+use crate::khevent::KhEvent;
 
 pub trait Bucketable {
   fn get_buckets(&self) -> Result<HashMap<String, Vec<String>>, String>;
@@ -25,8 +26,8 @@ impl Bucketable for IcalVEvent {
   fn get_buckets(&self) -> Result<HashMap<String, Vec<String>>, String> {
     let mut result:  HashMap<String, Vec<String>> = HashMap::new();
 
-    let start_date: Date<Local> = self.get_dtstart().ok_or_else(|| format!("Invalid DTSTART in {}", self.get_uid()))?.into();
-    let mut end_date: Date<Local> = self.get_dtend().map(|date| date.into()).unwrap_or(start_date);
+    let start_date: Date<Local> = self.get_start().ok_or_else(|| format!("Invalid DTSTART in {}", self.get_uid()))?.into();
+    let mut end_date: Date<Local> = self.get_end().map(|date| date.into()).unwrap_or(start_date);
 
     // end-dtimes are non-inclusive
     // so in case of date-only events, the last day of the event is dtend-1
diff --git a/src/actions/new.rs b/src/actions/new.rs
index e8c9cea..100e375 100644
--- a/src/actions/new.rs
+++ b/src/actions/new.rs
@@ -145,6 +145,7 @@ mod integration {
   use super::*;
   use crate::testutils;
   use crate::testdata;
+  use crate::khevent::KhEvent;
 
   #[test]
   fn test_parse_calendar() {
@@ -265,8 +266,8 @@ mod integration {
       .with_eventprops(&ep);
 
     let event = cal.get_principal_event();
-    assert_eq!(Some(from), event.get_dtstart());
-    assert_eq!(Some(to), event.get_dtend());
+    assert_eq!(Some(from), event.get_start());
+    assert_eq!(Some(to), event.get_end());
     assert_eq!(summary, event.get_summary().unwrap());
     assert_eq!(location, event.get_location().unwrap());
   }
diff --git a/src/actions/unroll.rs b/src/actions/unroll.rs
index 7c1bece..27f4e10 100644
--- a/src/actions/unroll.rs
+++ b/src/actions/unroll.rs
@@ -3,6 +3,7 @@ use structopt::StructOpt;
 
 use crate::khline::KhLine;
 use crate::KhResult;
+use crate::khevent::KhEvent;
 
 #[derive(Debug, StructOpt)]
 pub struct UnrollArgs {
diff --git a/src/icalwrap/icalvcalendar.rs b/src/icalwrap/icalvcalendar.rs
index 2228503..91a2018 100644
--- a/src/icalwrap/icalvcalendar.rs
+++ b/src/icalwrap/icalvcalendar.rs
@@ -368,6 +368,7 @@ impl Drop for IcalComponentOwner {
 mod tests {
   use super::*;
   use crate::testdata;
+  use crate::khevent::KhEvent;
   use chrono::{Local,TimeZone};
 
   #[test]
@@ -512,7 +513,7 @@ mod tests {
     let new_cal = cal.with_dtend(&timestamp);
 
     let event = new_cal.get_principal_event();
-    assert_eq!(timestamp, event.get_dtend().unwrap())
+    assert_eq!(timestamp, event.get_end().unwrap())
   }
 
   #[test]
@@ -524,7 +525,7 @@ mod tests {
     let new_cal = cal.with_dtstart(&timestamp);
 
     let event = new_cal.get_principal_event();
-    assert_eq!(timestamp, event.get_dtstart().unwrap())
+    assert_eq!(timestamp, event.get_start().unwrap())
   }
 
   #[test]
@@ -538,8 +539,8 @@ mod tests {
     let new_cal = cal.with_dtstart(&timestamp);
 
     let event = new_cal.get_principal_event();
-    assert_eq!(timestamp, event.get_dtstart().unwrap());
-    assert_eq!("Europe/Berlin", event.get_dtstart().unwrap().get_timezone().unwrap().get_name());
+    assert_eq!(timestamp, event.get_start().unwrap());
+    assert_eq!("Europe/Berlin", event.get_start().unwrap().get_timezone().unwrap().get_name());
   }
 
   #[test]
@@ -550,7 +551,7 @@ mod tests {
     let new_cal = cal.with_internal_timestamp(&timestamp);
 
     let event = new_cal.get_principal_event();
-    assert_eq!(timestamp, event.get_dtstart().unwrap());
+    assert_eq!(timestamp, event.get_start().unwrap());
   }
 
   #[test]
diff --git a/src/icalwrap/icalvevent.rs b/src/icalwrap/icalvevent.rs
index fdaa487..1494f03 100644
--- a/src/icalwrap/icalvevent.rs
+++ b/src/icalwrap/icalvevent.rs
@@ -6,6 +6,7 @@ use super::IcalTime;
 use super::IcalTimeZone;
 use super::IcalDuration;
 use crate::ical;
+use crate::khevent::KhEvent;
 
 pub struct IcalVEvent {
   ptr: *mut ical::icalcomponent,
@@ -31,6 +32,34 @@ impl IcalComponent for IcalVEvent {
   }
 }
 
+impl KhEvent for IcalVEvent {
+  fn get_start(&self) -> Option<IcalTime> {
+    //TODO: should probably depend on is_recur_master, not the instance timestamp
+    match self.instance_timestamp {
+      Some(ref timestamp) => Some(timestamp.clone()),
+      None => {
+        self.get_dtstart()
+      }
+    }
+  }
+
+  fn get_end(&self) -> Option<IcalTime> {
+    //TODO: should probably depend on is_recur_master, not the instance timestamp
+    match self.instance_timestamp {
+      Some(ref timestamp) => unsafe {
+        let icalduration = ical::icalcomponent_get_duration(self.ptr);
+        let dtend = ical::icaltime_add(**timestamp, icalduration);
+        Some(IcalTime::from(dtend))
+      },
+      None => self.get_dtend()
+    }
+  }
+
+  fn is_recur_master(&self) -> bool {
+    self.has_property_rrule() && self.instance_timestamp.is_none()
+  }
+}
+
 impl IcalVEvent {
   pub fn from_ptr_with_parent(
       ptr: *mut ical::icalcomponent,
@@ -44,22 +73,14 @@ impl IcalVEvent {
   }
 
   pub fn get_dtend(&self) -> Option<IcalTime> {
-    match self.instance_timestamp {
-      Some(ref timestamp) => unsafe {
-        let icalduration = ical::icalcomponent_get_duration(self.ptr);
-        let dtend = ical::icaltime_add(**timestamp, icalduration);
+    unsafe {
+      let dtend = ical::icalcomponent_get_dtend(self.ptr);
+      trace!("{:?}", dtend);
+      if ical::icaltime_is_null_time(dtend) == 1 {
+        None
+      } else {
         Some(IcalTime::from(dtend))
-      },
-      None =>
-        unsafe {
-          let dtend = ical::icalcomponent_get_dtend(self.ptr);
-          trace!("{:?}", dtend);
-          if ical::icaltime_is_null_time(dtend) == 1 {
-            None
-          } else {
-            Some(IcalTime::from(dtend))
-          }
-        }
+      }
     }
   }
 
@@ -75,15 +96,12 @@ impl IcalVEvent {
   }
 
   pub fn get_dtstart(&self) -> Option<IcalTime> {
-    match self.instance_timestamp {
-      Some(ref timestamp) => Some(timestamp.clone()),
-      None => unsafe {
-        let dtstart = ical::icalcomponent_get_dtstart(self.ptr);
-        if ical::icaltime_is_null_time(dtstart) == 1 {
-          None
-        } else {
-          Some(IcalTime::from(dtstart))
-        }
+    unsafe {
+      let dtstart = ical::icalcomponent_get_dtstart(self.ptr);
+      if ical::icaltime_is_null_time(dtstart) == 1 {
+        None
+      } else {
+        Some(IcalTime::from(dtstart))
       }
     }
   }
@@ -96,11 +114,7 @@ impl IcalVEvent {
     }
   }
 
-  pub fn is_recur_master(&self) -> bool {
-    self.is_recur() && self.instance_timestamp.is_none()
-  }
-
-  pub fn is_recur(&self) -> bool {
+  pub fn has_property_rrule(&self) -> bool {
     !self.get_properties(ical::icalproperty_kind_ICAL_RRULE_PROPERTY).is_empty()
   }
 
@@ -349,8 +363,8 @@ mod tests {
     let event = cal.get_principal_event();
     let mut recur_instances = event.get_recur_instances();
     let local = IcalTimeZone::local();
-    assert_eq!(IcalTime::floating_ymd(2018, 10, 11).with_timezone(&local), recur_instances.next().unwrap().get_dtstart().unwrap());
-    assert_eq!(IcalTime::floating_ymd(2018, 10, 18).with_timezone(&local), recur_instances.next().unwrap().get_dtstart().unwrap());
+    assert_eq!(IcalTime::floating_ymd(2018, 10, 11).with_timezone(&local), recur_instances.next().unwrap().get_start().unwrap());
+    assert_eq!(IcalTime::floating_ymd(2018, 10, 18).with_timezone(&local), recur_instances.next().unwrap().get_start().unwrap());
   }
 
   #[test]
diff --git a/src/khevent.rs b/src/khevent.rs
new file mode 100644
index 0000000..b3c10a2
--- /dev/null
+++ b/src/khevent.rs
@@ -0,0 +1,9 @@
+use crate::icalwrap::IcalTime;
+
+pub trait KhEvent {
+  fn get_start(&self) -> Option<IcalTime>;
+  fn get_end(&self) -> Option<IcalTime>;
+  fn is_recur_master(&self) -> bool;
+}
+
+
diff --git a/src/khline.rs b/src/khline.rs
index 314cdde..ffb79a3 100644
--- a/src/khline.rs
+++ b/src/khline.rs
@@ -6,6 +6,7 @@ use std::str::FromStr;
 use crate::icalwrap::{IcalVCalendar,IcalVEvent,IcalTime};
 use crate::utils::{fileutil,dateutil};
 use crate::defaults;
+use crate::khevent::KhEvent;
 
 #[derive(PartialEq,Eq,Debug)]
 pub struct KhLine {
@@ -65,7 +66,7 @@ impl KhLine {
 impl From<&IcalVEvent> for KhLine {
   fn from(event: &IcalVEvent) -> Self {
     let path = event.get_parent().unwrap().get_path().unwrap().to_path_buf();
-    let time = event.get_dtstart();
+    let time = event.get_start();
 
     KhLine{ path, time, index: None }
   }
@@ -250,7 +251,7 @@ mod tests {
       testdir.child(".khaleesi/cal/twodaysacrossbuckets.ics").path(),
       event.get_parent().unwrap().get_path().unwrap()
     );
-    assert_eq!(12345, event.get_dtstart().unwrap().timestamp());
+    assert_eq!(12345, event.get_start().unwrap().timestamp());
   }
 
   #[test]
@@ -266,7 +267,7 @@ mod tests {
     );
     assert_eq!(
       IcalTime::floating_ymd(2018, 12, 13).and_hms(23, 30, 00),
-      event.get_dtstart().unwrap()
+      event.get_start().unwrap()
     );
   }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 0eeab59..0214d41 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -13,6 +13,7 @@ pub mod defaults;
 pub mod edit;
 pub mod icalwrap;
 pub mod input;
+pub mod khevent;
 pub mod khline;
 pub mod selectors;
 pub mod seqfile;
diff --git a/src/selectors/mod.rs b/src/selectors/mod.rs
index 8cb57a0..940c1b3 100644
--- a/src/selectors/mod.rs
+++ b/src/selectors/mod.rs
@@ -2,6 +2,7 @@ use std::collections::HashMap;
 
 use crate::khline::{KhLine,khlines_to_events};
 use crate::icalwrap::IcalVEvent;
+use crate::khevent::KhEvent;
 
 use self::daterange::{SelectFilterFrom,SelectFilterTo};
 use self::cal::CalendarFilter;
@@ -91,13 +92,13 @@ impl SelectFilters {
   }
 
   fn line_is_from(&self, event: &IcalVEvent) -> bool {
-    let starts_after = self.from.includes_date(event.get_dtstart().unwrap().into());
-    let ends_after = self.from.includes_date(event.get_dtend().unwrap().into());
+    let starts_after = self.from.includes_date(event.get_start().unwrap().into());
+    let ends_after = self.from.includes_date(event.get_end().unwrap().into());
     starts_after || ends_after
   }
 
   fn line_is_to(&self, event: &IcalVEvent) -> bool {
-    self.to.includes_date(event.get_dtstart().unwrap().into())
+    self.to.includes_date(event.get_start().unwrap().into())
   }
 
   fn filter_index(&self, index: usize) -> bool {