Struct HtmlAdapter 

pub struct HtmlAdapter { /* private fields */ }

A Quarb adapter over a parsed HTML document.

Implementations

impl HtmlAdapter

pub fn set_document_url(&mut self, url: &str)

Declare the document’s own URL — the base a relative href joins against when ::href--> reaches across documents.

pub fn parse(html: &str) -> Self

Parse html and build the adapter.

pub fn locator(&self, node: NodeId) -> String

A locator path to node, like /html/body/div[2]/p, for rendering. A [n] index is added only to disambiguate same-tag siblings.

Trait Implementations

impl AstAdapter for HtmlAdapter

fn traits(&self, node: NodeId) -> Vec<String>

Structural traits: <block> or <inline>, plus <heading> for h1–h6 and <link> for an anchor with an href.

fn property(&self, node: NodeId, name: &str) -> Option<Value>

Attributes, by name (::href). Element text is the bare projection (::) — no attribute name is shadowed.

fn default_value(&self, node: NodeId) -> Option<Value>

The default projection of an element is its text content.

fn metadata(&self, node: NodeId, key: &str) -> Option<Value>

::::tag, ::::classes (the class attribute, split), ::::attrs (the attribute names, sorted — the parser does not preserve source order), and ::::n-attrs — facts about the element, never its data: attribute values are properties (::href), text is the bare projection. attrs is what makes a renamed attribute discoverable: enumerate the names, probe the values by shape.

fn resolve( &self, node: NodeId, property: &str, hint: Option<&str>, ) -> Option<NodeId>

