#![allow(clippy::items_after_test_module)]
use chrono::{DateTime, NaiveDate, Utc};
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "lowercase")]
pub enum Priority {
High,
#[default]
Normal,
Low,
}
impl Priority {
pub fn is_normal(&self) -> bool {
matches!(self, Priority::Normal)
}
}
impl std::str::FromStr for Priority {
type Err = anyhow::Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s.to_ascii_lowercase().as_str() {
"high" => Ok(Priority::High),
"normal" => Ok(Priority::Normal),
"low" => Ok(Priority::Low),
other => anyhow::bail!("unknown priority '{other}'; expected high, normal, or low"),
}
}
}
impl std::fmt::Display for Priority {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Priority::High => write!(f, "high"),
Priority::Normal => write!(f, "normal"),
Priority::Low => write!(f, "low"),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Status {
Pending,
Running,
Done,
Blocked,
}
impl Status {
pub fn as_str(&self) -> &'static str {
match self {
Status::Pending => "pending",
Status::Running => "running",
Status::Done => "done",
Status::Blocked => "blocked",
}
}
}
impl std::fmt::Display for Status {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct TaskProvenance {
#[serde(skip_serializing_if = "Option::is_none")]
pub doob: Option<DoobProvenance>,
}
impl TaskProvenance {
fn is_empty(&self) -> bool {
self.doob.is_none()
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct DoobProvenance {
pub id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Task {
pub id: String,
pub title: String,
pub status: Status,
#[serde(default)]
pub depends_on: Vec<String>,
#[serde(default)]
pub notes: String,
#[serde(default, skip_serializing_if = "TaskProvenance::is_empty")]
pub provenance: TaskProvenance,
#[serde(skip_serializing_if = "Option::is_none")]
pub crate_name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub commit: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub completed: Option<NaiveDate>,
#[serde(skip_serializing_if = "Option::is_none")]
pub run: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub started_at: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub completed_at: Option<DateTime<Utc>>,
#[serde(default, skip_serializing_if = "Priority::is_normal")]
pub priority: Priority,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub tags: Vec<String>,
}
impl Task {
pub fn new(id: impl Into<String>, title: impl Into<String>) -> Self {
Self {
id: id.into(),
title: title.into(),
status: Status::Pending,
depends_on: vec![],
notes: String::new(),
provenance: TaskProvenance::default(),
crate_name: None,
commit: None,
completed: None,
run: None,
started_at: None,
completed_at: None,
priority: Priority::Normal,
tags: vec![],
}
}
pub fn doob_id(&self) -> Option<&str> {
self.provenance.doob.as_ref().map(|value| value.id.as_str())
}
pub fn set_doob_id(&mut self, id: impl Into<String>) {
self.provenance.doob = Some(DoobProvenance { id: id.into() });
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct TaskGraph {
pub tasks: Vec<Task>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
plan_imports: Vec<PlanImport>,
#[serde(skip)]
done_cache: std::cell::RefCell<Option<std::collections::HashSet<String>>>,
}
impl Default for TaskGraph {
fn default() -> Self {
Self {
tasks: Vec::new(),
plan_imports: Vec::new(),
done_cache: std::cell::RefCell::new(None),
}
}
}
impl Clone for TaskGraph {
fn clone(&self) -> Self {
Self {
tasks: self.tasks.clone(),
plan_imports: self.plan_imports.clone(),
done_cache: std::cell::RefCell::new(None),
}
}
}
pub(crate) fn plan_file_stem(source: &str) -> &str {
let file_name = source.rsplit(['/', '\\']).next().unwrap_or(source);
file_name.strip_suffix(".md").unwrap_or(file_name)
}
impl TaskGraph {
pub(crate) fn plan_task_ids(&self, source: &str) -> Option<&[String]> {
self.plan_imports
.iter()
.find(|import| import.source == source)
.map(|import| import.task_ids.as_slice())
}
pub(crate) fn relocated_plan_task_ids(
&self,
source: &str,
is_gone: impl Fn(&str) -> bool,
) -> Option<&[String]> {
let stem = plan_file_stem(source);
let mut matches = self.plan_imports.iter().filter(|import| {
plan_file_stem(&import.source) == stem
&& is_gone(&import.source)
&& self.plan_import_has_live_tasks(import)
});
let only = matches.next()?;
matches.next().is_none().then_some(only.task_ids.as_slice())
}
fn plan_import_has_live_tasks(&self, import: &PlanImport) -> bool {
import
.task_ids
.iter()
.all(|id| self.tasks.iter().any(|task| &task.id == id))
}
pub(crate) fn is_imported_plan_task(&self, id: &str) -> bool {
self.plan_imports
.iter()
.any(|import| import.task_ids.iter().any(|task_id| task_id == id))
}
pub(crate) fn record_plan_import(&mut self, source: String, task_ids: Vec<String>) {
if let Some(import) = self
.plan_imports
.iter_mut()
.find(|import| import.source == source)
{
import.task_ids = task_ids;
return;
}
self.plan_imports.push(PlanImport { source, task_ids });
}
pub(crate) fn adopt_relocated_plan_import(
&mut self,
source: &str,
task_ids: Vec<String>,
is_relocated: impl Fn(&str, &[String]) -> bool,
) -> bool {
if self.plan_task_ids(source).is_some() {
return false;
}
let Some(index) = self
.plan_imports
.iter()
.position(|import| is_relocated(&import.source, &import.task_ids))
else {
return false;
};
self.plan_imports[index] = PlanImport {
source: source.to_string(),
task_ids,
};
true
}
pub(crate) fn clear_plan_imports(&mut self) {
self.plan_imports.clear();
}
pub fn done_ids(&self) -> std::cell::Ref<'_, std::collections::HashSet<String>> {
{
let cache = self.done_cache.borrow();
if cache.is_some() {
return std::cell::Ref::map(cache, |c| c.as_ref().unwrap());
}
}
let set: std::collections::HashSet<String> = self
.tasks
.iter()
.filter(|t| t.status == Status::Done)
.map(|t| t.id.clone())
.collect();
*self.done_cache.borrow_mut() = Some(set);
std::cell::Ref::map(self.done_cache.borrow(), |c| c.as_ref().unwrap())
}
pub fn invalidate_done_cache(&mut self) {
*self.done_cache.get_mut() = None;
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct PlanImport {
source: String,
task_ids: Vec<String>,
}
#[derive(Debug, Default)]
pub struct GraphSummary {
pub done: usize,
pub running: usize,
pub pending: usize,
pub blocked: usize,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn task_started_at_roundtrips_yaml() {
let mut t = Task::new("t1", "A");
t.started_at = Some(Utc::now());
let yaml = serde_yaml::to_string(&t).unwrap();
let back: Task = serde_yaml::from_str(&yaml).unwrap();
assert!(back.started_at.is_some());
}
#[test]
fn priority_default_is_normal() {
let t = Task::new("t1", "A");
assert_eq!(t.priority, Priority::Normal);
}
#[test]
fn priority_serializes_as_lowercase() {
let mut t = Task::new("t1", "A");
t.priority = Priority::High;
let yaml = serde_yaml::to_string(&t).unwrap();
assert!(yaml.contains("priority: high"), "got: {yaml}");
}
#[test]
fn priority_normal_is_skipped_in_yaml() {
let t = Task::new("t1", "A");
let yaml = serde_yaml::to_string(&t).unwrap();
assert!(
!yaml.contains("priority"),
"Normal priority should be omitted from YAML: {yaml}"
);
}
#[test]
fn priority_roundtrips_all_variants() {
for priority in [Priority::High, Priority::Normal, Priority::Low] {
let mut t = Task::new("t1", "A");
t.priority = priority.clone();
let yaml = serde_yaml::to_string(&t).unwrap();
let back: Task = serde_yaml::from_str(&yaml).unwrap();
assert_eq!(back.priority, priority);
}
}
#[test]
fn tags_roundtrip_yaml() {
let mut t = Task::new("t1", "A");
t.tags = vec!["frontend".into(), "urgent".into()];
let yaml = serde_yaml::to_string(&t).unwrap();
assert!(
yaml.contains("tags:"),
"tags field missing from YAML: {yaml}"
);
let back: Task = serde_yaml::from_str(&yaml).unwrap();
assert_eq!(back.tags, vec!["frontend", "urgent"]);
}
#[test]
fn tags_empty_skipped_in_yaml() {
let t = Task::new("t1", "A");
let yaml = serde_yaml::to_string(&t).unwrap();
assert!(
!yaml.contains("tags"),
"Empty tags should be omitted from YAML: {yaml}"
);
}
#[test]
fn tags_deserializes_missing_field_as_empty() {
let yaml = "id: t1\ntitle: A\nstatus: pending\n";
let t: Task = serde_yaml::from_str(yaml).unwrap();
assert!(t.tags.is_empty());
}
#[test]
fn completed_at_none_by_default_and_roundtrips() {
let t = Task::new("t1", "A");
assert!(t.completed_at.is_none());
let mut t2 = Task::new("t2", "B");
t2.completed_at = Some(Utc::now());
let yaml = serde_yaml::to_string(&t2).unwrap();
assert!(yaml.contains("completed_at"), "got: {yaml}");
let back: Task = serde_yaml::from_str(&yaml).unwrap();
assert!(back.completed_at.is_some());
}
#[test]
fn completed_at_skipped_when_none() {
let t = Task::new("t1", "A");
let yaml = serde_yaml::to_string(&t).unwrap();
assert!(
!yaml.contains("completed_at"),
"None completed_at should be omitted: {yaml}"
);
}
#[test]
fn priority_deserializes_missing_field_as_normal() {
let yaml = "id: t1\ntitle: A\nstatus: pending\n";
let t: Task = serde_yaml::from_str(yaml).unwrap();
assert_eq!(t.priority, Priority::Normal);
}
#[test]
fn priority_display() {
assert_eq!(Priority::High.to_string(), "high");
assert_eq!(Priority::Normal.to_string(), "normal");
assert_eq!(Priority::Low.to_string(), "low");
}
}
impl TaskGraph {
pub fn summary(&self) -> GraphSummary {
let mut s = GraphSummary::default();
for t in &self.tasks {
match t.status {
Status::Done => s.done += 1,
Status::Running => s.running += 1,
Status::Pending => s.pending += 1,
Status::Blocked => s.blocked += 1,
}
}
s
}
}