From fe22c66c5c7cc8210f9c59fec27e9ef9b90338a5 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Tue, 21 Dec 2021 00:13:06 +0100
Subject: [PATCH 01/80] Parse REMINDs

---
 src/files/commands.rs  |  1 +
 src/files/format.rs    |  2 ++
 src/files/grammar.pest |  3 ++-
 src/files/parse.rs     | 12 ++++++++++++
 4 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/src/files/commands.rs b/src/files/commands.rs
index 80a9065..a699ce3 100644
--- a/src/files/commands.rs
+++ b/src/files/commands.rs
@@ -267,6 +267,7 @@ pub enum Statement {
         from: NaiveDate,
         to: NaiveDate,
     },
+    Remind(Option<Spanned<Delta>>),
 }
 
 #[derive(Debug, Clone, Copy)]
diff --git a/src/files/format.rs b/src/files/format.rs
index 81fa4e0..a7764f4 100644
--- a/src/files/format.rs
+++ b/src/files/format.rs
@@ -221,6 +221,8 @@ impl fmt::Display for Statement {
             Statement::Until(None) => writeln!(f, "UNTIL *"),
             Statement::Except(date) => writeln!(f, "EXCEPT {}", date),
             Statement::Move { from, to, .. } => writeln!(f, "MOVE {} TO {}", from, to),
+            Statement::Remind(Some(delta)) => writeln!(f, "REMIND {}", delta),
+            Statement::Remind(None) => writeln!(f, "REMIND *"),
         }
     }
 }
diff --git a/src/files/grammar.pest b/src/files/grammar.pest
index c999230..d071cbb 100644
--- a/src/files/grammar.pest
+++ b/src/files/grammar.pest
@@ -107,8 +107,9 @@ stmt_from = !{ "FROM" ~ (datum | "*") ~ eol }
 stmt_until = !{ "UNTIL" ~ (datum | "*") ~ eol }
 stmt_except = !{ "EXCEPT" ~ datum ~ eol }
 stmt_move = !{ "MOVE" ~ datum ~ "TO" ~ datum ~ eol }
+stmt_remind = !{ "REMIND" ~ (delta | "*") ~ eol }
 
-statements = { (stmt_date | stmt_bdate | stmt_from | stmt_until | stmt_except | stmt_move)* }
+statements = { (stmt_date | stmt_bdate | stmt_from | stmt_until | stmt_except | stmt_move | stmt_remind)* }
 
 donedate = {
     datum ~ time ~ "--" ~ datum ~ time
diff --git a/src/files/parse.rs b/src/files/parse.rs
index d8807b9..cfcaaf6 100644
--- a/src/files/parse.rs
+++ b/src/files/parse.rs
@@ -623,6 +623,17 @@ fn parse_stmt_move(p: Pair<'_, Rule>) -> Result<Statement> {
     Ok(Statement::Move { span, from, to })
 }
 
+fn parse_stmt_remind(p: Pair<'_, Rule>) -> Result<Statement> {
+    assert_eq!(p.as_rule(), Rule::stmt_remind);
+    let mut p = p.into_inner();
+    let delta = match p.next() {
+        Some(p) => Some(parse_delta(p)?),
+        None => None,
+    };
+    assert_eq!(p.next(), None);
+    Ok(Statement::Remind(delta))
+}
+
 fn parse_statements(p: Pair<'_, Rule>, task: bool) -> Result<Vec<Statement>> {
     assert_eq!(p.as_rule(), Rule::statements);
     let mut statements = vec![];
@@ -635,6 +646,7 @@ fn parse_statements(p: Pair<'_, Rule>, task: bool) -> Result<Vec<Statement>> {
             Rule::stmt_until => parse_stmt_until(p)?,
             Rule::stmt_except => parse_stmt_except(p)?,
             Rule::stmt_move => parse_stmt_move(p)?,
+            Rule::stmt_remind => parse_stmt_remind(p)?,
             _ => unreachable!(),
         });
     }

From 66da16f4e309281d4aad48954c53551b374bf625 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Tue, 21 Dec 2021 00:14:14 +0100
Subject: [PATCH 02/80] Evaluate REMINDs

---
 src/eval/command.rs          | 75 ++++++++++++++++++++++++++++--------
 src/eval/command/birthday.rs | 15 +++++---
 src/eval/command/date.rs     |  8 ++--
 src/eval/command/formula.rs  |  4 +-
 src/eval/entry.rs            | 19 ++++++++-
 src/eval/error.rs            | 23 +++++++++++
 6 files changed, 115 insertions(+), 29 deletions(-)

diff --git a/src/eval/command.rs b/src/eval/command.rs
index cec8e2d..8bdac96 100644
--- a/src/eval/command.rs
+++ b/src/eval/command.rs
@@ -2,11 +2,14 @@ use std::collections::HashMap;
 
 use chrono::NaiveDate;
 
-use crate::files::commands::{BirthdaySpec, Command, Done, DoneDate, Note, Spec, Statement, Task};
-use crate::files::primitives::Span;
+use crate::files::commands::{
+    self, BirthdaySpec, Command, Done, DoneDate, Note, Spec, Statement, Task,
+};
+use crate::files::primitives::{Span, Spanned};
 use crate::files::SourcedCommand;
 
 use super::date::Dates;
+use super::delta::Delta;
 use super::{DateRange, Entry, EntryKind, Error, Result};
 
 mod birthday;
@@ -19,6 +22,7 @@ pub struct CommandState<'a> {
 
     from: Option<NaiveDate>,
     until: Option<NaiveDate>,
+    remind: Option<Spanned<Delta>>,
 
     dated: HashMap<NaiveDate, Entry>,
     undated: Vec<Entry>,
@@ -44,6 +48,7 @@ impl<'a> CommandState<'a> {
             command,
             from: None,
             until: None,
+            remind: None,
             dated: HashMap::new(),
             undated: Vec::new(),
         }
@@ -73,6 +78,13 @@ impl<'a> CommandState<'a> {
         }
     }
 
+    fn range_with_remind(&self) -> DateRange {
+        match &self.remind {
+            None => self.range,
+            Some(delta) => self.range.expand_by(&delta.value),
+        }
+    }
+
     /// Last root date mentioned in any `DONE`.
     fn last_done_root(&self) -> Option<NaiveDate> {
         match self.command.command {
@@ -113,11 +125,31 @@ impl<'a> CommandState<'a> {
         }
     }
 
+    fn entry_with_remind(&self, kind: EntryKind, dates: Option<Dates>) -> Result<Entry> {
+        let remind = if let (Some(dates), Some(delta)) = (dates, &self.remind) {
+            let index = self.command.source.file();
+            let start = dates.sorted().root();
+            let remind = delta.value.apply_date(index, dates.sorted().root())?;
+            if remind >= start {
+                return Err(Error::RemindDidNotMoveBackwards {
+                    index,
+                    span: delta.span,
+                    from: start,
+                    to: remind,
+                });
+            }
+            Some(remind)
+        } else {
+            None
+        };
+
+        Ok(Entry::new(self.command.source, kind, dates, remind))
+    }
+
     /// Add an entry, respecting [`Self::from`] and [`Self::until`]. Does not
     /// overwrite existing entries if a root date is specified.
-    fn add(&mut self, kind: EntryKind, dates: Option<Dates>) {
-        let entry = Entry::new(self.command.source, kind, dates);
-        if let Some(dates) = dates {
+    fn add(&mut self, entry: Entry) {
+        if let Some(dates) = entry.dates {
             let root = dates.root();
             if let Some(from) = self.from {
                 if root < from {
@@ -137,9 +169,8 @@ impl<'a> CommandState<'a> {
 
     /// Add an entry, ignoring [`Self::from`] and [`Self::until`]. Always
     /// overwrites existing entries if a root date is specified.
-    fn add_forced(&mut self, kind: EntryKind, dates: Option<Dates>) {
-        let entry = Entry::new(self.command.source, kind, dates);
-        if let Some(dates) = dates {
+    fn add_forced(&mut self, entry: Entry) {
+        if let Some(dates) = entry.dates {
             self.dated.insert(dates.root(), entry);
         } else {
             self.undated.push(entry);
@@ -160,11 +191,11 @@ impl<'a> CommandState<'a> {
                 self.eval_statement(statement)?;
             }
         } else if task.done.is_empty() {
-            self.add(self.kind(), None);
+            self.add(self.entry_with_remind(self.kind(), None)?);
         }
 
         for done in &task.done {
-            self.eval_done(done);
+            self.eval_done(done)?;
         }
 
         Ok(())
@@ -176,7 +207,7 @@ impl<'a> CommandState<'a> {
                 self.eval_statement(statement)?;
             }
         } else {
-            self.add(self.kind(), None);
+            self.add(self.entry_with_remind(self.kind(), None)?);
         }
 
         Ok(())
@@ -185,11 +216,12 @@ impl<'a> CommandState<'a> {
     fn eval_statement(&mut self, statement: &Statement) -> Result<()> {
         match statement {
             Statement::Date(spec) => self.eval_date(spec)?,
-            Statement::BDate(spec) => self.eval_bdate(spec),
+            Statement::BDate(spec) => self.eval_bdate(spec)?,
             Statement::From(date) => self.from = *date,
             Statement::Until(date) => self.until = *date,
             Statement::Except(date) => self.eval_except(*date),
             Statement::Move { span, from, to } => self.eval_move(*span, *from, *to)?,
+            Statement::Remind(delta) => self.eval_remind(delta),
         }
         Ok(())
     }
@@ -202,8 +234,8 @@ impl<'a> CommandState<'a> {
         }
     }
 
-    fn eval_bdate(&mut self, spec: &BirthdaySpec) {
-        self.eval_birthday_spec(spec);
+    fn eval_bdate(&mut self, spec: &BirthdaySpec) -> Result<()> {
+        self.eval_birthday_spec(spec)
     }
 
     fn eval_except(&mut self, date: NaiveDate) {
@@ -226,10 +258,19 @@ impl<'a> CommandState<'a> {
         }
     }
 
-    fn eval_done(&mut self, done: &Done) {
-        self.add_forced(
+    fn eval_remind(&mut self, delta: &Option<Spanned<commands::Delta>>) {
+        if let Some(delta) = delta {
+            self.remind = Some(Spanned::new(delta.span, (&delta.value).into()));
+        } else {
+            self.remind = None;
+        }
+    }
+
+    fn eval_done(&mut self, done: &Done) -> Result<()> {
+        self.add_forced(self.entry_with_remind(
             EntryKind::TaskDone(done.done_at),
             done.date.map(|date| date.into()),
-        );
+        )?);
+        Ok(())
     }
 }
diff --git a/src/eval/command/birthday.rs b/src/eval/command/birthday.rs
index 829160e..b10d83f 100644
--- a/src/eval/command/birthday.rs
+++ b/src/eval/command/birthday.rs
@@ -4,13 +4,14 @@ use crate::files::commands::BirthdaySpec;
 
 use super::super::command::CommandState;
 use super::super::date::Dates;
+use super::super::error::Result;
 use super::super::EntryKind;
 
 impl<'a> CommandState<'a> {
-    pub fn eval_birthday_spec(&mut self, spec: &BirthdaySpec) {
-        let range = match self.limit_from_until(self.range) {
+    pub fn eval_birthday_spec(&mut self, spec: &BirthdaySpec) -> Result<()> {
+        let range = match self.limit_from_until(self.range_with_remind()) {
             Some(range) => range,
-            None => return,
+            None => return Ok(()),
         };
 
         for year in range.years() {
@@ -26,15 +27,19 @@ impl<'a> CommandState<'a> {
             let kind = EntryKind::Birthday(age);
 
             if let Some(date) = spec.date.with_year(year) {
-                self.add(EntryKind::Birthday(age), Some(Dates::new(date, date)));
+                self.add(
+                    self.entry_with_remind(EntryKind::Birthday(age), Some(Dates::new(date, date)))?,
+                );
             } else {
                 assert_eq!(spec.date.month(), 2);
                 assert_eq!(spec.date.day(), 29);
 
                 let first = NaiveDate::from_ymd(year, 2, 28);
                 let second = NaiveDate::from_ymd(year, 3, 1);
-                self.add(kind, Some(Dates::new(first, second)));
+                self.add(self.entry_with_remind(kind, Some(Dates::new(first, second)))?);
             }
         }
+
+        Ok(())
     }
 }
diff --git a/src/eval/command/date.rs b/src/eval/command/date.rs
index 9fe1292..8ef5ff6 100644
--- a/src/eval/command/date.rs
+++ b/src/eval/command/date.rs
@@ -84,7 +84,7 @@ impl DateSpec {
                     .map(|date| date.succ())
                     .unwrap_or(self.start);
                 let range = s
-                    .range
+                    .range_with_remind()
                     .expand_by(&self.end_delta)
                     .move_by(&self.start_delta)
                     .with_from(range_from)?;
@@ -93,7 +93,7 @@ impl DateSpec {
             Command::Note(_) => {
                 let start = self.start;
                 let range = s
-                    .range
+                    .range_with_remind()
                     .expand_by(&self.end_delta)
                     .move_by(&self.start_delta);
                 (start, false, range)
@@ -142,13 +142,13 @@ impl<'a> CommandState<'a> {
                 }
                 while start <= range.until() {
                     let dates = spec.dates(index, start)?;
-                    self.add(self.kind(), Some(dates));
+                    self.add(self.entry_with_remind(self.kind(), Some(dates))?);
                     start = DateSpec::step(index, start, repeat)?;
                 }
             }
         } else {
             let dates = spec.dates(index, spec.start)?;
-            self.add(self.kind(), Some(dates));
+            self.add(self.entry_with_remind(self.kind(), Some(dates))?);
         }
         Ok(())
     }
diff --git a/src/eval/command/formula.rs b/src/eval/command/formula.rs
index 43f7d21..5ecc6a2 100644
--- a/src/eval/command/formula.rs
+++ b/src/eval/command/formula.rs
@@ -324,7 +324,7 @@ impl From<&commands::WeekdaySpec> for FormulaSpec {
 impl FormulaSpec {
     fn range(&self, s: &CommandState<'_>) -> Option<DateRange> {
         let mut range = s
-            .range
+            .range_with_remind()
             .expand_by(&self.end_delta)
             .move_by(&self.start_delta);
 
@@ -367,7 +367,7 @@ impl<'a> CommandState<'a> {
             for day in range.days() {
                 if spec.eval(index, day)? {
                     let dates = spec.dates(index, day)?;
-                    self.add(self.kind(), Some(dates));
+                    self.add(self.entry_with_remind(self.kind(), Some(dates))?);
                 }
             }
         }
diff --git a/src/eval/entry.rs b/src/eval/entry.rs
index cdfb0f8..d3daf26 100644
--- a/src/eval/entry.rs
+++ b/src/eval/entry.rs
@@ -19,14 +19,31 @@ pub struct Entry {
     pub source: Source,
     pub kind: EntryKind,
     pub dates: Option<Dates>,
+    /// Remind the user of an entry before it occurs. This date should always be
+    /// before the entry's start date, or `None` if there is no start date.
+    pub remind: Option<NaiveDate>,
 }
 
 impl Entry {
-    pub fn new(source: Source, kind: EntryKind, dates: Option<Dates>) -> Self {
+    pub fn new(
+        source: Source,
+        kind: EntryKind,
+        dates: Option<Dates>,
+        remind: Option<NaiveDate>,
+    ) -> Self {
+        if let Some(dates) = dates {
+            if let Some(remind) = remind {
+                assert!(remind < dates.sorted().root());
+            }
+        } else {
+            assert!(remind.is_none());
+        }
+
         Self {
             source,
             kind,
             dates,
+            remind,
         }
     }
 
diff --git a/src/eval/error.rs b/src/eval/error.rs
index 16fdf5c..b485143 100644
--- a/src/eval/error.rs
+++ b/src/eval/error.rs
@@ -34,6 +34,16 @@ pub enum Error {
         from: NaiveDate,
         to: NaiveDate,
     },
+    /// A `REMIND`'s delta did not move backwards in time from the entry's start
+    /// date. Instead, it either remained at the start date (`to == from`) or
+    /// moved forwards in time (`from < to`).
+    #[error("remind delta did not move backwards")]
+    RemindDidNotMoveBackwards {
+        index: usize,
+        span: Span,
+        from: NaiveDate,
+        to: NaiveDate,
+    },
     /// A `MOVE a TO b` statement was executed, but there was no entry at the
     /// date `a`.
     #[error("tried to move nonexisting entry")]
@@ -135,6 +145,19 @@ impl Error {
                 );
                 Self::print_at(sources, index, span, msg);
             }
+            Error::RemindDidNotMoveBackwards {
+                index,
+                span,
+                from,
+                to,
+            } => {
+                let msg = format!(
+                    "Remind delta did not move backwards\
+                    \nMoved from {} to {}",
+                    from, to
+                );
+                Self::print_at(sources, index, span, msg);
+            }
             Error::MoveWithoutSource { index, span } => {
                 let msg = "Tried to move nonexisting entry".to_string();
                 Self::print_at(sources, index, span, msg);

From 05a4582f13dd6e5a54a333251e59c3b2597506c3 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Tue, 21 Dec 2021 00:14:28 +0100
Subject: [PATCH 03/80] Display reminders correctly

---
 CHANGELOG.md          |  5 +++++
 src/cli/layout/day.rs | 11 +++++++----
 2 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a494d90..c0b9fae 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,11 @@
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## Unreleased
+
+### Added
+- `REMIND` statement
+
 ## 0.1.0 - 2021-12-20
 
 ### Added
diff --git a/src/cli/layout/day.rs b/src/cli/layout/day.rs
index 0cb4c0b..71b2016 100644
--- a/src/cli/layout/day.rs
+++ b/src/cli/layout/day.rs
@@ -81,10 +81,13 @@ impl DayLayout {
     fn layout_task(&mut self, index: usize, entry: &Entry) {
         if let Some(dates) = entry.dates {
             let (start, end) = dates.sorted().dates();
-            if self.today < start && (start - self.today).num_days() < 7 {
-                // TODO Make this adjustable, maybe even per-command
-                let days = (start - self.today).num_days();
-                self.insert(self.today, DayEntry::ReminderUntil(index, days));
+            if self.today < start {
+                if let Some(remind) = entry.remind {
+                    if remind <= self.today {
+                        let days = (start - self.today).num_days();
+                        self.insert(self.today, DayEntry::ReminderUntil(index, days));
+                    }
+                }
             } else if start < self.today && self.today < end {
                 let days = (end - self.today).num_days();
                 self.insert(self.today, DayEntry::ReminderWhile(index, days));

From 1ac39c69f238cb949b88865daff155760b05e1e5 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Tue, 21 Dec 2021 19:24:27 +0100
Subject: [PATCH 04/80] Move entries to a different time

---
 CHANGELOG.md            |  1 +
 src/eval/command.rs     | 39 +++++++++++++++++++++++++++++++--------
 src/eval/date.rs        | 21 +++++++++++++++++----
 src/eval/delta.rs       |  8 ++++----
 src/files/commands.rs   |  3 ++-
 src/files/format.rs     |  9 ++++++++-
 src/files/grammar.pest  |  2 +-
 src/files/parse.rs      | 20 +++++++++++++++++---
 src/files/primitives.rs | 22 ++++++++++++++++++----
 9 files changed, 99 insertions(+), 26 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c0b9fae..d12e3d9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ### Added
 - `REMIND` statement
+- `MOVE` entries to a different time
 
 ## 0.1.0 - 2021-12-20
 
diff --git a/src/eval/command.rs b/src/eval/command.rs
index 8bdac96..b277a7d 100644
--- a/src/eval/command.rs
+++ b/src/eval/command.rs
@@ -1,11 +1,11 @@
 use std::collections::HashMap;
 
-use chrono::NaiveDate;
+use chrono::{Duration, NaiveDate};
 
 use crate::files::commands::{
     self, BirthdaySpec, Command, Done, DoneDate, Note, Spec, Statement, Task,
 };
-use crate::files::primitives::{Span, Spanned};
+use crate::files::primitives::{Span, Spanned, Time};
 use crate::files::SourcedCommand;
 
 use super::date::Dates;
@@ -220,7 +220,12 @@ impl<'a> CommandState<'a> {
             Statement::From(date) => self.from = *date,
             Statement::Until(date) => self.until = *date,
             Statement::Except(date) => self.eval_except(*date),
-            Statement::Move { span, from, to } => self.eval_move(*span, *from, *to)?,
+            Statement::Move {
+                span,
+                from,
+                to,
+                to_time,
+            } => self.eval_move(*span, *from, *to, *to_time)?,
             Statement::Remind(delta) => self.eval_remind(delta),
         }
         Ok(())
@@ -242,13 +247,31 @@ impl<'a> CommandState<'a> {
         self.dated.remove(&date);
     }
 
-    fn eval_move(&mut self, span: Span, from: NaiveDate, to: NaiveDate) -> Result<()> {
+    fn eval_move(
+        &mut self,
+        span: Span,
+        from: NaiveDate,
+        to: Option<NaiveDate>,
+        to_time: Option<Time>,
+    ) -> Result<()> {
         if let Some(mut entry) = self.dated.remove(&from) {
-            if let Some(dates) = entry.dates {
-                let delta = to - from;
-                entry.dates = Some(dates.move_by(delta));
+            let mut dates = entry.dates.expect("comes from self.dated");
+
+            // Determine delta
+            let mut delta = Duration::zero();
+            if let Some(to) = to {
+                delta = delta + (to - dates.root());
             }
-            self.dated.insert(to, entry);
+            if let Some(to_time) = to_time {
+                if let Some((root, _)) = dates.times() {
+                    delta = delta + Duration::minutes(root.minutes_to(to_time));
+                }
+            }
+
+            dates = dates.move_by(delta);
+            entry.dates = Some(dates);
+            self.dated.insert(dates.root(), entry);
+
             Ok(())
         } else {
             Err(Error::MoveWithoutSource {
diff --git a/src/eval/date.rs b/src/eval/date.rs
index 61b2908..da8ce25 100644
--- a/src/eval/date.rs
+++ b/src/eval/date.rs
@@ -103,11 +103,24 @@ impl Dates {
     }
 
     pub fn move_by(&self, delta: Duration) -> Self {
-        Self {
-            root: self.root + delta,
-            other: self.other + delta,
-            times: self.times,
+        let mut result = *self;
+
+        // Modify dates
+        result.root += delta;
+        result.other += delta;
+
+        // Modify times if necessary (may further modify dates)
+        const MINUTES_PER_DAY: i64 = 24 * 60;
+        let minutes = delta.num_minutes() % MINUTES_PER_DAY; // May be negative
+        if let Some(times) = self.times {
+            let (root_days, root) = times.root.add_minutes(minutes);
+            let (other_days, other) = times.other.add_minutes(minutes);
+            result.root += Duration::days(root_days);
+            result.other += Duration::days(other_days);
+            result.times = Some(Times { root, other });
         }
+
+        result
     }
 }
 
diff --git a/src/eval/delta.rs b/src/eval/delta.rs
index ecde59b..dcc1706 100644
--- a/src/eval/delta.rs
+++ b/src/eval/delta.rs
@@ -258,8 +258,8 @@ impl DeltaEval {
             None => return Err(self.err_time(span)),
         };
 
-        let (days, time) = time.add_hours(amount);
-        self.curr += Duration::days(days.into());
+        let (days, time) = time.add_hours(amount.into());
+        self.curr += Duration::days(days);
         self.curr_time = Some(time);
         Ok(())
     }
@@ -270,8 +270,8 @@ impl DeltaEval {
             None => return Err(self.err_time(span)),
         };
 
-        let (days, time) = time.add_minutes(amount);
-        self.curr += Duration::days(days.into());
+        let (days, time) = time.add_minutes(amount.into());
+        self.curr += Duration::days(days);
         self.curr_time = Some(time);
         Ok(())
     }
diff --git a/src/files/commands.rs b/src/files/commands.rs
index a699ce3..90983d0 100644
--- a/src/files/commands.rs
+++ b/src/files/commands.rs
@@ -265,7 +265,8 @@ pub enum Statement {
     Move {
         span: Span,
         from: NaiveDate,
-        to: NaiveDate,
+        to: Option<NaiveDate>,
+        to_time: Option<Time>,
     },
     Remind(Option<Spanned<Delta>>),
 }
diff --git a/src/files/format.rs b/src/files/format.rs
index a7764f4..e169142 100644
--- a/src/files/format.rs
+++ b/src/files/format.rs
@@ -220,7 +220,14 @@ impl fmt::Display for Statement {
             Statement::Until(Some(date)) => writeln!(f, "UNTIL {}", date),
             Statement::Until(None) => writeln!(f, "UNTIL *"),
             Statement::Except(date) => writeln!(f, "EXCEPT {}", date),
-            Statement::Move { from, to, .. } => writeln!(f, "MOVE {} TO {}", from, to),
+            Statement::Move {
+                from, to, to_time, ..
+            } => match (to, to_time) {
+                (None, None) => unreachable!(),
+                (Some(to), None) => writeln!(f, "MOVE {} TO {}", from, to),
+                (None, Some(to_time)) => writeln!(f, "MOVE {} TO {}", from, to_time),
+                (Some(to), Some(to_time)) => writeln!(f, "MOVE {} TO {} {}", from, to, to_time),
+            },
             Statement::Remind(Some(delta)) => writeln!(f, "REMIND {}", delta),
             Statement::Remind(None) => writeln!(f, "REMIND *"),
         }
diff --git a/src/files/grammar.pest b/src/files/grammar.pest
index d071cbb..a2712be 100644
--- a/src/files/grammar.pest
+++ b/src/files/grammar.pest
@@ -106,7 +106,7 @@ stmt_bdate = !{ "BDATE" ~ bdatum ~ eol }
 stmt_from = !{ "FROM" ~ (datum | "*") ~ eol }
 stmt_until = !{ "UNTIL" ~ (datum | "*") ~ eol }
 stmt_except = !{ "EXCEPT" ~ datum ~ eol }
-stmt_move = !{ "MOVE" ~ datum ~ "TO" ~ datum ~ eol }
+stmt_move = !{ "MOVE" ~ datum ~ "TO" ~ (datum ~ time? | time) ~ eol }
 stmt_remind = !{ "REMIND" ~ (delta | "*") ~ eol }
 
 statements = { (stmt_date | stmt_bdate | stmt_from | stmt_until | stmt_except | stmt_move | stmt_remind)* }
diff --git a/src/files/parse.rs b/src/files/parse.rs
index cfcaaf6..3e43ab0 100644
--- a/src/files/parse.rs
+++ b/src/files/parse.rs
@@ -618,9 +618,23 @@ fn parse_stmt_move(p: Pair<'_, Rule>) -> Result<Statement> {
     let span = (&p.as_span()).into();
     let mut p = p.into_inner();
     let from = parse_datum(p.next().unwrap())?.value;
-    let to = parse_datum(p.next().unwrap())?.value;
-    assert_eq!(p.next(), None);
-    Ok(Statement::Move { span, from, to })
+
+    let mut to = None;
+    let mut to_time = None;
+    for p in p {
+        match p.as_rule() {
+            Rule::datum => to = Some(parse_datum(p)?.value),
+            Rule::time => to_time = Some(parse_time(p)?.value),
+            _ => unreachable!(),
+        }
+    }
+
+    Ok(Statement::Move {
+        span,
+        from,
+        to,
+        to_time,
+    })
 }
 
 fn parse_stmt_remind(p: Pair<'_, Rule>) -> Result<Statement> {
diff --git a/src/files/primitives.rs b/src/files/primitives.rs
index d41a2fb..a31b297 100644
--- a/src/files/primitives.rs
+++ b/src/files/primitives.rs
@@ -98,10 +98,15 @@ impl Time {
         true
     }
 
-    pub fn add_minutes(&self, amount: i32) -> (i32, Self) {
+    /// How many minutes into the day this time is.
+    fn minutes(&self) -> i64 {
+        (self.hour as i64) * 60 + (self.min as i64)
+    }
+
+    pub fn add_minutes(&self, amount: i64) -> (i64, Self) {
         match amount.cmp(&0) {
             Ordering::Less => {
-                let mut mins = (self.hour as i32) * 60 + (self.min as i32) + amount;
+                let mut mins = self.minutes() + amount;
 
                 let days = mins.div_euclid(60 * 24);
                 mins = mins.rem_euclid(60 * 24);
@@ -111,7 +116,7 @@ impl Time {
                 (days, Self::new(hour, min))
             }
             Ordering::Greater => {
-                let mut mins = (self.hour as i32) * 60 + (self.min as i32) + amount;
+                let mut mins = self.minutes() + amount;
 
                 let mut days = mins.div_euclid(60 * 24);
                 mins = mins.rem_euclid(60 * 24);
@@ -130,9 +135,18 @@ impl Time {
         }
     }
 
-    pub fn add_hours(&self, amount: i32) -> (i32, Self) {
+    pub fn add_hours(&self, amount: i64) -> (i64, Self) {
         self.add_minutes(amount * 60)
     }
+
+    /// `a.minutes_to(b)` returns the minutes from `a` to `b`, meaning it is
+    /// greater than 0 if `a` is earlier than `b`.
+    ///
+    /// May return weird amounts if [`Self::in_normal_range`] is not true for
+    /// both.
+    pub fn minutes_to(&self, other: Self) -> i64 {
+        other.minutes() - self.minutes()
+    }
 }
 
 #[derive(Debug, Clone, Copy)]

From 73a44a697af03bfeb49f191a739a139b26afc9fc Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Tue, 21 Dec 2021 19:33:55 +0100
Subject: [PATCH 05/80] Error when moving untimed entry to new time

---
 src/eval/command.rs   | 10 ++++++++--
 src/eval/error.rs     |  8 ++++++++
 src/files/commands.rs |  2 +-
 src/files/parse.rs    |  2 +-
 4 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/src/eval/command.rs b/src/eval/command.rs
index b277a7d..e65e6e6 100644
--- a/src/eval/command.rs
+++ b/src/eval/command.rs
@@ -244,6 +244,7 @@ impl<'a> CommandState<'a> {
     }
 
     fn eval_except(&mut self, date: NaiveDate) {
+        // TODO Error if nothing is removed?
         self.dated.remove(&date);
     }
 
@@ -252,7 +253,7 @@ impl<'a> CommandState<'a> {
         span: Span,
         from: NaiveDate,
         to: Option<NaiveDate>,
-        to_time: Option<Time>,
+        to_time: Option<Spanned<Time>>,
     ) -> Result<()> {
         if let Some(mut entry) = self.dated.remove(&from) {
             let mut dates = entry.dates.expect("comes from self.dated");
@@ -264,7 +265,12 @@ impl<'a> CommandState<'a> {
             }
             if let Some(to_time) = to_time {
                 if let Some((root, _)) = dates.times() {
-                    delta = delta + Duration::minutes(root.minutes_to(to_time));
+                    delta = delta + Duration::minutes(root.minutes_to(to_time.value));
+                } else {
+                    return Err(Error::TimedMoveWithoutTime {
+                        index: self.command.source.file(),
+                        span: to_time.span,
+                    });
                 }
             }
 
diff --git a/src/eval/error.rs b/src/eval/error.rs
index b485143..5219f7f 100644
--- a/src/eval/error.rs
+++ b/src/eval/error.rs
@@ -48,6 +48,10 @@ pub enum Error {
     /// date `a`.
     #[error("tried to move nonexisting entry")]
     MoveWithoutSource { index: usize, span: Span },
+    /// A `MOVE a TO b` statement was executed where `b` contains a time but `a`
+    /// doesn't was executed.
+    #[error("tried to move un-timed entry to new time")]
+    TimedMoveWithoutTime { index: usize, span: Span },
     /// A division by zero has occurred.
     #[error("tried to divide by zero")]
     DivByZero {
@@ -162,6 +166,10 @@ impl Error {
                 let msg = "Tried to move nonexisting entry".to_string();
                 Self::print_at(sources, index, span, msg);
             }
+            Error::TimedMoveWithoutTime { index, span } => {
+                let msg = "Tried to move un-timed entry to new time".to_string();
+                Self::print_at(sources, index, span, msg);
+            }
             Error::DivByZero { index, span, date } => {
                 let msg = format!(
                     "Tried to divide by zero\
diff --git a/src/files/commands.rs b/src/files/commands.rs
index 90983d0..76166b0 100644
--- a/src/files/commands.rs
+++ b/src/files/commands.rs
@@ -266,7 +266,7 @@ pub enum Statement {
         span: Span,
         from: NaiveDate,
         to: Option<NaiveDate>,
-        to_time: Option<Time>,
+        to_time: Option<Spanned<Time>>,
     },
     Remind(Option<Spanned<Delta>>),
 }
diff --git a/src/files/parse.rs b/src/files/parse.rs
index 3e43ab0..8a756f7 100644
--- a/src/files/parse.rs
+++ b/src/files/parse.rs
@@ -624,7 +624,7 @@ fn parse_stmt_move(p: Pair<'_, Rule>) -> Result<Statement> {
     for p in p {
         match p.as_rule() {
             Rule::datum => to = Some(parse_datum(p)?.value),
-            Rule::time => to_time = Some(parse_time(p)?.value),
+            Rule::time => to_time = Some(parse_time(p)?),
             _ => unreachable!(),
         }
     }

From 07ce85982c1e7177267de17524db029de76ce983 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Tue, 21 Dec 2021 19:46:36 +0100
Subject: [PATCH 06/80] Fix when and how reminders are calculated and displayed

---
 src/cli/layout/day.rs | 22 ++++++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git a/src/cli/layout/day.rs b/src/cli/layout/day.rs
index 71b2016..e326307 100644
--- a/src/cli/layout/day.rs
+++ b/src/cli/layout/day.rs
@@ -81,7 +81,11 @@ impl DayLayout {
     fn layout_task(&mut self, index: usize, entry: &Entry) {
         if let Some(dates) = entry.dates {
             let (start, end) = dates.sorted().dates();
-            if self.today < start {
+            if self.today < self.range.from() || self.range.until() < self.today {
+                // If `self.today` is not in range, reminders won't be displayed
+                // (since they're always displayed on `self.today`) so there's
+                // no need to calculate them.
+            } else if self.today < start {
                 if let Some(remind) = entry.remind {
                     if remind <= self.today {
                         let days = (start - self.today).num_days();
@@ -118,7 +122,18 @@ impl DayLayout {
     fn layout_note(&mut self, index: usize, entry: &Entry) {
         if let Some(dates) = entry.dates {
             let (start, end) = dates.sorted().dates();
-            if start < self.range.from() && self.range.until() < end {
+            if self.today < self.range.from() || self.range.until() < self.today {
+                // if `self.today` is not in range, reminders won't be displayed
+                // (since they're always displayed on `self.today`) so there's
+                // no need to calculate them.
+            } else if self.today < start {
+                if let Some(remind) = entry.remind {
+                    if remind <= self.today {
+                        let days = (start - self.today).num_days();
+                        self.insert(self.today, DayEntry::ReminderUntil(index, days));
+                    }
+                }
+            } else if start < self.range.from() && self.range.until() < end {
                 // This note applies to the current day, but it won't appear if
                 // we just layout it as a dated entry, so instead we add it as a
                 // reminder. Since we are usually more interested in when
@@ -126,9 +141,8 @@ impl DayLayout {
                 // the end.
                 let days = (end - self.today).num_days();
                 self.insert(self.today, DayEntry::ReminderWhile(index, days));
-            } else {
-                self.layout_dated_entry(index, dates);
             }
+            self.layout_dated_entry(index, dates);
         } else {
             self.insert(self.today, DayEntry::Undated(index));
         }

From 12c86e0d283d17a973df32e3fbafb2ec1802b5f0 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Tue, 21 Dec 2021 19:56:31 +0100
Subject: [PATCH 07/80] Fix formatting of ReminderWhile

---
 src/cli/layout/line.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cli/layout/line.rs b/src/cli/layout/line.rs
index a0e74c6..23adaba 100644
--- a/src/cli/layout/line.rs
+++ b/src/cli/layout/line.rs
@@ -154,7 +154,7 @@ impl LineLayout {
             DayEntry::ReminderWhile(i, d) => {
                 let text = Self::format_entry(files, entries, *i);
                 let plural = if *d == 1 { "" } else { "s" };
-                let text = format!("{} ({} day{} left)", text, i, plural);
+                let text = format!("{} ({} day{} left)", text, d, plural);
                 self.line_entry(Some(*i), Times::Untimed, text);
             }
             DayEntry::Undated(i) => {

From 2078c5e883f8945c554f949354e367e7bddef488 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Wed, 22 Dec 2021 15:58:10 +0000
Subject: [PATCH 08/80] Color output

---
 CHANGELOG.md           |   3 +
 Cargo.lock             |  12 +++
 Cargo.toml             |   1 +
 src/cli/layout/line.rs | 169 ++++++++++++++++++++++++++++++-----------
 src/cli/print.rs       | 116 +++++++++++++++++++---------
 5 files changed, 221 insertions(+), 80 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d12e3d9..42727fa 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - `REMIND` statement
 - `MOVE` entries to a different time
 
+### Changed
+- Output is now colored
+
 ## 0.1.0 - 2021-12-20
 
 ### Added
diff --git a/Cargo.lock b/Cargo.lock
index a4a4cfc..5afc4fb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -101,6 +101,17 @@ dependencies = [
  "vec_map",
 ]
 
+[[package]]
+name = "colored"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3616f750b84d8f0de8a58bda93e08e2a81ad3f523089b05f1dffecab48c6cbd"
+dependencies = [
+ "atty",
+ "lazy_static",
+ "winapi",
+]
+
 [[package]]
 name = "computus"
 version = "1.0.0"
@@ -425,6 +436,7 @@ name = "today"
 version = "0.1.0"
 dependencies = [
  "chrono",
+ "colored",
  "computus",
  "directories",
  "pest",
diff --git a/Cargo.toml b/Cargo.toml
index edc3e45..7a46abe 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,6 +5,7 @@ edition = "2021"
 
 [dependencies]
 chrono = "0.4.19"
+colored="2.0.0"
 computus = "1.0.0"
 directories = "4.0.1"
 pest = "2.1.3"
diff --git a/src/cli/layout/line.rs b/src/cli/layout/line.rs
index 23adaba..e5e8412 100644
--- a/src/cli/layout/line.rs
+++ b/src/cli/layout/line.rs
@@ -14,11 +14,39 @@ use crate::files::Files;
 use super::super::error::{Error, Result};
 use super::day::{DayEntry, DayLayout};
 
+#[derive(Debug, Clone, Copy)]
+pub enum SpanStyle {
+    Solid,
+    Dashed,
+    Dotted,
+}
+
+impl SpanStyle {
+    fn from_indentation(index: usize) -> Self {
+        match index % 3 {
+            0 => Self::Solid,
+            1 => Self::Dashed,
+            2 => Self::Dotted,
+            _ => unreachable!(),
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy)]
 pub enum SpanSegment {
-    Start,
-    Middle,
-    End,
+    Start(SpanStyle),
+    Middle(SpanStyle),
+    End(SpanStyle),
+}
+
+impl SpanSegment {
+    fn style(&self) -> SpanStyle {
+        match self {
+            SpanSegment::Start(s) => *s,
+            SpanSegment::Middle(s) => *s,
+            SpanSegment::End(s) => *s,
+        }
+    }
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -28,10 +56,19 @@ pub enum Times {
     FromTo(Time, Time),
 }
 
+#[derive(Debug, Clone, Copy)]
+pub enum LineKind {
+    Task,
+    Done,
+    Note,
+    Birthday,
+}
+
 pub enum LineEntry {
     Day {
         spans: Vec<Option<SpanSegment>>,
         date: NaiveDate,
+        today: bool,
     },
     Now {
         spans: Vec<Option<SpanSegment>>,
@@ -41,7 +78,9 @@ pub enum LineEntry {
         number: Option<usize>,
         spans: Vec<Option<SpanSegment>>,
         time: Times,
+        kind: LineKind,
         text: String,
+        extra: Option<String>,
     },
 }
 
@@ -80,7 +119,11 @@ impl LineLayout {
 
         for day in layout.range.days() {
             let spans = self.spans_for_line();
-            self.line(LineEntry::Day { spans, date: day });
+            self.line(LineEntry::Day {
+                spans,
+                date: day,
+                today: day == layout.today,
+            });
 
             let layout_entries = layout.days.get(&day).expect("got nonexisting day");
             for layout_entry in layout_entries {
@@ -114,8 +157,10 @@ impl LineLayout {
         match l_entry {
             DayEntry::End(i) => {
                 self.stop_span(*i);
-                let text = Self::format_entry(files, entries, *i);
-                self.line_entry(Some(*i), Times::Untimed, text);
+                let entry = &entries[*i];
+                let kind = Self::entry_kind(entry);
+                let text = Self::entry_title(files, entry);
+                self.line_entry(Some(*i), Times::Untimed, kind, text, None);
             }
             DayEntry::Now(t) => self.line(LineEntry::Now {
                 spans: self.spans_for_line(),
@@ -123,89 +168,114 @@ impl LineLayout {
             }),
             DayEntry::TimedEnd(i, t) => {
                 self.stop_span(*i);
-                let text = Self::format_entry(files, entries, *i);
-                self.line_entry(Some(*i), Times::At(*t), text);
+                let entry = &entries[*i];
+                let kind = Self::entry_kind(entry);
+                let text = Self::entry_title(files, entry);
+                self.line_entry(Some(*i), Times::At(*t), kind, text, None);
             }
             DayEntry::TimedAt(i, t, t2) => {
                 let time = t2
                     .map(|t2| Times::FromTo(*t, t2))
                     .unwrap_or_else(|| Times::At(*t));
-                let text = Self::format_entry(files, entries, *i);
-                self.line_entry(Some(*i), time, text);
+                let entry = &entries[*i];
+                let kind = Self::entry_kind(entry);
+                let text = Self::entry_title(files, entry);
+                self.line_entry(Some(*i), time, kind, text, None);
             }
             DayEntry::TimedStart(i, t) => {
                 self.start_span(*i);
-                let text = Self::format_entry(files, entries, *i);
-                self.line_entry(Some(*i), Times::At(*t), text);
+                let entry = &entries[*i];
+                let kind = Self::entry_kind(entry);
+                let text = Self::entry_title(files, entry);
+                self.line_entry(Some(*i), Times::At(*t), kind, text, None);
             }
             DayEntry::ReminderSince(i, d) => {
-                let text = Self::format_entry(files, entries, *i);
-                let text = if *d == 1 {
-                    format!("{} (yesterday)", text)
+                let entry = &entries[*i];
+                let kind = Self::entry_kind(entry);
+                let text = Self::entry_title(files, entry);
+                let extra = if *d == 1 {
+                    "yesterday".to_string()
                 } else {
-                    format!("{} ({} days ago)", text, d)
+                    format!("{} days ago", d)
                 };
-                self.line_entry(Some(*i), Times::Untimed, text);
+                self.line_entry(Some(*i), Times::Untimed, kind, text, Some(extra));
             }
             DayEntry::At(i) => {
-                let text = Self::format_entry(files, entries, *i);
-                self.line_entry(Some(*i), Times::Untimed, text);
+                let entry = &entries[*i];
+                let kind = Self::entry_kind(entry);
+                let text = Self::entry_title(files, entry);
+                self.line_entry(Some(*i), Times::Untimed, kind, text, None);
             }
             DayEntry::ReminderWhile(i, d) => {
-                let text = Self::format_entry(files, entries, *i);
+                let entry = &entries[*i];
+                let kind = Self::entry_kind(entry);
+                let text = Self::entry_title(files, entry);
                 let plural = if *d == 1 { "" } else { "s" };
-                let text = format!("{} ({} day{} left)", text, d, plural);
-                self.line_entry(Some(*i), Times::Untimed, text);
+                let extra = format!("{} day{} left", d, plural);
+                self.line_entry(Some(*i), Times::Untimed, kind, text, Some(extra));
             }
             DayEntry::Undated(i) => {
-                let text = Self::format_entry(files, entries, *i);
-                self.line_entry(Some(*i), Times::Untimed, text);
+                let entry = &entries[*i];
+                let kind = Self::entry_kind(entry);
+                let text = Self::entry_title(files, entry);
+                self.line_entry(Some(*i), Times::Untimed, kind, text, None);
             }
             DayEntry::Start(i) => {
                 self.start_span(*i);
-                let text = Self::format_entry(files, entries, *i);
-                self.line_entry(Some(*i), Times::Untimed, text);
+                let entry = &entries[*i];
+                let kind = Self::entry_kind(entry);
+                let text = Self::entry_title(files, entry);
+                self.line_entry(Some(*i), Times::Untimed, kind, text, None);
             }
             DayEntry::ReminderUntil(i, d) => {
-                let text = Self::format_entry(files, entries, *i);
-                let text = if *d == 1 {
-                    format!("{} (tomorrow)", text)
+                let entry = &entries[*i];
+                let kind = Self::entry_kind(entry);
+                let text = Self::entry_title(files, entry);
+                let extra = if *d == 1 {
+                    "tomorrow".to_string()
                 } else {
-                    format!("{} (in {} days)", text, d)
+                    format!("in {} days", d)
                 };
-                self.line_entry(Some(*i), Times::Untimed, text);
+                self.line_entry(Some(*i), Times::Untimed, kind, text, Some(extra));
             }
         }
     }
 
-    fn format_entry(files: &Files, entries: &[Entry], index: usize) -> String {
-        let entry = entries[index];
+    fn entry_kind(entry: &Entry) -> LineKind {
+        match entry.kind {
+            EntryKind::Task => LineKind::Task,
+            EntryKind::TaskDone(_) => LineKind::Done,
+            EntryKind::Note => LineKind::Note,
+            EntryKind::Birthday(_) => LineKind::Birthday,
+        }
+    }
+
+    fn entry_title(files: &Files, entry: &Entry) -> String {
         let command = files.command(entry.source);
         match entry.kind {
-            EntryKind::Task => format!("T {}", command.title()),
-            EntryKind::TaskDone(_) => format!("D {}", command.title()),
-            EntryKind::Note => format!("N {}", command.title()),
-            EntryKind::Birthday(Some(age)) => format!("B {} ({})", command.title(), age),
-            EntryKind::Birthday(None) => format!("B {}", command.title()),
+            EntryKind::Birthday(Some(age)) => format!("{} ({})", command.title(), age),
+            _ => command.title().to_string(),
         }
     }
 
     fn start_span(&mut self, index: usize) {
-        for span in self.spans.iter_mut() {
+        for (i, span) in self.spans.iter_mut().enumerate() {
             if span.is_none() {
-                *span = Some((index, SpanSegment::Start));
+                let style = SpanStyle::from_indentation(i);
+                *span = Some((index, SpanSegment::Start(style)));
                 return;
             }
         }
 
         // Not enough space, we need another column
-        self.spans.push(Some((index, SpanSegment::Start)));
+        let style = SpanStyle::from_indentation(self.spans.len());
+        self.spans.push(Some((index, SpanSegment::Start(style))));
     }
 
     fn stop_span(&mut self, index: usize) {
         for span in self.spans.iter_mut() {
             match span {
-                Some((i, s)) if *i == index => *s = SpanSegment::End,
+                Some((i, s)) if *i == index => *s = SpanSegment::End(s.style()),
                 _ => {}
             }
         }
@@ -214,8 +284,8 @@ impl LineLayout {
     fn step_spans(&mut self) {
         for span in self.spans.iter_mut() {
             match span {
-                Some((_, s @ SpanSegment::Start)) => *s = SpanSegment::Middle,
-                Some((_, SpanSegment::End)) => *span = None,
+                Some((_, s @ SpanSegment::Start(_))) => *s = SpanSegment::Middle(s.style()),
+                Some((_, SpanSegment::End(_))) => *span = None,
                 _ => {}
             }
         }
@@ -233,7 +303,14 @@ impl LineLayout {
         self.step_spans();
     }
 
-    fn line_entry(&mut self, index: Option<usize>, time: Times, text: String) {
+    fn line_entry(
+        &mut self,
+        index: Option<usize>,
+        time: Times,
+        kind: LineKind,
+        text: String,
+        extra: Option<String>,
+    ) {
         let number = match index {
             Some(index) => Some(match self.numbers.get(&index) {
                 Some(number) => *number,
@@ -250,7 +327,9 @@ impl LineLayout {
             number,
             spans: self.spans_for_line(),
             time,
+            kind,
             text,
+            extra,
         });
     }
 }
diff --git a/src/cli/print.rs b/src/cli/print.rs
index cd04776..5adcfa6 100644
--- a/src/cli/print.rs
+++ b/src/cli/print.rs
@@ -1,10 +1,11 @@
 use std::cmp;
 
 use chrono::{Datelike, NaiveDate};
+use colored::{Color, ColoredString, Colorize};
 
 use crate::files::primitives::{Time, Weekday};
 
-use super::layout::line::{LineEntry, LineLayout, SpanSegment, Times};
+use super::layout::line::{LineEntry, LineKind, LineLayout, SpanSegment, SpanStyle, Times};
 
 struct ShowLines {
     num_width: usize,
@@ -23,41 +24,59 @@ impl ShowLines {
 
     fn display_line(&mut self, line: &LineEntry) {
         match line {
-            LineEntry::Day { spans, date } => self.display_line_date(spans, *date),
+            LineEntry::Day { spans, date, today } => self.display_line_date(spans, *date, *today),
             LineEntry::Now { spans, time } => self.display_line_now(spans, *time),
             LineEntry::Entry {
                 number,
                 spans,
                 time,
+                kind,
                 text,
-            } => self.display_line_entry(*number, spans, *time, text),
+                extra,
+            } => self.display_line_entry(*number, spans, *time, *kind, text, extra),
         }
     }
 
-    fn display_line_date(&mut self, spans: &[Option<SpanSegment>], date: NaiveDate) {
+    fn display_line_date(&mut self, spans: &[Option<SpanSegment>], date: NaiveDate, today: bool) {
         let weekday: Weekday = date.weekday().into();
         let weekday = weekday.full_name();
-        self.push(&format!(
-            "{:=>nw$}={:=<sw$}===  {:9}  {}  ==={:=<sw$}={:=>nw$}\n",
-            "",
-            Self::display_spans(spans, '='),
+
+        let color = if today {
+            Color::BrightCyan
+        } else {
+            Color::Cyan
+        };
+
+        // '=' symbols before the spans start
+        let p1 = format!("{:=<w$}=", "", w = self.num_width);
+
+        // Spans and filler '=' symbols
+        let p2 = self.display_spans(spans, "=".color(color).bold());
+
+        // The rest of the line
+        let p3 = format!(
+            "===  {:9}  {}  ===={:=<w$}",
             weekday,
             date,
             "",
-            "",
-            nw = self.num_width,
-            sw = self.span_width
+            w = self.num_width + self.span_width
+        );
+
+        self.push(&format!(
+            "{}{}{}\n",
+            p1.color(color).bold(),
+            p2,
+            p3.color(color).bold()
         ));
     }
 
     fn display_line_now(&mut self, spans: &[Option<SpanSegment>], time: Time) {
         self.push(&format!(
-            "{:<nw$} {:sw$} {}\n",
-            "now",
-            Self::display_spans(spans, ' '),
-            time,
+            "{:<nw$} {} {}\n",
+            "now".bright_cyan().bold(),
+            self.display_spans(spans, " ".into()),
+            Self::display_time(Times::At(time)),
             nw = self.num_width,
-            sw = self.span_width
         ));
     }
 
@@ -66,43 +85,70 @@ impl ShowLines {
         number: Option<usize>,
         spans: &[Option<SpanSegment>],
         time: Times,
+        kind: LineKind,
         text: &str,
+        extra: &Option<String>,
     ) {
         let num = match number {
             Some(n) => format!("{}", n),
             None => "".to_string(),
         };
 
-        let time = match time {
-            Times::Untimed => "".to_string(),
-            Times::At(t) => format!("{} ", t),
-            Times::FromTo(t1, t2) => format!("{}--{} ", t1, t2),
-        };
-
         self.push(&format!(
-            "{:>nw$} {:sw$} {}{}\n",
-            num,
-            Self::display_spans(spans, ' '),
-            time,
+            "{:>nw$} {} {} {}{}{}\n",
+            num.bright_black(),
+            self.display_spans(spans, " ".into()),
+            Self::display_kind(kind),
+            Self::display_time(time),
             text,
+            Self::display_extra(extra),
             nw = self.num_width,
-            sw = self.span_width
         ))
     }
 
-    fn display_spans(spans: &[Option<SpanSegment>], empty: char) -> String {
+    fn display_spans(&self, spans: &[Option<SpanSegment>], empty: ColoredString) -> String {
         let mut result = String::new();
-        for segment in spans {
-            result.push(match segment {
-                Some(SpanSegment::Start) => '┌',
-                Some(SpanSegment::Middle) => '│',
-                Some(SpanSegment::End) => '└',
-                None => empty,
-            });
+        for i in 0..self.span_width {
+            if let Some(Some(segment)) = spans.get(i) {
+                let colored_str = match segment {
+                    SpanSegment::Start(_) => "┌".bright_black(),
+                    SpanSegment::Middle(SpanStyle::Solid) => "│".bright_black(),
+                    SpanSegment::Middle(SpanStyle::Dashed) => "╎".bright_black(),
+                    SpanSegment::Middle(SpanStyle::Dotted) => "┊".bright_black(),
+                    SpanSegment::End(_) => "└".bright_black(),
+                };
+                result.push_str(&format!("{}", colored_str));
+            } else {
+                result.push_str(&format!("{}", empty));
+            }
         }
         result
     }
 
+    fn display_time(time: Times) -> ColoredString {
+        match time {
+            Times::Untimed => "".into(),
+            Times::At(t) => format!("{} ", t).bright_black(),
+            Times::FromTo(t1, t2) => format!("{}--{} ", t1, t2).bright_black(),
+        }
+    }
+
+    fn display_kind(kind: LineKind) -> ColoredString {
+        match kind {
+            LineKind::Task => "T".magenta().bold(),
+            LineKind::Done => "D".green().bold(),
+            LineKind::Note => "N".blue().bold(),
+            LineKind::Birthday => "B".yellow().bold(),
+        }
+    }
+
+    fn display_extra(extra: &Option<String>) -> ColoredString {
+        match extra {
+            None => "".into(),
+            Some(extra) => format!(" ({})", extra).bright_black(),
+        }
+    }
+
     fn push(&mut self, line: &str) {
         self.result.push_str(line);
     }

From e2624fe64f042ce1bc39b34a0e19c27b7197df5b Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Wed, 22 Dec 2021 16:11:34 +0000
Subject: [PATCH 09/80] Fix "now" not being right-aligned

---
 src/cli/print.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cli/print.rs b/src/cli/print.rs
index 5adcfa6..66e5338 100644
--- a/src/cli/print.rs
+++ b/src/cli/print.rs
@@ -72,7 +72,7 @@ impl ShowLines {
 
     fn display_line_now(&mut self, spans: &[Option<SpanSegment>], time: Time) {
         self.push(&format!(
-            "{:<nw$} {} {}\n",
+            "{:>nw$} {} {}\n",
             "now".bright_cyan().bold(),
             self.display_spans(spans, " ".into()),
             Self::display_time(Times::At(time)),

From 7a67d01e1fe73587c6f4f623b04cb7fc071f8b89 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Wed, 22 Dec 2021 16:39:13 +0000
Subject: [PATCH 10/80] Fix reminders not making entries relevant

---
 src/eval/entry.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/eval/entry.rs b/src/eval/entry.rs
index d3daf26..303900d 100644
--- a/src/eval/entry.rs
+++ b/src/eval/entry.rs
@@ -110,6 +110,15 @@ impl Entries {
             return true;
         }
 
+        if let (Some(remind), Some(dates)) = (entry.remind, entry.dates) {
+            let (_, end) = dates.sorted().dates();
+            let remind_before = remind <= self.range.until();
+            let entry_before = end < self.range.from();
+            if remind_before && !entry_before {
+                return true;
+            }
+        }
+
         // Tasks that were finished inside the range
         if let EntryKind::TaskDone(done) = entry.kind {
             if self.range.contains(done) {

From 2b88008ba32347423a3c86d78814e86d29c71273 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Wed, 22 Dec 2021 17:01:06 +0000
Subject: [PATCH 11/80] Align "now" time with other times

---
 src/cli/print.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/cli/print.rs b/src/cli/print.rs
index 66e5338..e675a80 100644
--- a/src/cli/print.rs
+++ b/src/cli/print.rs
@@ -72,7 +72,7 @@ impl ShowLines {
 
     fn display_line_now(&mut self, spans: &[Option<SpanSegment>], time: Time) {
         self.push(&format!(
-            "{:>nw$} {} {}\n",
+            "{:>nw$} {}  {}\n",
             "now".bright_cyan().bold(),
             self.display_spans(spans, " ".into()),
             Self::display_time(Times::At(time)),
@@ -95,7 +95,7 @@ impl ShowLines {
         };
 
         self.push(&format!(
-            "{:>nw$} {} {} {}{}{}\n",
+            "{:>nw$} {} {}{} {}{}\n",
             num.bright_black(),
             self.display_spans(spans, " ".into()),
             Self::display_kind(kind),
@@ -128,8 +128,8 @@ impl ShowLines {
     fn display_time(time: Times) -> ColoredString {
         match time {
             Times::Untimed => "".into(),
-            Times::At(t) => format!("{} ", t).bright_black(),
-            Times::FromTo(t1, t2) => format!("{}--{} ", t1, t2).bright_black(),
+            Times::At(t) => format!(" {}", t).bright_black(),
+            Times::FromTo(t1, t2) => format!(" {}--{}", t1, t2).bright_black(),
         }
     }
 

From f9dbc0db0137352ffc3b41ff4ed8125c25696bf7 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Thu, 23 Dec 2021 17:02:41 +0000
Subject: [PATCH 12/80] Format Cargo.toml

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 7a46abe..8f8292a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 chrono = "0.4.19"
-colored="2.0.0"
+colored = "2.0.0"
 computus = "1.0.0"
 directories = "4.0.1"
 pest = "2.1.3"

From 8af268bd6895a80797932038393400455b523bb4 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Wed, 29 Dec 2021 00:53:27 +0100
Subject: [PATCH 13/80] Switch to patched tzdir

This fixes today not respecting the TZDIR environment variable, which is
necessary since NixOS uses a nonstandard time zone data location.
---
 Cargo.lock | 3 +--
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 5afc4fb..3e90b27 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -455,8 +455,7 @@ checksum = "b63708a265f51345575b27fe43f9500ad611579e764c79edbc2037b1121959ec"
 [[package]]
 name = "tzfile"
 version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f59c22c42a2537e4c7ad21a4007273bbc5bebed7f36bc93730a5780e22a4592e"
+source = "git+https://github.com/Garmelon/tzfile.git?branch=tzdir#a2a4775fdb2a24f33f616ca6289d715f647d53c2"
 dependencies = [
  "byteorder",
  "chrono",
diff --git a/Cargo.toml b/Cargo.toml
index 8f8292a..d0b6eb2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,4 +12,4 @@ pest = "2.1.3"
 pest_derive = "2.1.0"
 structopt = "0.3.25"
 thiserror = "1.0.30"
-tzfile = "0.1.3"
+tzfile = { git = "https://github.com/Garmelon/tzfile.git", branch = "tzdir" }

From e01de41925c5dc3b6d67df4dd8b45f652dcdfd99 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Thu, 30 Dec 2021 02:30:13 +0100
Subject: [PATCH 14/80] Make current day stand out more

---
 src/cli/print.rs | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/src/cli/print.rs b/src/cli/print.rs
index e675a80..22f5108 100644
--- a/src/cli/print.rs
+++ b/src/cli/print.rs
@@ -1,7 +1,7 @@
 use std::cmp;
 
 use chrono::{Datelike, NaiveDate};
-use colored::{Color, ColoredString, Colorize};
+use colored::{ColoredString, Colorize};
 
 use crate::files::primitives::{Time, Weekday};
 
@@ -41,17 +41,19 @@ impl ShowLines {
         let weekday: Weekday = date.weekday().into();
         let weekday = weekday.full_name();
 
-        let color = if today {
-            Color::BrightCyan
-        } else {
-            Color::Cyan
+        let styled = |s: &str| {
+            if today {
+                s.bright_cyan().bold()
+            } else {
+                s.cyan()
+            }
         };
 
         // '=' symbols before the spans start
         let p1 = format!("{:=<w$}=", "", w = self.num_width);
 
         // Spans and filler '=' symbols
-        let p2 = self.display_spans(spans, "=".color(color).bold());
+        let p2 = self.display_spans(spans, styled("="));
 
         // The rest of the line
         let p3 = format!(
@@ -62,12 +64,7 @@ impl ShowLines {
             w = self.num_width + self.span_width
         );
 
-        self.push(&format!(
-            "{}{}{}\n",
-            p1.color(color).bold(),
-            p2,
-            p3.color(color).bold()
-        ));
+        self.push(&format!("{}{}{}\n", styled(&p1), p2, styled(&p3)));
     }
 
     fn display_line_now(&mut self, spans: &[Option<SpanSegment>], time: Time) {

From e0cb1c8f238896ed5ccaf82d414c05a87f4b918c Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Fri, 31 Dec 2021 02:42:31 +0100
Subject: [PATCH 15/80] Don't write unchanged files

---
 src/files.rs | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/files.rs b/src/files.rs
index a8da331..0e5aded 100644
--- a/src/files.rs
+++ b/src/files.rs
@@ -141,7 +141,6 @@ impl Files {
     pub fn save(&self) -> Result<()> {
         for file in &self.files {
             if file.dirty {
-                println!("Saving file {:?}", file.path);
                 Self::save_file(&file.path, &file.file)?;
             }
         }
@@ -149,10 +148,16 @@ impl Files {
     }
 
     fn save_file(path: &Path, file: &File) -> Result<()> {
-        fs::write(path, &format!("{}", file)).map_err(|e| Error::WriteFile {
-            file: path.to_path_buf(),
-            error: e,
-        })?;
+        let formatted = format!("{}", file);
+        if file.contents == formatted {
+            println!("Unchanged file {:?}", path);
+        } else {
+            println!("Saving file {:?}", path);
+            fs::write(path, &formatted).map_err(|e| Error::WriteFile {
+                file: path.to_path_buf(),
+                error: e,
+            })?;
+        }
         Ok(())
     }
 

From 0e4ef7fef3db3779f589c6aaecda81c05a84cfe7 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Fri, 31 Dec 2021 23:57:40 +0100
Subject: [PATCH 16/80] Allow tasks to be canceled

---
 src/cli.rs             | 15 +++++++++++++++
 src/cli/cancel.rs      | 37 +++++++++++++++++++++++++++++++++++++
 src/cli/done.rs        |  3 ++-
 src/cli/layout/day.rs  |  6 ++++--
 src/cli/layout/line.rs |  2 ++
 src/cli/print.rs       |  1 +
 src/cli/show.rs        |  4 ++++
 src/eval/command.rs    | 12 +++++++-----
 src/eval/entry.rs      |  3 ++-
 src/files/commands.rs  |  7 +++++++
 src/files/format.rs    |  8 +++++++-
 src/files/grammar.pest |  3 ++-
 src/files/parse.rs     | 20 +++++++++++++++++---
 13 files changed, 107 insertions(+), 14 deletions(-)
 create mode 100644 src/cli/cancel.rs

diff --git a/src/cli.rs b/src/cli.rs
index 25d064d..027bc60 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -13,6 +13,7 @@ use crate::files::{self, Files};
 use self::error::Result;
 use self::layout::line::LineLayout;
 
+mod cancel;
 mod done;
 mod error;
 mod layout;
@@ -49,6 +50,12 @@ pub enum Command {
         #[structopt(required = true)]
         entries: Vec<usize>,
     },
+    /// Marks one or more entries as canceled
+    Cancel {
+        /// Entries to mark as done
+        #[structopt(required = true)]
+        entries: Vec<usize>,
+    },
     /// Reformat all loaded files
     Fmt,
 }
@@ -107,6 +114,14 @@ fn run_command(opt: &Opt, files: &mut Files, range: DateRange, now: NaiveDateTim
             let layout = find_layout(files, &entries, range, now);
             print::print(&layout);
         }
+        Some(Command::Cancel { entries: ns }) => {
+            let entries = find_entries(files, range)?;
+            let layout = find_layout(files, &entries, range, now);
+            cancel::cancel(files, &entries, &layout, ns, now)?;
+            let entries = find_entries(files, range)?;
+            let layout = find_layout(files, &entries, range, now);
+            print::print(&layout);
+        }
         Some(Command::Fmt) => files.mark_all_dirty(),
     }
     Ok(())
diff --git a/src/cli/cancel.rs b/src/cli/cancel.rs
new file mode 100644
index 0000000..62cc8ea
--- /dev/null
+++ b/src/cli/cancel.rs
@@ -0,0 +1,37 @@
+use std::vec;
+
+use chrono::NaiveDateTime;
+
+use crate::eval::Entry;
+use crate::files::commands::{Done, DoneKind};
+use crate::files::Files;
+
+use super::error::{Error, Result};
+use super::layout::line::LineLayout;
+
+pub fn cancel(
+    files: &mut Files,
+    entries: &[Entry],
+    layout: &LineLayout,
+    numbers: &[usize],
+    now: NaiveDateTime,
+) -> Result<()> {
+    let mut not_tasks = vec![];
+    for &number in numbers {
+        let entry = &entries[layout.look_up_number(number)?];
+        let done = Done {
+            kind: DoneKind::Canceled,
+            date: entry.dates.map(|dates| dates.into()),
+            done_at: now.date(),
+        };
+        if !files.add_done(entry.source, done) {
+            not_tasks.push(number);
+        }
+    }
+
+    if not_tasks.is_empty() {
+        Ok(())
+    } else {
+        Err(Error::NotATask(not_tasks))
+    }
+}
diff --git a/src/cli/done.rs b/src/cli/done.rs
index 379d6ce..1d3d809 100644
--- a/src/cli/done.rs
+++ b/src/cli/done.rs
@@ -3,7 +3,7 @@ use std::vec;
 use chrono::NaiveDateTime;
 
 use crate::eval::Entry;
-use crate::files::commands::Done;
+use crate::files::commands::{Done, DoneKind};
 use crate::files::Files;
 
 use super::error::{Error, Result};
@@ -20,6 +20,7 @@ pub fn done(
     for &number in numbers {
         let entry = &entries[layout.look_up_number(number)?];
         let done = Done {
+            kind: DoneKind::Done,
             date: entry.dates.map(|dates| dates.into()),
             done_at: now.date(),
         };
diff --git a/src/cli/layout/day.rs b/src/cli/layout/day.rs
index e326307..30db056 100644
--- a/src/cli/layout/day.rs
+++ b/src/cli/layout/day.rs
@@ -73,7 +73,9 @@ impl DayLayout {
     fn layout_entry(&mut self, index: usize, entry: &Entry) {
         match entry.kind {
             EntryKind::Task => self.layout_task(index, entry),
-            EntryKind::TaskDone(at) => self.layout_task_done(index, entry, at),
+            EntryKind::TaskDone(at) | EntryKind::TaskCanceled(at) => {
+                self.layout_task_done(index, entry, at)
+            }
             EntryKind::Note | EntryKind::Birthday(_) => self.layout_note(index, entry),
         }
     }
@@ -208,7 +210,7 @@ impl DayLayout {
         // 3.
         entries.sort_by_key(|(_, e, _)| match e.kind {
             EntryKind::Task => 0,
-            EntryKind::TaskDone(_) => 1,
+            EntryKind::TaskDone(_) | EntryKind::TaskCanceled(_) => 1,
             EntryKind::Birthday(_) => 2,
             EntryKind::Note => 3,
         });
diff --git a/src/cli/layout/line.rs b/src/cli/layout/line.rs
index e5e8412..637d963 100644
--- a/src/cli/layout/line.rs
+++ b/src/cli/layout/line.rs
@@ -60,6 +60,7 @@ pub enum Times {
 pub enum LineKind {
     Task,
     Done,
+    Canceled,
     Note,
     Birthday,
 }
@@ -245,6 +246,7 @@ impl LineLayout {
         match entry.kind {
             EntryKind::Task => LineKind::Task,
             EntryKind::TaskDone(_) => LineKind::Done,
+            EntryKind::TaskCanceled(_) => LineKind::Canceled,
             EntryKind::Note => LineKind::Note,
             EntryKind::Birthday(_) => LineKind::Birthday,
         }
diff --git a/src/cli/print.rs b/src/cli/print.rs
index 22f5108..657cf1e 100644
--- a/src/cli/print.rs
+++ b/src/cli/print.rs
@@ -134,6 +134,7 @@ impl ShowLines {
         match kind {
             LineKind::Task => "T".magenta().bold(),
             LineKind::Done => "D".green().bold(),
+            LineKind::Canceled => "C".red().bold(),
             LineKind::Note => "N".blue().bold(),
             LineKind::Birthday => "B".yellow().bold(),
         }
diff --git a/src/cli/show.rs b/src/cli/show.rs
index 1b20413..81cac22 100644
--- a/src/cli/show.rs
+++ b/src/cli/show.rs
@@ -13,6 +13,10 @@ fn show_entry(files: &Files, entry: &Entry) {
             println!("DONE {}", command.title());
             println!("DONE AT {}", when);
         }
+        EntryKind::TaskCanceled(when) => {
+            println!("CANCELED {}", command.title());
+            println!("CANCELED AT {}", when);
+        }
         EntryKind::Note => println!("NOTE {}", command.title()),
         EntryKind::Birthday(Some(age)) => {
             println!("BIRTHDAY {}", command.title());
diff --git a/src/eval/command.rs b/src/eval/command.rs
index e65e6e6..b0ec4a5 100644
--- a/src/eval/command.rs
+++ b/src/eval/command.rs
@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use chrono::{Duration, NaiveDate};
 
 use crate::files::commands::{
-    self, BirthdaySpec, Command, Done, DoneDate, Note, Spec, Statement, Task,
+    self, BirthdaySpec, Command, Done, DoneDate, DoneKind, Note, Spec, Statement, Task,
 };
 use crate::files::primitives::{Span, Spanned, Time};
 use crate::files::SourcedCommand;
@@ -296,10 +296,12 @@ impl<'a> CommandState<'a> {
     }
 
     fn eval_done(&mut self, done: &Done) -> Result<()> {
-        self.add_forced(self.entry_with_remind(
-            EntryKind::TaskDone(done.done_at),
-            done.date.map(|date| date.into()),
-        )?);
+        let kind = match done.kind {
+            DoneKind::Done => EntryKind::TaskDone(done.done_at),
+            DoneKind::Canceled => EntryKind::TaskCanceled(done.done_at),
+        };
+        let dates = done.date.map(|date| date.into());
+        self.add_forced(self.entry_with_remind(kind, dates)?);
         Ok(())
     }
 }
diff --git a/src/eval/entry.rs b/src/eval/entry.rs
index 303900d..09d51a0 100644
--- a/src/eval/entry.rs
+++ b/src/eval/entry.rs
@@ -9,6 +9,7 @@ use super::range::DateRange;
 pub enum EntryKind {
     Task,
     TaskDone(NaiveDate),
+    TaskCanceled(NaiveDate),
     Note,
     Birthday(Option<i32>),
 }
@@ -120,7 +121,7 @@ impl Entries {
         }
 
         // Tasks that were finished inside the range
-        if let EntryKind::TaskDone(done) = entry.kind {
+        if let EntryKind::TaskDone(done) | EntryKind::TaskCanceled(done) = entry.kind {
             if self.range.contains(done) {
                 return true;
             }
diff --git a/src/files/commands.rs b/src/files/commands.rs
index 76166b0..7d1ec2d 100644
--- a/src/files/commands.rs
+++ b/src/files/commands.rs
@@ -309,8 +309,15 @@ impl DoneDate {
     }
 }
 
+#[derive(Debug)]
+pub enum DoneKind {
+    Done,
+    Canceled,
+}
+
 #[derive(Debug)]
 pub struct Done {
+    pub kind: DoneKind,
     pub date: Option<DoneDate>,
     pub done_at: NaiveDate,
 }
diff --git a/src/files/format.rs b/src/files/format.rs
index e169142..0694462 100644
--- a/src/files/format.rs
+++ b/src/files/format.rs
@@ -2,6 +2,8 @@ use std::fmt;
 
 use chrono::Datelike;
 
+use crate::files::commands::DoneKind;
+
 use super::commands::{
     BirthdaySpec, Command, DateSpec, Delta, DeltaStep, Done, DoneDate, Expr, File, FormulaSpec,
     Note, Repeat, Spec, Statement, Task, Var, WeekdaySpec,
@@ -258,7 +260,11 @@ impl fmt::Display for DoneDate {
 
 impl fmt::Display for Done {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "DONE [{}]", self.done_at)?;
+        let kind = match self.kind {
+            DoneKind::Done => "DONE",
+            DoneKind::Canceled => "CANCELED",
+        };
+        write!(f, "{} [{}]", kind, self.done_at)?;
         if let Some(date) = &self.date {
             write!(f, " {}", date)?;
         }
diff --git a/src/files/grammar.pest b/src/files/grammar.pest
index a2712be..24e9a51 100644
--- a/src/files/grammar.pest
+++ b/src/files/grammar.pest
@@ -118,7 +118,8 @@ donedate = {
     | datum ~ "--" ~ datum
     | datum
 }
-done = !{ "DONE" ~ "[" ~ datum ~ "]" ~ donedate? ~ eol }
+done_kind = { "DONE" | "CANCELED" }
+done = !{ done_kind ~ "[" ~ datum ~ "]" ~ donedate? ~ eol }
 dones = { done* }
 
 desc_line = { "#" ~ (" " ~ rest_any)? ~ eol }
diff --git a/src/files/parse.rs b/src/files/parse.rs
index 8a756f7..fc869e5 100644
--- a/src/files/parse.rs
+++ b/src/files/parse.rs
@@ -8,8 +8,8 @@ use pest::prec_climber::{Assoc, Operator, PrecClimber};
 use pest::{Parser, Span};
 
 use super::commands::{
-    BirthdaySpec, Command, DateSpec, Delta, DeltaStep, Done, DoneDate, Expr, File, FormulaSpec,
-    Note, Repeat, Spec, Statement, Task, Var, WeekdaySpec,
+    BirthdaySpec, Command, DateSpec, Delta, DeltaStep, Done, DoneDate, DoneKind, Expr, File,
+    FormulaSpec, Note, Repeat, Spec, Statement, Task, Var, WeekdaySpec,
 };
 use super::primitives::{Spanned, Time, Weekday};
 
@@ -704,10 +704,20 @@ fn parse_donedate(p: Pair<'_, Rule>) -> Result<DoneDate> {
     })
 }
 
+fn parse_done_kind(p: Pair<'_, Rule>) -> DoneKind {
+    assert_eq!(p.as_rule(), Rule::done_kind);
+    match p.as_str() {
+        "DONE" => DoneKind::Done,
+        "CANCELED" => DoneKind::Canceled,
+        _ => unreachable!(),
+    }
+}
+
 fn parse_done(p: Pair<'_, Rule>) -> Result<Done> {
     assert_eq!(p.as_rule(), Rule::done);
     let mut p = p.into_inner();
 
+    let kind = parse_done_kind(p.next().unwrap());
     let done_at = parse_datum(p.next().unwrap())?.value;
     let date = if let Some(p) = p.next() {
         Some(parse_donedate(p)?)
@@ -717,7 +727,11 @@ fn parse_done(p: Pair<'_, Rule>) -> Result<Done> {
 
     assert_eq!(p.next(), None);
 
-    Ok(Done { date, done_at })
+    Ok(Done {
+        kind,
+        date,
+        done_at,
+    })
 }
 
 fn parse_dones(p: Pair<'_, Rule>) -> Result<Vec<Done>> {

From 017098da34a7fcba23271b91afe523c888318fc1 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Fri, 31 Dec 2021 17:54:26 +0100
Subject: [PATCH 17/80] Parse and format logs

---
 src/files/commands.rs  |  7 +++++++
 src/files/format.rs    | 17 ++++++++++++++++-
 src/files/grammar.pest |  5 ++++-
 src/files/parse.rs     | 21 ++++++++++++++++++++-
 4 files changed, 47 insertions(+), 3 deletions(-)

diff --git a/src/files/commands.rs b/src/files/commands.rs
index 7d1ec2d..ebb93d0 100644
--- a/src/files/commands.rs
+++ b/src/files/commands.rs
@@ -337,6 +337,12 @@ pub struct Note {
     pub desc: Vec<String>,
 }
 
+#[derive(Debug)]
+pub struct Log {
+    pub date: NaiveDate,
+    pub desc: Vec<String>,
+}
+
 #[derive(Debug)]
 pub enum Command {
     Task(Task),
@@ -371,5 +377,6 @@ pub struct File {
     pub contents: String,
     pub includes: Vec<String>,
     pub timezone: Option<String>,
+    pub logs: Vec<Log>,
     pub commands: Vec<Command>,
 }
diff --git a/src/files/format.rs b/src/files/format.rs
index 0694462..bc46e19 100644
--- a/src/files/format.rs
+++ b/src/files/format.rs
@@ -6,7 +6,7 @@ use crate::files::commands::DoneKind;
 
 use super::commands::{
     BirthdaySpec, Command, DateSpec, Delta, DeltaStep, Done, DoneDate, Expr, File, FormulaSpec,
-    Note, Repeat, Spec, Statement, Task, Var, WeekdaySpec,
+    Log, Note, Repeat, Spec, Statement, Task, Var, WeekdaySpec,
 };
 use super::primitives::{Spanned, Time, Weekday};
 
@@ -306,9 +306,19 @@ impl fmt::Display for Command {
     }
 }
 
+impl fmt::Display for Log {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(f, "LOG {}", self.date)?;
+        format_desc(f, &self.desc)?;
+        Ok(())
+    }
+}
+
 impl fmt::Display for File {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut empty = true;
+
+        // TODO Sort includes alphabetically
         for include in &self.includes {
             writeln!(f, "INCLUDE {}", include)?;
             empty = false;
@@ -322,6 +332,11 @@ impl fmt::Display for File {
             empty = false;
         }
 
+        // TODO Sort logs from old to new
+        for log in &self.logs {
+            writeln!(f, "{}", log)?;
+        }
+
         for command in &self.commands {
             if !empty {
                 writeln!(f)?;
diff --git a/src/files/grammar.pest b/src/files/grammar.pest
index 24e9a51..e0a0279 100644
--- a/src/files/grammar.pest
+++ b/src/files/grammar.pest
@@ -140,8 +140,11 @@ note = {
     ~ description
 }
 
+log_head = !{ "LOG" ~ datum ~ eol }
+log = { log_head ~ description }
+
 empty_line = _{ WHITESPACE* ~ NEWLINE }
-command = { include | timezone | task | note }
+command = { include | timezone | task | note | log }
 
 file = ${ SOI ~ (empty_line* ~ command)* ~ empty_line* ~ WHITESPACE* ~ EOI }
 
diff --git a/src/files/parse.rs b/src/files/parse.rs
index fc869e5..a60c850 100644
--- a/src/files/parse.rs
+++ b/src/files/parse.rs
@@ -9,7 +9,7 @@ use pest::{Parser, Span};
 
 use super::commands::{
     BirthdaySpec, Command, DateSpec, Delta, DeltaStep, Done, DoneDate, DoneKind, Expr, File,
-    FormulaSpec, Note, Repeat, Spec, Statement, Task, Var, WeekdaySpec,
+    FormulaSpec, Log, Note, Repeat, Spec, Statement, Task, Var, WeekdaySpec,
 };
 use super::primitives::{Spanned, Time, Weekday};
 
@@ -795,6 +795,23 @@ fn parse_note(p: Pair<'_, Rule>) -> Result<Note> {
     })
 }
 
+fn parse_log_head(p: Pair<'_, Rule>) -> Result<NaiveDate> {
+    assert_eq!(p.as_rule(), Rule::log_head);
+    Ok(parse_datum(p.into_inner().next().unwrap())?.value)
+}
+
+fn parse_log(p: Pair<'_, Rule>) -> Result<Log> {
+    assert_eq!(p.as_rule(), Rule::log);
+    let mut p = p.into_inner();
+
+    let date = parse_log_head(p.next().unwrap())?;
+    let desc = parse_description(p.next().unwrap())?;
+
+    assert_eq!(p.next(), None);
+
+    Ok(Log { date, desc })
+}
+
 fn parse_command(p: Pair<'_, Rule>, file: &mut File) -> Result<()> {
     assert_eq!(p.as_rule(), Rule::command);
 
@@ -807,6 +824,7 @@ fn parse_command(p: Pair<'_, Rule>, file: &mut File) -> Result<()> {
         },
         Rule::task => file.commands.push(Command::Task(parse_task(p)?)),
         Rule::note => file.commands.push(Command::Note(parse_note(p)?)),
+        Rule::log => file.logs.push(parse_log(p)?),
         _ => unreachable!(),
     }
 
@@ -820,6 +838,7 @@ pub fn parse_file(p: Pair<'_, Rule>, contents: String) -> Result<File> {
         contents,
         includes: vec![],
         timezone: None,
+        logs: vec![],
         commands: vec![],
     };
 

From 004aa8715358c61ce6dbda6a6ac83f29544330a2 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sun, 2 Jan 2022 00:36:53 +0100
Subject: [PATCH 18/80] Disable modules in preparation for refactoring

This way, compile errors from modules further up the dependency chain
don't obscure the important errors
---
 src/main.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 9053d12..f2a48ef 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,10 +3,10 @@
 #![warn(clippy::all)]
 #![warn(clippy::use_self)]
 
-mod cli;
-mod eval;
+// mod cli;
+// mod eval;
 mod files;
 
 fn main() {
-    cli::run();
+    // cli::run();
 }

From d27812b836816a79e286567560b401cd7b2f9b96 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sun, 2 Jan 2022 00:42:06 +0100
Subject: [PATCH 19/80] Represent commands in file uniformly

---
 src/files/commands.rs | 29 +++--------------------------
 src/files/format.rs   | 35 +++++++++++------------------------
 src/files/parse.rs    | 34 +++++++++++-----------------------
 3 files changed, 25 insertions(+), 73 deletions(-)

diff --git a/src/files/commands.rs b/src/files/commands.rs
index ebb93d0..b527d99 100644
--- a/src/files/commands.rs
+++ b/src/files/commands.rs
@@ -345,38 +345,15 @@ pub struct Log {
 
 #[derive(Debug)]
 pub enum Command {
+    Include(String),
+    Timezone(String),
     Task(Task),
     Note(Note),
-}
-
-impl Command {
-    pub fn title(&self) -> &str {
-        match self {
-            Self::Task(task) => &task.title,
-            Self::Note(note) => &note.title,
-        }
-    }
-
-    pub fn desc(&self) -> &[String] {
-        match self {
-            Self::Task(task) => &task.desc,
-            Self::Note(note) => &note.desc,
-        }
-    }
-
-    pub fn statements(&self) -> &[Statement] {
-        match self {
-            Self::Task(task) => &task.statements,
-            Self::Note(note) => &note.statements,
-        }
-    }
+    Log(Log),
 }
 
 #[derive(Debug)]
 pub struct File {
     pub contents: String,
-    pub includes: Vec<String>,
-    pub timezone: Option<String>,
-    pub logs: Vec<Log>,
     pub commands: Vec<Command>,
 }
diff --git a/src/files/format.rs b/src/files/format.rs
index bc46e19..4274a2a 100644
--- a/src/files/format.rs
+++ b/src/files/format.rs
@@ -300,8 +300,11 @@ impl fmt::Display for Note {
 impl fmt::Display for Command {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
+            Command::Include(name) => writeln!(f, "INCLUDE {}", name),
+            Command::Timezone(name) => writeln!(f, "TIMEZONE {}", name),
             Command::Task(task) => write!(f, "{}", task),
             Command::Note(note) => write!(f, "{}", note),
+            Command::Log(log) => write!(f, "{}", log),
         }
     }
 }
@@ -316,33 +319,17 @@ impl fmt::Display for Log {
 
 impl fmt::Display for File {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut empty = true;
+        for i in 0..self.commands.len() {
+            let curr = &self.commands[i];
+            let next = self.commands.get(i + 1);
 
-        // TODO Sort includes alphabetically
-        for include in &self.includes {
-            writeln!(f, "INCLUDE {}", include)?;
-            empty = false;
-        }
+            write!(f, "{}", curr)?;
 
-        if let Some(tz) = &self.timezone {
-            if !empty {
-                writeln!(f)?;
+            match (curr, next) {
+                (Command::Include(_), Some(Command::Include(_))) => {}
+                (_, None) => {}
+                _ => writeln!(f)?,
             }
-            writeln!(f, "TIMEZONE {}", tz)?;
-            empty = false;
-        }
-
-        // TODO Sort logs from old to new
-        for log in &self.logs {
-            writeln!(f, "{}", log)?;
-        }
-
-        for command in &self.commands {
-            if !empty {
-                writeln!(f)?;
-            }
-            write!(f, "{}", command)?;
-            empty = false;
         }
 
         Ok(())
diff --git a/src/files/parse.rs b/src/files/parse.rs
index a60c850..2f5f615 100644
--- a/src/files/parse.rs
+++ b/src/files/parse.rs
@@ -812,46 +812,34 @@ fn parse_log(p: Pair<'_, Rule>) -> Result<Log> {
     Ok(Log { date, desc })
 }
 
-fn parse_command(p: Pair<'_, Rule>, file: &mut File) -> Result<()> {
+fn parse_command(p: Pair<'_, Rule>) -> Result<Command> {
     assert_eq!(p.as_rule(), Rule::command);
 
     let p = p.into_inner().next().unwrap();
-    match p.as_rule() {
-        Rule::include => file.includes.push(parse_include(p)),
-        Rule::timezone => match file.timezone {
-            None => file.timezone = Some(parse_timezone(p)),
-            Some(_) => fail(p.as_span(), "cannot set timezone multiple times")?,
-        },
-        Rule::task => file.commands.push(Command::Task(parse_task(p)?)),
-        Rule::note => file.commands.push(Command::Note(parse_note(p)?)),
-        Rule::log => file.logs.push(parse_log(p)?),
+    Ok(match p.as_rule() {
+        Rule::include => Command::Include(parse_include(p)),
+        Rule::timezone => Command::Timezone(parse_timezone(p)),
+        Rule::task => Command::Task(parse_task(p)?),
+        Rule::note => Command::Note(parse_note(p)?),
+        Rule::log => Command::Log(parse_log(p)?),
         _ => unreachable!(),
-    }
-
-    Ok(())
+    })
 }
 
 pub fn parse_file(p: Pair<'_, Rule>, contents: String) -> Result<File> {
     assert_eq!(p.as_rule(), Rule::file);
 
-    let mut file = File {
-        contents,
-        includes: vec![],
-        timezone: None,
-        logs: vec![],
-        commands: vec![],
-    };
-
+    let mut commands = vec![];
     for p in p.into_inner() {
         // For some reason, the EOI in `file` always gets captured
         if p.as_rule() == Rule::EOI {
             break;
         }
 
-        parse_command(p, &mut file)?;
+        commands.push(parse_command(p)?);
     }
 
-    Ok(file)
+    Ok(File { contents, commands })
 }
 
 pub fn parse(path: &Path, input: &str) -> Result<File> {

From d8617ede24ee9ea58172cf61f25070fb7bdd97d7 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sun, 2 Jan 2022 00:43:06 +0100
Subject: [PATCH 20/80] Adapt Files to new file representation

---
 src/files.rs       | 154 ++++++++++++++++++++++++++++-----------------
 src/files/error.rs |  29 +++++----
 2 files changed, 111 insertions(+), 72 deletions(-)

diff --git a/src/files.rs b/src/files.rs
index 0e5aded..3022ef1 100644
--- a/src/files.rs
+++ b/src/files.rs
@@ -1,12 +1,11 @@
-use std::collections::HashMap;
+use std::collections::hash_map::Entry;
+use std::collections::{HashMap, HashSet};
 use std::fs;
 use std::path::{Path, PathBuf};
 
-use chrono::{DateTime, Utc};
+use chrono::{DateTime, NaiveDate, Utc};
 use tzfile::Tz;
 
-use crate::eval::SourceInfo;
-
 use self::commands::{Command, Done, File};
 pub use self::error::{Error, Result};
 
@@ -46,6 +45,10 @@ pub struct Source {
 }
 
 impl Source {
+    pub fn new(file: usize, command: usize) -> Self {
+        Self { file, command }
+    }
+
     pub fn file(&self) -> usize {
         self.file
     }
@@ -61,19 +64,30 @@ pub struct SourcedCommand<'a> {
 pub struct Files {
     files: Vec<LoadedFile>,
     timezone: Tz,
+    logs: HashMap<NaiveDate, Source>,
 }
 
 impl Files {
+    /* Loading */
+
     pub fn load(path: &Path) -> Result<Self> {
-        let mut paths = HashMap::new();
+        // Track already loaded files by their normalized paths
+        let mut loaded = HashSet::new();
+
         let mut files = vec![];
-        Self::load_file(&mut paths, &mut files, path)?;
+        Self::load_file(&mut loaded, &mut files, path)?;
+
         let timezone = Self::determine_timezone(&files)?;
-        Ok(Self { files, timezone })
+        let logs = Self::collect_logs(&files)?;
+        Ok(Self {
+            files,
+            timezone,
+            logs,
+        })
     }
 
     fn load_file(
-        paths: &mut HashMap<PathBuf, usize>,
+        loaded: &mut HashSet<PathBuf>,
         files: &mut Vec<LoadedFile>,
         name: &Path,
     ) -> Result<()> {
@@ -81,7 +95,7 @@ impl Files {
             path: name.to_path_buf(),
             error: e,
         })?;
-        if paths.contains_key(&path) {
+        if loaded.contains(&path) {
             // We've already loaded this exact file.
             return Ok(());
         }
@@ -93,51 +107,72 @@ impl Files {
 
         // Using `name` instead of `path` for the unwrap below.
         let file = parse::parse(name, &content)?;
-        let includes = file.includes.clone();
 
-        paths.insert(path.clone(), files.len());
+        let includes = file
+            .commands
+            .iter()
+            .filter_map(|c| match c {
+                Command::Include(path) => Some(path.clone()),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+
+        loaded.insert(path.clone());
         files.push(LoadedFile::new(path, name.to_owned(), file));
 
         for include in includes {
             // Since we've successfully opened the file, its name can't be the
-            // root directory or empty string and must thus have a parent.
+            // root directory or empty string and it must thus have a parent.
             let include_path = name.parent().unwrap().join(include);
-            Self::load_file(paths, files, &include_path)?;
+            Self::load_file(loaded, files, &include_path)?;
         }
 
         Ok(())
     }
 
     fn determine_timezone(files: &[LoadedFile]) -> Result<Tz> {
-        let mut found: Option<(PathBuf, String)> = None;
+        let mut found: Option<String> = None;
 
-        for file in files {
-            if let Some(file_tz) = &file.file.timezone {
-                if let Some((found_name, found_tz)) = &found {
-                    if found_tz != file_tz {
+        for command in Self::commands_of_files(files) {
+            if let Command::Timezone(tz) = command.command {
+                if let Some(found_tz) = &found {
+                    if tz != found_tz {
                         return Err(Error::TzConflict {
-                            file1: found_name.clone(),
                             tz1: found_tz.clone(),
-                            file2: file.name.clone(),
-                            tz2: file_tz.clone(),
+                            tz2: tz.clone(),
                         });
                     }
                 } else {
-                    found = Some((file.name.clone(), file_tz.clone()));
+                    found = Some(tz.clone());
                 }
             }
         }
 
-        Ok(if let Some((_, tz)) = found {
-            Tz::named(&tz).map_err(|e| Error::ResolveTz {
-                timezone: tz,
-                error: e,
-            })?
+        Ok(if let Some(timezone) = found {
+            Tz::named(&timezone).map_err(|error| Error::ResolveTz { timezone, error })?
         } else {
-            Tz::local().map_err(|e| Error::LocalTz { error: e })?
+            Tz::local().map_err(|error| Error::LocalTz { error })?
         })
     }
 
+    fn collect_logs(files: &[LoadedFile]) -> Result<HashMap<NaiveDate, Source>> {
+        let mut logs = HashMap::new();
+
+        for command in Self::commands_of_files(files) {
+            if let Command::Log(log) = command.command {
+                if let Entry::Vacant(e) = logs.entry(log.date) {
+                    e.insert(command.source);
+                } else {
+                    return Err(Error::LogConflict(log.date));
+                }
+            }
+        }
+
+        Ok(logs)
+    }
+
+    /* Saving */
+
     pub fn save(&self) -> Result<()> {
         for file in &self.files {
             if file.dirty {
@@ -148,6 +183,7 @@ impl Files {
     }
 
     fn save_file(path: &Path, file: &File) -> Result<()> {
+        // TODO Sort commands within file
         let formatted = format!("{}", file);
         if file.contents == formatted {
             println!("Unchanged file {:?}", path);
@@ -161,26 +197,47 @@ impl Files {
         Ok(())
     }
 
-    pub fn mark_all_dirty(&mut self) {
-        for file in self.files.iter_mut() {
-            file.dirty = true;
+    /* Querying */
+
+    pub fn files(&self) -> Vec<(&Path, &File)> {
+        self.files
+            .iter()
+            .map(|f| (&f.name as &Path, &f.file))
+            .collect()
+    }
+
+    fn commands_of_files(files: &[LoadedFile]) -> Vec<SourcedCommand<'_>> {
+        let mut result = vec![];
+        for (file_index, file) in files.iter().enumerate() {
+            for (command_index, command) in file.file.commands.iter().enumerate() {
+                let source = Source::new(file_index, command_index);
+                result.push(SourcedCommand { source, command });
+            }
         }
+        result
+    }
+
+    pub fn commands(&self) -> Vec<SourcedCommand<'_>> {
+        Self::commands_of_files(&self.files)
     }
 
     pub fn command(&self, source: Source) -> &Command {
         &self.files[source.file].file.commands[source.command]
     }
 
-    pub fn sources(&self) -> Vec<SourceInfo<'_>> {
-        self.files
-            .iter()
-            .map(|f| SourceInfo {
-                name: Some(f.name.to_string_lossy().to_string()),
-                content: &f.file.contents,
-            })
-            .collect()
+    pub fn now(&self) -> DateTime<&Tz> {
+        Utc::now().with_timezone(&&self.timezone)
     }
 
+    /* Updating */
+
+    pub fn mark_all_dirty(&mut self) {
+        for file in self.files.iter_mut() {
+            file.dirty = true;
+        }
+    }
+
+    /*
     /// Add a [`Done`] statement to the task identified by `source`.
     ///
     /// Returns whether the addition was successful. It can fail if the entry
@@ -195,22 +252,5 @@ impl Files {
         file.dirty = true;
         true
     }
-
-    pub fn commands(&self) -> Vec<SourcedCommand<'_>> {
-        let mut result = vec![];
-        for (file_index, file) in self.files.iter().enumerate() {
-            for (command_index, command) in file.file.commands.iter().enumerate() {
-                let source = Source {
-                    file: file_index,
-                    command: command_index,
-                };
-                result.push(SourcedCommand { source, command });
-            }
-        }
-        result
-    }
-
-    pub fn now(&self) -> DateTime<&Tz> {
-        Utc::now().with_timezone(&&self.timezone)
-    }
+    */
 }
diff --git a/src/files/error.rs b/src/files/error.rs
index 27b766b..aace490 100644
--- a/src/files/error.rs
+++ b/src/files/error.rs
@@ -1,8 +1,12 @@
 use std::path::PathBuf;
 use std::{io, result};
 
+use chrono::NaiveDate;
+
 use super::parse;
 
+// TODO Format TzConflict and LogConflict errors better
+
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
     #[error("Could not resolve {path}: {error}")]
@@ -17,13 +21,10 @@ pub enum Error {
     LocalTz { error: io::Error },
     #[error("{0}")]
     Parse(#[from] parse::Error),
-    #[error("{file1} has time zone {tz1} but {file2} has time zone {tz2}")]
-    TzConflict {
-        file1: PathBuf,
-        tz1: String,
-        file2: PathBuf,
-        tz2: String,
-    },
+    #[error("Conflicting time zones {tz1} and {tz2}")]
+    TzConflict { tz1: String, tz2: String },
+    #[error("Duplicate logs for {0}")]
+    LogConflict(NaiveDate),
 }
 
 impl Error {
@@ -50,15 +51,13 @@ impl Error {
                 eprintln!("  {}", error);
             }
             Error::Parse(error) => eprintln!("{}", error),
-            Error::TzConflict {
-                file1,
-                tz1,
-                file2,
-                tz2,
-            } => {
+            Error::TzConflict { tz1, tz2 } => {
                 eprintln!("Time zone conflict:");
-                eprintln!("  {:?} has time zone {}", file1, tz1);
-                eprintln!("  {:?} has time zone {}", file2, tz2);
+                eprintln!("  Both {} and {} are specified", tz1, tz2);
+            }
+            Error::LogConflict(date) => {
+                eprintln!("Log conflict:");
+                eprintln!("  More than one entry exists for {}", date);
             }
         }
     }

From d9c1dc78e4004a5a769f9e66bc83c350af1edf68 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sun, 2 Jan 2022 11:47:22 +0100
Subject: [PATCH 21/80] Integrate codespan-reporting

---
 Cargo.lock   | 30 ++++++++++++++++++++++++++++++
 Cargo.toml   |  2 ++
 src/files.rs | 42 +++++++++++++++++++++++++++++++-----------
 3 files changed, 63 insertions(+), 11 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 3e90b27..13420f4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -101,6 +101,16 @@ dependencies = [
  "vec_map",
 ]
 
+[[package]]
+name = "codespan-reporting"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
+dependencies = [
+ "termcolor",
+ "unicode-width",
+]
+
 [[package]]
 name = "colored"
 version = "2.0.0"
@@ -391,6 +401,15 @@ dependencies = [
  "unicode-xid",
 ]
 
+[[package]]
+name = "termcolor"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dfed899f0eb03f32ee8c6a0aabdb8a7949659e3466561fc0adf54e26d88c5f4"
+dependencies = [
+ "winapi-util",
+]
+
 [[package]]
 name = "textwrap"
 version = "0.11.0"
@@ -436,12 +455,14 @@ name = "today"
 version = "0.1.0"
 dependencies = [
  "chrono",
+ "codespan-reporting",
  "colored",
  "computus",
  "directories",
  "pest",
  "pest_derive",
  "structopt",
+ "termcolor",
  "thiserror",
  "tzfile",
 ]
@@ -519,6 +540,15 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
+[[package]]
+name = "winapi-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+dependencies = [
+ "winapi",
+]
+
 [[package]]
 name = "winapi-x86_64-pc-windows-gnu"
 version = "0.4.0"
diff --git a/Cargo.toml b/Cargo.toml
index d0b6eb2..458483b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,11 +5,13 @@ edition = "2021"
 
 [dependencies]
 chrono = "0.4.19"
+codespan-reporting = "0.11.1"
 colored = "2.0.0"
 computus = "1.0.0"
 directories = "4.0.1"
 pest = "2.1.3"
 pest_derive = "2.1.0"
 structopt = "0.3.25"
+termcolor = "1.1.2"
 thiserror = "1.0.30"
 tzfile = { git = "https://github.com/Garmelon/tzfile.git", branch = "tzdir" }
diff --git a/src/files.rs b/src/files.rs
index 3022ef1..1e1f8bd 100644
--- a/src/files.rs
+++ b/src/files.rs
@@ -4,6 +4,10 @@ use std::fs;
 use std::path::{Path, PathBuf};
 
 use chrono::{DateTime, NaiveDate, Utc};
+use codespan_reporting::diagnostic::Diagnostic;
+use codespan_reporting::files::SimpleFiles;
+use codespan_reporting::term::{self, Config};
+use termcolor::StandardStream;
 use tzfile::Tz;
 
 use self::commands::{Command, Done, File};
@@ -16,22 +20,26 @@ mod format;
 mod parse;
 pub mod primitives;
 
+// TODO Move file content from `File` to `LoadedFile`
 #[derive(Debug)]
 struct LoadedFile {
-    /// Canonical path for this file
+    /// Canonical path for this file.
     path: PathBuf,
-    // User-readable path for this file
+    /// User-readable path for this file.
     name: PathBuf,
+    /// Identifier for codespan-reporting.
+    cs_id: usize,
     file: File,
-    /// Whether this file has been changed
+    /// Whether this file has been changed.
     dirty: bool,
 }
 
 impl LoadedFile {
-    pub fn new(path: PathBuf, name: PathBuf, file: File) -> Self {
+    pub fn new(path: PathBuf, name: PathBuf, cs_id: usize, file: File) -> Self {
         Self {
             path,
             name,
+            cs_id,
             file,
             dirty: false,
         }
@@ -48,10 +56,6 @@ impl Source {
     pub fn new(file: usize, command: usize) -> Self {
         Self { file, command }
     }
-
-    pub fn file(&self) -> usize {
-        self.file
-    }
 }
 
 #[derive(Debug)]
@@ -63,6 +67,8 @@ pub struct SourcedCommand<'a> {
 #[derive(Debug)]
 pub struct Files {
     files: Vec<LoadedFile>,
+    /// Codespan-reporting file database.
+    cs_files: SimpleFiles<String, String>,
     timezone: Tz,
     logs: HashMap<NaiveDate, Source>,
 }
@@ -75,12 +81,14 @@ impl Files {
         let mut loaded = HashSet::new();
 
         let mut files = vec![];
-        Self::load_file(&mut loaded, &mut files, path)?;
+        let mut cs_files = SimpleFiles::new();
+        Self::load_file(&mut loaded, &mut files, &mut cs_files, path)?;
 
         let timezone = Self::determine_timezone(&files)?;
         let logs = Self::collect_logs(&files)?;
         Ok(Self {
             files,
+            cs_files,
             timezone,
             logs,
         })
@@ -89,6 +97,7 @@ impl Files {
     fn load_file(
         loaded: &mut HashSet<PathBuf>,
         files: &mut Vec<LoadedFile>,
+        cs_files: &mut SimpleFiles<String, String>,
         name: &Path,
     ) -> Result<()> {
         let path = name.canonicalize().map_err(|e| Error::ResolvePath {
@@ -118,13 +127,14 @@ impl Files {
             .collect::<Vec<_>>();
 
         loaded.insert(path.clone());
-        files.push(LoadedFile::new(path, name.to_owned(), file));
+        let cs_id = cs_files.add(path.to_string_lossy().to_string(), content);
+        files.push(LoadedFile::new(path, name.to_owned(), cs_id, file));
 
         for include in includes {
             // Since we've successfully opened the file, its name can't be the
             // root directory or empty string and it must thus have a parent.
             let include_path = name.parent().unwrap().join(include);
-            Self::load_file(loaded, files, &include_path)?;
+            Self::load_file(loaded, files, cs_files, &include_path)?;
         }
 
         Ok(())
@@ -253,4 +263,14 @@ impl Files {
         true
     }
     */
+
+    /* Errors */
+
+    pub fn eprint_diagnostic(&self, diagnostic: &Diagnostic<usize>) {
+        let mut out = StandardStream::stderr(termcolor::ColorChoice::Auto);
+        let config = Config::default();
+        if let Err(e) = term::emit(&mut out, &config, &self.cs_files, diagnostic) {
+            panic!("Error while reporting error: {}", e);
+        }
+    }
 }

From ef287b9fd020a787bbb454d3720a05c69fb11ea3 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sun, 2 Jan 2022 13:46:04 +0100
Subject: [PATCH 22/80] Format some errors with codespan-reporting

---
 src/files.rs            | 155 ++++++++++++++++++++++++++++------------
 src/files/commands.rs   |   6 +-
 src/files/error.rs      |  93 +++++++++++++++++++-----
 src/files/parse.rs      |  18 +++--
 src/files/primitives.rs |   8 ++-
 5 files changed, 205 insertions(+), 75 deletions(-)

diff --git a/src/files.rs b/src/files.rs
index 1e1f8bd..1ac07a6 100644
--- a/src/files.rs
+++ b/src/files.rs
@@ -10,8 +10,9 @@ use codespan_reporting::term::{self, Config};
 use termcolor::StandardStream;
 use tzfile::Tz;
 
-use self::commands::{Command, Done, File};
+use self::commands::{Command, File};
 pub use self::error::{Error, Result};
+use self::primitives::Spanned;
 
 pub mod arguments;
 pub mod commands;
@@ -52,10 +53,18 @@ pub struct Source {
     command: usize,
 }
 
+// TODO Rename to `SourceFile`?
+#[derive(Debug, Clone, Copy)]
+pub struct FileSource(usize);
+
 impl Source {
     pub fn new(file: usize, command: usize) -> Self {
         Self { file, command }
     }
+
+    pub fn file(&self) -> FileSource {
+        FileSource(self.file)
+    }
 }
 
 #[derive(Debug)]
@@ -69,37 +78,47 @@ pub struct Files {
     files: Vec<LoadedFile>,
     /// Codespan-reporting file database.
     cs_files: SimpleFiles<String, String>,
-    timezone: Tz,
+    timezone: Option<Tz>,
     logs: HashMap<NaiveDate, Source>,
 }
 
 impl Files {
     /* Loading */
 
-    pub fn load(path: &Path) -> Result<Self> {
+    pub fn new() -> Self {
+        Self {
+            files: vec![],
+            cs_files: SimpleFiles::new(),
+            timezone: None,
+            logs: HashMap::new(),
+        }
+    }
+
+    /// Load a file and all its includes.
+    ///
+    /// # Warning
+    ///
+    /// - This function must be called before all other functions.
+    /// - This function must only be called once.
+    /// - If this function fails,
+    ///   - it is safe to print the error with [`Files::eprint_diagnostic`] and
+    ///   - no other function must be called.
+    pub fn load(&mut self, path: &Path) -> Result<()> {
+        if !self.files.is_empty() {
+            panic!("Files::load called multiple times");
+        }
+
         // Track already loaded files by their normalized paths
         let mut loaded = HashSet::new();
 
-        let mut files = vec![];
-        let mut cs_files = SimpleFiles::new();
-        Self::load_file(&mut loaded, &mut files, &mut cs_files, path)?;
+        self.load_file(&mut loaded, path)?;
+        self.determine_timezone()?;
+        self.collect_logs()?;
 
-        let timezone = Self::determine_timezone(&files)?;
-        let logs = Self::collect_logs(&files)?;
-        Ok(Self {
-            files,
-            cs_files,
-            timezone,
-            logs,
-        })
+        Ok(())
     }
 
-    fn load_file(
-        loaded: &mut HashSet<PathBuf>,
-        files: &mut Vec<LoadedFile>,
-        cs_files: &mut SimpleFiles<String, String>,
-        name: &Path,
-    ) -> Result<()> {
+    fn load_file(&mut self, loaded: &mut HashSet<PathBuf>, name: &Path) -> Result<()> {
         let path = name.canonicalize().map_err(|e| Error::ResolvePath {
             path: name.to_path_buf(),
             error: e,
@@ -127,58 +146,87 @@ impl Files {
             .collect::<Vec<_>>();
 
         loaded.insert(path.clone());
-        let cs_id = cs_files.add(path.to_string_lossy().to_string(), content);
-        files.push(LoadedFile::new(path, name.to_owned(), cs_id, file));
+        let cs_id = self
+            .cs_files
+            .add(path.to_string_lossy().to_string(), content);
+        self.files
+            .push(LoadedFile::new(path, name.to_owned(), cs_id, file));
 
         for include in includes {
             // Since we've successfully opened the file, its name can't be the
             // root directory or empty string and it must thus have a parent.
-            let include_path = name.parent().unwrap().join(include);
-            Self::load_file(loaded, files, cs_files, &include_path)?;
+            let include_path = name.parent().unwrap().join(include.value);
+            self.load_file(loaded, &include_path)?;
         }
 
         Ok(())
     }
 
-    fn determine_timezone(files: &[LoadedFile]) -> Result<Tz> {
-        let mut found: Option<String> = None;
+    fn determine_timezone(&mut self) -> Result<()> {
+        assert_eq!(self.timezone, None);
 
-        for command in Self::commands_of_files(files) {
+        let mut found: Option<(Source, Spanned<String>)> = None;
+
+        for command in self.commands() {
             if let Command::Timezone(tz) = command.command {
-                if let Some(found_tz) = &found {
-                    if tz != found_tz {
+                if let Some((found_source, found_tz)) = &found {
+                    if tz.value != found_tz.value {
                         return Err(Error::TzConflict {
-                            tz1: found_tz.clone(),
-                            tz2: tz.clone(),
+                            file1: found_source.file(),
+                            span1: found_tz.span,
+                            tz1: found_tz.value.clone(),
+                            file2: command.source.file(),
+                            span2: tz.span,
+                            tz2: tz.value.clone(),
                         });
                     }
                 } else {
-                    found = Some(tz.clone());
+                    found = Some((command.source, tz.clone()));
                 }
             }
         }
 
-        Ok(if let Some(timezone) = found {
-            Tz::named(&timezone).map_err(|error| Error::ResolveTz { timezone, error })?
+        let timezone = if let Some((source, tz)) = found {
+            Tz::named(&tz.value).map_err(|error| Error::ResolveTz {
+                file: source.file(),
+                span: tz.span,
+                tz: tz.value,
+                error,
+            })?
         } else {
             Tz::local().map_err(|error| Error::LocalTz { error })?
-        })
+        };
+        self.timezone = Some(timezone);
+
+        Ok(())
     }
 
-    fn collect_logs(files: &[LoadedFile]) -> Result<HashMap<NaiveDate, Source>> {
-        let mut logs = HashMap::new();
-
-        for command in Self::commands_of_files(files) {
+    fn collect_logs(&mut self) -> Result<()> {
+        for command in Self::commands_of_files(&self.files) {
             if let Command::Log(log) = command.command {
-                if let Entry::Vacant(e) = logs.entry(log.date) {
-                    e.insert(command.source);
-                } else {
-                    return Err(Error::LogConflict(log.date));
+                match self.logs.entry(log.date.value) {
+                    Entry::Vacant(e) => {
+                        e.insert(command.source);
+                    }
+                    Entry::Occupied(e) => {
+                        let other_cmd = Self::command_of_files(&self.files, *e.get());
+                        let other_span = match &other_cmd.command {
+                            Command::Log(log) => log.date.span,
+                            _ => unreachable!(),
+                        };
+                        return Err(Error::LogConflict {
+                            file1: other_cmd.source.file(),
+                            span1: other_span,
+                            file2: command.source.file(),
+                            span2: log.date.span,
+                            date: log.date.value,
+                        });
+                    }
                 }
             }
         }
 
-        Ok(logs)
+        Ok(())
     }
 
     /* Saving */
@@ -231,12 +279,21 @@ impl Files {
         Self::commands_of_files(&self.files)
     }
 
-    pub fn command(&self, source: Source) -> &Command {
-        &self.files[source.file].file.commands[source.command]
+    fn command_of_files(files: &[LoadedFile], source: Source) -> SourcedCommand<'_> {
+        let command = &files[source.file].file.commands[source.command];
+        SourcedCommand { source, command }
+    }
+
+    pub fn command(&self, source: Source) -> SourcedCommand<'_> {
+        Self::command_of_files(&self.files, source)
     }
 
     pub fn now(&self) -> DateTime<&Tz> {
-        Utc::now().with_timezone(&&self.timezone)
+        if let Some(tz) = &self.timezone {
+            Utc::now().with_timezone(&tz)
+        } else {
+            panic!("Called Files::now before Files::load");
+        }
     }
 
     /* Updating */
@@ -266,6 +323,10 @@ impl Files {
 
     /* Errors */
 
+    pub fn cs_id(&self, file: FileSource) -> usize {
+        self.files[file.0].cs_id
+    }
+
     pub fn eprint_diagnostic(&self, diagnostic: &Diagnostic<usize>) {
         let mut out = StandardStream::stderr(termcolor::ColorChoice::Auto);
         let config = Config::default();
diff --git a/src/files/commands.rs b/src/files/commands.rs
index b527d99..bda9ce7 100644
--- a/src/files/commands.rs
+++ b/src/files/commands.rs
@@ -339,14 +339,14 @@ pub struct Note {
 
 #[derive(Debug)]
 pub struct Log {
-    pub date: NaiveDate,
+    pub date: Spanned<NaiveDate>,
     pub desc: Vec<String>,
 }
 
 #[derive(Debug)]
 pub enum Command {
-    Include(String),
-    Timezone(String),
+    Include(Spanned<String>),
+    Timezone(Spanned<String>),
     Task(Task),
     Note(Note),
     Log(Log),
diff --git a/src/files/error.rs b/src/files/error.rs
index aace490..3b8dc34 100644
--- a/src/files/error.rs
+++ b/src/files/error.rs
@@ -2,10 +2,10 @@ use std::path::PathBuf;
 use std::{io, result};
 
 use chrono::NaiveDate;
+use codespan_reporting::diagnostic::{Diagnostic, Label};
 
-use super::parse;
-
-// TODO Format TzConflict and LogConflict errors better
+use super::primitives::Span;
+use super::{parse, FileSource, Files};
 
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
@@ -15,20 +15,38 @@ pub enum Error {
     ReadFile { file: PathBuf, error: io::Error },
     #[error("Could not write {file}: {error}")]
     WriteFile { file: PathBuf, error: io::Error },
-    #[error("Could not resolve timezone {timezone}: {error}")]
-    ResolveTz { timezone: String, error: io::Error },
+    #[error("Could not resolve timezone {tz}: {error}")]
+    ResolveTz {
+        file: FileSource,
+        span: Span,
+        tz: String,
+        error: io::Error,
+    },
     #[error("Could not determine local timezone: {error}")]
     LocalTz { error: io::Error },
     #[error("{0}")]
     Parse(#[from] parse::Error),
     #[error("Conflicting time zones {tz1} and {tz2}")]
-    TzConflict { tz1: String, tz2: String },
-    #[error("Duplicate logs for {0}")]
-    LogConflict(NaiveDate),
+    TzConflict {
+        file1: FileSource,
+        span1: Span,
+        tz1: String,
+        file2: FileSource,
+        span2: Span,
+        tz2: String,
+    },
+    #[error("Duplicate logs for {date}")]
+    LogConflict {
+        file1: FileSource,
+        span1: Span,
+        file2: FileSource,
+        span2: Span,
+        date: NaiveDate,
+    },
 }
 
 impl Error {
-    pub fn print(&self) {
+    pub fn print(&self, files: &Files) {
         match self {
             Error::ResolvePath { path, error } => {
                 eprintln!("Could not resolve path {:?}:", path);
@@ -42,22 +60,61 @@ impl Error {
                 eprintln!("Could not write file {:?}:", file);
                 eprintln!("  {}", error);
             }
-            Error::ResolveTz { timezone, error } => {
-                eprintln!("Could not resolve time zone {}:", timezone);
-                eprintln!("  {}", error);
+            Error::ResolveTz {
+                file,
+                span,
+                tz,
+                error,
+            } => {
+                let diagnostic = Diagnostic::error()
+                    .with_message(format!("Could not resolve time zone {}", tz))
+                    .with_labels(vec![Label::primary(files.cs_id(*file), span)
+                        .with_message("Time zone defined here")])
+                    .with_notes(vec![format!("{}", error)]);
+                files.eprint_diagnostic(&diagnostic);
             }
             Error::LocalTz { error } => {
                 eprintln!("Could not determine local timezone:");
                 eprintln!("  {}", error);
             }
+            // TODO Format using codespan-reporting as well
             Error::Parse(error) => eprintln!("{}", error),
-            Error::TzConflict { tz1, tz2 } => {
-                eprintln!("Time zone conflict:");
-                eprintln!("  Both {} and {} are specified", tz1, tz2);
+            Error::TzConflict {
+                file1,
+                span1,
+                tz1,
+                file2,
+                span2,
+                tz2,
+            } => {
+                let diagnostic = Diagnostic::error()
+                    .with_message(format!("Time zone conflict between {} and {}", tz1, tz2))
+                    .with_labels(vec![
+                        Label::primary(files.cs_id(*file1), span1)
+                            .with_message("Time zone defined here"),
+                        Label::primary(files.cs_id(*file2), span2)
+                            .with_message("Time zone defined here"),
+                    ])
+                    .with_notes(vec![
+                        "All TIMEZONE commands must set the same time zone.".to_string()
+                    ]);
+                files.eprint_diagnostic(&diagnostic);
             }
-            Error::LogConflict(date) => {
-                eprintln!("Log conflict:");
-                eprintln!("  More than one entry exists for {}", date);
+            Error::LogConflict {
+                file1,
+                span1,
+                file2,
+                span2,
+                date,
+            } => {
+                let diagnostic = Diagnostic::error()
+                    .with_message(format!("Duplicate log entries for {}", date))
+                    .with_labels(vec![
+                        Label::primary(files.cs_id(*file1), span1).with_message("Log defined here"),
+                        Label::primary(files.cs_id(*file2), span2).with_message("Log defined here"),
+                    ])
+                    .with_notes(vec!["A day can have at most one LOG entry.".to_string()]);
+                files.eprint_diagnostic(&diagnostic);
             }
         }
     }
diff --git a/src/files/parse.rs b/src/files/parse.rs
index 2f5f615..f817d1d 100644
--- a/src/files/parse.rs
+++ b/src/files/parse.rs
@@ -33,14 +33,20 @@ fn fail<S: Into<String>, T>(span: Span<'_>, message: S) -> Result<T> {
     Err(error(span, message))
 }
 
-fn parse_include(p: Pair<'_, Rule>) -> String {
+fn parse_include(p: Pair<'_, Rule>) -> Spanned<String> {
     assert_eq!(p.as_rule(), Rule::include);
-    p.into_inner().next().unwrap().as_str().to_string()
+    let p = p.into_inner().next().unwrap();
+    let span = (&p.as_span()).into();
+    let name = p.as_str().to_string();
+    Spanned::new(span, name)
 }
 
-fn parse_timezone(p: Pair<'_, Rule>) -> String {
+fn parse_timezone(p: Pair<'_, Rule>) -> Spanned<String> {
     assert_eq!(p.as_rule(), Rule::timezone);
-    p.into_inner().next().unwrap().as_str().trim().to_string()
+    let p = p.into_inner().next().unwrap();
+    let span = (&p.as_span()).into();
+    let name = p.as_str().to_string();
+    Spanned::new(span, name)
 }
 
 fn parse_number(p: Pair<'_, Rule>) -> i32 {
@@ -795,9 +801,9 @@ fn parse_note(p: Pair<'_, Rule>) -> Result<Note> {
     })
 }
 
-fn parse_log_head(p: Pair<'_, Rule>) -> Result<NaiveDate> {
+fn parse_log_head(p: Pair<'_, Rule>) -> Result<Spanned<NaiveDate>> {
     assert_eq!(p.as_rule(), Rule::log_head);
-    Ok(parse_datum(p.into_inner().next().unwrap())?.value)
+    parse_datum(p.into_inner().next().unwrap())
 }
 
 fn parse_log(p: Pair<'_, Rule>) -> Result<Log> {
diff --git a/src/files/primitives.rs b/src/files/primitives.rs
index a31b297..118bfb3 100644
--- a/src/files/primitives.rs
+++ b/src/files/primitives.rs
@@ -1,5 +1,5 @@
 use std::cmp::{self, Ordering};
-use std::fmt;
+use std::{fmt, ops};
 
 use chrono::{NaiveTime, Timelike};
 
@@ -18,6 +18,12 @@ impl<'a> From<&pest::Span<'a>> for Span {
     }
 }
 
+impl From<&Span> for ops::Range<usize> {
+    fn from(span: &Span) -> Self {
+        span.start..span.end
+    }
+}
+
 impl Span {
     pub fn join(self, other: Self) -> Self {
         Self {

From 810ec67cf79602ed53c850002b1aed34ffb1ffe5 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sun, 2 Jan 2022 13:46:32 +0100
Subject: [PATCH 23/80] Reenable basic cli interaction

---
 src/cli.rs  | 44 +++++++++++++++++++++++++-------------------
 src/main.rs |  4 ++--
 2 files changed, 27 insertions(+), 21 deletions(-)

diff --git a/src/cli.rs b/src/cli.rs
index 027bc60..2decacf 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -6,19 +6,19 @@ use chrono::{NaiveDate, NaiveDateTime};
 use directories::ProjectDirs;
 use structopt::StructOpt;
 
-use crate::eval::{DateRange, Entry, EntryMode, SourceInfo};
+// use crate::eval::{DateRange, Entry, EntryMode, SourceInfo};
 use crate::files::arguments::Range;
 use crate::files::{self, Files};
 
-use self::error::Result;
-use self::layout::line::LineLayout;
+// use self::error::Result;
+// use self::layout::line::LineLayout;
 
-mod cancel;
-mod done;
-mod error;
-mod layout;
-mod print;
-mod show;
+// mod cancel;
+// mod done;
+// mod error;
+// mod layout;
+// mod print;
+// mod show;
 
 #[derive(Debug, StructOpt)]
 pub struct Opt {
@@ -67,11 +67,13 @@ fn default_file() -> PathBuf {
         .join("main.today")
 }
 
-fn load_files(opt: &Opt) -> result::Result<Files, files::Error> {
+fn load_files(opt: &Opt, files: &mut Files) -> result::Result<(), files::Error> {
     let file = opt.file.clone().unwrap_or_else(default_file);
-    Files::load(&file)
+    files.load(&file)
 }
 
+/*
+
 fn find_now(opt: &Opt, files: &Files) -> NaiveDateTime {
     let now = files.now().naive_local();
     if let Some(date) = opt.date {
@@ -127,16 +129,18 @@ fn run_command(opt: &Opt, files: &mut Files, range: DateRange, now: NaiveDateTim
     Ok(())
 }
 
+*/
+
 pub fn run() {
     let opt = Opt::from_args();
 
-    let mut files = match load_files(&opt) {
-        Ok(result) => result,
-        Err(e) => {
-            e.print();
-            process::exit(1);
-        }
-    };
+    let mut files = Files::new();
+    if let Err(e) = load_files(&opt, &mut files) {
+        e.print(&files);
+        process::exit(1);
+    }
+
+    /*
 
     let now = find_now(&opt, &files);
 
@@ -164,8 +168,10 @@ pub fn run() {
         process::exit(1);
     }
 
+    */
+
     if let Err(e) = files.save() {
-        e.print();
+        e.print(&files);
         process::exit(1);
     }
 }
diff --git a/src/main.rs b/src/main.rs
index f2a48ef..40770a6 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,10 +3,10 @@
 #![warn(clippy::all)]
 #![warn(clippy::use_self)]
 
-// mod cli;
+mod cli;
 // mod eval;
 mod files;
 
 fn main() {
-    // cli::run();
+    cli::run();
 }

From 8ae691bc3cb0ce8838d2c91c78c36e7abb5c1321 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sun, 2 Jan 2022 15:05:37 +0100
Subject: [PATCH 24/80] Adapt eval code to changes

These changes include the new file representation and Files API as well
as the codespan error reporting.
---
 src/eval.rs                  |  17 ++--
 src/eval/command.rs          | 131 +++++++++++++++----------
 src/eval/command/birthday.rs |   5 +-
 src/eval/command/date.rs     |  30 +++---
 src/eval/command/formula.rs  |  30 +++---
 src/eval/delta.rs            |  55 ++++++-----
 src/eval/error.rs            | 183 +++++++++++++++--------------------
 src/main.rs                  |   2 +-
 8 files changed, 238 insertions(+), 215 deletions(-)

diff --git a/src/eval.rs b/src/eval.rs
index e596ab1..80f3033 100644
--- a/src/eval.rs
+++ b/src/eval.rs
@@ -1,14 +1,14 @@
 use chrono::NaiveDate;
 
 use crate::files::arguments::{Range, RangeDate};
-use crate::files::Files;
+use crate::files::{FileSource, Files};
 
-use self::command::CommandState;
+use self::command::{CommandState, EvalCommand};
 pub use self::date::Dates;
 use self::delta::Delta;
 use self::entry::Entries;
 pub use self::entry::{Entry, EntryKind, EntryMode};
-pub use self::error::{Error, Result, SourceInfo};
+pub use self::error::Error;
 pub use self::range::DateRange;
 
 mod command;
@@ -20,11 +20,14 @@ mod range;
 mod util;
 
 impl Files {
-    pub fn eval(&self, mode: EntryMode, range: DateRange) -> Result<Vec<Entry>> {
+    pub fn eval(&self, mode: EntryMode, range: DateRange) -> Result<Vec<Entry>, Error<FileSource>> {
         let mut entries = Entries::new(mode, range);
         for command in self.commands() {
-            for entry in CommandState::new(command, range).eval()?.entries() {
-                entries.add(entry);
+            let source = command.source;
+            if let Some(command) = EvalCommand::new(command.command) {
+                for entry in CommandState::new(command, source, range).eval()?.entries() {
+                    entries.add(entry);
+                }
             }
         }
         Ok(entries.entries())
@@ -32,7 +35,7 @@ impl Files {
 }
 
 impl Range {
-    pub fn eval(&self, index: usize, today: NaiveDate) -> Result<DateRange> {
+    pub fn eval<S: Copy>(&self, index: S, today: NaiveDate) -> Result<DateRange, Error<S>> {
         let mut start = match self.start {
             RangeDate::Date(d) => d,
             RangeDate::Today => today,
diff --git a/src/eval/command.rs b/src/eval/command.rs
index b0ec4a5..e50e580 100644
--- a/src/eval/command.rs
+++ b/src/eval/command.rs
@@ -6,18 +6,69 @@ use crate::files::commands::{
     self, BirthdaySpec, Command, Done, DoneDate, DoneKind, Note, Spec, Statement, Task,
 };
 use crate::files::primitives::{Span, Spanned, Time};
-use crate::files::SourcedCommand;
+use crate::files::{FileSource, Source};
 
 use super::date::Dates;
 use super::delta::Delta;
-use super::{DateRange, Entry, EntryKind, Error, Result};
+use super::{DateRange, Entry, EntryKind, Error};
 
 mod birthday;
 mod date;
 mod formula;
 
+/// A command that can be evaluated.
+pub enum EvalCommand<'a> {
+    Task(&'a Task),
+    Note(&'a Note),
+}
+
+impl<'a> EvalCommand<'a> {
+    pub fn new(command: &'a Command) -> Option<Self> {
+        match command {
+            Command::Task(task) => Some(Self::Task(task)),
+            Command::Note(note) => Some(Self::Note(note)),
+            _ => None,
+        }
+    }
+
+    fn statements(&self) -> &[Statement] {
+        match self {
+            Self::Task(task) => &task.statements,
+            Self::Note(note) => &note.statements,
+        }
+    }
+
+    fn kind(&self) -> EntryKind {
+        match self {
+            Self::Task(_) => EntryKind::Task,
+            Self::Note(_) => EntryKind::Note,
+        }
+    }
+
+    /// Last root date mentioned in any `DONE`.
+    fn last_done_root(&self) -> Option<NaiveDate> {
+        match self {
+            Self::Task(task) => task
+                .done
+                .iter()
+                .filter_map(|done| done.date.map(DoneDate::root))
+                .max(),
+            Self::Note(_) => None,
+        }
+    }
+
+    /// Last completion date mentioned in any `DONE`.
+    fn last_done_completion(&self) -> Option<NaiveDate> {
+        match self {
+            Self::Task(task) => task.done.iter().map(|done| done.done_at).max(),
+            Self::Note(_) => None,
+        }
+    }
+}
+
 pub struct CommandState<'a> {
-    command: SourcedCommand<'a>,
+    command: EvalCommand<'a>,
+    source: Source,
     range: DateRange,
 
     from: Option<NaiveDate>,
@@ -29,7 +80,7 @@ pub struct CommandState<'a> {
 }
 
 impl<'a> CommandState<'a> {
-    pub fn new(command: SourcedCommand<'a>, mut range: DateRange) -> Self {
+    pub fn new(command: EvalCommand<'a>, source: Source, mut range: DateRange) -> Self {
         // If we don't calculate entries for the source of the move command, it
         // fails even though the user did nothing wrong. Also, move commands (or
         // chains thereof) may move an initially out-of-range entry into range.
@@ -37,15 +88,16 @@ impl<'a> CommandState<'a> {
         // To fix this, we just expand the range to contain all move command
         // sources. This is a quick fix, but until it becomes a performance
         // issue (if ever), it's probably fine.
-        for statement in command.command.statements() {
+        for statement in command.statements() {
             if let Statement::Move { from, .. } = statement {
                 range = range.containing(*from)
             }
         }
 
         Self {
-            range,
             command,
+            source,
+            range,
             from: None,
             until: None,
             remind: None,
@@ -54,10 +106,10 @@ impl<'a> CommandState<'a> {
         }
     }
 
-    pub fn eval(mut self) -> Result<Self> {
-        match self.command.command {
-            Command::Task(task) => self.eval_task(task)?,
-            Command::Note(note) => self.eval_note(note)?,
+    pub fn eval(mut self) -> Result<Self, Error<FileSource>> {
+        match self.command {
+            EvalCommand::Task(task) => self.eval_task(task)?,
+            EvalCommand::Note(note) => self.eval_note(note)?,
         }
         Ok(self)
     }
@@ -71,13 +123,6 @@ impl<'a> CommandState<'a> {
 
     // Helper functions
 
-    fn kind(&self) -> EntryKind {
-        match self.command.command {
-            Command::Task(_) => EntryKind::Task,
-            Command::Note(_) => EntryKind::Note,
-        }
-    }
-
     fn range_with_remind(&self) -> DateRange {
         match &self.remind {
             None => self.range,
@@ -85,26 +130,6 @@ impl<'a> CommandState<'a> {
         }
     }
 
-    /// Last root date mentioned in any `DONE`.
-    fn last_done_root(&self) -> Option<NaiveDate> {
-        match self.command.command {
-            Command::Task(task) => task
-                .done
-                .iter()
-                .filter_map(|done| done.date.map(DoneDate::root))
-                .max(),
-            Command::Note(_) => None,
-        }
-    }
-
-    /// Last completion date mentioned in any `DONE`.
-    fn last_done_completion(&self) -> Option<NaiveDate> {
-        match self.command.command {
-            Command::Task(task) => task.done.iter().map(|done| done.done_at).max(),
-            Command::Note(_) => None,
-        }
-    }
-
     fn limit_from_until(&self, range: DateRange) -> Option<DateRange> {
         let range_from = range.from();
         let from = self
@@ -125,9 +150,13 @@ impl<'a> CommandState<'a> {
         }
     }
 
-    fn entry_with_remind(&self, kind: EntryKind, dates: Option<Dates>) -> Result<Entry> {
+    fn entry_with_remind(
+        &self,
+        kind: EntryKind,
+        dates: Option<Dates>,
+    ) -> Result<Entry, Error<FileSource>> {
         let remind = if let (Some(dates), Some(delta)) = (dates, &self.remind) {
-            let index = self.command.source.file();
+            let index = self.source.file();
             let start = dates.sorted().root();
             let remind = delta.value.apply_date(index, dates.sorted().root())?;
             if remind >= start {
@@ -143,7 +172,7 @@ impl<'a> CommandState<'a> {
             None
         };
 
-        Ok(Entry::new(self.command.source, kind, dates, remind))
+        Ok(Entry::new(self.source, kind, dates, remind))
     }
 
     /// Add an entry, respecting [`Self::from`] and [`Self::until`]. Does not
@@ -185,13 +214,13 @@ impl<'a> CommandState<'a> {
             .any(|s| matches!(s, Statement::Date(_) | Statement::BDate(_)))
     }
 
-    fn eval_task(&mut self, task: &Task) -> Result<()> {
+    fn eval_task(&mut self, task: &Task) -> Result<(), Error<FileSource>> {
         if Self::has_date_stmt(&task.statements) {
             for statement in &task.statements {
                 self.eval_statement(statement)?;
             }
         } else if task.done.is_empty() {
-            self.add(self.entry_with_remind(self.kind(), None)?);
+            self.add(self.entry_with_remind(self.command.kind(), None)?);
         }
 
         for done in &task.done {
@@ -201,19 +230,19 @@ impl<'a> CommandState<'a> {
         Ok(())
     }
 
-    fn eval_note(&mut self, note: &Note) -> Result<()> {
+    fn eval_note(&mut self, note: &Note) -> Result<(), Error<FileSource>> {
         if Self::has_date_stmt(&note.statements) {
             for statement in &note.statements {
                 self.eval_statement(statement)?;
             }
         } else {
-            self.add(self.entry_with_remind(self.kind(), None)?);
+            self.add(self.entry_with_remind(self.command.kind(), None)?);
         }
 
         Ok(())
     }
 
-    fn eval_statement(&mut self, statement: &Statement) -> Result<()> {
+    fn eval_statement(&mut self, statement: &Statement) -> Result<(), Error<FileSource>> {
         match statement {
             Statement::Date(spec) => self.eval_date(spec)?,
             Statement::BDate(spec) => self.eval_bdate(spec)?,
@@ -231,7 +260,7 @@ impl<'a> CommandState<'a> {
         Ok(())
     }
 
-    fn eval_date(&mut self, spec: &Spec) -> Result<()> {
+    fn eval_date(&mut self, spec: &Spec) -> Result<(), Error<FileSource>> {
         match spec {
             Spec::Date(spec) => self.eval_date_spec(spec.into()),
             Spec::Weekday(spec) => self.eval_formula_spec(spec.into()),
@@ -239,7 +268,7 @@ impl<'a> CommandState<'a> {
         }
     }
 
-    fn eval_bdate(&mut self, spec: &BirthdaySpec) -> Result<()> {
+    fn eval_bdate(&mut self, spec: &BirthdaySpec) -> Result<(), Error<FileSource>> {
         self.eval_birthday_spec(spec)
     }
 
@@ -254,7 +283,7 @@ impl<'a> CommandState<'a> {
         from: NaiveDate,
         to: Option<NaiveDate>,
         to_time: Option<Spanned<Time>>,
-    ) -> Result<()> {
+    ) -> Result<(), Error<FileSource>> {
         if let Some(mut entry) = self.dated.remove(&from) {
             let mut dates = entry.dates.expect("comes from self.dated");
 
@@ -268,7 +297,7 @@ impl<'a> CommandState<'a> {
                     delta = delta + Duration::minutes(root.minutes_to(to_time.value));
                 } else {
                     return Err(Error::TimedMoveWithoutTime {
-                        index: self.command.source.file(),
+                        index: self.source.file(),
                         span: to_time.span,
                     });
                 }
@@ -281,7 +310,7 @@ impl<'a> CommandState<'a> {
             Ok(())
         } else {
             Err(Error::MoveWithoutSource {
-                index: self.command.source.file(),
+                index: self.source.file(),
                 span,
             })
         }
@@ -295,7 +324,7 @@ impl<'a> CommandState<'a> {
         }
     }
 
-    fn eval_done(&mut self, done: &Done) -> Result<()> {
+    fn eval_done(&mut self, done: &Done) -> Result<(), Error<FileSource>> {
         let kind = match done.kind {
             DoneKind::Done => EntryKind::TaskDone(done.done_at),
             DoneKind::Canceled => EntryKind::TaskCanceled(done.done_at),
diff --git a/src/eval/command/birthday.rs b/src/eval/command/birthday.rs
index b10d83f..cec1d2e 100644
--- a/src/eval/command/birthday.rs
+++ b/src/eval/command/birthday.rs
@@ -1,14 +1,15 @@
 use chrono::{Datelike, NaiveDate};
 
 use crate::files::commands::BirthdaySpec;
+use crate::files::FileSource;
 
 use super::super::command::CommandState;
 use super::super::date::Dates;
-use super::super::error::Result;
+use super::super::error::Error;
 use super::super::EntryKind;
 
 impl<'a> CommandState<'a> {
-    pub fn eval_birthday_spec(&mut self, spec: &BirthdaySpec) -> Result<()> {
+    pub fn eval_birthday_spec(&mut self, spec: &BirthdaySpec) -> Result<(), Error<FileSource>> {
         let range = match self.limit_from_until(self.range_with_remind()) {
             Some(range) => range,
             None => return Ok(()),
diff --git a/src/eval/command/date.rs b/src/eval/command/date.rs
index 8ef5ff6..f7ddacb 100644
--- a/src/eval/command/date.rs
+++ b/src/eval/command/date.rs
@@ -1,12 +1,14 @@
 use chrono::NaiveDate;
 
-use crate::files::commands::{self, Command};
+use crate::files::commands;
 use crate::files::primitives::{Spanned, Time};
+use crate::files::FileSource;
 
 use super::super::command::CommandState;
 use super::super::date::Dates;
 use super::super::delta::{Delta, DeltaStep};
-use super::super::{DateRange, Error, Result};
+use super::super::{DateRange, Error};
+use super::EvalCommand;
 
 pub struct DateSpec {
     pub start: NaiveDate,
@@ -72,14 +74,16 @@ impl DateSpec {
     /// `start` date itself should be skipped (and thus not result in an entry).
     /// This may be necessary if [`Self::start_at_done`] is set.
     fn start_and_range(&self, s: &CommandState<'_>) -> Option<(NaiveDate, bool, DateRange)> {
-        let (start, skip, range) = match s.command.command {
-            Command::Task(_) => {
+        let (start, skip, range) = match s.command {
+            EvalCommand::Task(_) => {
                 let (start, skip) = s
+                    .command
                     .last_done_completion()
                     .map(|start| (start, true))
                     .filter(|_| self.start_at_done)
                     .unwrap_or((self.start, false));
                 let range_from = s
+                    .command
                     .last_done_root()
                     .map(|date| date.succ())
                     .unwrap_or(self.start);
@@ -90,7 +94,7 @@ impl DateSpec {
                     .with_from(range_from)?;
                 (start, skip, range)
             }
-            Command::Note(_) => {
+            EvalCommand::Note(_) => {
                 let start = self.start;
                 let range = s
                     .range_with_remind()
@@ -103,7 +107,11 @@ impl DateSpec {
         Some((start, skip, range))
     }
 
-    fn step(index: usize, from: NaiveDate, repeat: &Spanned<Delta>) -> Result<NaiveDate> {
+    fn step(
+        index: FileSource,
+        from: NaiveDate,
+        repeat: &Spanned<Delta>,
+    ) -> Result<NaiveDate, Error<FileSource>> {
         let to = repeat.value.apply_date(index, from)?;
         if to > from {
             Ok(to)
@@ -117,7 +125,7 @@ impl DateSpec {
         }
     }
 
-    fn dates(&self, index: usize, start: NaiveDate) -> Result<Dates> {
+    fn dates(&self, index: FileSource, start: NaiveDate) -> Result<Dates, Error<FileSource>> {
         let root = self.start_delta.apply_date(index, start)?;
         Ok(if let Some(root_time) = self.start_time {
             let (other, other_time) = self.end_delta.apply_date_time(index, root, root_time)?;
@@ -130,8 +138,8 @@ impl DateSpec {
 }
 
 impl<'a> CommandState<'a> {
-    pub fn eval_date_spec(&mut self, spec: DateSpec) -> Result<()> {
-        let index = self.command.source.file();
+    pub fn eval_date_spec(&mut self, spec: DateSpec) -> Result<(), Error<FileSource>> {
+        let index = self.source.file();
         if let Some(repeat) = &spec.repeat {
             if let Some((mut start, skip, range)) = spec.start_and_range(self) {
                 if skip {
@@ -142,13 +150,13 @@ impl<'a> CommandState<'a> {
                 }
                 while start <= range.until() {
                     let dates = spec.dates(index, start)?;
-                    self.add(self.entry_with_remind(self.kind(), Some(dates))?);
+                    self.add(self.entry_with_remind(self.command.kind(), Some(dates))?);
                     start = DateSpec::step(index, start, repeat)?;
                 }
             }
         } else {
             let dates = spec.dates(index, spec.start)?;
-            self.add(self.entry_with_remind(self.kind(), Some(dates))?);
+            self.add(self.entry_with_remind(self.command.kind(), Some(dates))?);
         }
         Ok(())
     }
diff --git a/src/eval/command/formula.rs b/src/eval/command/formula.rs
index 5ecc6a2..e733937 100644
--- a/src/eval/command/formula.rs
+++ b/src/eval/command/formula.rs
@@ -1,12 +1,14 @@
 use chrono::{Datelike, Duration, NaiveDate};
 
-use crate::files::commands::{self, Command};
+use crate::files::commands;
 use crate::files::primitives::{Span, Spanned, Time, Weekday};
+use crate::files::FileSource;
 
 use super::super::command::CommandState;
 use super::super::date::Dates;
 use super::super::delta::{Delta, DeltaStep};
-use super::super::{util, DateRange, Error, Result};
+use super::super::{util, DateRange, Error};
+use super::EvalCommand;
 
 fn b2i(b: bool) -> i64 {
     if b {
@@ -47,7 +49,7 @@ pub enum Var {
 }
 
 impl Var {
-    fn eval(self, index: usize, date: NaiveDate) -> Result<i64> {
+    fn eval<S>(self, index: S, date: NaiveDate) -> Result<i64, Error<S>> {
         Ok(match self {
             Var::JulianDay => date.num_days_from_ce().into(),
             Var::Year => date.year().into(),
@@ -202,7 +204,7 @@ impl From<Weekday> for Expr {
 }
 
 impl Expr {
-    fn eval(&self, index: usize, date: NaiveDate) -> Result<i64> {
+    fn eval<S: Copy>(&self, index: S, date: NaiveDate) -> Result<i64, Error<S>> {
         Ok(match self {
             Expr::Lit(l) => *l,
             Expr::Var(v) => v.eval(index, date)?,
@@ -328,12 +330,12 @@ impl FormulaSpec {
             .expand_by(&self.end_delta)
             .move_by(&self.start_delta);
 
-        if let Command::Task(_) = s.command.command {
-            if let Some(last_done_root) = s.last_done_root() {
+        if let EvalCommand::Task(_) = s.command {
+            if let Some(last_done_root) = s.command.last_done_root() {
                 range = range.with_from(last_done_root.succ())?;
             } else if let Some(from) = s.from {
                 range = range.with_from(from)?;
-            } else if matches!(s.command.command, Command::Task(_)) {
+            } else if matches!(s.command, EvalCommand::Task(_)) {
                 // We have no idea if we missed any tasks since the user hasn't
                 // specified a `FROM`, so we just just look back one year. Any
                 // task older than a year is probably not important anyways...
@@ -344,7 +346,7 @@ impl FormulaSpec {
         s.limit_from_until(range)
     }
 
-    fn dates(&self, index: usize, start: NaiveDate) -> Result<Dates> {
+    fn dates(&self, index: FileSource, start: NaiveDate) -> Result<Dates, Error<FileSource>> {
         let root = self.start_delta.apply_date(index, start)?;
         Ok(if let Some(root_time) = self.start_time {
             let (other, other_time) = self.end_delta.apply_date_time(index, root, root_time)?;
@@ -355,19 +357,19 @@ impl FormulaSpec {
         })
     }
 
-    fn eval(&self, index: usize, date: NaiveDate) -> Result<bool> {
+    fn eval(&self, index: FileSource, date: NaiveDate) -> Result<bool, Error<FileSource>> {
         Ok(i2b(self.start.eval(index, date)?))
     }
 }
 
 impl<'a> CommandState<'a> {
-    pub fn eval_formula_spec(&mut self, spec: FormulaSpec) -> Result<()> {
+    pub fn eval_formula_spec(&mut self, spec: FormulaSpec) -> Result<(), Error<FileSource>> {
         if let Some(range) = spec.range(self) {
-            let index = self.command.source.file();
+            let index = self.source.file();
             for day in range.days() {
                 if spec.eval(index, day)? {
                     let dates = spec.dates(index, day)?;
-                    self.add(self.entry_with_remind(self.kind(), Some(dates))?);
+                    self.add(self.entry_with_remind(self.command.kind(), Some(dates))?);
                 }
             }
         }
@@ -386,7 +388,7 @@ mod tests {
     use super::{Expr, Var};
 
     fn expr(expr: &Expr, date: NaiveDate, target: i64) {
-        if let Ok(result) = expr.eval(0, date) {
+        if let Ok(result) = expr.eval((), date) {
             assert_eq!(result, target);
         } else {
             panic!("formula produced error for day {}", date);
@@ -400,7 +402,7 @@ mod tests {
         for delta in -1000..1000 {
             let d1 = NaiveDate::from_ymd(2021, 12, 19);
             let d2 = d1 + Duration::days(delta);
-            assert_eq!(e.eval(0, d2).unwrap() - e.eval(0, d1).unwrap(), delta);
+            assert_eq!(e.eval((), d2).unwrap() - e.eval((), d1).unwrap(), delta);
         }
     }
 
diff --git a/src/eval/delta.rs b/src/eval/delta.rs
index dcc1706..0872d7b 100644
--- a/src/eval/delta.rs
+++ b/src/eval/delta.rs
@@ -5,7 +5,7 @@ use chrono::{Datelike, Duration, NaiveDate};
 use crate::files::commands;
 use crate::files::primitives::{Span, Spanned, Time, Weekday};
 
-use super::{util, Error, Result};
+use super::{util, Error};
 
 /// Like [`commands::DeltaStep`] but includes a new constructor,
 /// [`DeltaStep::Time`].
@@ -142,16 +142,16 @@ impl From<&commands::Delta> for Delta {
     }
 }
 
-struct DeltaEval {
-    index: usize,
+struct DeltaEval<I> {
+    index: I,
     start: NaiveDate,
     start_time: Option<Time>,
     curr: NaiveDate,
     curr_time: Option<Time>,
 }
 
-impl DeltaEval {
-    fn new(index: usize, start: NaiveDate, start_time: Option<Time>) -> Self {
+impl<S: Copy> DeltaEval<S> {
+    fn new(index: S, start: NaiveDate, start_time: Option<Time>) -> Self {
         Self {
             index,
             start,
@@ -161,7 +161,7 @@ impl DeltaEval {
         }
     }
 
-    fn err_step(&self, span: Span) -> Error {
+    fn err_step(&self, span: Span) -> Error<S> {
         Error::DeltaInvalidStep {
             index: self.index,
             span,
@@ -172,7 +172,7 @@ impl DeltaEval {
         }
     }
 
-    fn err_time(&self, span: Span) -> Error {
+    fn err_time(&self, span: Span) -> Error<S> {
         Error::DeltaNoTime {
             index: self.index,
             span,
@@ -181,7 +181,7 @@ impl DeltaEval {
         }
     }
 
-    fn apply(&mut self, step: &Spanned<DeltaStep>) -> Result<()> {
+    fn apply(&mut self, step: &Spanned<DeltaStep>) -> Result<(), Error<S>> {
         match step.value {
             DeltaStep::Year(n) => self.step_year(step.span, n)?,
             DeltaStep::Month(n) => self.step_month(step.span, n)?,
@@ -196,7 +196,7 @@ impl DeltaEval {
         Ok(())
     }
 
-    fn step_year(&mut self, span: Span, amount: i32) -> Result<()> {
+    fn step_year(&mut self, span: Span, amount: i32) -> Result<(), Error<S>> {
         let year = self.curr.year() + amount;
         match NaiveDate::from_ymd_opt(year, self.curr.month(), self.curr.day()) {
             None => Err(self.err_step(span)),
@@ -207,7 +207,7 @@ impl DeltaEval {
         }
     }
 
-    fn step_month(&mut self, span: Span, amount: i32) -> Result<()> {
+    fn step_month(&mut self, span: Span, amount: i32) -> Result<(), Error<S>> {
         let (year, month) = util::add_months(self.curr.year(), self.curr.month(), amount);
         match NaiveDate::from_ymd_opt(year, month, self.curr.day()) {
             None => Err(self.err_step(span)),
@@ -218,7 +218,7 @@ impl DeltaEval {
         }
     }
 
-    fn step_month_reverse(&mut self, span: Span, amount: i32) -> Result<()> {
+    fn step_month_reverse(&mut self, span: Span, amount: i32) -> Result<(), Error<S>> {
         // Calculate offset from the last day of the month
         let month_length = util::month_length(self.curr.year(), self.curr.month()) as i32;
         let end_offset = self.curr.day() as i32 - month_length;
@@ -252,7 +252,7 @@ impl DeltaEval {
         self.curr += delta;
     }
 
-    fn step_hour(&mut self, span: Span, amount: i32) -> Result<()> {
+    fn step_hour(&mut self, span: Span, amount: i32) -> Result<(), Error<S>> {
         let time = match self.curr_time {
             Some(time) => time,
             None => return Err(self.err_time(span)),
@@ -264,7 +264,7 @@ impl DeltaEval {
         Ok(())
     }
 
-    fn step_minute(&mut self, span: Span, amount: i32) -> Result<()> {
+    fn step_minute(&mut self, span: Span, amount: i32) -> Result<(), Error<S>> {
         let time = match self.curr_time {
             Some(time) => time,
             None => return Err(self.err_time(span)),
@@ -290,7 +290,7 @@ impl DeltaEval {
         }
     }
 
-    fn step_time(&mut self, span: Span, time: Time) -> Result<()> {
+    fn step_time(&mut self, span: Span, time: Time) -> Result<(), Error<S>> {
         let curr_time = match self.curr_time {
             Some(time) => time,
             None => return Err(self.err_time(span)),
@@ -313,11 +313,11 @@ impl Delta {
         self.steps.iter().map(|step| step.value.upper_bound()).sum()
     }
 
-    fn apply(
+    fn apply<S: Copy>(
         &self,
-        index: usize,
+        index: S,
         start: (NaiveDate, Option<Time>),
-    ) -> Result<(NaiveDate, Option<Time>)> {
+    ) -> Result<(NaiveDate, Option<Time>), Error<S>> {
         let mut eval = DeltaEval::new(index, start.0, start.1);
         for step in &self.steps {
             eval.apply(step)?;
@@ -325,16 +325,16 @@ impl Delta {
         Ok((eval.curr, eval.curr_time))
     }
 
-    pub fn apply_date(&self, index: usize, date: NaiveDate) -> Result<NaiveDate> {
+    pub fn apply_date<S: Copy>(&self, index: S, date: NaiveDate) -> Result<NaiveDate, Error<S>> {
         Ok(self.apply(index, (date, None))?.0)
     }
 
-    pub fn apply_date_time(
+    pub fn apply_date_time<S: Copy>(
         &self,
-        index: usize,
+        index: S,
         date: NaiveDate,
         time: Time,
-    ) -> Result<(NaiveDate, Time)> {
+    ) -> Result<(NaiveDate, Time), Error<S>> {
         let (date, time) = self.apply(index, (date, Some(time)))?;
         Ok((date, time.expect("time was not preserved")))
     }
@@ -346,7 +346,7 @@ mod tests {
 
     use crate::files::primitives::{Span, Spanned, Time};
 
-    use super::super::Result;
+    use super::super::Error;
     use super::{Delta, DeltaStep as Step};
 
     const SPAN: Span = Span { start: 12, end: 34 };
@@ -357,8 +357,8 @@ mod tests {
         }
     }
 
-    fn apply_d(step: Step, from: (i32, u32, u32)) -> Result<NaiveDate> {
-        delta(step).apply_date(0, NaiveDate::from_ymd(from.0, from.1, from.2))
+    fn apply_d(step: Step, from: (i32, u32, u32)) -> Result<NaiveDate, Error<()>> {
+        delta(step).apply_date((), NaiveDate::from_ymd(from.0, from.1, from.2))
     }
 
     fn test_d(step: Step, from: (i32, u32, u32), expected: (i32, u32, u32)) {
@@ -368,9 +368,12 @@ mod tests {
         );
     }
 
-    fn apply_dt(step: Step, from: (i32, u32, u32, u32, u32)) -> Result<(NaiveDate, Time)> {
+    fn apply_dt(
+        step: Step,
+        from: (i32, u32, u32, u32, u32),
+    ) -> Result<(NaiveDate, Time), Error<()>> {
         delta(step).apply_date_time(
-            0,
+            (),
             NaiveDate::from_ymd(from.0, from.1, from.2),
             Time::new(from.3, from.4),
         )
diff --git a/src/eval/error.rs b/src/eval/error.rs
index 5219f7f..16062b9 100644
--- a/src/eval/error.rs
+++ b/src/eval/error.rs
@@ -1,15 +1,15 @@
-use std::result;
-
 use chrono::NaiveDate;
+use codespan_reporting::diagnostic::{Diagnostic, Label};
 
 use crate::files::primitives::{Span, Time};
+use crate::files::{FileSource, Files};
 
 #[derive(Debug, thiserror::Error)]
-pub enum Error {
+pub enum Error<S> {
     /// A delta step resulted in an invalid date.
     #[error("delta step resulted in invalid date")]
     DeltaInvalidStep {
-        index: usize,
+        index: S,
         span: Span,
         start: NaiveDate,
         start_time: Option<Time>,
@@ -19,7 +19,7 @@ pub enum Error {
     /// A time-based delta step was applied to a date without time.
     #[error("time-based delta step applied to date without time")]
     DeltaNoTime {
-        index: usize,
+        index: S,
         span: Span,
         start: NaiveDate,
         prev: NaiveDate,
@@ -29,7 +29,7 @@ pub enum Error {
     /// in time (`to < from`).
     #[error("repeat delta did not move forwards")]
     RepeatDidNotMoveForwards {
-        index: usize,
+        index: S,
         span: Span,
         from: NaiveDate,
         to: NaiveDate,
@@ -39,7 +39,7 @@ pub enum Error {
     /// moved forwards in time (`from < to`).
     #[error("remind delta did not move backwards")]
     RemindDidNotMoveBackwards {
-        index: usize,
+        index: S,
         span: Span,
         from: NaiveDate,
         to: NaiveDate,
@@ -47,55 +47,36 @@ pub enum Error {
     /// A `MOVE a TO b` statement was executed, but there was no entry at the
     /// date `a`.
     #[error("tried to move nonexisting entry")]
-    MoveWithoutSource { index: usize, span: Span },
+    MoveWithoutSource { index: S, span: Span },
     /// A `MOVE a TO b` statement was executed where `b` contains a time but `a`
     /// doesn't was executed.
     #[error("tried to move un-timed entry to new time")]
-    TimedMoveWithoutTime { index: usize, span: Span },
+    TimedMoveWithoutTime { index: S, span: Span },
     /// A division by zero has occurred.
     #[error("tried to divide by zero")]
     DivByZero {
-        index: usize,
+        index: S,
         span: Span,
         date: NaiveDate,
     },
     /// A modulo operation by zero has occurred.
     #[error("tried to modulo by zero")]
     ModByZero {
-        index: usize,
+        index: S,
         span: Span,
         date: NaiveDate,
     },
     /// Easter calculation failed.
     #[error("easter calculation failed")]
     Easter {
-        index: usize,
+        index: S,
         span: Span,
         date: NaiveDate,
         msg: &'static str,
     },
 }
 
-pub struct SourceInfo<'a> {
-    pub name: Option<String>,
-    pub content: &'a str,
-}
-
-impl Error {
-    fn print_at<'a>(sources: &[SourceInfo<'a>], index: &usize, span: &Span, message: String) {
-        use pest::error as pe;
-
-        let source = sources.get(*index).expect("index is valid");
-        let span = pest::Span::new(source.content, span.start, span.end).expect("span is valid");
-        let variant = pe::ErrorVariant::<()>::CustomError { message };
-        let mut error = pe::Error::new_from_span(variant, span);
-        if let Some(name) = &source.name {
-            error = error.with_path(name);
-        }
-
-        eprintln!("{}", error);
-    }
-
+impl Error<FileSource> {
     fn fmt_date_time(date: NaiveDate, time: Option<Time>) -> String {
         match time {
             None => format!("{}", date),
@@ -103,8 +84,8 @@ impl Error {
         }
     }
 
-    pub fn print<'a>(&self, sources: &[SourceInfo<'a>]) {
-        match self {
+    pub fn print(&self, files: &Files) {
+        let diagnostic = match self {
             Error::DeltaInvalidStep {
                 index,
                 span,
@@ -113,95 +94,91 @@ impl Error {
                 prev,
                 prev_time,
             } => {
-                let msg = format!(
-                    "Delta step resulted in invalid date\
-                    \nInitial start: {}\
-                    \nPrevious step: {}",
-                    Self::fmt_date_time(*start, *start_time),
-                    Self::fmt_date_time(*prev, *prev_time),
-                );
-                Self::print_at(sources, index, span, msg);
+                let start_str = Self::fmt_date_time(*start, *start_time);
+                let prev_str = Self::fmt_date_time(*prev, *prev_time);
+                Diagnostic::error()
+                    .with_message("Delta step resulted in invalid date")
+                    .with_labels(vec![
+                        Label::primary(files.cs_id(*index), span).with_message("At this step")
+                    ])
+                    .with_notes(vec![
+                        format!("Date before applying delta: {}", start_str),
+                        format!("Date before applying this step: {}", prev_str),
+                    ])
             }
             Error::DeltaNoTime {
                 index,
                 span,
                 start,
                 prev,
-            } => {
-                let msg = format!(
-                    "Time-based delta step applied to date without time\
-                    \nInitial start: {}\
-                    \nPrevious step: {}",
-                    start, prev
-                );
-                Self::print_at(sources, index, span, msg);
-            }
+            } => Diagnostic::error()
+                .with_message("Time-based delta step applied to date without time")
+                .with_labels(vec![
+                    Label::primary(files.cs_id(*index), span).with_message("At this step")
+                ])
+                .with_notes(vec![
+                    format!("Date before applying delta: {}", start),
+                    format!("Date before applying this step: {}", prev),
+                ]),
             Error::RepeatDidNotMoveForwards {
                 index,
                 span,
                 from,
                 to,
-            } => {
-                let msg = format!(
-                    "Repeat delta did not move forwards\
-                    \nMoved from {} to {}",
-                    from, to
-                );
-                Self::print_at(sources, index, span, msg);
-            }
+            } => Diagnostic::error()
+                .with_message("Repeat delta did not move forwards")
+                .with_labels(vec![
+                    Label::primary(files.cs_id(*index), span).with_message("This delta")
+                ])
+                .with_notes(vec![format!("Moved from {} to {}", from, to)]),
             Error::RemindDidNotMoveBackwards {
                 index,
                 span,
                 from,
                 to,
-            } => {
-                let msg = format!(
-                    "Remind delta did not move backwards\
-                    \nMoved from {} to {}",
-                    from, to
-                );
-                Self::print_at(sources, index, span, msg);
-            }
-            Error::MoveWithoutSource { index, span } => {
-                let msg = "Tried to move nonexisting entry".to_string();
-                Self::print_at(sources, index, span, msg);
-            }
-            Error::TimedMoveWithoutTime { index, span } => {
-                let msg = "Tried to move un-timed entry to new time".to_string();
-                Self::print_at(sources, index, span, msg);
-            }
-            Error::DivByZero { index, span, date } => {
-                let msg = format!(
-                    "Tried to divide by zero\
-                    \nAt date: {}",
-                    date
-                );
-                Self::print_at(sources, index, span, msg);
-            }
-            Error::ModByZero { index, span, date } => {
-                let msg = format!(
-                    "Tried to modulo by zero\
-                    \nAt date: {}",
-                    date
-                );
-                Self::print_at(sources, index, span, msg);
-            }
+            } => Diagnostic::error()
+                .with_message("Remind delta did not move backwards")
+                .with_labels(vec![
+                    Label::primary(files.cs_id(*index), span).with_message("This delta")
+                ])
+                .with_notes(vec![format!("Moved from {} to {}", from, to)]),
+            Error::MoveWithoutSource { index, span } => Diagnostic::error()
+                .with_message("Tried to move nonexistent entry")
+                .with_labels(vec![
+                    Label::primary(files.cs_id(*index), span).with_message("Here")
+                ]),
+            Error::TimedMoveWithoutTime { index, span } => Diagnostic::error()
+                .with_message("Tried to move un-timed entry to new time")
+                .with_labels(vec![
+                    Label::primary(files.cs_id(*index), span).with_message("Here")
+                ]),
+            Error::DivByZero { index, span, date } => Diagnostic::error()
+                .with_message("Tried to divide by zero")
+                .with_labels(vec![
+                    Label::primary(files.cs_id(*index), span).with_message("This expression")
+                ])
+                .with_notes(vec![format!("At date: {}", date)]),
+            Error::ModByZero { index, span, date } => Diagnostic::error()
+                .with_message("Tried to modulo by zero")
+                .with_labels(vec![
+                    Label::primary(files.cs_id(*index), span).with_message("This expression")
+                ])
+                .with_notes(vec![format!("At date: {}", date)]),
             Error::Easter {
                 index,
                 span,
                 date,
                 msg,
-            } => {
-                let msg = format!(
-                    "Failed to calculate easter\
-                    \nAt date: {}\
-                    \nReason: {}",
-                    date, msg
-                );
-                Self::print_at(sources, index, span, msg);
-            }
-        }
+            } => Diagnostic::error()
+                .with_message("Failed to calculate easter")
+                .with_labels(vec![
+                    Label::primary(files.cs_id(*index), span).with_message("This expression")
+                ])
+                .with_notes(vec![
+                    format!("At date: {}", date),
+                    format!("Reason: {}", msg),
+                ]),
+        };
+        files.eprint_diagnostic(&diagnostic);
     }
 }
-
-pub type Result<T> = result::Result<T, Error>;
diff --git a/src/main.rs b/src/main.rs
index 40770a6..9053d12 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -4,7 +4,7 @@
 #![warn(clippy::use_self)]
 
 mod cli;
-// mod eval;
+mod eval;
 mod files;
 
 fn main() {

From 5e47dddd4cdfa07e0fb1321c6d72521b191d52a6 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Wed, 5 Jan 2022 02:59:03 +0100
Subject: [PATCH 25/80] Make error formatting more generic

Now, some errors are generic over the FileId type, meaning I can now
pretty-print command line argument errors as well as normal errors with
the same machinery. This is accomplished via the Eprint trait, whose
generics are a tad complex but probably still fine.
---
 src/cli.rs         | 22 +++++++++----------
 src/error.rs       | 28 ++++++++++++++++++++++++
 src/eval/error.rs  | 38 +++++++++++++++------------------
 src/files.rs       | 53 ++++++++++++++++++++++++++++++++++------------
 src/files/error.rs | 28 ++++++++++++------------
 src/main.rs        |  1 +
 6 files changed, 111 insertions(+), 59 deletions(-)
 create mode 100644 src/error.rs

diff --git a/src/cli.rs b/src/cli.rs
index 2decacf..10b4e36 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -3,9 +3,11 @@ use std::str::FromStr;
 use std::{process, result};
 
 use chrono::{NaiveDate, NaiveDateTime};
+use codespan_reporting::files::SimpleFile;
 use directories::ProjectDirs;
 use structopt::StructOpt;
 
+use crate::error;
 // use crate::eval::{DateRange, Entry, EntryMode, SourceInfo};
 use crate::files::arguments::Range;
 use crate::files::{self, Files};
@@ -72,8 +74,6 @@ fn load_files(opt: &Opt, files: &mut Files) -> result::Result<(), files::Error>
     files.load(&file)
 }
 
-/*
-
 fn find_now(opt: &Opt, files: &Files) -> NaiveDateTime {
     let now = files.now().naive_local();
     if let Some(date) = opt.date {
@@ -83,6 +83,8 @@ fn find_now(opt: &Opt, files: &Files) -> NaiveDateTime {
     }
 }
 
+/*
+
 fn find_entries(files: &Files, range: DateRange) -> Result<Vec<Entry>> {
     Ok(files.eval(EntryMode::Relevant, range)?)
 }
@@ -136,24 +138,20 @@ pub fn run() {
 
     let mut files = Files::new();
     if let Err(e) = load_files(&opt, &mut files) {
-        e.print(&files);
+        error::eprint_error(&files, &e);
         process::exit(1);
     }
 
-    /*
-
     let now = find_now(&opt, &files);
 
     // Kinda ugly, but it can stay for now (until it grows at least).
     let range = match Range::from_str(&opt.range) {
-        Ok(range) => match range.eval(0, now.date()) {
+        Ok(range) => match range.eval((), now.date()) {
             Ok(range) => range,
             Err(e) => {
                 eprintln!("Failed to evaluate --range:");
-                e.print(&[SourceInfo {
-                    name: Some("--range".to_string()),
-                    content: &opt.range,
-                }]);
+                let file = SimpleFile::new("--range", &opt.range);
+                error::eprint_error(&file, &e);
                 process::exit(1)
             }
         },
@@ -163,6 +161,8 @@ pub fn run() {
         }
     };
 
+    /*
+
     if let Err(e) = run_command(&opt, &mut files, range, now) {
         e.print(&files.sources());
         process::exit(1);
@@ -171,7 +171,7 @@ pub fn run() {
     */
 
     if let Err(e) = files.save() {
-        e.print(&files);
+        error::eprint_error(&files, &e);
         process::exit(1);
     }
 }
diff --git a/src/error.rs b/src/error.rs
new file mode 100644
index 0000000..89e85e7
--- /dev/null
+++ b/src/error.rs
@@ -0,0 +1,28 @@
+use codespan_reporting::diagnostic::Diagnostic;
+use codespan_reporting::files::Files;
+use codespan_reporting::term::{self, Config};
+use termcolor::StandardStream;
+
+pub trait Eprint<'a, F: Files<'a>> {
+    fn eprint_diagnostic<'f: 'a>(
+        files: &'f F,
+        config: &Config,
+        diagnostic: &Diagnostic<F::FileId>,
+    ) {
+        let mut out = StandardStream::stderr(termcolor::ColorChoice::Auto);
+        if let Err(e) = term::emit(&mut out, config, files, diagnostic) {
+            panic!("Error while reporting error: {}", e);
+        }
+    }
+
+    fn eprint<'f: 'a>(&self, files: &'f F, config: &Config);
+}
+
+pub fn eprint_error<'a, 'f: 'a, F, E>(files: &'f F, e: &E)
+where
+    F: Files<'a>,
+    E: Eprint<'a, F>,
+{
+    let config = Config::default();
+    e.eprint(files, &config);
+}
diff --git a/src/eval/error.rs b/src/eval/error.rs
index 16062b9..4e5bd45 100644
--- a/src/eval/error.rs
+++ b/src/eval/error.rs
@@ -1,8 +1,10 @@
 use chrono::NaiveDate;
 use codespan_reporting::diagnostic::{Diagnostic, Label};
+use codespan_reporting::files::Files;
+use codespan_reporting::term::Config;
 
+use crate::error::Eprint;
 use crate::files::primitives::{Span, Time};
-use crate::files::{FileSource, Files};
 
 #[derive(Debug, thiserror::Error)]
 pub enum Error<S> {
@@ -76,15 +78,17 @@ pub enum Error<S> {
     },
 }
 
-impl Error<FileSource> {
+impl<S> Error<S> {
     fn fmt_date_time(date: NaiveDate, time: Option<Time>) -> String {
         match time {
             None => format!("{}", date),
             Some(time) => format!("{} {}", date, time),
         }
     }
+}
 
-    pub fn print(&self, files: &Files) {
+impl<'a, F: Files<'a>> Eprint<'a, F> for Error<F::FileId> {
+    fn eprint<'f: 'a>(&self, files: &'f F, config: &Config) {
         let diagnostic = match self {
             Error::DeltaInvalidStep {
                 index,
@@ -99,7 +103,7 @@ impl Error<FileSource> {
                 Diagnostic::error()
                     .with_message("Delta step resulted in invalid date")
                     .with_labels(vec![
-                        Label::primary(files.cs_id(*index), span).with_message("At this step")
+                        Label::primary(*index, span).with_message("At this step")
                     ])
                     .with_notes(vec![
                         format!("Date before applying delta: {}", start_str),
@@ -114,7 +118,7 @@ impl Error<FileSource> {
             } => Diagnostic::error()
                 .with_message("Time-based delta step applied to date without time")
                 .with_labels(vec![
-                    Label::primary(files.cs_id(*index), span).with_message("At this step")
+                    Label::primary(*index, span).with_message("At this step")
                 ])
                 .with_notes(vec![
                     format!("Date before applying delta: {}", start),
@@ -127,9 +131,7 @@ impl Error<FileSource> {
                 to,
             } => Diagnostic::error()
                 .with_message("Repeat delta did not move forwards")
-                .with_labels(vec![
-                    Label::primary(files.cs_id(*index), span).with_message("This delta")
-                ])
+                .with_labels(vec![Label::primary(*index, span).with_message("This delta")])
                 .with_notes(vec![format!("Moved from {} to {}", from, to)]),
             Error::RemindDidNotMoveBackwards {
                 index,
@@ -138,30 +140,24 @@ impl Error<FileSource> {
                 to,
             } => Diagnostic::error()
                 .with_message("Remind delta did not move backwards")
-                .with_labels(vec![
-                    Label::primary(files.cs_id(*index), span).with_message("This delta")
-                ])
+                .with_labels(vec![Label::primary(*index, span).with_message("This delta")])
                 .with_notes(vec![format!("Moved from {} to {}", from, to)]),
             Error::MoveWithoutSource { index, span } => Diagnostic::error()
                 .with_message("Tried to move nonexistent entry")
-                .with_labels(vec![
-                    Label::primary(files.cs_id(*index), span).with_message("Here")
-                ]),
+                .with_labels(vec![Label::primary(*index, span).with_message("Here")]),
             Error::TimedMoveWithoutTime { index, span } => Diagnostic::error()
                 .with_message("Tried to move un-timed entry to new time")
-                .with_labels(vec![
-                    Label::primary(files.cs_id(*index), span).with_message("Here")
-                ]),
+                .with_labels(vec![Label::primary(*index, span).with_message("Here")]),
             Error::DivByZero { index, span, date } => Diagnostic::error()
                 .with_message("Tried to divide by zero")
                 .with_labels(vec![
-                    Label::primary(files.cs_id(*index), span).with_message("This expression")
+                    Label::primary(*index, span).with_message("This expression")
                 ])
                 .with_notes(vec![format!("At date: {}", date)]),
             Error::ModByZero { index, span, date } => Diagnostic::error()
                 .with_message("Tried to modulo by zero")
                 .with_labels(vec![
-                    Label::primary(files.cs_id(*index), span).with_message("This expression")
+                    Label::primary(*index, span).with_message("This expression")
                 ])
                 .with_notes(vec![format!("At date: {}", date)]),
             Error::Easter {
@@ -172,13 +168,13 @@ impl Error<FileSource> {
             } => Diagnostic::error()
                 .with_message("Failed to calculate easter")
                 .with_labels(vec![
-                    Label::primary(files.cs_id(*index), span).with_message("This expression")
+                    Label::primary(*index, span).with_message("This expression")
                 ])
                 .with_notes(vec![
                     format!("At date: {}", date),
                     format!("Reason: {}", msg),
                 ]),
         };
-        files.eprint_diagnostic(&diagnostic);
+        Self::eprint_diagnostic(files, config, &diagnostic);
     }
 }
diff --git a/src/files.rs b/src/files.rs
index 1ac07a6..3ba0573 100644
--- a/src/files.rs
+++ b/src/files.rs
@@ -1,13 +1,10 @@
 use std::collections::hash_map::Entry;
 use std::collections::{HashMap, HashSet};
-use std::fs;
 use std::path::{Path, PathBuf};
+use std::{fs, result};
 
 use chrono::{DateTime, NaiveDate, Utc};
-use codespan_reporting::diagnostic::Diagnostic;
 use codespan_reporting::files::SimpleFiles;
-use codespan_reporting::term::{self, Config};
-use termcolor::StandardStream;
 use tzfile::Tz;
 
 use self::commands::{Command, File};
@@ -54,7 +51,7 @@ pub struct Source {
 }
 
 // TODO Rename to `SourceFile`?
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct FileSource(usize);
 
 impl Source {
@@ -82,6 +79,42 @@ pub struct Files {
     logs: HashMap<NaiveDate, Source>,
 }
 
+impl<'a> codespan_reporting::files::Files<'a> for Files {
+    type FileId = FileSource;
+    type Name = String;
+    type Source = &'a str;
+
+    fn name(
+        &'a self,
+        id: Self::FileId,
+    ) -> result::Result<Self::Name, codespan_reporting::files::Error> {
+        self.cs_files.name(self.cs_id(id))
+    }
+
+    fn source(
+        &'a self,
+        id: Self::FileId,
+    ) -> result::Result<Self::Source, codespan_reporting::files::Error> {
+        self.cs_files.source(self.cs_id(id))
+    }
+
+    fn line_index(
+        &'a self,
+        id: Self::FileId,
+        byte_index: usize,
+    ) -> result::Result<usize, codespan_reporting::files::Error> {
+        self.cs_files.line_index(self.cs_id(id), byte_index)
+    }
+
+    fn line_range(
+        &'a self,
+        id: Self::FileId,
+        line_index: usize,
+    ) -> result::Result<std::ops::Range<usize>, codespan_reporting::files::Error> {
+        self.cs_files.line_range(self.cs_id(id), line_index)
+    }
+}
+
 impl Files {
     /* Loading */
 
@@ -323,15 +356,7 @@ impl Files {
 
     /* Errors */
 
-    pub fn cs_id(&self, file: FileSource) -> usize {
+    fn cs_id(&self, file: FileSource) -> usize {
         self.files[file.0].cs_id
     }
-
-    pub fn eprint_diagnostic(&self, diagnostic: &Diagnostic<usize>) {
-        let mut out = StandardStream::stderr(termcolor::ColorChoice::Auto);
-        let config = Config::default();
-        if let Err(e) = term::emit(&mut out, &config, &self.cs_files, diagnostic) {
-            panic!("Error while reporting error: {}", e);
-        }
-    }
 }
diff --git a/src/files/error.rs b/src/files/error.rs
index 3b8dc34..14f2a8c 100644
--- a/src/files/error.rs
+++ b/src/files/error.rs
@@ -3,6 +3,9 @@ use std::{io, result};
 
 use chrono::NaiveDate;
 use codespan_reporting::diagnostic::{Diagnostic, Label};
+use codespan_reporting::term::Config;
+
+use crate::error::Eprint;
 
 use super::primitives::Span;
 use super::{parse, FileSource, Files};
@@ -45,8 +48,8 @@ pub enum Error {
     },
 }
 
-impl Error {
-    pub fn print(&self, files: &Files) {
+impl<'a> Eprint<'a, Files> for Error {
+    fn eprint<'f: 'a>(&self, files: &'f Files, config: &Config) {
         match self {
             Error::ResolvePath { path, error } => {
                 eprintln!("Could not resolve path {:?}:", path);
@@ -68,10 +71,11 @@ impl Error {
             } => {
                 let diagnostic = Diagnostic::error()
                     .with_message(format!("Could not resolve time zone {}", tz))
-                    .with_labels(vec![Label::primary(files.cs_id(*file), span)
-                        .with_message("Time zone defined here")])
+                    .with_labels(vec![
+                        Label::primary(*file, span).with_message("Time zone defined here")
+                    ])
                     .with_notes(vec![format!("{}", error)]);
-                files.eprint_diagnostic(&diagnostic);
+                Self::eprint_diagnostic(files, config, &diagnostic);
             }
             Error::LocalTz { error } => {
                 eprintln!("Could not determine local timezone:");
@@ -90,15 +94,13 @@ impl Error {
                 let diagnostic = Diagnostic::error()
                     .with_message(format!("Time zone conflict between {} and {}", tz1, tz2))
                     .with_labels(vec![
-                        Label::primary(files.cs_id(*file1), span1)
-                            .with_message("Time zone defined here"),
-                        Label::primary(files.cs_id(*file2), span2)
-                            .with_message("Time zone defined here"),
+                        Label::primary(*file1, span1).with_message("Time zone defined here"),
+                        Label::primary(*file2, span2).with_message("Time zone defined here"),
                     ])
                     .with_notes(vec![
                         "All TIMEZONE commands must set the same time zone.".to_string()
                     ]);
-                files.eprint_diagnostic(&diagnostic);
+                Self::eprint_diagnostic(files, config, &diagnostic);
             }
             Error::LogConflict {
                 file1,
@@ -110,11 +112,11 @@ impl Error {
                 let diagnostic = Diagnostic::error()
                     .with_message(format!("Duplicate log entries for {}", date))
                     .with_labels(vec![
-                        Label::primary(files.cs_id(*file1), span1).with_message("Log defined here"),
-                        Label::primary(files.cs_id(*file2), span2).with_message("Log defined here"),
+                        Label::primary(*file1, span1).with_message("Log defined here"),
+                        Label::primary(*file2, span2).with_message("Log defined here"),
                     ])
                     .with_notes(vec!["A day can have at most one LOG entry.".to_string()]);
-                files.eprint_diagnostic(&diagnostic);
+                Self::eprint_diagnostic(files, config, &diagnostic);
             }
         }
     }
diff --git a/src/main.rs b/src/main.rs
index 9053d12..5d5922f 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -4,6 +4,7 @@
 #![warn(clippy::use_self)]
 
 mod cli;
+mod error;
 mod eval;
 mod files;
 

From 3f5e06b113ab3c6faccdcf603ff4c2a31d42eba4 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Thu, 6 Jan 2022 18:04:34 +0100
Subject: [PATCH 26/80] Adapt cli code to changes

---
 src/cli.rs             | 46 +++++++++++++++++++-----------------------
 src/cli/cancel.rs      |  6 +++---
 src/cli/done.rs        |  6 +++---
 src/cli/error.rs       | 18 +++++++++--------
 src/cli/layout/day.rs  | 22 ++++++++------------
 src/cli/layout/line.rs | 10 ++++-----
 src/cli/show.rs        | 46 ++++++++++++++++++------------------------
 src/eval/command.rs    | 23 ++++++++++++++++++++-
 src/eval/entry.rs      |  8 +++++++-
 src/files.rs           |  6 ++----
 10 files changed, 101 insertions(+), 90 deletions(-)

diff --git a/src/cli.rs b/src/cli.rs
index 10b4e36..d1d9005 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -7,20 +7,19 @@ use codespan_reporting::files::SimpleFile;
 use directories::ProjectDirs;
 use structopt::StructOpt;
 
-use crate::error;
-// use crate::eval::{DateRange, Entry, EntryMode, SourceInfo};
+use crate::eval::{DateRange, Entry, EntryMode};
 use crate::files::arguments::Range;
-use crate::files::{self, Files};
+use crate::files::{self, FileSource, Files};
 
-// use self::error::Result;
-// use self::layout::line::LineLayout;
+use self::error::Error;
+use self::layout::line::LineLayout;
 
-// mod cancel;
-// mod done;
-// mod error;
-// mod layout;
-// mod print;
-// mod show;
+mod cancel;
+mod done;
+mod error;
+mod layout;
+mod print;
+mod show;
 
 #[derive(Debug, StructOpt)]
 pub struct Opt {
@@ -83,9 +82,7 @@ fn find_now(opt: &Opt, files: &Files) -> NaiveDateTime {
     }
 }
 
-/*
-
-fn find_entries(files: &Files, range: DateRange) -> Result<Vec<Entry>> {
+fn find_entries(files: &Files, range: DateRange) -> Result<Vec<Entry>, Error<FileSource>> {
     Ok(files.eval(EntryMode::Relevant, range)?)
 }
 
@@ -98,7 +95,12 @@ fn find_layout(
     layout::layout(files, entries, range, now)
 }
 
-fn run_command(opt: &Opt, files: &mut Files, range: DateRange, now: NaiveDateTime) -> Result<()> {
+fn run_command(
+    opt: &Opt,
+    files: &mut Files,
+    range: DateRange,
+    now: NaiveDateTime,
+) -> Result<(), Error<FileSource>> {
     match &opt.command {
         None => {
             let entries = find_entries(files, range)?;
@@ -131,14 +133,12 @@ fn run_command(opt: &Opt, files: &mut Files, range: DateRange, now: NaiveDateTim
     Ok(())
 }
 
-*/
-
 pub fn run() {
     let opt = Opt::from_args();
 
     let mut files = Files::new();
     if let Err(e) = load_files(&opt, &mut files) {
-        error::eprint_error(&files, &e);
+        crate::error::eprint_error(&files, &e);
         process::exit(1);
     }
 
@@ -151,7 +151,7 @@ pub fn run() {
             Err(e) => {
                 eprintln!("Failed to evaluate --range:");
                 let file = SimpleFile::new("--range", &opt.range);
-                error::eprint_error(&file, &e);
+                crate::error::eprint_error(&file, &e);
                 process::exit(1)
             }
         },
@@ -161,17 +161,13 @@ pub fn run() {
         }
     };
 
-    /*
-
     if let Err(e) = run_command(&opt, &mut files, range, now) {
-        e.print(&files.sources());
+        crate::error::eprint_error(&files, &e);
         process::exit(1);
     }
 
-    */
-
     if let Err(e) = files.save() {
-        error::eprint_error(&files, &e);
+        crate::error::eprint_error(&files, &e);
         process::exit(1);
     }
 }
diff --git a/src/cli/cancel.rs b/src/cli/cancel.rs
index 62cc8ea..4821676 100644
--- a/src/cli/cancel.rs
+++ b/src/cli/cancel.rs
@@ -6,16 +6,16 @@ use crate::eval::Entry;
 use crate::files::commands::{Done, DoneKind};
 use crate::files::Files;
 
-use super::error::{Error, Result};
+use super::error::Error;
 use super::layout::line::LineLayout;
 
-pub fn cancel(
+pub fn cancel<S>(
     files: &mut Files,
     entries: &[Entry],
     layout: &LineLayout,
     numbers: &[usize],
     now: NaiveDateTime,
-) -> Result<()> {
+) -> Result<(), Error<S>> {
     let mut not_tasks = vec![];
     for &number in numbers {
         let entry = &entries[layout.look_up_number(number)?];
diff --git a/src/cli/done.rs b/src/cli/done.rs
index 1d3d809..d68ad38 100644
--- a/src/cli/done.rs
+++ b/src/cli/done.rs
@@ -6,16 +6,16 @@ use crate::eval::Entry;
 use crate::files::commands::{Done, DoneKind};
 use crate::files::Files;
 
-use super::error::{Error, Result};
+use super::error::Error;
 use super::layout::line::LineLayout;
 
-pub fn done(
+pub fn done<S>(
     files: &mut Files,
     entries: &[Entry],
     layout: &LineLayout,
     numbers: &[usize],
     now: NaiveDateTime,
-) -> Result<()> {
+) -> Result<(), Error<S>> {
     let mut not_tasks = vec![];
     for &number in numbers {
         let entry = &entries[layout.look_up_number(number)?];
diff --git a/src/cli/error.rs b/src/cli/error.rs
index 3bf054e..725b2e3 100644
--- a/src/cli/error.rs
+++ b/src/cli/error.rs
@@ -1,21 +1,25 @@
 use std::result;
 
-use crate::eval::{self, SourceInfo};
+use codespan_reporting::files::Files;
+use codespan_reporting::term::Config;
+
+use crate::error::Eprint;
+use crate::eval;
 
 #[derive(Debug, thiserror::Error)]
-pub enum Error {
+pub enum Error<S> {
     #[error("{0}")]
-    Eval(#[from] eval::Error),
+    Eval(#[from] eval::Error<S>),
     #[error("No entry with number {0}")]
     NoSuchEntry(usize),
     #[error("Not a task")]
     NotATask(Vec<usize>),
 }
 
-impl Error {
-    pub fn print<'a>(&self, sources: &[SourceInfo<'a>]) {
+impl<'a, F: Files<'a>> Eprint<'a, F> for Error<F::FileId> {
+    fn eprint<'f: 'a>(&self, files: &'f F, config: &Config) {
         match self {
-            Error::Eval(e) => e.print(sources),
+            Error::Eval(e) => e.eprint(files, config),
             Error::NoSuchEntry(n) => eprintln!("No entry with number {}", n),
             Error::NotATask(ns) => {
                 if ns.is_empty() {
@@ -30,5 +34,3 @@ impl Error {
         }
     }
 }
-
-pub type Result<T> = result::Result<T, Error>;
diff --git a/src/cli/layout/day.rs b/src/cli/layout/day.rs
index 30db056..f3866a3 100644
--- a/src/cli/layout/day.rs
+++ b/src/cli/layout/day.rs
@@ -8,7 +8,6 @@ use std::collections::HashMap;
 use chrono::{NaiveDate, NaiveDateTime};
 
 use crate::eval::{DateRange, Dates, Entry, EntryKind};
-use crate::files::commands::Command;
 use crate::files::primitives::Time;
 use crate::files::Files;
 
@@ -51,15 +50,10 @@ impl DayLayout {
     pub fn layout(&mut self, files: &Files, entries: &[Entry]) {
         self.insert(self.today, DayEntry::Now(self.time));
 
-        let mut commands = entries
-            .iter()
-            .enumerate()
-            .map(|(i, e)| (i, e, files.command(e.source)))
-            .collect::<Vec<_>>();
+        let mut entries = entries.iter().enumerate().collect::<Vec<_>>();
+        Self::sort_entries(&mut entries);
 
-        Self::sort_entries(&mut commands);
-
-        for (index, entry, _) in commands {
+        for (index, entry) in entries {
             self.layout_entry(index, entry);
         }
 
@@ -196,7 +190,7 @@ impl DayLayout {
         }
     }
 
-    fn sort_entries(entries: &mut Vec<(usize, &Entry, &Command)>) {
+    fn sort_entries(entries: &mut Vec<(usize, &Entry)>) {
         // Entries should be sorted by these factors, in descending order of
         // significance:
         // 1. Their start date, if any
@@ -205,10 +199,10 @@ impl DayLayout {
         // 4. Their title
 
         // 4.
-        entries.sort_by_key(|(_, _, c)| c.title());
+        entries.sort_by_key(|(_, e)| &e.title);
 
         // 3.
-        entries.sort_by_key(|(_, e, _)| match e.kind {
+        entries.sort_by_key(|(_, e)| match e.kind {
             EntryKind::Task => 0,
             EntryKind::TaskDone(_) | EntryKind::TaskCanceled(_) => 1,
             EntryKind::Birthday(_) => 2,
@@ -216,14 +210,14 @@ impl DayLayout {
         });
 
         // 2.
-        entries.sort_by(|(_, e1, _), (_, e2, _)| {
+        entries.sort_by(|(_, e1), (_, e2)| {
             let d1 = e1.dates.map(|d| d.sorted().other_with_time());
             let d2 = e2.dates.map(|d| d.sorted().other_with_time());
             d2.cmp(&d1) // Inverse comparison
         });
 
         // 1.
-        entries.sort_by_key(|(_, e, _)| e.dates.map(|d| d.sorted().root_with_time()));
+        entries.sort_by_key(|(_, e)| e.dates.map(|d| d.sorted().root_with_time()));
     }
 
     fn sort_day(day: &mut Vec<DayEntry>) {
diff --git a/src/cli/layout/line.rs b/src/cli/layout/line.rs
index 637d963..78bbabc 100644
--- a/src/cli/layout/line.rs
+++ b/src/cli/layout/line.rs
@@ -11,7 +11,7 @@ use crate::eval::{Entry, EntryKind};
 use crate::files::primitives::Time;
 use crate::files::Files;
 
-use super::super::error::{Error, Result};
+use super::super::error::Error;
 use super::day::{DayEntry, DayLayout};
 
 #[derive(Debug, Clone, Copy)]
@@ -145,7 +145,7 @@ impl LineLayout {
         &self.lines
     }
 
-    pub fn look_up_number(&self, number: usize) -> Result<usize> {
+    pub fn look_up_number<S>(&self, number: usize) -> Result<usize, Error<S>> {
         self.numbers
             .iter()
             .filter(|(_, n)| **n == number)
@@ -253,10 +253,10 @@ impl LineLayout {
     }
 
     fn entry_title(files: &Files, entry: &Entry) -> String {
-        let command = files.command(entry.source);
+        let command = files.command(entry.source).command;
         match entry.kind {
-            EntryKind::Birthday(Some(age)) => format!("{} ({})", command.title(), age),
-            _ => command.title().to_string(),
+            EntryKind::Birthday(Some(age)) => format!("{} ({})", entry.title, age),
+            _ => entry.title.clone(),
         }
     }
 
diff --git a/src/cli/show.rs b/src/cli/show.rs
index 81cac22..1b433eb 100644
--- a/src/cli/show.rs
+++ b/src/cli/show.rs
@@ -1,32 +1,18 @@
 use crate::eval::{Entry, EntryKind};
 use crate::files::Files;
 
-use super::error::Result;
+use super::error::Error;
 use super::layout::line::LineLayout;
 
 fn show_entry(files: &Files, entry: &Entry) {
     let command = files.command(entry.source);
 
-    match entry.kind {
-        EntryKind::Task => println!("TASK {}", command.title()),
-        EntryKind::TaskDone(when) => {
-            println!("DONE {}", command.title());
-            println!("DONE AT {}", when);
-        }
-        EntryKind::TaskCanceled(when) => {
-            println!("CANCELED {}", command.title());
-            println!("CANCELED AT {}", when);
-        }
-        EntryKind::Note => println!("NOTE {}", command.title()),
-        EntryKind::Birthday(Some(age)) => {
-            println!("BIRTHDAY {}", command.title());
-            println!("AGE {}", age);
-        }
-        EntryKind::Birthday(None) => {
-            println!("BIRTHDAY {}", command.title());
-            println!("AGE UNKNOWN");
-        }
-    }
+    let kind = match entry.kind {
+        EntryKind::Task | EntryKind::TaskDone(_) | EntryKind::TaskCanceled(_) => "TASK",
+        EntryKind::Note => "NOTE",
+        EntryKind::Birthday(_) => "BIRTHDAY",
+    };
+    println!("{} {}", kind, entry.title);
 
     if let Some(dates) = entry.dates {
         println!("DATE {}", dates.sorted());
@@ -34,17 +20,25 @@ fn show_entry(files: &Files, entry: &Entry) {
         println!("NO DATE");
     }
 
-    for line in command.desc() {
-        println!("# {}", line);
+    match entry.kind {
+        EntryKind::TaskDone(when) => println!("DONE {}", when),
+        EntryKind::TaskCanceled(when) => println!("CANCELED {}", when),
+        EntryKind::Birthday(Some(age)) => println!("AGE {}", age),
+        _ => {}
+    }
+
+    println!("FROM COMMAND");
+    for line in format!("{}", command.command).lines() {
+        println!("| {}", line);
     }
 }
 
-pub fn show(
+pub fn show<S>(
     files: &Files,
     entries: &[Entry],
     layout: &LineLayout,
     numbers: &[usize],
-) -> Result<()> {
+) -> Result<(), Error<S>> {
     if numbers.is_empty() {
         // Nothing to do
         return Ok(());
@@ -53,7 +47,7 @@ pub fn show(
     let indices = numbers
         .iter()
         .map(|n| layout.look_up_number(*n))
-        .collect::<Result<Vec<usize>>>()?;
+        .collect::<Result<Vec<usize>, _>>()?;
 
     show_entry(files, &entries[indices[0]]);
     for &index in indices.iter().skip(1) {
diff --git a/src/eval/command.rs b/src/eval/command.rs
index e50e580..0bec665 100644
--- a/src/eval/command.rs
+++ b/src/eval/command.rs
@@ -45,6 +45,20 @@ impl<'a> EvalCommand<'a> {
         }
     }
 
+    fn title(&self) -> String {
+        match self {
+            Self::Task(task) => task.title.clone(),
+            Self::Note(note) => note.title.clone(),
+        }
+    }
+
+    fn has_description(&self) -> bool {
+        match self {
+            Self::Task(task) => !task.desc.is_empty(),
+            Self::Note(note) => !note.desc.is_empty(),
+        }
+    }
+
     /// Last root date mentioned in any `DONE`.
     fn last_done_root(&self) -> Option<NaiveDate> {
         match self {
@@ -172,7 +186,14 @@ impl<'a> CommandState<'a> {
             None
         };
 
-        Ok(Entry::new(self.source, kind, dates, remind))
+        Ok(Entry::new(
+            self.source,
+            kind,
+            self.command.title(),
+            self.command.has_description(),
+            dates,
+            remind,
+        ))
     }
 
     /// Add an entry, respecting [`Self::from`] and [`Self::until`]. Does not
diff --git a/src/eval/entry.rs b/src/eval/entry.rs
index 09d51a0..f0f1e74 100644
--- a/src/eval/entry.rs
+++ b/src/eval/entry.rs
@@ -15,10 +15,12 @@ pub enum EntryKind {
 }
 
 /// A single instance of a command.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone)]
 pub struct Entry {
     pub source: Source,
     pub kind: EntryKind,
+    pub title: String,
+    pub has_description: bool,
     pub dates: Option<Dates>,
     /// Remind the user of an entry before it occurs. This date should always be
     /// before the entry's start date, or `None` if there is no start date.
@@ -29,6 +31,8 @@ impl Entry {
     pub fn new(
         source: Source,
         kind: EntryKind,
+        title: String,
+        has_description: bool,
         dates: Option<Dates>,
         remind: Option<NaiveDate>,
     ) -> Self {
@@ -43,6 +47,8 @@ impl Entry {
         Self {
             source,
             kind,
+            title,
+            has_description,
             dates,
             remind,
         }
diff --git a/src/files.rs b/src/files.rs
index 3ba0573..484c76b 100644
--- a/src/files.rs
+++ b/src/files.rs
@@ -7,7 +7,7 @@ use chrono::{DateTime, NaiveDate, Utc};
 use codespan_reporting::files::SimpleFiles;
 use tzfile::Tz;
 
-use self::commands::{Command, File};
+use self::commands::{Command, Done, File};
 pub use self::error::{Error, Result};
 use self::primitives::Spanned;
 
@@ -337,7 +337,6 @@ impl Files {
         }
     }
 
-    /*
     /// Add a [`Done`] statement to the task identified by `source`.
     ///
     /// Returns whether the addition was successful. It can fail if the entry
@@ -347,12 +346,11 @@ impl Files {
         let file = &mut self.files[source.file];
         match &mut file.file.commands[source.command] {
             Command::Task(t) => t.done.push(done),
-            Command::Note(_) => return false,
+            _ => return false,
         }
         file.dirty = true;
         true
     }
-    */
 
     /* Errors */
 

From a4a6726091b644c9838065fb1a1bdc594694e33a Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Thu, 6 Jan 2022 18:22:18 +0100
Subject: [PATCH 27/80] Fix a few warnings

---
 src/cli.rs             | 21 ++++------
 src/cli/error.rs       |  2 -
 src/cli/layout.rs      | 12 ++----
 src/cli/layout/day.rs  |  3 +-
 src/cli/layout/line.rs | 94 ++++++++++++------------------------------
 5 files changed, 39 insertions(+), 93 deletions(-)

diff --git a/src/cli.rs b/src/cli.rs
index d1d9005..d54097f 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -86,13 +86,8 @@ fn find_entries(files: &Files, range: DateRange) -> Result<Vec<Entry>, Error<Fil
     Ok(files.eval(EntryMode::Relevant, range)?)
 }
 
-fn find_layout(
-    files: &Files,
-    entries: &[Entry],
-    range: DateRange,
-    now: NaiveDateTime,
-) -> LineLayout {
-    layout::layout(files, entries, range, now)
+fn find_layout(entries: &[Entry], range: DateRange, now: NaiveDateTime) -> LineLayout {
+    layout::layout(entries, range, now)
 }
 
 fn run_command(
@@ -104,28 +99,28 @@ fn run_command(
     match &opt.command {
         None => {
             let entries = find_entries(files, range)?;
-            let layout = find_layout(files, &entries, range, now);
+            let layout = find_layout(&entries, range, now);
             print::print(&layout);
         }
         Some(Command::Show { entries: ns }) => {
             let entries = find_entries(files, range)?;
-            let layout = find_layout(files, &entries, range, now);
+            let layout = find_layout(&entries, range, now);
             show::show(files, &entries, &layout, ns)?;
         }
         Some(Command::Done { entries: ns }) => {
             let entries = find_entries(files, range)?;
-            let layout = find_layout(files, &entries, range, now);
+            let layout = find_layout(&entries, range, now);
             done::done(files, &entries, &layout, ns, now)?;
             let entries = find_entries(files, range)?;
-            let layout = find_layout(files, &entries, range, now);
+            let layout = find_layout(&entries, range, now);
             print::print(&layout);
         }
         Some(Command::Cancel { entries: ns }) => {
             let entries = find_entries(files, range)?;
-            let layout = find_layout(files, &entries, range, now);
+            let layout = find_layout(&entries, range, now);
             cancel::cancel(files, &entries, &layout, ns, now)?;
             let entries = find_entries(files, range)?;
-            let layout = find_layout(files, &entries, range, now);
+            let layout = find_layout(&entries, range, now);
             print::print(&layout);
         }
         Some(Command::Fmt) => files.mark_all_dirty(),
diff --git a/src/cli/error.rs b/src/cli/error.rs
index 725b2e3..a84a0df 100644
--- a/src/cli/error.rs
+++ b/src/cli/error.rs
@@ -1,5 +1,3 @@
-use std::result;
-
 use codespan_reporting::files::Files;
 use codespan_reporting::term::Config;
 
diff --git a/src/cli/layout.rs b/src/cli/layout.rs
index 76575eb..9b8aa90 100644
--- a/src/cli/layout.rs
+++ b/src/cli/layout.rs
@@ -1,7 +1,6 @@
 use chrono::NaiveDateTime;
 
 use crate::eval::{DateRange, Entry};
-use crate::files::Files;
 
 use self::day::DayLayout;
 use self::line::LineLayout;
@@ -9,17 +8,12 @@ use self::line::LineLayout;
 mod day;
 pub mod line;
 
-pub fn layout(
-    files: &Files,
-    entries: &[Entry],
-    range: DateRange,
-    now: NaiveDateTime,
-) -> LineLayout {
+pub fn layout(entries: &[Entry], range: DateRange, now: NaiveDateTime) -> LineLayout {
     let mut day_layout = DayLayout::new(range, now);
-    day_layout.layout(files, entries);
+    day_layout.layout(entries);
 
     let mut line_layout = LineLayout::new();
-    line_layout.render(files, entries, &day_layout);
+    line_layout.render(entries, &day_layout);
 
     line_layout
 }
diff --git a/src/cli/layout/day.rs b/src/cli/layout/day.rs
index f3866a3..e0f2d17 100644
--- a/src/cli/layout/day.rs
+++ b/src/cli/layout/day.rs
@@ -9,7 +9,6 @@ use chrono::{NaiveDate, NaiveDateTime};
 
 use crate::eval::{DateRange, Dates, Entry, EntryKind};
 use crate::files::primitives::Time;
-use crate::files::Files;
 
 #[derive(Debug)]
 pub enum DayEntry {
@@ -47,7 +46,7 @@ impl DayLayout {
         }
     }
 
-    pub fn layout(&mut self, files: &Files, entries: &[Entry]) {
+    pub fn layout(&mut self, entries: &[Entry]) {
         self.insert(self.today, DayEntry::Now(self.time));
 
         let mut entries = entries.iter().enumerate().collect::<Vec<_>>();
diff --git a/src/cli/layout/line.rs b/src/cli/layout/line.rs
index 78bbabc..a1127a5 100644
--- a/src/cli/layout/line.rs
+++ b/src/cli/layout/line.rs
@@ -9,7 +9,6 @@ use chrono::NaiveDate;
 
 use crate::eval::{Entry, EntryKind};
 use crate::files::primitives::Time;
-use crate::files::Files;
 
 use super::super::error::Error;
 use super::day::{DayEntry, DayLayout};
@@ -108,7 +107,7 @@ impl LineLayout {
         }
     }
 
-    pub fn render(&mut self, files: &Files, entries: &[Entry], layout: &DayLayout) {
+    pub fn render(&mut self, entries: &[Entry], layout: &DayLayout) {
         // Make sure spans for visible `*End`s are drawn
         for entry in &layout.earlier {
             match entry {
@@ -128,7 +127,7 @@ impl LineLayout {
 
             let layout_entries = layout.days.get(&day).expect("got nonexisting day");
             for layout_entry in layout_entries {
-                self.render_layout_entry(files, entries, layout_entry);
+                self.render_layout_entry(entries, layout_entry);
             }
         }
     }
@@ -154,14 +153,11 @@ impl LineLayout {
             .ok_or(Error::NoSuchEntry(number))
     }
 
-    fn render_layout_entry(&mut self, files: &Files, entries: &[Entry], l_entry: &DayEntry) {
+    fn render_layout_entry(&mut self, entries: &[Entry], l_entry: &DayEntry) {
         match l_entry {
             DayEntry::End(i) => {
                 self.stop_span(*i);
-                let entry = &entries[*i];
-                let kind = Self::entry_kind(entry);
-                let text = Self::entry_title(files, entry);
-                self.line_entry(Some(*i), Times::Untimed, kind, text, None);
+                self.line_entry(entries, *i, Times::Untimed, None);
             }
             DayEntry::Now(t) => self.line(LineEntry::Now {
                 spans: self.spans_for_line(),
@@ -169,75 +165,48 @@ impl LineLayout {
             }),
             DayEntry::TimedEnd(i, t) => {
                 self.stop_span(*i);
-                let entry = &entries[*i];
-                let kind = Self::entry_kind(entry);
-                let text = Self::entry_title(files, entry);
-                self.line_entry(Some(*i), Times::At(*t), kind, text, None);
+                self.line_entry(entries, *i, Times::At(*t), None);
             }
             DayEntry::TimedAt(i, t, t2) => {
                 let time = t2
                     .map(|t2| Times::FromTo(*t, t2))
                     .unwrap_or_else(|| Times::At(*t));
-                let entry = &entries[*i];
-                let kind = Self::entry_kind(entry);
-                let text = Self::entry_title(files, entry);
-                self.line_entry(Some(*i), time, kind, text, None);
+                self.line_entry(entries, *i, time, None);
             }
             DayEntry::TimedStart(i, t) => {
                 self.start_span(*i);
-                let entry = &entries[*i];
-                let kind = Self::entry_kind(entry);
-                let text = Self::entry_title(files, entry);
-                self.line_entry(Some(*i), Times::At(*t), kind, text, None);
+                self.line_entry(entries, *i, Times::At(*t), None);
             }
             DayEntry::ReminderSince(i, d) => {
-                let entry = &entries[*i];
-                let kind = Self::entry_kind(entry);
-                let text = Self::entry_title(files, entry);
                 let extra = if *d == 1 {
                     "yesterday".to_string()
                 } else {
                     format!("{} days ago", d)
                 };
-                self.line_entry(Some(*i), Times::Untimed, kind, text, Some(extra));
+                self.line_entry(entries, *i, Times::Untimed, Some(extra));
             }
             DayEntry::At(i) => {
-                let entry = &entries[*i];
-                let kind = Self::entry_kind(entry);
-                let text = Self::entry_title(files, entry);
-                self.line_entry(Some(*i), Times::Untimed, kind, text, None);
+                self.line_entry(entries, *i, Times::Untimed, None);
             }
             DayEntry::ReminderWhile(i, d) => {
-                let entry = &entries[*i];
-                let kind = Self::entry_kind(entry);
-                let text = Self::entry_title(files, entry);
                 let plural = if *d == 1 { "" } else { "s" };
                 let extra = format!("{} day{} left", d, plural);
-                self.line_entry(Some(*i), Times::Untimed, kind, text, Some(extra));
+                self.line_entry(entries, *i, Times::Untimed, Some(extra));
             }
             DayEntry::Undated(i) => {
-                let entry = &entries[*i];
-                let kind = Self::entry_kind(entry);
-                let text = Self::entry_title(files, entry);
-                self.line_entry(Some(*i), Times::Untimed, kind, text, None);
+                self.line_entry(entries, *i, Times::Untimed, None);
             }
             DayEntry::Start(i) => {
                 self.start_span(*i);
-                let entry = &entries[*i];
-                let kind = Self::entry_kind(entry);
-                let text = Self::entry_title(files, entry);
-                self.line_entry(Some(*i), Times::Untimed, kind, text, None);
+                self.line_entry(entries, *i, Times::Untimed, None);
             }
             DayEntry::ReminderUntil(i, d) => {
-                let entry = &entries[*i];
-                let kind = Self::entry_kind(entry);
-                let text = Self::entry_title(files, entry);
                 let extra = if *d == 1 {
                     "tomorrow".to_string()
                 } else {
                     format!("in {} days", d)
                 };
-                self.line_entry(Some(*i), Times::Untimed, kind, text, Some(extra));
+                self.line_entry(entries, *i, Times::Untimed, Some(extra));
             }
         }
     }
@@ -252,8 +221,7 @@ impl LineLayout {
         }
     }
 
-    fn entry_title(files: &Files, entry: &Entry) -> String {
-        let command = files.command(entry.source).command;
+    fn entry_title(entry: &Entry) -> String {
         match entry.kind {
             EntryKind::Birthday(Some(age)) => format!("{} ({})", entry.title, age),
             _ => entry.title.clone(),
@@ -305,32 +273,24 @@ impl LineLayout {
         self.step_spans();
     }
 
-    fn line_entry(
-        &mut self,
-        index: Option<usize>,
-        time: Times,
-        kind: LineKind,
-        text: String,
-        extra: Option<String>,
-    ) {
-        let number = match index {
-            Some(index) => Some(match self.numbers.get(&index) {
-                Some(number) => *number,
-                None => {
-                    self.last_number += 1;
-                    self.numbers.insert(index, self.last_number);
-                    self.last_number
-                }
-            }),
-            None => None,
+    fn line_entry(&mut self, entries: &[Entry], index: usize, time: Times, extra: Option<String>) {
+        let entry = &entries[index];
+
+        let number = match self.numbers.get(&index) {
+            Some(number) => *number,
+            None => {
+                self.last_number += 1;
+                self.numbers.insert(index, self.last_number);
+                self.last_number
+            }
         };
 
         self.line(LineEntry::Entry {
-            number,
+            number: Some(number),
             spans: self.spans_for_line(),
             time,
-            kind,
-            text,
+            kind: Self::entry_kind(entry),
+            text: Self::entry_title(entry),
             extra,
         });
     }

From 80666c2cf5bc872bc0b8441b81eac19254f78a36 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Thu, 6 Jan 2022 18:22:26 +0100
Subject: [PATCH 28/80] Use same path for saving files as for loading

---
 src/files.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/files.rs b/src/files.rs
index 484c76b..faaca81 100644
--- a/src/files.rs
+++ b/src/files.rs
@@ -267,21 +267,21 @@ impl Files {
     pub fn save(&self) -> Result<()> {
         for file in &self.files {
             if file.dirty {
-                Self::save_file(&file.path, &file.file)?;
+                Self::save_file(file)?;
             }
         }
         Ok(())
     }
 
-    fn save_file(path: &Path, file: &File) -> Result<()> {
+    fn save_file(file: &LoadedFile) -> Result<()> {
         // TODO Sort commands within file
-        let formatted = format!("{}", file);
-        if file.contents == formatted {
-            println!("Unchanged file {:?}", path);
+        let formatted = format!("{}", file.file);
+        if file.file.contents == formatted {
+            println!("Unchanged file {:?}", file.name);
         } else {
-            println!("Saving file {:?}", path);
-            fs::write(path, &formatted).map_err(|e| Error::WriteFile {
-                file: path.to_path_buf(),
+            println!("Saving file {:?}", file.name);
+            fs::write(&file.name, &formatted).map_err(|e| Error::WriteFile {
+                file: file.name.to_path_buf(),
                 error: e,
             })?;
         }

From b3d81a8d0a191d32449043ac4a431deb26ed57f8 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Thu, 6 Jan 2022 18:34:09 +0100
Subject: [PATCH 29/80] Fix more warnings

---
 src/files.rs | 14 ++------------
 1 file changed, 2 insertions(+), 12 deletions(-)

diff --git a/src/files.rs b/src/files.rs
index faaca81..6ced9ae 100644
--- a/src/files.rs
+++ b/src/files.rs
@@ -21,8 +21,6 @@ pub mod primitives;
 // TODO Move file content from `File` to `LoadedFile`
 #[derive(Debug)]
 struct LoadedFile {
-    /// Canonical path for this file.
-    path: PathBuf,
     /// User-readable path for this file.
     name: PathBuf,
     /// Identifier for codespan-reporting.
@@ -33,9 +31,8 @@ struct LoadedFile {
 }
 
 impl LoadedFile {
-    pub fn new(path: PathBuf, name: PathBuf, cs_id: usize, file: File) -> Self {
+    pub fn new(name: PathBuf, cs_id: usize, file: File) -> Self {
         Self {
-            path,
             name,
             cs_id,
             file,
@@ -183,7 +180,7 @@ impl Files {
             .cs_files
             .add(path.to_string_lossy().to_string(), content);
         self.files
-            .push(LoadedFile::new(path, name.to_owned(), cs_id, file));
+            .push(LoadedFile::new(name.to_owned(), cs_id, file));
 
         for include in includes {
             // Since we've successfully opened the file, its name can't be the
@@ -290,13 +287,6 @@ impl Files {
 
     /* Querying */
 
-    pub fn files(&self) -> Vec<(&Path, &File)> {
-        self.files
-            .iter()
-            .map(|f| (&f.name as &Path, &f.file))
-            .collect()
-    }
-
     fn commands_of_files(files: &[LoadedFile]) -> Vec<SourcedCommand<'_>> {
         let mut result = vec![];
         for (file_index, file) in files.iter().enumerate() {

From 4a46e70a73dd2d0f066f0254a07966e480a4d098 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Thu, 6 Jan 2022 19:15:38 +0100
Subject: [PATCH 30/80] Print markers for logs and entry descriptions

---
 src/cli.rs             | 21 ++++++++++------
 src/cli/layout.rs      | 10 ++++++--
 src/cli/layout/line.rs |  7 +++++-
 src/cli/print.rs       | 55 ++++++++++++++++++++++++++++++++----------
 src/files.rs           | 10 +++++++-
 5 files changed, 78 insertions(+), 25 deletions(-)

diff --git a/src/cli.rs b/src/cli.rs
index d54097f..d1d9005 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -86,8 +86,13 @@ fn find_entries(files: &Files, range: DateRange) -> Result<Vec<Entry>, Error<Fil
     Ok(files.eval(EntryMode::Relevant, range)?)
 }
 
-fn find_layout(entries: &[Entry], range: DateRange, now: NaiveDateTime) -> LineLayout {
-    layout::layout(entries, range, now)
+fn find_layout(
+    files: &Files,
+    entries: &[Entry],
+    range: DateRange,
+    now: NaiveDateTime,
+) -> LineLayout {
+    layout::layout(files, entries, range, now)
 }
 
 fn run_command(
@@ -99,28 +104,28 @@ fn run_command(
     match &opt.command {
         None => {
             let entries = find_entries(files, range)?;
-            let layout = find_layout(&entries, range, now);
+            let layout = find_layout(files, &entries, range, now);
             print::print(&layout);
         }
         Some(Command::Show { entries: ns }) => {
             let entries = find_entries(files, range)?;
-            let layout = find_layout(&entries, range, now);
+            let layout = find_layout(files, &entries, range, now);
             show::show(files, &entries, &layout, ns)?;
         }
         Some(Command::Done { entries: ns }) => {
             let entries = find_entries(files, range)?;
-            let layout = find_layout(&entries, range, now);
+            let layout = find_layout(files, &entries, range, now);
             done::done(files, &entries, &layout, ns, now)?;
             let entries = find_entries(files, range)?;
-            let layout = find_layout(&entries, range, now);
+            let layout = find_layout(files, &entries, range, now);
             print::print(&layout);
         }
         Some(Command::Cancel { entries: ns }) => {
             let entries = find_entries(files, range)?;
-            let layout = find_layout(&entries, range, now);
+            let layout = find_layout(files, &entries, range, now);
             cancel::cancel(files, &entries, &layout, ns, now)?;
             let entries = find_entries(files, range)?;
-            let layout = find_layout(&entries, range, now);
+            let layout = find_layout(files, &entries, range, now);
             print::print(&layout);
         }
         Some(Command::Fmt) => files.mark_all_dirty(),
diff --git a/src/cli/layout.rs b/src/cli/layout.rs
index 9b8aa90..b063c44 100644
--- a/src/cli/layout.rs
+++ b/src/cli/layout.rs
@@ -1,6 +1,7 @@
 use chrono::NaiveDateTime;
 
 use crate::eval::{DateRange, Entry};
+use crate::files::Files;
 
 use self::day::DayLayout;
 use self::line::LineLayout;
@@ -8,12 +9,17 @@ use self::line::LineLayout;
 mod day;
 pub mod line;
 
-pub fn layout(entries: &[Entry], range: DateRange, now: NaiveDateTime) -> LineLayout {
+pub fn layout(
+    files: &Files,
+    entries: &[Entry],
+    range: DateRange,
+    now: NaiveDateTime,
+) -> LineLayout {
     let mut day_layout = DayLayout::new(range, now);
     day_layout.layout(entries);
 
     let mut line_layout = LineLayout::new();
-    line_layout.render(entries, &day_layout);
+    line_layout.render(files, entries, &day_layout);
 
     line_layout
 }
diff --git a/src/cli/layout/line.rs b/src/cli/layout/line.rs
index a1127a5..1236f8e 100644
--- a/src/cli/layout/line.rs
+++ b/src/cli/layout/line.rs
@@ -9,6 +9,7 @@ use chrono::NaiveDate;
 
 use crate::eval::{Entry, EntryKind};
 use crate::files::primitives::Time;
+use crate::files::Files;
 
 use super::super::error::Error;
 use super::day::{DayEntry, DayLayout};
@@ -69,6 +70,7 @@ pub enum LineEntry {
         spans: Vec<Option<SpanSegment>>,
         date: NaiveDate,
         today: bool,
+        has_log: bool,
     },
     Now {
         spans: Vec<Option<SpanSegment>>,
@@ -80,6 +82,7 @@ pub enum LineEntry {
         time: Times,
         kind: LineKind,
         text: String,
+        has_desc: bool,
         extra: Option<String>,
     },
 }
@@ -107,7 +110,7 @@ impl LineLayout {
         }
     }
 
-    pub fn render(&mut self, entries: &[Entry], layout: &DayLayout) {
+    pub fn render(&mut self, files: &Files, entries: &[Entry], layout: &DayLayout) {
         // Make sure spans for visible `*End`s are drawn
         for entry in &layout.earlier {
             match entry {
@@ -123,6 +126,7 @@ impl LineLayout {
                 spans,
                 date: day,
                 today: day == layout.today,
+                has_log: files.log(day).is_some(),
             });
 
             let layout_entries = layout.days.get(&day).expect("got nonexisting day");
@@ -291,6 +295,7 @@ impl LineLayout {
             time,
             kind: Self::entry_kind(entry),
             text: Self::entry_title(entry),
+            has_desc: entry.has_description,
             extra,
         });
     }
diff --git a/src/cli/print.rs b/src/cli/print.rs
index 657cf1e..c644577 100644
--- a/src/cli/print.rs
+++ b/src/cli/print.rs
@@ -24,7 +24,12 @@ impl ShowLines {
 
     fn display_line(&mut self, line: &LineEntry) {
         match line {
-            LineEntry::Day { spans, date, today } => self.display_line_date(spans, *date, *today),
+            LineEntry::Day {
+                spans,
+                date,
+                today,
+                has_log,
+            } => self.display_line_date(spans, *date, *today, *has_log),
             LineEntry::Now { spans, time } => self.display_line_now(spans, *time),
             LineEntry::Entry {
                 number,
@@ -32,12 +37,19 @@ impl ShowLines {
                 time,
                 kind,
                 text,
+                has_desc,
                 extra,
-            } => self.display_line_entry(*number, spans, *time, *kind, text, extra),
+            } => self.display_line_entry(*number, spans, *time, *kind, text, *has_desc, extra),
         }
     }
 
-    fn display_line_date(&mut self, spans: &[Option<SpanSegment>], date: NaiveDate, today: bool) {
+    fn display_line_date(
+        &mut self,
+        spans: &[Option<SpanSegment>],
+        date: NaiveDate,
+        today: bool,
+        has_log: bool,
+    ) {
         let weekday: Weekday = date.weekday().into();
         let weekday = weekday.full_name();
 
@@ -55,16 +67,23 @@ impl ShowLines {
         // Spans and filler '=' symbols
         let p2 = self.display_spans(spans, styled("="));
 
-        // The rest of the line
-        let p3 = format!(
-            "===  {:9}  {}  ===={:=<w$}",
-            weekday,
-            date,
-            "",
-            w = self.num_width + self.span_width
-        );
+        // The rest of the line until after the date
+        let p3 = format!("===  {:9}  {}", weekday, date,);
 
-        self.push(&format!("{}{}{}\n", styled(&p1), p2, styled(&p3)));
+        // The "has log" marker (if any)
+        let p4 = Self::display_marker(has_log, " ");
+
+        // The rest of the line
+        let p5 = format!(" ===={:=<w$}", "", w = self.num_width + self.span_width);
+
+        self.push(&format!(
+            "{}{}{}{}{}\n",
+            styled(&p1),
+            p2,
+            styled(&p3),
+            p4,
+            styled(&p5)
+        ));
     }
 
     fn display_line_now(&mut self, spans: &[Option<SpanSegment>], time: Time) {
@@ -84,6 +103,7 @@ impl ShowLines {
         time: Times,
         kind: LineKind,
         text: &str,
+        has_desc: bool,
         extra: &Option<String>,
     ) {
         let num = match number {
@@ -92,12 +112,13 @@ impl ShowLines {
         };
 
         self.push(&format!(
-            "{:>nw$} {} {}{} {}{}\n",
+            "{:>nw$} {} {}{} {}{}{}\n",
             num.bright_black(),
             self.display_spans(spans, " ".into()),
             Self::display_kind(kind),
             Self::display_time(time),
             text,
+            Self::display_marker(has_desc, ""),
             Self::display_extra(extra),
             nw = self.num_width,
         ))
@@ -140,6 +161,14 @@ impl ShowLines {
         }
     }
 
+    fn display_marker(marker: bool, otherwise: &str) -> ColoredString {
+        if marker {
+            "*".bright_yellow()
+        } else {
+            otherwise.into()
+        }
+    }
+
     fn display_extra(extra: &Option<String>) -> ColoredString {
         match extra {
             None => "".into(),
diff --git a/src/files.rs b/src/files.rs
index 6ced9ae..105010c 100644
--- a/src/files.rs
+++ b/src/files.rs
@@ -7,7 +7,7 @@ use chrono::{DateTime, NaiveDate, Utc};
 use codespan_reporting::files::SimpleFiles;
 use tzfile::Tz;
 
-use self::commands::{Command, Done, File};
+use self::commands::{Command, Done, File, Log};
 pub use self::error::{Error, Result};
 use self::primitives::Spanned;
 
@@ -311,6 +311,14 @@ impl Files {
         Self::command_of_files(&self.files, source)
     }
 
+    pub fn log(&self, date: NaiveDate) -> Option<&Log> {
+        let source = *self.logs.get(&date)?;
+        match self.command(source).command {
+            Command::Log(log) => Some(log),
+            _ => unreachable!(),
+        }
+    }
+
     pub fn now(&self) -> DateTime<&Tz> {
         if let Some(tz) = &self.timezone {
             Utc::now().with_timezone(&tz)

From 2f6911eecacffc8ead8f858c2ff4ff6af7e0b80b Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Fri, 7 Jan 2022 20:04:31 +0100
Subject: [PATCH 31/80] Refactor CLI argument parsing

---
 src/cli.rs             |  10 ++--
 src/eval.rs            |  28 ++++++++---
 src/files/arguments.rs | 106 ++++++++++++++++++++++++++++++-----------
 src/files/grammar.pest |  11 +++--
 src/files/parse.rs     |   2 +-
 5 files changed, 112 insertions(+), 45 deletions(-)

diff --git a/src/cli.rs b/src/cli.rs
index d1d9005..4664fcc 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -8,7 +8,7 @@ use directories::ProjectDirs;
 use structopt::StructOpt;
 
 use crate::eval::{DateRange, Entry, EntryMode};
-use crate::files::arguments::Range;
+use crate::files::arguments::CliRange;
 use crate::files::{self, FileSource, Files};
 
 use self::error::Error;
@@ -29,8 +29,8 @@ pub struct Opt {
     /// Overwrite the current date
     #[structopt(short, long)]
     date: Option<NaiveDate>,
-    /// The range days to focus on
-    #[structopt(short, long, default_value = "today-2d--today+13d")]
+    /// Range of days to focus on
+    #[structopt(short, long, default_value = "t-2d--t+13d")]
     range: String,
     #[structopt(subcommand)]
     command: Option<Command>,
@@ -57,7 +57,7 @@ pub enum Command {
         #[structopt(required = true)]
         entries: Vec<usize>,
     },
-    /// Reformat all loaded files
+    /// Reformats all loaded files
     Fmt,
 }
 
@@ -145,7 +145,7 @@ pub fn run() {
     let now = find_now(&opt, &files);
 
     // Kinda ugly, but it can stay for now (until it grows at least).
-    let range = match Range::from_str(&opt.range) {
+    let range = match CliRange::from_str(&opt.range) {
         Ok(range) => match range.eval((), now.date()) {
             Ok(range) => range,
             Err(e) => {
diff --git a/src/eval.rs b/src/eval.rs
index 80f3033..def8a51 100644
--- a/src/eval.rs
+++ b/src/eval.rs
@@ -1,6 +1,6 @@
 use chrono::NaiveDate;
 
-use crate::files::arguments::{Range, RangeDate};
+use crate::files::arguments::{CliDate, CliDatum, CliRange};
 use crate::files::{FileSource, Files};
 
 use self::command::{CommandState, EvalCommand};
@@ -34,11 +34,27 @@ impl Files {
     }
 }
 
-impl Range {
+impl CliDate {
+    pub fn eval<S: Copy>(&self, index: S, today: NaiveDate) -> Result<NaiveDate, Error<S>> {
+        let mut date = match self.datum {
+            CliDatum::Date(d) => d,
+            CliDatum::Today => today,
+        };
+
+        if let Some(delta) = &self.delta {
+            let delta: Delta = delta.into();
+            date = delta.apply_date(index, date)?;
+        }
+
+        Ok(date)
+    }
+}
+
+impl CliRange {
     pub fn eval<S: Copy>(&self, index: S, today: NaiveDate) -> Result<DateRange, Error<S>> {
         let mut start = match self.start {
-            RangeDate::Date(d) => d,
-            RangeDate::Today => today,
+            CliDatum::Date(d) => d,
+            CliDatum::Today => today,
         };
 
         if let Some(delta) = &self.start_delta {
@@ -49,8 +65,8 @@ impl Range {
         let mut end = start;
 
         match self.end {
-            Some(RangeDate::Date(d)) => end = d,
-            Some(RangeDate::Today) => end = today,
+            Some(CliDatum::Date(d)) => end = d,
+            Some(CliDatum::Today) => end = today,
             None => {}
         }
 
diff --git a/src/files/arguments.rs b/src/files/arguments.rs
index 13cbf29..c04f991 100644
--- a/src/files/arguments.rs
+++ b/src/files/arguments.rs
@@ -8,35 +8,83 @@ use super::commands::Delta;
 use super::parse::{self, Error, Result, Rule, TodayfileParser};
 
 #[derive(Debug)]
-pub enum RangeDate {
+pub enum CliDatum {
     Date(NaiveDate),
     Today,
 }
 
-#[derive(Debug)]
-pub struct Range {
-    pub start: RangeDate,
-    pub start_delta: Option<Delta>,
-    pub end: Option<RangeDate>,
-    pub end_delta: Option<Delta>,
-}
-
-/* Parsing */
-
-fn parse_range_date(p: Pair<'_, Rule>) -> Result<RangeDate> {
-    assert!(matches!(p.as_rule(), Rule::datum | Rule::today));
+fn parse_cli_datum(p: Pair<'_, Rule>) -> Result<CliDatum> {
+    assert_eq!(p.as_rule(), Rule::cli_datum);
+    let p = p.into_inner().next().unwrap();
     Ok(match p.as_rule() {
-        Rule::datum => RangeDate::Date(parse::parse_datum(p)?.value),
-        Rule::today => RangeDate::Today,
+        Rule::datum => CliDatum::Date(parse::parse_datum(p)?.value),
+        Rule::today => CliDatum::Today,
         _ => unreachable!(),
     })
 }
 
-fn parse_range_start(p: Pair<'_, Rule>) -> Result<(RangeDate, Option<Delta>)> {
-    assert_eq!(p.as_rule(), Rule::range_start);
+#[derive(Debug)]
+pub struct CliDate {
+    pub datum: CliDatum,
+    pub delta: Option<Delta>,
+}
+
+fn parse_cli_date(p: Pair<'_, Rule>) -> Result<CliDate> {
+    assert_eq!(p.as_rule(), Rule::cli_date);
     let mut p = p.into_inner();
 
-    let start = parse_range_date(p.next().unwrap())?;
+    let datum = parse_cli_datum(p.next().unwrap())?;
+    let delta = match p.next() {
+        Some(p) => Some(parse::parse_delta(p)?.value),
+        None => None,
+    };
+
+    assert_eq!(p.next(), None);
+
+    Ok(CliDate { datum, delta })
+}
+
+#[derive(Debug)]
+pub enum CliIdent {
+    Number(usize),
+    Date(CliDate),
+}
+
+fn parse_cli_ident(p: Pair<'_, Rule>) -> Result<CliIdent> {
+    assert_eq!(p.as_rule(), Rule::cli_ident);
+    let p = p.into_inner().next().unwrap();
+    Ok(match p.as_rule() {
+        Rule::number => CliIdent::Number(parse::parse_number(p) as usize),
+        Rule::cli_date => CliIdent::Date(parse_cli_date(p)?),
+        _ => unreachable!(),
+    })
+}
+
+impl FromStr for CliIdent {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self> {
+        let mut pairs = TodayfileParser::parse(Rule::cli_ident, s)?;
+        let p = pairs.next().unwrap();
+        assert_eq!(pairs.next(), None);
+
+        parse_cli_ident(p)
+    }
+}
+
+#[derive(Debug)]
+pub struct CliRange {
+    pub start: CliDatum,
+    pub start_delta: Option<Delta>,
+    pub end: Option<CliDatum>,
+    pub end_delta: Option<Delta>,
+}
+
+fn parse_cli_range_start(p: Pair<'_, Rule>) -> Result<(CliDatum, Option<Delta>)> {
+    assert_eq!(p.as_rule(), Rule::cli_range_start);
+    let mut p = p.into_inner();
+
+    let start = parse_cli_datum(p.next().unwrap())?;
     let start_delta = match p.next() {
         None => None,
         Some(p) => Some(parse::parse_delta(p)?.value),
@@ -47,15 +95,15 @@ fn parse_range_start(p: Pair<'_, Rule>) -> Result<(RangeDate, Option<Delta>)> {
     Ok((start, start_delta))
 }
 
-fn parse_range_end(p: Pair<'_, Rule>) -> Result<(Option<RangeDate>, Option<Delta>)> {
-    assert_eq!(p.as_rule(), Rule::range_end);
+fn parse_cli_range_end(p: Pair<'_, Rule>) -> Result<(Option<CliDatum>, Option<Delta>)> {
+    assert_eq!(p.as_rule(), Rule::cli_range_end);
 
     let mut end = None;
     let mut end_delta = None;
 
     for p in p.into_inner() {
         match p.as_rule() {
-            Rule::datum | Rule::today => end = Some(parse_range_date(p)?),
+            Rule::cli_datum => end = Some(parse_cli_datum(p)?),
             Rule::delta => end_delta = Some(parse::parse_delta(p)?.value),
             _ => unreachable!(),
         }
@@ -64,18 +112,18 @@ fn parse_range_end(p: Pair<'_, Rule>) -> Result<(Option<RangeDate>, Option<Delta
     Ok((end, end_delta))
 }
 
-fn parse_range(p: Pair<'_, Rule>) -> Result<Range> {
-    assert_eq!(p.as_rule(), Rule::range);
+fn parse_cli_range(p: Pair<'_, Rule>) -> Result<CliRange> {
+    assert_eq!(p.as_rule(), Rule::cli_range);
     let mut p = p.into_inner();
 
-    let (start, start_delta) = parse_range_start(p.next().unwrap())?;
+    let (start, start_delta) = parse_cli_range_start(p.next().unwrap())?;
     let (end, end_delta) = match p.next() {
         // For some reason, the EOI gets captured but the SOI doesn't.
-        Some(p) if p.as_rule() != Rule::EOI => parse_range_end(p)?,
+        Some(p) if p.as_rule() != Rule::EOI => parse_cli_range_end(p)?,
         _ => (None, None),
     };
 
-    Ok(Range {
+    Ok(CliRange {
         start,
         start_delta,
         end,
@@ -83,14 +131,14 @@ fn parse_range(p: Pair<'_, Rule>) -> Result<Range> {
     })
 }
 
-impl FromStr for Range {
+impl FromStr for CliRange {
     type Err = Error;
 
     fn from_str(s: &str) -> Result<Self> {
-        let mut pairs = TodayfileParser::parse(Rule::range, s)?;
+        let mut pairs = TodayfileParser::parse(Rule::cli_range, s)?;
         let p = pairs.next().unwrap();
         assert_eq!(pairs.next(), None);
 
-        parse_range(p)
+        parse_cli_range(p)
     }
 }
diff --git a/src/files/grammar.pest b/src/files/grammar.pest
index e0a0279..dba2273 100644
--- a/src/files/grammar.pest
+++ b/src/files/grammar.pest
@@ -148,7 +148,10 @@ command = { include | timezone | task | note | log }
 
 file = ${ SOI ~ (empty_line* ~ command)* ~ empty_line* ~ WHITESPACE* ~ EOI }
 
-today = { "today" }
-range_start = { (datum | today) ~ delta? }
-range_end = { (datum | today) ~ delta? | delta }
-range = { SOI ~ range_start ~ ("--" ~ range_end)? ~ EOI}
+today = { "today" | "t" }
+cli_datum = { datum | today }
+cli_date = { cli_datum ~ delta? }
+cli_ident = { SOI ~ (number | cli_date) ~ EOI }
+cli_range_start = { cli_datum ~ delta? }
+cli_range_end = { cli_datum ~ delta? | delta }
+cli_range = { SOI ~ cli_range_start ~ ("--" ~ cli_range_end)? ~ EOI }
diff --git a/src/files/parse.rs b/src/files/parse.rs
index f817d1d..67c0da9 100644
--- a/src/files/parse.rs
+++ b/src/files/parse.rs
@@ -49,7 +49,7 @@ fn parse_timezone(p: Pair<'_, Rule>) -> Spanned<String> {
     Spanned::new(span, name)
 }
 
-fn parse_number(p: Pair<'_, Rule>) -> i32 {
+pub fn parse_number(p: Pair<'_, Rule>) -> i32 {
     assert_eq!(p.as_rule(), Rule::number);
     p.as_str().parse().unwrap()
 }

From badc0d7a9f5905d13248f0651d7e16c0b9b7f738 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Fri, 7 Jan 2022 21:42:37 +0100
Subject: [PATCH 32/80] Print parse errors with codespan-reporting

---
 src/cli.rs             | 42 ++++++++++++---------
 src/files.rs           | 26 ++++++++++---
 src/files/arguments.rs | 22 ++++++-----
 src/files/commands.rs  | 11 ++++++
 src/files/error.rs     | 85 ++++++++++++++++++++++++++++++++++++++++--
 5 files changed, 150 insertions(+), 36 deletions(-)

diff --git a/src/cli.rs b/src/cli.rs
index 4664fcc..df1624f 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -7,9 +7,9 @@ use codespan_reporting::files::SimpleFile;
 use directories::ProjectDirs;
 use structopt::StructOpt;
 
-use crate::eval::{DateRange, Entry, EntryMode};
+use crate::eval::{self, DateRange, Entry, EntryMode};
 use crate::files::arguments::CliRange;
-use crate::files::{self, FileSource, Files};
+use crate::files::{self, FileSource, Files, ParseError};
 
 use self::error::Error;
 use self::layout::line::LineLayout;
@@ -95,6 +95,24 @@ fn find_layout(
     layout::layout(files, entries, range, now)
 }
 
+fn parse_eval_arg<T, R>(
+    name: &str,
+    text: &str,
+    eval: impl FnOnce(T) -> Result<R, eval::Error<()>>,
+) -> Option<R>
+where
+    T: FromStr<Err = ParseError<()>>,
+{
+    match T::from_str(text) {
+        Ok(value) => match eval(value) {
+            Ok(result) => return Some(result),
+            Err(e) => crate::error::eprint_error(&SimpleFile::new(name, text), &e),
+        },
+        Err(e) => crate::error::eprint_error(&SimpleFile::new(name, text), &e),
+    }
+    None
+}
+
 fn run_command(
     opt: &Opt,
     files: &mut Files,
@@ -144,21 +162,11 @@ pub fn run() {
 
     let now = find_now(&opt, &files);
 
-    // Kinda ugly, but it can stay for now (until it grows at least).
-    let range = match CliRange::from_str(&opt.range) {
-        Ok(range) => match range.eval((), now.date()) {
-            Ok(range) => range,
-            Err(e) => {
-                eprintln!("Failed to evaluate --range:");
-                let file = SimpleFile::new("--range", &opt.range);
-                crate::error::eprint_error(&file, &e);
-                process::exit(1)
-            }
-        },
-        Err(e) => {
-            eprintln!("Failed to parse --range:\n{}", e.with_path("--range"));
-            process::exit(1)
-        }
+    let range = match parse_eval_arg("--range", &opt.range, |range: CliRange| {
+        range.eval((), now.date())
+    }) {
+        Some(range) => range,
+        None => process::exit(1),
     };
 
     if let Err(e) = run_command(&opt, &mut files, range, now) {
diff --git a/src/files.rs b/src/files.rs
index 105010c..f1e170c 100644
--- a/src/files.rs
+++ b/src/files.rs
@@ -8,7 +8,7 @@ use codespan_reporting::files::SimpleFiles;
 use tzfile::Tz;
 
 use self::commands::{Command, Done, File, Log};
-pub use self::error::{Error, Result};
+pub use self::error::{Error, ParseError, Result};
 use self::primitives::Spanned;
 
 pub mod arguments;
@@ -162,9 +162,26 @@ impl Files {
             file: path.clone(),
             error: e,
         })?;
+        let cs_id = self
+            .cs_files
+            .add(name.to_string_lossy().to_string(), content.clone());
 
         // Using `name` instead of `path` for the unwrap below.
-        let file = parse::parse(name, &content)?;
+        let file = match parse::parse(name, &content) {
+            Ok(file) => file,
+            Err(error) => {
+                // Using a dummy file. This should be fine since we return an
+                // error immediately after and the user must never call `load`
+                // twice. Otherwise, we run the danger of overwriting a file
+                // with empty content.
+                self.files
+                    .push(LoadedFile::new(name.to_owned(), cs_id, File::dummy()));
+                return Err(Error::Parse {
+                    file: FileSource(self.files.len() - 1),
+                    error,
+                });
+            }
+        };
 
         let includes = file
             .commands
@@ -175,10 +192,7 @@ impl Files {
             })
             .collect::<Vec<_>>();
 
-        loaded.insert(path.clone());
-        let cs_id = self
-            .cs_files
-            .add(path.to_string_lossy().to_string(), content);
+        loaded.insert(path);
         self.files
             .push(LoadedFile::new(name.to_owned(), cs_id, file));
 
diff --git a/src/files/arguments.rs b/src/files/arguments.rs
index c04f991..6ff4b7d 100644
--- a/src/files/arguments.rs
+++ b/src/files/arguments.rs
@@ -1,3 +1,4 @@
+use std::result;
 use std::str::FromStr;
 
 use chrono::NaiveDate;
@@ -5,7 +6,8 @@ use pest::iterators::Pair;
 use pest::Parser;
 
 use super::commands::Delta;
-use super::parse::{self, Error, Result, Rule, TodayfileParser};
+use super::parse::{self, Result, Rule, TodayfileParser};
+use super::ParseError;
 
 #[derive(Debug)]
 pub enum CliDatum {
@@ -61,14 +63,15 @@ fn parse_cli_ident(p: Pair<'_, Rule>) -> Result<CliIdent> {
 }
 
 impl FromStr for CliIdent {
-    type Err = Error;
+    type Err = ParseError<()>;
 
-    fn from_str(s: &str) -> Result<Self> {
-        let mut pairs = TodayfileParser::parse(Rule::cli_ident, s)?;
+    fn from_str(s: &str) -> result::Result<Self, ParseError<()>> {
+        let mut pairs =
+            TodayfileParser::parse(Rule::cli_ident, s).map_err(|e| ParseError::new((), e))?;
         let p = pairs.next().unwrap();
         assert_eq!(pairs.next(), None);
 
-        parse_cli_ident(p)
+        parse_cli_ident(p).map_err(|e| ParseError::new((), e))
     }
 }
 
@@ -132,13 +135,14 @@ fn parse_cli_range(p: Pair<'_, Rule>) -> Result<CliRange> {
 }
 
 impl FromStr for CliRange {
-    type Err = Error;
+    type Err = ParseError<()>;
 
-    fn from_str(s: &str) -> Result<Self> {
-        let mut pairs = TodayfileParser::parse(Rule::cli_range, s)?;
+    fn from_str(s: &str) -> result::Result<Self, ParseError<()>> {
+        let mut pairs =
+            TodayfileParser::parse(Rule::cli_range, s).map_err(|e| ParseError::new((), e))?;
         let p = pairs.next().unwrap();
         assert_eq!(pairs.next(), None);
 
-        parse_cli_range(p)
+        parse_cli_range(p).map_err(|e| ParseError::new((), e))
     }
 }
diff --git a/src/files/commands.rs b/src/files/commands.rs
index bda9ce7..82c6b51 100644
--- a/src/files/commands.rs
+++ b/src/files/commands.rs
@@ -357,3 +357,14 @@ pub struct File {
     pub contents: String,
     pub commands: Vec<Command>,
 }
+
+impl File {
+    /// Create an empty dummy file. This file should only be used as a
+    /// placeholder value.
+    pub fn dummy() -> Self {
+        Self {
+            contents: String::new(),
+            commands: vec![],
+        }
+    }
+}
diff --git a/src/files/error.rs b/src/files/error.rs
index 14f2a8c..3133221 100644
--- a/src/files/error.rs
+++ b/src/files/error.rs
@@ -4,12 +4,85 @@ use std::{io, result};
 use chrono::NaiveDate;
 use codespan_reporting::diagnostic::{Diagnostic, Label};
 use codespan_reporting::term::Config;
+use pest::error::{ErrorVariant, InputLocation};
 
 use crate::error::Eprint;
 
 use super::primitives::Span;
 use super::{parse, FileSource, Files};
 
+#[derive(Debug, thiserror::Error)]
+#[error("{error}")]
+pub struct ParseError<S> {
+    file: S,
+    error: parse::Error,
+}
+
+impl<S> ParseError<S> {
+    pub fn new(file: S, error: parse::Error) -> Self {
+        Self { file, error }
+    }
+
+    fn rule_name(rule: parse::Rule) -> String {
+        // TODO Rename rules to be more readable?
+        format!("{:?}", rule)
+    }
+
+    fn enumerate(rules: &[parse::Rule]) -> String {
+        match rules.len() {
+            0 => "something".to_string(),
+            1 => Self::rule_name(rules[0]),
+            n => {
+                let except_last = rules
+                    .iter()
+                    .take(n - 1)
+                    .map(|rule| Self::rule_name(*rule))
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                let last = Self::rule_name(rules[n - 1]);
+                format!("{} or {}", except_last, last)
+            }
+        }
+    }
+
+    fn notes(&self) -> Vec<String> {
+        match &self.error.variant {
+            ErrorVariant::ParsingError {
+                positives,
+                negatives,
+            } => {
+                let mut notes = vec![];
+                if !positives.is_empty() {
+                    notes.push(format!("expected {}", Self::enumerate(positives)))
+                }
+                if !negatives.is_empty() {
+                    notes.push(format!("unexpected {}", Self::enumerate(negatives)))
+                }
+                notes
+            }
+            ErrorVariant::CustomError { message } => vec![message.clone()],
+        }
+    }
+}
+
+impl<'a, F> Eprint<'a, F> for ParseError<F::FileId>
+where
+    F: codespan_reporting::files::Files<'a>,
+{
+    fn eprint<'f: 'a>(&self, files: &'f F, config: &Config) {
+        let range = match self.error.location {
+            InputLocation::Pos(at) => at..at,
+            InputLocation::Span((from, to)) => from..to,
+        };
+        let name = files.name(self.file).expect("file exists");
+        let diagnostic = Diagnostic::error()
+            .with_message(format!("Could not parse {}", name))
+            .with_labels(vec![Label::primary(self.file, range)])
+            .with_notes(self.notes());
+        Self::eprint_diagnostic(files, config, &diagnostic);
+    }
+}
+
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
     #[error("Could not resolve {path}: {error}")]
@@ -27,8 +100,11 @@ pub enum Error {
     },
     #[error("Could not determine local timezone: {error}")]
     LocalTz { error: io::Error },
-    #[error("{0}")]
-    Parse(#[from] parse::Error),
+    #[error("{error}")]
+    Parse {
+        file: FileSource,
+        error: parse::Error,
+    },
     #[error("Conflicting time zones {tz1} and {tz2}")]
     TzConflict {
         file1: FileSource,
@@ -81,8 +157,9 @@ impl<'a> Eprint<'a, Files> for Error {
                 eprintln!("Could not determine local timezone:");
                 eprintln!("  {}", error);
             }
-            // TODO Format using codespan-reporting as well
-            Error::Parse(error) => eprintln!("{}", error),
+            Error::Parse { file, error } => {
+                ParseError::new(*file, error.clone()).eprint(files, config)
+            }
             Error::TzConflict {
                 file1,
                 span1,

From 3e2fa542139778c32c555c5a37117e9582560936 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Fri, 7 Jan 2022 22:34:00 +0100
Subject: [PATCH 33/80] Show logs in addition to entries

---
 src/cli.rs       | 26 +++++++++++++++----
 src/cli/error.rs |  4 +++
 src/cli/show.rs  | 65 ++++++++++++++++++++++++++++++++----------------
 src/eval.rs      |  2 +-
 src/files.rs     | 34 ++++++++++++++-----------
 5 files changed, 90 insertions(+), 41 deletions(-)

diff --git a/src/cli.rs b/src/cli.rs
index df1624f..5baf98c 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -8,7 +8,7 @@ use directories::ProjectDirs;
 use structopt::StructOpt;
 
 use crate::eval::{self, DateRange, Entry, EntryMode};
-use crate::files::arguments::CliRange;
+use crate::files::arguments::{CliIdent, CliRange};
 use crate::files::{self, FileSource, Files, ParseError};
 
 use self::error::Error;
@@ -41,9 +41,9 @@ pub enum Command {
     #[allow(rustdoc::broken_intra_doc_links)]
     /// Shows individual entries in detail
     Show {
-        /// Entries to show
+        /// Entries and days to show
         #[structopt(required = true)]
-        entries: Vec<usize>,
+        identifiers: Vec<String>,
     },
     /// Marks one or more entries as done
     Done {
@@ -113,6 +113,21 @@ where
     None
 }
 
+fn parse_show_idents(identifiers: &[String], today: NaiveDate) -> Vec<show::Ident> {
+    let mut idents = vec![];
+    for ident in identifiers {
+        let ident = match parse_eval_arg("identifier", ident, |ident: CliIdent| match ident {
+            CliIdent::Number(n) => Ok(show::Ident::Number(n)),
+            CliIdent::Date(d) => Ok(show::Ident::Date(d.eval((), today)?)),
+        }) {
+            Some(ident) => ident,
+            None => process::exit(1),
+        };
+        idents.push(ident);
+    }
+    idents
+}
+
 fn run_command(
     opt: &Opt,
     files: &mut Files,
@@ -125,10 +140,11 @@ fn run_command(
             let layout = find_layout(files, &entries, range, now);
             print::print(&layout);
         }
-        Some(Command::Show { entries: ns }) => {
+        Some(Command::Show { identifiers }) => {
             let entries = find_entries(files, range)?;
             let layout = find_layout(files, &entries, range, now);
-            show::show(files, &entries, &layout, ns)?;
+            let idents = parse_show_idents(identifiers, now.date());
+            show::show(files, &entries, &layout, &idents);
         }
         Some(Command::Done { entries: ns }) => {
             let entries = find_entries(files, range)?;
diff --git a/src/cli/error.rs b/src/cli/error.rs
index a84a0df..7ad1b01 100644
--- a/src/cli/error.rs
+++ b/src/cli/error.rs
@@ -1,3 +1,4 @@
+use chrono::NaiveDate;
 use codespan_reporting::files::Files;
 use codespan_reporting::term::Config;
 
@@ -10,6 +11,8 @@ pub enum Error<S> {
     Eval(#[from] eval::Error<S>),
     #[error("No entry with number {0}")]
     NoSuchEntry(usize),
+    #[error("No log for {0}")]
+    NoSuchLog(NaiveDate),
     #[error("Not a task")]
     NotATask(Vec<usize>),
 }
@@ -19,6 +22,7 @@ impl<'a, F: Files<'a>> Eprint<'a, F> for Error<F::FileId> {
         match self {
             Error::Eval(e) => e.eprint(files, config),
             Error::NoSuchEntry(n) => eprintln!("No entry with number {}", n),
+            Error::NoSuchLog(date) => eprintln!("No log for {}", date),
             Error::NotATask(ns) => {
                 if ns.is_empty() {
                     eprintln!("Not a task.");
diff --git a/src/cli/show.rs b/src/cli/show.rs
index 1b433eb..07c648c 100644
--- a/src/cli/show.rs
+++ b/src/cli/show.rs
@@ -1,9 +1,18 @@
+use chrono::NaiveDate;
+
 use crate::eval::{Entry, EntryKind};
-use crate::files::Files;
+use crate::files::commands::{Command, Log};
+use crate::files::{Files, Sourced};
 
 use super::error::Error;
 use super::layout::line::LineLayout;
 
+fn show_command(command: &Command) {
+    for line in format!("{}", command).lines() {
+        println!("| {}", line);
+    }
+}
+
 fn show_entry(files: &Files, entry: &Entry) {
     let command = files.command(entry.source);
 
@@ -28,32 +37,46 @@ fn show_entry(files: &Files, entry: &Entry) {
     }
 
     println!("FROM COMMAND");
-    for line in format!("{}", command.command).lines() {
-        println!("| {}", line);
+    show_command(command.value);
+}
+
+fn show_log(files: &Files, log: Sourced<'_, Log>) {
+    let command = files.command(log.source);
+
+    println!("LOG {}", log.value.date);
+
+    println!("FROM COMMAND");
+    show_command(command.value);
+}
+
+fn show_ident(files: &Files, entries: &[Entry], layout: &LineLayout, ident: Ident) {
+    match ident {
+        Ident::Number(n) => match layout.look_up_number::<()>(n) {
+            Ok(index) => show_entry(files, &entries[index]),
+            Err(e) => println!("{}", e),
+        },
+        Ident::Date(date) => match files.log(date) {
+            Some(log) => show_log(files, log),
+            None => println!("{}", Error::NoSuchLog::<()>(date)),
+        },
     }
 }
 
-pub fn show<S>(
-    files: &Files,
-    entries: &[Entry],
-    layout: &LineLayout,
-    numbers: &[usize],
-) -> Result<(), Error<S>> {
-    if numbers.is_empty() {
+#[derive(Debug, Clone, Copy)]
+pub enum Ident {
+    Number(usize),
+    Date(NaiveDate),
+}
+
+pub fn show(files: &Files, entries: &[Entry], layout: &LineLayout, idents: &[Ident]) {
+    if idents.is_empty() {
         // Nothing to do
-        return Ok(());
+        return;
     }
 
-    let indices = numbers
-        .iter()
-        .map(|n| layout.look_up_number(*n))
-        .collect::<Result<Vec<usize>, _>>()?;
-
-    show_entry(files, &entries[indices[0]]);
-    for &index in indices.iter().skip(1) {
+    show_ident(files, entries, layout, idents[0]);
+    for &ident in idents.iter().skip(1) {
         println!();
-        show_entry(files, &entries[index]);
+        show_ident(files, entries, layout, ident);
     }
-
-    Ok(())
 }
diff --git a/src/eval.rs b/src/eval.rs
index def8a51..b0ca8cf 100644
--- a/src/eval.rs
+++ b/src/eval.rs
@@ -24,7 +24,7 @@ impl Files {
         let mut entries = Entries::new(mode, range);
         for command in self.commands() {
             let source = command.source;
-            if let Some(command) = EvalCommand::new(command.command) {
+            if let Some(command) = EvalCommand::new(command.value) {
                 for entry in CommandState::new(command, source, range).eval()?.entries() {
                     entries.add(entry);
                 }
diff --git a/src/files.rs b/src/files.rs
index f1e170c..3f32812 100644
--- a/src/files.rs
+++ b/src/files.rs
@@ -62,9 +62,15 @@ impl Source {
 }
 
 #[derive(Debug)]
-pub struct SourcedCommand<'a> {
+pub struct Sourced<'a, T> {
     pub source: Source,
-    pub command: &'a Command,
+    pub value: &'a T,
+}
+
+impl<'a, T> Sourced<'a, T> {
+    fn new(source: Source, value: &'a T) -> Self {
+        Self { source, value }
+    }
 }
 
 #[derive(Debug)]
@@ -212,7 +218,7 @@ impl Files {
         let mut found: Option<(Source, Spanned<String>)> = None;
 
         for command in self.commands() {
-            if let Command::Timezone(tz) = command.command {
+            if let Command::Timezone(tz) = command.value {
                 if let Some((found_source, found_tz)) = &found {
                     if tz.value != found_tz.value {
                         return Err(Error::TzConflict {
@@ -247,14 +253,14 @@ impl Files {
 
     fn collect_logs(&mut self) -> Result<()> {
         for command in Self::commands_of_files(&self.files) {
-            if let Command::Log(log) = command.command {
+            if let Command::Log(log) = command.value {
                 match self.logs.entry(log.date.value) {
                     Entry::Vacant(e) => {
                         e.insert(command.source);
                     }
                     Entry::Occupied(e) => {
                         let other_cmd = Self::command_of_files(&self.files, *e.get());
-                        let other_span = match &other_cmd.command {
+                        let other_span = match &other_cmd.value {
                             Command::Log(log) => log.date.span,
                             _ => unreachable!(),
                         };
@@ -301,34 +307,34 @@ impl Files {
 
     /* Querying */
 
-    fn commands_of_files(files: &[LoadedFile]) -> Vec<SourcedCommand<'_>> {
+    fn commands_of_files(files: &[LoadedFile]) -> Vec<Sourced<'_, Command>> {
         let mut result = vec![];
         for (file_index, file) in files.iter().enumerate() {
             for (command_index, command) in file.file.commands.iter().enumerate() {
                 let source = Source::new(file_index, command_index);
-                result.push(SourcedCommand { source, command });
+                result.push(Sourced::new(source, command));
             }
         }
         result
     }
 
-    pub fn commands(&self) -> Vec<SourcedCommand<'_>> {
+    pub fn commands(&self) -> Vec<Sourced<'_, Command>> {
         Self::commands_of_files(&self.files)
     }
 
-    fn command_of_files(files: &[LoadedFile], source: Source) -> SourcedCommand<'_> {
+    fn command_of_files(files: &[LoadedFile], source: Source) -> Sourced<'_, Command> {
         let command = &files[source.file].file.commands[source.command];
-        SourcedCommand { source, command }
+        Sourced::new(source, command)
     }
 
-    pub fn command(&self, source: Source) -> SourcedCommand<'_> {
+    pub fn command(&self, source: Source) -> Sourced<'_, Command> {
         Self::command_of_files(&self.files, source)
     }
 
-    pub fn log(&self, date: NaiveDate) -> Option<&Log> {
+    pub fn log(&self, date: NaiveDate) -> Option<Sourced<'_, Log>> {
         let source = *self.logs.get(&date)?;
-        match self.command(source).command {
-            Command::Log(log) => Some(log),
+        match self.command(source).value {
+            Command::Log(log) => Some(Sourced::new(source, log)),
             _ => unreachable!(),
         }
     }

From 0484eda85939e2751841263bab8f7f34176644a7 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sat, 8 Jan 2022 00:37:55 +0100
Subject: [PATCH 34/80] Add 'log' cli command

---
 Cargo.lock              | 97 +++++++++++++++++++++++++++++++++++++++++
 Cargo.toml              |  1 +
 src/cli.rs              | 14 +++++-
 src/cli/error.rs        |  8 ++++
 src/cli/log.rs          | 26 +++++++++++
 src/files.rs            | 47 ++++++++++++++++++++
 src/files/arguments.rs  | 13 ++++++
 src/files/primitives.rs |  8 ++++
 8 files changed, 213 insertions(+), 1 deletion(-)
 create mode 100644 src/cli/log.rs

diff --git a/Cargo.lock b/Cargo.lock
index 13420f4..73c80f8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -157,6 +157,22 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "edit"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3cdd6936f8bd9782e28932eef853bfcd8548992ce5748bb3e7e88bad613d0ee0"
+dependencies = [
+ "tempfile",
+ "which",
+]
+
+[[package]]
+name = "either"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
+
 [[package]]
 name = "fake-simd"
 version = "0.1.2"
@@ -287,6 +303,12 @@ dependencies = [
  "sha-1",
 ]
 
+[[package]]
+name = "ppv-lite86"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
+
 [[package]]
 name = "proc-macro-error"
 version = "1.0.4"
@@ -329,6 +351,46 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "rand"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+ "rand_hc",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rand_hc"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7"
+dependencies = [
+ "rand_core",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.2.10"
@@ -348,6 +410,15 @@ dependencies = [
  "redox_syscall",
 ]
 
+[[package]]
+name = "remove_dir_all"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
+dependencies = [
+ "winapi",
+]
+
 [[package]]
 name = "sha-1"
 version = "0.8.2"
@@ -401,6 +472,20 @@ dependencies = [
  "unicode-xid",
 ]
 
+[[package]]
+name = "tempfile"
+version = "3.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "rand",
+ "redox_syscall",
+ "remove_dir_all",
+ "winapi",
+]
+
 [[package]]
 name = "termcolor"
 version = "1.1.2"
@@ -459,6 +544,7 @@ dependencies = [
  "colored",
  "computus",
  "directories",
+ "edit",
  "pest",
  "pest_derive",
  "structopt",
@@ -524,6 +610,17 @@ version = "0.10.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
 
+[[package]]
+name = "which"
+version = "4.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea187a8ef279bc014ec368c27a920da2024d2a711109bfbe3440585d5cf27ad9"
+dependencies = [
+ "either",
+ "lazy_static",
+ "libc",
+]
+
 [[package]]
 name = "winapi"
 version = "0.3.9"
diff --git a/Cargo.toml b/Cargo.toml
index 458483b..2807701 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,6 +9,7 @@ codespan-reporting = "0.11.1"
 colored = "2.0.0"
 computus = "1.0.0"
 directories = "4.0.1"
+edit = "0.1.3"
 pest = "2.1.3"
 pest_derive = "2.1.0"
 structopt = "0.3.25"
diff --git a/src/cli.rs b/src/cli.rs
index 5baf98c..4bb98ac 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -8,7 +8,7 @@ use directories::ProjectDirs;
 use structopt::StructOpt;
 
 use crate::eval::{self, DateRange, Entry, EntryMode};
-use crate::files::arguments::{CliIdent, CliRange};
+use crate::files::arguments::{CliDate, CliIdent, CliRange};
 use crate::files::{self, FileSource, Files, ParseError};
 
 use self::error::Error;
@@ -18,6 +18,7 @@ mod cancel;
 mod done;
 mod error;
 mod layout;
+mod log;
 mod print;
 mod show;
 
@@ -57,6 +58,11 @@ pub enum Command {
         #[structopt(required = true)]
         entries: Vec<usize>,
     },
+    /// Edits or creates a log entry
+    Log {
+        #[structopt(default_value = "today")]
+        date: String,
+    },
     /// Reformats all loaded files
     Fmt,
 }
@@ -162,6 +168,12 @@ fn run_command(
             let layout = find_layout(files, &entries, range, now);
             print::print(&layout);
         }
+        Some(Command::Log { date }) => {
+            match parse_eval_arg("date", date, |date: CliDate| date.eval((), now.date())) {
+                Some(date) => log::log(files, date)?,
+                None => process::exit(1),
+            };
+        }
         Some(Command::Fmt) => files.mark_all_dirty(),
     }
     Ok(())
diff --git a/src/cli/error.rs b/src/cli/error.rs
index 7ad1b01..b4246c3 100644
--- a/src/cli/error.rs
+++ b/src/cli/error.rs
@@ -1,3 +1,5 @@
+use std::io;
+
 use chrono::NaiveDate;
 use codespan_reporting::files::Files;
 use codespan_reporting::term::Config;
@@ -15,6 +17,8 @@ pub enum Error<S> {
     NoSuchLog(NaiveDate),
     #[error("Not a task")]
     NotATask(Vec<usize>),
+    #[error("Error editing log for {date}: {error}")]
+    EditingLog { date: NaiveDate, error: io::Error },
 }
 
 impl<'a, F: Files<'a>> Eprint<'a, F> for Error<F::FileId> {
@@ -33,6 +37,10 @@ impl<'a, F: Files<'a>> Eprint<'a, F> for Error<F::FileId> {
                     eprintln!("{} are not tasks.", ns.join(", "));
                 }
             }
+            Error::EditingLog { date, error } => {
+                eprintln!("Error editing log for {}", date);
+                eprintln!("  {}", error);
+            }
         }
     }
 }
diff --git a/src/cli/log.rs b/src/cli/log.rs
new file mode 100644
index 0000000..6456827
--- /dev/null
+++ b/src/cli/log.rs
@@ -0,0 +1,26 @@
+use chrono::NaiveDate;
+
+use crate::files::Files;
+
+use super::error::Error;
+
+pub fn log<S>(files: &mut Files, date: NaiveDate) -> Result<(), Error<S>> {
+    let desc = files
+        .log(date)
+        .map(|log| log.value.desc.join("\n"))
+        .unwrap_or_default();
+
+    let mut builder = edit::Builder::new();
+    builder.suffix(".md");
+    let edited = edit::edit_with_builder(desc, &builder)
+        .map_err(|error| Error::EditingLog { date, error })?;
+
+    let edited = edited
+        .lines()
+        .map(|line| line.to_string())
+        .collect::<Vec<_>>();
+
+    files.set_log(date, edited);
+
+    Ok(())
+}
diff --git a/src/files.rs b/src/files.rs
index 3f32812..007ad63 100644
--- a/src/files.rs
+++ b/src/files.rs
@@ -339,6 +339,21 @@ impl Files {
         }
     }
 
+    fn latest_log(&self) -> Option<(NaiveDate, Source)> {
+        self.logs
+            .iter()
+            .map(|(d, s)| (*d, *s))
+            .max_by_key(|(d, _)| *d)
+    }
+
+    fn latest_log_before(&self, date: NaiveDate) -> Option<(NaiveDate, Source)> {
+        self.logs
+            .iter()
+            .map(|(d, s)| (*d, *s))
+            .filter(|(d, _)| d <= &date)
+            .max_by_key(|(d, _)| *d)
+    }
+
     pub fn now(&self) -> DateTime<&Tz> {
         if let Some(tz) = &self.timezone {
             Utc::now().with_timezone(&tz)
@@ -355,6 +370,18 @@ impl Files {
         }
     }
 
+    fn modify(&mut self, source: Source, edit: impl FnOnce(&mut Command)) {
+        let file = &mut self.files[source.file];
+        edit(&mut file.file.commands[source.command]);
+        file.dirty = true;
+    }
+
+    fn insert(&mut self, file: FileSource, command: Command) {
+        let file = &mut self.files[file.0];
+        file.file.commands.push(command);
+        file.dirty = true;
+    }
+
     /// Add a [`Done`] statement to the task identified by `source`.
     ///
     /// Returns whether the addition was successful. It can fail if the entry
@@ -370,6 +397,26 @@ impl Files {
         true
     }
 
+    pub fn set_log(&mut self, date: NaiveDate, desc: Vec<String>) {
+        if let Some(source) = self.logs.get(&date).cloned() {
+            self.modify(source, |command| match command {
+                Command::Log(log) => log.desc = desc,
+                _ => unreachable!(),
+            });
+        } else {
+            let file = self
+                .latest_log_before(date)
+                .or_else(|| self.latest_log())
+                .map(|(_, source)| source.file())
+                .unwrap_or(FileSource(0));
+
+            let date = Spanned::dummy(date);
+            let command = Command::Log(Log { date, desc });
+
+            self.insert(file, command);
+        }
+    }
+
     /* Errors */
 
     fn cs_id(&self, file: FileSource) -> usize {
diff --git a/src/files/arguments.rs b/src/files/arguments.rs
index 6ff4b7d..100e7f1 100644
--- a/src/files/arguments.rs
+++ b/src/files/arguments.rs
@@ -46,6 +46,19 @@ fn parse_cli_date(p: Pair<'_, Rule>) -> Result<CliDate> {
     Ok(CliDate { datum, delta })
 }
 
+impl FromStr for CliDate {
+    type Err = ParseError<()>;
+
+    fn from_str(s: &str) -> result::Result<Self, ParseError<()>> {
+        let mut pairs =
+            TodayfileParser::parse(Rule::cli_date, s).map_err(|e| ParseError::new((), e))?;
+        let p = pairs.next().unwrap();
+        assert_eq!(pairs.next(), None);
+
+        parse_cli_date(p).map_err(|e| ParseError::new((), e))
+    }
+}
+
 #[derive(Debug)]
 pub enum CliIdent {
     Number(usize),
diff --git a/src/files/primitives.rs b/src/files/primitives.rs
index 118bfb3..e63b867 100644
--- a/src/files/primitives.rs
+++ b/src/files/primitives.rs
@@ -31,6 +31,10 @@ impl Span {
             end: cmp::max(self.end, other.end),
         }
     }
+
+    fn dummy() -> Self {
+        Self { start: 0, end: 0 }
+    }
 }
 
 #[derive(Clone, Copy)]
@@ -49,6 +53,10 @@ impl<T> Spanned<T> {
     pub fn new(span: Span, value: T) -> Self {
         Self { span, value }
     }
+
+    pub fn dummy(value: T) -> Self {
+        Self::new(Span::dummy(), value)
+    }
 }
 
 // I don't know how one would write this. It works as a polymorphic standalone

From ff642cc8c8dfc49ad6ab2fdd9812452c5637b872 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sat, 8 Jan 2022 01:01:49 +0100
Subject: [PATCH 35/80] Specify --date via CliDate

---
 src/cli.rs | 22 ++++++++++------------
 1 file changed, 10 insertions(+), 12 deletions(-)

diff --git a/src/cli.rs b/src/cli.rs
index 4bb98ac..15d5290 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -28,8 +28,8 @@ pub struct Opt {
     #[structopt(short, long, parse(from_os_str))]
     file: Option<PathBuf>,
     /// Overwrite the current date
-    #[structopt(short, long)]
-    date: Option<NaiveDate>,
+    #[structopt(short, long, default_value = "t")]
+    date: String,
     /// Range of days to focus on
     #[structopt(short, long, default_value = "t-2d--t+13d")]
     range: String,
@@ -79,15 +79,6 @@ fn load_files(opt: &Opt, files: &mut Files) -> result::Result<(), files::Error>
     files.load(&file)
 }
 
-fn find_now(opt: &Opt, files: &Files) -> NaiveDateTime {
-    let now = files.now().naive_local();
-    if let Some(date) = opt.date {
-        date.and_time(now.time())
-    } else {
-        now
-    }
-}
-
 fn find_entries(files: &Files, range: DateRange) -> Result<Vec<Entry>, Error<FileSource>> {
     Ok(files.eval(EntryMode::Relevant, range)?)
 }
@@ -188,7 +179,14 @@ pub fn run() {
         process::exit(1);
     }
 
-    let now = find_now(&opt, &files);
+    let now = files.now().naive_local();
+    let today = match parse_eval_arg("--date", &opt.date, |date: CliDate| {
+        date.eval((), now.date())
+    }) {
+        Some(date) => date,
+        None => process::exit(1),
+    };
+    let now = today.and_time(now.time());
 
     let range = match parse_eval_arg("--range", &opt.range, |range: CliRange| {
         range.eval((), now.date())

From 26c9c1faf1141ea2360542a8ffd8e64609adf92f Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sat, 8 Jan 2022 01:02:03 +0100
Subject: [PATCH 36/80] Add one-letter command aliases

---
 src/cli.rs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/cli.rs b/src/cli.rs
index 15d5290..7a42c93 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -39,28 +39,31 @@ pub struct Opt {
 
 #[derive(Debug, StructOpt)]
 pub enum Command {
-    #[allow(rustdoc::broken_intra_doc_links)]
     /// Shows individual entries in detail
+    #[structopt(alias = "s")]
     Show {
         /// Entries and days to show
         #[structopt(required = true)]
         identifiers: Vec<String>,
     },
     /// Marks one or more entries as done
+    #[structopt(alias = "d")]
     Done {
         /// Entries to mark as done
         #[structopt(required = true)]
         entries: Vec<usize>,
     },
     /// Marks one or more entries as canceled
+    #[structopt(alias = "c")]
     Cancel {
         /// Entries to mark as done
         #[structopt(required = true)]
         entries: Vec<usize>,
     },
     /// Edits or creates a log entry
+    #[structopt(alias = "l")]
     Log {
-        #[structopt(default_value = "today")]
+        #[structopt(default_value = "t")]
         date: String,
     },
     /// Reformats all loaded files

From efc97800b2622e9ba5f69e48d8f1595caba0ca7d Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sat, 8 Jan 2022 04:11:55 +0100
Subject: [PATCH 37/80] Remove empty logs

---
 src/files.rs        | 28 ++++++++++++++++++++++------
 src/files/format.rs | 27 +++++++++++++++++++--------
 2 files changed, 41 insertions(+), 14 deletions(-)

diff --git a/src/files.rs b/src/files.rs
index 007ad63..98b0f94 100644
--- a/src/files.rs
+++ b/src/files.rs
@@ -28,6 +28,11 @@ struct LoadedFile {
     file: File,
     /// Whether this file has been changed.
     dirty: bool,
+    /// Commands that have been removed and are to be skipped during formatting.
+    ///
+    /// They are not directly removed from the list of commands in order not to
+    /// change other commands' indices.
+    removed: HashSet<usize>,
 }
 
 impl LoadedFile {
@@ -37,6 +42,7 @@ impl LoadedFile {
             cs_id,
             file,
             dirty: false,
+            removed: HashSet::new(),
         }
     }
 }
@@ -292,7 +298,7 @@ impl Files {
 
     fn save_file(file: &LoadedFile) -> Result<()> {
         // TODO Sort commands within file
-        let formatted = format!("{}", file.file);
+        let formatted = file.file.format(&file.removed);
         if file.file.contents == formatted {
             println!("Unchanged file {:?}", file.name);
         } else {
@@ -382,6 +388,12 @@ impl Files {
         file.dirty = true;
     }
 
+    fn remove(&mut self, source: Source) {
+        let file = &mut self.files[source.file];
+        file.removed.insert(source.command);
+        file.dirty = true;
+    }
+
     /// Add a [`Done`] statement to the task identified by `source`.
     ///
     /// Returns whether the addition was successful. It can fail if the entry
@@ -399,11 +411,15 @@ impl Files {
 
     pub fn set_log(&mut self, date: NaiveDate, desc: Vec<String>) {
         if let Some(source) = self.logs.get(&date).cloned() {
-            self.modify(source, |command| match command {
-                Command::Log(log) => log.desc = desc,
-                _ => unreachable!(),
-            });
-        } else {
+            if desc.is_empty() {
+                self.remove(source);
+            } else {
+                self.modify(source, |command| match command {
+                    Command::Log(log) => log.desc = desc,
+                    _ => unreachable!(),
+                });
+            }
+        } else if !desc.is_empty() {
             let file = self
                 .latest_log_before(date)
                 .or_else(|| self.latest_log())
diff --git a/src/files/format.rs b/src/files/format.rs
index 4274a2a..ddc37fc 100644
--- a/src/files/format.rs
+++ b/src/files/format.rs
@@ -1,3 +1,4 @@
+use std::collections::HashSet;
 use std::fmt;
 
 use chrono::Datelike;
@@ -317,21 +318,31 @@ impl fmt::Display for Log {
     }
 }
 
-impl fmt::Display for File {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        for i in 0..self.commands.len() {
-            let curr = &self.commands[i];
-            let next = self.commands.get(i + 1);
+impl File {
+    pub fn format(&self, removed: &HashSet<usize>) -> String {
+        let mut result = String::new();
 
-            write!(f, "{}", curr)?;
+        let commands = self
+            .commands
+            .iter()
+            .enumerate()
+            .filter(|(i, _)| !removed.contains(i))
+            .map(|(_, c)| c)
+            .collect::<Vec<_>>();
+
+        for i in 0..commands.len() {
+            let curr = commands[i];
+            let next = commands.get(i + 1).copied();
+
+            result.push_str(&format!("{}", curr));
 
             match (curr, next) {
                 (Command::Include(_), Some(Command::Include(_))) => {}
                 (_, None) => {}
-                _ => writeln!(f)?,
+                _ => result.push('\n'),
             }
         }
 
-        Ok(())
+        result
     }
 }

From 1721f8c456459c4b18a4d1e4bb9e8e417c2edecf Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sat, 8 Jan 2022 04:12:02 +0100
Subject: [PATCH 38/80] Ignore clippy warning

---
 src/cli/print.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/cli/print.rs b/src/cli/print.rs
index c644577..3243e37 100644
--- a/src/cli/print.rs
+++ b/src/cli/print.rs
@@ -96,6 +96,7 @@ impl ShowLines {
         ));
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn display_line_entry(
         &mut self,
         number: Option<usize>,

From e0b6c839e2d18e94ee5e6922dc23639387a10db8 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sat, 8 Jan 2022 04:15:22 +0100
Subject: [PATCH 39/80] Fix doc comment

---
 src/files.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/files.rs b/src/files.rs
index 98b0f94..e1d437a 100644
--- a/src/files.rs
+++ b/src/files.rs
@@ -143,8 +143,8 @@ impl Files {
     /// - This function must be called before all other functions.
     /// - This function must only be called once.
     /// - If this function fails,
-    ///   - it is safe to print the error with [`Files::eprint_diagnostic`] and
-    ///   - no other function must be called.
+    ///   - it is safe to print the error using the [`codespan_reporting::files::Files`] instance and
+    ///   - no other functions may be called.
     pub fn load(&mut self, path: &Path) -> Result<()> {
         if !self.files.is_empty() {
             panic!("Files::load called multiple times");

From b430f1594fc8ef832a8a30b49523eedcc9bbe6af Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sun, 9 Jan 2022 15:05:50 +0100
Subject: [PATCH 40/80] Add spans to all commands

---
 src/cli/show.rs       |  4 ++--
 src/eval.rs           |  2 +-
 src/files.rs          | 24 ++++++++++++------------
 src/files/commands.rs |  2 +-
 src/files/format.rs   |  4 ++--
 src/files/parse.rs    |  8 +++++---
 6 files changed, 23 insertions(+), 21 deletions(-)

diff --git a/src/cli/show.rs b/src/cli/show.rs
index 07c648c..b0c399a 100644
--- a/src/cli/show.rs
+++ b/src/cli/show.rs
@@ -37,7 +37,7 @@ fn show_entry(files: &Files, entry: &Entry) {
     }
 
     println!("FROM COMMAND");
-    show_command(command.value);
+    show_command(&command.value.value);
 }
 
 fn show_log(files: &Files, log: Sourced<'_, Log>) {
@@ -46,7 +46,7 @@ fn show_log(files: &Files, log: Sourced<'_, Log>) {
     println!("LOG {}", log.value.date);
 
     println!("FROM COMMAND");
-    show_command(command.value);
+    show_command(&command.value.value);
 }
 
 fn show_ident(files: &Files, entries: &[Entry], layout: &LineLayout, ident: Ident) {
diff --git a/src/eval.rs b/src/eval.rs
index b0ca8cf..bd02859 100644
--- a/src/eval.rs
+++ b/src/eval.rs
@@ -24,7 +24,7 @@ impl Files {
         let mut entries = Entries::new(mode, range);
         for command in self.commands() {
             let source = command.source;
-            if let Some(command) = EvalCommand::new(command.value) {
+            if let Some(command) = EvalCommand::new(&command.value.value) {
                 for entry in CommandState::new(command, source, range).eval()?.entries() {
                     entries.add(entry);
                 }
diff --git a/src/files.rs b/src/files.rs
index e1d437a..a62c396 100644
--- a/src/files.rs
+++ b/src/files.rs
@@ -198,7 +198,7 @@ impl Files {
         let includes = file
             .commands
             .iter()
-            .filter_map(|c| match c {
+            .filter_map(|c| match &c.value {
                 Command::Include(path) => Some(path.clone()),
                 _ => None,
             })
@@ -224,7 +224,7 @@ impl Files {
         let mut found: Option<(Source, Spanned<String>)> = None;
 
         for command in self.commands() {
-            if let Command::Timezone(tz) = command.value {
+            if let Command::Timezone(tz) = &command.value.value {
                 if let Some((found_source, found_tz)) = &found {
                     if tz.value != found_tz.value {
                         return Err(Error::TzConflict {
@@ -259,14 +259,14 @@ impl Files {
 
     fn collect_logs(&mut self) -> Result<()> {
         for command in Self::commands_of_files(&self.files) {
-            if let Command::Log(log) = command.value {
+            if let Command::Log(log) = &command.value.value {
                 match self.logs.entry(log.date.value) {
                     Entry::Vacant(e) => {
                         e.insert(command.source);
                     }
                     Entry::Occupied(e) => {
                         let other_cmd = Self::command_of_files(&self.files, *e.get());
-                        let other_span = match &other_cmd.value {
+                        let other_span = match &other_cmd.value.value {
                             Command::Log(log) => log.date.span,
                             _ => unreachable!(),
                         };
@@ -313,7 +313,7 @@ impl Files {
 
     /* Querying */
 
-    fn commands_of_files(files: &[LoadedFile]) -> Vec<Sourced<'_, Command>> {
+    fn commands_of_files(files: &[LoadedFile]) -> Vec<Sourced<'_, Spanned<Command>>> {
         let mut result = vec![];
         for (file_index, file) in files.iter().enumerate() {
             for (command_index, command) in file.file.commands.iter().enumerate() {
@@ -324,22 +324,22 @@ impl Files {
         result
     }
 
-    pub fn commands(&self) -> Vec<Sourced<'_, Command>> {
+    pub fn commands(&self) -> Vec<Sourced<'_, Spanned<Command>>> {
         Self::commands_of_files(&self.files)
     }
 
-    fn command_of_files(files: &[LoadedFile], source: Source) -> Sourced<'_, Command> {
+    fn command_of_files(files: &[LoadedFile], source: Source) -> Sourced<'_, Spanned<Command>> {
         let command = &files[source.file].file.commands[source.command];
         Sourced::new(source, command)
     }
 
-    pub fn command(&self, source: Source) -> Sourced<'_, Command> {
+    pub fn command(&self, source: Source) -> Sourced<'_, Spanned<Command>> {
         Self::command_of_files(&self.files, source)
     }
 
     pub fn log(&self, date: NaiveDate) -> Option<Sourced<'_, Log>> {
         let source = *self.logs.get(&date)?;
-        match self.command(source).value {
+        match &self.command(source).value.value {
             Command::Log(log) => Some(Sourced::new(source, log)),
             _ => unreachable!(),
         }
@@ -378,13 +378,13 @@ impl Files {
 
     fn modify(&mut self, source: Source, edit: impl FnOnce(&mut Command)) {
         let file = &mut self.files[source.file];
-        edit(&mut file.file.commands[source.command]);
+        edit(&mut file.file.commands[source.command].value);
         file.dirty = true;
     }
 
     fn insert(&mut self, file: FileSource, command: Command) {
         let file = &mut self.files[file.0];
-        file.file.commands.push(command);
+        file.file.commands.push(Spanned::dummy(command));
         file.dirty = true;
     }
 
@@ -401,7 +401,7 @@ impl Files {
     #[must_use]
     pub fn add_done(&mut self, source: Source, done: Done) -> bool {
         let file = &mut self.files[source.file];
-        match &mut file.file.commands[source.command] {
+        match &mut file.file.commands[source.command].value {
             Command::Task(t) => t.done.push(done),
             _ => return false,
         }
diff --git a/src/files/commands.rs b/src/files/commands.rs
index 82c6b51..09eb631 100644
--- a/src/files/commands.rs
+++ b/src/files/commands.rs
@@ -355,7 +355,7 @@ pub enum Command {
 #[derive(Debug)]
 pub struct File {
     pub contents: String,
-    pub commands: Vec<Command>,
+    pub commands: Vec<Spanned<Command>>,
 }
 
 impl File {
diff --git a/src/files/format.rs b/src/files/format.rs
index ddc37fc..b289048 100644
--- a/src/files/format.rs
+++ b/src/files/format.rs
@@ -331,8 +331,8 @@ impl File {
             .collect::<Vec<_>>();
 
         for i in 0..commands.len() {
-            let curr = commands[i];
-            let next = commands.get(i + 1).copied();
+            let curr = &commands[i].value;
+            let next = commands.get(i + 1).map(|c| &c.value);
 
             result.push_str(&format!("{}", curr));
 
diff --git a/src/files/parse.rs b/src/files/parse.rs
index 67c0da9..8637fb0 100644
--- a/src/files/parse.rs
+++ b/src/files/parse.rs
@@ -818,18 +818,20 @@ fn parse_log(p: Pair<'_, Rule>) -> Result<Log> {
     Ok(Log { date, desc })
 }
 
-fn parse_command(p: Pair<'_, Rule>) -> Result<Command> {
+fn parse_command(p: Pair<'_, Rule>) -> Result<Spanned<Command>> {
     assert_eq!(p.as_rule(), Rule::command);
 
     let p = p.into_inner().next().unwrap();
-    Ok(match p.as_rule() {
+    let span = (&p.as_span()).into();
+    let command = match p.as_rule() {
         Rule::include => Command::Include(parse_include(p)),
         Rule::timezone => Command::Timezone(parse_timezone(p)),
         Rule::task => Command::Task(parse_task(p)?),
         Rule::note => Command::Note(parse_note(p)?),
         Rule::log => Command::Log(parse_log(p)?),
         _ => unreachable!(),
-    })
+    };
+    Ok(Spanned::new(span, command))
 }
 
 pub fn parse_file(p: Pair<'_, Rule>, contents: String) -> Result<File> {

From 26479ac58d91c608783368968c446b8d65ad4065 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sun, 9 Jan 2022 16:04:34 +0100
Subject: [PATCH 41/80] Improve format of show command

---
 src/cli.rs             |  1 +
 src/cli/layout/line.rs |  2 +-
 src/cli/print.rs       | 13 ++------
 src/cli/show.rs        | 73 ++++++++++++++++++++++++++++--------------
 src/cli/util.rs        | 13 ++++++++
 5 files changed, 66 insertions(+), 36 deletions(-)
 create mode 100644 src/cli/util.rs

diff --git a/src/cli.rs b/src/cli.rs
index 7a42c93..5b093e2 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -21,6 +21,7 @@ mod layout;
 mod log;
 mod print;
 mod show;
+mod util;
 
 #[derive(Debug, StructOpt)]
 pub struct Opt {
diff --git a/src/cli/layout/line.rs b/src/cli/layout/line.rs
index 1236f8e..0d1c360 100644
--- a/src/cli/layout/line.rs
+++ b/src/cli/layout/line.rs
@@ -215,7 +215,7 @@ impl LineLayout {
         }
     }
 
-    fn entry_kind(entry: &Entry) -> LineKind {
+    pub fn entry_kind(entry: &Entry) -> LineKind {
         match entry.kind {
             EntryKind::Task => LineKind::Task,
             EntryKind::TaskDone(_) => LineKind::Done,
diff --git a/src/cli/print.rs b/src/cli/print.rs
index 3243e37..1cdfe4d 100644
--- a/src/cli/print.rs
+++ b/src/cli/print.rs
@@ -6,6 +6,7 @@ use colored::{ColoredString, Colorize};
 use crate::files::primitives::{Time, Weekday};
 
 use super::layout::line::{LineEntry, LineKind, LineLayout, SpanSegment, SpanStyle, Times};
+use super::util;
 
 struct ShowLines {
     num_width: usize,
@@ -116,7 +117,7 @@ impl ShowLines {
             "{:>nw$} {} {}{} {}{}{}\n",
             num.bright_black(),
             self.display_spans(spans, " ".into()),
-            Self::display_kind(kind),
+            util::display_kind(kind),
             Self::display_time(time),
             text,
             Self::display_marker(has_desc, ""),
@@ -152,16 +153,6 @@ impl ShowLines {
         }
     }
 
-    fn display_kind(kind: LineKind) -> ColoredString {
-        match kind {
-            LineKind::Task => "T".magenta().bold(),
-            LineKind::Done => "D".green().bold(),
-            LineKind::Canceled => "C".red().bold(),
-            LineKind::Note => "N".blue().bold(),
-            LineKind::Birthday => "B".yellow().bold(),
-        }
-    }
-
     fn display_marker(marker: bool, otherwise: &str) -> ColoredString {
         if marker {
             "*".bright_yellow()
diff --git a/src/cli/show.rs b/src/cli/show.rs
index b0c399a..3eefd9c 100644
--- a/src/cli/show.rs
+++ b/src/cli/show.rs
@@ -1,52 +1,75 @@
 use chrono::NaiveDate;
+use codespan_reporting::files::Files as CsFiles;
+use colored::Colorize;
 
 use crate::eval::{Entry, EntryKind};
 use crate::files::commands::{Command, Log};
+use crate::files::primitives::Spanned;
 use crate::files::{Files, Sourced};
 
 use super::error::Error;
 use super::layout::line::LineLayout;
+use super::util;
 
-fn show_command(command: &Command) {
-    for line in format!("{}", command).lines() {
-        println!("| {}", line);
+fn fmt_where(files: &Files, command: &Sourced<'_, Spanned<Command>>) -> String {
+    let name = files.name(command.source.file()).expect("file exists");
+    let line = files
+        .line_number(command.source.file(), command.value.span.start)
+        .expect("file exists and line is valid");
+    format!("Line {} in {}", line, name)
+}
+
+fn print_desc(command: &Sourced<'_, Spanned<Command>>) {
+    let desc: &[String] = match &command.value.value {
+        Command::Task(task) => &task.desc,
+        Command::Note(note) => &note.desc,
+        Command::Log(log) => &log.desc,
+        _ => &[],
+    };
+    if !desc.is_empty() {
+        println!();
+        for line in desc {
+            println!("{}", line);
+        }
     }
 }
 
 fn show_entry(files: &Files, entry: &Entry) {
     let command = files.command(entry.source);
 
-    let kind = match entry.kind {
-        EntryKind::Task | EntryKind::TaskDone(_) | EntryKind::TaskCanceled(_) => "TASK",
-        EntryKind::Note => "NOTE",
-        EntryKind::Birthday(_) => "BIRTHDAY",
+    let kind = util::display_kind(LineLayout::entry_kind(entry));
+    println!("{} {} {}", "Title:".bright_black(), kind, entry.title);
+
+    let what = match entry.kind {
+        EntryKind::Task => "Task".to_string(),
+        EntryKind::TaskDone(date) => format!("Task, done {}", date),
+        EntryKind::TaskCanceled(date) => format!("Task, canceled {}", date),
+        EntryKind::Note => "Note".to_string(),
+        EntryKind::Birthday(None) => "Birthday, age unknown".to_string(),
+        EntryKind::Birthday(Some(age)) => format!("Birthday, age {}", age),
     };
-    println!("{} {}", kind, entry.title);
+    println!("{}  {}", "What:".bright_black(), what);
 
-    if let Some(dates) = entry.dates {
-        println!("DATE {}", dates.sorted());
-    } else {
-        println!("NO DATE");
-    }
+    let when = match entry.dates {
+        None => "no date".to_string(),
+        Some(date) => format!("{}", date.sorted()),
+    };
+    println!("{}  {}", "When:".bright_black(), when);
 
-    match entry.kind {
-        EntryKind::TaskDone(when) => println!("DONE {}", when),
-        EntryKind::TaskCanceled(when) => println!("CANCELED {}", when),
-        EntryKind::Birthday(Some(age)) => println!("AGE {}", age),
-        _ => {}
-    }
+    println!("{} {}", "Where:".bright_black(), fmt_where(files, &command));
 
-    println!("FROM COMMAND");
-    show_command(&command.value.value);
+    print_desc(&command);
 }
 
 fn show_log(files: &Files, log: Sourced<'_, Log>) {
     let command = files.command(log.source);
 
-    println!("LOG {}", log.value.date);
+    println!("{}  Log entry", "What:".bright_black());
+    println!("{}  {}", "When:".bright_black(), log.value.date);
 
-    println!("FROM COMMAND");
-    show_command(&command.value.value);
+    println!("{} {}", "Where:".bright_black(), fmt_where(files, &command));
+
+    print_desc(&command);
 }
 
 fn show_ident(files: &Files, entries: &[Entry], layout: &LineLayout, ident: Ident) {
@@ -76,6 +99,8 @@ pub fn show(files: &Files, entries: &[Entry], layout: &LineLayout, idents: &[Ide
 
     show_ident(files, entries, layout, idents[0]);
     for &ident in idents.iter().skip(1) {
+        println!();
+        println!();
         println!();
         show_ident(files, entries, layout, ident);
     }
diff --git a/src/cli/util.rs b/src/cli/util.rs
new file mode 100644
index 0000000..bad291a
--- /dev/null
+++ b/src/cli/util.rs
@@ -0,0 +1,13 @@
+use colored::{ColoredString, Colorize};
+
+use super::layout::line::LineKind;
+
+pub fn display_kind(kind: LineKind) -> ColoredString {
+    match kind {
+        LineKind::Task => "T".magenta().bold(),
+        LineKind::Done => "D".green().bold(),
+        LineKind::Canceled => "C".red().bold(),
+        LineKind::Note => "N".blue().bold(),
+        LineKind::Birthday => "B".yellow().bold(),
+    }
+}

From d7a26128a0f1dc219134484917ba0cbbca3c6c17 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sun, 9 Jan 2022 16:04:42 +0100
Subject: [PATCH 42/80] Fix show command argument parsing

---
 src/files/grammar.pest | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/files/grammar.pest b/src/files/grammar.pest
index dba2273..cb7d4e6 100644
--- a/src/files/grammar.pest
+++ b/src/files/grammar.pest
@@ -151,7 +151,7 @@ file = ${ SOI ~ (empty_line* ~ command)* ~ empty_line* ~ WHITESPACE* ~ EOI }
 today = { "today" | "t" }
 cli_datum = { datum | today }
 cli_date = { cli_datum ~ delta? }
-cli_ident = { SOI ~ (number | cli_date) ~ EOI }
+cli_ident = { SOI ~ (cli_date | number) ~ EOI }
 cli_range_start = { cli_datum ~ delta? }
 cli_range_end = { cli_datum ~ delta? | delta }
 cli_range = { SOI ~ cli_range_start ~ ("--" ~ cli_range_end)? ~ EOI }

From 20fc4bd3cc11e0d1ab07d17d2af2ff029ab65ebe Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sun, 9 Jan 2022 16:35:47 +0100
Subject: [PATCH 43/80] Update changelog

---
 CHANGELOG.md | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 42727fa..9e22c23 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,11 +5,33 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 ## Unreleased
 
 ### Added
-- `REMIND` statement
+- `LOG` command
+- `REMIND` and `CANCEL` statements
 - `MOVE` entries to a different time
+- `today log` CLI command
+- One-letter aliases for
+    - `today show`: `today s`
+    - `today log`: `today l`
+    - `today done`: `today d`
+    - `today cancel`: `today c`
+- `--date` now accepts expressions like `today-3d`
+- In `--range` and `--date`, `t` can be used as abbreviation for `today`
+- `*` markers in output for days with logs and entries with descriptions
 
 ### Changed
 - Output is now colored
+- Better error messages
+- Overhauled `today show` format
+    - It can now show log entries for days
+    - It now displays the source command (file and line) of the entry
+- When saving...
+    - Unchanged files are no longer overwritten
+    - Commands are no longer reordered
+- Always prints import-based path, not absolute path
+
+### Fixed
+- Alignment in output
+- Respect `TZDIR` environment variable
 
 ## 0.1.0 - 2021-12-20
 

From 170e291ec5a88044521c27e30a8c09ee2475f4e5 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sun, 9 Jan 2022 16:40:17 +0100
Subject: [PATCH 44/80] Simplify DoneDate when formatting

---
 CHANGELOG.md          |  1 +
 src/eval/date.rs      | 36 ++++++++++--------------------------
 src/files/commands.rs | 27 +++++++++++++++++++++++++++
 src/files/format.rs   |  3 +--
 4 files changed, 39 insertions(+), 28 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9e22c23..6d89c0e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -27,6 +27,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - When saving...
     - Unchanged files are no longer overwritten
     - Commands are no longer reordered
+    - Done and cancel dates are simplified
 - Always prints import-based path, not absolute path
 
 ### Fixed
diff --git a/src/eval/date.rs b/src/eval/date.rs
index da8ce25..54eb2e1 100644
--- a/src/eval/date.rs
+++ b/src/eval/date.rs
@@ -149,32 +149,16 @@ impl From<DoneDate> for Dates {
 
 impl From<Dates> for DoneDate {
     fn from(dates: Dates) -> Self {
-        if dates.root == dates.other {
-            match dates.times {
-                Some(times) if times.root == times.other => Self::DateTime {
-                    root: dates.root,
-                    root_time: times.root,
-                },
-                Some(times) => Self::DateTimeToTime {
-                    root: dates.root,
-                    root_time: times.root,
-                    other_time: times.other,
-                },
-                None => Self::Date { root: dates.root },
-            }
-        } else {
-            match dates.times {
-                Some(times) => Self::DateTimeToDateTime {
-                    root: dates.root,
-                    root_time: times.root,
-                    other: dates.other,
-                    other_time: times.other,
-                },
-                None => Self::DateToDate {
-                    root: dates.root,
-                    other: dates.other,
-                },
-            }
+        let (root, other) = dates.dates();
+        match dates.times() {
+            Some((root_time, other_time)) => Self::DateTimeToDateTime {
+                root,
+                root_time,
+                other,
+                other_time,
+            },
+            None => Self::DateToDate { root, other },
         }
+        .simplified()
     }
 }
diff --git a/src/files/commands.rs b/src/files/commands.rs
index 09eb631..f8f6f4f 100644
--- a/src/files/commands.rs
+++ b/src/files/commands.rs
@@ -307,6 +307,33 @@ impl DoneDate {
             DoneDate::DateTimeToDateTime { root, .. } => root,
         }
     }
+
+    /// Remove redundancies like the same date or time specified twice.
+    pub fn simplified(self) -> Self {
+        let result = match self {
+            Self::DateToDate { root, other } if root == other => Self::Date { root },
+            Self::DateTimeToDateTime {
+                root,
+                root_time,
+                other,
+                other_time,
+            } if root == other => Self::DateTimeToTime {
+                root,
+                root_time,
+                other_time,
+            },
+            other => other,
+        };
+
+        match result {
+            Self::DateTimeToTime {
+                root,
+                root_time,
+                other_time,
+            } if root_time == other_time => Self::DateTime { root, root_time },
+            other => other,
+        }
+    }
 }
 
 #[derive(Debug)]
diff --git a/src/files/format.rs b/src/files/format.rs
index b289048..368f60f 100644
--- a/src/files/format.rs
+++ b/src/files/format.rs
@@ -239,8 +239,7 @@ impl fmt::Display for Statement {
 
 impl fmt::Display for DoneDate {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // TODO Remove redundant dates
-        match self {
+        match self.simplified() {
             DoneDate::Date { root } => write!(f, "{}", root),
             DoneDate::DateTime { root, root_time } => write!(f, "{} {}", root, root_time),
             DoneDate::DateToDate { root, other } => write!(f, "{} -- {}", root, other),

From 721718eee4eec0d52b9dbf68db8fea8fdba25a0c Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sun, 9 Jan 2022 16:49:10 +0100
Subject: [PATCH 45/80] Fix line numbers in show command

---
 src/cli/show.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cli/show.rs b/src/cli/show.rs
index 3eefd9c..4ed8470 100644
--- a/src/cli/show.rs
+++ b/src/cli/show.rs
@@ -14,9 +14,9 @@ use super::util;
 fn fmt_where(files: &Files, command: &Sourced<'_, Spanned<Command>>) -> String {
     let name = files.name(command.source.file()).expect("file exists");
     let line = files
-        .line_number(command.source.file(), command.value.span.start)
+        .line_index(command.source.file(), command.value.span.start)
         .expect("file exists and line is valid");
-    format!("Line {} in {}", line, name)
+    format!("Line {} in {}", line + 1, name)
 }
 
 fn print_desc(command: &Sourced<'_, Spanned<Command>>) {

From d169037b7a56d1b13da1a2da40f2a80ea680ae9f Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sun, 9 Jan 2022 20:12:06 +0100
Subject: [PATCH 46/80] Don't store file content string in File

---
 src/files.rs          | 15 ++++++++++++---
 src/files/commands.rs |  6 +-----
 src/files/parse.rs    |  6 +++---
 3 files changed, 16 insertions(+), 11 deletions(-)

diff --git a/src/files.rs b/src/files.rs
index a62c396..0edc0ca 100644
--- a/src/files.rs
+++ b/src/files.rs
@@ -290,16 +290,24 @@ impl Files {
     pub fn save(&self) -> Result<()> {
         for file in &self.files {
             if file.dirty {
-                Self::save_file(file)?;
+                self.save_file(file)?;
             }
         }
         Ok(())
     }
 
-    fn save_file(file: &LoadedFile) -> Result<()> {
+    fn save_file(&self, file: &LoadedFile) -> Result<()> {
         // TODO Sort commands within file
+
+        let previous = self
+            .cs_files
+            .get(file.cs_id)
+            .expect("cs id is valid")
+            .source();
+
         let formatted = file.file.format(&file.removed);
-        if file.file.contents == formatted {
+
+        if previous == &formatted {
             println!("Unchanged file {:?}", file.name);
         } else {
             println!("Saving file {:?}", file.name);
@@ -308,6 +316,7 @@ impl Files {
                 error: e,
             })?;
         }
+
         Ok(())
     }
 
diff --git a/src/files/commands.rs b/src/files/commands.rs
index f8f6f4f..1b0ee1a 100644
--- a/src/files/commands.rs
+++ b/src/files/commands.rs
@@ -381,7 +381,6 @@ pub enum Command {
 
 #[derive(Debug)]
 pub struct File {
-    pub contents: String,
     pub commands: Vec<Spanned<Command>>,
 }
 
@@ -389,9 +388,6 @@ impl File {
     /// Create an empty dummy file. This file should only be used as a
     /// placeholder value.
     pub fn dummy() -> Self {
-        Self {
-            contents: String::new(),
-            commands: vec![],
-        }
+        Self { commands: vec![] }
     }
 }
diff --git a/src/files/parse.rs b/src/files/parse.rs
index 8637fb0..629ffea 100644
--- a/src/files/parse.rs
+++ b/src/files/parse.rs
@@ -834,7 +834,7 @@ fn parse_command(p: Pair<'_, Rule>) -> Result<Spanned<Command>> {
     Ok(Spanned::new(span, command))
 }
 
-pub fn parse_file(p: Pair<'_, Rule>, contents: String) -> Result<File> {
+pub fn parse_file(p: Pair<'_, Rule>) -> Result<File> {
     assert_eq!(p.as_rule(), Rule::file);
 
     let mut commands = vec![];
@@ -847,7 +847,7 @@ pub fn parse_file(p: Pair<'_, Rule>, contents: String) -> Result<File> {
         commands.push(parse_command(p)?);
     }
 
-    Ok(File { contents, commands })
+    Ok(File { commands })
 }
 
 pub fn parse(path: &Path, input: &str) -> Result<File> {
@@ -857,5 +857,5 @@ pub fn parse(path: &Path, input: &str) -> Result<File> {
     let file_pair = pairs.next().unwrap();
     assert_eq!(pairs.next(), None);
 
-    parse_file(file_pair, input.to_string()).map_err(|e| e.with_path(&pathstr))
+    parse_file(file_pair).map_err(|e| e.with_path(&pathstr))
 }

From 039b7b73ee92d3b8a73c0a538c2c09520ed33bed Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sun, 9 Jan 2022 20:24:53 +0100
Subject: [PATCH 47/80] Reorder commands inside a file again

---
 CHANGELOG.md        |  4 ++--
 src/files/format.rs | 44 ++++++++++++++++++++++++++++++++++++++++----
 2 files changed, 42 insertions(+), 6 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6d89c0e..d2d0971 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -26,8 +26,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
     - It now displays the source command (file and line) of the entry
 - When saving...
     - Unchanged files are no longer overwritten
-    - Commands are no longer reordered
-    - Done and cancel dates are simplified
+    - Imports are now sorted alphabetically
+    - Done and cancel dates are now simplified where possible
 - Always prints import-based path, not absolute path
 
 ### Fixed
diff --git a/src/files/format.rs b/src/files/format.rs
index 368f60f..6fb79b2 100644
--- a/src/files/format.rs
+++ b/src/files/format.rs
@@ -318,20 +318,56 @@ impl fmt::Display for Log {
 }
 
 impl File {
+    fn sort(commands: &mut Vec<&Command>) {
+        // Order of commands in a file:
+        // 1. Imports, sorted alphabetically
+        // 2. Time zone(s)
+        // 3. Log entries, sorted by date (ascending)
+        // 4. Tasks and notes, in original order
+
+        // There should always be at most one time zone, so we don't care about
+        // their order.
+
+        // In the individual steps we must use a stable sort so the order of 4.
+        // is not lost.
+
+        // Order imports alphabetically
+        commands.sort_by_key(|c| match c {
+            Command::Include(path) => Some(&path.value),
+            _ => None,
+        });
+
+        // Order log entries by date
+        commands.sort_by_key(|c| match c {
+            Command::Log(Log { date, .. }) => Some(date.value),
+            _ => None,
+        });
+
+        // Order by type
+        commands.sort_by_key(|c| match c {
+            Command::Include(_) => 0,
+            Command::Timezone(_) => 1,
+            Command::Log(_) => 2,
+            Command::Task(_) | Command::Note(_) => 3,
+        });
+    }
+
     pub fn format(&self, removed: &HashSet<usize>) -> String {
         let mut result = String::new();
 
-        let commands = self
+        let mut commands = self
             .commands
             .iter()
             .enumerate()
             .filter(|(i, _)| !removed.contains(i))
-            .map(|(_, c)| c)
+            .map(|(_, c)| &c.value)
             .collect::<Vec<_>>();
 
+        Self::sort(&mut commands);
+
         for i in 0..commands.len() {
-            let curr = &commands[i].value;
-            let next = commands.get(i + 1).map(|c| &c.value);
+            let curr = &commands[i];
+            let next = commands.get(i + 1);
 
             result.push_str(&format!("{}", curr));
 

From 0b4f614af6305f883354c08eb50dcaf1f1b1998b Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Fri, 14 Jan 2022 17:53:07 +0100
Subject: [PATCH 48/80] Specify default capture file

---
 CHANGELOG.md           |  2 +-
 src/files.rs           | 33 +++++++++++++++++++++++++++++++++
 src/files/commands.rs  |  2 ++
 src/files/error.rs     | 24 ++++++++++++++++++++++++
 src/files/format.rs    | 11 +++++++----
 src/files/grammar.pest |  3 ++-
 src/files/parse.rs     |  1 +
 7 files changed, 70 insertions(+), 6 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d2d0971..1de5b85 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,7 +5,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 ## Unreleased
 
 ### Added
-- `LOG` command
+- `LOG` and `CAPTURE` commands
 - `REMIND` and `CANCEL` statements
 - `MOVE` entries to a different time
 - `today log` CLI command
diff --git a/src/files.rs b/src/files.rs
index 0edc0ca..8d66b2c 100644
--- a/src/files.rs
+++ b/src/files.rs
@@ -85,6 +85,7 @@ pub struct Files {
     /// Codespan-reporting file database.
     cs_files: SimpleFiles<String, String>,
     timezone: Option<Tz>,
+    capture: Option<usize>,
     logs: HashMap<NaiveDate, Source>,
 }
 
@@ -132,6 +133,7 @@ impl Files {
             files: vec![],
             cs_files: SimpleFiles::new(),
             timezone: None,
+            capture: None,
             logs: HashMap::new(),
         }
     }
@@ -155,6 +157,7 @@ impl Files {
 
         self.load_file(&mut loaded, path)?;
         self.determine_timezone()?;
+        self.determine_capture()?;
         self.collect_logs()?;
 
         Ok(())
@@ -257,6 +260,32 @@ impl Files {
         Ok(())
     }
 
+    fn determine_capture(&mut self) -> Result<()> {
+        assert_eq!(self.capture, None);
+
+        let mut found: Option<Source> = None;
+
+        for command in self.commands() {
+            if let Command::Capture = &command.value.value {
+                if let Some(found) = &found {
+                    let found_cmd = self.command(*found);
+                    return Err(Error::MultipleCapture {
+                        file1: found.file(),
+                        span1: found_cmd.value.span,
+                        file2: command.source.file(),
+                        span2: command.value.span,
+                    });
+                } else {
+                    found = Some(command.source);
+                }
+            }
+        }
+
+        self.capture = found.map(|s| s.file);
+
+        Ok(())
+    }
+
     fn collect_logs(&mut self) -> Result<()> {
         for command in Self::commands_of_files(&self.files) {
             if let Command::Log(log) = &command.value.value {
@@ -369,6 +398,10 @@ impl Files {
             .max_by_key(|(d, _)| *d)
     }
 
+    pub fn capture(&self) -> Option<FileSource> {
+        self.capture.map(FileSource)
+    }
+
     pub fn now(&self) -> DateTime<&Tz> {
         if let Some(tz) = &self.timezone {
             Utc::now().with_timezone(&tz)
diff --git a/src/files/commands.rs b/src/files/commands.rs
index 1b0ee1a..a53aa50 100644
--- a/src/files/commands.rs
+++ b/src/files/commands.rs
@@ -271,6 +271,7 @@ pub enum Statement {
     Remind(Option<Spanned<Delta>>),
 }
 
+#[allow(clippy::enum_variant_names)]
 #[derive(Debug, Clone, Copy)]
 pub enum DoneDate {
     Date {
@@ -374,6 +375,7 @@ pub struct Log {
 pub enum Command {
     Include(Spanned<String>),
     Timezone(Spanned<String>),
+    Capture, // TODO Set capture file by template?
     Task(Task),
     Note(Note),
     Log(Log),
diff --git a/src/files/error.rs b/src/files/error.rs
index 3133221..983160d 100644
--- a/src/files/error.rs
+++ b/src/files/error.rs
@@ -114,6 +114,13 @@ pub enum Error {
         span2: Span,
         tz2: String,
     },
+    #[error("Multiple capture commands")]
+    MultipleCapture {
+        file1: FileSource,
+        span1: Span,
+        file2: FileSource,
+        span2: Span,
+    },
     #[error("Duplicate logs for {date}")]
     LogConflict {
         file1: FileSource,
@@ -179,6 +186,23 @@ impl<'a> Eprint<'a, Files> for Error {
                     ]);
                 Self::eprint_diagnostic(files, config, &diagnostic);
             }
+            Error::MultipleCapture {
+                file1,
+                span1,
+                file2,
+                span2,
+            } => {
+                let diagnostic = Diagnostic::error()
+                    .with_message("Multiple capture commands")
+                    .with_labels(vec![
+                        Label::primary(*file1, span1),
+                        Label::primary(*file2, span2),
+                    ])
+                    .with_notes(vec![
+                        "There must be at most one CAPTURE command.".to_string()
+                    ]);
+                Self::eprint_diagnostic(files, config, &diagnostic);
+            }
             Error::LogConflict {
                 file1,
                 span1,
diff --git a/src/files/format.rs b/src/files/format.rs
index 6fb79b2..f9ad86a 100644
--- a/src/files/format.rs
+++ b/src/files/format.rs
@@ -302,6 +302,7 @@ impl fmt::Display for Command {
         match self {
             Command::Include(name) => writeln!(f, "INCLUDE {}", name),
             Command::Timezone(name) => writeln!(f, "TIMEZONE {}", name),
+            Command::Capture => writeln!(f, "CAPTURE"),
             Command::Task(task) => write!(f, "{}", task),
             Command::Note(note) => write!(f, "{}", note),
             Command::Log(log) => write!(f, "{}", log),
@@ -322,8 +323,9 @@ impl File {
         // Order of commands in a file:
         // 1. Imports, sorted alphabetically
         // 2. Time zone(s)
-        // 3. Log entries, sorted by date (ascending)
-        // 4. Tasks and notes, in original order
+        // 3. Captures
+        // 4. Log entries, sorted by date (ascending)
+        // 5. Tasks and notes, in original order
 
         // There should always be at most one time zone, so we don't care about
         // their order.
@@ -347,8 +349,9 @@ impl File {
         commands.sort_by_key(|c| match c {
             Command::Include(_) => 0,
             Command::Timezone(_) => 1,
-            Command::Log(_) => 2,
-            Command::Task(_) | Command::Note(_) => 3,
+            Command::Capture => 2,
+            Command::Log(_) => 3,
+            Command::Task(_) | Command::Note(_) => 4,
         });
     }
 
diff --git a/src/files/grammar.pest b/src/files/grammar.pest
index cb7d4e6..b83741e 100644
--- a/src/files/grammar.pest
+++ b/src/files/grammar.pest
@@ -5,6 +5,7 @@ rest_any = { (!eol ~ ANY)* }
 
 include = { "INCLUDE" ~ WHITESPACE ~ rest_some ~ eol }
 timezone = { "TIMEZONE" ~ WHITESPACE ~ rest_some ~ eol }
+capture = { "CAPTURE" ~ eol }
 
 number = @{ ASCII_DIGIT{1,9} } // Fits into an i32
 
@@ -144,7 +145,7 @@ log_head = !{ "LOG" ~ datum ~ eol }
 log = { log_head ~ description }
 
 empty_line = _{ WHITESPACE* ~ NEWLINE }
-command = { include | timezone | task | note | log }
+command = { include | timezone | capture | task | note | log }
 
 file = ${ SOI ~ (empty_line* ~ command)* ~ empty_line* ~ WHITESPACE* ~ EOI }
 
diff --git a/src/files/parse.rs b/src/files/parse.rs
index 629ffea..65200d4 100644
--- a/src/files/parse.rs
+++ b/src/files/parse.rs
@@ -826,6 +826,7 @@ fn parse_command(p: Pair<'_, Rule>) -> Result<Spanned<Command>> {
     let command = match p.as_rule() {
         Rule::include => Command::Include(parse_include(p)),
         Rule::timezone => Command::Timezone(parse_timezone(p)),
+        Rule::capture => Command::Capture,
         Rule::task => Command::Task(parse_task(p)?),
         Rule::note => Command::Note(parse_note(p)?),
         Rule::log => Command::Log(parse_log(p)?),

From 371c86f10f2b97f73be550af1f28fd9184d75de9 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Fri, 14 Jan 2022 17:59:17 +0100
Subject: [PATCH 49/80] Reword changelog slightly

---
 CHANGELOG.md | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1de5b85..fffc35e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,15 +5,16 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 ## Unreleased
 
 ### Added
-- `LOG` and `CAPTURE` commands
-- `REMIND` and `CANCEL` statements
-- `MOVE` entries to a different time
-- `today log` CLI command
+- `LOG` command and `today log` CLI command
+- `CAPTURE` command
+- `REMIND` statement
+- `CANCEL` statement for tasks
 - One-letter aliases for
     - `today show`: `today s`
     - `today log`: `today l`
     - `today done`: `today d`
     - `today cancel`: `today c`
+- `MOVE` can now move entries to a different time
 - `--date` now accepts expressions like `today-3d`
 - In `--range` and `--date`, `t` can be used as abbreviation for `today`
 - `*` markers in output for days with logs and entries with descriptions

From 82affe39a19492a7fa18b0c433ae1046a7c1066d Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Fri, 14 Jan 2022 21:26:18 +0100
Subject: [PATCH 50/80] Simplify error handling in cli module

---
 src/cli.rs             | 89 ++++++++++++++++++------------------------
 src/cli/cancel.rs      |  6 +--
 src/cli/done.rs        |  6 +--
 src/cli/error.rs       | 30 +++++++++++---
 src/cli/layout/line.rs |  2 +-
 src/cli/log.rs         |  2 +-
 src/cli/show.rs        |  4 +-
 7 files changed, 72 insertions(+), 67 deletions(-)

diff --git a/src/cli.rs b/src/cli.rs
index 5b093e2..0da37a3 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -9,9 +9,9 @@ use structopt::StructOpt;
 
 use crate::eval::{self, DateRange, Entry, EntryMode};
 use crate::files::arguments::{CliDate, CliIdent, CliRange};
-use crate::files::{self, FileSource, Files, ParseError};
+use crate::files::{self, Files, ParseError};
 
-use self::error::Error;
+use self::error::{Error, Result};
 use self::layout::line::LineLayout;
 
 mod cancel;
@@ -83,7 +83,7 @@ fn load_files(opt: &Opt, files: &mut Files) -> result::Result<(), files::Error>
     files.load(&file)
 }
 
-fn find_entries(files: &Files, range: DateRange) -> Result<Vec<Entry>, Error<FileSource>> {
+fn find_entries(files: &Files, range: DateRange) -> Result<Vec<Entry>> {
     Ok(files.eval(EntryMode::Relevant, range)?)
 }
 
@@ -96,45 +96,34 @@ fn find_layout(
     layout::layout(files, entries, range, now)
 }
 
-fn parse_eval_arg<T, R>(
-    name: &str,
-    text: &str,
-    eval: impl FnOnce(T) -> Result<R, eval::Error<()>>,
-) -> Option<R>
+fn parse_eval_arg<T, E, R>(name: &str, text: &str, eval: E) -> Result<R>
 where
     T: FromStr<Err = ParseError<()>>,
+    E: FnOnce(T) -> result::Result<R, eval::Error<()>>,
 {
-    match T::from_str(text) {
-        Ok(value) => match eval(value) {
-            Ok(result) => return Some(result),
-            Err(e) => crate::error::eprint_error(&SimpleFile::new(name, text), &e),
-        },
-        Err(e) => crate::error::eprint_error(&SimpleFile::new(name, text), &e),
-    }
-    None
+    let value = T::from_str(text).map_err(|error| Error::ArgumentParse {
+        file: SimpleFile::new(name.to_string(), text.to_string()),
+        error,
+    })?;
+    eval(value).map_err(|error| Error::ArgumentEval {
+        file: SimpleFile::new(name.to_string(), text.to_string()),
+        error,
+    })
 }
 
-fn parse_show_idents(identifiers: &[String], today: NaiveDate) -> Vec<show::Ident> {
+fn parse_show_idents(identifiers: &[String], today: NaiveDate) -> Result<Vec<show::Ident>> {
     let mut idents = vec![];
     for ident in identifiers {
-        let ident = match parse_eval_arg("identifier", ident, |ident: CliIdent| match ident {
+        let ident = parse_eval_arg("identifier", ident, |ident: CliIdent| match ident {
             CliIdent::Number(n) => Ok(show::Ident::Number(n)),
             CliIdent::Date(d) => Ok(show::Ident::Date(d.eval((), today)?)),
-        }) {
-            Some(ident) => ident,
-            None => process::exit(1),
-        };
+        })?;
         idents.push(ident);
     }
-    idents
+    Ok(idents)
 }
 
-fn run_command(
-    opt: &Opt,
-    files: &mut Files,
-    range: DateRange,
-    now: NaiveDateTime,
-) -> Result<(), Error<FileSource>> {
+fn run_command(opt: &Opt, files: &mut Files, range: DateRange, now: NaiveDateTime) -> Result<()> {
     match &opt.command {
         None => {
             let entries = find_entries(files, range)?;
@@ -144,7 +133,7 @@ fn run_command(
         Some(Command::Show { identifiers }) => {
             let entries = find_entries(files, range)?;
             let layout = find_layout(files, &entries, range, now);
-            let idents = parse_show_idents(identifiers, now.date());
+            let idents = parse_show_idents(identifiers, now.date())?;
             show::show(files, &entries, &layout, &idents);
         }
         Some(Command::Done { entries: ns }) => {
@@ -164,16 +153,30 @@ fn run_command(
             print::print(&layout);
         }
         Some(Command::Log { date }) => {
-            match parse_eval_arg("date", date, |date: CliDate| date.eval((), now.date())) {
-                Some(date) => log::log(files, date)?,
-                None => process::exit(1),
-            };
+            let date = parse_eval_arg("date", date, |date: CliDate| date.eval((), now.date()))?;
+            log::log(files, date)?
         }
         Some(Command::Fmt) => files.mark_all_dirty(),
     }
     Ok(())
 }
 
+fn run_with_files(opt: Opt, files: &mut Files) -> Result<()> {
+    let now = files.now().naive_local();
+    let today = parse_eval_arg("--date", &opt.date, |date: CliDate| {
+        date.eval((), now.date())
+    })?;
+    let now = today.and_time(now.time());
+
+    let range = parse_eval_arg("--range", &opt.range, |range: CliRange| {
+        range.eval((), now.date())
+    })?;
+
+    run_command(&opt, files, range, now)?;
+
+    Ok(())
+}
+
 pub fn run() {
     let opt = Opt::from_args();
 
@@ -183,23 +186,7 @@ pub fn run() {
         process::exit(1);
     }
 
-    let now = files.now().naive_local();
-    let today = match parse_eval_arg("--date", &opt.date, |date: CliDate| {
-        date.eval((), now.date())
-    }) {
-        Some(date) => date,
-        None => process::exit(1),
-    };
-    let now = today.and_time(now.time());
-
-    let range = match parse_eval_arg("--range", &opt.range, |range: CliRange| {
-        range.eval((), now.date())
-    }) {
-        Some(range) => range,
-        None => process::exit(1),
-    };
-
-    if let Err(e) = run_command(&opt, &mut files, range, now) {
+    if let Err(e) = run_with_files(opt, &mut files) {
         crate::error::eprint_error(&files, &e);
         process::exit(1);
     }
diff --git a/src/cli/cancel.rs b/src/cli/cancel.rs
index 4821676..62cc8ea 100644
--- a/src/cli/cancel.rs
+++ b/src/cli/cancel.rs
@@ -6,16 +6,16 @@ use crate::eval::Entry;
 use crate::files::commands::{Done, DoneKind};
 use crate::files::Files;
 
-use super::error::Error;
+use super::error::{Error, Result};
 use super::layout::line::LineLayout;
 
-pub fn cancel<S>(
+pub fn cancel(
     files: &mut Files,
     entries: &[Entry],
     layout: &LineLayout,
     numbers: &[usize],
     now: NaiveDateTime,
-) -> Result<(), Error<S>> {
+) -> Result<()> {
     let mut not_tasks = vec![];
     for &number in numbers {
         let entry = &entries[layout.look_up_number(number)?];
diff --git a/src/cli/done.rs b/src/cli/done.rs
index d68ad38..1d3d809 100644
--- a/src/cli/done.rs
+++ b/src/cli/done.rs
@@ -6,16 +6,16 @@ use crate::eval::Entry;
 use crate::files::commands::{Done, DoneKind};
 use crate::files::Files;
 
-use super::error::Error;
+use super::error::{Error, Result};
 use super::layout::line::LineLayout;
 
-pub fn done<S>(
+pub fn done(
     files: &mut Files,
     entries: &[Entry],
     layout: &LineLayout,
     numbers: &[usize],
     now: NaiveDateTime,
-) -> Result<(), Error<S>> {
+) -> Result<()> {
     let mut not_tasks = vec![];
     for &number in numbers {
         let entry = &entries[layout.look_up_number(number)?];
diff --git a/src/cli/error.rs b/src/cli/error.rs
index b4246c3..b740d7d 100644
--- a/src/cli/error.rs
+++ b/src/cli/error.rs
@@ -1,16 +1,27 @@
-use std::io;
+use std::{io, result};
 
 use chrono::NaiveDate;
-use codespan_reporting::files::Files;
+use codespan_reporting::files::{Files, SimpleFile};
 use codespan_reporting::term::Config;
 
 use crate::error::Eprint;
-use crate::eval;
+use crate::files::FileSource;
+use crate::{eval, files};
 
 #[derive(Debug, thiserror::Error)]
-pub enum Error<S> {
+pub enum Error {
     #[error("{0}")]
-    Eval(#[from] eval::Error<S>),
+    Eval(#[from] eval::Error<FileSource>),
+    #[error("{error}")]
+    ArgumentParse {
+        file: SimpleFile<String, String>,
+        error: files::ParseError<()>,
+    },
+    #[error("{error}")]
+    ArgumentEval {
+        file: SimpleFile<String, String>,
+        error: eval::Error<()>,
+    },
     #[error("No entry with number {0}")]
     NoSuchEntry(usize),
     #[error("No log for {0}")]
@@ -21,10 +32,17 @@ pub enum Error<S> {
     EditingLog { date: NaiveDate, error: io::Error },
 }
 
-impl<'a, F: Files<'a>> Eprint<'a, F> for Error<F::FileId> {
+pub type Result<T> = result::Result<T, Error>;
+
+impl<'a, F> Eprint<'a, F> for Error
+where
+    F: Files<'a, FileId = FileSource>,
+{
     fn eprint<'f: 'a>(&self, files: &'f F, config: &Config) {
         match self {
             Error::Eval(e) => e.eprint(files, config),
+            Error::ArgumentParse { file, error } => error.eprint(file, config),
+            Error::ArgumentEval { file, error } => error.eprint(file, config),
             Error::NoSuchEntry(n) => eprintln!("No entry with number {}", n),
             Error::NoSuchLog(date) => eprintln!("No log for {}", date),
             Error::NotATask(ns) => {
diff --git a/src/cli/layout/line.rs b/src/cli/layout/line.rs
index 0d1c360..171dd3e 100644
--- a/src/cli/layout/line.rs
+++ b/src/cli/layout/line.rs
@@ -148,7 +148,7 @@ impl LineLayout {
         &self.lines
     }
 
-    pub fn look_up_number<S>(&self, number: usize) -> Result<usize, Error<S>> {
+    pub fn look_up_number(&self, number: usize) -> Result<usize, Error> {
         self.numbers
             .iter()
             .filter(|(_, n)| **n == number)
diff --git a/src/cli/log.rs b/src/cli/log.rs
index 6456827..2e4f150 100644
--- a/src/cli/log.rs
+++ b/src/cli/log.rs
@@ -4,7 +4,7 @@ use crate::files::Files;
 
 use super::error::Error;
 
-pub fn log<S>(files: &mut Files, date: NaiveDate) -> Result<(), Error<S>> {
+pub fn log(files: &mut Files, date: NaiveDate) -> Result<(), Error> {
     let desc = files
         .log(date)
         .map(|log| log.value.desc.join("\n"))
diff --git a/src/cli/show.rs b/src/cli/show.rs
index 4ed8470..6b40e9b 100644
--- a/src/cli/show.rs
+++ b/src/cli/show.rs
@@ -74,13 +74,13 @@ fn show_log(files: &Files, log: Sourced<'_, Log>) {
 
 fn show_ident(files: &Files, entries: &[Entry], layout: &LineLayout, ident: Ident) {
     match ident {
-        Ident::Number(n) => match layout.look_up_number::<()>(n) {
+        Ident::Number(n) => match layout.look_up_number(n) {
             Ok(index) => show_entry(files, &entries[index]),
             Err(e) => println!("{}", e),
         },
         Ident::Date(date) => match files.log(date) {
             Some(log) => show_log(files, log),
-            None => println!("{}", Error::NoSuchLog::<()>(date)),
+            None => println!("{}", Error::NoSuchLog(date)),
         },
     }
 }

From fe1bf309b877534d085f9a1ff5fb2b3879f6a2c1 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Fri, 14 Jan 2022 22:05:52 +0100
Subject: [PATCH 51/80] Prepare string editing for 'today new'

---
 src/cli/error.rs | 10 +++++-----
 src/cli/log.rs   |  6 ++----
 src/cli/util.rs  | 11 +++++++++++
 src/main.rs      |  2 ++
 4 files changed, 20 insertions(+), 9 deletions(-)

diff --git a/src/cli/error.rs b/src/cli/error.rs
index b740d7d..c625dbe 100644
--- a/src/cli/error.rs
+++ b/src/cli/error.rs
@@ -28,8 +28,8 @@ pub enum Error {
     NoSuchLog(NaiveDate),
     #[error("Not a task")]
     NotATask(Vec<usize>),
-    #[error("Error editing log for {date}: {error}")]
-    EditingLog { date: NaiveDate, error: io::Error },
+    #[error("Error editing: {0}")]
+    EditingIo(io::Error),
 }
 
 pub type Result<T> = result::Result<T, Error>;
@@ -55,9 +55,9 @@ where
                     eprintln!("{} are not tasks.", ns.join(", "));
                 }
             }
-            Error::EditingLog { date, error } => {
-                eprintln!("Error editing log for {}", date);
-                eprintln!("  {}", error);
+            Error::EditingIo(error) => {
+                eprintln!("Error while editing:");
+                eprintln!("  {error}");
             }
         }
     }
diff --git a/src/cli/log.rs b/src/cli/log.rs
index 2e4f150..3703cef 100644
--- a/src/cli/log.rs
+++ b/src/cli/log.rs
@@ -3,6 +3,7 @@ use chrono::NaiveDate;
 use crate::files::Files;
 
 use super::error::Error;
+use super::util;
 
 pub fn log(files: &mut Files, date: NaiveDate) -> Result<(), Error> {
     let desc = files
@@ -10,10 +11,7 @@ pub fn log(files: &mut Files, date: NaiveDate) -> Result<(), Error> {
         .map(|log| log.value.desc.join("\n"))
         .unwrap_or_default();
 
-    let mut builder = edit::Builder::new();
-    builder.suffix(".md");
-    let edited = edit::edit_with_builder(desc, &builder)
-        .map_err(|error| Error::EditingLog { date, error })?;
+    let edited = util::edit_with_suffix(&desc, ".md")?;
 
     let edited = edited
         .lines()
diff --git a/src/cli/util.rs b/src/cli/util.rs
index bad291a..5d1c3d5 100644
--- a/src/cli/util.rs
+++ b/src/cli/util.rs
@@ -1,5 +1,6 @@
 use colored::{ColoredString, Colorize};
 
+use super::error::{Error, Result};
 use super::layout::line::LineKind;
 
 pub fn display_kind(kind: LineKind) -> ColoredString {
@@ -11,3 +12,13 @@ pub fn display_kind(kind: LineKind) -> ColoredString {
         LineKind::Birthday => "B".yellow().bold(),
     }
 }
+
+pub fn edit(input: &str) -> Result<String> {
+    edit::edit(input).map_err(Error::EditingIo)
+}
+
+pub fn edit_with_suffix(input: &str, suffix: &str) -> Result<String> {
+    let mut builder = edit::Builder::new();
+    builder.suffix(suffix);
+    edit::edit_with_builder(input, &builder).map_err(Error::EditingIo)
+}
diff --git a/src/main.rs b/src/main.rs
index 5d5922f..c55f748 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,6 +3,8 @@
 #![warn(clippy::all)]
 #![warn(clippy::use_self)]
 
+// TODO Switch to new format syntax project-wide
+
 mod cli;
 mod error;
 mod eval;

From 0dcb75b10358694b0452f63a181d0e65051f0563 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Fri, 14 Jan 2022 22:08:27 +0100
Subject: [PATCH 52/80] Parse arbitrary commands

---
 src/cli.rs                         |  2 +-
 src/eval.rs                        |  2 +-
 src/files.rs                       |  2 +-
 src/files/{arguments.rs => cli.rs} | 51 +++++++++++++++++++-----------
 src/files/grammar.pest             |  1 +
 src/files/parse.rs                 |  2 +-
 6 files changed, 37 insertions(+), 23 deletions(-)
 rename src/files/{arguments.rs => cli.rs} (76%)

diff --git a/src/cli.rs b/src/cli.rs
index 0da37a3..db3c14e 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -8,7 +8,7 @@ use directories::ProjectDirs;
 use structopt::StructOpt;
 
 use crate::eval::{self, DateRange, Entry, EntryMode};
-use crate::files::arguments::{CliDate, CliIdent, CliRange};
+use crate::files::cli::{CliDate, CliIdent, CliRange};
 use crate::files::{self, Files, ParseError};
 
 use self::error::{Error, Result};
diff --git a/src/eval.rs b/src/eval.rs
index bd02859..24859af 100644
--- a/src/eval.rs
+++ b/src/eval.rs
@@ -1,6 +1,6 @@
 use chrono::NaiveDate;
 
-use crate::files::arguments::{CliDate, CliDatum, CliRange};
+use crate::files::cli::{CliDate, CliDatum, CliRange};
 use crate::files::{FileSource, Files};
 
 use self::command::{CommandState, EvalCommand};
diff --git a/src/files.rs b/src/files.rs
index 8d66b2c..aba9c48 100644
--- a/src/files.rs
+++ b/src/files.rs
@@ -11,7 +11,7 @@ use self::commands::{Command, Done, File, Log};
 pub use self::error::{Error, ParseError, Result};
 use self::primitives::Spanned;
 
-pub mod arguments;
+pub mod cli;
 pub mod commands;
 mod error;
 mod format;
diff --git a/src/files/arguments.rs b/src/files/cli.rs
similarity index 76%
rename from src/files/arguments.rs
rename to src/files/cli.rs
index 100e7f1..6f72ca9 100644
--- a/src/files/arguments.rs
+++ b/src/files/cli.rs
@@ -5,10 +5,21 @@ use chrono::NaiveDate;
 use pest::iterators::Pair;
 use pest::Parser;
 
-use super::commands::Delta;
+use super::commands::{Command, Delta};
 use super::parse::{self, Result, Rule, TodayfileParser};
 use super::ParseError;
 
+fn from_str_via_parse<P, R>(s: &str, rule: Rule, parse: P) -> result::Result<R, ParseError<()>>
+where
+    P: FnOnce(Pair<'_, Rule>) -> Result<R>,
+{
+    let mut pairs = TodayfileParser::parse(rule, s).map_err(|e| ParseError::new((), e))?;
+    let p = pairs.next().unwrap();
+    assert_eq!(pairs.next(), None);
+
+    parse(p).map_err(|e| ParseError::new((), e))
+}
+
 #[derive(Debug)]
 pub enum CliDatum {
     Date(NaiveDate),
@@ -50,12 +61,7 @@ impl FromStr for CliDate {
     type Err = ParseError<()>;
 
     fn from_str(s: &str) -> result::Result<Self, ParseError<()>> {
-        let mut pairs =
-            TodayfileParser::parse(Rule::cli_date, s).map_err(|e| ParseError::new((), e))?;
-        let p = pairs.next().unwrap();
-        assert_eq!(pairs.next(), None);
-
-        parse_cli_date(p).map_err(|e| ParseError::new((), e))
+        from_str_via_parse(s, Rule::cli_date, parse_cli_date)
     }
 }
 
@@ -79,12 +85,7 @@ impl FromStr for CliIdent {
     type Err = ParseError<()>;
 
     fn from_str(s: &str) -> result::Result<Self, ParseError<()>> {
-        let mut pairs =
-            TodayfileParser::parse(Rule::cli_ident, s).map_err(|e| ParseError::new((), e))?;
-        let p = pairs.next().unwrap();
-        assert_eq!(pairs.next(), None);
-
-        parse_cli_ident(p).map_err(|e| ParseError::new((), e))
+        from_str_via_parse(s, Rule::cli_ident, parse_cli_ident)
     }
 }
 
@@ -151,11 +152,23 @@ impl FromStr for CliRange {
     type Err = ParseError<()>;
 
     fn from_str(s: &str) -> result::Result<Self, ParseError<()>> {
-        let mut pairs =
-            TodayfileParser::parse(Rule::cli_range, s).map_err(|e| ParseError::new((), e))?;
-        let p = pairs.next().unwrap();
-        assert_eq!(pairs.next(), None);
-
-        parse_cli_range(p).map_err(|e| ParseError::new((), e))
+        from_str_via_parse(s, Rule::cli_range, parse_cli_range)
+    }
+}
+
+#[derive(Debug)]
+pub struct CliCommand(pub Command);
+
+fn parse_cli_command(p: Pair<'_, Rule>) -> Result<CliCommand> {
+    assert_eq!(p.as_rule(), Rule::cli_command);
+    let p = p.into_inner().next().unwrap();
+    Ok(CliCommand(parse::parse_command(p)?.value))
+}
+
+impl FromStr for CliCommand {
+    type Err = ParseError<()>;
+
+    fn from_str(s: &str) -> result::Result<Self, ParseError<()>> {
+        from_str_via_parse(s, Rule::cli_command, parse_cli_command)
     }
 }
diff --git a/src/files/grammar.pest b/src/files/grammar.pest
index b83741e..3d80b4c 100644
--- a/src/files/grammar.pest
+++ b/src/files/grammar.pest
@@ -156,3 +156,4 @@ cli_ident = { SOI ~ (cli_date | number) ~ EOI }
 cli_range_start = { cli_datum ~ delta? }
 cli_range_end = { cli_datum ~ delta? | delta }
 cli_range = { SOI ~ cli_range_start ~ ("--" ~ cli_range_end)? ~ EOI }
+cli_command = { SOI ~ command ~ EOI }
diff --git a/src/files/parse.rs b/src/files/parse.rs
index 65200d4..574d785 100644
--- a/src/files/parse.rs
+++ b/src/files/parse.rs
@@ -818,7 +818,7 @@ fn parse_log(p: Pair<'_, Rule>) -> Result<Log> {
     Ok(Log { date, desc })
 }
 
-fn parse_command(p: Pair<'_, Rule>) -> Result<Spanned<Command>> {
+pub fn parse_command(p: Pair<'_, Rule>) -> Result<Spanned<Command>> {
     assert_eq!(p.as_rule(), Rule::command);
 
     let p = p.into_inner().next().unwrap();

From 3befb7c773ceaed5b28b33ea5a1c25afd2f62adb Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Fri, 14 Jan 2022 22:37:40 +0100
Subject: [PATCH 53/80] Implement 'today new'

---
 CHANGELOG.md           |   2 +-
 Cargo.lock             | 105 ++++++++++++++++++++++++++++++++++++++++-
 Cargo.toml             |   1 +
 src/cli.rs             |  18 +++++++
 src/cli/error.rs       |   3 ++
 src/cli/new.rs         |  46 ++++++++++++++++++
 src/files.rs           |   2 +-
 src/files/grammar.pest |   2 +-
 8 files changed, 174 insertions(+), 5 deletions(-)
 create mode 100644 src/cli/new.rs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fffc35e..74be72d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,7 +6,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ### Added
 - `LOG` command and `today log` CLI command
-- `CAPTURE` command
+- `CAPTURE` command and `today new` CLI command
 - `REMIND` statement
 - `CANCEL` statement for tasks
 - One-letter aliases for
diff --git a/Cargo.lock b/Cargo.lock
index 73c80f8..ceb2ab1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -67,6 +67,18 @@ version = "1.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
 
+[[package]]
+name = "cc"
+version = "1.0.72"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22a9137b95ea06864e018375b72adfb7db6e6f68cfc8df5a04d00288050485ee"
+
+[[package]]
+name = "cfg-if"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
@@ -146,6 +158,16 @@ dependencies = [
  "dirs-sys",
 ]
 
+[[package]]
+name = "dirs-next"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf36e65a80337bea855cd4ef9b8401ffce06a7baedf2e85ec467b1ac3f6e82b6"
+dependencies = [
+ "cfg-if 1.0.0",
+ "dirs-sys-next",
+]
+
 [[package]]
 name = "dirs-sys"
 version = "0.3.6"
@@ -157,6 +179,17 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "dirs-sys-next"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
+dependencies = [
+ "libc",
+ "redox_users",
+ "winapi",
+]
+
 [[package]]
 name = "edit"
 version = "0.1.3"
@@ -194,7 +227,7 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
  "libc",
  "wasi",
 ]
@@ -229,12 +262,39 @@ version = "0.2.112"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b03d17f364a3a042d5e5d46b053bbbf82c92c9430c592dd4c064dc6ee997125"
 
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if 1.0.0",
+]
+
 [[package]]
 name = "maplit"
 version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"
 
+[[package]]
+name = "memchr"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+
+[[package]]
+name = "nix"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83450fe6a6142ddd95fb064b746083fc4ef1705fe81f64a64e1d4b39f54a1055"
+dependencies = [
+ "bitflags",
+ "cc",
+ "cfg-if 0.1.10",
+ "libc",
+]
+
 [[package]]
 name = "num-integer"
 version = "0.1.44"
@@ -342,6 +402,15 @@ dependencies = [
  "unicode-xid",
 ]
 
+[[package]]
+name = "promptly"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b99cfb0289110d969dd21637cfbc922584329bc9e5037c5e576325c615658509"
+dependencies = [
+ "rustyline",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.10"
@@ -419,6 +488,31 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "rustyline"
+version = "6.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f0d5e7b0219a3eadd5439498525d4765c59b7c993ef0c12244865cd2d988413"
+dependencies = [
+ "cfg-if 0.1.10",
+ "dirs-next",
+ "libc",
+ "log",
+ "memchr",
+ "nix",
+ "scopeguard",
+ "unicode-segmentation",
+ "unicode-width",
+ "utf8parse",
+ "winapi",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+
 [[package]]
 name = "sha-1"
 version = "0.8.2"
@@ -478,7 +572,7 @@ version = "3.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
  "libc",
  "rand",
  "redox_syscall",
@@ -547,6 +641,7 @@ dependencies = [
  "edit",
  "pest",
  "pest_derive",
+ "promptly",
  "structopt",
  "termcolor",
  "thiserror",
@@ -592,6 +687,12 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
 
+[[package]]
+name = "utf8parse"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "936e4b492acfd135421d8dca4b1aa80a7bfc26e702ef3af710e0752684df5372"
+
 [[package]]
 name = "vec_map"
 version = "0.8.2"
diff --git a/Cargo.toml b/Cargo.toml
index 2807701..4ee590e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,6 +12,7 @@ directories = "4.0.1"
 edit = "0.1.3"
 pest = "2.1.3"
 pest_derive = "2.1.0"
+promptly = "0.3.0"
 structopt = "0.3.25"
 termcolor = "1.1.2"
 thiserror = "1.0.30"
diff --git a/src/cli.rs b/src/cli.rs
index db3c14e..25b944f 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -19,6 +19,7 @@ mod done;
 mod error;
 mod layout;
 mod log;
+mod new;
 mod print;
 mod show;
 mod util;
@@ -47,6 +48,12 @@ pub enum Command {
         #[structopt(required = true)]
         identifiers: Vec<String>,
     },
+    /// Create a new entry based on a template
+    #[structopt(alias = "n")]
+    New {
+        #[structopt(subcommand)]
+        template: Template,
+    },
     /// Marks one or more entries as done
     #[structopt(alias = "d")]
     Done {
@@ -71,6 +78,14 @@ pub enum Command {
     Fmt,
 }
 
+// TODO Add templates for tasks and notes
+#[derive(Debug, StructOpt)]
+pub enum Template {
+    /// An undated task marked as done today
+    #[structopt(alias = "d")]
+    Done,
+}
+
 fn default_file() -> PathBuf {
     ProjectDirs::from("", "", "today")
         .expect("could not determine config dir")
@@ -136,6 +151,9 @@ fn run_command(opt: &Opt, files: &mut Files, range: DateRange, now: NaiveDateTim
             let idents = parse_show_idents(identifiers, now.date())?;
             show::show(files, &entries, &layout, &idents);
         }
+        Some(Command::New { template }) => match template {
+            Template::Done => new::done(files, now)?,
+        },
         Some(Command::Done { entries: ns }) => {
             let entries = find_entries(files, range)?;
             let layout = find_layout(files, &entries, range, now);
diff --git a/src/cli/error.rs b/src/cli/error.rs
index c625dbe..7ab0130 100644
--- a/src/cli/error.rs
+++ b/src/cli/error.rs
@@ -28,6 +28,8 @@ pub enum Error {
     NoSuchLog(NaiveDate),
     #[error("Not a task")]
     NotATask(Vec<usize>),
+    #[error("No capture file found")]
+    NoCaptureFile,
     #[error("Error editing: {0}")]
     EditingIo(io::Error),
 }
@@ -55,6 +57,7 @@ where
                     eprintln!("{} are not tasks.", ns.join(", "));
                 }
             }
+            Error::NoCaptureFile => eprintln!("No capture file found"),
             Error::EditingIo(error) => {
                 eprintln!("Error while editing:");
                 eprintln!("  {error}");
diff --git a/src/cli/new.rs b/src/cli/new.rs
new file mode 100644
index 0000000..67a66e6
--- /dev/null
+++ b/src/cli/new.rs
@@ -0,0 +1,46 @@
+use std::str::FromStr;
+
+use chrono::NaiveDateTime;
+use codespan_reporting::files::SimpleFile;
+
+use crate::files::cli::CliCommand;
+use crate::files::commands::{Done, DoneKind, Task};
+use crate::files::Files;
+
+use super::error::{Error, Result};
+use super::util;
+
+pub fn done(files: &mut Files, now: NaiveDateTime) -> Result<()> {
+    let capture = files.capture().ok_or(Error::NoCaptureFile)?;
+
+    let command = Task {
+        title: String::new(),
+        statements: vec![],
+        done: vec![Done {
+            kind: DoneKind::Done,
+            date: None,
+            done_at: now.date(),
+        }],
+        desc: vec![],
+    };
+
+    let mut text = format!("{command}");
+    let command = loop {
+        text = util::edit(&text)?;
+        match CliCommand::from_str(&text) {
+            Ok(command) => break command.0,
+            Err(e) => crate::error::eprint_error(&SimpleFile::new("new command", &text), &e),
+        }
+        if !matches!(
+            promptly::prompt_default("Continue editing?", true),
+            Ok(true)
+        ) {
+            println!("Aborting");
+            return Ok(());
+        }
+    };
+
+    files.insert(capture, command);
+
+    Ok(())
+}
diff --git a/src/files.rs b/src/files.rs
index aba9c48..8522547 100644
--- a/src/files.rs
+++ b/src/files.rs
@@ -424,7 +424,7 @@ impl Files {
         file.dirty = true;
     }
 
-    fn insert(&mut self, file: FileSource, command: Command) {
+    pub fn insert(&mut self, file: FileSource, command: Command) {
         let file = &mut self.files[file.0];
         file.file.commands.push(Spanned::dummy(command));
         file.dirty = true;
diff --git a/src/files/grammar.pest b/src/files/grammar.pest
index 3d80b4c..894a695 100644
--- a/src/files/grammar.pest
+++ b/src/files/grammar.pest
@@ -156,4 +156,4 @@ cli_ident = { SOI ~ (cli_date | number) ~ EOI }
 cli_range_start = { cli_datum ~ delta? }
 cli_range_end = { cli_datum ~ delta? | delta }
 cli_range = { SOI ~ cli_range_start ~ ("--" ~ cli_range_end)? ~ EOI }
-cli_command = { SOI ~ command ~ EOI }
+cli_command = ${ SOI ~ empty_line* ~ command ~ empty_line* ~ WHITESPACE* ~ EOI }

From a3a0e0b9cf140c5225a26033086c9df271a2aee9 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Fri, 14 Jan 2022 23:16:29 +0100
Subject: [PATCH 54/80] Add more 'today new' templates

---
 src/cli.rs     |  30 ++++++++++++-
 src/cli/new.rs | 118 ++++++++++++++++++++++++++++++++++++++-----------
 2 files changed, 121 insertions(+), 27 deletions(-)

diff --git a/src/cli.rs b/src/cli.rs
index 25b944f..2636f5b 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -81,7 +81,19 @@ pub enum Command {
 // TODO Add templates for tasks and notes
 #[derive(Debug, StructOpt)]
 pub enum Template {
-    /// An undated task marked as done today
+    /// Adds a task
+    #[structopt(alias = "t")]
+    Task {
+        /// If specified, the task is dated to this date
+        date: Option<String>,
+    },
+    /// Adds a note
+    #[structopt(alias = "n")]
+    Note {
+        /// If specified, the note is dated to this date
+        date: Option<String>,
+    },
+    /// Adds an undated task marked as done today
     #[structopt(alias = "d")]
     Done,
 }
@@ -126,6 +138,10 @@ where
     })
 }
 
+fn parse_eval_date(name: &str, text: &str, today: NaiveDate) -> Result<NaiveDate> {
+    parse_eval_arg(name, text, |date: CliDate| date.eval((), today))
+}
+
 fn parse_show_idents(identifiers: &[String], today: NaiveDate) -> Result<Vec<show::Ident>> {
     let mut idents = vec![];
     for ident in identifiers {
@@ -152,7 +168,17 @@ fn run_command(opt: &Opt, files: &mut Files, range: DateRange, now: NaiveDateTim
             show::show(files, &entries, &layout, &idents);
         }
         Some(Command::New { template }) => match template {
-            Template::Done => new::done(files, now)?,
+            Template::Task { date: Some(date) } => {
+                let date = parse_eval_date("date", date, now.date())?;
+                new::task(files, Some(date))?
+            }
+            Template::Task { date: None } => new::task(files, None)?,
+            Template::Note { date: Some(date) } => {
+                let date = parse_eval_date("date", date, now.date())?;
+                new::note(files, Some(date))?
+            }
+            Template::Note { date: None } => new::note(files, None)?,
+            Template::Done => new::done(files, now.date())?,
         },
         Some(Command::Done { entries: ns }) => {
             let entries = find_entries(files, range)?;
diff --git a/src/cli/new.rs b/src/cli/new.rs
index 67a66e6..ecd040f 100644
--- a/src/cli/new.rs
+++ b/src/cli/new.rs
@@ -1,46 +1,114 @@
+use std::result;
 use std::str::FromStr;
 
-use chrono::NaiveDateTime;
+use chrono::NaiveDate;
 use codespan_reporting::files::SimpleFile;
 
 use crate::files::cli::CliCommand;
-use crate::files::commands::{Done, DoneKind, Task};
-use crate::files::Files;
+use crate::files::commands::{Command, DateSpec, Done, DoneKind, Note, Spec, Statement, Task};
+use crate::files::{Files, ParseError};
 
 use super::error::{Error, Result};
 use super::util;
 
-pub fn done(files: &mut Files, now: NaiveDateTime) -> Result<()> {
-    let capture = files.capture().ok_or(Error::NoCaptureFile)?;
-
-    let command = Task {
-        title: String::new(),
-        statements: vec![],
-        done: vec![Done {
-            kind: DoneKind::Done,
-            date: None,
-            done_at: now.date(),
-        }],
-        desc: vec![],
-    };
-
-    let mut text = format!("{command}");
-    let command = loop {
+fn edit<R, F>(name: &str, mut text: String, validate: F) -> Result<Option<R>>
+where
+    R: FromStr<Err = ParseError<()>>,
+    F: Fn(&R) -> result::Result<(), &str>,
+{
+    Ok(loop {
         text = util::edit(&text)?;
-        match CliCommand::from_str(&text) {
-            Ok(command) => break command.0,
-            Err(e) => crate::error::eprint_error(&SimpleFile::new("new command", &text), &e),
+        match text.parse() {
+            Ok(command) => match validate(&command) {
+                Ok(()) => break Some(command),
+                Err(msg) => eprintln!("{msg}"),
+            },
+            Err(e) => crate::error::eprint_error(&SimpleFile::new(name, &text), &e),
         }
         if !matches!(
             promptly::prompt_default("Continue editing?", true),
             Ok(true)
         ) {
             println!("Aborting");
-            return Ok(());
+            break None;
         }
-    };
+    })
+}
 
-    files.insert(capture, command);
+fn is_task_or_note(command: &CliCommand) -> result::Result<(), &str> {
+    match command.0 {
+        Command::Task(_) | Command::Note(_) => Ok(()),
+        _ => Err("Only TASK and NOTE are allowed"),
+    }
+}
+
+fn new_command(files: &mut Files, command: Command) -> Result<()> {
+    let capture = files.capture().ok_or(Error::NoCaptureFile)?;
+
+    let command = edit("new command", format!("{command}"), is_task_or_note)?;
+    if let Some(command) = command {
+        files.insert(capture, command.0)
+    }
 
     Ok(())
 }
+
+pub fn task(files: &mut Files, date: Option<NaiveDate>) -> Result<()> {
+    let statements = match date {
+        Some(date) => vec![Statement::Date(Spec::Date(DateSpec {
+            start: date,
+            start_delta: None,
+            start_time: None,
+            end: None,
+            end_delta: None,
+            end_time: None,
+            repeat: None,
+        }))],
+        None => vec![],
+    };
+    let command = Command::Task(Task {
+        title: String::new(),
+        statements,
+        done: vec![],
+        desc: vec![],
+    });
+
+    new_command(files, command)
+}
+
+pub fn note(files: &mut Files, date: Option<NaiveDate>) -> Result<()> {
+    let statements = match date {
+        Some(date) => vec![Statement::Date(Spec::Date(DateSpec {
+            start: date,
+            start_delta: None,
+            start_time: None,
+            end: None,
+            end_delta: None,
+            end_time: None,
+            repeat: None,
+        }))],
+        None => vec![],
+    };
+    let command = Command::Note(Note {
+        title: String::new(),
+        statements,
+        desc: vec![],
+    });
+
+    new_command(files, command)
+}
+
+pub fn done(files: &mut Files, date: NaiveDate) -> Result<()> {
+    let command = Command::Task(Task {
+        title: String::new(),
+        statements: vec![],
+        done: vec![Done {
+            kind: DoneKind::Done,
+            date: None,
+            done_at: date,
+        }],
+        desc: vec![],
+    });
+
+    new_command(files, command)
+}

From f82b368fe1f816236657d11e20c83a93009bc532 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sat, 15 Jan 2022 01:09:34 +0100
Subject: [PATCH 55/80] Use new format syntax in most places

---
 src/cli/error.rs            |   4 +-
 src/cli/layout/line.rs      |   6 +-
 src/cli/print.rs            |  31 ++++----
 src/cli/show.rs             |  11 +--
 src/error.rs                |   2 +-
 src/eval/command/formula.rs |   2 +-
 src/eval/error.rs           |  21 +++---
 src/files/error.rs          |  26 +++----
 src/files/format.rs         | 142 ++++++++++++++++++------------------
 src/main.rs                 |   2 -
 10 files changed, 120 insertions(+), 127 deletions(-)

diff --git a/src/cli/error.rs b/src/cli/error.rs
index 7ab0130..929650a 100644
--- a/src/cli/error.rs
+++ b/src/cli/error.rs
@@ -45,8 +45,8 @@ where
             Error::Eval(e) => e.eprint(files, config),
             Error::ArgumentParse { file, error } => error.eprint(file, config),
             Error::ArgumentEval { file, error } => error.eprint(file, config),
-            Error::NoSuchEntry(n) => eprintln!("No entry with number {}", n),
-            Error::NoSuchLog(date) => eprintln!("No log for {}", date),
+            Error::NoSuchEntry(n) => eprintln!("No entry with number {n}"),
+            Error::NoSuchLog(date) => eprintln!("No log for {date}"),
             Error::NotATask(ns) => {
                 if ns.is_empty() {
                     eprintln!("Not a task.");
diff --git a/src/cli/layout/line.rs b/src/cli/layout/line.rs
index 171dd3e..fffaab6 100644
--- a/src/cli/layout/line.rs
+++ b/src/cli/layout/line.rs
@@ -185,7 +185,7 @@ impl LineLayout {
                 let extra = if *d == 1 {
                     "yesterday".to_string()
                 } else {
-                    format!("{} days ago", d)
+                    format!("{d} days ago")
                 };
                 self.line_entry(entries, *i, Times::Untimed, Some(extra));
             }
@@ -194,7 +194,7 @@ impl LineLayout {
             }
             DayEntry::ReminderWhile(i, d) => {
                 let plural = if *d == 1 { "" } else { "s" };
-                let extra = format!("{} day{} left", d, plural);
+                let extra = format!("{d} day{plural} left");
                 self.line_entry(entries, *i, Times::Untimed, Some(extra));
             }
             DayEntry::Undated(i) => {
@@ -208,7 +208,7 @@ impl LineLayout {
                 let extra = if *d == 1 {
                     "tomorrow".to_string()
                 } else {
-                    format!("in {} days", d)
+                    format!("in {d} days")
                 };
                 self.line_entry(entries, *i, Times::Untimed, Some(extra));
             }
diff --git a/src/cli/print.rs b/src/cli/print.rs
index 1cdfe4d..1cb8caf 100644
--- a/src/cli/print.rs
+++ b/src/cli/print.rs
@@ -63,28 +63,25 @@ impl ShowLines {
         };
 
         // '=' symbols before the spans start
-        let p1 = format!("{:=<w$}=", "", w = self.num_width);
+        let p1 = styled(&format!("{:=<w$}=", "", w = self.num_width));
 
         // Spans and filler '=' symbols
         let p2 = self.display_spans(spans, styled("="));
 
         // The rest of the line until after the date
-        let p3 = format!("===  {:9}  {}", weekday, date,);
+        let p3 = styled(&format!("===  {weekday:9}  {date}"));
 
         // The "has log" marker (if any)
         let p4 = Self::display_marker(has_log, " ");
 
         // The rest of the line
-        let p5 = format!(" ===={:=<w$}", "", w = self.num_width + self.span_width);
-
-        self.push(&format!(
-            "{}{}{}{}{}\n",
-            styled(&p1),
-            p2,
-            styled(&p3),
-            p4,
-            styled(&p5)
+        let p5 = styled(&format!(
+            " ===={:=<w$}",
+            "",
+            w = self.num_width + self.span_width
         ));
+
+        self.push(&format!("{p1}{p2}{p3}{p4}{p5}\n"));
     }
 
     fn display_line_now(&mut self, spans: &[Option<SpanSegment>], time: Time) {
@@ -109,7 +106,7 @@ impl ShowLines {
         extra: &Option<String>,
     ) {
         let num = match number {
-            Some(n) => format!("{}", n),
+            Some(n) => format!("{n}"),
             None => "".to_string(),
         };
 
@@ -137,9 +134,9 @@ impl ShowLines {
                     SpanSegment::Middle(SpanStyle::Dotted) => "┊".bright_black(),
                     SpanSegment::End(_) => "└".bright_black(),
                 };
-                result.push_str(&format!("{}", colored_str));
+                result.push_str(&format!("{colored_str}"));
             } else {
-                result.push_str(&format!("{}", empty));
+                result.push_str(&format!("{empty}"));
             }
         }
         result
@@ -148,8 +145,8 @@ impl ShowLines {
     fn display_time(time: Times) -> ColoredString {
         match time {
             Times::Untimed => "".into(),
-            Times::At(t) => format!(" {}", t).bright_black(),
-            Times::FromTo(t1, t2) => format!(" {}--{}", t1, t2).bright_black(),
+            Times::At(t) => format!(" {t}").bright_black(),
+            Times::FromTo(t1, t2) => format!(" {t1}--{t2}").bright_black(),
         }
     }
 
@@ -164,7 +161,7 @@ impl ShowLines {
     fn display_extra(extra: &Option<String>) -> ColoredString {
         match extra {
             None => "".into(),
-            Some(extra) => format!(" ({})", extra).bright_black(),
+            Some(extra) => format!(" ({extra})").bright_black(),
         }
     }
 
diff --git a/src/cli/show.rs b/src/cli/show.rs
index 6b40e9b..12bcc31 100644
--- a/src/cli/show.rs
+++ b/src/cli/show.rs
@@ -16,7 +16,8 @@ fn fmt_where(files: &Files, command: &Sourced<'_, Spanned<Command>>) -> String {
     let line = files
         .line_index(command.source.file(), command.value.span.start)
         .expect("file exists and line is valid");
-    format!("Line {} in {}", line + 1, name)
+    let line = line + 1; // 1-indexed for human consumption
+    format!("Line {line} in {name}")
 }
 
 fn print_desc(command: &Sourced<'_, Spanned<Command>>) {
@@ -42,11 +43,11 @@ fn show_entry(files: &Files, entry: &Entry) {
 
     let what = match entry.kind {
         EntryKind::Task => "Task".to_string(),
-        EntryKind::TaskDone(date) => format!("Task, done {}", date),
-        EntryKind::TaskCanceled(date) => format!("Task, canceled {}", date),
+        EntryKind::TaskDone(date) => format!("Task, done {date}"),
+        EntryKind::TaskCanceled(date) => format!("Task, canceled {date}"),
         EntryKind::Note => "Note".to_string(),
         EntryKind::Birthday(None) => "Birthday, age unknown".to_string(),
-        EntryKind::Birthday(Some(age)) => format!("Birthday, age {}", age),
+        EntryKind::Birthday(Some(age)) => format!("Birthday, age {age}"),
     };
     println!("{}  {}", "What:".bright_black(), what);
 
@@ -76,7 +77,7 @@ fn show_ident(files: &Files, entries: &[Entry], layout: &LineLayout, ident: Iden
     match ident {
         Ident::Number(n) => match layout.look_up_number(n) {
             Ok(index) => show_entry(files, &entries[index]),
-            Err(e) => println!("{}", e),
+            Err(e) => println!("{e}"),
         },
         Ident::Date(date) => match files.log(date) {
             Some(log) => show_log(files, log),
diff --git a/src/error.rs b/src/error.rs
index 89e85e7..b8a658e 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -11,7 +11,7 @@ pub trait Eprint<'a, F: Files<'a>> {
     ) {
         let mut out = StandardStream::stderr(termcolor::ColorChoice::Auto);
         if let Err(e) = term::emit(&mut out, config, files, diagnostic) {
-            panic!("Error while reporting error: {}", e);
+            panic!("Error while reporting error: {e}");
         }
     }
 
diff --git a/src/eval/command/formula.rs b/src/eval/command/formula.rs
index e733937..c9a8692 100644
--- a/src/eval/command/formula.rs
+++ b/src/eval/command/formula.rs
@@ -391,7 +391,7 @@ mod tests {
         if let Ok(result) = expr.eval((), date) {
             assert_eq!(result, target);
         } else {
-            panic!("formula produced error for day {}", date);
+            panic!("formula produced error for day {date}");
         }
     }
 
diff --git a/src/eval/error.rs b/src/eval/error.rs
index 4e5bd45..c78a131 100644
--- a/src/eval/error.rs
+++ b/src/eval/error.rs
@@ -106,8 +106,8 @@ impl<'a, F: Files<'a>> Eprint<'a, F> for Error<F::FileId> {
                         Label::primary(*index, span).with_message("At this step")
                     ])
                     .with_notes(vec![
-                        format!("Date before applying delta: {}", start_str),
-                        format!("Date before applying this step: {}", prev_str),
+                        format!("Date before applying delta: {start_str}"),
+                        format!("Date before applying this step: {prev_str}"),
                     ])
             }
             Error::DeltaNoTime {
@@ -121,8 +121,8 @@ impl<'a, F: Files<'a>> Eprint<'a, F> for Error<F::FileId> {
                     Label::primary(*index, span).with_message("At this step")
                 ])
                 .with_notes(vec![
-                    format!("Date before applying delta: {}", start),
-                    format!("Date before applying this step: {}", prev),
+                    format!("Date before applying delta: {start}"),
+                    format!("Date before applying this step: {prev}"),
                 ]),
             Error::RepeatDidNotMoveForwards {
                 index,
@@ -132,7 +132,7 @@ impl<'a, F: Files<'a>> Eprint<'a, F> for Error<F::FileId> {
             } => Diagnostic::error()
                 .with_message("Repeat delta did not move forwards")
                 .with_labels(vec![Label::primary(*index, span).with_message("This delta")])
-                .with_notes(vec![format!("Moved from {} to {}", from, to)]),
+                .with_notes(vec![format!("Moved from {from} to {to}")]),
             Error::RemindDidNotMoveBackwards {
                 index,
                 span,
@@ -141,7 +141,7 @@ impl<'a, F: Files<'a>> Eprint<'a, F> for Error<F::FileId> {
             } => Diagnostic::error()
                 .with_message("Remind delta did not move backwards")
                 .with_labels(vec![Label::primary(*index, span).with_message("This delta")])
-                .with_notes(vec![format!("Moved from {} to {}", from, to)]),
+                .with_notes(vec![format!("Moved from {from} to {to}")]),
             Error::MoveWithoutSource { index, span } => Diagnostic::error()
                 .with_message("Tried to move nonexistent entry")
                 .with_labels(vec![Label::primary(*index, span).with_message("Here")]),
@@ -153,13 +153,13 @@ impl<'a, F: Files<'a>> Eprint<'a, F> for Error<F::FileId> {
                 .with_labels(vec![
                     Label::primary(*index, span).with_message("This expression")
                 ])
-                .with_notes(vec![format!("At date: {}", date)]),
+                .with_notes(vec![format!("At date: {date}")]),
             Error::ModByZero { index, span, date } => Diagnostic::error()
                 .with_message("Tried to modulo by zero")
                 .with_labels(vec![
                     Label::primary(*index, span).with_message("This expression")
                 ])
-                .with_notes(vec![format!("At date: {}", date)]),
+                .with_notes(vec![format!("At date: {date}")]),
             Error::Easter {
                 index,
                 span,
@@ -170,10 +170,7 @@ impl<'a, F: Files<'a>> Eprint<'a, F> for Error<F::FileId> {
                 .with_labels(vec![
                     Label::primary(*index, span).with_message("This expression")
                 ])
-                .with_notes(vec![
-                    format!("At date: {}", date),
-                    format!("Reason: {}", msg),
-                ]),
+                .with_notes(vec![format!("At date: {date}"), format!("Reason: {msg}")]),
         };
         Self::eprint_diagnostic(files, config, &diagnostic);
     }
diff --git a/src/files/error.rs b/src/files/error.rs
index 983160d..aabd582 100644
--- a/src/files/error.rs
+++ b/src/files/error.rs
@@ -40,7 +40,7 @@ impl<S> ParseError<S> {
                     .collect::<Vec<_>>()
                     .join(", ");
                 let last = Self::rule_name(rules[n - 1]);
-                format!("{} or {}", except_last, last)
+                format!("{except_last} or {last}")
             }
         }
     }
@@ -76,7 +76,7 @@ where
         };
         let name = files.name(self.file).expect("file exists");
         let diagnostic = Diagnostic::error()
-            .with_message(format!("Could not parse {}", name))
+            .with_message(format!("Could not parse {name}"))
             .with_labels(vec![Label::primary(self.file, range)])
             .with_notes(self.notes());
         Self::eprint_diagnostic(files, config, &diagnostic);
@@ -135,16 +135,16 @@ impl<'a> Eprint<'a, Files> for Error {
     fn eprint<'f: 'a>(&self, files: &'f Files, config: &Config) {
         match self {
             Error::ResolvePath { path, error } => {
-                eprintln!("Could not resolve path {:?}:", path);
-                eprintln!("  {}", error);
+                eprintln!("Could not resolve path {path:?}:");
+                eprintln!("  {error}");
             }
             Error::ReadFile { file, error } => {
-                eprintln!("Could not read file {:?}:", file);
-                eprintln!("  {}", error);
+                eprintln!("Could not read file {file:?}:");
+                eprintln!("  {error}");
             }
             Error::WriteFile { file, error } => {
-                eprintln!("Could not write file {:?}:", file);
-                eprintln!("  {}", error);
+                eprintln!("Could not write file {file:?}:");
+                eprintln!("  {error}");
             }
             Error::ResolveTz {
                 file,
@@ -153,16 +153,16 @@ impl<'a> Eprint<'a, Files> for Error {
                 error,
             } => {
                 let diagnostic = Diagnostic::error()
-                    .with_message(format!("Could not resolve time zone {}", tz))
+                    .with_message(format!("Could not resolve time zone {tz}"))
                     .with_labels(vec![
                         Label::primary(*file, span).with_message("Time zone defined here")
                     ])
-                    .with_notes(vec![format!("{}", error)]);
+                    .with_notes(vec![format!("{error}")]);
                 Self::eprint_diagnostic(files, config, &diagnostic);
             }
             Error::LocalTz { error } => {
                 eprintln!("Could not determine local timezone:");
-                eprintln!("  {}", error);
+                eprintln!("  {error}");
             }
             Error::Parse { file, error } => {
                 ParseError::new(*file, error.clone()).eprint(files, config)
@@ -176,7 +176,7 @@ impl<'a> Eprint<'a, Files> for Error {
                 tz2,
             } => {
                 let diagnostic = Diagnostic::error()
-                    .with_message(format!("Time zone conflict between {} and {}", tz1, tz2))
+                    .with_message(format!("Time zone conflict between {tz1} and {tz2}"))
                     .with_labels(vec![
                         Label::primary(*file1, span1).with_message("Time zone defined here"),
                         Label::primary(*file2, span2).with_message("Time zone defined here"),
@@ -211,7 +211,7 @@ impl<'a> Eprint<'a, Files> for Error {
                 date,
             } => {
                 let diagnostic = Diagnostic::error()
-                    .with_message(format!("Duplicate log entries for {}", date))
+                    .with_message(format!("Duplicate log entries for {date}"))
                     .with_labels(vec![
                         Label::primary(*file1, span1).with_message("Log defined here"),
                         Label::primary(*file2, span2).with_message("Log defined here"),
diff --git a/src/files/format.rs b/src/files/format.rs
index f9ad86a..5f2ec3f 100644
--- a/src/files/format.rs
+++ b/src/files/format.rs
@@ -22,7 +22,7 @@ fn format_desc(f: &mut fmt::Formatter<'_>, desc: &[String]) -> fmt::Result {
         if line.is_empty() {
             writeln!(f, "#")?;
         } else {
-            writeln!(f, "# {}", line)?;
+            writeln!(f, "# {line}")?;
         }
     }
     Ok(())
@@ -76,29 +76,29 @@ impl fmt::Display for DateSpec {
         // Start
         write!(f, "{}", self.start)?;
         for delta in &self.start_delta {
-            write!(f, " {}", delta)?;
+            write!(f, " {delta}")?;
         }
         for time in &self.start_time {
-            write!(f, " {}", time)?;
+            write!(f, " {time}")?;
         }
 
         // End
         if self.end.is_some() || self.end_delta.is_some() || self.end_time.is_some() {
             write!(f, " --")?;
             if let Some(date) = self.end {
-                write!(f, " {}", date)?;
+                write!(f, " {date}")?;
             }
             if let Some(delta) = &self.end_delta {
-                write!(f, " {}", delta)?;
+                write!(f, " {delta}")?;
             }
             if let Some(time) = &self.end_time {
-                write!(f, " {}", time)?;
+                write!(f, " {time}")?;
             }
         }
 
         // Repeat
         if let Some(repeat) = &self.repeat {
-            write!(f, "; {}", repeat)?;
+            write!(f, "; {repeat}")?;
         }
 
         Ok(())
@@ -110,20 +110,20 @@ impl fmt::Display for WeekdaySpec {
         // Start
         write!(f, "{}", self.start)?;
         for time in &self.start_time {
-            write!(f, " {}", time)?;
+            write!(f, " {time}")?;
         }
 
         // End
         if self.end.is_some() || self.end_delta.is_some() || self.end_time.is_some() {
             write!(f, " --")?;
             if let Some(wd) = self.end {
-                write!(f, " {}", wd)?;
+                write!(f, " {wd}")?;
             }
             if let Some(delta) = &self.end_delta {
-                write!(f, " {}", delta)?;
+                write!(f, " {delta}")?;
             }
             if let Some(time) = &self.end_time {
-                write!(f, " {}", time)?;
+                write!(f, " {time}")?;
             }
         }
 
@@ -140,25 +140,25 @@ impl fmt::Display for Var {
 impl fmt::Display for Expr {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Expr::Lit(i) => write!(f, "{}", i),
-            Expr::Var(v) => write!(f, "{}", v),
-            Expr::Paren(e) => write!(f, "({})", e),
-            Expr::Neg(e) => write!(f, "-{}", e),
-            Expr::Add(a, b) => write!(f, "{} + {}", a, b),
-            Expr::Sub(a, b) => write!(f, "{} - {}", a, b),
-            Expr::Mul(a, b) => write!(f, "{} * {}", a, b),
-            Expr::Div(a, b) => write!(f, "{} / {}", a, b),
-            Expr::Mod(a, b) => write!(f, "{} % {}", a, b),
-            Expr::Eq(a, b) => write!(f, "{} = {}", a, b),
-            Expr::Neq(a, b) => write!(f, "{} != {}", a, b),
-            Expr::Lt(a, b) => write!(f, "{} < {}", a, b),
-            Expr::Lte(a, b) => write!(f, "{} <= {}", a, b),
-            Expr::Gt(a, b) => write!(f, "{} > {}", a, b),
-            Expr::Gte(a, b) => write!(f, "{} >= {}", a, b),
-            Expr::Not(e) => write!(f, "!{}", e),
-            Expr::And(a, b) => write!(f, "{} & {}", a, b),
-            Expr::Or(a, b) => write!(f, "{} | {}", a, b),
-            Expr::Xor(a, b) => write!(f, "{} ^ {}", a, b),
+            Expr::Lit(i) => write!(f, "{i}"),
+            Expr::Var(v) => write!(f, "{v}"),
+            Expr::Paren(e) => write!(f, "({e})"),
+            Expr::Neg(e) => write!(f, "-{e}"),
+            Expr::Add(a, b) => write!(f, "{a} + {b}"),
+            Expr::Sub(a, b) => write!(f, "{a} - {b}"),
+            Expr::Mul(a, b) => write!(f, "{a} * {b}"),
+            Expr::Div(a, b) => write!(f, "{a} / {b}"),
+            Expr::Mod(a, b) => write!(f, "{a} % {b}"),
+            Expr::Eq(a, b) => write!(f, "{a} = {b}"),
+            Expr::Neq(a, b) => write!(f, "{a} != {b}"),
+            Expr::Lt(a, b) => write!(f, "{a} < {b}"),
+            Expr::Lte(a, b) => write!(f, "{a} <= {b}"),
+            Expr::Gt(a, b) => write!(f, "{a} > {b}"),
+            Expr::Gte(a, b) => write!(f, "{a} >= {b}"),
+            Expr::Not(e) => write!(f, "!{e}"),
+            Expr::And(a, b) => write!(f, "{a} & {b}"),
+            Expr::Or(a, b) => write!(f, "{a} | {b}"),
+            Expr::Xor(a, b) => write!(f, "{a} ^ {b}"),
         }
     }
 }
@@ -167,25 +167,25 @@ impl fmt::Display for FormulaSpec {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // Start
         if let Some(expr) = &self.start {
-            write!(f, "({})", expr)?;
+            write!(f, "({expr})")?;
         } else {
             write!(f, "*")?;
         }
         for delta in &self.start_delta {
-            write!(f, " {}", delta)?;
+            write!(f, " {delta}")?;
         }
         for time in &self.start_time {
-            write!(f, " {}", time)?;
+            write!(f, " {time}")?;
         }
 
         // End
         if self.end_delta.is_some() || self.end_time.is_some() {
             write!(f, " --")?;
             if let Some(delta) = &self.end_delta {
-                write!(f, " {}", delta)?;
+                write!(f, " {delta}")?;
             }
             if let Some(time) = &self.end_time {
-                write!(f, " {}", time)?;
+                write!(f, " {time}")?;
             }
         }
 
@@ -196,9 +196,9 @@ impl fmt::Display for FormulaSpec {
 impl fmt::Display for Spec {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Spec::Date(spec) => write!(f, "{}", spec),
-            Spec::Weekday(spec) => write!(f, "{}", spec),
-            Spec::Formula(spec) => write!(f, "{}", spec),
+            Spec::Date(spec) => write!(f, "{spec}"),
+            Spec::Weekday(spec) => write!(f, "{spec}"),
+            Spec::Formula(spec) => write!(f, "{spec}"),
         }
     }
 }
@@ -216,22 +216,22 @@ impl fmt::Display for BirthdaySpec {
 impl fmt::Display for Statement {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Statement::Date(spec) => writeln!(f, "DATE {}", spec),
-            Statement::BDate(spec) => writeln!(f, "BDATE {}", spec),
-            Statement::From(Some(date)) => writeln!(f, "FROM {}", date),
+            Statement::Date(spec) => writeln!(f, "DATE {spec}"),
+            Statement::BDate(spec) => writeln!(f, "BDATE {spec}"),
+            Statement::From(Some(date)) => writeln!(f, "FROM {date}"),
             Statement::From(None) => writeln!(f, "FROM *"),
-            Statement::Until(Some(date)) => writeln!(f, "UNTIL {}", date),
+            Statement::Until(Some(date)) => writeln!(f, "UNTIL {date}"),
             Statement::Until(None) => writeln!(f, "UNTIL *"),
-            Statement::Except(date) => writeln!(f, "EXCEPT {}", date),
+            Statement::Except(date) => writeln!(f, "EXCEPT {date}"),
             Statement::Move {
                 from, to, to_time, ..
             } => match (to, to_time) {
                 (None, None) => unreachable!(),
-                (Some(to), None) => writeln!(f, "MOVE {} TO {}", from, to),
-                (None, Some(to_time)) => writeln!(f, "MOVE {} TO {}", from, to_time),
-                (Some(to), Some(to_time)) => writeln!(f, "MOVE {} TO {} {}", from, to, to_time),
+                (Some(to), None) => writeln!(f, "MOVE {from} TO {to}"),
+                (None, Some(to_time)) => writeln!(f, "MOVE {from} TO {to_time}"),
+                (Some(to), Some(to_time)) => writeln!(f, "MOVE {from} TO {to} {to_time}"),
             },
-            Statement::Remind(Some(delta)) => writeln!(f, "REMIND {}", delta),
+            Statement::Remind(Some(delta)) => writeln!(f, "REMIND {delta}"),
             Statement::Remind(None) => writeln!(f, "REMIND *"),
         }
     }
@@ -240,20 +240,20 @@ impl fmt::Display for Statement {
 impl fmt::Display for DoneDate {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.simplified() {
-            DoneDate::Date { root } => write!(f, "{}", root),
-            DoneDate::DateTime { root, root_time } => write!(f, "{} {}", root, root_time),
-            DoneDate::DateToDate { root, other } => write!(f, "{} -- {}", root, other),
+            DoneDate::Date { root } => write!(f, "{root}"),
+            DoneDate::DateTime { root, root_time } => write!(f, "{root} {root_time}"),
+            DoneDate::DateToDate { root, other } => write!(f, "{root} -- {other}"),
             DoneDate::DateTimeToTime {
                 root,
                 root_time,
                 other_time,
-            } => write!(f, "{} {} -- {}", root, root_time, other_time),
+            } => write!(f, "{root} {root_time} -- {other_time}"),
             DoneDate::DateTimeToDateTime {
                 root,
                 root_time,
                 other,
                 other_time,
-            } => write!(f, "{} {} -- {} {}", root, root_time, other, other_time),
+            } => write!(f, "{root} {root_time} -- {other} {other_time}"),
         }
     }
 }
@@ -264,9 +264,9 @@ impl fmt::Display for Done {
             DoneKind::Done => "DONE",
             DoneKind::Canceled => "CANCELED",
         };
-        write!(f, "{} [{}]", kind, self.done_at)?;
+        write!(f, "{kind} [{}]", self.done_at)?;
         if let Some(date) = &self.date {
-            write!(f, " {}", date)?;
+            write!(f, " {date}")?;
         }
         writeln!(f)
     }
@@ -276,10 +276,10 @@ impl fmt::Display for Task {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         writeln!(f, "TASK {}", self.title)?;
         for statement in &self.statements {
-            write!(f, "{}", statement)?;
+            write!(f, "{statement}")?;
         }
         for done in &self.done {
-            write!(f, "{}", done)?;
+            write!(f, "{done}")?;
         }
         format_desc(f, &self.desc)?;
         Ok(())
@@ -290,26 +290,13 @@ impl fmt::Display for Note {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         writeln!(f, "NOTE {}", self.title)?;
         for statement in &self.statements {
-            write!(f, "{}", statement)?;
+            write!(f, "{statement}")?;
         }
         format_desc(f, &self.desc)?;
         Ok(())
     }
 }
 
-impl fmt::Display for Command {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Command::Include(name) => writeln!(f, "INCLUDE {}", name),
-            Command::Timezone(name) => writeln!(f, "TIMEZONE {}", name),
-            Command::Capture => writeln!(f, "CAPTURE"),
-            Command::Task(task) => write!(f, "{}", task),
-            Command::Note(note) => write!(f, "{}", note),
-            Command::Log(log) => write!(f, "{}", log),
-        }
-    }
-}
-
 impl fmt::Display for Log {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         writeln!(f, "LOG {}", self.date)?;
@@ -318,6 +305,19 @@ impl fmt::Display for Log {
     }
 }
 
+impl fmt::Display for Command {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Command::Include(name) => writeln!(f, "INCLUDE {name}"),
+            Command::Timezone(name) => writeln!(f, "TIMEZONE {name}"),
+            Command::Capture => writeln!(f, "CAPTURE"),
+            Command::Task(task) => write!(f, "{task}"),
+            Command::Note(note) => write!(f, "{note}"),
+            Command::Log(log) => write!(f, "{log}"),
+        }
+    }
+}
+
 impl File {
     fn sort(commands: &mut Vec<&Command>) {
         // Order of commands in a file:
@@ -372,7 +372,7 @@ impl File {
             let curr = &commands[i];
             let next = commands.get(i + 1);
 
-            result.push_str(&format!("{}", curr));
+            result.push_str(&format!("{curr}"));
 
             match (curr, next) {
                 (Command::Include(_), Some(Command::Include(_))) => {}
diff --git a/src/main.rs b/src/main.rs
index c55f748..5d5922f 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,8 +3,6 @@
 #![warn(clippy::all)]
 #![warn(clippy::use_self)]
 
-// TODO Switch to new format syntax project-wide
-
 mod cli;
 mod error;
 mod eval;

From 4a2f72fabffee4b20bdd07e4069133734b1272cc Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sat, 15 Jan 2022 01:13:31 +0100
Subject: [PATCH 56/80] Remove unnecessary label messages

---
 src/eval/error.rs  | 28 +++++++++-------------------
 src/files/error.rs | 12 +++++-------
 2 files changed, 14 insertions(+), 26 deletions(-)

diff --git a/src/eval/error.rs b/src/eval/error.rs
index c78a131..d2cd7dd 100644
--- a/src/eval/error.rs
+++ b/src/eval/error.rs
@@ -102,9 +102,7 @@ impl<'a, F: Files<'a>> Eprint<'a, F> for Error<F::FileId> {
                 let prev_str = Self::fmt_date_time(*prev, *prev_time);
                 Diagnostic::error()
                     .with_message("Delta step resulted in invalid date")
-                    .with_labels(vec![
-                        Label::primary(*index, span).with_message("At this step")
-                    ])
+                    .with_labels(vec![Label::primary(*index, span)])
                     .with_notes(vec![
                         format!("Date before applying delta: {start_str}"),
                         format!("Date before applying this step: {prev_str}"),
@@ -117,9 +115,7 @@ impl<'a, F: Files<'a>> Eprint<'a, F> for Error<F::FileId> {
                 prev,
             } => Diagnostic::error()
                 .with_message("Time-based delta step applied to date without time")
-                .with_labels(vec![
-                    Label::primary(*index, span).with_message("At this step")
-                ])
+                .with_labels(vec![Label::primary(*index, span)])
                 .with_notes(vec![
                     format!("Date before applying delta: {start}"),
                     format!("Date before applying this step: {prev}"),
@@ -131,7 +127,7 @@ impl<'a, F: Files<'a>> Eprint<'a, F> for Error<F::FileId> {
                 to,
             } => Diagnostic::error()
                 .with_message("Repeat delta did not move forwards")
-                .with_labels(vec![Label::primary(*index, span).with_message("This delta")])
+                .with_labels(vec![Label::primary(*index, span)])
                 .with_notes(vec![format!("Moved from {from} to {to}")]),
             Error::RemindDidNotMoveBackwards {
                 index,
@@ -140,25 +136,21 @@ impl<'a, F: Files<'a>> Eprint<'a, F> for Error<F::FileId> {
                 to,
             } => Diagnostic::error()
                 .with_message("Remind delta did not move backwards")
-                .with_labels(vec![Label::primary(*index, span).with_message("This delta")])
+                .with_labels(vec![Label::primary(*index, span)])
                 .with_notes(vec![format!("Moved from {from} to {to}")]),
             Error::MoveWithoutSource { index, span } => Diagnostic::error()
                 .with_message("Tried to move nonexistent entry")
-                .with_labels(vec![Label::primary(*index, span).with_message("Here")]),
+                .with_labels(vec![Label::primary(*index, span)]),
             Error::TimedMoveWithoutTime { index, span } => Diagnostic::error()
                 .with_message("Tried to move un-timed entry to new time")
-                .with_labels(vec![Label::primary(*index, span).with_message("Here")]),
+                .with_labels(vec![Label::primary(*index, span)]),
             Error::DivByZero { index, span, date } => Diagnostic::error()
                 .with_message("Tried to divide by zero")
-                .with_labels(vec![
-                    Label::primary(*index, span).with_message("This expression")
-                ])
+                .with_labels(vec![Label::primary(*index, span)])
                 .with_notes(vec![format!("At date: {date}")]),
             Error::ModByZero { index, span, date } => Diagnostic::error()
                 .with_message("Tried to modulo by zero")
-                .with_labels(vec![
-                    Label::primary(*index, span).with_message("This expression")
-                ])
+                .with_labels(vec![Label::primary(*index, span)])
                 .with_notes(vec![format!("At date: {date}")]),
             Error::Easter {
                 index,
@@ -167,9 +159,7 @@ impl<'a, F: Files<'a>> Eprint<'a, F> for Error<F::FileId> {
                 msg,
             } => Diagnostic::error()
                 .with_message("Failed to calculate easter")
-                .with_labels(vec![
-                    Label::primary(*index, span).with_message("This expression")
-                ])
+                .with_labels(vec![Label::primary(*index, span)])
                 .with_notes(vec![format!("At date: {date}"), format!("Reason: {msg}")]),
         };
         Self::eprint_diagnostic(files, config, &diagnostic);
diff --git a/src/files/error.rs b/src/files/error.rs
index aabd582..f0ad33e 100644
--- a/src/files/error.rs
+++ b/src/files/error.rs
@@ -154,9 +154,7 @@ impl<'a> Eprint<'a, Files> for Error {
             } => {
                 let diagnostic = Diagnostic::error()
                     .with_message(format!("Could not resolve time zone {tz}"))
-                    .with_labels(vec![
-                        Label::primary(*file, span).with_message("Time zone defined here")
-                    ])
+                    .with_labels(vec![Label::primary(*file, span)])
                     .with_notes(vec![format!("{error}")]);
                 Self::eprint_diagnostic(files, config, &diagnostic);
             }
@@ -178,8 +176,8 @@ impl<'a> Eprint<'a, Files> for Error {
                 let diagnostic = Diagnostic::error()
                     .with_message(format!("Time zone conflict between {tz1} and {tz2}"))
                     .with_labels(vec![
-                        Label::primary(*file1, span1).with_message("Time zone defined here"),
-                        Label::primary(*file2, span2).with_message("Time zone defined here"),
+                        Label::primary(*file1, span1),
+                        Label::primary(*file2, span2),
                     ])
                     .with_notes(vec![
                         "All TIMEZONE commands must set the same time zone.".to_string()
@@ -213,8 +211,8 @@ impl<'a> Eprint<'a, Files> for Error {
                 let diagnostic = Diagnostic::error()
                     .with_message(format!("Duplicate log entries for {date}"))
                     .with_labels(vec![
-                        Label::primary(*file1, span1).with_message("Log defined here"),
-                        Label::primary(*file2, span2).with_message("Log defined here"),
+                        Label::primary(*file1, span1),
+                        Label::primary(*file2, span2),
                     ])
                     .with_notes(vec!["A day can have at most one LOG entry.".to_string()]);
                 Self::eprint_diagnostic(files, config, &diagnostic);

From 570142c0b68c5c27f6d830755c724345270b0499 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Thu, 17 Mar 2022 21:32:12 +0100
Subject: [PATCH 57/80] Fix weekday deltas

---
 src/eval/delta.rs | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/src/eval/delta.rs b/src/eval/delta.rs
index 0872d7b..364a226 100644
--- a/src/eval/delta.rs
+++ b/src/eval/delta.rs
@@ -284,6 +284,7 @@ impl<S: Copy> DeltaEval<S> {
             let days = rest + (amount - 1) * 7;
             self.curr += Duration::days(days.into());
         } else if amount < 0 {
+            let amount = -amount;
             let rest: i32 = weekday.until(curr_wd).into();
             let days = rest + (amount - 1) * 7;
             self.curr -= Duration::days(days.into());
@@ -566,6 +567,43 @@ mod tests {
         assert!(apply_d(Step::Minute(0), (2021, 7, 3)).is_err());
     }
 
+    #[test]
+    fn delta_weekday() {
+        use crate::files::primitives::Weekday::*;
+
+        test_d(Step::Weekday(-1, Friday), (2022, 3, 17), (2022, 3, 11));
+        test_d(Step::Weekday(-1, Saturday), (2022, 3, 17), (2022, 3, 12));
+        test_d(Step::Weekday(-1, Sunday), (2022, 3, 17), (2022, 3, 13));
+        test_d(Step::Weekday(-1, Monday), (2022, 3, 17), (2022, 3, 14));
+        test_d(Step::Weekday(-1, Tuesday), (2022, 3, 17), (2022, 3, 15));
+        test_d(Step::Weekday(-1, Wednesday), (2022, 3, 17), (2022, 3, 16));
+        test_d(Step::Weekday(-1, Thursday), (2022, 3, 17), (2022, 3, 17));
+
+        test_d(Step::Weekday(1, Thursday), (2022, 3, 17), (2022, 3, 17));
+        test_d(Step::Weekday(1, Friday), (2022, 3, 17), (2022, 3, 18));
+        test_d(Step::Weekday(1, Saturday), (2022, 3, 17), (2022, 3, 19));
+        test_d(Step::Weekday(1, Sunday), (2022, 3, 17), (2022, 3, 20));
+        test_d(Step::Weekday(1, Monday), (2022, 3, 17), (2022, 3, 21));
+        test_d(Step::Weekday(1, Tuesday), (2022, 3, 17), (2022, 3, 22));
+        test_d(Step::Weekday(1, Wednesday), (2022, 3, 17), (2022, 3, 23));
+
+        test_d(Step::Weekday(2, Thursday), (2022, 3, 17), (2022, 3, 24));
+        test_d(Step::Weekday(2, Friday), (2022, 3, 17), (2022, 3, 25));
+        test_d(Step::Weekday(2, Saturday), (2022, 3, 17), (2022, 3, 26));
+        test_d(Step::Weekday(2, Sunday), (2022, 3, 17), (2022, 3, 27));
+        test_d(Step::Weekday(2, Monday), (2022, 3, 17), (2022, 3, 28));
+        test_d(Step::Weekday(2, Tuesday), (2022, 3, 17), (2022, 3, 29));
+        test_d(Step::Weekday(2, Wednesday), (2022, 3, 17), (2022, 3, 30));
+
+        test_d(Step::Weekday(3, Thursday), (2022, 3, 17), (2022, 3, 31));
+        test_d(Step::Weekday(3, Friday), (2022, 3, 17), (2022, 4, 1));
+        test_d(Step::Weekday(3, Saturday), (2022, 3, 17), (2022, 4, 2));
+        test_d(Step::Weekday(3, Sunday), (2022, 3, 17), (2022, 4, 3));
+        test_d(Step::Weekday(3, Monday), (2022, 3, 17), (2022, 4, 4));
+        test_d(Step::Weekday(3, Tuesday), (2022, 3, 17), (2022, 4, 5));
+        test_d(Step::Weekday(3, Wednesday), (2022, 3, 17), (2022, 4, 6));
+    }
+
     #[test]
     fn delta_time() {
         test_dt(

From 6b82a2cfd2592aeaf3602f6644770cad99d79094 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Fri, 18 Mar 2022 03:09:27 +0100
Subject: [PATCH 58/80] Update changelog

---
 CHANGELOG.md | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 74be72d..691ed70 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,11 +9,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - `CAPTURE` command and `today new` CLI command
 - `REMIND` statement
 - `CANCEL` statement for tasks
-- One-letter aliases for
-    - `today show`: `today s`
-    - `today log`: `today l`
-    - `today done`: `today d`
-    - `today cancel`: `today c`
+- One-letter aliases for `show`, `log`, `done` and `cancel` CLI commands
 - `MOVE` can now move entries to a different time
 - `--date` now accepts expressions like `today-3d`
 - In `--range` and `--date`, `t` can be used as abbreviation for `today`
@@ -34,6 +30,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 ### Fixed
 - Alignment in output
 - Respect `TZDIR` environment variable
+- Negative weekday deltas
 
 ## 0.1.0 - 2021-12-20
 

From a236e8d953b222ee61797bc95032778581e8ae4f Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Fri, 18 Mar 2022 03:20:40 +0100
Subject: [PATCH 59/80] Update dependencies

---
 Cargo.lock | 135 +++++++++++++++++++++--------------------------------
 Cargo.toml |   4 +-
 2 files changed, 56 insertions(+), 83 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ceb2ab1..b9254b2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -24,9 +24,9 @@ dependencies = [
 
 [[package]]
 name = "autocfg"
-version = "1.0.1"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
 [[package]]
 name = "bitflags"
@@ -69,9 +69,9 @@ checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
 
 [[package]]
 name = "cc"
-version = "1.0.72"
+version = "1.0.73"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22a9137b95ea06864e018375b72adfb7db6e6f68cfc8df5a04d00288050485ee"
+checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
 
 [[package]]
 name = "cfg-if"
@@ -170,9 +170,9 @@ dependencies = [
 
 [[package]]
 name = "dirs-sys"
-version = "0.3.6"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03d86534ed367a67548dc68113a0f5db55432fdfbb6e6f9d77704397d95d5780"
+checksum = "1b1d1d91c932ef41c0f2663aa8b0ca0342d444d842c06914aa0a7e352d0bada6"
 dependencies = [
  "libc",
  "redox_users",
@@ -212,6 +212,15 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
 
+[[package]]
+name = "fastrand"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3fcf0cee53519c866c09b5de1f6c56ff9d647101f81c1964fa632e148896cdf"
+dependencies = [
+ "instant",
+]
+
 [[package]]
 name = "generic-array"
 version = "0.12.4"
@@ -223,9 +232,9 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.3"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
+checksum = "d39cd93900197114fa1fcb7ae84ca742095eed9442088988ae74fa744e930e77"
 dependencies = [
  "cfg-if 1.0.0",
  "libc",
@@ -250,6 +259,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "instant"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+dependencies = [
+ "cfg-if 1.0.0",
+]
+
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
@@ -258,9 +276,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
 [[package]]
 name = "libc"
-version = "0.2.112"
+version = "0.2.120"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b03d17f364a3a042d5e5d46b053bbbf82c92c9430c592dd4c064dc6ee997125"
+checksum = "ad5c14e80759d0939d013e6ca49930e59fc53dd8e5009132f76240c179380c09"
 
 [[package]]
 name = "log"
@@ -363,12 +381,6 @@ dependencies = [
  "sha-1",
 ]
 
-[[package]]
-name = "ppv-lite86"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
-
 [[package]]
 name = "proc-macro-error"
 version = "1.0.4"
@@ -395,9 +407,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.34"
+version = "1.0.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f84e92c0f7c9d58328b85a78557813e4bd845130db68d7184635344399423b1"
+checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
 dependencies = [
  "unicode-xid",
 ]
@@ -413,70 +425,31 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.10"
+version = "1.0.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38bc8cc6a5f2e3655e0899c1b848643b2562f853f114bfec7be120678e3ace05"
+checksum = "b4af2ec4714533fcdf07e886f17025ace8b997b9ce51204ee69b6da831c3da57"
 dependencies = [
  "proc-macro2",
 ]
 
-[[package]]
-name = "rand"
-version = "0.8.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
-dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
- "rand_hc",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
-dependencies = [
- "ppv-lite86",
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
-dependencies = [
- "getrandom",
-]
-
-[[package]]
-name = "rand_hc"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7"
-dependencies = [
- "rand_core",
-]
-
 [[package]]
 name = "redox_syscall"
-version = "0.2.10"
+version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8383f39639269cde97d255a32bdb68c047337295414940c68bdd30c2e13203ff"
+checksum = "8380fe0152551244f0747b1bf41737e0f8a74f97a14ccefd1148187271634f3c"
 dependencies = [
  "bitflags",
 ]
 
 [[package]]
 name = "redox_users"
-version = "0.4.0"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "528532f3d801c87aec9def2add9ca802fe569e44a544afe633765267840abe64"
+checksum = "7776223e2696f1aa4c6b0170e83212f47296a00424305117d013dfe86fb0fe55"
 dependencies = [
  "getrandom",
  "redox_syscall",
+ "thiserror",
 ]
 
 [[package]]
@@ -533,9 +506,9 @@ checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
 
 [[package]]
 name = "structopt"
-version = "0.3.25"
+version = "0.3.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40b9788f4202aa75c240ecc9c15c65185e6a39ccdeb0fd5d008b98825464c87c"
+checksum = "0c6b5c64445ba8094a6ab0c3cd2ad323e07171012d9c98b0b15651daf1787a10"
 dependencies = [
  "clap",
  "lazy_static",
@@ -557,9 +530,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "1.0.82"
+version = "1.0.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8daf5dd0bb60cbd4137b1b587d2fc0ae729bc07cf01cd70b36a1ed5ade3b9d59"
+checksum = "ea297be220d52398dcc07ce15a209fce436d361735ac1db700cab3b6cdfb9f54"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -568,13 +541,13 @@ dependencies = [
 
 [[package]]
 name = "tempfile"
-version = "3.2.0"
+version = "3.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22"
+checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
 dependencies = [
  "cfg-if 1.0.0",
+ "fastrand",
  "libc",
- "rand",
  "redox_syscall",
  "remove_dir_all",
  "winapi",
@@ -582,9 +555,9 @@ dependencies = [
 
 [[package]]
 name = "termcolor"
-version = "1.1.2"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dfed899f0eb03f32ee8c6a0aabdb8a7949659e3466561fc0adf54e26d88c5f4"
+checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
 dependencies = [
  "winapi-util",
 ]
@@ -650,9 +623,9 @@ dependencies = [
 
 [[package]]
 name = "typenum"
-version = "1.14.0"
+version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b63708a265f51345575b27fe43f9500ad611579e764c79edbc2037b1121959ec"
+checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
 
 [[package]]
 name = "tzfile"
@@ -671,9 +644,9 @@ checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c"
 
 [[package]]
 name = "unicode-segmentation"
-version = "1.8.0"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8895849a949e7845e06bd6dc1aa51731a103c42707010a5b591c0038fb73385b"
+checksum = "7e8820f5d777f6224dc4be3632222971ac30164d4a258d595640799554ebfd99"
 
 [[package]]
 name = "unicode-width"
@@ -701,9 +674,9 @@ checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
 
 [[package]]
 name = "version_check"
-version = "0.9.3"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
 
 [[package]]
 name = "wasi"
@@ -713,9 +686,9 @@ checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
 
 [[package]]
 name = "which"
-version = "4.2.2"
+version = "4.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea187a8ef279bc014ec368c27a920da2024d2a711109bfbe3440585d5cf27ad9"
+checksum = "2a5a7e487e921cf220206864a94a89b6c6905bfc19f1057fa26a4cb360e5c1d2"
 dependencies = [
  "either",
  "lazy_static",
diff --git a/Cargo.toml b/Cargo.toml
index 4ee590e..54e6aeb 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,7 @@ edit = "0.1.3"
 pest = "2.1.3"
 pest_derive = "2.1.0"
 promptly = "0.3.0"
-structopt = "0.3.25"
-termcolor = "1.1.2"
+structopt = "0.3.26"
+termcolor = "1.1.3"
 thiserror = "1.0.30"
 tzfile = { git = "https://github.com/Garmelon/tzfile.git", branch = "tzdir" }

From 29e4e786eaded9541bdbdd67351f06358428768f Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Fri, 18 Mar 2022 03:21:02 +0100
Subject: [PATCH 60/80] Release version 0.2.0

---
 CHANGELOG.md | 2 ++
 Cargo.lock   | 2 +-
 Cargo.toml   | 2 +-
 3 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 691ed70..18b3029 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## Unreleased
 
+## 0.2.0 - 2022-03-18
+
 ### Added
 - `LOG` command and `today log` CLI command
 - `CAPTURE` command and `today new` CLI command
diff --git a/Cargo.lock b/Cargo.lock
index b9254b2..a98d22d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -604,7 +604,7 @@ dependencies = [
 
 [[package]]
 name = "today"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "chrono",
  "codespan-reporting",
diff --git a/Cargo.toml b/Cargo.toml
index 54e6aeb..a207198 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "today"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 
 [dependencies]

From f231fee50874a406f0790ecc885699daae80aa64 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Mon, 2 May 2022 11:37:09 +0200
Subject: [PATCH 61/80] Document Done fields

---
 src/files/commands.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/files/commands.rs b/src/files/commands.rs
index a53aa50..483fd7a 100644
--- a/src/files/commands.rs
+++ b/src/files/commands.rs
@@ -346,7 +346,9 @@ pub enum DoneKind {
 #[derive(Debug)]
 pub struct Done {
     pub kind: DoneKind,
+    /// The date of the task the DONE refers to.
     pub date: Option<DoneDate>,
+    /// When the task was actually completed.
     pub done_at: NaiveDate,
 }
 

From 74433eccbe6d3ec0a32256280931b42d400fce02 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Mon, 2 May 2022 11:49:57 +0200
Subject: [PATCH 62/80] Highlight current birthdays

---
 CHANGELOG.md           |  3 +++
 src/cli/layout/line.rs | 40 +++++++++++++++++++++++++---------------
 src/cli/print.rs       | 11 ++++++++++-
 src/cli/util.rs        |  4 ++++
 4 files changed, 42 insertions(+), 16 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 18b3029..2c219af 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## Unreleased
 
+### Changed
+- Birthdays for current day are now highlighted
+
 ## 0.2.0 - 2022-03-18
 
 ### Added
diff --git a/src/cli/layout/line.rs b/src/cli/layout/line.rs
index fffaab6..a63d45e 100644
--- a/src/cli/layout/line.rs
+++ b/src/cli/layout/line.rs
@@ -56,7 +56,7 @@ pub enum Times {
     FromTo(Time, Time),
 }
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum LineKind {
     Task,
     Done,
@@ -79,6 +79,7 @@ pub enum LineEntry {
     Entry {
         number: Option<usize>,
         spans: Vec<Option<SpanSegment>>,
+        today: bool,
         time: Times,
         kind: LineKind,
         text: String,
@@ -121,17 +122,18 @@ impl LineLayout {
         self.step_spans();
 
         for day in layout.range.days() {
+            let today = day == layout.today;
             let spans = self.spans_for_line();
             self.line(LineEntry::Day {
                 spans,
                 date: day,
-                today: day == layout.today,
+                today,
                 has_log: files.log(day).is_some(),
             });
 
             let layout_entries = layout.days.get(&day).expect("got nonexisting day");
             for layout_entry in layout_entries {
-                self.render_layout_entry(entries, layout_entry);
+                self.render_layout_entry(entries, layout_entry, today);
             }
         }
     }
@@ -157,11 +159,11 @@ impl LineLayout {
             .ok_or(Error::NoSuchEntry(number))
     }
 
-    fn render_layout_entry(&mut self, entries: &[Entry], l_entry: &DayEntry) {
+    fn render_layout_entry(&mut self, entries: &[Entry], l_entry: &DayEntry, today: bool) {
         match l_entry {
             DayEntry::End(i) => {
                 self.stop_span(*i);
-                self.line_entry(entries, *i, Times::Untimed, None);
+                self.line_entry(entries, *i, today, Times::Untimed, None);
             }
             DayEntry::Now(t) => self.line(LineEntry::Now {
                 spans: self.spans_for_line(),
@@ -169,17 +171,17 @@ impl LineLayout {
             }),
             DayEntry::TimedEnd(i, t) => {
                 self.stop_span(*i);
-                self.line_entry(entries, *i, Times::At(*t), None);
+                self.line_entry(entries, *i, today, Times::At(*t), None);
             }
             DayEntry::TimedAt(i, t, t2) => {
                 let time = t2
                     .map(|t2| Times::FromTo(*t, t2))
                     .unwrap_or_else(|| Times::At(*t));
-                self.line_entry(entries, *i, time, None);
+                self.line_entry(entries, *i, today, time, None);
             }
             DayEntry::TimedStart(i, t) => {
                 self.start_span(*i);
-                self.line_entry(entries, *i, Times::At(*t), None);
+                self.line_entry(entries, *i, today, Times::At(*t), None);
             }
             DayEntry::ReminderSince(i, d) => {
                 let extra = if *d == 1 {
@@ -187,22 +189,22 @@ impl LineLayout {
                 } else {
                     format!("{d} days ago")
                 };
-                self.line_entry(entries, *i, Times::Untimed, Some(extra));
+                self.line_entry(entries, *i, today, Times::Untimed, Some(extra));
             }
             DayEntry::At(i) => {
-                self.line_entry(entries, *i, Times::Untimed, None);
+                self.line_entry(entries, *i, today, Times::Untimed, None);
             }
             DayEntry::ReminderWhile(i, d) => {
                 let plural = if *d == 1 { "" } else { "s" };
                 let extra = format!("{d} day{plural} left");
-                self.line_entry(entries, *i, Times::Untimed, Some(extra));
+                self.line_entry(entries, *i, today, Times::Untimed, Some(extra));
             }
             DayEntry::Undated(i) => {
-                self.line_entry(entries, *i, Times::Untimed, None);
+                self.line_entry(entries, *i, today, Times::Untimed, None);
             }
             DayEntry::Start(i) => {
                 self.start_span(*i);
-                self.line_entry(entries, *i, Times::Untimed, None);
+                self.line_entry(entries, *i, today, Times::Untimed, None);
             }
             DayEntry::ReminderUntil(i, d) => {
                 let extra = if *d == 1 {
@@ -210,7 +212,7 @@ impl LineLayout {
                 } else {
                     format!("in {d} days")
                 };
-                self.line_entry(entries, *i, Times::Untimed, Some(extra));
+                self.line_entry(entries, *i, today, Times::Untimed, Some(extra));
             }
         }
     }
@@ -277,7 +279,14 @@ impl LineLayout {
         self.step_spans();
     }
 
-    fn line_entry(&mut self, entries: &[Entry], index: usize, time: Times, extra: Option<String>) {
+    fn line_entry(
+        &mut self,
+        entries: &[Entry],
+        index: usize,
+        today: bool,
+        time: Times,
+        extra: Option<String>,
+    ) {
         let entry = &entries[index];
 
         let number = match self.numbers.get(&index) {
@@ -292,6 +301,7 @@ impl LineLayout {
         self.line(LineEntry::Entry {
             number: Some(number),
             spans: self.spans_for_line(),
+            today,
             time,
             kind: Self::entry_kind(entry),
             text: Self::entry_title(entry),
diff --git a/src/cli/print.rs b/src/cli/print.rs
index 1cb8caf..471cd85 100644
--- a/src/cli/print.rs
+++ b/src/cli/print.rs
@@ -35,12 +35,14 @@ impl ShowLines {
             LineEntry::Entry {
                 number,
                 spans,
+                today,
                 time,
                 kind,
                 text,
                 has_desc,
                 extra,
-            } => self.display_line_entry(*number, spans, *time, *kind, text, *has_desc, extra),
+            } => self
+                .display_line_entry(*number, spans, *today, *time, *kind, text, *has_desc, extra),
         }
     }
 
@@ -99,6 +101,7 @@ impl ShowLines {
         &mut self,
         number: Option<usize>,
         spans: &[Option<SpanSegment>],
+        today: bool,
         time: Times,
         kind: LineKind,
         text: &str,
@@ -110,6 +113,12 @@ impl ShowLines {
             None => "".to_string(),
         };
 
+        let text = if kind == LineKind::Birthday && today {
+            util::display_current_birthday_text(text)
+        } else {
+            text.into()
+        };
+
         self.push(&format!(
             "{:>nw$} {} {}{} {}{}{}\n",
             num.bright_black(),
diff --git a/src/cli/util.rs b/src/cli/util.rs
index 5d1c3d5..e862088 100644
--- a/src/cli/util.rs
+++ b/src/cli/util.rs
@@ -13,6 +13,10 @@ pub fn display_kind(kind: LineKind) -> ColoredString {
     }
 }
 
+pub fn display_current_birthday_text(text: &str) -> ColoredString {
+    text.yellow()
+}
+
 pub fn edit(input: &str) -> Result<String> {
     edit::edit(input).map_err(Error::EditingIo)
 }

From f42cf01a158eb2af9f1682312e2f838f949d1340 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Mon, 2 May 2022 12:49:03 +0200
Subject: [PATCH 63/80] Fix cli arg anchoring

---
 CHANGELOG.md           |  3 +++
 src/files/cli.rs       | 31 +++++++++++++++++++++++++------
 src/files/grammar.pest |  9 +++++++--
 3 files changed, 35 insertions(+), 8 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2c219af..9edef0d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 ### Changed
 - Birthdays for current day are now highlighted
 
+### Fixed
+- `--date` accepting incomplete expressions
+
 ## 0.2.0 - 2022-03-18
 
 ### Added
diff --git a/src/files/cli.rs b/src/files/cli.rs
index 6f72ca9..ddd804f 100644
--- a/src/files/cli.rs
+++ b/src/files/cli.rs
@@ -57,11 +57,17 @@ fn parse_cli_date(p: Pair<'_, Rule>) -> Result<CliDate> {
     Ok(CliDate { datum, delta })
 }
 
+fn parse_cli_date_arg(p: Pair<'_, Rule>) -> Result<CliDate> {
+    assert_eq!(p.as_rule(), Rule::cli_date_arg);
+    let p = p.into_inner().next().unwrap();
+    parse_cli_date(p)
+}
+
 impl FromStr for CliDate {
     type Err = ParseError<()>;
 
     fn from_str(s: &str) -> result::Result<Self, ParseError<()>> {
-        from_str_via_parse(s, Rule::cli_date, parse_cli_date)
+        from_str_via_parse(s, Rule::cli_date_arg, parse_cli_date_arg)
     }
 }
 
@@ -81,11 +87,17 @@ fn parse_cli_ident(p: Pair<'_, Rule>) -> Result<CliIdent> {
     })
 }
 
+fn parse_cli_ident_arg(p: Pair<'_, Rule>) -> Result<CliIdent> {
+    assert_eq!(p.as_rule(), Rule::cli_ident_arg);
+    let p = p.into_inner().next().unwrap();
+    parse_cli_ident(p)
+}
+
 impl FromStr for CliIdent {
     type Err = ParseError<()>;
 
     fn from_str(s: &str) -> result::Result<Self, ParseError<()>> {
-        from_str_via_parse(s, Rule::cli_ident, parse_cli_ident)
+        from_str_via_parse(s, Rule::cli_ident_arg, parse_cli_ident_arg)
     }
 }
 
@@ -135,11 +147,12 @@ fn parse_cli_range(p: Pair<'_, Rule>) -> Result<CliRange> {
 
     let (start, start_delta) = parse_cli_range_start(p.next().unwrap())?;
     let (end, end_delta) = match p.next() {
-        // For some reason, the EOI gets captured but the SOI doesn't.
-        Some(p) if p.as_rule() != Rule::EOI => parse_cli_range_end(p)?,
-        _ => (None, None),
+        Some(p) => parse_cli_range_end(p)?,
+        None => (None, None),
     };
 
+    assert_eq!(p.next(), None);
+
     Ok(CliRange {
         start,
         start_delta,
@@ -148,11 +161,17 @@ fn parse_cli_range(p: Pair<'_, Rule>) -> Result<CliRange> {
     })
 }
 
+fn parse_cli_range_arg(p: Pair<'_, Rule>) -> Result<CliRange> {
+    assert_eq!(p.as_rule(), Rule::cli_range_arg);
+    let p = p.into_inner().next().unwrap();
+    parse_cli_range(p)
+}
+
 impl FromStr for CliRange {
     type Err = ParseError<()>;
 
     fn from_str(s: &str) -> result::Result<Self, ParseError<()>> {
-        from_str_via_parse(s, Rule::cli_range, parse_cli_range)
+        from_str_via_parse(s, Rule::cli_range_arg, parse_cli_range_arg)
     }
 }
 
diff --git a/src/files/grammar.pest b/src/files/grammar.pest
index 894a695..278c4b6 100644
--- a/src/files/grammar.pest
+++ b/src/files/grammar.pest
@@ -152,8 +152,13 @@ file = ${ SOI ~ (empty_line* ~ command)* ~ empty_line* ~ WHITESPACE* ~ EOI }
 today = { "today" | "t" }
 cli_datum = { datum | today }
 cli_date = { cli_datum ~ delta? }
-cli_ident = { SOI ~ (cli_date | number) ~ EOI }
+cli_ident = { cli_date | number }
 cli_range_start = { cli_datum ~ delta? }
 cli_range_end = { cli_datum ~ delta? | delta }
-cli_range = { SOI ~ cli_range_start ~ ("--" ~ cli_range_end)? ~ EOI }
+cli_range = { cli_range_start ~ ("--" ~ cli_range_end)? }
+
+cli_date_arg = { SOI ~ cli_date ~ EOI }
+cli_ident_arg = { SOI ~ cli_ident ~ EOI }
+cli_range_arg = { SOI ~ cli_range ~ EOI }
+
 cli_command = ${ SOI ~ empty_line* ~ command ~ empty_line* ~ WHITESPACE* ~ EOI }

From 972a590ba9285251add86ba8d63b2d79f16cbeb3 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Mon, 2 May 2022 12:57:21 +0200
Subject: [PATCH 64/80] Satisfy clippy

---
 src/cli/layout/day.rs  | 4 ++--
 src/cli/layout/line.rs | 4 +---
 src/files/format.rs    | 2 +-
 3 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/cli/layout/day.rs b/src/cli/layout/day.rs
index e0f2d17..044269c 100644
--- a/src/cli/layout/day.rs
+++ b/src/cli/layout/day.rs
@@ -189,7 +189,7 @@ impl DayLayout {
         }
     }
 
-    fn sort_entries(entries: &mut Vec<(usize, &Entry)>) {
+    fn sort_entries(entries: &mut [(usize, &Entry)]) {
         // Entries should be sorted by these factors, in descending order of
         // significance:
         // 1. Their start date, if any
@@ -219,7 +219,7 @@ impl DayLayout {
         entries.sort_by_key(|(_, e)| e.dates.map(|d| d.sorted().root_with_time()));
     }
 
-    fn sort_day(day: &mut Vec<DayEntry>) {
+    fn sort_day(day: &mut [DayEntry]) {
         // In a day, entries should be sorted into these categories:
         // 1. Untimed entries that end at the current day
         // 2. Timed entries, based on
diff --git a/src/cli/layout/line.rs b/src/cli/layout/line.rs
index a63d45e..42cd871 100644
--- a/src/cli/layout/line.rs
+++ b/src/cli/layout/line.rs
@@ -174,9 +174,7 @@ impl LineLayout {
                 self.line_entry(entries, *i, today, Times::At(*t), None);
             }
             DayEntry::TimedAt(i, t, t2) => {
-                let time = t2
-                    .map(|t2| Times::FromTo(*t, t2))
-                    .unwrap_or_else(|| Times::At(*t));
+                let time = t2.map(|t2| Times::FromTo(*t, t2)).unwrap_or(Times::At(*t));
                 self.line_entry(entries, *i, today, time, None);
             }
             DayEntry::TimedStart(i, t) => {
diff --git a/src/files/format.rs b/src/files/format.rs
index 5f2ec3f..caa5d9b 100644
--- a/src/files/format.rs
+++ b/src/files/format.rs
@@ -319,7 +319,7 @@ impl fmt::Display for Command {
 }
 
 impl File {
-    fn sort(commands: &mut Vec<&Command>) {
+    fn sort(commands: &mut [&Command]) {
         // Order of commands in a file:
         // 1. Imports, sorted alphabetically
         // 2. Time zone(s)

From a63529b972160b13c605c35c8ccb437dff4e2cdd Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Wed, 4 May 2022 11:17:18 +0200
Subject: [PATCH 65/80] Increase default --range by one day

---
 CHANGELOG.md | 1 +
 src/cli.rs   | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9edef0d..33ddeb8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ### Changed
 - Birthdays for current day are now highlighted
+- Default value for `--range` argument
 
 ### Fixed
 - `--date` accepting incomplete expressions
diff --git a/src/cli.rs b/src/cli.rs
index 2636f5b..401e3a3 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -33,7 +33,7 @@ pub struct Opt {
     #[structopt(short, long, default_value = "t")]
     date: String,
     /// Range of days to focus on
-    #[structopt(short, long, default_value = "t-2d--t+13d")]
+    #[structopt(short, long, default_value = "t-2d--t+2w")]
     range: String,
     #[structopt(subcommand)]
     command: Option<Command>,

From bc0d2481c80393809f68209e26fee47bbeae33a5 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Thu, 19 May 2022 13:56:09 +0200
Subject: [PATCH 66/80] Switch from structopt to clap

---
 Cargo.lock | 125 +++++++++++++++++++++++++++--------------------------
 Cargo.toml |   2 +-
 src/cli.rs |  45 ++++++++++---------
 3 files changed, 86 insertions(+), 86 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a98d22d..47f1e1a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,15 +2,6 @@
 # It is not intended for manual editing.
 version = 3
 
-[[package]]
-name = "ansi_term"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
-dependencies = [
- "winapi",
-]
-
 [[package]]
 name = "atty"
 version = "0.2.14"
@@ -100,17 +91,41 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "2.34.0"
+version = "3.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"
+checksum = "d2dbdf4bdacb33466e854ce889eee8dfd5729abf7ccd7664d0a2d60cd384440b"
 dependencies = [
- "ansi_term",
  "atty",
  "bitflags",
+ "clap_derive",
+ "clap_lex",
+ "indexmap",
+ "lazy_static",
  "strsim",
+ "termcolor",
  "textwrap",
- "unicode-width",
- "vec_map",
+]
+
+[[package]]
+name = "clap_derive"
+version = "3.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25320346e922cffe59c0bbc5410c8d8784509efb321488971081313cb1e1a33c"
+dependencies = [
+ "heck",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a37c35f1112dad5e6e0b1adaff798507497a18fceeb30cceb3bae7d1427b9213"
+dependencies = [
+ "os_str_bytes",
 ]
 
 [[package]]
@@ -242,13 +257,16 @@ dependencies = [
 ]
 
 [[package]]
-name = "heck"
-version = "0.3.3"
+name = "hashbrown"
+version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d621efb26863f0e9924c6ac577e8275e5e6b77455db64ffa6c65c904e9e132c"
-dependencies = [
- "unicode-segmentation",
-]
+checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
+
+[[package]]
+name = "heck"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
 
 [[package]]
 name = "hermit-abi"
@@ -259,6 +277,16 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "indexmap"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f647032dfaa1f8b6dc29bd3edb7bbef4861b8b8007ebb118d6db284fd59f6ee"
+dependencies = [
+ "autocfg",
+ "hashbrown",
+]
+
 [[package]]
 name = "instant"
 version = "0.1.12"
@@ -338,6 +366,12 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"
 
+[[package]]
+name = "os_str_bytes"
+version = "6.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "029d8d0b2f198229de29dca79676f2738ff952edf3fde542eb8bf94d8c21b435"
+
 [[package]]
 name = "pest"
 version = "2.1.3"
@@ -500,33 +534,9 @@ dependencies = [
 
 [[package]]
 name = "strsim"
-version = "0.8.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
-
-[[package]]
-name = "structopt"
-version = "0.3.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c6b5c64445ba8094a6ab0c3cd2ad323e07171012d9c98b0b15651daf1787a10"
-dependencies = [
- "clap",
- "lazy_static",
- "structopt-derive",
-]
-
-[[package]]
-name = "structopt-derive"
-version = "0.4.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcb5ae327f9cc13b68763b5749770cb9e048a99bd9dfdfa58d0cf05d5f64afe0"
-dependencies = [
- "heck",
- "proc-macro-error",
- "proc-macro2",
- "quote",
- "syn",
-]
+checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
 
 [[package]]
 name = "syn"
@@ -564,27 +574,24 @@ dependencies = [
 
 [[package]]
 name = "textwrap"
-version = "0.11.0"
+version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
-dependencies = [
- "unicode-width",
-]
+checksum = "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb"
 
 [[package]]
 name = "thiserror"
-version = "1.0.30"
+version = "1.0.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "854babe52e4df1653706b98fcfc05843010039b406875930a70e4d9644e5c417"
+checksum = "bd829fe32373d27f76265620b5309d0340cb8550f523c1dda251d6298069069a"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.30"
+version = "1.0.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa32fd3f627f367fe16f893e2597ae3c05020f8bba2666a4e6ea73d377e5714b"
+checksum = "0396bc89e626244658bef819e22d0cc459e795a5ebe878e6ec336d1674a8d79a"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -607,6 +614,7 @@ name = "today"
 version = "0.2.0"
 dependencies = [
  "chrono",
+ "clap",
  "codespan-reporting",
  "colored",
  "computus",
@@ -615,7 +623,6 @@ dependencies = [
  "pest",
  "pest_derive",
  "promptly",
- "structopt",
  "termcolor",
  "thiserror",
  "tzfile",
@@ -666,12 +673,6 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "936e4b492acfd135421d8dca4b1aa80a7bfc26e702ef3af710e0752684df5372"
 
-[[package]]
-name = "vec_map"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
-
 [[package]]
 name = "version_check"
 version = "0.9.4"
diff --git a/Cargo.toml b/Cargo.toml
index a207198..31dd4b0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,6 +5,7 @@ edition = "2021"
 
 [dependencies]
 chrono = "0.4.19"
+clap = { version = "3.1.18", features = ["derive"] }
 codespan-reporting = "0.11.1"
 colored = "2.0.0"
 computus = "1.0.0"
@@ -13,7 +14,6 @@ edit = "0.1.3"
 pest = "2.1.3"
 pest_derive = "2.1.0"
 promptly = "0.3.0"
-structopt = "0.3.26"
 termcolor = "1.1.3"
 thiserror = "1.0.30"
 tzfile = { git = "https://github.com/Garmelon/tzfile.git", branch = "tzdir" }
diff --git a/src/cli.rs b/src/cli.rs
index 401e3a3..1189420 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -3,9 +3,9 @@ use std::str::FromStr;
 use std::{process, result};
 
 use chrono::{NaiveDate, NaiveDateTime};
+use clap::Parser;
 use codespan_reporting::files::SimpleFile;
 use directories::ProjectDirs;
-use structopt::StructOpt;
 
 use crate::eval::{self, DateRange, Entry, EntryMode};
 use crate::files::cli::{CliDate, CliIdent, CliRange};
@@ -24,77 +24,76 @@ mod print;
 mod show;
 mod util;
 
-#[derive(Debug, StructOpt)]
+#[derive(Debug, clap::Parser)]
 pub struct Opt {
     /// File to load
-    #[structopt(short, long, parse(from_os_str))]
+    #[clap(short, long)]
     file: Option<PathBuf>,
     /// Overwrite the current date
-    #[structopt(short, long, default_value = "t")]
+    #[clap(short, long, default_value = "t")]
     date: String,
     /// Range of days to focus on
-    #[structopt(short, long, default_value = "t-2d--t+2w")]
+    #[clap(short, long, default_value = "t-2d--t+2w")]
     range: String,
-    #[structopt(subcommand)]
+    #[clap(subcommand)]
     command: Option<Command>,
 }
 
-#[derive(Debug, StructOpt)]
+#[derive(Debug, clap::Subcommand)]
 pub enum Command {
     /// Shows individual entries in detail
-    #[structopt(alias = "s")]
+    #[clap(alias = "s")]
     Show {
         /// Entries and days to show
-        #[structopt(required = true)]
+        #[clap(required = true)]
         identifiers: Vec<String>,
     },
     /// Create a new entry based on a template
-    #[structopt(alias = "n")]
+    #[clap(alias = "n")]
     New {
-        #[structopt(subcommand)]
+        #[clap(subcommand)]
         template: Template,
     },
     /// Marks one or more entries as done
-    #[structopt(alias = "d")]
+    #[clap(alias = "d")]
     Done {
         /// Entries to mark as done
-        #[structopt(required = true)]
+        #[clap(required = true)]
         entries: Vec<usize>,
     },
     /// Marks one or more entries as canceled
-    #[structopt(alias = "c")]
+    #[clap(alias = "c")]
     Cancel {
         /// Entries to mark as done
-        #[structopt(required = true)]
+        #[clap(required = true)]
         entries: Vec<usize>,
     },
     /// Edits or creates a log entry
-    #[structopt(alias = "l")]
+    #[clap(alias = "l")]
     Log {
-        #[structopt(default_value = "t")]
+        #[clap(default_value = "t")]
         date: String,
     },
     /// Reformats all loaded files
     Fmt,
 }
 
-// TODO Add templates for tasks and notes
-#[derive(Debug, StructOpt)]
+#[derive(Debug, clap::Subcommand)]
 pub enum Template {
     /// Adds a task
-    #[structopt(alias = "t")]
+    #[clap(alias = "t")]
     Task {
         /// If specified, the task is dated to this date
         date: Option<String>,
     },
     /// Adds a note
-    #[structopt(alias = "n")]
+    #[clap(alias = "n")]
     Note {
         /// If specified, the note is dated to this date
         date: Option<String>,
     },
     /// Adds an undated task marked as done today
-    #[structopt(alias = "d")]
+    #[clap(alias = "d")]
     Done,
 }
 
@@ -222,7 +221,7 @@ fn run_with_files(opt: Opt, files: &mut Files) -> Result<()> {
 }
 
 pub fn run() {
-    let opt = Opt::from_args();
+    let opt = Opt::parse();
 
     let mut files = Files::new();
     if let Err(e) = load_files(&opt, &mut files) {

From aaa3537e90523bdc5798ee4c98be5a3052ebee91 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Thu, 19 May 2022 14:00:33 +0200
Subject: [PATCH 67/80] Update dependencies

---
 Cargo.lock | 64 +++++++++++++++++++++++++++---------------------------
 Cargo.toml |  2 +-
 2 files changed, 33 insertions(+), 33 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 47f1e1a..6713148 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -247,9 +247,9 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d39cd93900197114fa1fcb7ae84ca742095eed9442088988ae74fa744e930e77"
+checksum = "9be70c98951c83b8d2f8f60d7065fa6d5146873094452a1008da8c2f1e4205ad"
 dependencies = [
  "cfg-if 1.0.0",
  "libc",
@@ -304,15 +304,15 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
 [[package]]
 name = "libc"
-version = "0.2.120"
+version = "0.2.126"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad5c14e80759d0939d013e6ca49930e59fc53dd8e5009132f76240c179380c09"
+checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836"
 
 [[package]]
 name = "log"
-version = "0.4.14"
+version = "0.4.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
 dependencies = [
  "cfg-if 1.0.0",
 ]
@@ -325,9 +325,9 @@ checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"
 
 [[package]]
 name = "memchr"
-version = "2.4.1"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
 
 [[package]]
 name = "nix"
@@ -343,9 +343,9 @@ dependencies = [
 
 [[package]]
 name = "num-integer"
-version = "0.1.44"
+version = "0.1.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db"
+checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
 dependencies = [
  "autocfg",
  "num-traits",
@@ -353,9 +353,9 @@ dependencies = [
 
 [[package]]
 name = "num-traits"
-version = "0.2.14"
+version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"
+checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
 dependencies = [
  "autocfg",
 ]
@@ -441,11 +441,11 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.36"
+version = "1.0.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
+checksum = "c54b25569025b7fc9651de43004ae593a75ad88543b17178aa5e1b9c4f15f56f"
 dependencies = [
- "unicode-xid",
+ "unicode-ident",
 ]
 
 [[package]]
@@ -459,27 +459,27 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.16"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4af2ec4714533fcdf07e886f17025ace8b997b9ce51204ee69b6da831c3da57"
+checksum = "a1feb54ed693b93a84e14094943b84b7c4eae204c512b7ccb95ab0c66d278ad1"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
 name = "redox_syscall"
-version = "0.2.11"
+version = "0.2.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8380fe0152551244f0747b1bf41737e0f8a74f97a14ccefd1148187271634f3c"
+checksum = "62f25bc4c7e55e0b0b7a1d43fb893f4fa1361d0abe38b9ce4f323c2adfe6ef42"
 dependencies = [
  "bitflags",
 ]
 
 [[package]]
 name = "redox_users"
-version = "0.4.2"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7776223e2696f1aa4c6b0170e83212f47296a00424305117d013dfe86fb0fe55"
+checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b"
 dependencies = [
  "getrandom",
  "redox_syscall",
@@ -540,13 +540,13 @@ checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
 
 [[package]]
 name = "syn"
-version = "1.0.89"
+version = "1.0.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea297be220d52398dcc07ce15a209fce436d361735ac1db700cab3b6cdfb9f54"
+checksum = "fbaf6116ab8924f39d52792136fb74fd60a80194cf1b1c6ffa6453eef1c3f942"
 dependencies = [
  "proc-macro2",
  "quote",
- "unicode-xid",
+ "unicode-ident",
 ]
 
 [[package]]
@@ -649,6 +649,12 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c"
 
+[[package]]
+name = "unicode-ident"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d22af068fba1eb5edcb4aea19d382b2a3deb4c8f9d475c589b6ada9e0fd493ee"
+
 [[package]]
 name = "unicode-segmentation"
 version = "1.9.0"
@@ -661,12 +667,6 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
 
-[[package]]
-name = "unicode-xid"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
-
 [[package]]
 name = "utf8parse"
 version = "0.2.0"
@@ -687,9 +687,9 @@ checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
 
 [[package]]
 name = "which"
-version = "4.2.4"
+version = "4.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a5a7e487e921cf220206864a94a89b6c6905bfc19f1057fa26a4cb360e5c1d2"
+checksum = "5c4fb54e6113b6a8772ee41c3404fb0301ac79604489467e0a9ce1f3e97c24ae"
 dependencies = [
  "either",
  "lazy_static",
diff --git a/Cargo.toml b/Cargo.toml
index 31dd4b0..a977331 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,5 +15,5 @@ pest = "2.1.3"
 pest_derive = "2.1.0"
 promptly = "0.3.0"
 termcolor = "1.1.3"
-thiserror = "1.0.30"
+thiserror = "1.0.31"
 tzfile = { git = "https://github.com/Garmelon/tzfile.git", branch = "tzdir" }

From 36d8082c9db5aba5a56b490b41ecee9af3578103 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Mon, 31 Oct 2022 17:00:02 +0100
Subject: [PATCH 68/80] Update dependencies

---
 Cargo.lock | 596 ++++++++++++++++++++++++++++++++++++++++-------------
 Cargo.toml |  14 +-
 2 files changed, 460 insertions(+), 150 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 6713148..174496c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,6 +2,15 @@
 # It is not intended for manual editing.
 version = 3
 
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "atty"
 version = "0.2.14"
@@ -27,30 +36,18 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "block-buffer"
-version = "0.7.3"
+version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
+checksum = "69cce20737498f97b993470a6e536b8523f0af7892a4f928cceb1ac5e52ebe7e"
 dependencies = [
- "block-padding",
- "byte-tools",
- "byteorder",
  "generic-array",
 ]
 
 [[package]]
-name = "block-padding"
-version = "0.1.5"
+name = "bumpalo"
+version = "3.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"
-dependencies = [
- "byte-tools",
-]
-
-[[package]]
-name = "byte-tools"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
+checksum = "572f695136211188308f16ad2ca5c851a712c464060ae6974944458eb83880ba"
 
 [[package]]
 name = "byteorder"
@@ -60,15 +57,9 @@ checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
 
 [[package]]
 name = "cc"
-version = "1.0.73"
+version = "1.0.74"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
-
-[[package]]
-name = "cfg-if"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+checksum = "581f5dba903aac52ea3feb5ec4810848460ee833876f1f9b0fdeab1f19091574"
 
 [[package]]
 name = "cfg-if"
@@ -78,39 +69,39 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chrono"
-version = "0.4.19"
+version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73"
+checksum = "bfd4d1b31faaa3a89d7934dbded3111da0d2ef28e3ebccdb4f0179f5929d1ef1"
 dependencies = [
- "libc",
+ "iana-time-zone",
+ "js-sys",
  "num-integer",
  "num-traits",
  "time",
+ "wasm-bindgen",
  "winapi",
 ]
 
 [[package]]
 name = "clap"
-version = "3.1.18"
+version = "4.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2dbdf4bdacb33466e854ce889eee8dfd5729abf7ccd7664d0a2d60cd384440b"
+checksum = "335867764ed2de42325fafe6d18b8af74ba97ee0c590fa016f157535b42ab04b"
 dependencies = [
  "atty",
  "bitflags",
  "clap_derive",
  "clap_lex",
- "indexmap",
- "lazy_static",
+ "once_cell",
  "strsim",
  "termcolor",
- "textwrap",
 ]
 
 [[package]]
 name = "clap_derive"
-version = "3.1.18"
+version = "4.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25320346e922cffe59c0bbc5410c8d8784509efb321488971081313cb1e1a33c"
+checksum = "16a1b0f6422af32d5da0c58e2703320f379216ee70198241c84173a8c5ac28f3"
 dependencies = [
  "heck",
  "proc-macro-error",
@@ -121,13 +112,24 @@ dependencies = [
 
 [[package]]
 name = "clap_lex"
-version = "0.2.0"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a37c35f1112dad5e6e0b1adaff798507497a18fceeb30cceb3bae7d1427b9213"
+checksum = "0d4198f73e42b4936b35b5bb248d81d2b595ecb170da0bac7655c54eedfa8da8"
 dependencies = [
  "os_str_bytes",
 ]
 
+[[package]]
+name = "clipboard-win"
+version = "4.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4ab1b92798304eedc095b53942963240037c0516452cb11aeba709d420b2219"
+dependencies = [
+ "error-code",
+ "str-buf",
+ "winapi",
+]
+
 [[package]]
 name = "codespan-reporting"
 version = "0.11.1"
@@ -156,12 +158,82 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9eaa21df489b1e50af464db43c1fc69f60492060ac7baae3996fe8a5f476790"
 
 [[package]]
-name = "digest"
-version = "0.8.1"
+name = "core-foundation-sys"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5"
+checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28d997bd5e24a5928dd43e46dc529867e207907fe0b239c3477d924f7f2ca320"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
 dependencies = [
  "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "cxx"
+version = "1.0.80"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b7d4e43b25d3c994662706a1d4fcfc32aaa6afd287502c111b237093bb23f3a"
+dependencies = [
+ "cc",
+ "cxxbridge-flags",
+ "cxxbridge-macro",
+ "link-cplusplus",
+]
+
+[[package]]
+name = "cxx-build"
+version = "1.0.80"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84f8829ddc213e2c1368e51a2564c552b65a8cb6a28f31e576270ac81d5e5827"
+dependencies = [
+ "cc",
+ "codespan-reporting",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "scratch",
+ "syn",
+]
+
+[[package]]
+name = "cxxbridge-flags"
+version = "1.0.80"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e72537424b474af1460806647c41d4b6d35d09ef7fe031c5c2fa5766047cc56a"
+
+[[package]]
+name = "cxxbridge-macro"
+version = "1.0.80"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "309e4fb93eed90e1e14bea0da16b209f81813ba9fc7830c20ed151dd7bc0a4d7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adfbc57365a37acbd2ebf2b64d7e69bb766e2fea813521ed536f5d0520dcf86c"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
 ]
 
 [[package]]
@@ -175,11 +247,11 @@ dependencies = [
 
 [[package]]
 name = "dirs-next"
-version = "1.0.2"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf36e65a80337bea855cd4ef9b8401ffce06a7baedf2e85ec467b1ac3f6e82b6"
+checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
  "dirs-sys-next",
 ]
 
@@ -207,9 +279,9 @@ dependencies = [
 
 [[package]]
 name = "edit"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cdd6936f8bd9782e28932eef853bfcd8548992ce5748bb3e7e88bad613d0ee0"
+checksum = "c562aa71f7bc691fde4c6bf5f93ae5a5298b617c2eb44c76c87832299a17fbb4"
 dependencies = [
  "tempfile",
  "which",
@@ -217,51 +289,88 @@ dependencies = [
 
 [[package]]
 name = "either"
-version = "1.6.1"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
+checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"
 
 [[package]]
-name = "fake-simd"
+name = "endian-type"
 version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
+checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d"
+
+[[package]]
+name = "errno"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f639046355ee4f37944e44f60642c6f3a7efa3cf6b78c78a0d989a8ce6c396a1"
+dependencies = [
+ "errno-dragonfly",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "errno-dragonfly"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "error-code"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64f18991e7bf11e7ffee451b5318b5c1a73c52d0d0ada6e5a3017c8c1ced6a21"
+dependencies = [
+ "libc",
+ "str-buf",
+]
 
 [[package]]
 name = "fastrand"
-version = "1.7.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3fcf0cee53519c866c09b5de1f6c56ff9d647101f81c1964fa632e148896cdf"
+checksum = "a7a407cfaa3385c4ae6b23e84623d48c2798d06e3e6a1878f7f59f17b3f86499"
 dependencies = [
  "instant",
 ]
 
 [[package]]
-name = "generic-array"
-version = "0.12.4"
+name = "fd-lock"
+version = "3.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffdf9f34f1447443d37393cc6c2b8313aebddcd96906caf34e54c68d8e57d7bd"
+checksum = "e11dcc7e4d79a8c89b9ab4c6f5c30b1fc4a83c420792da3542fd31179ed5f517"
+dependencies = [
+ "cfg-if",
+ "rustix",
+ "windows-sys",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9"
 dependencies = [
  "typenum",
+ "version_check",
 ]
 
 [[package]]
 name = "getrandom"
-version = "0.2.6"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9be70c98951c83b8d2f8f60d7065fa6d5146873094452a1008da8c2f1e4205ad"
+checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
  "libc",
- "wasi",
+ "wasi 0.11.0+wasi-snapshot-preview1",
 ]
 
-[[package]]
-name = "hashbrown"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
-
 [[package]]
 name = "heck"
 version = "0.4.0"
@@ -278,13 +387,27 @@ dependencies = [
 ]
 
 [[package]]
-name = "indexmap"
-version = "1.8.1"
+name = "iana-time-zone"
+version = "0.1.53"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f647032dfaa1f8b6dc29bd3edb7bbef4861b8b8007ebb118d6db284fd59f6ee"
+checksum = "64c122667b287044802d6ce17ee2ddf13207ed924c712de9a66a5814d5b64765"
 dependencies = [
- "autocfg",
- "hashbrown",
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "wasm-bindgen",
+ "winapi",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0703ae284fc167426161c2e3f1da3ea71d94b21bedbcc9494e92b28e334e3dca"
+dependencies = [
+ "cxx",
+ "cxx-build",
 ]
 
 [[package]]
@@ -293,7 +416,22 @@ version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
+]
+
+[[package]]
+name = "io-lifetimes"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e481ccbe3dea62107216d0d1138bb8ad8e5e5c43009a098bd1990272c497b0"
+
+[[package]]
+name = "js-sys"
+version = "0.3.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47"
+dependencies = [
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -304,9 +442,24 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
 [[package]]
 name = "libc"
-version = "0.2.126"
+version = "0.2.137"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836"
+checksum = "fc7fcc620a3bff7cdd7a365be3376c97191aeaccc2a603e600951e452615bf89"
+
+[[package]]
+name = "link-cplusplus"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9272ab7b96c9046fbc5bc56c06c117cb639fe2d509df0c421cad82d2915cf369"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.0.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4d2456c373231a208ad294c33dc5bff30051eafd954cd4caae83a712b12854d"
 
 [[package]]
 name = "log"
@@ -314,15 +467,9 @@ version = "0.4.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
 ]
 
-[[package]]
-name = "maplit"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"
-
 [[package]]
 name = "memchr"
 version = "2.5.0"
@@ -330,15 +477,34 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
 
 [[package]]
-name = "nix"
-version = "0.18.0"
+name = "memoffset"
+version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83450fe6a6142ddd95fb064b746083fc4ef1705fe81f64a64e1d4b39f54a1055"
+checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "nibble_vec"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77a5d83df9f36fe23f0c3648c6bbb8b0298bb5f1939c8f2704431371f4b84d43"
+dependencies = [
+ "smallvec",
+]
+
+[[package]]
+name = "nix"
+version = "0.23.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f866317acbd3a240710c63f065ffb1e4fd466259045ccb504130b7f668f35c6"
 dependencies = [
  "bitflags",
  "cc",
- "cfg-if 0.1.10",
+ "cfg-if",
  "libc",
+ "memoffset",
 ]
 
 [[package]]
@@ -361,31 +527,32 @@ dependencies = [
 ]
 
 [[package]]
-name = "opaque-debug"
-version = "0.2.3"
+name = "once_cell"
+version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"
+checksum = "86f0b0d4bf799edbc74508c1e8bf170ff5f41238e5f8225603ca7caaae2b7860"
 
 [[package]]
 name = "os_str_bytes"
-version = "6.0.1"
+version = "6.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "029d8d0b2f198229de29dca79676f2738ff952edf3fde542eb8bf94d8c21b435"
+checksum = "3baf96e39c5359d2eb0dd6ccb42c62b91d9678aa68160d261b9e0ccbf9e9dea9"
 
 [[package]]
 name = "pest"
-version = "2.1.3"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10f4872ae94d7b90ae48754df22fd42ad52ce740b8f370b03da4835417403e53"
+checksum = "dbc7bc69c062e492337d74d59b120c274fd3d261b6bf6d3207d499b4b379c41a"
 dependencies = [
+ "thiserror",
  "ucd-trie",
 ]
 
 [[package]]
 name = "pest_derive"
-version = "2.1.0"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "833d1ae558dc601e9a60366421196a8d94bc0ac980476d0b67e1d0988d72b2d0"
+checksum = "60b75706b9642ebcb34dab3bc7750f811609a0eb1dd8b88c2d15bf628c1c65b2"
 dependencies = [
  "pest",
  "pest_generator",
@@ -393,9 +560,9 @@ dependencies = [
 
 [[package]]
 name = "pest_generator"
-version = "2.1.3"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99b8db626e31e5b81787b9783425769681b347011cc59471e33ea46d2ea0cf55"
+checksum = "f4f9272122f5979a6511a749af9db9bfc810393f63119970d7085fed1c4ea0db"
 dependencies = [
  "pest",
  "pest_meta",
@@ -406,13 +573,13 @@ dependencies = [
 
 [[package]]
 name = "pest_meta"
-version = "2.1.3"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54be6e404f5317079812fc8f9f5279de376d8856929e21c184ecf6bbd692a11d"
+checksum = "4c8717927f9b79515e565a64fe46c38b8cd0427e64c40680b14a7365ab09ac8d"
 dependencies = [
- "maplit",
+ "once_cell",
  "pest",
- "sha-1",
+ "sha1",
 ]
 
 [[package]]
@@ -441,36 +608,46 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.39"
+version = "1.0.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c54b25569025b7fc9651de43004ae593a75ad88543b17178aa5e1b9c4f15f56f"
+checksum = "5ea3d908b0e36316caf9e9e2c4625cdde190a7e6f440d794667ed17a1855e725"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "promptly"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b99cfb0289110d969dd21637cfbc922584329bc9e5037c5e576325c615658509"
+checksum = "9acbc6c5a5b029fe58342f58445acb00ccfe24624e538894bc2f04ce112980ba"
 dependencies = [
  "rustyline",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.18"
+version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1feb54ed693b93a84e14094943b84b7c4eae204c512b7ccb95ab0c66d278ad1"
+checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
-name = "redox_syscall"
-version = "0.2.13"
+name = "radix_trie"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62f25bc4c7e55e0b0b7a1d43fb893f4fa1361d0abe38b9ce4f323c2adfe6ef42"
+checksum = "c069c179fcdc6a2fe24d8d18305cf085fdbd4f922c041943e203685d6a1c58fd"
+dependencies = [
+ "endian-type",
+ "nibble_vec",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
 dependencies = [
  "bitflags",
 ]
@@ -496,18 +673,37 @@ dependencies = [
 ]
 
 [[package]]
-name = "rustyline"
-version = "6.3.0"
+name = "rustix"
+version = "0.35.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f0d5e7b0219a3eadd5439498525d4765c59b7c993ef0c12244865cd2d988413"
+checksum = "985947f9b6423159c4726323f373be0a21bdb514c5af06a849cb3d2dce2d01e8"
 dependencies = [
- "cfg-if 0.1.10",
+ "bitflags",
+ "errno",
+ "io-lifetimes",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys",
+]
+
+[[package]]
+name = "rustyline"
+version = "9.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db7826789c0e25614b03e5a54a0717a86f9ff6e6e5247f92b369472869320039"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "clipboard-win",
  "dirs-next",
+ "fd-lock",
  "libc",
  "log",
  "memchr",
  "nix",
+ "radix_trie",
  "scopeguard",
+ "smallvec",
  "unicode-segmentation",
  "unicode-width",
  "utf8parse",
@@ -521,17 +717,34 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
-name = "sha-1"
-version = "0.8.2"
+name = "scratch"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7d94d0bede923b3cea61f3f1ff57ff8cdfd77b400fb8f9998949e0cf04163df"
+checksum = "9c8132065adcfd6e02db789d9285a0deb2f3fcb04002865ab67d5fb103533898"
+
+[[package]]
+name = "sha1"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f04293dc80c3993519f2d7f6f511707ee7094fe0c6d3406feb330cdb3540eba3"
 dependencies = [
- "block-buffer",
+ "cfg-if",
+ "cpufeatures",
  "digest",
- "fake-simd",
- "opaque-debug",
 ]
 
+[[package]]
+name = "smallvec"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
+
+[[package]]
+name = "str-buf"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e08d8363704e6c71fc928674353e6b7c23dcea9d82d7012c8faf2a3a025f8d0"
+
 [[package]]
 name = "strsim"
 version = "0.10.0"
@@ -540,9 +753,9 @@ checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
 
 [[package]]
 name = "syn"
-version = "1.0.95"
+version = "1.0.103"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbaf6116ab8924f39d52792136fb74fd60a80194cf1b1c6ffa6453eef1c3f942"
+checksum = "a864042229133ada95abf3b54fdc62ef5ccabe9515b64717bcb9a1919e59445d"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -555,7 +768,7 @@ version = "3.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
  "fastrand",
  "libc",
  "redox_syscall",
@@ -572,26 +785,20 @@ dependencies = [
  "winapi-util",
 ]
 
-[[package]]
-name = "textwrap"
-version = "0.15.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb"
-
 [[package]]
 name = "thiserror"
-version = "1.0.31"
+version = "1.0.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd829fe32373d27f76265620b5309d0340cb8550f523c1dda251d6298069069a"
+checksum = "10deb33631e3c9018b9baf9dcbbc4f737320d2b576bac10f6aefa048fa407e3e"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.31"
+version = "1.0.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0396bc89e626244658bef819e22d0cc459e795a5ebe878e6ec336d1674a8d79a"
+checksum = "982d17546b47146b28f7c22e3d08465f6b8903d0ea13c1660d9d84a6e7adcdbb"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -605,7 +812,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6db9e6914ab8b1ae1c260a4ae7a49b6c5611b40328a735b21862567685e73255"
 dependencies = [
  "libc",
- "wasi",
+ "wasi 0.10.0+wasi-snapshot-preview1",
  "winapi",
 ]
 
@@ -645,27 +852,27 @@ dependencies = [
 
 [[package]]
 name = "ucd-trie"
-version = "0.1.3"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c"
+checksum = "9e79c4d996edb816c91e4308506774452e55e95c3c9de07b6729e17e15a5ef81"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.0"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d22af068fba1eb5edcb4aea19d382b2a3deb4c8f9d475c589b6ada9e0fd493ee"
+checksum = "6ceab39d59e4c9499d4e5a8ee0e2735b891bb7308ac83dfb4e80cad195c9f6f3"
 
 [[package]]
 name = "unicode-segmentation"
-version = "1.9.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e8820f5d777f6224dc4be3632222971ac30164d4a258d595640799554ebfd99"
+checksum = "0fdbf052a0783de01e944a6ce7a8cb939e295b1e7be835a1112c3b9a7f047a5a"
 
 [[package]]
 name = "unicode-width"
-version = "0.1.9"
+version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
+checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
 
 [[package]]
 name = "utf8parse"
@@ -686,14 +893,74 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
 
 [[package]]
-name = "which"
-version = "4.2.5"
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c4fb54e6113b6a8772ee41c3404fb0301ac79604489467e0a9ce1f3e97c24ae"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.83"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.83"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142"
+dependencies = [
+ "bumpalo",
+ "log",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.83"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "052be0f94026e6cbc75cdefc9bae13fd6052cdcaf532fa6c45e7ae33a1e6c810"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.83"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07bc0c051dc5f23e307b13285f9d75df86bfdf816c5721e573dec1f9b8aa193c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.83"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f"
+
+[[package]]
+name = "which"
+version = "4.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c831fbbee9e129a8cf93e7747a82da9d95ba8e16621cae60ec2cdc849bacb7b"
 dependencies = [
  "either",
- "lazy_static",
  "libc",
+ "once_cell",
 ]
 
 [[package]]
@@ -726,3 +993,46 @@ name = "winapi-x86_64-pc-windows-gnu"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-sys"
+version = "0.36.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea04155a16a59f9eab786fe12a4a450e75cdb175f9e0d80da1e17db09f55b8d2"
+dependencies = [
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.36.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9bb8c3fd39ade2d67e9874ac4f3db21f0d710bee00fe7cab16949ec184eeaa47"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.36.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "180e6ccf01daf4c426b846dfc66db1fc518f074baa793aa7d9b9aaeffad6a3b6"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.36.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2e7917148b2812d1eeafaeb22a97e4813dfa60a3f8f78ebe204bcc88f12f024"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.36.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4dcd171b8776c41b97521e5da127a2d86ad280114807d0b2ab1e462bc764d9e1"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.36.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c811ca4a8c853ef420abd8592ba53ddbbac90410fab6903b3e79972a631f7680"
diff --git a/Cargo.toml b/Cargo.toml
index a977331..82c07b4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,16 +4,16 @@ version = "0.2.0"
 edition = "2021"
 
 [dependencies]
-chrono = "0.4.19"
-clap = { version = "3.1.18", features = ["derive"] }
+chrono = "0.4.22"
+clap = { version = "4.0.18", features = ["derive"] }
 codespan-reporting = "0.11.1"
 colored = "2.0.0"
 computus = "1.0.0"
 directories = "4.0.1"
-edit = "0.1.3"
-pest = "2.1.3"
-pest_derive = "2.1.0"
-promptly = "0.3.0"
+edit = "0.1.4"
+pest = "2.4.0"
+pest_derive = "2.4.0"
+promptly = "0.3.1"
 termcolor = "1.1.3"
-thiserror = "1.0.31"
+thiserror = "1.0.37"
 tzfile = { git = "https://github.com/Garmelon/tzfile.git", branch = "tzdir" }

From 57da1026c2c0bfd7d163460d326c92f59cb94034 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Mon, 31 Oct 2022 17:07:10 +0100
Subject: [PATCH 69/80] Use cove lints

---
 src/main.rs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/main.rs b/src/main.rs
index 5d5922f..84013df 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,5 +1,17 @@
+#![deny(unsafe_code)]
+// Rustc lint groups
 #![warn(future_incompatible)]
 #![warn(rust_2018_idioms)]
+// Rustc lints
+#![warn(noop_method_call)]
+#![warn(single_use_lifetimes)]
+#![warn(trivial_numeric_casts)]
+#![warn(unused_crate_dependencies)]
+#![warn(unused_extern_crates)]
+#![warn(unused_import_braces)]
+#![warn(unused_lifetimes)]
+#![warn(unused_qualifications)]
+// Clippy lints
 #![warn(clippy::all)]
 #![warn(clippy::use_self)]
 

From c5a2e5dccbb4f86f8062432ac9ade45a2518469c Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Mon, 31 Oct 2022 17:16:08 +0100
Subject: [PATCH 70/80] Fix some warnings

---
 src/cli/error.rs             |  16 +++---
 src/cli/layout/line.rs       |   6 +-
 src/eval/command/birthday.rs |   2 +-
 src/eval/command/date.rs     |   2 +-
 src/eval/command/formula.rs  |  82 +++++++++++++--------------
 src/eval/delta.rs            |  32 +++++------
 src/files/commands.rs        | 104 +++++++++++++++++------------------
 src/files/error.rs           |  18 +++---
 src/files/format.rs          |  86 ++++++++++++++---------------
 src/files/primitives.rs      |  14 ++---
 10 files changed, 181 insertions(+), 181 deletions(-)

diff --git a/src/cli/error.rs b/src/cli/error.rs
index 929650a..ef35e12 100644
--- a/src/cli/error.rs
+++ b/src/cli/error.rs
@@ -42,12 +42,12 @@ where
 {
     fn eprint<'f: 'a>(&self, files: &'f F, config: &Config) {
         match self {
-            Error::Eval(e) => e.eprint(files, config),
-            Error::ArgumentParse { file, error } => error.eprint(file, config),
-            Error::ArgumentEval { file, error } => error.eprint(file, config),
-            Error::NoSuchEntry(n) => eprintln!("No entry with number {n}"),
-            Error::NoSuchLog(date) => eprintln!("No log for {date}"),
-            Error::NotATask(ns) => {
+            Self::Eval(e) => e.eprint(files, config),
+            Self::ArgumentParse { file, error } => error.eprint(file, config),
+            Self::ArgumentEval { file, error } => error.eprint(file, config),
+            Self::NoSuchEntry(n) => eprintln!("No entry with number {n}"),
+            Self::NoSuchLog(date) => eprintln!("No log for {date}"),
+            Self::NotATask(ns) => {
                 if ns.is_empty() {
                     eprintln!("Not a task.");
                 } else if ns.len() == 1 {
@@ -57,8 +57,8 @@ where
                     eprintln!("{} are not tasks.", ns.join(", "));
                 }
             }
-            Error::NoCaptureFile => eprintln!("No capture file found"),
-            Error::EditingIo(error) => {
+            Self::NoCaptureFile => eprintln!("No capture file found"),
+            Self::EditingIo(error) => {
                 eprintln!("Error while editing:");
                 eprintln!("  {error}");
             }
diff --git a/src/cli/layout/line.rs b/src/cli/layout/line.rs
index 42cd871..79d0a43 100644
--- a/src/cli/layout/line.rs
+++ b/src/cli/layout/line.rs
@@ -42,9 +42,9 @@ pub enum SpanSegment {
 impl SpanSegment {
     fn style(&self) -> SpanStyle {
         match self {
-            SpanSegment::Start(s) => *s,
-            SpanSegment::Middle(s) => *s,
-            SpanSegment::End(s) => *s,
+            Self::Start(s) => *s,
+            Self::Middle(s) => *s,
+            Self::End(s) => *s,
         }
     }
 }
diff --git a/src/eval/command/birthday.rs b/src/eval/command/birthday.rs
index cec1d2e..4f0cb32 100644
--- a/src/eval/command/birthday.rs
+++ b/src/eval/command/birthday.rs
@@ -8,7 +8,7 @@ use super::super::date::Dates;
 use super::super::error::Error;
 use super::super::EntryKind;
 
-impl<'a> CommandState<'a> {
+impl CommandState<'_> {
     pub fn eval_birthday_spec(&mut self, spec: &BirthdaySpec) -> Result<(), Error<FileSource>> {
         let range = match self.limit_from_until(self.range_with_remind()) {
             Some(range) => range,
diff --git a/src/eval/command/date.rs b/src/eval/command/date.rs
index f7ddacb..9a895c2 100644
--- a/src/eval/command/date.rs
+++ b/src/eval/command/date.rs
@@ -137,7 +137,7 @@ impl DateSpec {
     }
 }
 
-impl<'a> CommandState<'a> {
+impl CommandState<'_> {
     pub fn eval_date_spec(&mut self, spec: DateSpec) -> Result<(), Error<FileSource>> {
         let index = self.source.file();
         if let Some(repeat) = &spec.repeat {
diff --git a/src/eval/command/formula.rs b/src/eval/command/formula.rs
index c9a8692..f50e0d8 100644
--- a/src/eval/command/formula.rs
+++ b/src/eval/command/formula.rs
@@ -51,38 +51,38 @@ pub enum Var {
 impl Var {
     fn eval<S>(self, index: S, date: NaiveDate) -> Result<i64, Error<S>> {
         Ok(match self {
-            Var::JulianDay => date.num_days_from_ce().into(),
-            Var::Year => date.year().into(),
-            Var::YearLength => util::year_length(date.year()).into(),
-            Var::YearDay => date.ordinal().into(),
-            Var::YearDayReverse => (util::year_length(date.year()) - date.ordinal0()).into(),
-            Var::YearWeek => (date.ordinal0().div_euclid(7) + 1).into(),
-            Var::YearWeekReverse => {
+            Self::JulianDay => date.num_days_from_ce().into(),
+            Self::Year => date.year().into(),
+            Self::YearLength => util::year_length(date.year()).into(),
+            Self::YearDay => date.ordinal().into(),
+            Self::YearDayReverse => (util::year_length(date.year()) - date.ordinal0()).into(),
+            Self::YearWeek => (date.ordinal0().div_euclid(7) + 1).into(),
+            Self::YearWeekReverse => {
                 #[allow(non_snake_case)]
                 let yD = util::year_length(date.year()) - date.ordinal();
                 (yD.div_euclid(7) + 1).into()
             }
-            Var::Month => date.month().into(),
-            Var::MonthLength => util::month_length(date.year(), date.month()).into(),
-            Var::MonthWeek => (date.day0().div_euclid(7) + 1).into(),
-            Var::MonthWeekReverse => {
+            Self::Month => date.month().into(),
+            Self::MonthLength => util::month_length(date.year(), date.month()).into(),
+            Self::MonthWeek => (date.day0().div_euclid(7) + 1).into(),
+            Self::MonthWeekReverse => {
                 #[allow(non_snake_case)]
                 let mD = util::month_length(date.year(), date.month()) - date.day();
                 (mD.div_euclid(7) + 1).into()
             }
-            Var::Day => date.day().into(),
-            Var::DayReverse => {
+            Self::Day => date.day().into(),
+            Self::DayReverse => {
                 let ml = util::month_length(date.year(), date.month());
                 (ml - date.day0()).into()
             }
-            Var::IsoYear => date.iso_week().year().into(),
-            Var::IsoYearLength => util::iso_year_length(date.iso_week().year()).into(),
-            Var::IsoWeek => date.iso_week().week().into(),
-            Var::Weekday => {
+            Self::IsoYear => date.iso_week().year().into(),
+            Self::IsoYearLength => util::iso_year_length(date.iso_week().year()).into(),
+            Self::IsoWeek => date.iso_week().week().into(),
+            Self::Weekday => {
                 let wd: Weekday = date.weekday().into();
                 wd.num().into()
             }
-            Var::Easter(span) => {
+            Self::Easter(span) => {
                 let e = computus::gregorian(date.year()).map_err(|e| Error::Easter {
                     index,
                     span,
@@ -91,16 +91,16 @@ impl Var {
                 })?;
                 NaiveDate::from_ymd(e.year, e.month, e.day).ordinal().into()
             }
-            Var::IsWeekday => {
+            Self::IsWeekday => {
                 let wd: Weekday = date.weekday().into();
                 b2i(!wd.is_weekend())
             }
-            Var::IsWeekend => {
+            Self::IsWeekend => {
                 let wd: Weekday = date.weekday().into();
                 b2i(wd.is_weekend())
             }
-            Var::IsLeapYear => b2i(util::is_leap_year(date.year())),
-            Var::IsIsoLeapYear => b2i(util::is_iso_leap_year(date.year())),
+            Self::IsLeapYear => b2i(util::is_leap_year(date.year())),
+            Self::IsIsoLeapYear => b2i(util::is_iso_leap_year(date.year())),
         })
     }
 }
@@ -206,13 +206,13 @@ impl From<Weekday> for Expr {
 impl Expr {
     fn eval<S: Copy>(&self, index: S, date: NaiveDate) -> Result<i64, Error<S>> {
         Ok(match self {
-            Expr::Lit(l) => *l,
-            Expr::Var(v) => v.eval(index, date)?,
-            Expr::Neg(e) => -e.eval(index, date)?,
-            Expr::Add(a, b) => a.eval(index, date)? + b.eval(index, date)?,
-            Expr::Sub(a, b) => a.eval(index, date)? - b.eval(index, date)?,
-            Expr::Mul(a, b) => a.eval(index, date)? * b.eval(index, date)?,
-            Expr::Div(a, b, span) => {
+            Self::Lit(l) => *l,
+            Self::Var(v) => v.eval(index, date)?,
+            Self::Neg(e) => -e.eval(index, date)?,
+            Self::Add(a, b) => a.eval(index, date)? + b.eval(index, date)?,
+            Self::Sub(a, b) => a.eval(index, date)? - b.eval(index, date)?,
+            Self::Mul(a, b) => a.eval(index, date)? * b.eval(index, date)?,
+            Self::Div(a, b, span) => {
                 let b = b.eval(index, date)?;
                 if b == 0 {
                     return Err(Error::DivByZero {
@@ -223,7 +223,7 @@ impl Expr {
                 }
                 a.eval(index, date)?.div_euclid(b)
             }
-            Expr::Mod(a, b, span) => {
+            Self::Mod(a, b, span) => {
                 let b = b.eval(index, date)?;
                 if b == 0 {
                     return Err(Error::ModByZero {
@@ -234,16 +234,16 @@ impl Expr {
                 }
                 a.eval(index, date)?.rem_euclid(b)
             }
-            Expr::Eq(a, b) => b2i(a.eval(index, date)? == b.eval(index, date)?),
-            Expr::Neq(a, b) => b2i(a.eval(index, date)? != b.eval(index, date)?),
-            Expr::Lt(a, b) => b2i(a.eval(index, date)? < b.eval(index, date)?),
-            Expr::Lte(a, b) => b2i(a.eval(index, date)? <= b.eval(index, date)?),
-            Expr::Gt(a, b) => b2i(a.eval(index, date)? > b.eval(index, date)?),
-            Expr::Gte(a, b) => b2i(a.eval(index, date)? >= b.eval(index, date)?),
-            Expr::Not(e) => b2i(!i2b(e.eval(index, date)?)),
-            Expr::And(a, b) => b2i(i2b(a.eval(index, date)?) && i2b(b.eval(index, date)?)),
-            Expr::Or(a, b) => b2i(i2b(a.eval(index, date)?) || i2b(b.eval(index, date)?)),
-            Expr::Xor(a, b) => b2i(i2b(a.eval(index, date)?) ^ i2b(b.eval(index, date)?)),
+            Self::Eq(a, b) => b2i(a.eval(index, date)? == b.eval(index, date)?),
+            Self::Neq(a, b) => b2i(a.eval(index, date)? != b.eval(index, date)?),
+            Self::Lt(a, b) => b2i(a.eval(index, date)? < b.eval(index, date)?),
+            Self::Lte(a, b) => b2i(a.eval(index, date)? <= b.eval(index, date)?),
+            Self::Gt(a, b) => b2i(a.eval(index, date)? > b.eval(index, date)?),
+            Self::Gte(a, b) => b2i(a.eval(index, date)? >= b.eval(index, date)?),
+            Self::Not(e) => b2i(!i2b(e.eval(index, date)?)),
+            Self::And(a, b) => b2i(i2b(a.eval(index, date)?) && i2b(b.eval(index, date)?)),
+            Self::Or(a, b) => b2i(i2b(a.eval(index, date)?) || i2b(b.eval(index, date)?)),
+            Self::Xor(a, b) => b2i(i2b(a.eval(index, date)?) ^ i2b(b.eval(index, date)?)),
         })
     }
 }
@@ -362,7 +362,7 @@ impl FormulaSpec {
     }
 }
 
-impl<'a> CommandState<'a> {
+impl CommandState<'_> {
     pub fn eval_formula_spec(&mut self, spec: FormulaSpec) -> Result<(), Error<FileSource>> {
         if let Some(range) = spec.range(self) {
             let index = self.source.file();
diff --git a/src/eval/delta.rs b/src/eval/delta.rs
index 364a226..f390cf2 100644
--- a/src/eval/delta.rs
+++ b/src/eval/delta.rs
@@ -43,84 +43,84 @@ impl DeltaStep {
     /// A lower bound on days
     fn lower_bound(&self) -> i32 {
         match self {
-            DeltaStep::Year(n) => {
+            Self::Year(n) => {
                 if *n < 0 {
                     *n * 366
                 } else {
                     *n * 365
                 }
             }
-            DeltaStep::Month(n) | DeltaStep::MonthReverse(n) => {
+            Self::Month(n) | Self::MonthReverse(n) => {
                 if *n < 0 {
                     *n * 31
                 } else {
                     *n * 28
                 }
             }
-            DeltaStep::Day(n) => *n,
-            DeltaStep::Week(n) => *n * 7,
-            DeltaStep::Hour(n) => {
+            Self::Day(n) => *n,
+            Self::Week(n) => *n * 7,
+            Self::Hour(n) => {
                 if *n < 0 {
                     *n / 24 + (*n % 24).signum()
                 } else {
                     *n / 24
                 }
             }
-            DeltaStep::Minute(n) => {
+            Self::Minute(n) => {
                 if *n < 0 {
                     *n / (24 * 60) + (*n % (24 * 60)).signum()
                 } else {
                     *n / (24 * 60)
                 }
             }
-            DeltaStep::Weekday(n, _) => match n.cmp(&0) {
+            Self::Weekday(n, _) => match n.cmp(&0) {
                 Ordering::Less => *n * 7 - 1,
                 Ordering::Equal => 0,
                 Ordering::Greater => *n * 7 - 7,
             },
-            DeltaStep::Time(_) => 0,
+            Self::Time(_) => 0,
         }
     }
 
     /// An upper bound on days
     fn upper_bound(&self) -> i32 {
         match self {
-            DeltaStep::Year(n) => {
+            Self::Year(n) => {
                 if *n > 0 {
                     *n * 366
                 } else {
                     *n * 365
                 }
             }
-            DeltaStep::Month(n) | DeltaStep::MonthReverse(n) => {
+            Self::Month(n) | Self::MonthReverse(n) => {
                 if *n > 0 {
                     *n * 31
                 } else {
                     *n * 28
                 }
             }
-            DeltaStep::Day(n) => *n,
-            DeltaStep::Week(n) => *n * 7,
-            DeltaStep::Hour(n) => {
+            Self::Day(n) => *n,
+            Self::Week(n) => *n * 7,
+            Self::Hour(n) => {
                 if *n > 0 {
                     *n / 24 + (*n % 24).signum()
                 } else {
                     *n / 24
                 }
             }
-            DeltaStep::Minute(n) => {
+            Self::Minute(n) => {
                 if *n > 0 {
                     *n / (24 * 60) + (*n % (24 * 60)).signum()
                 } else {
                     *n / (24 * 60)
                 }
             }
-            DeltaStep::Weekday(n, _) => match n.cmp(&0) {
+            Self::Weekday(n, _) => match n.cmp(&0) {
                 Ordering::Less => *n * 7 - 7,
                 Ordering::Equal => 0,
                 Ordering::Greater => *n * 7 - 1,
             },
-            DeltaStep::Time(_) => 1,
+            Self::Time(_) => 1,
         }
     }
 }
diff --git a/src/files/commands.rs b/src/files/commands.rs
index 483fd7a..e3ff9d3 100644
--- a/src/files/commands.rs
+++ b/src/files/commands.rs
@@ -27,27 +27,27 @@ pub enum DeltaStep {
 impl DeltaStep {
     pub fn amount(&self) -> i32 {
         match self {
-            DeltaStep::Year(i) => *i,
-            DeltaStep::Month(i) => *i,
-            DeltaStep::MonthReverse(i) => *i,
-            DeltaStep::Day(i) => *i,
-            DeltaStep::Week(i) => *i,
-            DeltaStep::Hour(i) => *i,
-            DeltaStep::Minute(i) => *i,
-            DeltaStep::Weekday(i, _) => *i,
+            Self::Year(i) => *i,
+            Self::Month(i) => *i,
+            Self::MonthReverse(i) => *i,
+            Self::Day(i) => *i,
+            Self::Week(i) => *i,
+            Self::Hour(i) => *i,
+            Self::Minute(i) => *i,
+            Self::Weekday(i, _) => *i,
         }
     }
 
     pub fn name(&self) -> &'static str {
         match self {
-            DeltaStep::Year(_) => "y",
-            DeltaStep::Month(_) => "m",
-            DeltaStep::MonthReverse(_) => "M",
-            DeltaStep::Day(_) => "d",
-            DeltaStep::Week(_) => "w",
-            DeltaStep::Hour(_) => "h",
-            DeltaStep::Minute(_) => "min",
-            DeltaStep::Weekday(_, wd) => wd.name(),
+            Self::Year(_) => "y",
+            Self::Month(_) => "m",
+            Self::MonthReverse(_) => "M",
+            Self::Day(_) => "d",
+            Self::Week(_) => "w",
+            Self::Hour(_) => "h",
+            Self::Minute(_) => "min",
+            Self::Weekday(_, wd) => wd.name(),
         }
     }
 }
@@ -168,39 +168,39 @@ impl Var {
     pub fn name(&self) -> &'static str {
         match self {
             // Constants
-            Var::True => "true",
-            Var::False => "false",
-            Var::Monday => "mon",
-            Var::Tuesday => "tue",
-            Var::Wednesday => "wed",
-            Var::Thursday => "thu",
-            Var::Friday => "fri",
-            Var::Saturday => "sat",
-            Var::Sunday => "sun",
+            Self::True => "true",
+            Self::False => "false",
+            Self::Monday => "mon",
+            Self::Tuesday => "tue",
+            Self::Wednesday => "wed",
+            Self::Thursday => "thu",
+            Self::Friday => "fri",
+            Self::Saturday => "sat",
+            Self::Sunday => "sun",
             // Variables
-            Var::JulianDay => "j",
-            Var::Year => "y",
-            Var::YearLength => "yl",
-            Var::YearDay => "yd",
-            Var::YearDayReverse => "yD",
-            Var::YearWeek => "yw",
-            Var::YearWeekReverse => "yW",
-            Var::Month => "m",
-            Var::MonthLength => "ml",
-            Var::MonthWeek => "mw",
-            Var::MonthWeekReverse => "mW",
-            Var::Day => "d",
-            Var::DayReverse => "D",
-            Var::IsoYear => "iy",
-            Var::IsoYearLength => "iyl",
-            Var::IsoWeek => "iw",
-            Var::Weekday => "wd",
-            Var::Easter => "e",
+            Self::JulianDay => "j",
+            Self::Year => "y",
+            Self::YearLength => "yl",
+            Self::YearDay => "yd",
+            Self::YearDayReverse => "yD",
+            Self::YearWeek => "yw",
+            Self::YearWeekReverse => "yW",
+            Self::Month => "m",
+            Self::MonthLength => "ml",
+            Self::MonthWeek => "mw",
+            Self::MonthWeekReverse => "mW",
+            Self::Day => "d",
+            Self::DayReverse => "D",
+            Self::IsoYear => "iy",
+            Self::IsoYearLength => "iyl",
+            Self::IsoWeek => "iw",
+            Self::Weekday => "wd",
+            Self::Easter => "e",
             // Variables with "boolean" values
-            Var::IsWeekday => "isWeekday",
-            Var::IsWeekend => "isWeekend",
-            Var::IsLeapYear => "isLeapYear",
-            Var::IsIsoLeapYear => "isIsoLeapYear",
+            Self::IsWeekday => "isWeekday",
+            Self::IsWeekend => "isWeekend",
+            Self::IsLeapYear => "isLeapYear",
+            Self::IsIsoLeapYear => "isIsoLeapYear",
         }
     }
 }
@@ -301,11 +301,11 @@ pub enum DoneDate {
 impl DoneDate {
     pub fn root(self) -> NaiveDate {
         match self {
-            DoneDate::Date { root } => root,
-            DoneDate::DateTime { root, .. } => root,
-            DoneDate::DateToDate { root, .. } => root,
-            DoneDate::DateTimeToTime { root, .. } => root,
-            DoneDate::DateTimeToDateTime { root, .. } => root,
+            Self::Date { root } => root,
+            Self::DateTime { root, .. } => root,
+            Self::DateToDate { root, .. } => root,
+            Self::DateTimeToTime { root, .. } => root,
+            Self::DateTimeToDateTime { root, .. } => root,
         }
     }
 
diff --git a/src/files/error.rs b/src/files/error.rs
index f0ad33e..40fa7f7 100644
--- a/src/files/error.rs
+++ b/src/files/error.rs
@@ -134,19 +134,19 @@ pub enum Error {
 impl<'a> Eprint<'a, Files> for Error {
     fn eprint<'f: 'a>(&self, files: &'f Files, config: &Config) {
         match self {
-            Error::ResolvePath { path, error } => {
+            Self::ResolvePath { path, error } => {
                 eprintln!("Could not resolve path {path:?}:");
                 eprintln!("  {error}");
             }
-            Error::ReadFile { file, error } => {
+            Self::ReadFile { file, error } => {
                 eprintln!("Could not read file {file:?}:");
                 eprintln!("  {error}");
             }
-            Error::WriteFile { file, error } => {
+            Self::WriteFile { file, error } => {
                 eprintln!("Could not write file {file:?}:");
                 eprintln!("  {error}");
             }
-            Error::ResolveTz {
+            Self::ResolveTz {
                 file,
                 span,
                 tz,
@@ -158,14 +158,14 @@ impl<'a> Eprint<'a, Files> for Error {
                     .with_notes(vec![format!("{error}")]);
                 Self::eprint_diagnostic(files, config, &diagnostic);
             }
-            Error::LocalTz { error } => {
+            Self::LocalTz { error } => {
                 eprintln!("Could not determine local timezone:");
                 eprintln!("  {error}");
             }
-            Error::Parse { file, error } => {
+            Self::Parse { file, error } => {
                 ParseError::new(*file, error.clone()).eprint(files, config)
             }
-            Error::TzConflict {
+            Self::TzConflict {
                 file1,
                 span1,
                 tz1,
@@ -184,7 +184,7 @@ impl<'a> Eprint<'a, Files> for Error {
                     ]);
                 Self::eprint_diagnostic(files, config, &diagnostic);
             }
-            Error::MultipleCapture {
+            Self::MultipleCapture {
                 file1,
                 span1,
                 file2,
@@ -201,7 +201,7 @@ impl<'a> Eprint<'a, Files> for Error {
                     ]);
                 Self::eprint_diagnostic(files, config, &diagnostic);
             }
-            Error::LogConflict {
+            Self::LogConflict {
                 file1,
                 span1,
                 file2,
diff --git a/src/files/format.rs b/src/files/format.rs
index caa5d9b..280d58c 100644
--- a/src/files/format.rs
+++ b/src/files/format.rs
@@ -140,25 +140,25 @@ impl fmt::Display for Var {
 impl fmt::Display for Expr {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Expr::Lit(i) => write!(f, "{i}"),
-            Expr::Var(v) => write!(f, "{v}"),
-            Expr::Paren(e) => write!(f, "({e})"),
-            Expr::Neg(e) => write!(f, "-{e}"),
-            Expr::Add(a, b) => write!(f, "{a} + {b}"),
-            Expr::Sub(a, b) => write!(f, "{a} - {b}"),
-            Expr::Mul(a, b) => write!(f, "{a} * {b}"),
-            Expr::Div(a, b) => write!(f, "{a} / {b}"),
-            Expr::Mod(a, b) => write!(f, "{a} % {b}"),
-            Expr::Eq(a, b) => write!(f, "{a} = {b}"),
-            Expr::Neq(a, b) => write!(f, "{a} != {b}"),
-            Expr::Lt(a, b) => write!(f, "{a} < {b}"),
-            Expr::Lte(a, b) => write!(f, "{a} <= {b}"),
-            Expr::Gt(a, b) => write!(f, "{a} > {b}"),
-            Expr::Gte(a, b) => write!(f, "{a} >= {b}"),
-            Expr::Not(e) => write!(f, "!{e}"),
-            Expr::And(a, b) => write!(f, "{a} & {b}"),
-            Expr::Or(a, b) => write!(f, "{a} | {b}"),
-            Expr::Xor(a, b) => write!(f, "{a} ^ {b}"),
+            Self::Lit(i) => write!(f, "{i}"),
+            Self::Var(v) => write!(f, "{v}"),
+            Self::Paren(e) => write!(f, "({e})"),
+            Self::Neg(e) => write!(f, "-{e}"),
+            Self::Add(a, b) => write!(f, "{a} + {b}"),
+            Self::Sub(a, b) => write!(f, "{a} - {b}"),
+            Self::Mul(a, b) => write!(f, "{a} * {b}"),
+            Self::Div(a, b) => write!(f, "{a} / {b}"),
+            Self::Mod(a, b) => write!(f, "{a} % {b}"),
+            Self::Eq(a, b) => write!(f, "{a} = {b}"),
+            Self::Neq(a, b) => write!(f, "{a} != {b}"),
+            Self::Lt(a, b) => write!(f, "{a} < {b}"),
+            Self::Lte(a, b) => write!(f, "{a} <= {b}"),
+            Self::Gt(a, b) => write!(f, "{a} > {b}"),
+            Self::Gte(a, b) => write!(f, "{a} >= {b}"),
+            Self::Not(e) => write!(f, "!{e}"),
+            Self::And(a, b) => write!(f, "{a} & {b}"),
+            Self::Or(a, b) => write!(f, "{a} | {b}"),
+            Self::Xor(a, b) => write!(f, "{a} ^ {b}"),
         }
     }
 }
@@ -196,9 +196,9 @@ impl fmt::Display for FormulaSpec {
 impl fmt::Display for Spec {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Spec::Date(spec) => write!(f, "{spec}"),
-            Spec::Weekday(spec) => write!(f, "{spec}"),
-            Spec::Formula(spec) => write!(f, "{spec}"),
+            Self::Date(spec) => write!(f, "{spec}"),
+            Self::Weekday(spec) => write!(f, "{spec}"),
+            Self::Formula(spec) => write!(f, "{spec}"),
         }
     }
 }
@@ -216,14 +216,14 @@ impl fmt::Display for BirthdaySpec {
 impl fmt::Display for Statement {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Statement::Date(spec) => writeln!(f, "DATE {spec}"),
-            Statement::BDate(spec) => writeln!(f, "BDATE {spec}"),
-            Statement::From(Some(date)) => writeln!(f, "FROM {date}"),
-            Statement::From(None) => writeln!(f, "FROM *"),
-            Statement::Until(Some(date)) => writeln!(f, "UNTIL {date}"),
-            Statement::Until(None) => writeln!(f, "UNTIL *"),
-            Statement::Except(date) => writeln!(f, "EXCEPT {date}"),
-            Statement::Move {
+            Self::Date(spec) => writeln!(f, "DATE {spec}"),
+            Self::BDate(spec) => writeln!(f, "BDATE {spec}"),
+            Self::From(Some(date)) => writeln!(f, "FROM {date}"),
+            Self::From(None) => writeln!(f, "FROM *"),
+            Self::Until(Some(date)) => writeln!(f, "UNTIL {date}"),
+            Self::Until(None) => writeln!(f, "UNTIL *"),
+            Self::Except(date) => writeln!(f, "EXCEPT {date}"),
+            Self::Move {
                 from, to, to_time, ..
             } => match (to, to_time) {
                 (None, None) => unreachable!(),
@@ -231,8 +231,8 @@ impl fmt::Display for Statement {
                 (None, Some(to_time)) => writeln!(f, "MOVE {from} TO {to_time}"),
                 (Some(to), Some(to_time)) => writeln!(f, "MOVE {from} TO {to} {to_time}"),
             },
-            Statement::Remind(Some(delta)) => writeln!(f, "REMIND {delta}"),
-            Statement::Remind(None) => writeln!(f, "REMIND *"),
+            Self::Remind(Some(delta)) => writeln!(f, "REMIND {delta}"),
+            Self::Remind(None) => writeln!(f, "REMIND *"),
         }
     }
 }
@@ -240,15 +240,15 @@ impl fmt::Display for Statement {
 impl fmt::Display for DoneDate {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.simplified() {
-            DoneDate::Date { root } => write!(f, "{root}"),
-            DoneDate::DateTime { root, root_time } => write!(f, "{root} {root_time}"),
-            DoneDate::DateToDate { root, other } => write!(f, "{root} -- {other}"),
-            DoneDate::DateTimeToTime {
+            Self::Date { root } => write!(f, "{root}"),
+            Self::DateTime { root, root_time } => write!(f, "{root} {root_time}"),
+            Self::DateToDate { root, other } => write!(f, "{root} -- {other}"),
+            Self::DateTimeToTime {
                 root,
                 root_time,
                 other_time,
             } => write!(f, "{root} {root_time} -- {other_time}"),
-            DoneDate::DateTimeToDateTime {
+            Self::DateTimeToDateTime {
                 root,
                 root_time,
                 other,
@@ -308,12 +308,12 @@ impl fmt::Display for Log {
 impl fmt::Display for Command {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Command::Include(name) => writeln!(f, "INCLUDE {name}"),
-            Command::Timezone(name) => writeln!(f, "TIMEZONE {name}"),
-            Command::Capture => writeln!(f, "CAPTURE"),
-            Command::Task(task) => write!(f, "{task}"),
-            Command::Note(note) => write!(f, "{note}"),
-            Command::Log(log) => write!(f, "{log}"),
+            Self::Include(name) => writeln!(f, "INCLUDE {name}"),
+            Self::Timezone(name) => writeln!(f, "TIMEZONE {name}"),
+            Self::Capture => writeln!(f, "CAPTURE"),
+            Self::Task(task) => write!(f, "{task}"),
+            Self::Note(note) => write!(f, "{note}"),
+            Self::Log(log) => write!(f, "{log}"),
         }
     }
 }
diff --git a/src/files/primitives.rs b/src/files/primitives.rs
index e63b867..b4a9dc2 100644
--- a/src/files/primitives.rs
+++ b/src/files/primitives.rs
@@ -206,13 +206,13 @@ impl Weekday {
     /// `Saturday`, `Sunday`).
     pub fn full_name(self) -> &'static str {
         match self {
-            Weekday::Monday => "Monday",
-            Weekday::Tuesday => "Tuesday",
-            Weekday::Wednesday => "Wednesday",
-            Weekday::Thursday => "Thursday",
-            Weekday::Friday => "Friday",
-            Weekday::Saturday => "Saturday",
-            Weekday::Sunday => "Sunday",
+            Self::Monday => "Monday",
+            Self::Tuesday => "Tuesday",
+            Self::Wednesday => "Wednesday",
+            Self::Thursday => "Thursday",
+            Self::Friday => "Friday",
+            Self::Saturday => "Saturday",
+            Self::Sunday => "Sunday",
         }
     }
 

From f01c3818c0209196ded18e20af6cbe72d8cd9a19 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Mon, 31 Oct 2022 18:06:49 +0100
Subject: [PATCH 71/80] Ignore some false positives

---
 src/cli/error.rs   | 1 +
 src/error.rs       | 3 +++
 src/eval/error.rs  | 1 +
 src/files/error.rs | 2 ++
 4 files changed, 7 insertions(+)

diff --git a/src/cli/error.rs b/src/cli/error.rs
index ef35e12..05b239a 100644
--- a/src/cli/error.rs
+++ b/src/cli/error.rs
@@ -40,6 +40,7 @@ impl<'a, F> Eprint<'a, F> for Error
 where
     F: Files<'a, FileId = FileSource>,
 {
+    #[allow(single_use_lifetimes)]
     fn eprint<'f: 'a>(&self, files: &'f F, config: &Config) {
         match self {
             Self::Eval(e) => e.eprint(files, config),
diff --git a/src/error.rs b/src/error.rs
index b8a658e..2cee250 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -4,6 +4,7 @@ use codespan_reporting::term::{self, Config};
 use termcolor::StandardStream;
 
 pub trait Eprint<'a, F: Files<'a>> {
+    #[allow(single_use_lifetimes)]
     fn eprint_diagnostic<'f: 'a>(
         files: &'f F,
         config: &Config,
@@ -15,9 +16,11 @@ pub trait Eprint<'a, F: Files<'a>> {
         }
     }
 
+    #[allow(single_use_lifetimes)]
     fn eprint<'f: 'a>(&self, files: &'f F, config: &Config);
 }
 
+#[allow(single_use_lifetimes)]
 pub fn eprint_error<'a, 'f: 'a, F, E>(files: &'f F, e: &E)
 where
     F: Files<'a>,
diff --git a/src/eval/error.rs b/src/eval/error.rs
index d2cd7dd..d2225fb 100644
--- a/src/eval/error.rs
+++ b/src/eval/error.rs
@@ -88,6 +88,7 @@ impl<S> Error<S> {
 }
 
 impl<'a, F: Files<'a>> Eprint<'a, F> for Error<F::FileId> {
+    #[allow(single_use_lifetimes)]
     fn eprint<'f: 'a>(&self, files: &'f F, config: &Config) {
         let diagnostic = match self {
             Error::DeltaInvalidStep {
diff --git a/src/files/error.rs b/src/files/error.rs
index 40fa7f7..f2e961a 100644
--- a/src/files/error.rs
+++ b/src/files/error.rs
@@ -69,6 +69,7 @@ impl<'a, F> Eprint<'a, F> for ParseError<F::FileId>
 where
     F: codespan_reporting::files::Files<'a>,
 {
+    #[allow(single_use_lifetimes)]
     fn eprint<'f: 'a>(&self, files: &'f F, config: &Config) {
         let range = match self.error.location {
             InputLocation::Pos(at) => at..at,
@@ -132,6 +133,7 @@ pub enum Error {
 }
 
 impl<'a> Eprint<'a, Files> for Error {
+    #[allow(single_use_lifetimes)]
     fn eprint<'f: 'a>(&self, files: &'f Files, config: &Config) {
         match self {
             Self::ResolvePath { path, error } => {

From 11d9a2f1c7534f697b455cdabe8392006e263db9 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Tue, 1 Nov 2022 14:55:08 +0100
Subject: [PATCH 72/80] Switch to pratt parser

---
 src/files/parse.rs | 27 +++++++++++++--------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/src/files/parse.rs b/src/files/parse.rs
index 574d785..90d9ffe 100644
--- a/src/files/parse.rs
+++ b/src/files/parse.rs
@@ -4,7 +4,7 @@ use std::result;
 use chrono::NaiveDate;
 use pest::error::ErrorVariant;
 use pest::iterators::Pair;
-use pest::prec_climber::{Assoc, Operator, PrecClimber};
+use pest::pratt_parser::{Assoc, Op, PrattParser};
 use pest::{Parser, Span};
 
 use super::commands::{
@@ -429,21 +429,20 @@ fn parse_op(l: Spanned<Expr>, p: Pair<'_, Rule>, r: Spanned<Expr>) -> Spanned<Ex
 fn parse_expr(p: Pair<'_, Rule>) -> Spanned<Expr> {
     assert_eq!(p.as_rule(), Rule::expr);
 
-    fn op(rule: Rule) -> Operator<Rule> {
-        Operator::new(rule, Assoc::Left)
+    fn infl(rule: Rule) -> Op<Rule> {
+        Op::infix(rule, Assoc::Left)
     }
 
-    let climber = PrecClimber::new(vec![
-        // Precedence from low to high
-        op(Rule::op_or) | op(Rule::op_xor),
-        op(Rule::op_and),
-        op(Rule::op_eq) | op(Rule::op_neq),
-        op(Rule::op_lt) | op(Rule::op_lte) | op(Rule::op_gt) | op(Rule::op_gte),
-        op(Rule::op_mul) | op(Rule::op_div) | op(Rule::op_mod),
-        op(Rule::op_add) | op(Rule::op_sub),
-    ]);
-
-    climber.climb(p.into_inner(), parse_term, parse_op)
+    PrattParser::new()
+        .op(infl(Rule::op_or) | infl(Rule::op_xor))
+        .op(infl(Rule::op_and))
+        .op(infl(Rule::op_eq) | infl(Rule::op_neq))
+        .op(infl(Rule::op_lt) | infl(Rule::op_lte) | infl(Rule::op_gt) | infl(Rule::op_gte))
+        .op(infl(Rule::op_mul) | infl(Rule::op_div) | infl(Rule::op_mod))
+        .op(infl(Rule::op_add) | infl(Rule::op_sub))
+        .map_primary(parse_term)
+        .map_infix(parse_op)
+        .parse(p.into_inner())
 }
 
 fn parse_date_expr_start(p: Pair<'_, Rule>, spec: &mut FormulaSpec) -> Result<()> {

From 23b0a5e5fc6af410398c2c81bffba68de34901da Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Tue, 1 Nov 2022 15:14:30 +0100
Subject: [PATCH 73/80] Use pratt parser for prefix logic

---
 src/files/grammar.pest | 47 ++++++++++++-----------
 src/files/parse.rs     | 84 ++++++++++++++++++++----------------------
 2 files changed, 62 insertions(+), 69 deletions(-)

diff --git a/src/files/grammar.pest b/src/files/grammar.pest
index 278c4b6..a808d4e 100644
--- a/src/files/grammar.pest
+++ b/src/files/grammar.pest
@@ -59,34 +59,33 @@ variable = {
     | "e"
 }
 
-unop_neg = { "-" }
-unop_not = { "!" }
-unop = _{ unop_neg | unop_not }
+prefix_neg = { "-" }
+prefix_not = { "!" }
+prefix = _{ prefix_neg | prefix_not }
 
-op_add = { "+" }
-op_sub = { "-" }
-op_mul = { "*" }
-op_div = { "/" }
-op_mod = { "%" }
-op_eq = { "=" }
-op_neq = { "!=" }
-op_lt = { "<" }
-op_lte = { "<=" }
-op_gt = { ">" }
-op_gte = { ">=" }
-op_and = { "&" }
-op_or = { "|" }
-op_xor = { "^" }
-op = _{
-    op_add | op_sub | op_mul | op_div | op_mod
-    | op_eq | op_neq | op_lt | op_lte | op_gt | op_gte
-    | op_and | op_or | op_xor
+infix_add = { "+" }
+infix_sub = { "-" }
+infix_mul = { "*" }
+infix_div = { "/" }
+infix_mod = { "%" }
+infix_eq = { "=" }
+infix_neq = { "!=" }
+infix_lt = { "<" }
+infix_lte = { "<=" }
+infix_gt = { ">" }
+infix_gte = { ">=" }
+infix_and = { "&" }
+infix_or = { "|" }
+infix_xor = { "^" }
+infix = _{
+    infix_add | infix_sub | infix_mul | infix_div | infix_mod
+    | infix_eq | infix_neq | infix_lt | infix_lte | infix_gt | infix_gte
+    | infix_and | infix_or | infix_xor
 }
 
 paren_expr = { "(" ~ expr ~ ")" }
-unop_expr = { unop ~ expr }
-term = { number | boolean | variable | paren_expr | unop_expr }
-expr = { term ~ (op ~ term)* }
+term = { number | boolean | variable | paren_expr }
+expr = { prefix* ~ term ~ (infix ~ prefix* ~ term)* }
 
 date_fixed_start = { datum ~ delta? ~ time? }
 date_fixed_end = { datum ~ delta? ~ time? | delta ~ time? | time }
diff --git a/src/files/parse.rs b/src/files/parse.rs
index 90d9ffe..7110075 100644
--- a/src/files/parse.rs
+++ b/src/files/parse.rs
@@ -359,24 +359,6 @@ fn parse_variable(p: Pair<'_, Rule>) -> Var {
     }
 }
 
-fn parse_unop_expr(p: Pair<'_, Rule>) -> Spanned<Expr> {
-    assert_eq!(p.as_rule(), Rule::unop_expr);
-    let span = (&p.as_span()).into();
-
-    let mut p = p.into_inner();
-    let p_op = p.next().unwrap();
-    let p_expr = p.next().unwrap();
-    assert_eq!(p.next(), None);
-
-    let inner = parse_expr(p_expr);
-    let expr = match p_op.as_rule() {
-        Rule::unop_neg => Expr::Neg(Box::new(inner)),
-        Rule::unop_not => Expr::Not(Box::new(inner)),
-        _ => unreachable!(),
-    };
-    Spanned::new(span, expr)
-}
-
 fn parse_paren_expr(p: Pair<'_, Rule>) -> Spanned<Expr> {
     assert_eq!(p.as_rule(), Rule::paren_expr);
     let span = (&p.as_span()).into();
@@ -392,34 +374,43 @@ fn parse_term(p: Pair<'_, Rule>) -> Spanned<Expr> {
         Rule::number => Spanned::new(span, Expr::Lit(parse_number(p).into())),
         Rule::boolean => Spanned::new(span, Expr::Var(parse_boolean(p))),
         Rule::variable => Spanned::new(span, Expr::Var(parse_variable(p))),
-        Rule::unop_expr => parse_unop_expr(p),
         Rule::paren_expr => parse_paren_expr(p),
         _ => unreachable!(),
     }
 }
 
-fn parse_op(l: Spanned<Expr>, p: Pair<'_, Rule>, r: Spanned<Expr>) -> Spanned<Expr> {
+fn parse_prefix(p: Pair<'_, Rule>, s: Spanned<Expr>) -> Spanned<Expr> {
+    let span = s.span.join((&p.as_span()).into());
+    let expr = match p.as_rule() {
+        Rule::prefix_neg => Expr::Neg(Box::new(s)),
+        Rule::prefix_not => Expr::Not(Box::new(s)),
+        _ => unreachable!(),
+    };
+    Spanned::new(span, expr)
+}
+
+fn parse_infix(l: Spanned<Expr>, p: Pair<'_, Rule>, r: Spanned<Expr>) -> Spanned<Expr> {
     let span = l.span.join(r.span);
     let expr = match p.as_rule() {
         // Integer-y operations
-        Rule::op_add => Expr::Add(Box::new(l), Box::new(r)),
-        Rule::op_sub => Expr::Sub(Box::new(l), Box::new(r)),
-        Rule::op_mul => Expr::Mul(Box::new(l), Box::new(r)),
-        Rule::op_div => Expr::Div(Box::new(l), Box::new(r)),
-        Rule::op_mod => Expr::Mod(Box::new(l), Box::new(r)),
+        Rule::infix_add => Expr::Add(Box::new(l), Box::new(r)),
+        Rule::infix_sub => Expr::Sub(Box::new(l), Box::new(r)),
+        Rule::infix_mul => Expr::Mul(Box::new(l), Box::new(r)),
+        Rule::infix_div => Expr::Div(Box::new(l), Box::new(r)),
+        Rule::infix_mod => Expr::Mod(Box::new(l), Box::new(r)),
 
         // Comparisons
-        Rule::op_eq => Expr::Eq(Box::new(l), Box::new(r)),
-        Rule::op_neq => Expr::Neq(Box::new(l), Box::new(r)),
-        Rule::op_lt => Expr::Lt(Box::new(l), Box::new(r)),
-        Rule::op_lte => Expr::Lte(Box::new(l), Box::new(r)),
-        Rule::op_gt => Expr::Gt(Box::new(l), Box::new(r)),
-        Rule::op_gte => Expr::Gte(Box::new(l), Box::new(r)),
+        Rule::infix_eq => Expr::Eq(Box::new(l), Box::new(r)),
+        Rule::infix_neq => Expr::Neq(Box::new(l), Box::new(r)),
+        Rule::infix_lt => Expr::Lt(Box::new(l), Box::new(r)),
+        Rule::infix_lte => Expr::Lte(Box::new(l), Box::new(r)),
+        Rule::infix_gt => Expr::Gt(Box::new(l), Box::new(r)),
+        Rule::infix_gte => Expr::Gte(Box::new(l), Box::new(r)),
 
         // Boolean-y operations
-        Rule::op_and => Expr::And(Box::new(l), Box::new(r)),
-        Rule::op_or => Expr::Or(Box::new(l), Box::new(r)),
-        Rule::op_xor => Expr::Xor(Box::new(l), Box::new(r)),
+        Rule::infix_and => Expr::And(Box::new(l), Box::new(r)),
+        Rule::infix_or => Expr::Or(Box::new(l), Box::new(r)),
+        Rule::infix_xor => Expr::Xor(Box::new(l), Box::new(r)),
 
         _ => unreachable!(),
     };
@@ -429,19 +420,22 @@ fn parse_op(l: Spanned<Expr>, p: Pair<'_, Rule>, r: Spanned<Expr>) -> Spanned<Ex
 fn parse_expr(p: Pair<'_, Rule>) -> Spanned<Expr> {
     assert_eq!(p.as_rule(), Rule::expr);
 
-    fn infl(rule: Rule) -> Op<Rule> {
-        Op::infix(rule, Assoc::Left)
-    }
-
     PrattParser::new()
-        .op(infl(Rule::op_or) | infl(Rule::op_xor))
-        .op(infl(Rule::op_and))
-        .op(infl(Rule::op_eq) | infl(Rule::op_neq))
-        .op(infl(Rule::op_lt) | infl(Rule::op_lte) | infl(Rule::op_gt) | infl(Rule::op_gte))
-        .op(infl(Rule::op_mul) | infl(Rule::op_div) | infl(Rule::op_mod))
-        .op(infl(Rule::op_add) | infl(Rule::op_sub))
+        .op(Op::infix(Rule::infix_or, Assoc::Left) | Op::infix(Rule::infix_xor, Assoc::Left))
+        .op(Op::infix(Rule::infix_and, Assoc::Left))
+        .op(Op::infix(Rule::infix_eq, Assoc::Left) | Op::infix(Rule::infix_neq, Assoc::Left))
+        .op(Op::infix(Rule::infix_lt, Assoc::Left)
+            | Op::infix(Rule::infix_lte, Assoc::Left)
+            | Op::infix(Rule::infix_gt, Assoc::Left)
+            | Op::infix(Rule::infix_gte, Assoc::Left))
+        .op(Op::infix(Rule::infix_mul, Assoc::Left)
+            | Op::infix(Rule::infix_div, Assoc::Left)
+            | Op::infix(Rule::infix_mod, Assoc::Left))
+        .op(Op::infix(Rule::infix_add, Assoc::Left) | Op::infix(Rule::infix_sub, Assoc::Left))
+        .op(Op::prefix(Rule::prefix_neg) | Op::prefix(Rule::prefix_not))
         .map_primary(parse_term)
-        .map_infix(parse_op)
+        .map_prefix(parse_prefix)
+        .map_infix(parse_infix)
         .parse(p.into_inner())
 }
 

From f3792fae6498172d2c645b28dc6bf6949c60180d Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Tue, 1 Nov 2022 16:41:37 +0100
Subject: [PATCH 74/80] Add marks to show which span a reminder belongs to

---
 CHANGELOG.md           |  3 +++
 src/cli/layout/line.rs | 16 +++++++++++++++-
 src/cli/print.rs       |  1 +
 3 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 33ddeb8..b969feb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## Unreleased
 
+### Added
+- Marks to show which span a reminder belongs to
+
 ### Changed
 - Birthdays for current day are now highlighted
 - Default value for `--range` argument
diff --git a/src/cli/layout/line.rs b/src/cli/layout/line.rs
index 79d0a43..5f5d686 100644
--- a/src/cli/layout/line.rs
+++ b/src/cli/layout/line.rs
@@ -36,6 +36,7 @@ impl SpanStyle {
 pub enum SpanSegment {
     Start(SpanStyle),
     Middle(SpanStyle),
+    Mark(SpanStyle),
     End(SpanStyle),
 }
 
@@ -44,6 +45,7 @@ impl SpanSegment {
         match self {
             Self::Start(s) => *s,
             Self::Middle(s) => *s,
+            Self::Mark(s) => *s,
             Self::End(s) => *s,
         }
     }
@@ -195,6 +197,7 @@ impl LineLayout {
             DayEntry::ReminderWhile(i, d) => {
                 let plural = if *d == 1 { "" } else { "s" };
                 let extra = format!("{d} day{plural} left");
+                self.mark_span(*i);
                 self.line_entry(entries, *i, today, Times::Untimed, Some(extra));
             }
             DayEntry::Undated(i) => {
@@ -246,6 +249,15 @@ impl LineLayout {
         self.spans.push(Some((index, SpanSegment::Start(style))));
     }
 
+    fn mark_span(&mut self, index: usize) {
+        for span in self.spans.iter_mut() {
+            match span {
+                Some((i, s)) if *i == index => *s = SpanSegment::Mark(s.style()),
+                _ => {}
+            }
+        }
+    }
+
     fn stop_span(&mut self, index: usize) {
         for span in self.spans.iter_mut() {
             match span {
@@ -258,7 +270,9 @@ impl LineLayout {
     fn step_spans(&mut self) {
         for span in self.spans.iter_mut() {
             match span {
-                Some((_, s @ SpanSegment::Start(_))) => *s = SpanSegment::Middle(s.style()),
+                Some((_, s @ (SpanSegment::Start(_) | SpanSegment::Mark(_)))) => {
+                    *s = SpanSegment::Middle(s.style())
+                }
                 Some((_, SpanSegment::End(_))) => *span = None,
                 _ => {}
             }
diff --git a/src/cli/print.rs b/src/cli/print.rs
index 471cd85..cabba63 100644
--- a/src/cli/print.rs
+++ b/src/cli/print.rs
@@ -141,6 +141,7 @@ impl ShowLines {
                     SpanSegment::Middle(SpanStyle::Solid) => "│".bright_black(),
                     SpanSegment::Middle(SpanStyle::Dashed) => "╎".bright_black(),
                     SpanSegment::Middle(SpanStyle::Dotted) => "┊".bright_black(),
+                    SpanSegment::Mark(_) => "┝".bright_black(),
                     SpanSegment::End(_) => "└".bright_black(),
                 };
                 result.push_str(&format!("{colored_str}"));

From 64c41b1073278f2eaeb3de10a13f0546f7f2b396 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sat, 11 Feb 2023 21:50:38 +0100
Subject: [PATCH 75/80] Satisfy clippy

---
 src/files/cli.rs   | 3 ++-
 src/files/error.rs | 6 +++---
 src/files/parse.rs | 6 +++---
 3 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/files/cli.rs b/src/files/cli.rs
index ddd804f..0efbfa4 100644
--- a/src/files/cli.rs
+++ b/src/files/cli.rs
@@ -13,7 +13,8 @@ fn from_str_via_parse<P, R>(s: &str, rule: Rule, parse: P) -> result::Result<R,
 where
     P: FnOnce(Pair<'_, Rule>) -> Result<R>,
 {
-    let mut pairs = TodayfileParser::parse(rule, s).map_err(|e| ParseError::new((), e))?;
+    let mut pairs =
+        TodayfileParser::parse(rule, s).map_err(|e| ParseError::new((), Box::new(e)))?;
     let p = pairs.next().unwrap();
     assert_eq!(pairs.next(), None);
 
diff --git a/src/files/error.rs b/src/files/error.rs
index f2e961a..dde9262 100644
--- a/src/files/error.rs
+++ b/src/files/error.rs
@@ -15,11 +15,11 @@ use super::{parse, FileSource, Files};
 #[error("{error}")]
 pub struct ParseError<S> {
     file: S,
-    error: parse::Error,
+    error: Box<parse::Error>,
 }
 
 impl<S> ParseError<S> {
-    pub fn new(file: S, error: parse::Error) -> Self {
+    pub fn new(file: S, error: Box<parse::Error>) -> Self {
         Self { file, error }
     }
 
@@ -104,7 +104,7 @@ pub enum Error {
     #[error("{error}")]
     Parse {
         file: FileSource,
-        error: parse::Error,
+        error: Box<parse::Error>,
     },
     #[error("Conflicting time zones {tz1} and {tz2}")]
     TzConflict {
diff --git a/src/files/parse.rs b/src/files/parse.rs
index 7110075..8ff2eca 100644
--- a/src/files/parse.rs
+++ b/src/files/parse.rs
@@ -18,7 +18,7 @@ use super::primitives::{Spanned, Time, Weekday};
 pub struct TodayfileParser;
 
 pub type Error = pest::error::Error<Rule>;
-pub type Result<T> = result::Result<T, Error>;
+pub type Result<T> = result::Result<T, Box<Error>>;
 
 fn error<S: Into<String>>(span: Span<'_>, message: S) -> Error {
     Error::new_from_span(
@@ -30,7 +30,7 @@ fn error<S: Into<String>>(span: Span<'_>, message: S) -> Error {
 }
 
 fn fail<S: Into<String>, T>(span: Span<'_>, message: S) -> Result<T> {
-    Err(error(span, message))
+    Err(Box::new(error(span, message)))
 }
 
 fn parse_include(p: Pair<'_, Rule>) -> Spanned<String> {
@@ -851,5 +851,5 @@ pub fn parse(path: &Path, input: &str) -> Result<File> {
     let file_pair = pairs.next().unwrap();
     assert_eq!(pairs.next(), None);
 
-    parse_file(file_pair).map_err(|e| e.with_path(&pathstr))
+    parse_file(file_pair).map_err(|e| Box::new(e.with_path(&pathstr)))
 }

From 4529f383fea8191c4a79ccadf475614929f3bf03 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sat, 11 Feb 2023 22:12:58 +0100
Subject: [PATCH 76/80] Update chrono

---
 Cargo.lock                   |   4 +-
 Cargo.toml                   |   2 +-
 src/eval/command/birthday.rs |   4 +-
 src/eval/command/date.rs     |   2 +-
 src/eval/command/formula.rs  | 771 ++++++++++++++++++-----------------
 src/eval/delta.rs            |  10 +-
 src/eval/range.rs            |   2 +-
 src/eval/util.rs             |   7 +-
 src/files/parse.rs           |   2 +-
 9 files changed, 409 insertions(+), 395 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 174496c..be2f02f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -69,9 +69,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chrono"
-version = "0.4.22"
+version = "0.4.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfd4d1b31faaa3a89d7934dbded3111da0d2ef28e3ebccdb4f0179f5929d1ef1"
+checksum = "16b0a3d9ed01224b22057780a37bb8c5dbfe1be8ba48678e7bf57ec4b385411f"
 dependencies = [
  "iana-time-zone",
  "js-sys",
diff --git a/Cargo.toml b/Cargo.toml
index 82c07b4..396b6c9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,7 +4,7 @@ version = "0.2.0"
 edition = "2021"
 
 [dependencies]
-chrono = "0.4.22"
+chrono = "0.4.23"
 clap = { version = "4.0.18", features = ["derive"] }
 codespan-reporting = "0.11.1"
 colored = "2.0.0"
diff --git a/src/eval/command/birthday.rs b/src/eval/command/birthday.rs
index 4f0cb32..d6c05c7 100644
--- a/src/eval/command/birthday.rs
+++ b/src/eval/command/birthday.rs
@@ -35,8 +35,8 @@ impl CommandState<'_> {
                 assert_eq!(spec.date.month(), 2);
                 assert_eq!(spec.date.day(), 29);
 
-                let first = NaiveDate::from_ymd(year, 2, 28);
-                let second = NaiveDate::from_ymd(year, 3, 1);
+                let first = NaiveDate::from_ymd_opt(year, 2, 28).unwrap();
+                let second = NaiveDate::from_ymd_opt(year, 3, 1).unwrap();
                 self.add(self.entry_with_remind(kind, Some(Dates::new(first, second)))?);
             }
         }
diff --git a/src/eval/command/date.rs b/src/eval/command/date.rs
index 9a895c2..58095f8 100644
--- a/src/eval/command/date.rs
+++ b/src/eval/command/date.rs
@@ -85,7 +85,7 @@ impl DateSpec {
                 let range_from = s
                     .command
                     .last_done_root()
-                    .map(|date| date.succ())
+                    .map(|date| date.succ_opt().unwrap())
                     .unwrap_or(self.start);
                 let range = s
                     .range_with_remind()
diff --git a/src/eval/command/formula.rs b/src/eval/command/formula.rs
index f50e0d8..138d3ce 100644
--- a/src/eval/command/formula.rs
+++ b/src/eval/command/formula.rs
@@ -89,7 +89,10 @@ impl Var {
                     date,
                     msg: e,
                 })?;
-                NaiveDate::from_ymd(e.year, e.month, e.day).ordinal().into()
+                NaiveDate::from_ymd_opt(e.year, e.month, e.day)
+                    .unwrap()
+                    .ordinal()
+                    .into()
             }
             Self::IsWeekday => {
                 let wd: Weekday = date.weekday().into();
@@ -332,7 +335,7 @@ impl FormulaSpec {
 
         if let EvalCommand::Task(_) = s.command {
             if let Some(last_done_root) = s.command.last_done_root() {
-                range = range.with_from(last_done_root.succ())?;
+                range = range.with_from(last_done_root.succ_opt().unwrap())?;
             } else if let Some(from) = s.from {
                 range = range.with_from(from)?;
             } else if matches!(s.command, EvalCommand::Task(_)) {
@@ -395,12 +398,22 @@ mod tests {
         }
     }
 
+    fn expr_ymd(e: &Expr, ymd: (i32, u32, u32), target: i64) {
+        let (y, m, d) = ymd;
+        expr(e, NaiveDate::from_ymd_opt(y, m, d).unwrap(), target);
+    }
+
+    fn expr_yo(e: &Expr, yo: (i32, u32), target: i64) {
+        let (y, o) = yo;
+        expr(e, NaiveDate::from_yo_opt(y, o).unwrap(), target);
+    }
+
     #[test]
     fn julian_day() {
         let e = Expr::Var(Var::JulianDay);
 
         for delta in -1000..1000 {
-            let d1 = NaiveDate::from_ymd(2021, 12, 19);
+            let d1 = NaiveDate::from_ymd_opt(2021, 12, 19).unwrap();
             let d2 = d1 + Duration::days(delta);
             assert_eq!(e.eval((), d2).unwrap() - e.eval((), d1).unwrap(), delta);
         }
@@ -411,21 +424,21 @@ mod tests {
         let e = Expr::Var(Var::Year);
 
         for y in -3000..=3000 {
-            expr(&e, NaiveDate::from_ymd(y, 2, 19), y.into());
+            expr_ymd(&e, (y, 2, 19), y.into());
         }
 
-        expr(&e, NaiveDate::from_ymd(2021, 1, 1), 2021);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 31), 2021);
+        expr_ymd(&e, (2021, 1, 1), 2021);
+        expr_ymd(&e, (2021, 12, 31), 2021);
     }
 
     #[test]
     fn year_length() {
         let e = Expr::Var(Var::YearLength);
 
-        expr(&e, NaiveDate::from_ymd(2000, 12, 19), 366);
-        expr(&e, NaiveDate::from_ymd(2019, 12, 19), 365);
-        expr(&e, NaiveDate::from_ymd(2020, 12, 19), 366);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 19), 365);
+        expr_ymd(&e, (2000, 12, 19), 366);
+        expr_ymd(&e, (2019, 12, 19), 365);
+        expr_ymd(&e, (2020, 12, 19), 366);
+        expr_ymd(&e, (2021, 12, 19), 365);
     }
 
     #[test]
@@ -433,11 +446,11 @@ mod tests {
         let e = Expr::Var(Var::YearDay);
 
         for i in 1..=365 {
-            expr(&e, NaiveDate::from_yo(2020, i), i.into());
-            expr(&e, NaiveDate::from_yo(2021, i), i.into());
+            expr_yo(&e, (2020, i), i.into());
+            expr_yo(&e, (2021, i), i.into());
         }
 
-        expr(&e, NaiveDate::from_yo(2020, 366), 366);
+        expr_yo(&e, (2020, 366), 366);
     }
 
     #[test]
@@ -445,14 +458,14 @@ mod tests {
         let e = Expr::Var(Var::YearDayReverse);
 
         for i in 1..=365 {
-            expr(&e, NaiveDate::from_yo(2020, i), (366 - i + 1).into());
-            expr(&e, NaiveDate::from_yo(2021, i), (365 - i + 1).into());
+            expr_yo(&e, (2020, i), (366 - i + 1).into());
+            expr_yo(&e, (2021, i), (365 - i + 1).into());
         }
 
-        expr(&e, NaiveDate::from_ymd(2020, 1, 1), 366);
-        expr(&e, NaiveDate::from_ymd(2021, 1, 1), 365);
-        expr(&e, NaiveDate::from_ymd(2020, 12, 31), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 31), 1);
+        expr_ymd(&e, (2020, 1, 1), 366);
+        expr_ymd(&e, (2021, 1, 1), 365);
+        expr_ymd(&e, (2020, 12, 31), 1);
+        expr_ymd(&e, (2021, 12, 31), 1);
     }
 
     #[test]
@@ -460,32 +473,32 @@ mod tests {
         let e = Expr::Var(Var::YearWeek);
 
         for y in 1000..3000 {
-            expr(&e, NaiveDate::from_ymd(y, 1, 1), 1);
-            expr(&e, NaiveDate::from_ymd(y, 1, 2), 1);
-            expr(&e, NaiveDate::from_ymd(y, 1, 3), 1);
-            expr(&e, NaiveDate::from_ymd(y, 1, 4), 1);
-            expr(&e, NaiveDate::from_ymd(y, 1, 5), 1);
-            expr(&e, NaiveDate::from_ymd(y, 1, 6), 1);
-            expr(&e, NaiveDate::from_ymd(y, 1, 7), 1);
-            expr(&e, NaiveDate::from_ymd(y, 1, 8), 2);
-            expr(&e, NaiveDate::from_ymd(y, 1, 9), 2);
-            expr(&e, NaiveDate::from_ymd(y, 1, 10), 2);
-            expr(&e, NaiveDate::from_ymd(y, 1, 11), 2);
-            expr(&e, NaiveDate::from_ymd(y, 1, 12), 2);
-            expr(&e, NaiveDate::from_ymd(y, 1, 13), 2);
-            expr(&e, NaiveDate::from_ymd(y, 1, 14), 2);
-            expr(&e, NaiveDate::from_ymd(y, 1, 15), 3);
+            expr_ymd(&e, (y, 1, 1), 1);
+            expr_ymd(&e, (y, 1, 2), 1);
+            expr_ymd(&e, (y, 1, 3), 1);
+            expr_ymd(&e, (y, 1, 4), 1);
+            expr_ymd(&e, (y, 1, 5), 1);
+            expr_ymd(&e, (y, 1, 6), 1);
+            expr_ymd(&e, (y, 1, 7), 1);
+            expr_ymd(&e, (y, 1, 8), 2);
+            expr_ymd(&e, (y, 1, 9), 2);
+            expr_ymd(&e, (y, 1, 10), 2);
+            expr_ymd(&e, (y, 1, 11), 2);
+            expr_ymd(&e, (y, 1, 12), 2);
+            expr_ymd(&e, (y, 1, 13), 2);
+            expr_ymd(&e, (y, 1, 14), 2);
+            expr_ymd(&e, (y, 1, 15), 3);
         }
 
-        expr(&e, NaiveDate::from_ymd(2020, 12, 28), 52);
-        expr(&e, NaiveDate::from_ymd(2020, 12, 29), 52);
-        expr(&e, NaiveDate::from_ymd(2020, 12, 30), 53);
-        expr(&e, NaiveDate::from_ymd(2020, 12, 31), 53);
+        expr_ymd(&e, (2020, 12, 28), 52);
+        expr_ymd(&e, (2020, 12, 29), 52);
+        expr_ymd(&e, (2020, 12, 30), 53);
+        expr_ymd(&e, (2020, 12, 31), 53);
 
-        expr(&e, NaiveDate::from_ymd(2021, 12, 28), 52);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 29), 52);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 30), 52);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 31), 53);
+        expr_ymd(&e, (2021, 12, 28), 52);
+        expr_ymd(&e, (2021, 12, 29), 52);
+        expr_ymd(&e, (2021, 12, 30), 52);
+        expr_ymd(&e, (2021, 12, 31), 53);
     }
 
     #[test]
@@ -493,32 +506,32 @@ mod tests {
         let e = Expr::Var(Var::YearWeekReverse);
 
         for y in 1000..3000 {
-            expr(&e, NaiveDate::from_ymd(y, 12, 31), 1);
-            expr(&e, NaiveDate::from_ymd(y, 12, 30), 1);
-            expr(&e, NaiveDate::from_ymd(y, 12, 29), 1);
-            expr(&e, NaiveDate::from_ymd(y, 12, 28), 1);
-            expr(&e, NaiveDate::from_ymd(y, 12, 27), 1);
-            expr(&e, NaiveDate::from_ymd(y, 12, 26), 1);
-            expr(&e, NaiveDate::from_ymd(y, 12, 25), 1);
-            expr(&e, NaiveDate::from_ymd(y, 12, 24), 2);
-            expr(&e, NaiveDate::from_ymd(y, 12, 23), 2);
-            expr(&e, NaiveDate::from_ymd(y, 12, 22), 2);
-            expr(&e, NaiveDate::from_ymd(y, 12, 21), 2);
-            expr(&e, NaiveDate::from_ymd(y, 12, 20), 2);
-            expr(&e, NaiveDate::from_ymd(y, 12, 19), 2);
-            expr(&e, NaiveDate::from_ymd(y, 12, 18), 2);
-            expr(&e, NaiveDate::from_ymd(y, 12, 17), 3);
+            expr_ymd(&e, (y, 12, 31), 1);
+            expr_ymd(&e, (y, 12, 30), 1);
+            expr_ymd(&e, (y, 12, 29), 1);
+            expr_ymd(&e, (y, 12, 28), 1);
+            expr_ymd(&e, (y, 12, 27), 1);
+            expr_ymd(&e, (y, 12, 26), 1);
+            expr_ymd(&e, (y, 12, 25), 1);
+            expr_ymd(&e, (y, 12, 24), 2);
+            expr_ymd(&e, (y, 12, 23), 2);
+            expr_ymd(&e, (y, 12, 22), 2);
+            expr_ymd(&e, (y, 12, 21), 2);
+            expr_ymd(&e, (y, 12, 20), 2);
+            expr_ymd(&e, (y, 12, 19), 2);
+            expr_ymd(&e, (y, 12, 18), 2);
+            expr_ymd(&e, (y, 12, 17), 3);
         }
 
-        expr(&e, NaiveDate::from_ymd(2020, 1, 1), 53);
-        expr(&e, NaiveDate::from_ymd(2020, 1, 2), 53);
-        expr(&e, NaiveDate::from_ymd(2020, 1, 3), 52);
-        expr(&e, NaiveDate::from_ymd(2020, 1, 4), 52);
+        expr_ymd(&e, (2020, 1, 1), 53);
+        expr_ymd(&e, (2020, 1, 2), 53);
+        expr_ymd(&e, (2020, 1, 3), 52);
+        expr_ymd(&e, (2020, 1, 4), 52);
 
-        expr(&e, NaiveDate::from_ymd(2021, 1, 1), 53);
-        expr(&e, NaiveDate::from_ymd(2021, 1, 2), 52);
-        expr(&e, NaiveDate::from_ymd(2021, 1, 3), 52);
-        expr(&e, NaiveDate::from_ymd(2021, 1, 4), 52);
+        expr_ymd(&e, (2021, 1, 1), 53);
+        expr_ymd(&e, (2021, 1, 2), 52);
+        expr_ymd(&e, (2021, 1, 3), 52);
+        expr_ymd(&e, (2021, 1, 4), 52);
     }
 
     #[test]
@@ -526,7 +539,7 @@ mod tests {
         let e = Expr::Var(Var::Month);
         for y in -1000..=3000 {
             for m in 1..=12 {
-                expr(&e, NaiveDate::from_ymd(y, m, 13), m.into());
+                expr_ymd(&e, (y, m, 13), m.into());
             }
         }
     }
@@ -535,96 +548,96 @@ mod tests {
     fn month_length() {
         let e = Expr::Var(Var::MonthLength);
 
-        expr(&e, NaiveDate::from_ymd(2021, 1, 5), 31);
-        expr(&e, NaiveDate::from_ymd(2021, 2, 5), 28);
-        expr(&e, NaiveDate::from_ymd(2021, 3, 5), 31);
-        expr(&e, NaiveDate::from_ymd(2021, 4, 5), 30);
-        expr(&e, NaiveDate::from_ymd(2021, 5, 5), 31);
-        expr(&e, NaiveDate::from_ymd(2021, 6, 5), 30);
-        expr(&e, NaiveDate::from_ymd(2021, 7, 5), 31);
-        expr(&e, NaiveDate::from_ymd(2021, 8, 5), 31);
-        expr(&e, NaiveDate::from_ymd(2021, 9, 5), 30);
-        expr(&e, NaiveDate::from_ymd(2021, 10, 5), 31);
-        expr(&e, NaiveDate::from_ymd(2021, 11, 5), 30);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 5), 31);
+        expr_ymd(&e, (2021, 1, 5), 31);
+        expr_ymd(&e, (2021, 2, 5), 28);
+        expr_ymd(&e, (2021, 3, 5), 31);
+        expr_ymd(&e, (2021, 4, 5), 30);
+        expr_ymd(&e, (2021, 5, 5), 31);
+        expr_ymd(&e, (2021, 6, 5), 30);
+        expr_ymd(&e, (2021, 7, 5), 31);
+        expr_ymd(&e, (2021, 8, 5), 31);
+        expr_ymd(&e, (2021, 9, 5), 30);
+        expr_ymd(&e, (2021, 10, 5), 31);
+        expr_ymd(&e, (2021, 11, 5), 30);
+        expr_ymd(&e, (2021, 12, 5), 31);
 
-        expr(&e, NaiveDate::from_ymd(2020, 2, 5), 29);
-        expr(&e, NaiveDate::from_ymd(2019, 2, 5), 28);
-        expr(&e, NaiveDate::from_ymd(2000, 2, 5), 29);
+        expr_ymd(&e, (2020, 2, 5), 29);
+        expr_ymd(&e, (2019, 2, 5), 28);
+        expr_ymd(&e, (2000, 2, 5), 29);
     }
 
     #[test]
     fn month_week() {
         let e = Expr::Var(Var::MonthWeek);
 
-        expr(&e, NaiveDate::from_ymd(2021, 12, 1), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 2), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 3), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 4), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 5), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 6), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 7), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 8), 2);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 9), 2);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 10), 2);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 11), 2);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 12), 2);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 13), 2);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 14), 2);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 15), 3);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 16), 3);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 17), 3);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 18), 3);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 19), 3);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 20), 3);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 21), 3);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 22), 4);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 23), 4);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 24), 4);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 25), 4);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 26), 4);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 27), 4);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 28), 4);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 29), 5);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 30), 5);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 31), 5);
+        expr_ymd(&e, (2021, 12, 1), 1);
+        expr_ymd(&e, (2021, 12, 2), 1);
+        expr_ymd(&e, (2021, 12, 3), 1);
+        expr_ymd(&e, (2021, 12, 4), 1);
+        expr_ymd(&e, (2021, 12, 5), 1);
+        expr_ymd(&e, (2021, 12, 6), 1);
+        expr_ymd(&e, (2021, 12, 7), 1);
+        expr_ymd(&e, (2021, 12, 8), 2);
+        expr_ymd(&e, (2021, 12, 9), 2);
+        expr_ymd(&e, (2021, 12, 10), 2);
+        expr_ymd(&e, (2021, 12, 11), 2);
+        expr_ymd(&e, (2021, 12, 12), 2);
+        expr_ymd(&e, (2021, 12, 13), 2);
+        expr_ymd(&e, (2021, 12, 14), 2);
+        expr_ymd(&e, (2021, 12, 15), 3);
+        expr_ymd(&e, (2021, 12, 16), 3);
+        expr_ymd(&e, (2021, 12, 17), 3);
+        expr_ymd(&e, (2021, 12, 18), 3);
+        expr_ymd(&e, (2021, 12, 19), 3);
+        expr_ymd(&e, (2021, 12, 20), 3);
+        expr_ymd(&e, (2021, 12, 21), 3);
+        expr_ymd(&e, (2021, 12, 22), 4);
+        expr_ymd(&e, (2021, 12, 23), 4);
+        expr_ymd(&e, (2021, 12, 24), 4);
+        expr_ymd(&e, (2021, 12, 25), 4);
+        expr_ymd(&e, (2021, 12, 26), 4);
+        expr_ymd(&e, (2021, 12, 27), 4);
+        expr_ymd(&e, (2021, 12, 28), 4);
+        expr_ymd(&e, (2021, 12, 29), 5);
+        expr_ymd(&e, (2021, 12, 30), 5);
+        expr_ymd(&e, (2021, 12, 31), 5);
     }
 
     #[test]
     fn month_week_reverse() {
         let e = Expr::Var(Var::MonthWeekReverse);
 
-        expr(&e, NaiveDate::from_ymd(2021, 12, 1), 5);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 2), 5);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 3), 5);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 4), 4);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 5), 4);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 6), 4);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 7), 4);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 8), 4);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 9), 4);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 10), 4);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 11), 3);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 12), 3);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 13), 3);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 14), 3);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 15), 3);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 16), 3);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 17), 3);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 18), 2);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 19), 2);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 20), 2);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 21), 2);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 22), 2);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 23), 2);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 24), 2);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 25), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 26), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 27), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 28), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 29), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 30), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 31), 1);
+        expr_ymd(&e, (2021, 12, 1), 5);
+        expr_ymd(&e, (2021, 12, 2), 5);
+        expr_ymd(&e, (2021, 12, 3), 5);
+        expr_ymd(&e, (2021, 12, 4), 4);
+        expr_ymd(&e, (2021, 12, 5), 4);
+        expr_ymd(&e, (2021, 12, 6), 4);
+        expr_ymd(&e, (2021, 12, 7), 4);
+        expr_ymd(&e, (2021, 12, 8), 4);
+        expr_ymd(&e, (2021, 12, 9), 4);
+        expr_ymd(&e, (2021, 12, 10), 4);
+        expr_ymd(&e, (2021, 12, 11), 3);
+        expr_ymd(&e, (2021, 12, 12), 3);
+        expr_ymd(&e, (2021, 12, 13), 3);
+        expr_ymd(&e, (2021, 12, 14), 3);
+        expr_ymd(&e, (2021, 12, 15), 3);
+        expr_ymd(&e, (2021, 12, 16), 3);
+        expr_ymd(&e, (2021, 12, 17), 3);
+        expr_ymd(&e, (2021, 12, 18), 2);
+        expr_ymd(&e, (2021, 12, 19), 2);
+        expr_ymd(&e, (2021, 12, 20), 2);
+        expr_ymd(&e, (2021, 12, 21), 2);
+        expr_ymd(&e, (2021, 12, 22), 2);
+        expr_ymd(&e, (2021, 12, 23), 2);
+        expr_ymd(&e, (2021, 12, 24), 2);
+        expr_ymd(&e, (2021, 12, 25), 1);
+        expr_ymd(&e, (2021, 12, 26), 1);
+        expr_ymd(&e, (2021, 12, 27), 1);
+        expr_ymd(&e, (2021, 12, 28), 1);
+        expr_ymd(&e, (2021, 12, 29), 1);
+        expr_ymd(&e, (2021, 12, 30), 1);
+        expr_ymd(&e, (2021, 12, 31), 1);
     }
 
     #[test]
@@ -632,78 +645,78 @@ mod tests {
         let e = Expr::Var(Var::Day);
 
         for d in 1..=31 {
-            expr(&e, NaiveDate::from_ymd(2020, 1, d), d.into());
-            expr(&e, NaiveDate::from_ymd(2020, 3, d), d.into());
-            expr(&e, NaiveDate::from_ymd(2020, 5, d), d.into());
-            expr(&e, NaiveDate::from_ymd(2020, 7, d), d.into());
-            expr(&e, NaiveDate::from_ymd(2020, 8, d), d.into());
-            expr(&e, NaiveDate::from_ymd(2020, 10, d), d.into());
-            expr(&e, NaiveDate::from_ymd(2020, 12, d), d.into());
+            expr_ymd(&e, (2020, 1, d), d.into());
+            expr_ymd(&e, (2020, 3, d), d.into());
+            expr_ymd(&e, (2020, 5, d), d.into());
+            expr_ymd(&e, (2020, 7, d), d.into());
+            expr_ymd(&e, (2020, 8, d), d.into());
+            expr_ymd(&e, (2020, 10, d), d.into());
+            expr_ymd(&e, (2020, 12, d), d.into());
 
-            expr(&e, NaiveDate::from_ymd(2021, 1, d), d.into());
-            expr(&e, NaiveDate::from_ymd(2021, 3, d), d.into());
-            expr(&e, NaiveDate::from_ymd(2021, 5, d), d.into());
-            expr(&e, NaiveDate::from_ymd(2021, 7, d), d.into());
-            expr(&e, NaiveDate::from_ymd(2021, 8, d), d.into());
-            expr(&e, NaiveDate::from_ymd(2021, 10, d), d.into());
-            expr(&e, NaiveDate::from_ymd(2021, 12, d), d.into());
+            expr_ymd(&e, (2021, 1, d), d.into());
+            expr_ymd(&e, (2021, 3, d), d.into());
+            expr_ymd(&e, (2021, 5, d), d.into());
+            expr_ymd(&e, (2021, 7, d), d.into());
+            expr_ymd(&e, (2021, 8, d), d.into());
+            expr_ymd(&e, (2021, 10, d), d.into());
+            expr_ymd(&e, (2021, 12, d), d.into());
         }
 
         for d in 1..=30 {
-            expr(&e, NaiveDate::from_ymd(2020, 4, d), d.into());
-            expr(&e, NaiveDate::from_ymd(2020, 6, d), d.into());
-            expr(&e, NaiveDate::from_ymd(2020, 9, d), d.into());
-            expr(&e, NaiveDate::from_ymd(2020, 11, d), d.into());
+            expr_ymd(&e, (2020, 4, d), d.into());
+            expr_ymd(&e, (2020, 6, d), d.into());
+            expr_ymd(&e, (2020, 9, d), d.into());
+            expr_ymd(&e, (2020, 11, d), d.into());
 
-            expr(&e, NaiveDate::from_ymd(2021, 4, d), d.into());
-            expr(&e, NaiveDate::from_ymd(2021, 6, d), d.into());
-            expr(&e, NaiveDate::from_ymd(2021, 9, d), d.into());
-            expr(&e, NaiveDate::from_ymd(2021, 11, d), d.into());
+            expr_ymd(&e, (2021, 4, d), d.into());
+            expr_ymd(&e, (2021, 6, d), d.into());
+            expr_ymd(&e, (2021, 9, d), d.into());
+            expr_ymd(&e, (2021, 11, d), d.into());
         }
 
         for d in 1..=28 {
-            expr(&e, NaiveDate::from_ymd(2020, 2, d), d.into());
-            expr(&e, NaiveDate::from_ymd(2021, 2, d), d.into());
+            expr_ymd(&e, (2020, 2, d), d.into());
+            expr_ymd(&e, (2021, 2, d), d.into());
         }
 
-        expr(&e, NaiveDate::from_ymd(2020, 2, 29), 29);
+        expr_ymd(&e, (2020, 2, 29), 29);
     }
 
     #[test]
     fn day_reverse() {
         let e = Expr::Var(Var::DayReverse);
 
-        expr(&e, NaiveDate::from_ymd(2021, 12, 1), 31);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 2), 30);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 3), 29);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 4), 28);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 5), 27);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 6), 26);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 7), 25);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 8), 24);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 9), 23);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 10), 22);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 11), 21);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 12), 20);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 13), 19);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 14), 18);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 15), 17);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 16), 16);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 17), 15);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 18), 14);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 19), 13);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 20), 12);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 21), 11);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 22), 10);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 23), 9);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 24), 8);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 25), 7);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 26), 6);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 27), 5);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 28), 4);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 29), 3);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 30), 2);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 31), 1);
+        expr_ymd(&e, (2021, 12, 1), 31);
+        expr_ymd(&e, (2021, 12, 2), 30);
+        expr_ymd(&e, (2021, 12, 3), 29);
+        expr_ymd(&e, (2021, 12, 4), 28);
+        expr_ymd(&e, (2021, 12, 5), 27);
+        expr_ymd(&e, (2021, 12, 6), 26);
+        expr_ymd(&e, (2021, 12, 7), 25);
+        expr_ymd(&e, (2021, 12, 8), 24);
+        expr_ymd(&e, (2021, 12, 9), 23);
+        expr_ymd(&e, (2021, 12, 10), 22);
+        expr_ymd(&e, (2021, 12, 11), 21);
+        expr_ymd(&e, (2021, 12, 12), 20);
+        expr_ymd(&e, (2021, 12, 13), 19);
+        expr_ymd(&e, (2021, 12, 14), 18);
+        expr_ymd(&e, (2021, 12, 15), 17);
+        expr_ymd(&e, (2021, 12, 16), 16);
+        expr_ymd(&e, (2021, 12, 17), 15);
+        expr_ymd(&e, (2021, 12, 18), 14);
+        expr_ymd(&e, (2021, 12, 19), 13);
+        expr_ymd(&e, (2021, 12, 20), 12);
+        expr_ymd(&e, (2021, 12, 21), 11);
+        expr_ymd(&e, (2021, 12, 22), 10);
+        expr_ymd(&e, (2021, 12, 23), 9);
+        expr_ymd(&e, (2021, 12, 24), 8);
+        expr_ymd(&e, (2021, 12, 25), 7);
+        expr_ymd(&e, (2021, 12, 26), 6);
+        expr_ymd(&e, (2021, 12, 27), 5);
+        expr_ymd(&e, (2021, 12, 28), 4);
+        expr_ymd(&e, (2021, 12, 29), 3);
+        expr_ymd(&e, (2021, 12, 30), 2);
+        expr_ymd(&e, (2021, 12, 31), 1);
     }
 
     #[test]
@@ -712,32 +725,32 @@ mod tests {
 
         // From https://en.wikipedia.org/wiki/ISO_week_date
 
-        expr(&e, NaiveDate::from_ymd(1977, 1, 1), 1976);
-        expr(&e, NaiveDate::from_ymd(1977, 1, 2), 1976);
-        expr(&e, NaiveDate::from_ymd(1977, 1, 3), 1977);
+        expr_ymd(&e, (1977, 1, 1), 1976);
+        expr_ymd(&e, (1977, 1, 2), 1976);
+        expr_ymd(&e, (1977, 1, 3), 1977);
 
-        expr(&e, NaiveDate::from_ymd(1977, 12, 31), 1977);
-        expr(&e, NaiveDate::from_ymd(1978, 1, 1), 1977);
-        expr(&e, NaiveDate::from_ymd(1978, 1, 2), 1978);
+        expr_ymd(&e, (1977, 12, 31), 1977);
+        expr_ymd(&e, (1978, 1, 1), 1977);
+        expr_ymd(&e, (1978, 1, 2), 1978);
 
-        expr(&e, NaiveDate::from_ymd(1978, 12, 31), 1978);
-        expr(&e, NaiveDate::from_ymd(1979, 1, 1), 1979);
+        expr_ymd(&e, (1978, 12, 31), 1978);
+        expr_ymd(&e, (1979, 1, 1), 1979);
 
-        expr(&e, NaiveDate::from_ymd(1979, 12, 30), 1979);
-        expr(&e, NaiveDate::from_ymd(1979, 12, 31), 1980);
-        expr(&e, NaiveDate::from_ymd(1980, 1, 1), 1980);
+        expr_ymd(&e, (1979, 12, 30), 1979);
+        expr_ymd(&e, (1979, 12, 31), 1980);
+        expr_ymd(&e, (1980, 1, 1), 1980);
 
-        expr(&e, NaiveDate::from_ymd(1980, 12, 28), 1980);
-        expr(&e, NaiveDate::from_ymd(1980, 12, 29), 1981);
-        expr(&e, NaiveDate::from_ymd(1980, 12, 30), 1981);
-        expr(&e, NaiveDate::from_ymd(1980, 12, 31), 1981);
-        expr(&e, NaiveDate::from_ymd(1981, 1, 1), 1981);
+        expr_ymd(&e, (1980, 12, 28), 1980);
+        expr_ymd(&e, (1980, 12, 29), 1981);
+        expr_ymd(&e, (1980, 12, 30), 1981);
+        expr_ymd(&e, (1980, 12, 31), 1981);
+        expr_ymd(&e, (1981, 1, 1), 1981);
 
-        expr(&e, NaiveDate::from_ymd(1981, 12, 31), 1981);
-        expr(&e, NaiveDate::from_ymd(1982, 1, 1), 1981);
-        expr(&e, NaiveDate::from_ymd(1982, 1, 2), 1981);
-        expr(&e, NaiveDate::from_ymd(1982, 1, 3), 1981);
-        expr(&e, NaiveDate::from_ymd(1982, 1, 4), 1982);
+        expr_ymd(&e, (1981, 12, 31), 1981);
+        expr_ymd(&e, (1982, 1, 1), 1981);
+        expr_ymd(&e, (1982, 1, 2), 1981);
+        expr_ymd(&e, (1982, 1, 3), 1981);
+        expr_ymd(&e, (1982, 1, 4), 1982);
     }
 
     #[test]
@@ -745,37 +758,37 @@ mod tests {
         let e = Expr::Var(Var::IsoYearLength);
 
         // August 1st is definitely in the same year in both systems
-        expr(&e, NaiveDate::from_ymd(2000, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2001, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2002, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2003, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2004, 8, 1), 52 * 7 + 7);
-        expr(&e, NaiveDate::from_ymd(2005, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2006, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2007, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2008, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2009, 8, 1), 52 * 7 + 7);
-        expr(&e, NaiveDate::from_ymd(2010, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2011, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2012, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2013, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2014, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2015, 8, 1), 52 * 7 + 7);
-        expr(&e, NaiveDate::from_ymd(2016, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2017, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2018, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2019, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2020, 8, 1), 52 * 7 + 7);
-        expr(&e, NaiveDate::from_ymd(2021, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2022, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2023, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2024, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2025, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2026, 8, 1), 52 * 7 + 7);
-        expr(&e, NaiveDate::from_ymd(2027, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2028, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2029, 8, 1), 52 * 7);
-        expr(&e, NaiveDate::from_ymd(2030, 8, 1), 52 * 7);
+        expr_ymd(&e, (2000, 8, 1), 52 * 7);
+        expr_ymd(&e, (2001, 8, 1), 52 * 7);
+        expr_ymd(&e, (2002, 8, 1), 52 * 7);
+        expr_ymd(&e, (2003, 8, 1), 52 * 7);
+        expr_ymd(&e, (2004, 8, 1), 52 * 7 + 7);
+        expr_ymd(&e, (2005, 8, 1), 52 * 7);
+        expr_ymd(&e, (2006, 8, 1), 52 * 7);
+        expr_ymd(&e, (2007, 8, 1), 52 * 7);
+        expr_ymd(&e, (2008, 8, 1), 52 * 7);
+        expr_ymd(&e, (2009, 8, 1), 52 * 7 + 7);
+        expr_ymd(&e, (2010, 8, 1), 52 * 7);
+        expr_ymd(&e, (2011, 8, 1), 52 * 7);
+        expr_ymd(&e, (2012, 8, 1), 52 * 7);
+        expr_ymd(&e, (2013, 8, 1), 52 * 7);
+        expr_ymd(&e, (2014, 8, 1), 52 * 7);
+        expr_ymd(&e, (2015, 8, 1), 52 * 7 + 7);
+        expr_ymd(&e, (2016, 8, 1), 52 * 7);
+        expr_ymd(&e, (2017, 8, 1), 52 * 7);
+        expr_ymd(&e, (2018, 8, 1), 52 * 7);
+        expr_ymd(&e, (2019, 8, 1), 52 * 7);
+        expr_ymd(&e, (2020, 8, 1), 52 * 7 + 7);
+        expr_ymd(&e, (2021, 8, 1), 52 * 7);
+        expr_ymd(&e, (2022, 8, 1), 52 * 7);
+        expr_ymd(&e, (2023, 8, 1), 52 * 7);
+        expr_ymd(&e, (2024, 8, 1), 52 * 7);
+        expr_ymd(&e, (2025, 8, 1), 52 * 7);
+        expr_ymd(&e, (2026, 8, 1), 52 * 7 + 7);
+        expr_ymd(&e, (2027, 8, 1), 52 * 7);
+        expr_ymd(&e, (2028, 8, 1), 52 * 7);
+        expr_ymd(&e, (2029, 8, 1), 52 * 7);
+        expr_ymd(&e, (2030, 8, 1), 52 * 7);
     }
 
     #[test]
@@ -784,52 +797,52 @@ mod tests {
 
         // From https://en.wikipedia.org/wiki/ISO_week_date
 
-        expr(&e, NaiveDate::from_ymd(1977, 1, 1), 53);
-        expr(&e, NaiveDate::from_ymd(1977, 1, 2), 53);
-        expr(&e, NaiveDate::from_ymd(1977, 1, 3), 1);
+        expr_ymd(&e, (1977, 1, 1), 53);
+        expr_ymd(&e, (1977, 1, 2), 53);
+        expr_ymd(&e, (1977, 1, 3), 1);
 
-        expr(&e, NaiveDate::from_ymd(1977, 12, 31), 52);
-        expr(&e, NaiveDate::from_ymd(1978, 1, 1), 52);
-        expr(&e, NaiveDate::from_ymd(1978, 1, 2), 1);
+        expr_ymd(&e, (1977, 12, 31), 52);
+        expr_ymd(&e, (1978, 1, 1), 52);
+        expr_ymd(&e, (1978, 1, 2), 1);
 
-        expr(&e, NaiveDate::from_ymd(1978, 12, 31), 52);
-        expr(&e, NaiveDate::from_ymd(1979, 1, 1), 1);
+        expr_ymd(&e, (1978, 12, 31), 52);
+        expr_ymd(&e, (1979, 1, 1), 1);
 
-        expr(&e, NaiveDate::from_ymd(1979, 12, 30), 52);
-        expr(&e, NaiveDate::from_ymd(1979, 12, 31), 1);
-        expr(&e, NaiveDate::from_ymd(1980, 1, 1), 1);
+        expr_ymd(&e, (1979, 12, 30), 52);
+        expr_ymd(&e, (1979, 12, 31), 1);
+        expr_ymd(&e, (1980, 1, 1), 1);
 
-        expr(&e, NaiveDate::from_ymd(1980, 12, 28), 52);
-        expr(&e, NaiveDate::from_ymd(1980, 12, 29), 1);
-        expr(&e, NaiveDate::from_ymd(1980, 12, 30), 1);
-        expr(&e, NaiveDate::from_ymd(1980, 12, 31), 1);
-        expr(&e, NaiveDate::from_ymd(1981, 1, 1), 1);
+        expr_ymd(&e, (1980, 12, 28), 52);
+        expr_ymd(&e, (1980, 12, 29), 1);
+        expr_ymd(&e, (1980, 12, 30), 1);
+        expr_ymd(&e, (1980, 12, 31), 1);
+        expr_ymd(&e, (1981, 1, 1), 1);
 
-        expr(&e, NaiveDate::from_ymd(1981, 12, 31), 53);
-        expr(&e, NaiveDate::from_ymd(1982, 1, 1), 53);
-        expr(&e, NaiveDate::from_ymd(1982, 1, 2), 53);
-        expr(&e, NaiveDate::from_ymd(1982, 1, 3), 53);
-        expr(&e, NaiveDate::from_ymd(1982, 1, 4), 1);
+        expr_ymd(&e, (1981, 12, 31), 53);
+        expr_ymd(&e, (1982, 1, 1), 53);
+        expr_ymd(&e, (1982, 1, 2), 53);
+        expr_ymd(&e, (1982, 1, 3), 53);
+        expr_ymd(&e, (1982, 1, 4), 1);
     }
 
     #[test]
     fn weekday() {
         let e = Expr::Var(Var::Weekday);
 
-        expr(&e, NaiveDate::from_ymd(2021, 12, 18), 6);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 19), 7);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 20), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 21), 2);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 22), 3);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 23), 4);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 24), 5);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 25), 6);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 26), 7);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 27), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 28), 2);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 29), 3);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 30), 4);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 31), 5);
+        expr_ymd(&e, (2021, 12, 18), 6);
+        expr_ymd(&e, (2021, 12, 19), 7);
+        expr_ymd(&e, (2021, 12, 20), 1);
+        expr_ymd(&e, (2021, 12, 21), 2);
+        expr_ymd(&e, (2021, 12, 22), 3);
+        expr_ymd(&e, (2021, 12, 23), 4);
+        expr_ymd(&e, (2021, 12, 24), 5);
+        expr_ymd(&e, (2021, 12, 25), 6);
+        expr_ymd(&e, (2021, 12, 26), 7);
+        expr_ymd(&e, (2021, 12, 27), 1);
+        expr_ymd(&e, (2021, 12, 28), 2);
+        expr_ymd(&e, (2021, 12, 29), 3);
+        expr_ymd(&e, (2021, 12, 30), 4);
+        expr_ymd(&e, (2021, 12, 31), 5);
     }
 
     #[test]
@@ -889,10 +902,10 @@ mod tests {
         ];
 
         for (y, m, d) in dates {
-            expr(
+            expr_ymd(
                 &e,
-                NaiveDate::from_ymd(y, 1, 1),
-                NaiveDate::from_ymd(y, m, d).ordinal().into(),
+                (y, 1, 1),
+                NaiveDate::from_ymd_opt(y, m, d).unwrap().ordinal().into(),
             );
         }
     }
@@ -901,77 +914,77 @@ mod tests {
     fn is_weekday() {
         let e = Expr::Var(Var::IsWeekday);
 
-        expr(&e, NaiveDate::from_ymd(2021, 12, 18), 0);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 19), 0);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 20), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 21), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 22), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 23), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 24), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 25), 0);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 26), 0);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 27), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 28), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 29), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 30), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 31), 1);
+        expr_ymd(&e, (2021, 12, 18), 0);
+        expr_ymd(&e, (2021, 12, 19), 0);
+        expr_ymd(&e, (2021, 12, 20), 1);
+        expr_ymd(&e, (2021, 12, 21), 1);
+        expr_ymd(&e, (2021, 12, 22), 1);
+        expr_ymd(&e, (2021, 12, 23), 1);
+        expr_ymd(&e, (2021, 12, 24), 1);
+        expr_ymd(&e, (2021, 12, 25), 0);
+        expr_ymd(&e, (2021, 12, 26), 0);
+        expr_ymd(&e, (2021, 12, 27), 1);
+        expr_ymd(&e, (2021, 12, 28), 1);
+        expr_ymd(&e, (2021, 12, 29), 1);
+        expr_ymd(&e, (2021, 12, 30), 1);
+        expr_ymd(&e, (2021, 12, 31), 1);
     }
 
     #[test]
     fn is_weekend() {
         let e = Expr::Var(Var::IsWeekend);
 
-        expr(&e, NaiveDate::from_ymd(2021, 12, 18), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 19), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 20), 0);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 21), 0);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 22), 0);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 23), 0);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 24), 0);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 25), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 26), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 27), 0);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 28), 0);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 29), 0);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 30), 0);
-        expr(&e, NaiveDate::from_ymd(2021, 12, 31), 0);
+        expr_ymd(&e, (2021, 12, 18), 1);
+        expr_ymd(&e, (2021, 12, 19), 1);
+        expr_ymd(&e, (2021, 12, 20), 0);
+        expr_ymd(&e, (2021, 12, 21), 0);
+        expr_ymd(&e, (2021, 12, 22), 0);
+        expr_ymd(&e, (2021, 12, 23), 0);
+        expr_ymd(&e, (2021, 12, 24), 0);
+        expr_ymd(&e, (2021, 12, 25), 1);
+        expr_ymd(&e, (2021, 12, 26), 1);
+        expr_ymd(&e, (2021, 12, 27), 0);
+        expr_ymd(&e, (2021, 12, 28), 0);
+        expr_ymd(&e, (2021, 12, 29), 0);
+        expr_ymd(&e, (2021, 12, 30), 0);
+        expr_ymd(&e, (2021, 12, 31), 0);
     }
 
     #[test]
     fn is_leap_year() {
         let e = Expr::Var(Var::IsLeapYear);
 
-        expr(&e, NaiveDate::from_ymd(2000, 1, 1), 1);
-        expr(&e, NaiveDate::from_ymd(2001, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2002, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2003, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2004, 1, 1), 1);
-        expr(&e, NaiveDate::from_ymd(2005, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2006, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2007, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2008, 1, 1), 1);
-        expr(&e, NaiveDate::from_ymd(2009, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2010, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2011, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2012, 1, 1), 1);
-        expr(&e, NaiveDate::from_ymd(2013, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2014, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2015, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2016, 1, 1), 1);
-        expr(&e, NaiveDate::from_ymd(2017, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2018, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2019, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2020, 1, 1), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2022, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2023, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2024, 1, 1), 1);
-        expr(&e, NaiveDate::from_ymd(2025, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2026, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2027, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2028, 1, 1), 1);
-        expr(&e, NaiveDate::from_ymd(2029, 1, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2030, 1, 1), 0);
+        expr_ymd(&e, (2000, 1, 1), 1);
+        expr_ymd(&e, (2001, 1, 1), 0);
+        expr_ymd(&e, (2002, 1, 1), 0);
+        expr_ymd(&e, (2003, 1, 1), 0);
+        expr_ymd(&e, (2004, 1, 1), 1);
+        expr_ymd(&e, (2005, 1, 1), 0);
+        expr_ymd(&e, (2006, 1, 1), 0);
+        expr_ymd(&e, (2007, 1, 1), 0);
+        expr_ymd(&e, (2008, 1, 1), 1);
+        expr_ymd(&e, (2009, 1, 1), 0);
+        expr_ymd(&e, (2010, 1, 1), 0);
+        expr_ymd(&e, (2011, 1, 1), 0);
+        expr_ymd(&e, (2012, 1, 1), 1);
+        expr_ymd(&e, (2013, 1, 1), 0);
+        expr_ymd(&e, (2014, 1, 1), 0);
+        expr_ymd(&e, (2015, 1, 1), 0);
+        expr_ymd(&e, (2016, 1, 1), 1);
+        expr_ymd(&e, (2017, 1, 1), 0);
+        expr_ymd(&e, (2018, 1, 1), 0);
+        expr_ymd(&e, (2019, 1, 1), 0);
+        expr_ymd(&e, (2020, 1, 1), 1);
+        expr_ymd(&e, (2021, 1, 1), 0);
+        expr_ymd(&e, (2022, 1, 1), 0);
+        expr_ymd(&e, (2023, 1, 1), 0);
+        expr_ymd(&e, (2024, 1, 1), 1);
+        expr_ymd(&e, (2025, 1, 1), 0);
+        expr_ymd(&e, (2026, 1, 1), 0);
+        expr_ymd(&e, (2027, 1, 1), 0);
+        expr_ymd(&e, (2028, 1, 1), 1);
+        expr_ymd(&e, (2029, 1, 1), 0);
+        expr_ymd(&e, (2030, 1, 1), 0);
     }
 
     #[test]
@@ -979,36 +992,36 @@ mod tests {
         let e = Expr::Var(Var::IsIsoLeapYear);
 
         // August 1st is definitely in the same year in both systems
-        expr(&e, NaiveDate::from_ymd(2000, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2001, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2002, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2003, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2004, 8, 1), 1);
-        expr(&e, NaiveDate::from_ymd(2005, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2006, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2007, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2008, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2009, 8, 1), 1);
-        expr(&e, NaiveDate::from_ymd(2010, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2011, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2012, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2013, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2014, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2015, 8, 1), 1);
-        expr(&e, NaiveDate::from_ymd(2016, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2017, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2018, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2019, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2020, 8, 1), 1);
-        expr(&e, NaiveDate::from_ymd(2021, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2022, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2023, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2024, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2025, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2026, 8, 1), 1);
-        expr(&e, NaiveDate::from_ymd(2027, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2028, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2029, 8, 1), 0);
-        expr(&e, NaiveDate::from_ymd(2030, 8, 1), 0);
+        expr_ymd(&e, (2000, 8, 1), 0);
+        expr_ymd(&e, (2001, 8, 1), 0);
+        expr_ymd(&e, (2002, 8, 1), 0);
+        expr_ymd(&e, (2003, 8, 1), 0);
+        expr_ymd(&e, (2004, 8, 1), 1);
+        expr_ymd(&e, (2005, 8, 1), 0);
+        expr_ymd(&e, (2006, 8, 1), 0);
+        expr_ymd(&e, (2007, 8, 1), 0);
+        expr_ymd(&e, (2008, 8, 1), 0);
+        expr_ymd(&e, (2009, 8, 1), 1);
+        expr_ymd(&e, (2010, 8, 1), 0);
+        expr_ymd(&e, (2011, 8, 1), 0);
+        expr_ymd(&e, (2012, 8, 1), 0);
+        expr_ymd(&e, (2013, 8, 1), 0);
+        expr_ymd(&e, (2014, 8, 1), 0);
+        expr_ymd(&e, (2015, 8, 1), 1);
+        expr_ymd(&e, (2016, 8, 1), 0);
+        expr_ymd(&e, (2017, 8, 1), 0);
+        expr_ymd(&e, (2018, 8, 1), 0);
+        expr_ymd(&e, (2019, 8, 1), 0);
+        expr_ymd(&e, (2020, 8, 1), 1);
+        expr_ymd(&e, (2021, 8, 1), 0);
+        expr_ymd(&e, (2022, 8, 1), 0);
+        expr_ymd(&e, (2023, 8, 1), 0);
+        expr_ymd(&e, (2024, 8, 1), 0);
+        expr_ymd(&e, (2025, 8, 1), 0);
+        expr_ymd(&e, (2026, 8, 1), 1);
+        expr_ymd(&e, (2027, 8, 1), 0);
+        expr_ymd(&e, (2028, 8, 1), 0);
+        expr_ymd(&e, (2029, 8, 1), 0);
+        expr_ymd(&e, (2030, 8, 1), 0);
     }
 }
diff --git a/src/eval/delta.rs b/src/eval/delta.rs
index f390cf2..b42d8a7 100644
--- a/src/eval/delta.rs
+++ b/src/eval/delta.rs
@@ -298,7 +298,7 @@ impl<S: Copy> DeltaEval<S> {
         };
 
         if time < curr_time {
-            self.curr = self.curr.succ();
+            self.curr = self.curr.succ_opt().unwrap();
         }
         self.curr_time = Some(time);
         Ok(())
@@ -359,13 +359,13 @@ mod tests {
     }
 
     fn apply_d(step: Step, from: (i32, u32, u32)) -> Result<NaiveDate, Error<()>> {
-        delta(step).apply_date((), NaiveDate::from_ymd(from.0, from.1, from.2))
+        delta(step).apply_date((), NaiveDate::from_ymd_opt(from.0, from.1, from.2).unwrap())
     }
 
     fn test_d(step: Step, from: (i32, u32, u32), expected: (i32, u32, u32)) {
         assert_eq!(
             apply_d(step, from).unwrap(),
-            NaiveDate::from_ymd(expected.0, expected.1, expected.2)
+            NaiveDate::from_ymd_opt(expected.0, expected.1, expected.2).unwrap()
         );
     }
 
@@ -375,7 +375,7 @@ mod tests {
     ) -> Result<(NaiveDate, Time), Error<()>> {
         delta(step).apply_date_time(
             (),
-            NaiveDate::from_ymd(from.0, from.1, from.2),
+            NaiveDate::from_ymd_opt(from.0, from.1, from.2).unwrap(),
             Time::new(from.3, from.4),
         )
     }
@@ -385,7 +385,7 @@ mod tests {
         assert_eq!(
             apply_dt(step, from).unwrap(),
             (
-                NaiveDate::from_ymd(expected.0, expected.1, expected.2),
+                NaiveDate::from_ymd_opt(expected.0, expected.1, expected.2).unwrap(),
                 Time::new(expected.3, expected.4)
             )
         );
diff --git a/src/eval/range.rs b/src/eval/range.rs
index 8a7cef5..88b6ec2 100644
--- a/src/eval/range.rs
+++ b/src/eval/range.rs
@@ -75,7 +75,7 @@ impl DateRange {
 
     pub fn days(&self) -> impl Iterator<Item = NaiveDate> {
         (self.from.num_days_from_ce()..=self.until.num_days_from_ce())
-            .map(NaiveDate::from_num_days_from_ce)
+            .map(|days| NaiveDate::from_num_days_from_ce_opt(days).unwrap())
     }
 
     pub fn years(&self) -> RangeInclusive<i32> {
diff --git a/src/eval/util.rs b/src/eval/util.rs
index 65b6ee4..9b010bc 100644
--- a/src/eval/util.rs
+++ b/src/eval/util.rs
@@ -9,13 +9,14 @@ pub fn is_iso_leap_year(year: i32) -> bool {
 }
 
 pub fn year_length(year: i32) -> u32 {
-    NaiveDate::from_ymd(year, 12, 31).ordinal()
+    NaiveDate::from_ymd_opt(year, 12, 31).unwrap().ordinal()
 }
 
 pub fn month_length(year: i32, month: u32) -> u32 {
     NaiveDate::from_ymd_opt(year, month + 1, 1)
-        .unwrap_or_else(|| NaiveDate::from_ymd(year + 1, 1, 1))
-        .pred()
+        .unwrap_or_else(|| NaiveDate::from_ymd_opt(year + 1, 1, 1).unwrap())
+        .pred_opt()
+        .unwrap()
         .day()
 }
 
diff --git a/src/files/parse.rs b/src/files/parse.rs
index 8ff2eca..067e765 100644
--- a/src/files/parse.rs
+++ b/src/files/parse.rs
@@ -293,7 +293,7 @@ fn parse_date_fixed(p: Pair<'_, Rule>) -> Result<DateSpec> {
     assert_eq!(p.as_rule(), Rule::date_fixed);
 
     let mut spec = DateSpec {
-        start: NaiveDate::from_ymd(0, 1, 1),
+        start: NaiveDate::from_ymd_opt(0, 1, 1).unwrap(),
         start_delta: None,
         start_time: None,
         end: None,

From cb470d201ee811e409d036c363b533068f6d55d5 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sat, 11 Feb 2023 22:24:15 +0100
Subject: [PATCH 77/80] Update dependencies

---
 Cargo.lock | 259 +++++++++++++++++++++++++++++++----------------------
 Cargo.toml |  10 +--
 2 files changed, 157 insertions(+), 112 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index be2f02f..4836ec3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -17,7 +17,7 @@ version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
 dependencies = [
- "hermit-abi",
+ "hermit-abi 0.1.19",
  "libc",
  "winapi",
 ]
@@ -45,9 +45,9 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.11.1"
+version = "3.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "572f695136211188308f16ad2ca5c851a712c464060ae6974944458eb83880ba"
+checksum = "0d261e256854913907f67ed06efbc3338dfe6179796deefc1ff763fc1aee5535"
 
 [[package]]
 name = "byteorder"
@@ -57,9 +57,9 @@ checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
 
 [[package]]
 name = "cc"
-version = "1.0.74"
+version = "1.0.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "581f5dba903aac52ea3feb5ec4810848460ee833876f1f9b0fdeab1f19091574"
+checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
 
 [[package]]
 name = "cfg-if"
@@ -84,14 +84,14 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.0.18"
+version = "4.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "335867764ed2de42325fafe6d18b8af74ba97ee0c590fa016f157535b42ab04b"
+checksum = "f13b9c79b5d1dd500d20ef541215a6423c75829ef43117e1b4d17fd8af0b5d76"
 dependencies = [
- "atty",
  "bitflags",
  "clap_derive",
  "clap_lex",
+ "is-terminal",
  "once_cell",
  "strsim",
  "termcolor",
@@ -99,9 +99,9 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.0.18"
+version = "4.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16a1b0f6422af32d5da0c58e2703320f379216ee70198241c84173a8c5ac28f3"
+checksum = "684a277d672e91966334af371f1a7b5833f9aa00b07c84e92fbce95e00208ce8"
 dependencies = [
  "heck",
  "proc-macro-error",
@@ -112,18 +112,18 @@ dependencies = [
 
 [[package]]
 name = "clap_lex"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d4198f73e42b4936b35b5bb248d81d2b595ecb170da0bac7655c54eedfa8da8"
+checksum = "783fe232adfca04f90f56201b26d79682d4cd2625e0bc7290b95123afe558ade"
 dependencies = [
  "os_str_bytes",
 ]
 
 [[package]]
 name = "clipboard-win"
-version = "4.4.2"
+version = "4.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4ab1b92798304eedc095b53942963240037c0516452cb11aeba709d420b2219"
+checksum = "7191c27c2357d9b7ef96baac1773290d4ca63b24205b82a3fd8a0637afcf0362"
 dependencies = [
  "error-code",
  "str-buf",
@@ -184,9 +184,9 @@ dependencies = [
 
 [[package]]
 name = "cxx"
-version = "1.0.80"
+version = "1.0.90"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b7d4e43b25d3c994662706a1d4fcfc32aaa6afd287502c111b237093bb23f3a"
+checksum = "90d59d9acd2a682b4e40605a242f6670eaa58c5957471cbf85e8aa6a0b97a5e8"
 dependencies = [
  "cc",
  "cxxbridge-flags",
@@ -196,9 +196,9 @@ dependencies = [
 
 [[package]]
 name = "cxx-build"
-version = "1.0.80"
+version = "1.0.90"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84f8829ddc213e2c1368e51a2564c552b65a8cb6a28f31e576270ac81d5e5827"
+checksum = "ebfa40bda659dd5c864e65f4c9a2b0aff19bea56b017b9b77c73d3766a453a38"
 dependencies = [
  "cc",
  "codespan-reporting",
@@ -211,15 +211,15 @@ dependencies = [
 
 [[package]]
 name = "cxxbridge-flags"
-version = "1.0.80"
+version = "1.0.90"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e72537424b474af1460806647c41d4b6d35d09ef7fe031c5c2fa5766047cc56a"
+checksum = "457ce6757c5c70dc6ecdbda6925b958aae7f959bda7d8fb9bde889e34a09dc03"
 
 [[package]]
 name = "cxxbridge-macro"
-version = "1.0.80"
+version = "1.0.90"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "309e4fb93eed90e1e14bea0da16b209f81813ba9fc7830c20ed151dd7bc0a4d7"
+checksum = "ebf883b7aacd7b2aeb2a7b338648ee19f57c140d4ee8e52c68979c6b2f7f2263"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -228,9 +228,9 @@ dependencies = [
 
 [[package]]
 name = "digest"
-version = "0.10.5"
+version = "0.10.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adfbc57365a37acbd2ebf2b64d7e69bb766e2fea813521ed536f5d0520dcf86c"
+checksum = "8168378f4e5023e7218c89c891c0fd8ecdb5e5e4f18cb78f38cf245dd021e76f"
 dependencies = [
  "block-buffer",
  "crypto-common",
@@ -289,9 +289,9 @@ dependencies = [
 
 [[package]]
 name = "either"
-version = "1.8.0"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"
+checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91"
 
 [[package]]
 name = "endian-type"
@@ -341,9 +341,9 @@ dependencies = [
 
 [[package]]
 name = "fd-lock"
-version = "3.0.6"
+version = "3.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e11dcc7e4d79a8c89b9ab4c6f5c30b1fc4a83c420792da3542fd31179ed5f517"
+checksum = "8ef1a30ae415c3a691a4f41afddc2dbcd6d70baf338368d85ebc1e8ed92cedb9"
 dependencies = [
  "cfg-if",
  "rustix",
@@ -373,9 +373,9 @@ dependencies = [
 
 [[package]]
 name = "heck"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
 
 [[package]]
 name = "hermit-abi"
@@ -386,6 +386,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "hermit-abi"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fed44880c466736ef9a5c5b5facefb5ed0785676d0c02d612db14e54f0d84286"
+
 [[package]]
 name = "iana-time-zone"
 version = "0.1.53"
@@ -421,15 +427,31 @@ dependencies = [
 
 [[package]]
 name = "io-lifetimes"
-version = "0.7.4"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6e481ccbe3dea62107216d0d1138bb8ad8e5e5c43009a098bd1990272c497b0"
+checksum = "1abeb7a0dd0f8181267ff8adc397075586500b81b28a73e8a0208b00fc170fb3"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
+[[package]]
+name = "is-terminal"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0a45d56fe973d6db23972bf5bc46f988a4a2385deac9cc29572f09daef"
+dependencies = [
+ "hermit-abi 0.3.1",
+ "io-lifetimes",
+ "rustix",
+ "windows-sys",
+]
 
 [[package]]
 name = "js-sys"
-version = "0.3.60"
+version = "0.3.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47"
+checksum = "445dde2150c55e483f3d8416706b97ec8e8237c307e5b7b4b8dd15e6af2a0730"
 dependencies = [
  "wasm-bindgen",
 ]
@@ -442,24 +464,24 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
 [[package]]
 name = "libc"
-version = "0.2.137"
+version = "0.2.139"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc7fcc620a3bff7cdd7a365be3376c97191aeaccc2a603e600951e452615bf89"
+checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79"
 
 [[package]]
 name = "link-cplusplus"
-version = "1.0.7"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9272ab7b96c9046fbc5bc56c06c117cb639fe2d509df0c421cad82d2915cf369"
+checksum = "ecd207c9c713c34f95a097a5b029ac2ce6010530c7b49d7fea24d977dede04f5"
 dependencies = [
  "cc",
 ]
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.0.46"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4d2456c373231a208ad294c33dc5bff30051eafd954cd4caae83a712b12854d"
+checksum = "f051f77a7c8e6957c0696eac88f26b0117e54f52d3fc682ab19397a8812846a4"
 
 [[package]]
 name = "log"
@@ -496,9 +518,9 @@ dependencies = [
 
 [[package]]
 name = "nix"
-version = "0.23.1"
+version = "0.23.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f866317acbd3a240710c63f065ffb1e4fd466259045ccb504130b7f668f35c6"
+checksum = "8f3790c00a0150112de0f4cd161e3d7fc4b2d8a5542ffc35f099a2562aecb35c"
 dependencies = [
  "bitflags",
  "cc",
@@ -528,21 +550,21 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.16.0"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86f0b0d4bf799edbc74508c1e8bf170ff5f41238e5f8225603ca7caaae2b7860"
+checksum = "6f61fba1741ea2b3d6a1e3178721804bb716a68a6aeba1149b5d52e3d464ea66"
 
 [[package]]
 name = "os_str_bytes"
-version = "6.3.1"
+version = "6.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3baf96e39c5359d2eb0dd6ccb42c62b91d9678aa68160d261b9e0ccbf9e9dea9"
+checksum = "9b7820b9daea5457c9f21c69448905d723fbd21136ccf521748f23fd49e723ee"
 
 [[package]]
 name = "pest"
-version = "2.4.0"
+version = "2.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbc7bc69c062e492337d74d59b120c274fd3d261b6bf6d3207d499b4b379c41a"
+checksum = "028accff104c4e513bad663bbcd2ad7cfd5304144404c31ed0a77ac103d00660"
 dependencies = [
  "thiserror",
  "ucd-trie",
@@ -550,9 +572,9 @@ dependencies = [
 
 [[package]]
 name = "pest_derive"
-version = "2.4.0"
+version = "2.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60b75706b9642ebcb34dab3bc7750f811609a0eb1dd8b88c2d15bf628c1c65b2"
+checksum = "2ac3922aac69a40733080f53c1ce7f91dcf57e1a5f6c52f421fadec7fbdc4b69"
 dependencies = [
  "pest",
  "pest_generator",
@@ -560,9 +582,9 @@ dependencies = [
 
 [[package]]
 name = "pest_generator"
-version = "2.4.0"
+version = "2.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4f9272122f5979a6511a749af9db9bfc810393f63119970d7085fed1c4ea0db"
+checksum = "d06646e185566b5961b4058dd107e0a7f56e77c3f484549fb119867773c0f202"
 dependencies = [
  "pest",
  "pest_meta",
@@ -573,13 +595,13 @@ dependencies = [
 
 [[package]]
 name = "pest_meta"
-version = "2.4.0"
+version = "2.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c8717927f9b79515e565a64fe46c38b8cd0427e64c40680b14a7365ab09ac8d"
+checksum = "e6f60b2ba541577e2a0c307c8f39d1439108120eb7903adeb6497fa880c59616"
 dependencies = [
  "once_cell",
  "pest",
- "sha1",
+ "sha2",
 ]
 
 [[package]]
@@ -608,9 +630,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.47"
+version = "1.0.51"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ea3d908b0e36316caf9e9e2c4625cdde190a7e6f440d794667ed17a1855e725"
+checksum = "5d727cae5b39d21da60fa540906919ad737832fe0b1c165da3a34d6548c849d6"
 dependencies = [
  "unicode-ident",
 ]
@@ -626,9 +648,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.21"
+version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
+checksum = "8856d8364d252a14d474036ea1358d63c9e6965c8e5c1885c18f73d70bff9c7b"
 dependencies = [
  "proc-macro2",
 ]
@@ -674,9 +696,9 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "0.35.12"
+version = "0.36.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "985947f9b6423159c4726323f373be0a21bdb514c5af06a849cb3d2dce2d01e8"
+checksum = "f43abb88211988493c1abb44a70efa56ff0ce98f233b7b276146f1f3f7ba9644"
 dependencies = [
  "bitflags",
  "errno",
@@ -718,15 +740,15 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
 name = "scratch"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8132065adcfd6e02db789d9285a0deb2f3fcb04002865ab67d5fb103533898"
+checksum = "ddccb15bcce173023b3fedd9436f882a0739b8dfb45e4f6b6002bee5929f61b2"
 
 [[package]]
-name = "sha1"
-version = "0.10.5"
+name = "sha2"
+version = "0.10.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f04293dc80c3993519f2d7f6f511707ee7094fe0c6d3406feb330cdb3540eba3"
+checksum = "82e6b795fe2e3b1e845bafcb27aa35405c4d47cdfc92af5fc8d3002f76cebdc0"
 dependencies = [
  "cfg-if",
  "cpufeatures",
@@ -753,9 +775,9 @@ checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
 
 [[package]]
 name = "syn"
-version = "1.0.103"
+version = "1.0.107"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a864042229133ada95abf3b54fdc62ef5ccabe9515b64717bcb9a1919e59445d"
+checksum = "1f4064b5b16e03ae50984a5a8ed5d4f8803e6bc1fd170a3cda91a1be4b18e3f5"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -778,27 +800,27 @@ dependencies = [
 
 [[package]]
 name = "termcolor"
-version = "1.1.3"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
+checksum = "be55cf8942feac5c765c2c993422806843c9a9a45d4d5c407ad6dd2ea95eb9b6"
 dependencies = [
  "winapi-util",
 ]
 
 [[package]]
 name = "thiserror"
-version = "1.0.37"
+version = "1.0.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10deb33631e3c9018b9baf9dcbbc4f737320d2b576bac10f6aefa048fa407e3e"
+checksum = "6a9cd18aa97d5c45c6603caea1da6628790b37f7a34b6ca89522331c5180fed0"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.37"
+version = "1.0.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "982d17546b47146b28f7c22e3d08465f6b8903d0ea13c1660d9d84a6e7adcdbb"
+checksum = "1fb327af4685e4d03fa8cbcf1716380da910eeb2bb8be417e7f9fd3fb164f36f"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -807,9 +829,9 @@ dependencies = [
 
 [[package]]
 name = "time"
-version = "0.1.44"
+version = "0.1.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6db9e6914ab8b1ae1c260a4ae7a49b6c5611b40328a735b21862567685e73255"
+checksum = "1b797afad3f312d1c66a56d11d0316f916356d11bd158fbc6ca6389ff6bf805a"
 dependencies = [
  "libc",
  "wasi 0.10.0+wasi-snapshot-preview1",
@@ -837,9 +859,9 @@ dependencies = [
 
 [[package]]
 name = "typenum"
-version = "1.15.0"
+version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
+checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"
 
 [[package]]
 name = "tzfile"
@@ -858,15 +880,15 @@ checksum = "9e79c4d996edb816c91e4308506774452e55e95c3c9de07b6729e17e15a5ef81"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.5"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ceab39d59e4c9499d4e5a8ee0e2735b891bb7308ac83dfb4e80cad195c9f6f3"
+checksum = "84a22b9f218b40614adcb3f4ff08b703773ad44fa9423e4e0d346d5db86e4ebc"
 
 [[package]]
 name = "unicode-segmentation"
-version = "1.10.0"
+version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fdbf052a0783de01e944a6ce7a8cb939e295b1e7be835a1112c3b9a7f047a5a"
+checksum = "1dd624098567895118886609431a7c3b8f516e41d30e0643f03d94592a147e36"
 
 [[package]]
 name = "unicode-width"
@@ -900,9 +922,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.83"
+version = "0.2.84"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268"
+checksum = "31f8dcbc21f30d9b8f2ea926ecb58f6b91192c17e9d33594b3df58b2007ca53b"
 dependencies = [
  "cfg-if",
  "wasm-bindgen-macro",
@@ -910,9 +932,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.83"
+version = "0.2.84"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142"
+checksum = "95ce90fd5bcc06af55a641a86428ee4229e44e07033963a2290a8e241607ccb9"
 dependencies = [
  "bumpalo",
  "log",
@@ -925,9 +947,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.83"
+version = "0.2.84"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "052be0f94026e6cbc75cdefc9bae13fd6052cdcaf532fa6c45e7ae33a1e6c810"
+checksum = "4c21f77c0bedc37fd5dc21f897894a5ca01e7bb159884559461862ae90c0b4c5"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -935,9 +957,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.83"
+version = "0.2.84"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07bc0c051dc5f23e307b13285f9d75df86bfdf816c5721e573dec1f9b8aa193c"
+checksum = "2aff81306fcac3c7515ad4e177f521b5c9a15f2b08f4e32d823066102f35a5f6"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -948,15 +970,15 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.83"
+version = "0.2.84"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f"
+checksum = "0046fef7e28c3804e5e38bfa31ea2a0f73905319b677e57ebe37e49358989b5d"
 
 [[package]]
 name = "which"
-version = "4.3.0"
+version = "4.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c831fbbee9e129a8cf93e7747a82da9d95ba8e16621cae60ec2cdc849bacb7b"
+checksum = "2441c784c52b289a054b7201fc93253e288f094e2f4be9058343127c4226a269"
 dependencies = [
  "either",
  "libc",
@@ -996,43 +1018,66 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "windows-sys"
-version = "0.36.1"
+version = "0.45.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea04155a16a59f9eab786fe12a4a450e75cdb175f9e0d80da1e17db09f55b8d2"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
 dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.42.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e2522491fbfcd58cc84d47aeb2958948c4b8982e9a2d8a2a35bbaed431390e7"
+dependencies = [
+ "windows_aarch64_gnullvm",
  "windows_aarch64_msvc",
  "windows_i686_gnu",
  "windows_i686_msvc",
  "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
  "windows_x86_64_msvc",
 ]
 
 [[package]]
-name = "windows_aarch64_msvc"
-version = "0.36.1"
+name = "windows_aarch64_gnullvm"
+version = "0.42.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9bb8c3fd39ade2d67e9874ac4f3db21f0d710bee00fe7cab16949ec184eeaa47"
+checksum = "8c9864e83243fdec7fc9c5444389dcbbfd258f745e7853198f365e3c4968a608"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c8b1b673ffc16c47a9ff48570a9d85e25d265735c503681332589af6253c6c7"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.36.1"
+version = "0.42.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "180e6ccf01daf4c426b846dfc66db1fc518f074baa793aa7d9b9aaeffad6a3b6"
+checksum = "de3887528ad530ba7bdbb1faa8275ec7a1155a45ffa57c37993960277145d640"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.36.1"
+version = "0.42.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2e7917148b2812d1eeafaeb22a97e4813dfa60a3f8f78ebe204bcc88f12f024"
+checksum = "bf4d1122317eddd6ff351aa852118a2418ad4214e6613a50e0191f7004372605"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.36.1"
+version = "0.42.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4dcd171b8776c41b97521e5da127a2d86ad280114807d0b2ab1e462bc764d9e1"
+checksum = "c1040f221285e17ebccbc2591ffdc2d44ee1f9186324dd3e84e99ac68d699c45"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "628bfdf232daa22b0d64fdb62b09fcc36bb01f05a3939e20ab73aaf9470d0463"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.36.1"
+version = "0.42.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c811ca4a8c853ef420abd8592ba53ddbbac90410fab6903b3e79972a631f7680"
+checksum = "447660ad36a13288b1db4d4248e857b510e8c3a225c822ba4fb748c0aafecffd"
diff --git a/Cargo.toml b/Cargo.toml
index 396b6c9..34106a8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,15 +5,15 @@ edition = "2021"
 
 [dependencies]
 chrono = "0.4.23"
-clap = { version = "4.0.18", features = ["derive"] }
+clap = { version = "4.1.4", features = ["derive"] }
 codespan-reporting = "0.11.1"
 colored = "2.0.0"
 computus = "1.0.0"
 directories = "4.0.1"
 edit = "0.1.4"
-pest = "2.4.0"
-pest_derive = "2.4.0"
+pest = "2.5.5"
+pest_derive = "2.5.5"
 promptly = "0.3.1"
-termcolor = "1.1.3"
-thiserror = "1.0.37"
+termcolor = "1.2.0"
+thiserror = "1.0.38"
 tzfile = { git = "https://github.com/Garmelon/tzfile.git", branch = "tzdir" }

From 4001d0653be1b9bffdb2d7a9ee053147506f499c Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Sat, 3 Aug 2024 03:31:37 +0200
Subject: [PATCH 78/80] Satisfy clippy

---
 src/files/format.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/files/format.rs b/src/files/format.rs
index 280d58c..e16569a 100644
--- a/src/files/format.rs
+++ b/src/files/format.rs
@@ -75,10 +75,10 @@ impl fmt::Display for DateSpec {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // Start
         write!(f, "{}", self.start)?;
-        for delta in &self.start_delta {
+        if let Some(delta) = &self.start_delta {
             write!(f, " {delta}")?;
         }
-        for time in &self.start_time {
+        if let Some(time) = &self.start_time {
             write!(f, " {time}")?;
         }
 
@@ -109,7 +109,7 @@ impl fmt::Display for WeekdaySpec {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // Start
         write!(f, "{}", self.start)?;
-        for time in &self.start_time {
+        if let Some(time) = &self.start_time {
             write!(f, " {time}")?;
         }
 
@@ -171,10 +171,10 @@ impl fmt::Display for FormulaSpec {
         } else {
             write!(f, "*")?;
         }
-        for delta in &self.start_delta {
+        if let Some(delta) = &self.start_delta {
             write!(f, " {delta}")?;
         }
-        for time in &self.start_time {
+        if let Some(time) = &self.start_time {
             write!(f, " {time}")?;
         }
 

From 22eec53c5ae1f6b14de7217c7ecf81496de5d712 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Thu, 21 Nov 2024 02:14:12 +0100
Subject: [PATCH 79/80] Move warnings to Cargo.toml

---
 Cargo.toml  | 16 ++++++++++++++++
 src/main.rs | 17 -----------------
 2 files changed, 16 insertions(+), 17 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 34106a8..0ae8a9f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,3 +17,19 @@ promptly = "0.3.1"
 termcolor = "1.2.0"
 thiserror = "1.0.38"
 tzfile = { git = "https://github.com/Garmelon/tzfile.git", branch = "tzdir" }
+
+[lints]
+rust.unsafe_code = { level = "forbid", priority = 1 }
+rust.future_incompatible = "warn"
+rust.rust_2018_idioms = "warn"
+rust.noop_method_call = "warn"
+rust.single_use_lifetimes = "warn"
+rust.trivial_numeric_casts = "warn"
+rust.unused = "warn"
+rust.unused_crate_dependencies = "warn"
+rust.unused_extern_crates = "warn"
+rust.unused_import_braces = "warn"
+rust.unused_lifetimes = "warn"
+rust.unused_qualifications = "warn"
+clippy.all = "warn"
+clippy.use_self = "warn"
diff --git a/src/main.rs b/src/main.rs
index 84013df..4897001 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,20 +1,3 @@
-#![deny(unsafe_code)]
-// Rustc lint groups
-#![warn(future_incompatible)]
-#![warn(rust_2018_idioms)]
-// Rustc lints
-#![warn(noop_method_call)]
-#![warn(single_use_lifetimes)]
-#![warn(trivial_numeric_casts)]
-#![warn(unused_crate_dependencies)]
-#![warn(unused_extern_crates)]
-#![warn(unused_import_braces)]
-#![warn(unused_lifetimes)]
-#![warn(unused_qualifications)]
-// Clippy lints
-#![warn(clippy::all)]
-#![warn(clippy::use_self)]
-
 mod cli;
 mod error;
 mod eval;

From abf4d5a502f9f97c59335c2f7b43cd76840b4079 Mon Sep 17 00:00:00 2001
From: Joscha <joscha@plugh.de>
Date: Thu, 21 Nov 2024 02:14:35 +0100
Subject: [PATCH 80/80] Silence remaining warnings

---
 src/eval/entry.rs | 1 +
 src/eval/range.rs | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/eval/entry.rs b/src/eval/entry.rs
index f0f1e74..7ee93e0 100644
--- a/src/eval/entry.rs
+++ b/src/eval/entry.rs
@@ -61,6 +61,7 @@ impl Entry {
 
 /// Mode that determines how entries are filtered when they are added to
 /// an [`Entries`].
+#[allow(dead_code)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum EntryMode {
     /// The entry's root date must be contained in the range.
diff --git a/src/eval/range.rs b/src/eval/range.rs
index 88b6ec2..51ddcc0 100644
--- a/src/eval/range.rs
+++ b/src/eval/range.rs
@@ -37,6 +37,7 @@ impl DateRange {
     /// Return a new range with its [`Self::until`] set to a new value.
     ///
     /// Returns [`None`] if the new value is earlier than [`Self::from`].
+    #[allow(dead_code)]
     pub fn with_until(&self, until: NaiveDate) -> Option<Self> {
         if self.from <= until {
             Some(Self::new(self.from, until))