Struct IntentCoverage 

pub struct IntentCoverage {
    pub criteria: Vec<CriterionCoverage>,
    pub issues: Vec<IssuePurpose>,
    pub findings: Vec<IntentFinding>,
}

The whole derived coverage: every criterion of every live intent, every issue with the reason it exists, and every finding the two produced. Nothing here is stored; it is derived on each read from the intents and the plan.

use majordomus_cli::intent_plan::{IntentCoverage, IssueOrigin, IssuePurpose};
let coverage = IntentCoverage {
    criteria: vec![],
    issues: vec![IssuePurpose {
        issue: "I0007".into(),
        milestone: "ops".into(),
        origin: IssueOrigin::Maintenance,
        serves: vec![],
        intents: vec![],
    }],
    findings: vec![],
};
assert_eq!(coverage.failures(), 0);
assert_eq!(coverage.purpose("I0007").unwrap().origin, IssueOrigin::Maintenance);

Fields

criteria: Vec<CriterionCoverage>

Every criterion of every live intent, in intent then declaration order.

issues: Vec<IssuePurpose>

Every issue of the plan, in id order, with the reason it exists.

findings: Vec<IntentFinding>

Every finding, in derivation order.

Implementations

impl IntentCoverage

pub fn failures(&self) -> usize

How many of the findings are failures rather than warnings: the count that decides whether majordomus intent validate exits 10.

use majordomus_cli::intent_plan::IntentCoverage;
let clean = IntentCoverage { criteria: vec![], issues: vec![], findings: vec![] };
assert_eq!(clean.failures(), 0);

pub fn purpose(&self, issue: &str) -> Option<&IssuePurpose>

The purpose of one issue by id, or None when the plan holds no such issue — the answer to “why does this issue exist?”.

use majordomus_cli::intent_plan::IntentCoverage;
let coverage = IntentCoverage { criteria: vec![], issues: vec![], findings: vec![] };
assert!(coverage.purpose("I0001").is_none());

pub fn criterion( &self, intent: &str, criterion: &str, ) -> Option<&CriterionCoverage>

The coverage of one <intent>#<criterion>, or None when no live intent declares it — the answer to “which work carries this criterion?”.

use majordomus_cli::intent_plan::IntentCoverage;
let coverage = IntentCoverage { criteria: vec![], issues: vec![], findings: vec![] };
assert!(coverage.criterion("intent-planning", "gap-is-recorded").is_none());

Trait Implementations

impl Clone for IntentCoverage

fn clone(&self) -> IntentCoverage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IntentCoverage

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IntentCoverage

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for IntentCoverage

impl JsonSchema for IntentCoverage

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 IntentCoverage

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

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 IntentCoverage