provenance-cli 0.2.1

Command-line interface for Provenance requirements traceability
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

use std::io::Read as _;

use crate::cli::sdk::SdkCommand;
use crate::output;
use provenance_core::{ScopeId, StableId};
use provenance_store::operations;
use provenance_store::state_store::{BeginVerificationInput, CompleteVerificationInput};

mod check_statement;
mod query;
mod render;

pub(super) fn handle(command: SdkCommand) -> anyhow::Result<()> {
    match command {
        SdkCommand::CheckStatement { format } => check_statement::handle(format)?,
        SdkCommand::Info { repo, format } => {
            output::print(format, &operations::engine_info(repo)?)?;
        }
        SdkCommand::Plan {
            repo,
            scope,
            format,
        } => {
            let repo = Some(operations::discover_repository(repo)?);
            let input = read_stdin_json()?;
            let plan = operations::plan(repo, &ScopeId::new(scope)?, input)?;
            match format {
                output::OutputFormat::Json | output::OutputFormat::Jsonl => {
                    output::print(format, &plan)?;
                }
                output::OutputFormat::Markdown
                | output::OutputFormat::Table
                | output::OutputFormat::Toon => {
                    print!("{}", render::render(&plan));
                }
            }
        }
        SdkCommand::Apply {
            repo,
            scope,
            format,
        } => {
            let repo = Some(operations::discover_repository(repo)?);
            let input = read_stdin_json()?;
            let result = operations::apply(repo, &ScopeId::new(scope)?, input)?;
            output::print(format, &result)?;
        }
        SdkCommand::BeginVerification {
            repo,
            scope,
            format,
        } => {
            let repo = Some(operations::discover_repository(repo)?);
            let input = read_stdin_json::<BeginVerificationInput>()?;
            let run = operations::begin_verification(repo, ScopeId::new(scope)?, input)?;
            output::print(format, &run)?;
        }
        SdkCommand::CompleteVerification {
            repo,
            scope,
            format,
        } => {
            let repo = Some(operations::discover_repository(repo)?);
            let input = read_stdin_json::<CompleteVerificationInput>()?;
            let run = operations::complete_verification(repo, &ScopeId::new(scope)?, input)?;
            output::print(format, &run)?;
        }
        SdkCommand::VerificationRuns {
            repo,
            scope,
            rule,
            format,
        } => {
            let repo = Some(operations::discover_repository(repo)?);
            let rule = rule.map(StableId::new).transpose()?;
            let runs = operations::verification_runs(repo, &ScopeId::new(scope)?, rule.as_ref())?;
            output::print(format, &runs)?;
        }
        SdkCommand::Get { query } => query::handle(query::Operation::Get, query)?,
        SdkCommand::Search { query } => query::handle(query::Operation::Search, query)?,
        SdkCommand::Neighbors { query } => query::handle(query::Operation::Neighbors, query)?,
        SdkCommand::Trace { query } => query::handle(query::Operation::Trace, query)?,
        SdkCommand::Impact { query } => query::handle(query::Operation::Impact, query)?,
        SdkCommand::Evidence { query } => query::handle(query::Operation::Evidence, query)?,
        SdkCommand::Stale { query } => query::handle(query::Operation::Stale, query)?,
        SdkCommand::ResolveSymbol { query } => {
            query::handle(query::Operation::ResolveSymbol, query)?;
        }
        SdkCommand::VerificationBindings {
            repo,
            scope,
            rule,
            format,
        } => {
            let repo = Some(operations::discover_repository(repo)?);
            let rule = rule.map(StableId::new).transpose()?;
            let bindings =
                operations::verification_bindings(repo, &ScopeId::new(scope)?, rule.as_ref())?;
            output::print(format, &bindings)?;
        }
    }
    Ok(())
}

fn read_stdin_json<T: serde::de::DeserializeOwned>() -> anyhow::Result<T> {
    let mut input = String::new();
    std::io::stdin().read_to_string(&mut input)?;
    anyhow::ensure!(
        !input.trim().is_empty(),
        "expected a JSON document on stdin"
    );
    serde_json::from_str(&input).map_err(Into::into)
}