Struct Facets 

pub struct Facets { /* private fields */ }

The classifier: one workspace’s answer to “what is this key?”.

Cheap to build and cheap to hold — it is the config’s vocabulary, resolved once, and every lookup is a map hit. Build it from the workspace config when there is one and take Facets::default when there is not: a lone document opened outside any workspace is still read with prov’s built-in vocabulary, which is what makes contents mean contents in a file nobody has configured.

Implementations

impl Facets

pub fn from_config(config: &WorkspaceConfig) -> Self

Classify against a resolved workspace config.

pub fn relations(&self) -> &RelationSet

The relation vocabulary these facets read by — what crate::links walks, and what a frontend hands prov when it resolves a target.

pub fn of_key(&self, key: &str) -> Facet

Classify a top-level key.

Relations first, so a workspace that declares fields.contents — legal, and a thing a confused config can say — still gets a link field for the key prov will follow. The fields half only reaches keys the relation vocabulary left alone.

pub fn of(&self, path: &[Seg]) -> Facet

Classify a metadata path.

The first segment decides, so contents[2] is the relation contents and prov.relations.see_also.inverse is policy. That is not a shortcut: a path’s facet is a fact about which of prov’s axes it belongs to, and every segment below the first is a part of the same one. It also matches how flower scopes its own managed sets, which are root keys matched exactly — so a list built here goes into set_demoted meaning what it meant on the way out.

An empty path — the document itself — is Facet::Carried: the document is not one of prov’s keys.

pub fn classify(&self, meta: &Value) -> Vec<(String, Facet)>

Every top-level key of meta, in document order, with its facet.

Document order, not sorted: the order keys are written in is the document’s own and a lossless editor’s whole point. A caller that wants them grouped groups them.

Examples found in repository

examples/inspect.rs (line 23)

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 structural_keys(&self, meta: &Value) -> Vec<String>

The keys present in meta that are prov’s structure (Facet::structural) — shaped for Model::set_demoted.

Present in the document, not every key prov knows: demoting a key the document does not have is harmless but tells a reader nothing, and the list is short enough to be worth being exact about.

pub fn managed_keys(&self, meta: &Value) -> Vec<String>

The keys present in meta that the workspace maintains (Facet::managed) — shaped for the derived argument of Model::with_managed.

pub fn managed_key_names(&self) -> Vec<String>

Every key this workspace maintains, whether or not a given document carries it — the same list as managed_keys, asked without a document.

The form a constructor needs: flower takes its derived set before the first row list exists, which is before there is a parsed document to ask. Naming a key the document does not have is inert (there is no row to mark read-only), and naming one it gains later is the point — a document that acquires an id should not become editable in the same breath.

Examples found in repository

examples/inspect.rs (line 20)

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 carried_keys(&self, meta: &Value) -> Vec<String>

The keys present in meta that prov carries and never reads — the complement a frontend showing “just this document’s own values” wants.

Trait Implementations

impl Clone for Facets

fn clone(&self) -> Facets

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Facets

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

Formats the value using the given formatter.

impl Default for Facets

fn default() -> Self

prov’s built-in vocabulary and nothing else — the right answer for a document read outside a workspace, which is still a prov document.