Enum Transition 

pub enum Transition {
    Start,
    Verify,
    Done,
}

One lifecycle move.

Three, not four: evidence appends a record rather than moving an issue, and it belongs with the record it proves rather than with the moves it unblocks.

use majordomus_cli::plan::Transition;

// The wire spelling is the one a caller types on the command line.
let t: Transition = serde_json::from_str("\"done\"").unwrap();
assert_eq!(t, Transition::Done);
assert_eq!(serde_json::to_string(&Transition::Start).unwrap(), "\"start\"");

// Each move owns the field it stamps and the event it records; nothing else decides
// either, so a new move cannot be added without saying both.
for (t, field, event) in [
    (Transition::Start, "started_at", "plan_start"),
    (Transition::Verify, "verified_at", "plan_verify"),
    (Transition::Done, "completed_at", "plan_done"),
] {
    assert_eq!(t.field(), field);
    assert_eq!(t.event(), event);
}

Variants

Start

Execution began. Refused unless the issue is READY.

Verify

Implementation is complete and the evidence is still outstanding.

Done

Complete. Refused while anything it waits on is unfinished, or while any evidence its own record requires is absent.

Implementations

impl Transition

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

The record field this move stamps, and the only field it writes besides updated_at.

The status is never stored: an issue records what happened to it and the status follows. So a move owns a timestamp, not a state, and this names which one.

use majordomus_cli::plan::Transition;
assert_eq!(Transition::Start.field(), "started_at");
assert_eq!(Transition::Done.field(), "completed_at");

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

The event share/events.yaml declares for it.

The four plan events are spelled with an underscore rather than the dot the rest of the vocabulary uses. They are registered as written, because the ledger of this repository already holds dozens of them and a rename would orphan every one.

use majordomus_cli::plan::Transition;
assert_eq!(Transition::Verify.event(), "plan_verify");
assert!(Transition::Done.event().starts_with("plan_"));

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

The record field that carries this move’s seal, beside the stamp it proves.

use majordomus_cli::plan::Transition;
assert_eq!(Transition::Start.seal_field(), "started_event");
assert_eq!(Transition::Verify.seal_field(), "verified_event");
assert_eq!(Transition::Done.seal_field(), "completed_event");

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

The word a caller types for this move: majordomus plan <verb> <id>.

use majordomus_cli::plan::Transition;
assert_eq!(Transition::Start.verb(), "start");
assert_eq!(Transition::Verify.verb(), "verify");
assert_eq!(Transition::Done.verb(), "done");

Trait Implementations

impl Clone for Transition

fn clone(&self) -> Transition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Transition

impl Debug for Transition

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Transition

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Transition

impl JsonSchema for Transition

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 Transition

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

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 Transition