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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use std::collections::HashSet;

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

use crate::cli::{EditArgs, RemoveField};

pub(super) struct Removals<'a> {
    note: Vec<&'a str>,
    acceptance: Vec<&'a str>,
    link: Vec<&'a str>,
    blocked_by: Vec<&'a str>,
    evidence: Vec<&'a str>,
}

impl<'a> Removals<'a> {
    pub(super) fn new(args: &'a EditArgs) -> Self {
        let mut grouped = Self {
            note: Vec::new(),
            acceptance: Vec::new(),
            link: Vec::new(),
            blocked_by: Vec::new(),
            evidence: Vec::new(),
        };
        for removal in &args.remove {
            grouped.for_field_mut(removal.field).push(&removal.selector);
        }
        grouped
    }

    pub(super) fn for_field(&self, field: RemoveField) -> &[&'a str] {
        match field {
            RemoveField::Note => &self.note,
            RemoveField::Acceptance => &self.acceptance,
            RemoveField::Link => &self.link,
            RemoveField::BlockedBy => &self.blocked_by,
            RemoveField::Evidence => &self.evidence,
        }
    }

    fn for_field_mut(&mut self, field: RemoveField) -> &mut Vec<&'a str> {
        match field {
            RemoveField::Note => &mut self.note,
            RemoveField::Acceptance => &mut self.acceptance,
            RemoveField::Link => &mut self.link,
            RemoveField::BlockedBy => &mut self.blocked_by,
            RemoveField::Evidence => &mut self.evidence,
        }
    }
}

pub(super) fn apply(
    current: &[String],
    additions: &[String],
    removals: &[&str],
    reorder: Option<&str>,
) -> Result<Vec<String>> {
    let mut list = current.to_vec();
    for selector in removals {
        remove(&mut list, selector)?;
    }
    if let Some(order) = reorder {
        list = permute(&list, order)?;
    }
    for item in additions {
        ensure!(!item.is_empty(), "list item is empty");
        ensure!(!list.contains(item), "duplicate {item}");
        list.push(item.clone());
    }
    Ok(list)
}

fn remove(list: &mut Vec<String>, selector: &str) -> Result<()> {
    if let Ok(index) = selector.parse::<usize>()
        && index >= 1
        && index <= list.len()
    {
        list.remove(index - 1);
        return Ok(());
    }
    let index = list
        .iter()
        .position(|item| item == selector)
        .with_context(|| format!("{selector} is not in the list"))?;
    list.remove(index);
    Ok(())
}

fn permute(list: &[String], order: &str) -> Result<Vec<String>> {
    let indexes: Result<Vec<usize>, _> = order
        .split(',')
        .map(|part| part.trim().parse::<usize>())
        .collect();
    let indexes = indexes.context("--reorder-notes needs a permutation such as 3,1,2")?;
    ensure!(
        indexes.len() == list.len(),
        "--reorder-notes must name every note once"
    );
    let mut seen = HashSet::new();
    let mut reordered = Vec::with_capacity(list.len());
    for index in indexes {
        ensure!(
            index >= 1 && index <= list.len(),
            "--reorder-notes index {index} is out of range"
        );
        ensure!(seen.insert(index), "--reorder-notes repeats {index}");
        reordered.push(list[index - 1].clone());
    }
    Ok(reordered)
}