Struct RuleDefinition 

pub struct RuleDefinition {

    pub id: String,
    pub identity: String,
    pub uri: String,
    pub version: u64,
    pub title: String,
    pub description: Option<String>,
    pub statement: Option<String>,
    pub status: String,
    pub class: Class,
    pub namespace: String,
    pub depends_on: Vec<String>,
    pub tags: Vec<String>,
    pub path: String,
    pub enforcement: Enforcement,
}

One rule, as the repository canonically declares it.

Example

Built by definitions from the index rather than by hand. Its ordering is the one the crate has, so a report over the same tree reads the same twice.

use majordomus_cli::rules::{Class, RuleDefinition};
let d = RuleDefinition {
    id: "project.scope-is-declared".into(),
    identity: "project.scope-is-declared@1".into(),
    uri: "majordomus://rule/project.scope-is-declared@1".into(),
    version: 1,
    title: "Scope is declared".into(),
    description: None,
    statement: None,
    status: "active".into(),
    class: Class::Blocking,
    namespace: "project".into(),
    depends_on: vec![],
    tags: vec![],
    path: ".ai/repo/rules/project/scope-is-declared.v1.md".into(),
    enforcement: Enforcement {
        mode: Mode::Declarative, validator: None, category: None, exit_code: None,
        enforced_by: None, tests: vec![], reviewed_because: None,
    },
};
assert_eq!(d.class, Class::Blocking);

Fields

id: String

The rule id, <namespace>.<stem>, without the version.

identity: String

The identity the index holds, with the version.

uri: String

majordomus://rule/<identity>.

version: u64

The declared version.

title: String

The title.

description: Option<String>

The one-line description.

statement: Option<String>

The normative sentence.

status: String

active, or whatever else the front matter declares.

class: Class

How strongly it binds.

namespace: String

Whether it came with the vendored package or belongs to this project.

depends_on: Vec<String>

The rules it depends on, by id.

tags: Vec<String>

The declared tags.

path: String

Repository-relative path of the rule object.

enforcement: Enforcement

How it is enforced, as declared.

Trait Implementations

impl Clone for RuleDefinition

fn clone(&self) -> RuleDefinition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RuleDefinition

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RuleDefinition

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for RuleDefinition

impl JsonSchema for RuleDefinition

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 Ordered for RuleDefinition

A rule is ordered by its namespace, then by what a reader reads, then by its id — so that the vendored package and the project’s own rules stay in their blocks and the sequence is total whatever order discovery handed them.

fn order_key(&self) -> OrderKey<'_>

The four parts this item is ordered by. Borrowed from the item: building a key allocates nothing, so sorting a large collection costs the comparisons and no more.

impl PartialEq for RuleDefinition

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

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 RuleDefinition