Follow an attribute that is a fragment reference (#section) to the element with that id. Used by an anchor’s ::href-->.

fn external_ref( &self, node: NodeId, property: &str, hint: Option<&str>, ) -> Option<String>

The external reference an href-like attribute holds: the absolute URL, relative values joined against the document’s own URL (when the mount declared one). A bare #fragment stays in-document (that is resolve’s job); a fragment on a cross-document URL rides along — it is the crossref within the target, landed by resolve_fragment once that document is mounted. Non-web schemes reference nothing followable. Feeds ::href--> across documents — the acquisition arrow.

fn resolve_fragment(&self, _node: NodeId, fragment: &str) -> Option<NodeId>

html’s fragment landing: the element whose id is fragment, anywhere in this document.

fn ref_property(&self, node: NodeId) -> Option<String>

The bare arrow’s property: an anchor-family element’s href, a frame’s src.

fn ref_label(&self, node: NodeId, property: &str) -> Option<String>

The relation an href edge carries: the rel attribute — <link rel="stylesheet">, <a rel="nofollow">. The spec’s -->stylesheet hint filters on it; absent, the edge label falls back to the property name.

fn root(&self) -> NodeId

The root node — the initial navigation context.

fn children(&self, node: NodeId) -> Vec<NodeId>

The tree children of node, in document order.

fn name(&self, node: NodeId) -> Option<String>

The name of node — the label of its incoming tree edge.

fn parent(&self, node: NodeId) -> Option<NodeId>

The parent of node, or None for the root.

fn children_named(&self, node: NodeId, name: &str) -> Vec<NodeId>

The children of node whose edge name is exactly name — the engine’s fast path for name-matcher child hops. The default filters children; an adapter whose containers cannot be enumerated (permission-scoped or unbounded remote trees) overrides this with a direct, name-addressed lookup. Must be observationally identical to the default wherever enumeration works. The adapter owns the name test: it may deliberately alias — resolve a name to a node whose edge name differs (git revision syntax landing on a hash-named commit) — and the engine will not re-filter. Container-scoped resolution like that stays child-axis only; per-node spelling aliases belong in answers_to, which this default consults.

fn answers_to(&self, node: NodeId, name: &str) -> bool

Whether node answers to name as a literal spelling (ruling #30). The default is canonical equality. An adapter may declare per-node aliases — a social feed spelling a handle @alice while the stripped alice is the hop name — and the engine consults this wherever a literal name is matched, on every axis, so one override keeps /@alice and //@alice in agreement. :::name stays canonical (locators and reflection print it; an alias is a way in, never a way out), and name patterns (~(...), *) test the canonical name only.

fn has_trait(&self, node: NodeId, name: &str) -> bool

Whether node bears name as a trait, as written in a <...> clause. The default is membership in traits; an adapter may declare aliases the way answers_to does for names — a model file’s alias <chunk> <block>; or alias <s/^tag://i>; — and the engine consults this wherever a written trait is matched. Reflection and serialization print the canonical traits only.

fn aliased_metadata(&self, _node: NodeId) -> &'static [&'static str]

Metadata keys this adapter also answers at :: (ruling #29), for the given node — per node, because a composite adapter (a multi-mount, a graft) answers for whichever document owns it. Only an adapter whose property surface is closed — fixed by the adapter, never grown by document content — may declare aliases: a git commit cannot sprout a short field, where a JSON object can sprout anything. Data always wins: the engine consults property first and falls through only when it answers None for that node, so an alias can never shadow a document. Core metadata (:::) is never aliased — name, id and index exist on every node, and aliasing them would change what ::name means wherever a document happens to lack that field.

fn links(&self, _node: NodeId) -> Vec<(String, NodeId)>

Outgoing crosslinks from node, as (label, target) pairs, for -> navigation (a filesystem adapter’s symlinks).

fn backlinks(&self, _node: NodeId) -> Vec<(String, NodeId)>

Incoming crosslinks to node, as (label, source) pairs, for <- navigation. May be expensive (an adapter that does not precompute edges must search for referrers).

fn link_property( &self, _source: NodeId, _label: &str, _target: NodeId, _name: &str, ) -> Option<Value>

A property of the crosslink source --label--> target — the $-::prop read. Adapters whose edges carry data (a property graph’s relationship properties) override this; None if the edge is bare or unknown. Where parallel edges share source, label, and target, the adapter answers for one of them, consistently.

fn document_by_ref(&self, _id: &str) -> Option<NodeId>

The document this arbor holds under an external-reference identifier (a URL, fragment-stripped), when it can answer without the host’s registration: the landing rung of --> after the mounted-document table misses. An adapter over a store of pages answers by URL lookup; the engine performs no IO either way.

fn reverse_resolve( &self, _node: NodeId, _property: Option<&str>, _hint: Option<&str>, ) -> Option<Vec<NodeId>>

Every node whose property (or, when None, own reference property) resolves to node, in document order — the reverse index behind <--. None keeps the engine’s walk of the whole arbor; Some is the adapter’s complete answer.

fn descendants_named( &self, _node: NodeId, _name: &str, ) -> Option<Vec<(NodeId, usize)>>

The descendants of node that answer to name, each with its depth (children are depth 1), in document order — the fast path behind //name for an adapter whose substrate indexes names. None keeps the engine’s walk; Some must be exactly what the walk would find.

fn prefetch_links(&self, _nodes: &[NodeId], _dir: LinkDir)

A batching hint: the engine is about to follow dir crosslinks from every node in nodes. An adapter backed by a store may fetch them in one statement; semantics are unchanged either way.

fn quantifier_bound(&self) -> usize

The quantifier bound N_max: the depth to which open-ended path quantifiers (+, *, {m,}) expand, and the ceiling of any explicit {m,n} (the effective upper bound is min(n, N_max)). An adapter whose natural structures run deep may raise it; the CLI overrides it per run (qua --quantifier-bound).

fn allow_shell(&self) -> bool

Whether the sh(...) pipeline stage may run external commands. False by default — query text stays inert data — and enabled per run by the CLI (qua --allow-shell) through the AllowShell wrapper.

fn invocation_instant(&self) -> Option<(i64, u32)>

The invocation instant now() denotes (spec: The Temporal Fragment, Determinism): one UTC timeline point bound by the runner BEFORE evaluation begins — evaluation itself never reads a clock. None by default (a library run is fully deterministic; now() reads as null); the CLI binds it at startup — pinnable with qua --now — through the WithNow wrapper.

fn provenance(&self, _node: NodeId) -> Provenance

The data provenance of node — the :::source / :::instant / :::dpid / :::provenance core-metadata keys. Empty by default: an adapter answers only the components its substrate genuinely records (never the invocation clock); wrapper adapters fill missing components from what they know — the mount its target, a graft its outer leaf, a model its derivation — and forward the rest inward, so resolution is nearest-ancestor per component.

fn has_node(&self, node: NodeId) -> bool

Whether node is an id this adapter minted — the guard behind the node-id anchor ((!N)), which may name an id from an earlier run (ids are minted deterministically: the same source, the same ids). The default probes the id through parent and name and treats a panic as absence, so an adapter that indexes by id needs no override; one that can answer cheaply should.

fn provenance_list(&self, node: NodeId) -> ProvenanceList

The data provenance of node as a list — every source the substrate records for the datum, and how many it elides. The default is the singular answer as a one-entry list; an adapter whose substrate records several (kaiv’s ?a;b;+N) overrides it, and a wrapper layers each entry.

fn unit_scale(&self, expr: &str) -> Option<(f64, String)>

The scale of a unit expression — (factor, canonical SI-base expansion) — for the unital reading’s criterion text (spec: The Quantital Fragment). The default answers from the engine’s frozen built-in table; a unit-aware adapter (kaiv) overrides it to include the mounted document’s own custom units, so [::range < '50kellicam'] resolves through the document’s .!units imports.