Struct ObligationClosure 

pub struct ObligationClosure {

    pub id: String,
    pub title: String,
    pub summary: String,
    pub discharged_by: String,
    pub remote: bool,
    pub inputs: Vec<String>,
    pub state: ObligationState,
    pub staleness: Option<Divergence>,
    pub evidence: Option<Evidence>,
    pub inputs_hash_now: Option<String>,
    pub inputs_files: Option<usize>,
    pub detail: String,
    pub reproduce: String,
}

One obligation the task declared, joined with what the vocabulary says about it and with the evidence that does or does not discharge it.

The vocabulary’s fields are repeated here on purpose: a client asking what this task owes gets the token’s title, its summary and the command that would discharge it in the same answer, and needs no second call to render a report.

use majordomus_cli::capability::builtin::obligations::{ObligationClosure, ObligationState};
let owed: ObligationClosure = serde_json::from_str(
    r#"{"id":"pages","title":"The published site serves this commit","remote":true,
        "state":"owed","detail":"owed, and no evidence was recorded",
        "reproduce":"majordomus evidence --covers pages --command 'scripts/pages verify'"}"#,
)
.unwrap();
assert_eq!(owed.state, ObligationState::Owed);
assert!(owed.evidence.is_none() && owed.staleness.is_none(), "nothing to label");
assert!(owed.reproduce.starts_with("majordomus evidence"), "a finding carries its repair");

Fields

id: String

The token, as the task’s requires names it.

title: String

From the vocabulary; the token itself when it declares none.

summary: String

From the vocabulary.

discharged_by: String

From the vocabulary: the command that produces the evidence.

remote: bool

From the vocabulary: whether the fact is remote.

inputs: Vec<String>

From the vocabulary: the pathspecs the evidence is hashed over.

state: ObligationState

Where it stands.

staleness: Option<Divergence>

How far the evidence is from this checkout, in the repository’s one staleness vocabulary. None when there is no evidence to label.

A remote fact is labelled against the commit it was taken at, because the site that serves a commit goes on serving it while the tree moves underneath. A tree-bound fact is labelled by re-hashing: equal hashes are exact, and a difference takes the commit’s label, which is advanced when the working tree has merely moved on and diverged when the history it named is gone. A token that declares neither inputs nor a remote fact is bound to nothing and stays exact once recorded — that is the validator’s behaviour, and it is reproduced rather than tightened here.

evidence: Option<Evidence>

The line that discharged it, or None.

inputs_hash_now: Option<String>

What the token’s inputs hash to in this tree now — the other half of “stale against what”. None for a token that declares no inputs, and None when git could not be asked which files they select.

inputs_files: Option<usize>

How many tracked files that hash was taken over. Reported because the shell’s selection and this one are not always the same set — see the module header — and a count is the cheapest way for a reader to see it rather than be told it.

detail: String

One line: what this obligation’s standing actually is, in the words the validator uses when it refuses.

reproduce: String

The command that would discharge it. Every finding here carries the way to act on it, as project.finding-carries-reproduce asks.

Trait Implementations

impl Clone for ObligationClosure

fn clone(&self) -> ObligationClosure

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ObligationClosure

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ObligationClosure

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ObligationClosure

impl JsonSchema for ObligationClosure

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 ObligationClosure

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

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 ObligationClosure