Struct Edge 

pub struct Edge {
    pub direction: Direction,
    pub edge: String,
    pub field: String,
    pub uri: Option<String>,
    pub kind: String,
    pub label: String,
    pub title: Option<String>,
    pub route: Option<String>,
    pub external: bool,
}

One edge, as an entity page reads it.

Everything a reader needs about the other end is here — what to show, what kind of thing it is, and the address to send them to — so the page renders a relation without going back to the index for it. route is None exactly when external is true: a file, a test or a command is named by the layer and is not an object of it, so there is no entity page to link to and the template shows plain text instead of a dead link.

use majordomus_cli::entity::{Direction, Edge};
use majordomus_cli::order::Ordered;

let edge = Edge {
    direction: Direction::Incoming,
    edge: "depends_on".into(),
    field: "depends_on".into(),
    uri: Some("majordomus://rule/project.x@1".into()),
    kind: "rule".into(),
    label: "project.x@1".into(),
    title: Some("A rule".into()),
    route: Some("/cockpit/objects/rule/project-x-1".into()),
    external: false,
};

// the relation is the group and the direction ranks inside it; see the `Ordered` impl
let key = edge.order_key();
assert_eq!(key.group, Some("depends_on"));
assert_eq!(key.rank, Direction::Incoming as i64);
assert_eq!(key.identity, "majordomus://rule/project.x@1");

Fields

direction: Direction

Which way it runs from the entity that was asked for.

edge: String

The relationship, in the graph’s vocabulary (depends_on, put_in_force, …).

field: String

The front matter key the reference was declared under.

uri: Option<String>

The object at the other end: its URI when the layer holds it.

kind: String

Its kind — of the layer, or the external vocabulary (file, test, command).

label: String

What to show: the identity of an object, or the name of something outside.

title: Option<String>

Its title, when it is an object that has one.

route: Option<String>

Its entity route, when it has one; absent for something outside the layer.

external: bool

True when the other end is not an object of this index.

Trait Implementations

impl Clone for Edge

fn clone(&self) -> Edge

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Edge

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Edge

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Edge

impl JsonSchema for Edge

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 Edge

An edge is ordered by the relation it is, then by which way it runs, then by what a reader sees.

The relation is the group, because that is the bucket the reader is actually scanning — every depends_on together, every put_in_force together — and the direction is a rank inside it rather than the most significant part, because every consumer of this collection filters to one direction before it renders (the entity page draws the declared references and the backlinks as two sections). The URI is the tie-breaker, and an external end that has none falls back to its label; edges dedups, so two edges that compare equal here were the same edge twice.

This is the whole order of the collection. There was a sort_by here beside the building of it, which is the second opinion crate::order exists to remove — the natural comparison it brings is also the one every other surface of this repository shows, so case-2 precedes case-10 on an entity page as it does everywhere else.

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 Edge

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

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 Edge