Skip to main content

ifc_template_catalog/compliance/
validate.rs

1use std::collections::{BTreeMap, BTreeSet};
2
3use crate::definition::{PropertyKind, PropertyTemplate, SetTemplate, SetTemplateKind};
4
5use super::{
6    MemberForm, ObservedSet, UnexpectedMemberPolicy, ValidationCode, ValidationIssue,
7    ValidationPolicy, ValidationReport, ValidationSeverity,
8};
9
10struct Expected {
11    form: MemberForm,
12    data_types: Vec<String>,
13    values: Vec<String>,
14}
15
16/// Check an [`ObservedSet`] against a [`SetTemplate`]'s expected members and
17/// return every deviation found under `policy`. Never fails; disagreements
18/// are reported as issues, not as a `Result` error.
19pub fn validate(
20    template: &SetTemplate,
21    observed: &ObservedSet,
22    policy: ValidationPolicy,
23) -> ValidationReport {
24    let mut report = ValidationReport::default();
25    if template.name != observed.name {
26        push(
27            &mut report,
28            ValidationCode::SetNameMismatch,
29            ValidationSeverity::Error,
30            None,
31            format!(
32                "observed `{}` does not match template `{}`",
33                observed.name, template.name
34            ),
35        );
36    }
37    let expected = expected_members(template);
38    let mut seen = BTreeSet::new();
39    for member in &observed.members {
40        if !seen.insert(member.name.as_str()) {
41            push(
42                &mut report,
43                ValidationCode::DuplicateMember,
44                ValidationSeverity::Error,
45                Some(&member.name),
46                "member appears more than once".into(),
47            );
48            continue;
49        }
50        let Some(spec) = expected.get(&member.name) else {
51            let severity = match policy.unexpected_members {
52                UnexpectedMemberPolicy::Ignore => continue,
53                UnexpectedMemberPolicy::Warning => ValidationSeverity::Warning,
54                UnexpectedMemberPolicy::Error => ValidationSeverity::Error,
55            };
56            push(
57                &mut report,
58                ValidationCode::UnexpectedMember,
59                severity,
60                Some(&member.name),
61                "member is not declared by the template".into(),
62            );
63            continue;
64        };
65        if member.form != spec.form {
66            push(
67                &mut report,
68                ValidationCode::FormMismatch,
69                ValidationSeverity::Error,
70                Some(&member.name),
71                format!("observed {:?}, expected {:?}", member.form, spec.form),
72            );
73        }
74        if !member.data_types.is_empty()
75            && !spec.data_types.is_empty()
76            && !same_types(&member.data_types, &spec.data_types)
77        {
78            push(
79                &mut report,
80                ValidationCode::DataTypeMismatch,
81                ValidationSeverity::Error,
82                Some(&member.name),
83                format!(
84                    "observed {:?}, expected {:?}",
85                    member.data_types, spec.data_types
86                ),
87            );
88        }
89        if let Some(value) = &member.enumeration_value {
90            if !spec.values.is_empty() && !spec.values.iter().any(|item| item == value) {
91                push(
92                    &mut report,
93                    ValidationCode::InvalidEnumerationValue,
94                    ValidationSeverity::Error,
95                    Some(&member.name),
96                    format!("`{value}` is not in the template enumeration"),
97                );
98            }
99        }
100    }
101    if policy.require_all_members {
102        for name in expected.keys().filter(|name| !seen.contains(name.as_str())) {
103            push(
104                &mut report,
105                ValidationCode::MissingMember,
106                ValidationSeverity::Error,
107                Some(name),
108                "required-by-policy member is absent".into(),
109            );
110        }
111    }
112    report
113}
114
115fn expected_members(template: &SetTemplate) -> BTreeMap<String, Expected> {
116    let mut output = BTreeMap::new();
117    match &template.kind {
118        SetTemplateKind::Property { properties, .. } => flatten("", properties, &mut output),
119        SetTemplateKind::Quantity { quantities, .. } => {
120            for quantity in quantities {
121                output.insert(
122                    quantity.name.clone(),
123                    Expected {
124                        form: MemberForm::Quantity(quantity.kind),
125                        data_types: vec![],
126                        values: vec![],
127                    },
128                );
129            }
130        }
131    }
132    output
133}
134
135fn flatten(parent: &str, properties: &[PropertyTemplate], output: &mut BTreeMap<String, Expected>) {
136    for property in properties {
137        let path = if parent.is_empty() {
138            property.name.clone()
139        } else {
140            format!("{parent}.{}", property.name)
141        };
142        let (form, data_types, values) = describe(&property.kind);
143        output.insert(
144            path.clone(),
145            Expected {
146                form,
147                data_types,
148                values,
149            },
150        );
151        if let PropertyKind::Complex { properties, .. } = &property.kind {
152            flatten(&path, properties, output);
153        }
154    }
155}
156
157fn describe(kind: &PropertyKind) -> (MemberForm, Vec<String>, Vec<String>) {
158    let one = |name: &Option<String>| name.clone().into_iter().collect();
159    match kind {
160        PropertyKind::SingleValue { data_type } => {
161            (MemberForm::SingleValue, one(&data_type.type_name), vec![])
162        }
163        PropertyKind::BoundedValue { data_type } => {
164            (MemberForm::BoundedValue, one(&data_type.type_name), vec![])
165        }
166        PropertyKind::EnumeratedValue {
167            data_type,
168            values,
169            constants,
170            ..
171        } => (
172            MemberForm::EnumeratedValue,
173            data_type
174                .as_ref()
175                .and_then(|item| item.type_name.clone())
176                .into_iter()
177                .collect(),
178            values
179                .iter()
180                .cloned()
181                .chain(constants.iter().map(|constant| constant.name.clone()))
182                .collect(),
183        ),
184        PropertyKind::ListValue { data_type } => {
185            (MemberForm::ListValue, one(&data_type.type_name), vec![])
186        }
187        PropertyKind::ReferenceValue { reference_type } => (
188            MemberForm::ReferenceValue,
189            vec![reference_type.clone()],
190            vec![],
191        ),
192        PropertyKind::TableValue {
193            defining_type,
194            defined_type,
195            ..
196        } => (
197            MemberForm::TableValue,
198            [
199                defining_type.type_name.clone(),
200                defined_type.type_name.clone(),
201            ]
202            .into_iter()
203            .flatten()
204            .collect(),
205            vec![],
206        ),
207        PropertyKind::Complex { .. } => (MemberForm::Complex, vec![], vec![]),
208    }
209}
210
211fn same_types(actual: &[String], expected: &[String]) -> bool {
212    actual.len() == expected.len()
213        && actual
214            .iter()
215            .zip(expected)
216            .all(|(left, right)| left.eq_ignore_ascii_case(right))
217}
218fn push(
219    report: &mut ValidationReport,
220    code: ValidationCode,
221    severity: ValidationSeverity,
222    member: Option<&str>,
223    message: String,
224) {
225    report.issues.push(ValidationIssue {
226        code,
227        severity,
228        member: member.map(str::to_owned),
229        message,
230    });
231}