unsafe-review-cli 0.3.6

CLI adapter for unsafe-review
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

use serde_json::{Value, json};
use unsafe_review_core::ReviewCard;

use crate::lsp::TRUST_BOUNDARY;

pub(super) fn build_diagnostic_data(card: &ReviewCard) -> Value {
    json!({
        "card_id": &card.id.0,
        "operation": &card.operation.expression,
        "operation_family": card.operation.family.as_str(),
        "hazards": card.hazards.iter().map(|hazard| hazard.as_str()).collect::<Vec<_>>(),
        "required_safety_conditions": card.obligations.iter().map(|obligation| {
            json!({
                "key": &obligation.key,
                "description": &obligation.description
            })
        }).collect::<Vec<_>>(),
        "evidence_summary": {
            "contract": {
                "present": card.contract.present,
                "state": present_label(card.contract.present),
                "summary": &card.contract.summary
            },
            "discharge": {
                "present": card.discharge.present,
                "state": present_label(card.discharge.present),
                "summary": &card.discharge.summary
            },
            "reach": {
                "state": &card.reach.state,
                "summary": &card.reach.summary
            },
            "witness": {
                "present": card.witness.present,
                "state": present_label(card.witness.present),
                "summary": &card.witness.summary
            },
            "reach_limitation": "static reach evidence is not proof that the unsafe site executed"
        },
        "obligation_evidence": card.obligation_evidence.iter().map(|evidence| {
            json!({
                "key": &evidence.obligation.key,
                "description": &evidence.obligation.description,
                "contract": evidence_state(
                    evidence.contract.present,
                    &evidence.contract.state,
                    &evidence.contract.summary
                ),
                "discharge": evidence_state(
                    evidence.discharge.present,
                    &evidence.discharge.state,
                    &evidence.discharge.summary
                ),
                "reach": evidence_state(
                    evidence.reach.present,
                    &evidence.reach.state,
                    &evidence.reach.summary
                ),
                "witness": evidence_state(
                    evidence.witness.present,
                    &evidence.witness.state,
                    &evidence.witness.summary
                )
            })
        }).collect::<Vec<_>>(),
        "missing_evidence": card.missing.iter().map(|missing| missing.message.as_str()).collect::<Vec<_>>(),
        "next_action": &card.next_action.summary,
        "witness_routes": card.routes.iter().map(|route| {
            json!({
                "kind": route.kind.as_str(),
                "reason": &route.reason,
                "command": route.command.as_deref(),
                "required": route.required
            })
        }).collect::<Vec<_>>(),
        "verify_commands": &card.next_action.verify_commands,
        "trust_boundary": TRUST_BOUNDARY
    })
}

fn evidence_state(present: bool, state: &str, summary: &str) -> Value {
    json!({
        "present": present,
        "state": state,
        "summary": summary
    })
}

fn present_label(present: bool) -> &'static str {
    if present { "present" } else { "missing" }
}