Enum Facet 

pub enum Facet {
    Relation(RelationFacet),
    Policy,
    Identity,
    Title,
    Payload(Payload),
    Stamp,
    Field(FieldFacet),
    Carried,
}

What a frontmatter key is to prov.

Exhaustive over a document’s top-level keys: every key falls in exactly one of these, and Facet::Carried is the one that means “prov does not read this”. A nested key takes its top-level ancestor’s facet — see Facets::of.

Variants

Relation(RelationFacet)

A link field: the targets are edges in the workspace graph.

Policy

The root’s prov: block — workspace policy, inline.

Identity

id — the document’s stable identity. Minted and maintained by the workspace, not typed.

Title

title — read back by prov for nominal references and for the generated about page, but written by a person.

Payload(Payload)

One of the four keys on the opaque-payload axis.

Stamp

The field the workspace’s updated: config names — machine-stamped in RFC 3339 UTC because prov reads it back to know when to rewrite it. The name is the workspace’s; a human-friendly date is a different, user-owned field prov never touches.

Field(FieldFacet)

Declared in fields.<name>: prov resolves its values against a vocabulary, or at least knows their type.

Carried

Carried by prov and never read by it. The default, and the majority of an ordinary document.

Implementations

impl Facet

pub fn read_by_prov(&self) -> bool

Whether prov reads this key at all. false only for Carried.

pub fn structural(&self) -> bool

Whether this is prov’s own structure rather than something the document says about itself — the line a frontend that separates the two draws.

contents, part_of, config, prov:, id, content_hash are structure. title is not, and neither is a declared field: prov reads both, but a person wrote them, and putting audience: public behind the same fold as id hides the thing the reader came for.

A question, not a policy. Nothing in this crate acts on it.

Examples found in repository

examples/inspect.rs (line 25)

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 managed(&self) -> bool

Whether the workspace maintains this value, so an editor should draw the row and decline the edit rather than offer a text box.

id is minted, content_hash is computed, the updated stamp is written on save. Typing into any of the three does not change what it will say after the next prov operation; it only makes the document briefly wrong. This is exactly flower’s derived set — see managed_keys.

Examples found in repository

examples/inspect.rs (line 26)

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 relation(&self) -> Option<&RelationFacet>

The relation this key declares, when it is one — the test a frontend applies before offering to follow a row.

pub fn kind(&self) -> &'static str

A short, frontend-neutral name for the kind — for a badge, a filter, or a status line that wants to say what a row is without a match arm.

Examples found in repository

examples/inspect.rs (line 32)

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()
        );
    }
}

Trait Implementations

impl Clone for Facet

fn clone(&self) -> Facet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Facet

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

Formats the value using the given formatter.