Enum ReviewState 

pub enum ReviewState {
    Open,
    Answered,
    Withdrawn,
    Expired,
}

A review request’s standing: whether anybody has answered it yet. There is deliberately no Approved or Rejected here — a request may be answered by several runtimes and the verdicts are the answers’ own, so collapsing them into one state would throw away the disagreement that makes a second reviewer worth asking.

use std::sync::Arc;
use majordomus_cli::mesh::identity::NodeIdentity;
use majordomus_cli::mesh::journal::{EventBody, Journal, StreamLiveness};
use majordomus_cli::mesh::state::{fold, ReviewState};

let j = Journal::open(Arc::new(NodeIdentity::ephemeral().unwrap()), "0000000000000001",
    "repo".into(), None).unwrap();
j.append_own(EventBody::ReviewRequested { review: "r1".into(), session: "s1".into(),
    subject: "feature/x".into(), scope: vec![], issue: None, reviewer: None, body: None }).unwrap();
let asked = fold(&j.events(), &|_| StreamLiveness::Own);
assert_eq!(asked.reviews[0].state, ReviewState::Open);

let request = asked.reviews[0].key.clone();
j.append_own(EventBody::ReviewAnswered { request, session: "s2".into(),
    verdict: "approved".into(), note: None }).unwrap();
assert_eq!(fold(&j.events(), &|_| StreamLiveness::Own).reviews[0].state, ReviewState::Answered);

Variants

Open

Nobody has answered.

Answered

At least one answer.

Withdrawn

The runtime that asked ended the request: done, void or superseded. Whatever was answered before stays with it.

Expired

Nobody answered and the runtime that asked stopped beating. A reading of liveness, like a claim’s expiry, decided from the journal and the streams’ beats so that no runtime needs another’s clock — a runtime that beats again reads open again.

Implementations

impl ReviewState

pub fn is_waiting(self) -> bool

Whether the request still waits for a verdict: open, and nothing else.

use majordomus_cli::mesh::state::ReviewState;
assert!(ReviewState::Open.is_waiting());
assert!(!ReviewState::Answered.is_waiting() && !ReviewState::Withdrawn.is_waiting());
assert!(!ReviewState::Expired.is_waiting());

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

The state’s word, as every surface prints it.

use majordomus_cli::mesh::state::ReviewState;
assert_eq!(ReviewState::Withdrawn.as_str(), "withdrawn");
assert_eq!(serde_json::to_value(ReviewState::Expired).unwrap(), ReviewState::Expired.as_str());

Trait Implementations

impl Clone for ReviewState

fn clone(&self) -> ReviewState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ReviewState

impl Debug for ReviewState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ReviewState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ReviewState

impl JsonSchema for ReviewState

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 ReviewState

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

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 ReviewState