Struct Topology 

pub struct Topology {
    pub surfaces: Vec<Surface>,
}

Every surface this repository exposes, resolved together.

The order is by mount, most specific first, then by id: the order a router must consult them in, computed rather than left to whoever inserted a route last.

Fields

surfaces: Vec<Surface>

The resolved surfaces, in route-precedence order.

Implementations

impl Topology

pub fn new(surfaces: Vec<Surface>) -> Self

Sort surfaces into route-precedence order and hold them.

Precedence is depth first — a longer mount wins over a shorter one, so the root application is consulted last — and identity breaks ties, so the order never depends on discovery order, filesystem order or a hash map.

use majordomus_cli::web::model::*;
let t = Topology::new(vec![s("app", "/"), s("tests", "/tests")]);
assert_eq!(t.surfaces[0].id, "tests");   // the specific one is consulted first
assert_eq!(t.surfaces[1].id, "app");
// the root is last whatever it is compared with: `owner()` rests on this, and the
// root's own slash must never be counted as depth
let deep = Topology::new(vec![s("api", "/api/v1"), s("root", "/"), s("docs", "/docs")]);
assert_eq!(deep.ids(), vec!["api", "docs", "root"]);

pub fn owner(&self, path: &str) -> Option<&Surface>

The surface that owns a request path, or none when nothing does.

use majordomus_cli::web::model::*;
let t = Topology::new(vec![s("app", "/"), s("tests", "/tests")]);
assert_eq!(t.owner("/tests/index.html").unwrap().id, "tests");
assert_eq!(t.owner("/anything-else").unwrap().id, "app");

pub fn get(&self, id: &str) -> Option<&Surface>

One surface by id.

pub fn select(&self, only: &[String], exclude: &[String]) -> Topology

The topology narrowed to a selection: only when it is not empty, minus exclude.

Selection is by discovered id and nothing else, so a surface that did not exist when this code was written is selectable the day it is discovered.

pub fn ids(&self) -> Vec<&str>

The ids this topology holds, in precedence order.

pub fn served(&self, runtime: Runtime) -> Topology

The topology as a process with these runtime capabilities serves it.

One resolution, two worlds: a surface that is only published (the site as it is deployed) is not served, and a surface whose feature this process does not have is not there at all. Both narrowings are filters over the same value, so nothing can be served that was not discovered.

use majordomus_cli::web::discover::{self, Runtime};
let all = discover::native(Runtime::full());
let none = majordomus_cli::web::Topology::new(all).served(Runtime::default());
assert!(!none.ids().contains(&"mcp"));

pub fn published(&self) -> Topology

The topology as a publication holds it: every surface that contributes files.

pub fn public_in(&self, category: Category) -> Vec<&Surface>

The public surfaces of one category, in precedence order: what a person is shown.

Trait Implementations

impl Clone for Topology

fn clone(&self) -> Topology

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Topology

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Topology

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Topology

impl JsonSchema for Topology

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 PartialEq for Topology

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

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 Topology