loft-cli 2.0.4

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
94
95

//! A command stopped on errors (F-45): each error as JSON for `--format json`, the lines standard
//! error shows, and exit 1. A read or validation error's line is
//! `<path>:<line>:<column>: <message>` (RQ-158).

use std::path::Path;

use loftspec::check::Placed;
use loftspec::codec::{Files, ReadError};
use loftspec::trace::{TRACE, TraceError};
use loftspec_store::{FileStore, StoreError};
use serde_json::Value;

use crate::finish::Finished;
use crate::json;
use crate::out::errln;

/// Why a command stopped: its errors as JSON, and the lines standard error shows.
pub struct Stop {
    pub errors: Vec<Value>,
    pub lines: Vec<String>,
}

impl Stop {
    /// One error of `kind`, its message also the line.
    pub fn one(kind: &str, message: String) -> Self {
        Self::all(kind, vec![message])
    }

    /// One error of `kind` for each message, each message also a line.
    pub fn all(kind: &str, messages: Vec<String>) -> Self {
        Self {
            errors: messages
                .iter()
                .map(|message| json::error(kind, message, &[]))
                .collect(),
            lines: messages,
        }
    }

    /// The validator's errors, each at the sites of the elements it names.
    pub fn invalid(errors: &[Placed]) -> Self {
        Self {
            errors: json::validation_errors(errors),
            lines: errors.iter().map(ToString::to_string).collect(),
        }
    }

    /// Prints the failure document under `schema` when JSON was asked for, and each line on
    /// standard error, and exits 1.
    pub fn exit(self, schema: &str, as_json: bool) -> Finished {
        let finished = Finished::stopped(&self.errors);
        if as_json {
            json::print(&json::failure(schema, self.errors));
        }
        for line in &self.lines {
            errln!("{line}");
        }
        finished
    }
}

impl From<StoreError> for Stop {
    fn from(error: StoreError) -> Self {
        Self::one("store", error.to_string())
    }
}

impl From<Vec<ReadError>> for Stop {
    fn from(errors: Vec<ReadError>) -> Self {
        Self {
            errors: json::read_errors(&errors),
            lines: errors.iter().map(ToString::to_string).collect(),
        }
    }
}

impl From<Vec<TraceError>> for Stop {
    fn from(errors: Vec<TraceError>) -> Self {
        Self {
            errors: errors
                .iter()
                .map(|error| {
                    let site = json::site_at(&TRACE, error.location);
                    json::error_at("trace", &error.problem.to_string(), vec![site])
                })
                .collect(),
            lines: errors.iter().map(ToString::to_string).collect(),
        }
    }
}

/// The files of the tree under `root`.
pub fn read_files(root: &Path) -> Result<Files, Stop> {
    Ok(FileStore::open(root)?.read_files()?)
}