qctl 0.5.4

Control in-repo YAML work queues
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

use std::path::Path;

use anyhow::{Result, bail, ensure};

use crate::cli::{EditArgs, UnsetField};
use crate::document::Change;

pub(super) struct ListEdit<'a> {
    key: &'static str,
    before: &'a [String],
    after: Vec<String>,
}

impl<'a> ListEdit<'a> {
    pub(super) fn new(key: &'static str, before: &'a [String], after: Vec<String>) -> Self {
        Self { key, before, after }
    }
}

pub(super) fn changes(args: &EditArgs, path: &Path, lists: &[ListEdit<'_>]) -> Result<Vec<Change>> {
    if args.patch.is_some() && args.unset.contains(&UnsetField::Patch) {
        bail!("use --patch or --unset patch, not both");
    }
    if args.plan.is_some() && args.unset.contains(&UnsetField::Plan) {
        bail!("use --plan or --unset plan, not both");
    }
    crate::mutate::require_plan(path, args.plan.as_deref())?;

    let mut changes = Vec::new();
    push_scalar(&mut changes, "title", args.title.as_deref())?;
    push_scalar(&mut changes, "scope", args.scope.as_deref())?;
    push_scalar(&mut changes, "outcome", args.outcome.as_deref())?;
    if let Some(kind) = args.kind {
        changes.push(Change::set("kind", kind.to_string()));
    }
    push_scalar(&mut changes, "open", args.open.as_deref())?;
    push_optional(
        &mut changes,
        "patch",
        args.patch.as_deref(),
        args.unset.contains(&UnsetField::Patch),
    )?;
    push_optional(
        &mut changes,
        "plan",
        args.plan.as_deref(),
        args.unset.contains(&UnsetField::Plan),
    )?;
    for list in lists {
        push_list(&mut changes, list);
    }
    Ok(changes)
}

fn push_scalar(changes: &mut Vec<Change>, key: &str, value: Option<&str>) -> Result<()> {
    let Some(value) = value else {
        return Ok(());
    };
    ensure!(!value.is_empty(), "--{key} needs a value");
    changes.push(Change::set(key, value));
    Ok(())
}

fn push_optional(
    changes: &mut Vec<Change>,
    key: &str,
    value: Option<&str>,
    unset: bool,
) -> Result<()> {
    if unset {
        changes.push(Change::unset(key));
        return Ok(());
    }
    push_scalar(changes, key, value)
}

fn push_list(changes: &mut Vec<Change>, list: &ListEdit<'_>) {
    if list.before == list.after.as_slice() {
        return;
    }
    changes.push(Change::List {
        key: list.key.to_owned(),
        before: list.before.to_vec(),
        after: list.after.clone(),
    });
}