Struct Obligation 

pub struct Obligation {
    pub id: String,
    pub title: String,
    pub summary: String,
    pub discharged_by: String,
    pub inputs: Vec<String>,
    pub remote: bool,
    pub note: String,
}

One token a task may declare in requires, as the distribution ships it.

remote and inputs are what decide how its evidence is judged, and they are the file’s decision rather than this reader’s: a fact the working tree cannot establish is bound to the commit it was taken at, and everything else is bound to the bytes of the files its pathspecs select.

use majordomus_cli::capability::builtin::obligations::Obligation;
let push: Obligation = serde_json::from_str(
    r#"{"id":"push","title":"The commit reached the remote",
        "summary":"The branch's head exists on the remote it tracks.",
        "discharged_by":"git","remote":true}"#,
)
.unwrap();
assert!(push.remote);
assert!(push.inputs.is_empty(), "a remote fact is bound to a commit, not to a tree");

Fields

id: String

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

title: String

The obligation as a heading.

summary: String

What a worker is being asked to have done.

discharged_by: String

The command that produces the evidence. none for a token held by another line of the contract and listed so that a report can say it rather than leave a hole.

inputs: Vec<String>

The pathspecs the evidence is hashed over. Empty for a token whose fact is remote, and empty for one bound to neither: see ObligationClosure::staleness.

remote: bool

True when the fact cannot be established from the working tree alone — a push, a publication, a deployment. Such evidence is bound to a commit, not to a tree.

note: String

What the vocabulary says about the token beyond its summary.

Trait Implementations

impl Clone for Obligation

fn clone(&self) -> Obligation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Obligation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Obligation

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Obligation

impl JsonSchema for Obligation

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 Obligation

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

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 Obligation