Struct Coverage 

pub struct Coverage {
    pub rules: usize,
    pub blocking: usize,
    pub advisory: usize,
    pub named_proof: usize,
    pub artifacts_present: usize,
    pub runnable: usize,
    pub recorded: usize,
    pub passing: usize,
    pub gated: usize,
    pub mechanism_only: usize,
    pub review_only: usize,
    pub satisfied: usize,
}

How much of the rule corpus carries each part of a proof.

Every number here is counted from the tree. Nothing in this struct may be written down anywhere else: a hardcoded rule count is the defect this repository keeps rediscovering.

Example

Every number is counted from the tree; an empty corpus counts zero rather than reading as complete, which is what Coverage::default is for.

use majordomus_cli::rules::Coverage;
let c = Coverage::default();
assert_eq!(c.rules, 0);
assert_eq!(c.review_only, 0);

Fields

rules: usize

Rules discovered.

blocking: usize

Of those, blocking.

advisory: usize

Of those, advisory.

named_proof: usize

Rules naming a validator or at least one test.

artifacts_present: usize

Rules every one of whose named paths is in the tree.

runnable: usize

Rules at least one of whose tests a runner owns.

recorded: usize

Rules every one of whose tests has a recorded run.

passing: usize

Rules whose recorded runs all passed.

gated: usize

Rules some CI gate runs.

mechanism_only: usize

Rules whose only executable proof is a gate: a mechanism that refuses violations, with no recorded verdict behind it. Counted apart from passing so that the two are never read as one number.

review_only: usize

Rules that declare, with a reason, that a reader enforces them. Counted apart from every executable mode: this number going up is governance getting weaker, and a summary that folded it into a total would hide exactly that.

satisfied: usize

Rules whose state their class can live with.

Trait Implementations

impl Clone for Coverage

fn clone(&self) -> Coverage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Coverage

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

Formats the value using the given formatter.

impl Default for Coverage

fn default() -> Coverage

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Coverage

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Coverage

impl JsonSchema for Coverage

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 Coverage

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

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 Coverage