Garmelon/today
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Unify Dates logic and expand DoneDate format

Browse source
This commit is contained in:
Joscha 2021-12-14 23:32:04 +01:00
parent 2e7ab3c4a1
commit c69af9bcde
8 changed files with 119 additions and 133 deletions
Download patch file Download diff file Expand all files Collapse all files

24
src/cli/layout/day.rs
View file

@ -80,7 +80,7 @@ impl DayLayout {
fn layout_task(&mut self, index: usize, entry: &Entry) {
if let Some(dates) = entry.dates {
let (start, end) = dates.start_end();
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();
@ -100,8 +100,9 @@ impl DayLayout {
fn layout_task_done(&mut self, index: usize, entry: &Entry, at: NaiveDate) {
if let Some(dates) = entry.dates {
if at > dates.end() {
let days = (at - dates.end()).num_days();
let (_, end) = dates.sorted().dates();
if at > end {
let days = (at - end).num_days();
self.insert(at, DayEntry::ReminderSince(index, days));
}
self.layout_dated_entry(index, dates);
@ -113,7 +114,7 @@ impl DayLayout {
fn layout_note(&mut self, index: usize, entry: &Entry) {
if let Some(dates) = entry.dates {
let (start, end) = dates.start_end();
let (start, end) = dates.sorted().dates();
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
@ -131,9 +132,10 @@ impl DayLayout {
}
fn layout_dated_entry(&mut self, index: usize, dates: Dates) {
let (start, end) = dates.start_end();
let sorted_dates = dates.sorted();
let (start, end) = sorted_dates.dates();
#[allow(clippy::if_same_then_else)] // Makes the code easier to read
if let Some((date, time)) = dates.point_in_time() {
if let Some((date, time)) = sorted_dates.point_in_time() {
let entry = match time {
Some(time) => DayEntry::TimedAt(index, time, None),
None => DayEntry::At(index),
@ -149,7 +151,7 @@ impl DayLayout {
// omit them both. Otherwise, we would get a bracket without any
// visible start or end.
} else {
let (start_entry, end_entry) = match dates.start_end_time() {
let (start_entry, end_entry) = match sorted_dates.times() {
Some((start_time, end_time)) => (
DayEntry::TimedStart(index, start_time),
DayEntry::TimedEnd(index, end_time),
@ -196,13 +198,13 @@ impl DayLayout {
// 2.
entries.sort_by(|(_, e1, _), (_, e2, _)| {
let d1 = e1.dates.map(|d| (d.end(), d.end_time()));
let d2 = e2.dates.map(|d| (d.end(), d.end_time()));
d2.cmp(&d1)
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.start(), d.start_time())));
entries.sort_by_key(|(_, e, _)| e.dates.map(|d| d.sorted().root_with_time()));
}
fn sort_day(day: &mut Vec<DayEntry>) {

16
src/cli/show.rs
View file

@ -145,22 +145,10 @@ pub fn show_entry(files: &Files, entry: &Entry) -> Result<()> {
}
if let Some(dates) = entry.dates {
let (start, end) = dates.start_end();
if start == end {
match dates.start_end_time() {
Some((s, e)) if s == e => println!("DATE {} {}", start, s),
Some((s, e)) => println!("DATE {} {} -- {}", start, s, e),
None => println!("DATE {}", start),
}
} else {
match dates.start_end_time() {
Some((s, e)) => println!("DATE {} {} -- {} {}", start, s, end, e),
None => println!("DATE {} -- {}", start, end),
}
}
println!("DATE {}", dates.sorted());
} else {
println!("NO DATE");
};
}
for line in command.desc() {
println!("# {}", line);

178
src/eval/date.rs
View file

@ -20,44 +20,8 @@ pub struct Dates {
impl fmt::Display for Dates {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let (start, end) = self.start_end();
match self.start_end_time() {
Some((start_time, end_time)) if start == end && start_time == end_time => {
write!(f, "{} {}", start, start_time)
}
Some((start_time, end_time)) if start == end => {
write!(f, "{} {} -- {}", start, start_time, end_time)
}
Some((start_time, end_time)) => {
write!(f, "{} {} -- {} {}", start, start_time, end, end_time)
}
None if start == end => write!(f, "{}", start),
None => write!(f, "{} -- {}", start, end),
}
}
}
impl From<Dates> for DoneDate {
fn from(dates: Dates) -> Self {
match dates.times {
Some(times) if dates.root == dates.other && times.root == times.other => {
DoneDate::DateWithTime {
root: dates.root,
root_time: times.root,
}
}
Some(times) => DoneDate::DateToDateWithTime {
root: dates.root,
root_time: times.root,
other: dates.other,
other_time: times.other,
},
None if dates.root == dates.other => DoneDate::Date { root: dates.root },
None => DoneDate::DateToDate {
root: dates.root,
other: dates.other,
},
}
let done_date: DoneDate = (*self).into();
write!(f, "{}", done_date)
}
}
@ -86,66 +50,55 @@ impl Dates {
}
}
pub fn root(&self) -> NaiveDate {
pub fn root(self) -> NaiveDate {
self.root
}
pub fn other(&self) -> NaiveDate {
self.other
pub fn root_with_time(self) -> (NaiveDate, Option<Time>) {
(self.root, self.times.map(|t| t.root))
}
pub fn root_time(&self) -> Option<Time> {
self.times.map(|times| times.root)
pub fn other_with_time(self) -> (NaiveDate, Option<Time>) {
(self.other, self.times.map(|t| t.other))
}
pub fn other_time(&self) -> Option<Time> {
self.times.map(|times| times.other)
pub fn dates(self) -> (NaiveDate, NaiveDate) {
(self.root, self.other)
}
pub fn start_end(&self) -> (NaiveDate, NaiveDate) {
if self.root <= self.other {
(self.root, self.other)
} else {
(self.other, self.root)
pub fn times(self) -> Option<(Time, Time)> {
self.times.map(|times| (times.root, times.other))
}
/// Flip `root` and `other`.
fn flip(self) -> Self {
Self {
root: self.other,
other: self.root,
times: self.times.map(|times| Times {
root: times.other,
other: times.root,
}),
}
}
pub fn start(&self) -> NaiveDate {
self.start_end().0
}
pub fn end(&self) -> NaiveDate {
self.start_end().1
}
pub fn start_end_time(&self) -> Option<(Time, Time)> {
if let Some(times) = self.times {
if self.root < self.other || (self.root == self.other && times.root <= times.other) {
Some((times.root, times.other))
} else {
Some((times.other, times.root))
}
} else {
None
}
}
pub fn start_time(&self) -> Option<Time> {
self.start_end_time().map(|times| times.0)
}
pub fn end_time(&self) -> Option<Time> {
self.start_end_time().map(|times| times.1)
}
pub fn point_in_time(&self) -> Option<(NaiveDate, Option<Time>)> {
if self.root != self.other {
return None;
}
/// Return a new [`Dates`] where `root` is the earlier and `other` the later
/// date.
pub fn sorted(self) -> Self {
match self.times {
Some(times) if times.root == times.other => Some((self.root, Some(times.root))),
Some(_) => None,
None => Some((self.root, None)),
_ if self.root < self.other => self,
None if self.root <= self.other => self,
Some(times) if self.root <= self.other && times.root <= times.other => self,
_ => self.flip(),
}
}
pub fn point_in_time(self) -> Option<(NaiveDate, Option<Time>)> {
let done_date: DoneDate = self.into();
match done_date {
DoneDate::Date { root } => Some((root, None)),
DoneDate::DateTime { root, root_time } => Some((root, Some(root_time))),
_ => None,
}
}
@ -162,27 +115,52 @@ impl From<DoneDate> for Dates {
fn from(date: DoneDate) -> Self {
match date {
DoneDate::Date { root } => Self::new(root, root),
DoneDate::DateWithTime { root, root_time } => {
DoneDate::DateTime { root, root_time } => {
Self::new_with_time(root, root_time, root, root_time)
}
DoneDate::DateToDate { root, other } => {
if root <= other {
Self::new(root, other)
} else {
Self::new(other, root)
}
}
DoneDate::DateToDateWithTime {
DoneDate::DateToDate { root, other } => Self::new(root, other),
DoneDate::DateTimeToTime {
root,
root_time,
other_time,
} => Self::new_with_time(root, root_time, root, other_time),
DoneDate::DateTimeToDateTime {
root,
root_time,
other,
other_time,
} => {
if root < other || (root == other && root_time <= other_time) {
Self::new_with_time(root, root_time, other, other_time)
} else {
Self::new_with_time(other, other_time, root, root_time)
}
} => Self::new_with_time(root, root_time, other, other_time),
}
}
}
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,
},
}
}
}

6
src/eval/entry.rs
View file

@ -75,8 +75,9 @@ impl Entries {
fn is_touching(&self, entry: &Entry) -> bool {
if let Some(dates) = entry.dates {
let (start, end) = dates.sorted().dates();
// Inside the range or overlapping it
dates.start() <= self.range.until() && self.range.from() <= dates.end()
start <= self.range.until() && self.range.from() <= end
} else {
false
}
@ -102,7 +103,8 @@ impl Entries {
// Unfinished tasks before or inside the range
if let EntryKind::Task = entry.kind {
if let Some(dates) = entry.dates {
if dates.start() <= self.range.until() {
let (start, _) = dates.sorted().dates();
if start <= self.range.until() {
return true;
}
}

9
src/files/commands.rs
View file

@ -268,7 +268,7 @@ pub enum DoneDate {
Date {
root: NaiveDate,
},
DateWithTime {
DateTime {
root: NaiveDate,
root_time: Time,
},
@ -276,7 +276,12 @@ pub enum DoneDate {
root: NaiveDate,
other: NaiveDate,
},
DateToDateWithTime {
DateTimeToTime {
root: NaiveDate,
root_time: Time,
other_time: Time,
},
DateTimeToDateTime {
root: NaiveDate,
root_time: Time,
other: NaiveDate,

9
src/files/format.rs
View file

@ -229,9 +229,14 @@ impl fmt::Display for DoneDate {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
DoneDate::Date { root } => write!(f, "{}", root),
DoneDate::DateWithTime { root, root_time } => write!(f, "{} {}", root, root_time),
DoneDate::DateTime { root, root_time } => write!(f, "{} {}", root, root_time),
DoneDate::DateToDate { root, other } => write!(f, "{} -- {}", root, other),
DoneDate::DateToDateWithTime {
DoneDate::DateTimeToTime {
root,
root_time,
other_time,
} => write!(f, "{} {} -- {}", root, root_time, other_time),
DoneDate::DateTimeToDateTime {
root,
root_time,
other,

1
src/files/grammar.pest
View file

@ -112,6 +112,7 @@ statements = { (stmt_date | stmt_bdate | stmt_from | stmt_until | stmt_except |
donedate = {
datum ~ time ~ "--" ~ datum ~ time
| datum ~ time ~ "--" ~ time
| datum ~ time
| datum ~ "--" ~ datum
| datum

9
src/files/parse.rs
View file

@ -652,7 +652,7 @@ fn parse_donedate(p: Pair<'_, Rule>) -> Result<DoneDate> {
root: parse_datum(ps.pop().unwrap())?.value,
},
2 => match ps[1].as_rule() {
Rule::time => DoneDate::DateWithTime {
Rule::time => DoneDate::DateTime {
root_time: parse_time(ps.pop().unwrap())?.value,
root: parse_datum(ps.pop().unwrap())?.value,
},
@ -662,7 +662,12 @@ fn parse_donedate(p: Pair<'_, Rule>) -> Result<DoneDate> {
},
_ => unreachable!(),
},
4 => DoneDate::DateToDateWithTime {
3 => DoneDate::DateTimeToTime {
other_time: parse_time(ps.pop().unwrap())?.value,
root_time: parse_time(ps.pop().unwrap())?.value,
root: parse_datum(ps.pop().unwrap())?.value,
},
4 => DoneDate::DateTimeToDateTime {
other_time: parse_time(ps.pop().unwrap())?.value,
other: parse_datum(ps.pop().unwrap())?.value,
root_time: parse_time(ps.pop().unwrap())?.value,