Use simpler date type for entries

src/eval.rs

@@ -7,6 +7,7 @@ pub use self::error::{Error, Result};
 pub use self::range::DateRange;
 
 mod command;
+mod date;
 mod delta;
 mod entry;
 mod error;

src/eval/date.rs

@@ -0,0 +1,77 @@
+use chrono::NaiveDate;
+
+use crate::files::commands::Time;
+
+#[derive(Debug, Clone, Copy)]
+pub struct Times {
+    start: Time,
+    end: Time,
+}
+
+impl Times {
+    pub fn start(&self) -> Time {
+        self.start
+    }
+
+    pub fn end(&self) -> Time {
+        self.end
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Dates {
+    start: NaiveDate,
+    end: NaiveDate,
+    times: Option<Times>,
+}
+
+impl Dates {
+    pub fn new(start: NaiveDate, end: NaiveDate) -> Self {
+        assert!(start <= end);
+        Self {
+            start,
+            end,
+            times: None,
+        }
+    }
+
+    pub fn new_with_time(
+        start: NaiveDate,
+        end: NaiveDate,
+        start_time: Time,
+        end_time: Time,
+    ) -> Self {
+        assert!(start <= end);
+        if start == end {
+            assert!(start_time <= end_time);
+        }
+        Self {
+            start,
+            end,
+            times: Some(Times {
+                start: start_time,
+                end: end_time,
+            }),
+        }
+    }
+
+    pub fn start(&self) -> NaiveDate {
+        self.start
+    }
+
+    pub fn end(&self) -> NaiveDate {
+        self.start
+    }
+
+    pub fn times(&self) -> Option<Times> {
+        self.times
+    }
+
+    pub fn start_time(&self) -> Option<Time> {
+        self.times.as_ref().map(Times::start)
+    }
+
+    pub fn end_time(&self) -> Option<Time> {
+        self.times.as_ref().map(Times::end)
+    }
+}

src/eval/entry.rs

@@ -1,8 +1,8 @@
 use chrono::NaiveDate;
 
-use crate::files::commands::DoneDate;
 use crate::files::Source;
 
+use super::date::Dates;
 use super::range::DateRange;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -21,7 +21,8 @@ pub struct Entry {
     pub desc: Vec<String>,
 
     pub source: Source,
-    pub root: Option<DoneDate>,
+    pub dates: Option<Dates>,
+    pub root: Option<NaiveDate>,
 }
 
 /// Mode that determines how entries are filtered when they are added to
@@ -57,22 +58,22 @@ impl Entries {
 
     fn is_rooted(&self, entry: &Entry) -> bool {
         match entry.root {
-            Some(date) => self.range.contains(date.root()),
+            Some(date) => self.range.contains(date),
             None => false,
         }
     }
 
     fn is_touching(&self, entry: &Entry) -> bool {
-        if let Some(date) = entry.root {
+        if let Some(dates) = entry.dates {
             // Inside the range or overlapping it
-            date.first() <= self.range.until() && self.range.from() <= date.last()
+            dates.start() <= self.range.until() && self.range.from() <= dates.end()
         } else {
             false
         }
     }
 
     fn is_relevant(&self, entry: &Entry) -> bool {
-        if entry.root.is_none() {
+        if entry.dates.is_none() {
             return true;
         }
 
@@ -90,14 +91,14 @@ impl Entries {
 
         // Unfinished tasks before or inside the range
         if let EntryKind::Task = entry.kind {
-            if let Some(date) = entry.root {
-                if date.first() <= self.range.until() {
+            if let Some(dates) = entry.dates {
+                if dates.start() <= self.range.until() {
                     return true;
                 }
             }
         }
 
-        return false;
+        false
     }
 
     pub fn add(&mut self, entry: Entry) {