dtcs 0.9.0

Reference implementation of the Data Transformation Contract Standard (DTCS)
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

//! Capability matching (SPEC Ch 14 ยง6).

use crate::diagnostics::{codes, compilation_error, DiagnosticCategory};
use crate::model::RegistryDocument;
use crate::plan::{validate_with_registry, TransformationPlan};
use crate::registry;

use super::model::{CapabilityMatchReport, EngineCapabilityDeclaration};
use super::requirements::PlanRequirements;
use super::validate;

/// Match a transformation plan against an engine capability declaration.
#[must_use]
pub fn match_plan(
    plan: &TransformationPlan,
    declaration: &EngineCapabilityDeclaration,
) -> CapabilityMatchReport {
    match_plan_with_registry(plan, declaration, registry::default_registry())
}

/// Match a transformation plan against an engine capability declaration with a registry catalog.
#[must_use]
pub fn match_plan_with_registry(
    plan: &TransformationPlan,
    declaration: &EngineCapabilityDeclaration,
    registry_doc: &RegistryDocument,
) -> CapabilityMatchReport {
    let mut report = CapabilityMatchReport::default();

    let plan_validation = validate_with_registry(plan, registry_doc);
    if !plan_validation.is_valid() {
        report.diagnostics = plan_validation.diagnostics;
        report.supported = false;
        return report;
    }

    let validation = validate(declaration);
    if !validation.is_valid() {
        report.diagnostics = validation.diagnostics;
        report.supported = false;
        return report;
    }

    let requirements = PlanRequirements::from_plan(plan);
    report.missing = requirements.gaps_against(declaration);

    for gap in &report.missing {
        report.diagnostics.push(
            compilation_error(
                codes::UNSUPPORTED_CAPABILITY,
                DiagnosticCategory::Capability,
                format!(
                    "engine '{}' does not support {} '{}'",
                    declaration.engine_id, gap.category, gap.required
                ),
            )
            .with_object_ref(&gap.required),
        );
    }

    report.supported = report.missing.is_empty();
    report
}