qctl 0.3.0

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

use crate::cli::CheckArgs;
use crate::ledger::{graph_errors, load_value, read, resolve_path, schema_value};
use crate::trailers;
use anyhow::{Result, bail};
use std::collections::HashSet;

pub fn run(args: &CheckArgs) -> Result<()> {
    let path = resolve_path(&args.ledger);
    let schema = schema_value()?;
    let instance = load_value(&path)?;
    // `format` is an annotation by default, which would let `completed: last
    // Tuesday` through the one keyword that describes it.
    let validator = jsonschema::options()
        .should_validate_formats(true)
        .build(&schema)?;
    let mut errors: Vec<String> = validator
        .iter_errors(&instance)
        .map(|error| format!("{}: {error}", error.instance_path()))
        .collect();

    // A wrong value must not hide a wrong graph, so the rows are read without
    // being judged and every rule reports in the same pass. The values are the
    // schema's business here — garde states the same rules for the verbs, and
    // repeating it would print each defect twice.
    match read(&path) {
        Ok(ledger) => {
            errors.extend(graph_errors(&ledger, &path));
            if !args.no_git {
                errors.extend(trailer_errors(&ledger, &path));
            }
        }
        Err(error) => errors.push(format!("{error:#}")),
    }

    if errors.is_empty() {
        println!("ok  {}", path.display());
        return Ok(());
    }
    for error in &errors {
        eprintln!("qctl: {error}");
    }
    bail!(
        "{} problem(s) in {}: {}",
        errors.len(),
        path.display(),
        errors.join("; ")
    );
}

fn trailer_errors(ledger: &crate::ledger::Ledger, path: &std::path::Path) -> Vec<String> {
    let cwd = match std::env::current_dir() {
        Ok(cwd) => cwd,
        Err(error) => return vec![format!("git trailer scan failed: {error}")],
    };
    let ledger_dir = match path.parent() {
        Some(parent) if !parent.as_os_str().is_empty() => parent,
        _ => cwd.as_path(),
    };
    let skip = "git trailer scan skipped: ledger is not in the current repository; pass --no-git";
    let ledger_root = match trailers::git_root_status(ledger_dir) {
        trailers::GitRoot::Failed(error) => {
            return vec![format!("git trailer scan failed: {error:#}")];
        }
        trailers::GitRoot::Absent => return vec![skip.into()],
        trailers::GitRoot::Root(root) => root,
    };
    let cwd_root = match trailers::git_root_status(&cwd) {
        trailers::GitRoot::Failed(error) => {
            return vec![format!("git trailer scan failed: {error:#}")];
        }
        trailers::GitRoot::Absent => return vec![skip.into()],
        trailers::GitRoot::Root(root) => root,
    };
    let ledger_root = ledger_root.canonicalize().unwrap_or(ledger_root);
    let cwd_root = cwd_root.canonicalize().unwrap_or(cwd_root);
    if ledger_root != cwd_root {
        return vec![skip.into()];
    }
    let closed = match trailers::closed_ids(&ledger_root) {
        Ok(closed) => closed,
        Err(error) => return vec![format!("git trailer scan failed: {error:#}")],
    };
    let queued: HashSet<_> = ledger.queue.iter().map(|task| task.id.as_str()).collect();
    let mut errors = Vec::new();
    let mut seen = HashSet::new();
    for (id, sha) in closed {
        if !queued.contains(id.as_str()) || !seen.insert(id.clone()) {
            continue;
        }
        errors.push(format!(
            "{id} is closed by {sha} but still queued; archive it (Closes/Completes trailer)"
        ));
    }
    errors
}