Struct ReviewView 

pub struct ReviewView {
    pub key: String,
    pub session: String,
    pub subject: String,
    pub scope: Vec<String>,
    pub issue: Option<String>,
    pub reviewer: Option<String>,
    pub body: Option<String>,
    pub state: ReviewState,
    pub answers: Vec<ReviewAnswer>,
    pub result: Option<String>,
}

One review request anywhere in the mesh, with every answer it has drawn. A request with no reviewer is an offer to the whole mesh rather than to nobody, which is why the answers are a list: any linked runtime carrying the reviews feature may add one, and they are kept in Lamport order so that every runtime reads them in the same sequence.

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

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/mesh-cooperation".into(), scope: vec!["src/mesh".into()],
    issue: Some("#184".into()), reviewer: None, body: None }).unwrap();
let request = fold(&j.events(), &|_| StreamLiveness::Own).reviews[0].key.clone();
j.append_own(EventBody::ReviewAnswered { request, session: "s2".into(),
    verdict: "approved".into(), note: Some("reads well".into()) }).unwrap();

let state = fold(&j.events(), &|_| StreamLiveness::Own);
let review: &ReviewView = &state.reviews[0];
assert_eq!(review.subject, "feature/mesh-cooperation");
assert_eq!(review.reviewer, None, "offered to the mesh, not addressed");
assert_eq!(review.answers[0].verdict, "approved");

Fields

key: String

<stream>/<review>.

session: String

The requesting session’s key.

subject: String

What is to be reviewed.

scope: Vec<String>

Paths it covers.

issue: Option<String>

The issue.

reviewer: Option<String>

The runtime asked, when one was.

body: Option<String>

What the reviewer needs beyond the subject, when the requester wrote it.

state: ReviewState

Its standing.

answers: Vec<ReviewAnswer>

The answers, in Lamport order.

result: Option<String>

The requester’s own result or reason, written when it withdrew the request. Never an answer: a review is another session’s verdict.

Trait Implementations

impl Clone for ReviewView

fn clone(&self) -> ReviewView

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReviewView

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ReviewView

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ReviewView

impl JsonSchema for ReviewView

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 ReviewView

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

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 ReviewView