Enum TaskReadiness 

pub enum TaskReadiness {
    Ready,
    Blocked,
    Waiting,
    InProgress,
    Review,
    CompletionBlocked,
    Complete,
    Cancelled,
    Undeclared,
}

Where a development task stands, as work.

use majordomus_cli::devtask::TaskReadiness;

// every state names the canonical status it refines, and refines only one
assert_eq!(TaskReadiness::Ready.canonical(), "READY");
assert_eq!(TaskReadiness::Waiting.canonical(), "BLOCKED");
assert_eq!(TaskReadiness::Blocked.canonical(), "BLOCKED");
assert_eq!(TaskReadiness::Review.canonical(), "VERIFY");
assert_eq!(TaskReadiness::CompletionBlocked.canonical(), "VERIFY");

// and one state is the absence of a record rather than a status of one
assert!(TaskReadiness::Undeclared.canonical().is_empty());

Variants

Ready

Nothing holds it back and nobody has started it. Canonical READY.

Blocked

At least one issue it depends on is not DONE. Canonical BLOCKED.

Waiting

Every issue dependency is satisfied; the milestone gate holds it. Canonical BLOCKED, and a distinct situation because it is resolved in another milestone.

InProgress

Execution began: the record carries started_at. Canonical ACTIVE.

Review

Implementation is declared finished and completion has not been recorded: the record carries verified_at. Canonical VERIFY.

CompletionBlocked

Completion was recorded and the evidence the record itself requires is not all there, so the plan refuses to call it DONE. Canonical VERIFY, and the case the evidence_missing finding is about.

Complete

Finished on its own terms: not cancelled, completion recorded, every required evidence token present. Canonical DONE.

Cancelled

Withdrawn. Canonical CANCELLED.

Undeclared

The canonical model does not declare this id. Not a status: the absence of a record.

Implementations

impl TaskReadiness

pub const ALL: &'static [TaskReadiness]

Every state, in the order a board reads them: the executable ones first, the finished ones last. Declared once so that no surface writes the sequence down.

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

The canonical status this refines, or the empty string for TaskReadiness::Undeclared, which refines none.

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

The word a projection prints.

pub fn is_startable(self) -> bool

May a worker pick this up right now?

use majordomus_cli::devtask::TaskReadiness;
assert!(TaskReadiness::Ready.is_startable());
assert!(!TaskReadiness::InProgress.is_startable(), "somebody already has it");

pub fn is_terminal(self) -> bool

Is there nothing further to do, whatever happens elsewhere?

pub fn derive( status: &str, blockers: &[String], completion_recorded: bool, evidence_covered: bool, ) -> TaskReadiness

Derive the readiness from the facts the plan already holds.

The arguments are exactly what crate::plan derives and what the canonical record declares; nothing is read here, and nothing is guessed. status is the canonical status, blockers the plan’s own blocked_by list — whose milestone: prefix is what separates TaskReadiness::Waiting from TaskReadiness::Blocked — and completion_recorded / evidence_covered are what separate TaskReadiness::CompletionBlocked from TaskReadiness::Review.

use majordomus_cli::devtask::TaskReadiness;

// blocked only by its milestone is waiting, not blocked
let waiting = TaskReadiness::derive("BLOCKED", &["milestone:m1".to_string()], false, true);
assert_eq!(waiting, TaskReadiness::Waiting);

// blocked by a peer, milestone gate or not, is blocked
let blocked = TaskReadiness::derive(
    "BLOCKED",
    &["I0002".to_string(), "milestone:m1".to_string()],
    false,
    true,
);
assert_eq!(blocked, TaskReadiness::Blocked);

// completion recorded without the evidence it requires
let stuck = TaskReadiness::derive("VERIFY", &[], true, false);
assert_eq!(stuck, TaskReadiness::CompletionBlocked);

// verified and waiting to be closed
assert_eq!(TaskReadiness::derive("VERIFY", &[], false, false), TaskReadiness::Review);

// a status the plan never derives is not silently mapped onto one that looks fine
assert_eq!(TaskReadiness::derive("NONESUCH", &[], false, false), TaskReadiness::Undeclared);

Trait Implementations

impl Clone for TaskReadiness

fn clone(&self) -> TaskReadiness

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for TaskReadiness

impl Debug for TaskReadiness

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TaskReadiness

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for TaskReadiness

impl Hash for TaskReadiness

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 TaskReadiness

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 TaskReadiness

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

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

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

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 TaskReadiness