loft-cli 2.0.1

The loft command line: author, check, format, render and publish a specification in a git repository
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

//! `loft check` (F-38): the reader, then the validator, then the linter, with an exit code a CI
//! job can gate on. In text, each error and finding is one line, errors before findings (AC-522,
//! AC-595); with `--format json`, one document on standard output (RQ-155).

use std::path::Path;
use std::process::ExitCode;

use loftspec::check::{Checked, check};
use loftspec::lint::Severity;
use loftspec_store::FileStore;
use serde_json::{Value, json};

use crate::json;

/// The schema `--format json` writes to, by name and version (RQ-156).
const SCHEMA: &str = "loft-check/1";

pub fn run(root: &Path, fail_on: Option<Severity>, as_json: bool) -> ExitCode {
    let files = match FileStore::open(root).and_then(|store| store.read_files()) {
        Ok(files) => files,
        Err(error) => {
            if as_json {
                json::print(&json::failure(SCHEMA, vec![json::store_error(&error)]));
            }
            eprintln!("{error}");
            return ExitCode::FAILURE;
        }
    };
    let checked = check(&files);
    let failed_on = fail_on.is_some_and(|threshold| {
        checked
            .findings()
            .iter()
            .any(|finding| finding.severity >= threshold)
    });
    let failed = checked.has_errors() || failed_on;
    if as_json {
        json::print(&document(
            &checked,
            if failed { "failed" } else { "passed" },
        ));
    } else {
        print(&checked);
    }
    if failed {
        ExitCode::FAILURE
    } else {
        ExitCode::SUCCESS
    }
}

fn print(checked: &Checked) {
    match checked {
        Checked::Unread(errors) => {
            for error in errors {
                println!("{error}");
            }
        }
        Checked::Read {
            invalid,
            config,
            findings,
        } => {
            for error in invalid {
                println!("{error}");
            }
            for error in config {
                println!("{error}");
            }
            for finding in findings {
                println!("{finding}");
            }
        }
    }
}

fn document(checked: &Checked, outcome: &str) -> Value {
    let (errors, findings): (Vec<Value>, Vec<Value>) = match checked {
        Checked::Unread(errors) => (json::read_errors(errors), Vec::new()),
        Checked::Read {
            invalid,
            config,
            findings,
        } => (
            json::validation_errors(invalid)
                .into_iter()
                .chain(config.iter().map(|e| json::read_error("lint-config", e)))
                .collect(),
            findings.iter().map(json::finding).collect(),
        ),
    };
    json::result(SCHEMA, outcome, json!({ "findings": findings }), errors)
}