Struct ClaimProof 

pub struct ClaimProof {

    pub id: String,
    pub claim: String,
    pub status: String,
    pub source: Option<String>,
    pub implementation: Option<String>,
    pub test_path: Option<String>,
    pub test: Option<String>,
    pub state: ProofState,
    pub meaning: String,
    pub execution: Option<Execution>,
    pub changed: Vec<String>,
    pub detail: Option<String>,
    pub reproduce: Option<String>,
}

One claim, joined to whatever the repository actually recorded about it.

The claim’s own fields are carried verbatim beside the derived ones, so that a reader who disbelieves the state can check the join rather than take it.

use majordomus_cli::evidence::{ClaimProof, ProofState};

let proof = ClaimProof {
    id: "scope-integrity".into(),
    claim: "a commit outside the task's scope is refused".into(),
    status: "guaranteed".into(),
    source: Some("docs/SCOPE.md".into()),
    implementation: Some("apps/majordomus-cli/src/scope.rs".into()),
    test_path: Some("test/cases/07_scope.sh".into()),
    test: Some("suite:07_scope".into()),
    state: ProofState::NotRun,
    meaning: ProofState::NotRun.meaning().to_string(),
    execution: None,
    changed: vec![],
    detail: None,
    reproduce: Some("bash test/run.sh 07_scope".into()),
};

let json = serde_json::to_value(&proof).unwrap();
// `changed` is emitted empty rather than omitted: a client must not have to tell
// "no file changed" from "the server did not say"
assert_eq!(json["changed"], serde_json::json!([]));
// an execution that does not exist is absent, not a null standing in for one
assert!(json.get("execution").is_none());
// and so is a detail the state did not need
assert!(json.get("detail").is_none());
assert_eq!(json["meaning"], serde_json::json!(ProofState::NotRun.meaning()));

Example

A ClaimProof is produced by report; its state is the whole answer and its meaning is that answer in a sentence, worded once for every surface.

use majordomus_cli::evidence::{report, ClaimProof, Ledger};
use majordomus_cli::synthetic::SyntheticRepository;
let repo = SyntheticRepository::small().unwrap();
let ledger = Ledger::load(repo.root()).unwrap();
let r = report(&repo.index().unwrap(), &ledger);
let proofs: &[ClaimProof] = &r.claims;
assert!(proofs.is_empty(), "a synthetic tree declares no claims");

Fields

id: String

The claim’s id, as docs/CLAIMS.yaml spells it.

claim: String

The claim sentence.

status: String

The status the claim declares: guaranteed, advisory, planned, rejected.

source: Option<String>

The document that defines the behaviour.

implementation: Option<String>

The file that implements it.

test_path: Option<String>

The path the claim names as its test, verbatim.

test: Option<String>

The test’s stable identity, when a runner owns it.

state: ProofState

What the repository can say about the proof.

meaning: String

That state, in one sentence.

execution: Option<Execution>

The execution the state was derived from, when there is one.

changed: Vec<String>

The files this claim names that differ between the recorded commit and the working tree. Empty unless the state is ProofState::Stale.

Always emitted, empty included: the schema this capability publishes says the key is there, and a client that has to tell “no files changed” from “the server did not say” is a client reading two different answers as one.

detail: Option<String>

Why the state is what it is, in one sentence, when the state alone does not say: a test that declined to run, a run on a commit the presented revision does not contain, a tree that was not its commit, a failing run the checkout holds uncommitted.

reproduce: Option<String>

The command that produces the proof again, when a runner owns the test.

Trait Implementations

impl Clone for ClaimProof

fn clone(&self) -> ClaimProof

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ClaimProof

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ClaimProof

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ClaimProof

impl JsonSchema for ClaimProof

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 ClaimProof

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

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 ClaimProof