aqc-text-engine-core 0.2.0

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

//! Text byte-stream requirement merge logic.

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

use super::{ResolvedTextFileRequirements, TextFileRequirements, TextSnippet};

/// Provenance-tagged text requirements routed to one text-engine target.
type TextRequirementInput = Vec<(Provenance, TextFileRequirements)>;
/// Resolved text requirements plus merge conflicts found during resolution.
type TextMergeOutput = (ResolvedTextFileRequirements, Vec<ConflictEntry>);

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: TextRequirementInput) -> TextMergeOutput {
        let mut conflicts = Vec::new();
        let exact_contents = resolve_optional_scalar(
            "exact_contents",
            &reqs,
            |req| req.exact_contents.clone(),
            &mut conflicts,
        );
        let required_snippets = resolve_snippets(
            "required_snippets",
            &reqs,
            |req| req.required_snippets.clone(),
            &mut conflicts,
        );
        (
            ResolvedTextFileRequirements {
                exact_contents,
                required_snippets,
            },
            conflicts,
        )
    }
}

/// Resolve optional scalar text assertions while preserving 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)
    }
}

/// Resolve required text snippets through the shared item merge primitive.
fn resolve_snippets(
    key: &str,
    items: &[(Provenance, TextFileRequirements)],
    get: impl Fn(&TextFileRequirements) -> ItemRequirements<TextSnippet>,
    conflicts: &mut Vec<ConflictEntry>,
) -> ResolvedItemRequirements<TextSnippet> {
    resolve_items(
        key,
        items
            .iter()
            .map(|(prov, req)| (prov.clone(), get(req)))
            .collect(),
        conflicts,
    )
}