Struct RulesTally 

pub struct RulesTally {
    pub head: Option<String>,
    pub working_tree: String,
    pub rules: usize,
    pub blocking: usize,
    pub project: usize,
    pub gated: usize,
    pub states: BTreeMap<String, usize>,
    pub proven: usize,
    pub failing: usize,
    pub reviewed: usize,
    pub unproven: usize,
    pub findings: usize,
}

The rule corpus, counted by crate::rules::report against a commit.

use majordomus_cli::environment::preflight::RulesTally;
use majordomus_cli::evidence::Ledger;
use majordomus_cli::synthetic::SyntheticRepository;
let repo = SyntheticRepository::small().unwrap();
let report = majordomus_cli::rules::report(&repo.index().unwrap(), &Ledger::empty());
let tally = RulesTally::of(&report);
assert_eq!(tally.rules, report.coverage.rules);
assert_eq!(tally.proven, 0, "an empty ledger proves nothing");

Fields

head: Option<String>

The commit it was counted at.

working_tree: String

clean, dirty or unknown when it was counted.

rules: usize

Rules discovered.

blocking: usize

Of those, blocking.

project: usize

Of those, the repository’s own (project.); the rest are vendored.

gated: usize

Rules a CI gate runs.

states: BTreeMap<String, usize>

Rules in each state, by the state’s printed word.

proven: usize

Rules proven against the tree they were counted at.

failing: usize

Rules whose latest recorded run failed.

reviewed: usize

Rules that declare a reader enforces them.

unproven: usize

Rules naming neither a validator nor a test.

findings: usize

Rules whose class their proof does not support.

Implementations

impl RulesTally

pub fn of(report: &RulesReport) -> Self

The tally of one report: the counts entry needs, stamped with the commit and tree the report was derived against, so a later reader can tell when it went stale.

use majordomus_cli::environment::preflight::RulesTally;
use majordomus_cli::rules::{RulesReport, RulesVerdict};
let empty = RulesReport { head: None, working_tree: "clean".into(),
    verdict: RulesVerdict::Unproven, rules: vec![], states: Default::default(),
    coverage: Default::default(), findings: vec![], satisfied: true };
assert_eq!(RulesTally::of(&empty).rules, 0);

Trait Implementations

impl Clone for RulesTally

fn clone(&self) -> RulesTally

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RulesTally

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

Formats the value using the given formatter.

impl Default for RulesTally

fn default() -> RulesTally

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RulesTally

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for RulesTally

impl JsonSchema for RulesTally

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 RulesTally

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

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 RulesTally