Enum GateStatus 

pub enum GateStatus {
    Pass,
    Fail,
    Stale,
    Blocked,
    Queued,
    Exempt,
    Unknown,
}

use majordomus_cli::gates::GateStatus;

// the three answers a reader is entitled to, and they are different answers
assert!(GateStatus::Fail.refuses(), "a run that failed refuses");
assert!(GateStatus::Queued.unverified(), "asked and unanswered is a debt");
assert!(!GateStatus::Exempt.refuses() && !GateStatus::Exempt.unverified());

// and the one that is neither: a run whose tree has moved proves nothing about this one
assert!(GateStatus::Stale.refuses());
assert_eq!(GateStatus::Stale.as_str(), "stale");

What is known about one gate. Every word is one this repository’s design tokens already carry (share/design/tokens.yaml, status.states), so a surface renders it without being taught a sixth vocabulary and the design gate does not refuse it.

Variants

Pass

It ran over these inputs and succeeded. The only word that discharges anything.

Fail

It ran over these inputs and failed. Completion is refused.

Stale

It ran, and the files that select it have changed since; what it proved is about a tree that no longer exists. Completion is refused, because the alternative is treating a claim about the past as a claim about the present.

Blocked

Something it cannot run without has not passed, so its own silence means nothing.

Queued

The plan selects it and no run has ever reported. Not unknown: the question was asked and no answer came, which is a debt somebody owes, and not pass, which is the mistake this word exists to make impossible.

Exempt

The plan does not select it: nothing the task changed can make it true or false.

Unknown

It cannot be judged here at all — no model, no git, a ledger that would not read. An honest gap, and never a pass.

Implementations

impl GateStatus

pub fn as_str(self) -> &'static str

The word this status is reported under.

use majordomus_cli::gates::GateStatus;
assert_eq!(GateStatus::Queued.as_str(), "queued");
// green and never-reported are different words, which is the whole point
assert_ne!(GateStatus::Pass.as_str(), GateStatus::Queued.as_str());

pub fn refuses(self) -> bool

Does this status, on a required gate, refuse canonical completion?

True only for what is known to be wrong: a run that failed, a run whose evidence no longer describes the tree, and a gate whose prerequisite is in one of those states. Absence does not refuse — queued and unknown are reported as unverified, and a worker who claims a task is finished over them is making a claim the record contradicts rather than one the tool accepted.

use majordomus_cli::gates::GateStatus;
assert!(GateStatus::Fail.refuses() && GateStatus::Stale.refuses());
assert!(!GateStatus::Queued.refuses(), "absence is a debt, not a failure");
assert!(!GateStatus::Exempt.refuses());

pub fn unverified(self) -> bool

Is this status the absence of a verdict rather than a verdict?

use majordomus_cli::gates::GateStatus;
// asked and unanswered, or unaskable: two different gaps, both reported as gaps
assert!(GateStatus::Queued.unverified() && GateStatus::Unknown.unverified());
// a verdict is a verdict whichever way it went
assert!(!GateStatus::Pass.unverified() && !GateStatus::Fail.unverified());
// and a gate the change cannot affect was never a question
assert!(!GateStatus::Exempt.unverified());

Trait Implementations

impl Clone for GateStatus

fn clone(&self) -> GateStatus

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for GateStatus

impl Debug for GateStatus

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GateStatus

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for GateStatus

impl JsonSchema for GateStatus

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Ord for GateStatus

fn cmp(&self, other: &GateStatus) -> 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.

impl PartialEq for GateStatus

fn eq(&self, other: &GateStatus) -> 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 PartialOrd for GateStatus

fn partial_cmp(&self, other: &GateStatus) -> 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 Serialize for GateStatus

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for GateStatus