Implement basic structure for task evaluation

src/eval.rs

@@ -1,12 +1,13 @@
+use std::cmp;
 use std::result;
 
 use chrono::{Datelike, NaiveDate};
 
-use crate::eval::entry::EntryDate;
-use crate::files::commands::{Birthday, Command, Note, Spec, Task};
+use crate::files::commands::{Birthday, Command, DoneDate, Note, Spec, Task};
 use crate::files::{Files, Source, SourcedCommand};
 
-use self::entry::{Entry, EntryKind, EntryMap};
+use self::entry::EntryMap;
+pub use self::entry::{Entry, EntryKind};
 pub use self::range::DateRange;
 
 mod delta;
@@ -30,43 +31,136 @@ impl Eval {
     fn eval_spec(
         &mut self,
         spec: &Spec,
-        new_entry: impl Fn(Source, EntryDate) -> Entry,
+        last_done: Option<NaiveDate>,
+        new_entry: impl Fn(Source, Option<DoneDate>) -> Entry,
     ) -> Result<()> {
         todo!()
     }
 
+    fn eval_dones(&mut self, task: &Task) {
+        for done in &task.done {
+            let entry = Entry {
+                kind: EntryKind::TaskDone(done.done_at),
+                title: task.title.clone(),
+                desc: task.desc.clone(),
+                source: self.source,
+                date: done.date,
+            };
+            self.map.insert(entry);
+        }
+    }
+
+    fn determine_last_done(task: &Task) -> Option<NaiveDate> {
+        task.done
+            .iter()
+            .flat_map(|done| done.date.iter())
+            .map(|d| d.root())
+            .max()
+    }
+
+    fn determine_task_range(&self, task: &Task, last_done: Option<NaiveDate>) -> Option<DateRange> {
+        let mut from = self.map.range.from();
+        let mut until = self.map.range.until();
+
+        if let Some(last_done) = last_done {
+            from = cmp::min(from, last_done);
+        }
+
+        if let Some(task_from) = task.from {
+            from = cmp::max(from, task_from);
+        }
+        if let Some(task_until) = task.until {
+            until = cmp::min(until, task_until);
+        }
+
+        if from <= until {
+            Some(DateRange::new(from, until))
+        } else {
+            None
+        }
+    }
+
+    fn eval_task(&mut self, task: &Task) -> Result<()> {
+        self.eval_dones(task);
+
+        if task.done.iter().any(|done| done.date.is_none()) {
+            return Ok(());
+        }
+
+        if task.when.is_empty() {
+            self.map.insert(Entry {
+                kind: EntryKind::Task,
+                title: task.title.clone(),
+                desc: task.desc.clone(),
+                source: self.source,
+                date: None,
+            });
+        } else {
+            let last_done = Self::determine_last_done(task);
+
+            if let Some(range) = self.determine_task_range(task, last_done) {
+                self.map.range = range;
+            } else {
+                return Ok(());
+            }
+
+            for except in &task.except {
+                self.map.block(*except);
+            }
+
+            for spec in &task.when {
+                self.eval_spec(spec, last_done, |source, date| Entry {
+                    kind: EntryKind::Note,
+                    title: task.title.clone(),
+                    desc: task.desc.clone(),
+                    source,
+                    date,
+                })?;
+            }
+        }
+        Ok(())
+    }
+
+    fn determine_note_range(&self, note: &Note) -> Option<DateRange> {
+        let mut from = self.map.range.from();
+        let mut until = self.map.range.until();
+
+        if let Some(task_from) = note.from {
+            from = cmp::max(from, task_from);
+        }
+        if let Some(task_until) = note.until {
+            until = cmp::max(until, task_until);
+        }
+
+        if from <= until {
+            Some(DateRange::new(from, until))
+        } else {
+            None
+        }
+    }
+
     fn eval_note(&mut self, note: &Note) -> Result<()> {
         if note.when.is_empty() {
-            let entry = Entry {
+            self.map.insert(Entry {
                 kind: EntryKind::Note,
                 title: note.title.clone(),
                 desc: note.desc.clone(),
                 source: self.source,
-                date: EntryDate::None,
-            };
-            self.map.insert(entry);
+                date: None,
+            });
         } else {
-            if let Some(from) = note.from {
-                if self.map.range().until() < from {
-                    return Ok(());
-                }
-                if self.map.range().from() < from {
-                    self.map.set_from(from);
-                }
-            }
-            if let Some(until) = note.until {
-                if until < self.map.range().from() {
-                    return Ok(());
-                }
-                if until < self.map.range().until() {
-                    self.map.set_until(until);
-                }
+            if let Some(range) = self.determine_note_range(note) {
+                self.map.range = range;
+            } else {
+                return Ok(());
             }
+
             for except in &note.except {
                 self.map.block(*except);
             }
+
             for spec in &note.when {
-                self.eval_spec(spec, |source, date| Entry {
+                self.eval_spec(spec, None, |source, date| Entry {
                     kind: EntryKind::Note,
                     title: note.title.clone(),
                     desc: note.desc.clone(),
@@ -79,7 +173,7 @@ impl Eval {
     }
 
     fn eval_birthday(&mut self, birthday: &Birthday) {
-        for year in self.map.range().years() {
+        for year in self.map.range.years() {
             let when = &birthday.when;
             let mut title = birthday.title.clone();
 
@@ -97,7 +191,7 @@ impl Eval {
                     title: title.clone(),
                     desc: birthday.desc.clone(),
                     source: self.source,
-                    date: EntryDate::Date { root: date },
+                    date: Some(DoneDate::Date { root: date }),
                 };
                 self.map.insert(entry);
             } else {
@@ -110,7 +204,7 @@ impl Eval {
                     title: format!("{} (first half)", title),
                     desc: birthday.desc.clone(),
                     source: self.source,
-                    date: EntryDate::Date { root: date },
+                    date: Some(DoneDate::Date { root: date }),
                 };
                 self.map.insert(entry);
 
@@ -120,7 +214,7 @@ impl Eval {
                     title: format!("{} (second half)", title),
                     desc: birthday.desc.clone(),
                     source: self.source,
-                    date: EntryDate::Date { root: date },
+                    date: Some(DoneDate::Date { root: date }),
                 };
                 self.map.insert(entry);
             }