Enum ViolationCode 

pub enum ViolationCode {
    RustPublicMissingDocs,
    RustPublicThinDocs,
    RustPublicMissingExample,
    RustExampleNotExecutable,
    RustExamplePlaceholder,
    RustExampleDoesNotNameSubject,
    RustModuleMissingDocs,
    RustModuleMissingExample,
    RustModuleMissingBehaviouralTest,
    OperationCliUnclassified,
    OperationClassificationStale,
    OperationClassificationConflict,
    OperationMissingOpenapi,
    OperationProjectionMissing,
    OperationProjectionOrphan,
}

What is wrong, as a stable machine-readable code.

The codes are the contract between the validator and everything downstream: CI annotations, Cockpit filters, documentation anchors and an agent deciding what to fix. A code is never renamed once it has shipped; a rule that stops existing takes its code with it.

Variants

RustPublicMissingDocs

An exported item carries no documentation at all.

RustPublicThinDocs

An exported item’s documentation says nothing its signature had not already said.

RustPublicMissingExample

An exported item that carries behaviour has no executable example.

RustExampleNotExecutable

Every example an item has is ignored or is prose in a fenced box.

RustExamplePlaceholder

An example asserts nothing, or asserts something that is true of any program.

RustExampleDoesNotNameSubject

An example never names the item it is documenting.

RustModuleMissingDocs

An exported module carries no module-level documentation.

RustModuleMissingExample

An exported module has no module-level executable example.

RustModuleMissingBehaviouralTest

No test names an exported module, and it declares none of its own.

OperationCliUnclassified

A command of the command line is neither a canonical capability nor classified as belonging to the command line alone.

OperationClassificationStale

A command is classified as belonging to the command line alone, and the command line no longer has it.

OperationClassificationConflict

A command is classified as local and bound to a capability: two answers to one question.

OperationMissingOpenapi

A capability declares an HTTP route and the OpenAPI document does not describe it.

OperationProjectionMissing

A capability declares a projection that the projection itself does not carry.

OperationProjectionOrphan

A projection carries an entry the registry does not hold.

Implementations

impl ViolationCode

pub fn as_str(self) -> &'static str

The code as it is written everywhere: RUST_PUBLIC_MISSING_EXAMPLE.

use majordomus_cli::quality::ViolationCode;
assert_eq!(ViolationCode::RustPublicMissingExample.as_str(), "RUST_PUBLIC_MISSING_EXAMPLE");

pub fn rule(self) -> &'static str

The rule of the repository’s layer that requires this, by canonical id.

A finding that could not name a rule would be an opinion. Every code names one, and the suite proves the rule exists.

use majordomus_cli::quality::ViolationCode;
assert_eq!(
    ViolationCode::RustModuleMissingExample.rule(),
    "project.rust-public-api-quality@1"
);
assert_eq!(
    ViolationCode::OperationCliUnclassified.rule(),
    "project.operation-transport-parity@1"
);

pub fn why(self) -> &'static str

Why it matters, in one sentence: what goes wrong in the world if this stands.

use majordomus_cli::quality::ViolationCode;
assert!(ViolationCode::RustExamplePlaceholder.why().contains("nothing"));

pub fn remediation(self) -> &'static str

What to do about it, in the imperative. Read by a person and by an agent.

use majordomus_cli::quality::ViolationCode;
assert!(ViolationCode::OperationCliUnclassified.remediation().contains("CliExposure"));

pub fn severity(self) -> Severity

How bad it is. Every code this subsystem ships is an error: a warning-forever mode is how a rule becomes decoration.

pub fn all() -> Vec<ViolationCode>

Every code, for the projections that list them and the test that proves each one is distinct.

use majordomus_cli::quality::ViolationCode;
let all = ViolationCode::all();
let mut codes: Vec<&str> = all.iter().map(|c| c.as_str()).collect();
codes.sort();
codes.dedup();
assert_eq!(codes.len(), all.len(), "every code is distinct");

Trait Implementations

impl Clone for ViolationCode

fn clone(&self) -> ViolationCode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ViolationCode

impl Debug for ViolationCode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ViolationCode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ViolationCode

impl JsonSchema for ViolationCode

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 Ord for ViolationCode

fn cmp(&self, other: &ViolationCode) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for ViolationCode

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

fn partial_cmp(&self, other: &ViolationCode) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for ViolationCode

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 ViolationCode