loftspec 2.0.2

The Loft Specification Format: document model, identity, canonical bytes, hashing and conversion
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
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
123
124
125
126
127
128
129
130
131
132

//! Former labels (RQ-179, RQ-180) and the completeness a decision's state requires (RQ-184,
//! RQ-185). References inside a decision and its successors are checked by the index.

use super::ValidationError;
use crate::decision::{Decision, DriverPayload, NodeRef, StateKind};
use crate::document::{Document, Edge, SubjectRole};
use crate::identity::Label;

pub(super) fn check(document: &Document, errors: &mut Vec<ValidationError>) {
    for decision in &document.decisions {
        former_labels(document, decision, errors);
        completeness(document, decision, errors);
    }
}

/// Every former label the document's decisions name, in one pass over the edges and the
/// decisions: in `subject` edges, drivers and consequences.
pub(crate) fn all_former_labels<'a>(
    edges: &'a [Edge],
    decisions: &'a [Decision],
) -> impl Iterator<Item = Label> + 'a {
    let edges = edges.iter().filter_map(|edge| match *edge {
        Edge::Subject { subject, .. } => Some(subject),
        _ => None,
    });
    let elements = decisions.iter().flat_map(|decision| {
        let drivers = decision
            .drivers
            .iter()
            .filter_map(|driver| match driver.payload {
                DriverPayload::Subject { subject } => Some(subject),
                DriverPayload::Local { .. } => None,
            });
        drivers.chain(decision.consequences.iter().filter_map(|c| c.subject))
    });
    edges.chain(elements).filter_map(|subject| match subject {
        NodeRef::Former(label) => Some(label),
        NodeRef::Held(_) => None,
    })
}

/// Every former label a decision names: in its `subject` edges, its drivers and its
/// consequences.
fn former_labels_of<'a>(
    document: &'a Document,
    decision: &'a Decision,
) -> impl Iterator<Item = Label> + 'a {
    let edges = document.edges.iter().filter_map(move |edge| match *edge {
        Edge::Subject {
            decision: from,
            subject,
            ..
        } if from == decision.id => Some(subject),
        _ => None,
    });
    let drivers = decision
        .drivers
        .iter()
        .filter_map(|driver| match driver.payload {
            DriverPayload::Subject { subject } => Some(subject),
            DriverPayload::Local { .. } => None,
        });
    let consequences = decision.consequences.iter().filter_map(|c| c.subject);
    edges
        .chain(drivers)
        .chain(consequences)
        .filter_map(|subject| match subject {
            NodeRef::Former(label) => Some(label),
            NodeRef::Held(_) => None,
        })
}

fn former_labels(document: &Document, decision: &Decision, errors: &mut Vec<ValidationError>) {
    let kind = decision.state.kind();
    let terminal = matches!(kind, StateKind::Retired | StateKind::Superseded);
    for label in former_labels_of(document, decision) {
        if !terminal {
            errors.push(ValidationError::FormerLabelInLiveDecision {
                decision: decision.id,
                state: kind.as_str(),
                label,
            });
        }
        if let Some(element) = document.bindings.resolve(label) {
            errors.push(ValidationError::FormerLabelInUse { label, element });
        }
    }
}

/// A resolved decision weighs at least two options against a driver, with every assessment
/// (RQ-184); an accepted, superseded or retired one also has a consequence and an `outcome`
/// subject (RQ-185).
fn completeness(document: &Document, decision: &Decision, errors: &mut Vec<ValidationError>) {
    let kind = decision.state.kind();
    if kind == StateKind::Proposed {
        return;
    }
    let id = decision.id;
    if decision.options.len() < 2 {
        errors.push(ValidationError::TooFewOptions(id));
    }
    if decision.drivers.is_empty() {
        errors.push(ValidationError::NoDriver(id));
    }
    for option in &decision.options {
        for driver in &decision.drivers {
            let assessed = decision
                .assessments
                .iter()
                .any(|cell| cell.option == option.id && cell.driver == driver.id);
            if !assessed {
                errors.push(ValidationError::MissingAssessment {
                    decision: id,
                    option: option.id,
                    driver: driver.id,
                });
            }
        }
    }
    if kind == StateKind::Rejected {
        return;
    }
    if decision.consequences.is_empty() {
        errors.push(ValidationError::NoConsequence(id));
    }
    let has_outcome = document.edges.iter().any(|edge| {
        matches!(*edge, Edge::Subject { decision: from, role: SubjectRole::Outcome, .. } if from == id)
    });
    if !has_outcome {
        errors.push(ValidationError::NoOutcomeSubject(id));
    }
}