Something went wrong. Try again.
A Rust clone of doing by Brett Terpstra — a command line tool for remembering what you were doing and tracking what you've done.
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543use std::fmt::{Display, Formatter, Result as FmtResult};
use chrono::{DateTime, Datelike, Local};use serde::{Deserialize, Serialize};
/// Duration display format modes.////// Determines how a `chrono::Duration` is rendered as a human-readable string.#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]pub enum DurationFormat { /// `01:02:30` — zero-padded `HH:MM:SS` clock format. Clock, /// `1d 2h 30m` — abbreviated with spaces. Dhm, /// `02:30` — hours and minutes clock format (days folded into hours). Hm, /// `90` — total minutes as a plain number. M, /// `about an hour and a half` — fuzzy natural language approximation. Natural, /// `1 hour 30 minutes` — exact natural language. #[default] Text,}
impl DurationFormat { /// Parse a format name from a config string value. /// /// Unrecognized values fall back to [`DurationFormat::Text`]. pub fn from_config(s: &str) -> Self { match s.trim().to_lowercase().as_str() { "clock" => Self::Clock, "dhm" => Self::Dhm, "hm" => Self::Hm, "m" => Self::M, "natural" => Self::Natural, _ => Self::Text, } }}
/// A formatted duration that implements [`Display`].#[derive(Clone, Debug)]pub struct FormattedDuration { days: i64, format: DurationFormat, hours: i64, minutes: i64, seconds: i64,}
impl FormattedDuration { /// Create a new formatted duration from a `chrono::Duration` and format mode. pub fn new(duration: chrono::Duration, format: DurationFormat) -> Self { let total_seconds = duration.num_seconds(); let total_minutes = total_seconds / 60; let total_hours = total_minutes / 60;
let days = total_hours / 24; let hours = total_hours % 24; let minutes = total_minutes % 60; let seconds = total_seconds % 60;
Self { days, format, hours, minutes, seconds, } }
/// Total duration expressed as whole minutes. fn total_minutes(&self) -> i64 { self.days * 24 * 60 + self.hours * 60 + self.minutes }}
impl Display for FormattedDuration { fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult { match self.format { DurationFormat::Clock => { let total_hours = self.days * 24 + self.hours; write!(f, "{:02}:{:02}:{:02}", total_hours, self.minutes, self.seconds) } DurationFormat::Dhm => write!( f, "{}", format_parts(self.days, self.hours, self.minutes, dhm_component) ), DurationFormat::Hm => { let total_hours = self.days * 24 + self.hours; write!(f, "{:02}:{:02}", total_hours, self.minutes) } DurationFormat::M => write!(f, "{}", self.total_minutes()), DurationFormat::Natural => write!(f, "{}", natural_duration(self.total_minutes())), DurationFormat::Text => write!( f, "{}", format_parts(self.days, self.hours, self.minutes, text_component) ), } }}
/// A formatted short date that implements [`Display`].#[derive(Clone, Debug)]pub struct FormattedShortdate { formatted: String,}
impl FormattedShortdate { /// Format a datetime using config-driven relative date buckets. /// /// Dates from today use the `today` format, dates within the last week use /// `this_week`, dates within the same year use `this_month`, and older dates /// use the `older` format. pub fn new(datetime: DateTime<Local>, config: &ShortdateFormatConfig) -> Self { let now = Local::now(); let today = now.date_naive();
let fmt = if datetime.date_naive() == today { &config.today } else if datetime.date_naive() > today - chrono::Duration::days(7) { &config.this_week } else if datetime.year() == today.year() { &config.this_month } else { &config.older };
Self { formatted: datetime.format(fmt).to_string(), } }}
impl Display for FormattedShortdate { fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult { write!(f, "{}", self.formatted) }}
/// Date format strings for relative time display.#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]#[serde(default)]pub struct ShortdateFormatConfig { pub older: String, pub this_month: String, pub this_week: String, pub today: String,}
impl Default for ShortdateFormatConfig { fn default() -> Self { Self { older: "%m/%d/%y %_I:%M%P".into(), this_month: "%m/%d %_I:%M%P".into(), this_week: "%a %_I:%M%P".into(), today: "%_I:%M%P".into(), } }}
/// Format a tag total duration as `DD:HH:MM`.pub fn format_tag_total(duration: chrono::Duration) -> String { let total_minutes = duration.num_minutes(); let total_hours = total_minutes / 60;
let days = total_hours / 24; let hours = total_hours % 24; let minutes = total_minutes % 60;
format!("{days:02}:{hours:02}:{minutes:02}")}
fn dhm_component(value: i64, _unit: &str, suffix: &str) -> String { format!("{value}{suffix}")}
fn format_parts(days: i64, hours: i64, minutes: i64, fmt: fn(i64, &str, &str) -> String) -> String { let mut parts = Vec::new(); if days > 0 { parts.push(fmt(days, "day", "d")); } if hours > 0 { parts.push(fmt(hours, "hour", "h")); } if minutes > 0 || parts.is_empty() { parts.push(fmt(minutes, "minute", "m")); } parts.join(" ")}
fn natural_duration(total_minutes: i64) -> String { if total_minutes == 0 { return "0 minutes".into(); }
let hours = total_minutes / 60; let minutes = total_minutes % 60; let days = hours / 24; let remaining_hours = hours % 24;
if days > 0 { if remaining_hours == 0 && minutes == 0 { return if days == 1 { "about a day".into() } else { format!("about {days} days") }; } if remaining_hours >= 12 { return format!("about {} days", days + 1); } return format!("about {days} and a half days"); }
if remaining_hours > 0 { if minutes <= 15 { return if remaining_hours == 1 { "about an hour".into() } else { format!("about {remaining_hours} hours") }; } if minutes >= 45 { let rounded = remaining_hours + 1; return format!("about {rounded} hours"); } return if remaining_hours == 1 { "about an hour and a half".into() } else { format!("about {remaining_hours} and a half hours") }; }
if minutes == 1 { "about a minute".into() } else if minutes < 5 { "a few minutes".into() } else if minutes < 15 { format!("about {minutes} minutes") } else if minutes < 18 { "about 15 minutes".into() } else if minutes < 23 { "about 20 minutes".into() } else if minutes < 35 { "about half an hour".into() } else if minutes < 50 { "about 45 minutes".into() } else { "about an hour".into() }}
fn pluralize(count: i64, word: &str) -> String { if count == 1 { format!("{count} {word}") } else { format!("{count} {word}s") }}
fn text_component(value: i64, unit: &str, _suffix: &str) -> String { pluralize(value, unit)}
#[cfg(test)]mod test { use chrono::Duration;
use super::*;
mod duration_format { use pretty_assertions::assert_eq;
use super::*;
#[test] fn it_defaults_unknown_to_text() { assert_eq!(DurationFormat::from_config("unknown"), DurationFormat::Text); }
#[test] fn it_is_case_insensitive() { assert_eq!(DurationFormat::from_config("CLOCK"), DurationFormat::Clock); }
#[test] fn it_parses_clock_from_config() { assert_eq!(DurationFormat::from_config("clock"), DurationFormat::Clock); }
#[test] fn it_parses_dhm_from_config() { assert_eq!(DurationFormat::from_config("dhm"), DurationFormat::Dhm); }
#[test] fn it_parses_hm_from_config() { assert_eq!(DurationFormat::from_config("hm"), DurationFormat::Hm); }
#[test] fn it_parses_m_from_config() { assert_eq!(DurationFormat::from_config("m"), DurationFormat::M); }
#[test] fn it_parses_natural_from_config() { assert_eq!(DurationFormat::from_config("natural"), DurationFormat::Natural); }
#[test] fn it_parses_text_from_config() { assert_eq!(DurationFormat::from_config("text"), DurationFormat::Text); } }
mod format_tag_total { use pretty_assertions::assert_eq;
use super::*;
#[test] fn it_formats_zero() { assert_eq!(format_tag_total(Duration::zero()), "00:00:00"); }
#[test] fn it_formats_hours_and_minutes() { assert_eq!(format_tag_total(Duration::seconds(5400)), "00:01:30"); }
#[test] fn it_formats_days_hours_minutes() { let duration = Duration::seconds(93600 + 1800);
assert_eq!(format_tag_total(duration), "01:02:30"); } }
mod formatted_duration { use pretty_assertions::assert_eq;
use super::*;
#[test] fn it_formats_clock() { let fd = FormattedDuration::new(Duration::seconds(93600), DurationFormat::Clock);
assert_eq!(fd.to_string(), "26:00:00"); }
#[test] fn it_formats_clock_with_minutes() { let fd = FormattedDuration::new(Duration::seconds(5400), DurationFormat::Clock);
assert_eq!(fd.to_string(), "01:30:00"); }
#[test] fn it_formats_clock_with_seconds() { let fd = FormattedDuration::new(Duration::seconds(3661), DurationFormat::Clock);
assert_eq!(fd.to_string(), "01:01:01"); }
#[test] fn it_formats_dhm() { let fd = FormattedDuration::new(Duration::seconds(93600 + 1800), DurationFormat::Dhm);
assert_eq!(fd.to_string(), "1d 2h 30m"); }
#[test] fn it_formats_dhm_hours_only() { let fd = FormattedDuration::new(Duration::hours(3), DurationFormat::Dhm);
assert_eq!(fd.to_string(), "3h"); }
#[test] fn it_formats_dhm_zero_duration() { let fd = FormattedDuration::new(Duration::zero(), DurationFormat::Dhm);
assert_eq!(fd.to_string(), "0m"); }
#[test] fn it_formats_hm() { let fd = FormattedDuration::new(Duration::seconds(93600 + 1800), DurationFormat::Hm);
assert_eq!(fd.to_string(), "26:30"); }
#[test] fn it_formats_m() { let fd = FormattedDuration::new(Duration::seconds(5400), DurationFormat::M);
assert_eq!(fd.to_string(), "90"); }
#[test] fn it_formats_natural_about_hours() { let fd = FormattedDuration::new(Duration::hours(3), DurationFormat::Natural);
assert_eq!(fd.to_string(), "about 3 hours"); }
#[test] fn it_formats_natural_about_20_minutes() { let fd = FormattedDuration::new(Duration::minutes(18), DurationFormat::Natural);
assert_eq!(fd.to_string(), "about 20 minutes"); }
#[test] fn it_formats_natural_few_minutes() { let fd = FormattedDuration::new(Duration::minutes(3), DurationFormat::Natural);
assert_eq!(fd.to_string(), "a few minutes"); }
#[test] fn it_formats_natural_half_hour() { let fd = FormattedDuration::new(Duration::minutes(30), DurationFormat::Natural);
assert_eq!(fd.to_string(), "about half an hour"); }
#[test] fn it_formats_natural_hour_and_half() { let fd = FormattedDuration::new(Duration::minutes(90), DurationFormat::Natural);
assert_eq!(fd.to_string(), "about an hour and a half"); }
#[test] fn it_formats_text() { let fd = FormattedDuration::new(Duration::seconds(5400), DurationFormat::Text);
assert_eq!(fd.to_string(), "1 hour 30 minutes"); }
#[test] fn it_formats_text_plural() { let fd = FormattedDuration::new(Duration::seconds(93600 + 1800), DurationFormat::Text);
assert_eq!(fd.to_string(), "1 day 2 hours 30 minutes"); }
#[test] fn it_formats_text_singular() { let fd = FormattedDuration::new(Duration::hours(1), DurationFormat::Text);
assert_eq!(fd.to_string(), "1 hour"); }
#[test] fn it_formats_text_zero_duration() { let fd = FormattedDuration::new(Duration::zero(), DurationFormat::Text);
assert_eq!(fd.to_string(), "0 minutes"); } }
mod formatted_shortdate { use chrono::TimeZone; use pretty_assertions::assert_eq;
use super::*;
fn config() -> ShortdateFormatConfig { ShortdateFormatConfig { today: "%H:%M".into(), this_week: "%a %H:%M".into(), this_month: "%m/%d %H:%M".into(), older: "%m/%d/%y %H:%M".into(), } }
#[test] fn it_formats_older() { let datetime = Local.with_ymd_and_hms(2020, 6, 15, 14, 30, 0).unwrap();
let result = FormattedShortdate::new(datetime, &config());
assert_eq!(result.to_string(), "06/15/20 14:30"); }
#[test] fn it_formats_this_month() { let old = Local::now() - Duration::days(20); let datetime = Local .with_ymd_and_hms(old.year(), old.month(), old.day(), 14, 30, 0) .unwrap();
let result = FormattedShortdate::new(datetime, &config());
let expected = datetime.format("%m/%d %H:%M").to_string(); assert_eq!(result.to_string(), expected); }
#[test] fn it_formats_this_week() { let yesterday = Local::now() - Duration::days(2); let datetime = Local .with_ymd_and_hms(yesterday.year(), yesterday.month(), yesterday.day(), 14, 30, 0) .unwrap();
let result = FormattedShortdate::new(datetime, &config());
let expected = datetime.format("%a %H:%M").to_string(); assert_eq!(result.to_string(), expected); }
#[test] fn it_formats_cross_year_dates_as_older() { let now = Local::now(); let last_year = now.year() - 1; let datetime = Local.with_ymd_and_hms(last_year, 11, 15, 14, 30, 0).unwrap();
let result = FormattedShortdate::new(datetime, &config());
assert_eq!(result.to_string(), format!("11/15/{} 14:30", last_year % 100)); }
#[test] fn it_formats_today() { let now = Local::now(); let datetime = Local .with_ymd_and_hms(now.year(), now.month(), now.day(), 14, 30, 0) .unwrap();
let result = FormattedShortdate::new(datetime, &config());
assert_eq!(result.to_string(), "14:30"); } }}