aqc-text-engine-core 0.4.1

Reusable text file requirement, merge, and reconcile helpers for AQC file engines.
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

//! Text byte-stream requirement merge logic.

use aqc_file_engine_core::{
    ConflictEntry, Provenance, Resolve, ResolvedRequirement, ScalarAssertion, resolve_items,
};

use super::{ResolvedTextFileRequirements, TextFileRequirements};

impl TextFileRequirements {
    #[must_use]
    #[allow(
        clippy::needless_pass_by_value,
        reason = "merged_reconcile passes owned typed requirements to every engine merge function."
    )]
    pub fn merge(
        reqs: Vec<(Provenance, Self)>,
    ) -> (ResolvedTextFileRequirements, Vec<ConflictEntry>) {
        let mut conflicts = Vec::new();
        let exact_contents = resolve_optional_scalar(
            "exact_contents",
            &reqs,
            |req| req.exact_contents.clone(),
            &mut conflicts,
        );
        let contents = resolve_items(
            "contents",
            reqs.iter()
                .map(|(prov, req)| (prov.clone(), req.contents.clone()))
                .collect(),
            &mut conflicts,
        );
        (
            ResolvedTextFileRequirements {
                exact_contents,
                contents,
            },
            conflicts,
        )
    }
}

/// Resolve one optional scalar field while preserving source provenance.
fn resolve_optional_scalar<T>(
    key: &str,
    items: &[(Provenance, TextFileRequirements)],
    get: impl Fn(&TextFileRequirements) -> Option<ScalarAssertion<T>>,
    conflicts: &mut Vec<ConflictEntry>,
) -> Option<ResolvedRequirement<ScalarAssertion<T>, ScalarAssertion<T>>>
where
    T: aqc_file_engine_core::ScalarValue,
{
    let assertions = items
        .iter()
        .filter_map(|(prov, req)| get(req).map(|assertion| (prov.clone(), assertion)))
        .collect::<Vec<_>>();
    if assertions.is_empty() {
        None
    } else {
        ScalarAssertion::<T>::resolve(key, assertions, conflicts)
    }
}