use crate::validation::blocker::Blocker;
use crate::validation::options::{ExternalValidationMode, ValidationConfig};
use crate::validation::report::{
CoverageKind, NotApplied, NotAppliedReason, PartialApplication, RuleCoverage,
};
use crate::validation::rule_status::{RuleStatus, ValidationGate, ValidationRuleStatus};
fn gate_enabled(gate: ValidationGate, config: ValidationConfig) -> bool {
match gate {
ValidationGate::Always => true,
ValidationGate::Compliant => config.compliant,
ValidationGate::Complete => config.complete,
ValidationGate::BestPractice => config.best_practice,
}
}
pub fn compute_coverage(
catalog: &[ValidationRuleStatus],
external_mode: ExternalValidationMode,
config: ValidationConfig,
) -> RuleCoverage {
let mut coverage = RuleCoverage::default();
for status in catalog {
if !gate_enabled(status.gate, config) {
coverage.not_applied.push(NotApplied {
rule: status.rule,
reason: NotAppliedReason::GatedOff(status.gate),
});
continue;
}
match coverage_for_rule(status, external_mode) {
RuleCoverageOutcome::Fully => coverage.fully_applied.push(status.rule),
RuleCoverageOutcome::Partial(application) => {
coverage.partially_applied.push(application);
}
RuleCoverageOutcome::NotApplied(record) => coverage.not_applied.push(record),
}
}
coverage
}
enum RuleCoverageOutcome {
Fully,
Partial(PartialApplication),
NotApplied(NotApplied),
}
fn coverage_for_rule(
status: &ValidationRuleStatus,
external_mode: ExternalValidationMode,
) -> RuleCoverageOutcome {
let resolver_satisfied = matches!(
external_mode,
ExternalValidationMode::ProvidedOnly | ExternalValidationMode::ExternalAllowed
);
match status.status {
RuleStatus::Error | RuleStatus::Warning => RuleCoverageOutcome::Fully,
RuleStatus::Configurable => {
let blocker = status
.blocker
.expect("Configurable rule must declare a blocker (build invariant)");
match blocker {
Blocker::Resolver if resolver_satisfied => RuleCoverageOutcome::Fully,
Blocker::Resolver => RuleCoverageOutcome::Partial(PartialApplication {
rule: status.rule,
blocker,
coverage_kind: CoverageKind::LocalReferencesOnly,
}),
Blocker::External => RuleCoverageOutcome::Partial(PartialApplication {
rule: status.rule,
blocker,
coverage_kind: CoverageKind::LocalReferencesOnly,
}),
_ => RuleCoverageOutcome::Fully,
}
}
RuleStatus::MachineUncheckable => RuleCoverageOutcome::NotApplied(NotApplied {
rule: status.rule,
reason: NotAppliedReason::MachineUncheckable,
}),
RuleStatus::Unimplemented => {
let blocker = status
.blocker
.expect("Unimplemented rule must declare a blocker (build invariant)");
RuleCoverageOutcome::NotApplied(NotApplied {
rule: status.rule,
reason: NotAppliedReason::Deferred(blocker),
})
}
}
}
#[allow(dead_code)]
pub fn coverage_kind_for(blocker: Blocker) -> CoverageKind {
match blocker {
Blocker::Ontology => CoverageKind::OntologyKnownTermsOnly,
Blocker::Resolver | Blocker::External => CoverageKind::LocalReferencesOnly,
Blocker::Policy => CoverageKind::PolicyDefaultUndecided,
Blocker::StrictDatatype => CoverageKind::LexicalShapeOnly,
}
}