Struct SubjectEntry 

pub struct SubjectEntry {
    pub kind: SubjectKind,
    pub id: String,
    pub status: Option<String>,
    pub page: Option<String>,
    pub alias_of: Option<String>,
    pub programs: Vec<Program>,
    pub members: Vec<String>,
    pub routes: Vec<Route>,
    pub mechanisms: Vec<String>,
    pub findings: Vec<SubjectFinding>,
}

One subject of the index: what it is, what it is made of and the tests it reaches.

use majordomus_cli::evidence::subject::{self, SubjectEntry, SubjectKind};
use majordomus_cli::synthetic::SyntheticRepository;

let repo = SyntheticRepository::small().unwrap();
let ctx = repo.context().unwrap();
let s = subject::index(&ctx.index, &ctx.product, &ctx.registry);
let entry: &SubjectEntry = s.get("capability:capabilities.list").unwrap();
assert_eq!(entry.kind, SubjectKind::Capability);
assert_eq!(entry.page.as_deref(), Some("/evidence/capabilities/capabilities-list/"));
assert!(entry.members.contains(&"command:capabilities list".to_string()));
assert!(entry.programs.is_empty(), "only a command names its programs");

Fields

kind: SubjectKind

What kind of declaration it is.

id: String

Its id within the kind.

status: Option<String>

The status its declaration states: a claim, a rule, a feature or a use case.

page: Option<String>

Its page on the site: /evidence/<section>/<slug>/.

alias_of: Option<String>

The capability an MCP tool is an alias of.

programs: Vec<Program>

The programs a command word belongs to, in declaration order; empty for every other kind.

members: Vec<String>

The subjects it is made of, by key, unique, in byte order.

routes: Vec<Route>

Its own routes, in (via, test, path) order.

mechanisms: Vec<String>

A rule’s named paths that no runner drives.

findings: Vec<SubjectFinding>

Its structural findings.

Trait Implementations

impl Clone for SubjectEntry

fn clone(&self) -> SubjectEntry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SubjectEntry

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SubjectEntry

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for SubjectEntry

impl PartialEq for SubjectEntry

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

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 SubjectEntry