Struct Declaration 

pub struct Declaration {
    pub schema: String,
    pub id: String,
    pub mount: String,
    pub title: Option<String>,
    pub index: Option<String>,
    pub producer: Option<String>,
    pub availability: Option<Availability>,
    pub category: Option<Category>,
    pub visibility: Option<Visibility>,
    pub built_from: Option<String>,
}

A producer’s declaration: the intent that no walk of its output can infer.

id and mount are the intent. Everything else has a documented default, because a field a producer must fill in to say what the convention already says is a field that will disagree with reality one day.

use majordomus_cli::web::discover::Declaration;
let d: Declaration = serde_json::from_str(r#"{
    "schema": "web-surface/v1", "id": "tests", "mount": "/tests"
}"#).unwrap();
assert_eq!(d.id, "tests");
assert_eq!(d.index.as_deref(), None);

Fields

schema: String

The contract this declaration follows.

id: String

The surface’s identity, which is also its selector.

mount: String

Where the producer intends its output to be mounted.

title: Option<String>

One line for a listing; the id when absent.

index: Option<String>

The file the mount itself answers with; index.html when absent.

producer: Option<String>

What produced the directory, for a reader who has to rebuild it.

availability: Option<Availability>

Whether the surface is published, served, or both; both when absent.

category: Option<Category>

What the surface is for; a generated directory is a report when it says nothing.

visibility: Option<Visibility>

Whether a person is shown it; public when absent, because a producer that went to the trouble of declaring a mount meant it to be found.

built_from: Option<String>

The revision the output was built from, when the producer knows it: what makes a stale artifact a finding instead of a surprise.

Trait Implementations

impl Clone for Declaration

fn clone(&self) -> Declaration

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Declaration

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Declaration

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Declaration

impl PartialEq for Declaration

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

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 Declaration