backburner 0.1.2

Private project memory for work worth coming back to.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use anyhow::Result;
use serde::Serialize;

use crate::models::{Context, TaskDetails, TaskStatus};
use crate::repository::FinishSessionResult;

pub fn json<T: Serialize>(value: &T) -> Result<()> {
    println!("{}", serde_json::to_string_pretty(value)?);
    Ok(())
}

pub fn list(title: &str, tasks: &[TaskDetails]) {
    println!("{title}");
    if tasks.is_empty() {
        println!("\nNothing here.");
        return;
    }
    println!();
    for details in tasks {
        print_task_line(details);
    }
}

pub fn show(details: &TaskDetails) {
    println!("#{} {}", details.task.id, details.task.title);
    println!("Status: {}", details.task.status);
    if let Some(planned) = &details.task.planned_date_key {
        println!("Planned: {planned}");
    }
    if details.task.completed_at.is_some() {
        println!("Completed: yes");
    }
    if !details.notes.is_empty() {
        println!("\nNotes:");
        for note in &details.notes {
            println!("- {}", note.body);
        }
    }
    if !details.files.is_empty() {
        println!("\nFiles:");
        for file in &details.files {
            match file.line {
                Some(line) => println!("- {}:{line}", file.path),
                None => println!("- {}", file.path),
            }
        }
    }
    if !details.commands.is_empty() {
        println!("\nCommands:");
        for command in &details.commands {
            println!("- {}", command.command);
        }
    }
}

pub fn context(context: &Context) {
    if context.promoted > 0 {
        println!("Promoted {} planned task(s).\n", context.promoted);
    }
    list("Today", &context.today);
    println!();
    let backburner = context
        .backburner
        .iter()
        .take(8)
        .cloned()
        .collect::<Vec<_>>();
    list("Backburner", &backburner);
}

pub fn finish_session(result: &FinishSessionResult) {
    println!(
        "Archived {} completed task(s). Moved {} unfinished task(s) to Backburner.",
        result.archived, result.backburnered
    );
}

pub fn moved(id: i64, status: TaskStatus) {
    println!("Moved #{id} to {status}.");
}

fn print_task_line(details: &TaskDetails) {
    let check = if details.task.completed_at.is_some() {
        "[x]"
    } else {
        "[ ]"
    };
    let planned = details
        .task
        .planned_date_key
        .as_ref()
        .map(|value| format!(" ({value})"))
        .unwrap_or_default();
    println!(
        "{check} #{} {}{}",
        details.task.id, details.task.title, planned
    );
    for file in details.files.iter().take(2) {
        match file.line {
            Some(line) => println!("    {}:{line}", file.path),
            None => println!("    {}", file.path),
        }
    }
    if let Some(command) = details.commands.first() {
        println!("    {}", command.command);
    }
}