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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use crate::ConditionalGuard;

/// Reports whether two conditional guards are exact logical complements.
#[must_use]
pub fn guards_are_complementary(left: &ConditionalGuard, right: &ConditionalGuard) -> bool {
    fn negated_truthy_path(guard: &ConditionalGuard) -> Option<&str> {
        let ConditionalGuard::Not(inner) = guard else {
            return None;
        };
        match inner.as_ref() {
            ConditionalGuard::Truthy { path } => Some(path),
            _ => None,
        }
    }
    match (left, right) {
        (ConditionalGuard::Truthy { path }, negated)
        | (negated, ConditionalGuard::Truthy { path }) => {
            negated_truthy_path(negated) == Some(path)
        }
        _ => false,
    }
}

/// Reports whether every member of `subset` occurs in the larger `superset`.
#[must_use]
pub fn key_is_strict_subset(subset: &[ConditionalGuard], superset: &[ConditionalGuard]) -> bool {
    key_is_strict_subset_by(subset, superset)
}

/// Keys differing in exactly one complementary member resolve to their shared key.
#[must_use]
pub fn resolve_complementary_keys(
    left: &[ConditionalGuard],
    right: &[ConditionalGuard],
) -> Option<Vec<ConditionalGuard>> {
    resolve_complementary_keys_by(left, right, guards_are_complementary)
}

fn key_is_strict_subset_by<T: PartialEq>(subset: &[T], superset: &[T]) -> bool {
    subset.len() < superset.len() && subset.iter().all(|item| superset.contains(item))
}

fn resolve_complementary_keys_by<T: Clone + PartialEq>(
    left: &[T],
    right: &[T],
    are_complementary: impl Fn(&T, &T) -> bool,
) -> Option<Vec<T>> {
    if left.len() != right.len() {
        return None;
    }
    let left_only: Vec<&T> = left.iter().filter(|guard| !right.contains(guard)).collect();
    let right_only: Vec<&T> = right.iter().filter(|guard| !left.contains(guard)).collect();
    let ([left_extra], [right_extra]) = (left_only.as_slice(), right_only.as_slice()) else {
        return None;
    };
    if !are_complementary(left_extra, right_extra) {
        return None;
    }
    Some(
        left.iter()
            .filter(|guard| *guard != *left_extra)
            .cloned()
            .collect(),
    )
}

/// Minimize a disjunction of conjunctive guard keys by exact resolution,
/// absorption, and deduplication.
#[must_use]
pub fn minimize_key_disjunction(keys: Vec<Vec<ConditionalGuard>>) -> Vec<Vec<ConditionalGuard>> {
    minimize_disjunction_by(keys, guards_are_complementary)
}

pub(crate) fn minimize_disjunction_by<T: Clone + Ord>(
    mut keys: Vec<Vec<T>>,
    are_complementary: impl Copy + Fn(&T, &T) -> bool,
) -> Vec<Vec<T>> {
    keys.sort();
    keys.dedup();
    loop {
        let mut resolved = None;
        'search: for (index, left) in keys.iter().enumerate() {
            for (other_index, right) in keys.iter().enumerate().skip(index + 1) {
                if let Some(common) = resolve_complementary_keys_by(left, right, are_complementary)
                {
                    resolved = Some((index, other_index, common));
                    break 'search;
                }
            }
        }
        let Some((index, other_index, common)) = resolved else {
            break;
        };
        keys.remove(other_index);
        keys.remove(index);
        if !keys.contains(&common) {
            keys.push(common);
        }
        keys.sort();
    }
    let sets = keys.clone();
    keys.retain(|candidate| {
        !sets
            .iter()
            .any(|other| other != candidate && key_is_strict_subset_by(other, candidate))
    });
    keys
}