Enum Predicate 

pub enum Predicate {
    CountAtLeast {
        key: String,
        min: usize,
    },
    CountAtMost {
        key: String,
        max: usize,
    },
    ContentMustNotContain {
        key: String,
        forbidden: Vec<ForbiddenTerm>,
    },
    ContentMustContain {
        key: String,
        required_field: String,
    },
    CrossReference {
        source_key: String,
        target_key: String,
    },
    HasFacts {
        key: String,
    },
    RequiredFields {
        key: String,
        fields: Vec<FieldRequirement>,
    },
    Custom {
        description: String,
    },
}

A semantic predicate extracted from Gherkin steps.

Represents the testable assertion that an invariant checks. Each variant maps to a code pattern in the generated Rust check.

Variants

CountAtLeast

“the Context key X contains at least N facts”

Fields

key: String

min: usize

CountAtMost

“the Context key X contains at most N facts”

Fields

key: String

max: usize

ContentMustNotContain

“it must not contain any forbidden term” (with table of terms)

Fields

key: String

forbidden: Vec<ForbiddenTerm>

ContentMustContain

“it must include field X with a non-empty value”

Fields

key: String

required_field: String

CrossReference

“for each X fact there exists a Y fact referencing it”

Fields

source_key: String

target_key: String

HasFacts

“any fact under key X” / “facts exist under key X”

Fields

key: String

RequiredFields

“must include” with a table of required fields

Fields

key: String

fields: Vec<FieldRequirement>

Custom

Unrecognized step — preserved for downstream handling.

Fields

description: String

Trait Implementations

impl Clone for Predicate

fn clone(&self) -> Predicate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Predicate

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

Formats the value using the given formatter.

impl PartialEq for Predicate

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Predicate