Enum ConditionalGuard 

pub enum ConditionalGuard {
    Truthy {
        path: ValuesPath,
    },
    With {
        path: ValuesPath,
    },
    Eq {
        path: ValuesPath,
        value: GuardValue,
    },
    NotEq {
        path: ValuesPath,
        value: GuardValue,
    },
    Absent {
        path: ValuesPath,
    },
    TypeIs {
        path: ValuesPath,
        schema_type: String,
    },
    MatchesPattern {
        path: ValuesPath,
        pattern: String,
    },
    IntGt {
        path: ValuesPath,
        bound: i64,
    },
    IntLt {
        path: ValuesPath,
        bound: i64,
    },
    HasKey {
        path: ValuesPath,
        key: String,
    },
    ContainsMemberEquals {
        path: ValuesPath,
        member: String,
        value: GuardValue,
    },
    ContainsTruthyMember {
        path: ValuesPath,
        member: String,
    },
    ContainsEquals {
        path: ValuesPath,
        value: GuardValue,
    },
    AtMostOneMember {
        path: ValuesPath,
    },
    MinMembers {
        path: ValuesPath,
        bound: i64,
    },
    Not(Box<ConditionalGuard>),
    AllOf(Vec<ConditionalGuard>),
    AnyOf(Vec<ConditionalGuard>),
}

Values-decidable guard expression that can be lowered into JSON Schema conditionals.

Variants

Truthy

The value at path is Helm-truthy.

Fields

path: ValuesPath

Values path tested for truthiness.

With

A with action selected the non-empty value at path.

Fields

path: ValuesPath

Values path selected by the action.

Eq

The value at path equals a literal.

Fields

path: ValuesPath

Values path compared with the literal.

value: GuardValue

Literal required at the path.

NotEq

The value at path differs from a literal.

Fields

path: ValuesPath

Values path compared with the literal.

value: GuardValue

Literal excluded at the path.

Absent

The value at path is absent.

Fields

path: ValuesPath

Values path whose absence selects the branch.

TypeIs

The value at path has a specific JSON Schema type.

Fields

path: ValuesPath

Values path subjected to the type test.

schema_type: String

JSON Schema type name accepted by the branch.

MatchesPattern

The string at path matches a regular expression.

Fields

path: ValuesPath

Values path subjected to the pattern test.

pattern: String

ECMA-compatible regular expression required by the branch.

IntGt

The path’s RAW value is a JSON integer strictly greater than bound — a sound SUBSET of the Sprig coercion (gt (int64 x) bound) it stands in for, valid only where firing less often is safe.

Fields

path: ValuesPath

Values path subjected to the integer comparison.

bound: i64

Exclusive lower bound.

IntLt

The mirror of ConditionalGuard::IntGt: the path’s RAW value is a JSON integer strictly less than bound, under the same sound-subset contract.

Fields

path: ValuesPath

Values path subjected to the integer comparison.

bound: i64

Exclusive upper bound.

HasKey

The mapping at path contains the literal member key. The key is an OPAQUE property name (it may contain dots), so it rides beside the segmented path instead of being appended to it.

Fields

path: ValuesPath

Values path expected to hold a mapping.

key: String

Literal mapping key whose presence selects the branch.

ContainsMemberEquals

SOME iterated item of the collection at path has member equal to value — the document-level meaning of a range-sentinel flag (Range(path) ∧ Eq(path.*.member, value)). Lowers to contains over the array lane and the double-negated member quantifier over the object lane.

Fields

path: ValuesPath

Values path expected to hold the iterated collection.

member: String

Member name compared within each collection item.

value: GuardValue

Literal that at least one member must equal.

ContainsTruthyMember

SOME iterated item of the collection at path has a Helm-truthy member — the document-level meaning of a Boolean range sentinel (Range(path) ∧ Truthy(path.*.member)).

Fields

path: ValuesPath

Values path expected to hold the iterated collection.

member: String

Member whose truthiness selects the sentinel state.

ContainsEquals

SOME item of the list at path deep-equals the scalar literal — Sprig has LITERAL .Values.list. has returns false on a nil haystack and aborts on non-lists, so the guard holds exactly for arrays carrying the literal; lowers to contains with a const item.

Fields

path: ValuesPath

Values path expected to hold the list.

value: GuardValue

Literal that at least one list item must equal.

AtMostOneMember

The collection at path has at most one entry — the document-level form of “every iteration of this range is the first” (an empty-initialized dedup accumulator cannot have shadowed anything). A sound subset: it may only scope positive-polarity evidence.

Fields

path: ValuesPath

Values path expected to hold the bounded collection.

MinMembers

The value at path is a mapping with at least bound members (gt (keys X | len) N). Exact: both polarities encode.

Fields

path: ValuesPath

Values path expected to hold the mapping.

bound: i64

Inclusive minimum number of members.

Not(Box<ConditionalGuard>)

Logical negation of a guard.

AllOf(Vec<ConditionalGuard>)

Conjunction of every enclosed guard.

AnyOf(Vec<ConditionalGuard>)

Disjunction of the enclosed guards.

Implementations

impl ConditionalGuard

pub fn is_self_truthy_for(&self, target: &ValuesPath) -> bool

Reports whether this guard tests the target’s own Helm truthiness.

pub fn is_self_presence_for(&self, target: &ValuesPath) -> bool

Reports whether this guard can hold only while the target path exists.

pub fn predicate(&self) -> Predicate

Reconstructs the exact Boolean predicate represented by this schema guard.

impl ConditionalGuard

pub fn value_paths(&self) -> BTreeSet<ValuesPath>

Returns every values path referenced by this guard tree.

pub fn map_value_paths<F>(self, map: &mut F) -> Self

where F: FnMut(ValuesPath) -> ValuesPath,

Rewrite the values paths carried by this guard (and every nested guard).

Trait Implementations

impl Clone for ConditionalGuard

fn clone(&self) -> ConditionalGuard

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ConditionalGuard

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for ConditionalGuard

impl Hash for ConditionalGuard

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for ConditionalGuard

fn cmp(&self, other: &ConditionalGuard) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for ConditionalGuard

fn eq(&self, other: &ConditionalGuard) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for ConditionalGuard

fn partial_cmp(&self, other: &ConditionalGuard) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for ConditionalGuard

impl TryFrom<&Guard> for ConditionalGuard

type Error = ()

The type returned in the event of a conversion error.

fn try_from(guard: &Guard) -> Result<Self, Self::Error>

Performs the conversion.