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

use super::index::CheckIndex;
use provenance_core::{Scope, ScopeId, StableId};
use provenance_store::state_store::StateStore;
use std::collections::BTreeSet;

mod collaboration;
mod core;
mod ideation;

struct ScopeRecords {
    scope_id: ScopeId,
    core: core::Records,
    collaboration: collaboration::Records,
    ideation: ideation::Records,
}

impl ScopeRecords {
    fn load(store: &StateStore, scope_id: &ScopeId) -> anyhow::Result<Self> {
        Ok(Self {
            scope_id: scope_id.clone(),
            core: core::Records::load(store, scope_id)?,
            collaboration: collaboration::Records::load(store, scope_id)?,
            ideation: ideation::Records::load(store, scope_id)?,
        })
    }

    fn validate_scope_ownership(
        &self,
        manifest_scopes: &BTreeSet<String>,
        findings: &mut Vec<String>,
    ) {
        self.core.validate_scope_ownership(&self.scope_id, findings);
        self.collaboration
            .validate_scope_ownership(manifest_scopes, &self.scope_id, findings);
        self.ideation
            .validate_scope_ownership(&self.scope_id, findings);
    }
}

fn check_scope_ownership(
    loaded_scope_id: &ScopeId,
    embedded_scope_id: &ScopeId,
    record_type: &str,
    record_id: &StableId,
    findings: &mut Vec<String>,
) {
    if loaded_scope_id != embedded_scope_id {
        findings.push(format!(
            "{record_type} {} loaded from scope {} has embedded scope_id {}",
            record_id.as_str(),
            loaded_scope_id.as_str(),
            embedded_scope_id.as_str()
        ));
    }
}

pub(super) fn validate(
    store: &StateStore,
    scopes: &[Scope],
    manifest_scopes: &BTreeSet<String>,
    index: &mut CheckIndex,
    dangling: &mut Vec<String>,
) -> anyhow::Result<()> {
    let records = scopes
        .iter()
        .map(|scope| ScopeRecords::load(store, &scope.id))
        .collect::<anyhow::Result<Vec<_>>>()?;

    let mut ownership_findings = Vec::new();
    for scope in &records {
        scope.validate_scope_ownership(manifest_scopes, &mut ownership_findings);
    }
    anyhow::ensure!(
        ownership_findings.is_empty(),
        "scope ownership finding(s):\n- {}",
        ownership_findings.join("\n- ")
    );

    for scope in &records {
        scope.core.add_to(index);
        scope.collaboration.add_to(index);
        scope.ideation.add_to(index);
    }
    for scope in &records {
        scope.core.validate(index, &scope.scope_id, dangling);
        scope
            .collaboration
            .validate(index, manifest_scopes, &scope.scope_id, dangling);
        scope.ideation.validate(index, &scope.scope_id, dangling);
    }

    Ok(())
}