Struct MetaLink 

pub struct MetaLink {
    pub path: Vec<Seg>,
    pub relation: RelationFacet,
    pub link: Link,
    pub kind: TargetKind,
}

One link declared by a document’s metadata.

Fields

path: Vec<Seg>

Where the link sits in the metadata: [Key("part_of")] for a scalar relation, [Key("contents"), Index(2)] for the third item of a list. The path a frontend compares against its cursor.

relation: RelationFacet

The relation that declared it, and everything the vocabulary says about that relation — including whether it is the spanning backbone and whether it is a one-way pointer at machinery.

link: Link

The parsed link: its label, its target, and which wrapper it was written in. Link::render puts it back the way it came.

kind: TargetKind

What shape of thing the target names, by syntax.

Implementations

impl MetaLink

pub fn target(&self) -> &str

The target as written, locator and all.

pub fn locator(&self) -> Option<&str>

The #locator suffix, when the target has one — a place inside the document the rest of the target names. Carried by prov, never resolved.

pub fn display(&self) -> &str

What to put on a row: the link’s label when it was written with one, and the target otherwise. A labeled link is labeled because the target is not what a reader wants to read.

Examples found in repository

examples/inspect.rs (line 49)

fn main() {
    let path = std::path::PathBuf::from(std::env::args().nth(1).expect("a document"));
    let view = WorkspaceView::discover(&path).expect("discovery");
    match &view {
        Some(v) => println!("workspace: {}", v.root_dir().display()),
        None => println!("workspace: none"),
    }
    let facets = view
        .as_ref()
        .map(|v| v.facets().clone())
        .unwrap_or_default();
    let schema = view.as_ref().map(|v| v.schema_for(&path));
    let session =
        DocumentSession::open_managed(&path, schema, facets.managed_key_names()).expect("open");

    println!("\nkeys:");
    for (key, facet) in facets.classify(session.meta()) {
        let flags = [
            facet.structural().then_some("structural"),
            facet.managed().then_some("managed"),
        ]
        .into_iter()
        .flatten()
        .collect::<Vec<_>>()
        .join(",");
        println!("  {key:<14} {:<9} {flags}", facet.kind());
    }

    println!("\nlinks:");
    for link in links_in(session.meta(), &facets) {
        let landing = match &view {
            Some(v) => v.resolve(&path, &link),
            None => resolve_without_workspace(&path, &link),
        };
        let mark = if matches!(landing, Destination::Document { exists: true, .. }) {
            "→"
        } else {
            "·"
        };
        println!(
            "  {mark} {:<10} {:<22} {}",
            link.relation.name,
            link.display(),
            landing.describe()
        );
    }
}

pub fn leaves_the_workspace(&self) -> bool

Whether following this link would leave the workspace — a URL, or a reference into a workspace prov cannot locate from here.

Trait Implementations

impl Clone for MetaLink

fn clone(&self) -> MetaLink

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MetaLink

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

Formats the value using the given formatter.