ifc_template_catalog/compliance/
validate.rs1use 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
16pub 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}