reqfile 0.3.0

Check that a codebase meets its requirements
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

//! `reqfile list`: every requirement of the repository, with its type,
//! checks, and source for requirements taken with `use`.

use std::path::Path;

use serde_json::json;

use super::workspace::Workspace;
use crate::core::reqfile::{Check, Kind};
use crate::core::resolve::Effective;

/// The listing to print, or the errors that prevent it.
pub fn run(cwd: &Path, kind: Option<Kind>, json: bool) -> Result<String, Vec<String>> {
    let workspace = Workspace::load(cwd)?;
    let listed: Vec<&Effective> = workspace
        .blocks
        .iter()
        .filter(|b| kind.is_none_or(|k| b.kind == k))
        .collect();
    Ok(if json {
        render_json(&listed)
    } else {
        render(&listed, kind)
    })
}

/// The blocks grouped by Reqfile, then counted.
fn render(listed: &[&Effective], kind: Option<Kind>) -> String {
    let what = kind.map_or(String::new(), |k| format!("{} ", k.as_str()));
    if listed.is_empty() {
        return format!("No {what}requirements in this repository.\n");
    }
    let mut out = String::new();
    let mut current = "";
    for block in listed {
        if block.reqfile != current {
            current = &block.reqfile;
            if !out.is_empty() {
                out += "\n";
            }
            out += &format!("From {current}:\n");
        }
        let (source, inherited) = match &block.imported {
            Some(imported) => (
                format!("  use: {}", imported.location.describe()),
                if imported.checks_inherited {
                    " (inherited)"
                } else {
                    " (set here)"
                },
            ),
            None => (String::new(), ""),
        };
        out += &format!(
            "  {} ({}){source}  checks: {}{inherited}\n",
            block.id,
            block.kind.as_str(),
            check_types(block).join(", ")
        );
    }
    let count = |k: Kind| listed.iter().filter(|b| b.kind == k).count();
    out += &format!("\n{} {what}requirements", listed.len());
    if kind.is_none() {
        out += &format!(
            ": {} product, {} code",
            count(Kind::Product),
            count(Kind::Code)
        );
        if count(Kind::Process) > 0 {
            out += &format!(", {} process", count(Kind::Process));
        }
    }
    out += ".\n";
    out
}

fn render_json(listed: &[&Effective]) -> String {
    let requirements: Vec<serde_json::Value> = listed
        .iter()
        .map(|block| {
            let imported = block.imported.as_ref().map(|i| {
                json!({
                    "use": i.location.describe(),
                    "definition": i.definition,
                    "commit": i.commit,
                    "checks_inherited": i.checks_inherited,
                })
            });
            json!({
                "reqfile": block.reqfile,
                "line": block.line,
                "id": block.id,
                "kind": block.kind.as_str(),
                "must": block.must,
                "why": block.why,
                "who": block.who,
                "ref": block.reference,
                "checks": check_types(block),
                "imported": imported,
            })
        })
        .collect();
    serde_json::to_string_pretty(&json!({ "requirements": requirements }))
        .expect("the listing serializes to JSON")
        + "\n"
}

/// The types of a block's checks, in declaration order, without repeats.
fn check_types(block: &Effective) -> Vec<&'static str> {
    let mut types: Vec<&str> = Vec::new();
    for check in &block.checks {
        let name = match check {
            Check::Command(_) => "command",
            Check::Decision(d) if d.blocking => "decision (blocking)",
            Check::Decision(_) => "decision",
        };
        if !types.contains(&name) {
            types.push(name);
        }
    }
    types
}