use anyhow::{bail, Result};
use chrono::{DateTime, FixedOffset, NaiveDate, Utc};
use serde::{Deserialize, Deserializer, Serialize};
use serde_json::{json, Value};
pub const REMIND_DAYS: u32 = 14;
pub const REMIND_DAYS_HARD: u32 = 30;
pub const REMIND_DAYS_MAX: u32 = 366;
pub const BLOCK_CAP: usize = 5;
pub const THIS_WEEK_DAYS: i64 = 7;
pub(crate) fn is_false(b: &bool) -> bool {
!*b
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Deadline {
#[serde(default, skip_serializing_if = "String::is_empty")]
pub due: String,
#[serde(default, skip_serializing_if = "is_false")]
pub hard: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub remind_days: Option<u32>,
#[serde(default, skip_serializing_if = "String::is_empty")]
pub waits_on: String,
#[serde(default, skip_serializing_if = "String::is_empty")]
pub expected: String,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum When {
Day(NaiveDate),
At(DateTime<FixedOffset>),
}
pub fn parse_when(raw: &str) -> Option<When> {
let s = raw.trim();
if let Ok(d) = NaiveDate::parse_from_str(s, "%Y-%m-%d") {
return Some(When::Day(d));
}
if let Ok(t) = DateTime::parse_from_rfc3339(s) {
return Some(When::At(t));
}
DateTime::parse_from_str(s, "%Y-%m-%dT%H:%M%:z").ok().map(When::At)
}
impl Deadline {
pub fn is_empty(&self) -> bool {
*self == Deadline::default()
}
pub fn effective(&self) -> Option<(When, &str, bool)> {
let due = self.due.trim();
if !due.is_empty() {
return parse_when(due).map(|w| (w, due, false));
}
let expected = self.expected.trim();
if !expected.is_empty() {
return parse_when(expected).map(|w| (w, expected, true));
}
None
}
pub fn window(&self) -> u32 {
self.remind_days.unwrap_or(if self.hard { REMIND_DAYS_HARD } else { REMIND_DAYS })
}
pub fn diff_fields(&self) -> [(&'static str, String); 5] {
[
("due", self.due.clone()),
("hard", if self.hard { "true".into() } else { String::new() }),
("remind_days", self.remind_days.map(|d| d.to_string()).unwrap_or_default()),
("waits_on", self.waits_on.clone()),
("expected", self.expected.clone()),
]
}
pub fn validate(&self, kind: &str, is_task: bool) -> Result<()> {
if self.is_empty() {
return Ok(());
}
if !is_task {
bail!("due, hard, remind_days, waits_on and expected are task-only fields (kind '{kind}')");
}
for (name, value) in [("due", &self.due), ("expected", &self.expected)] {
if !value.trim().is_empty() && parse_when(value).is_none() {
bail!(
"{name} must be YYYY-MM-DD or a date-time with its zone, e.g. 2026-03-14T17:00:00-07:00 (got '{value}')"
);
}
}
let dated = !self.due.trim().is_empty() || !self.expected.trim().is_empty();
if !dated && (self.hard || self.remind_days.is_some() || !self.waits_on.trim().is_empty()) {
bail!(
"hard, remind_days and waits_on describe a deadline: set due, or expected while the real date is not known yet"
);
}
if let Some(days) = self.remind_days {
if days > REMIND_DAYS_MAX {
bail!("remind_days must be at most {REMIND_DAYS_MAX} (got {days})");
}
}
if !self.waits_on.is_empty() && self.waits_on.trim().is_empty() {
bail!("waits_on is blank — leave it out if the date does not depend on an event");
}
if let Some(hit) = crate::model::find_secret(&self.waits_on) {
bail!("waits_on looks like a secret ({hit}…) — store secrets as pointers in refs");
}
Ok(())
}
}
#[derive(Debug, Default, Deserialize)]
pub struct DeadlinePatch {
#[serde(default, deserialize_with = "present")]
pub due: Option<Option<String>>,
#[serde(default, deserialize_with = "present")]
pub hard: Option<Option<bool>>,
#[serde(default, deserialize_with = "present")]
pub remind_days: Option<Option<u32>>,
#[serde(default, deserialize_with = "present")]
pub waits_on: Option<Option<String>>,
#[serde(default, deserialize_with = "present")]
pub expected: Option<Option<String>>,
}
fn present<'de, D, T>(d: D) -> Result<Option<T>, D::Error>
where
D: Deserializer<'de>,
T: Deserialize<'de>,
{
T::deserialize(d).map(Some)
}
impl DeadlinePatch {
pub fn is_empty(&self) -> bool {
self.due.is_none()
&& self.hard.is_none()
&& self.remind_days.is_none()
&& self.waits_on.is_none()
&& self.expected.is_none()
}
pub fn apply(self, mut d: Deadline) -> Deadline {
let (names_hard, names_days, names_event) =
(self.hard.is_some(), self.remind_days.is_some(), self.waits_on.is_some());
if let Some(due) = self.due {
d.due = due.unwrap_or_default().trim().to_string();
}
if let Some(hard) = self.hard {
d.hard = hard.unwrap_or(false);
}
if let Some(days) = self.remind_days {
d.remind_days = days;
}
if let Some(waits_on) = self.waits_on {
d.waits_on = waits_on.unwrap_or_default();
}
if let Some(expected) = self.expected {
d.expected = expected.unwrap_or_default().trim().to_string();
}
if d.due.trim().is_empty() && d.expected.trim().is_empty() {
if !names_hard {
d.hard = false;
}
if !names_days {
d.remind_days = None;
}
if !names_event {
d.waits_on.clear();
}
}
d
}
}
#[derive(Debug, Clone, Copy)]
pub struct Clock {
pub now: DateTime<Utc>,
pub today: NaiveDate,
}
impl Clock {
pub fn new(now: DateTime<Utc>, today: Option<NaiveDate>) -> Clock {
let today = today.unwrap_or_else(|| now.with_timezone(&chrono::Local).date_naive());
Clock { now, today }
}
}
pub struct Task<'a> {
pub key: &'a str,
pub title: &'a str,
pub status: &'a str,
pub assignee: &'a str,
pub tags: &'a [String],
pub deadline: &'a Deadline,
}
#[derive(Debug, Clone, Serialize, PartialEq)]
pub struct Item {
pub key: String,
pub title: String,
pub status: String,
#[serde(skip_serializing_if = "String::is_empty")]
pub assignee: String,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub tags: Vec<String>,
pub due: String,
pub days_left: i64,
pub overdue: bool,
#[serde(skip_serializing_if = "is_false")]
pub hard: bool,
#[serde(skip_serializing_if = "is_false")]
pub provisional: bool,
#[serde(skip_serializing_if = "String::is_empty")]
pub waits_on: String,
pub remind_days: u32,
}
impl Item {
pub fn surfaced(&self) -> bool {
self.overdue || self.days_left <= i64::from(self.remind_days)
}
pub fn bucket(&self) -> &'static str {
if self.overdue {
"overdue"
} else if self.days_left <= THIS_WEEK_DAYS {
"this_week"
} else {
"later"
}
}
pub fn in_scope(&self, scope: &[String]) -> bool {
scope.iter().all(|s| self.tags.iter().any(|t| t.eq_ignore_ascii_case(s)))
}
}
pub fn item(task: &Task, clock: &Clock) -> Option<Item> {
let (when, written, provisional) = task.deadline.effective()?;
let (days_left, overdue) = match when {
When::Day(day) => ((day - clock.today).num_days(), clock.today > day),
When::At(at) => {
let day = at.date_naive();
let days = (day - clock.today).num_days();
let present = (clock.today - clock.now.date_naive()).num_days().abs() <= 1;
let overdue = clock.today > day || (present && clock.now > at);
(if overdue { days.min(0) } else { days }, overdue)
}
};
Some(Item {
key: task.key.to_string(),
title: task.title.to_string(),
status: task.status.to_string(),
assignee: task.assignee.to_string(),
tags: task.tags.to_vec(),
due: written.to_string(),
days_left,
overdue,
hard: task.deadline.hard,
provisional,
waits_on: if provisional { task.deadline.waits_on.clone() } else { String::new() },
remind_days: task.deadline.window(),
})
}
pub fn sort(items: &mut [Item]) {
items.sort_by(|a, b| {
b.overdue
.cmp(&a.overdue)
.then(b.hard.cmp(&a.hard))
.then(a.days_left.cmp(&b.days_left))
.then(a.key.cmp(&b.key))
});
}
pub fn block(mut items: Vec<Item>, clock: &Clock, scope: &[String]) -> Option<Value> {
items.retain(Item::surfaced);
if items.is_empty() {
return None;
}
sort(&mut items);
if !scope.is_empty() {
items.sort_by_key(|i| (!i.overdue, !i.in_scope(scope)));
}
let count = items.len();
let overdue = items.iter().filter(|i| i.overdue).count();
items.truncate(BLOCK_CAP);
Some(json!({
"today": clock.today.to_string(),
"count": count,
"overdue": overdue,
"more": count - items.len(),
"items": items,
}))
}
#[cfg(test)]
#[path = "deadline_tests.rs"]
mod tests;