rustodo 2.26.0

A modern, powerful task manager built with Rust
Documentation 
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

//! Handler for `todo project edit <ID>`.

use anyhow::Result;
use colored::Colorize;

use crate::cli::ProjectEditArgs;
use crate::storage::Storage;
use crate::utils::date_parser;
use crate::utils::validation::resolve_visible_index;

pub fn execute(storage: &impl Storage, args: ProjectEditArgs) -> Result<()> {
    let (_, mut projects, _) = storage.load_all()?;

    let real_index = resolve_visible_index(&projects, args.id, |p| p.is_deleted())
        .map_err(|_| anyhow::anyhow!("Project #{} not found", args.id))?;

    let due = if let Some(ref due_str) = args.due {
        Some(date_parser::parse_date_not_in_past(due_str)?)
    } else {
        None
    };

    let project = &mut projects[real_index];
    let mut changes = Vec::new();

    if let Some(ref new_name) = args.name {
        if new_name.trim().is_empty() {
            return Err(anyhow::anyhow!("Project name cannot be empty"));
        }
        if &project.name != new_name {
            project.name = new_name.clone();
            changes.push(format!("name → {}", new_name.bright_white()));
        }
    }

    if args.done && !project.completed {
        project.mark_done();
        changes.push(format!("status → {}", "done".green()));
    } else if args.undone && project.completed {
        project.mark_undone();
        changes.push(format!("status → {}", "pending".yellow()));
    }

    if let Some(new_diff) = args.difficulty
        && project.difficulty != new_diff
    {
        project.difficulty = new_diff;
        changes.push(format!("difficulty → {}", new_diff.label().yellow()));
    }

    if args.clear_tech {
        if !project.tech.is_empty() {
            let old = project.tech.clone();
            project.tech.clear();
            changes.push(format!("tech cleared → was [{}]", old.join(", ").dimmed()));
        }
    } else {
        if !args.remove_tech.is_empty() {
            let remove_normalized: Vec<String> = args
                .remove_tech
                .iter()
                .map(|t| t.trim().to_lowercase())
                .collect();
            let mut removed = Vec::new();
            project.tech.retain(|t| {
                if remove_normalized.contains(&t.to_lowercase()) {
                    removed.push(t.clone());
                    false
                } else {
                    true
                }
            });
            if !removed.is_empty() {
                changes.push(format!("removed tech → [{}]", removed.join(", ").red()));
            }
        }
        if !args.add_tech.is_empty() {
            let mut added = Vec::new();
            for tech in &args.add_tech {
                let tech = tech.trim().to_string();
                if tech.is_empty() {
                    continue;
                }
                if !project
                    .tech
                    .iter()
                    .any(|t| t.to_lowercase() == tech.to_lowercase())
                {
                    project.tech.push(tech.clone());
                    added.push(tech);
                }
            }
            if !added.is_empty() {
                changes.push(format!("added tech → [{}]", added.join(", ").cyan()));
            }
        }
    }

    if args.clear_due {
        if project.due_date.is_some() {
            project.due_date = None;
            changes.push("due date → cleared".dimmed().to_string());
        }
    } else if let Some(new_due) = due
        && project.due_date != Some(new_due)
    {
        project.due_date = Some(new_due);
        changes.push(format!("due date → {}", new_due.to_string().cyan()));
    }

    if changes.is_empty() {
        println!(
            "{} No changes made (values are already set to the specified values).",
            "".blue()
        );
        return Ok(());
    }

    projects[real_index].touch();
    storage.save_projects(&projects)?;

    println!("{} Project #{} updated:", "✓".green(), args.id);
    for change in &changes {
        println!("  • {}", change);
    }

    Ok(())
}