Enum RulesVerdict 

pub enum RulesVerdict {
    Proven,
    Unproven,
    Failing,
}

What the whole corpus can be said to prove, in one word, before any number is read.

satisfied answers a narrower question — are there findings — and a corpus in which no blocking rule was ever run has none, because not run, gated and reviewed are weaker states rather than defects (docs/DOCTRINE.md). Read alone, satisfied: true over such a corpus says “every rule is enforced” about a repository that has shown nothing. The verdict is the answer that cannot be read that way: it is proven only when every blocking rule is proven — a passing run recorded on a clean tree, at a commit that nothing but the evidence ledger has changed since. A rule whose inputs are merely unchanged is not that (ADR 0041), and leaves the corpus unproven.

Example

use majordomus_cli::rules::{RuleState, RulesVerdict};
// a corpus with a finding is failing, whatever else is true of it
assert_eq!(RulesVerdict::of([RuleState::Proven], true), RulesVerdict::Failing);
// one blocking rule never run is enough to leave the corpus unproven
assert_eq!(
    RulesVerdict::of([RuleState::Proven, RuleState::NotRun], false),
    RulesVerdict::Unproven
);
assert_eq!(RulesVerdict::of([RuleState::Proven], false), RulesVerdict::Proven);
// a pass whose inputs are merely unchanged is not proven
assert_eq!(
    RulesVerdict::of([RuleState::Proven, RuleState::InputsUnchanged], false),
    RulesVerdict::Unproven
);

Variants

Proven

Every blocking rule is proven: a passing run recorded on a clean tree, at a commit that nothing but the evidence ledger has changed since.

Unproven

No rule is a finding, and at least one blocking rule is not proven — never run, gated, reviewed, stale, or passing with only its inputs unchanged — or there is no blocking rule at all.

Failing

At least one rule declares a class its proof does not support.

Implementations

impl RulesVerdict

pub fn of( blocking: impl IntoIterator<Item = RuleState>, any_finding: bool, ) -> Self

Decide the verdict from the state of every blocking rule and whether any finding exists.

Only proven counts. stale does not: a pass older than its subject is a pass of something else. Nor does inputs unchanged: a run recorded on a dirty tree, or one whose repository has moved since, is the absence of a known invalidation and not proof (ADR 0041), and a corpus verdict of proven over it would be the one badge the evidence states exist to refuse. An empty set of blocking rules is unproven, not proven — a corpus that claims nothing has shown nothing, and success by vacancy is the number that stops meaning anything.

use majordomus_cli::rules::{RuleState, RulesVerdict};
assert_eq!(RulesVerdict::of([RuleState::Stale], false), RulesVerdict::Unproven);
assert_eq!(RulesVerdict::of([], false), RulesVerdict::Unproven);
assert_eq!(
    RulesVerdict::of([RuleState::InputsUnchanged], false),
    RulesVerdict::Unproven
);

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

The one word every surface prints for this verdict, and the one word a script greps for: the serialised form and the rendered form are the same string, so a reader and a parser can never be told different things about the same report. The three are proven, unproven and failing, and the middle one exists because “no finding” and “proven” are not the same answer — RulesVerdict::meaning says why in prose.

use majordomus_cli::rules::RulesVerdict;
assert_eq!(RulesVerdict::Unproven.label(), "unproven");
assert_eq!(RulesVerdict::Proven.label(), "proven");
assert_eq!(RulesVerdict::Failing.label(), "failing");

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

What the verdict asserts, in one sentence, carried beside the label so that a reader is never left to infer it from a colour or a word.

The sentence is the whole point of the type. A report that found no fault used to be rendered as a pass, and “no rule is a finding” is a far weaker statement than “every blocking rule is proven”: the first is satisfied by a corpus nothing has ever run. unproven says that distinction out loud, in the one place a person reads, so that an absence of findings cannot be quoted as proof.

use majordomus_cli::rules::RulesVerdict;
assert!(RulesVerdict::Unproven.meaning().contains("not a finding"));
assert!(RulesVerdict::Proven.meaning().contains("Every blocking rule"));

Trait Implementations

impl Clone for RulesVerdict

fn clone(&self) -> RulesVerdict

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for RulesVerdict

impl Debug for RulesVerdict

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RulesVerdict

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for RulesVerdict

impl Hash for RulesVerdict

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 JsonSchema for RulesVerdict

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 RulesVerdict

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

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

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

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 RulesVerdict