helm-schema-core 0.0.4

Generate an accurate JSON schema for any helm chart
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

use crate::{ApiPresenceQuery, CapabilityGuard, HelperBranch, HelperBranchBody};

/// Authoritative answer to a parsed `.Capabilities.APIVersions.Has` query for
/// a specific Kubernetes version.
pub trait CapabilityOracle: Send + Sync {
    /// Returns an authoritative presence answer, or `None` when uncertain.
    fn capability_has_query(&self, query: &ApiPresenceQuery) -> Option<bool>;
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum GuardLiveness {
    Live,
    Dead,
    Unknown,
}

/// Resolve a typed-branch chain to the literal alternatives the chart would
/// emit at runtime for the target K8s version. If a non-empty branch is not
/// statically decidable, return no chosen branch so callers preserve all
/// candidates instead of collapsing ambiguity to source order.
#[must_use]
pub fn live_literals<O: CapabilityOracle + ?Sized>(
    branches: &[HelperBranch],
    oracle: &O,
) -> Vec<String> {
    for branch in branches {
        if branch.body.is_empty() {
            continue;
        }
        match guard_liveness(branch.guard.as_ref(), oracle) {
            GuardLiveness::Dead => continue,
            GuardLiveness::Unknown => return Vec::new(),
            GuardLiveness::Live => {}
        }
        match &branch.body {
            HelperBranchBody::Literals { values } => return values.clone(),
            HelperBranchBody::Nested { branches: nested } => {
                let inner = live_literals(nested, oracle);
                if !inner.is_empty() {
                    return inner;
                }
            }
        }
    }
    Vec::new()
}

fn guard_liveness<O: CapabilityOracle + ?Sized>(
    guard: Option<&CapabilityGuard>,
    oracle: &O,
) -> GuardLiveness {
    match guard {
        None => GuardLiveness::Live,
        Some(CapabilityGuard::Opaque { .. }) => GuardLiveness::Unknown,
        Some(CapabilityGuard::Has { api }) => ApiPresenceQuery::parse_helm_literal(api)
            .and_then(|query| oracle.capability_has_query(&query))
            .map_or(GuardLiveness::Unknown, bool_liveness),
        Some(CapabilityGuard::NotHas { api }) => ApiPresenceQuery::parse_helm_literal(api)
            .and_then(|query| oracle.capability_has_query(&query))
            .map_or(GuardLiveness::Unknown, |has| bool_liveness(!has)),
    }
}

fn bool_liveness(live: bool) -> GuardLiveness {
    if live {
        GuardLiveness::Live
    } else {
        GuardLiveness::Dead
    }
}