Enum Availability 

pub enum Availability {
    Always,
    Runtime,
    BuildTime,
    Authenticated,
}

Where a capability means anything: the environment a caller must be in for it to answer at all.

The published site and the running server are genuinely different places. Without this on the model, every template grows its own idea of what works where — and the usual shape that takes is a condition on the page’s own address, which is a rule hidden where nobody will find it and nothing can test it. This is the only thing a projection may ask.

It is classified rather than declared: the facts that decide it — what kind of thing this is and which transports it is projected through — are already on the descriptor, and asking each declaration to restate them would be the same knowledge written twice. Availability::classify is the one place the rule lives.

Variants

Always

True in every environment, a published page with no server included: the layer’s own content, which a build renders and a process serves from the same index.

Runtime

A process must be running to answer: everything with a handler, whether it is reached over HTTP, over MCP or from the command line.

BuildTime

A value captured when the site was generated, rendered afterwards as the capture it is. Nothing classifies to this yet; the static projection of the graph is what will declare it, and it is on the model so that a captured value can be labelled as captured instead of being shown as current.

Authenticated

A process must be running and the caller must be one it has authenticated. Nothing in this repository authenticates a caller yet; a surface that does will say so here rather than in the template that renders its link.

Implementations

impl Availability

pub fn classify(kind: CapabilityKind, _exposure: &Exposure) -> Availability

Classify from what the descriptor already declares.

The match is exhaustive on purpose and has no fallback arm: a new kind, or a transport that changes what an environment can offer, is a compile error here rather than a silent Always in a page that then links to nothing.

use majordomus_cli::capability::{Availability, CapabilityKind, Exposure};
let nowhere = Exposure::default();
assert_eq!(Availability::classify(CapabilityKind::Resource, &nowhere), Availability::Always);
assert_eq!(Availability::classify(CapabilityKind::Query, &nowhere), Availability::Runtime);

Trait Implementations

impl Clone for Availability

fn clone(&self) -> Availability

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Availability

impl Debug for Availability

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Availability

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Availability

impl JsonSchema for Availability

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 Availability

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

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

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

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 Availability