Enum TreeState 

pub enum TreeState {
    Clean,
    Dirty,
    Unknown,
}

Whether a tree was the commit it sits on: the three words the ledger and git already use, typed.

unknown is not a softer clean. It is what is recorded when git could not be asked, and not knowing is not proof, so every rule here treats it as not clean.

use majordomus_cli::evidence::freshness::TreeState;

assert_eq!(TreeState::parse("clean"), TreeState::Clean);
assert_eq!(TreeState::parse("dirty"), TreeState::Dirty);
// a word nobody wrote down is not a clean tree
assert_eq!(TreeState::parse("spotless"), TreeState::Unknown);
assert_eq!(TreeState::Dirty.as_str(), "dirty");
assert_eq!(serde_json::to_value(TreeState::Unknown).unwrap(), "unknown");

Variants

Clean

The tree was the commit: nothing but the evidence ledger differed from it.

Dirty

Something other than the evidence ledger differed from the commit.

Unknown

Git could not be asked, or the word recorded is none of the three.

Implementations

impl TreeState

pub fn parse(word: &str) -> TreeState

Read the word a recorder or git wrote: clean and dirty are themselves, and anything else is TreeState::Unknown, never a guess at one of the other two.

use majordomus_cli::evidence::freshness::TreeState;
assert_eq!(TreeState::parse("clean"), TreeState::Clean);
assert_eq!(TreeState::parse("Clean"), TreeState::Unknown, "the words are exact");
assert_eq!(TreeState::parse(""), TreeState::Unknown);

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

The word itself, as the ledger and the report spell it.

use majordomus_cli::evidence::freshness::TreeState;
for t in [TreeState::Clean, TreeState::Dirty, TreeState::Unknown] {
    assert_eq!(TreeState::parse(t.as_str()), t, "the word reads back as itself");
}

pub fn weaker(self, other: TreeState) -> TreeState

The weaker of two statements about one tree: clean only when both say clean, dirty when either says dirty, and unknown otherwise.

This is how a caller’s own knowledge meets a measurement. A site build that knows its tree was dirty can weaken a clean measurement; nothing a caller says can make a measured dirty tree clean.

use majordomus_cli::evidence::freshness::TreeState::{Clean, Dirty, Unknown};
assert_eq!(Clean.weaker(Clean), Clean);
assert_eq!(Clean.weaker(Dirty), Dirty);
assert_eq!(Dirty.weaker(Clean), Dirty, "a given clean never overrides a dirty tree");
assert_eq!(Unknown.weaker(Dirty), Dirty);
assert_eq!(Clean.weaker(Unknown), Unknown);

Trait Implementations

impl Clone for TreeState

fn clone(&self) -> TreeState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for TreeState

impl Debug for TreeState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TreeState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for TreeState

impl JsonSchema for TreeState

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 PartialEq for TreeState

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

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 TreeState