Struct GitlabAdapter 

pub struct GitlabAdapter { /* private fields */ }

GitLab, exposed as an arbor.

Implementations

impl GitlabAdapter

pub fn connect(target: &str) -> Result<Self, GitlabError>

Connect to gitlab: or gitlab:PATH (a group, project, or user namespace to anchor).

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

A human-readable locator: the gitlab.com-shaped path.

Trait Implementations

impl AstAdapter for GitlabAdapter

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

Direct addressing, one GET per segment: a group or user at the root, a subgroup or project under a group, an issue/MR by iid (any state), a pipeline by id.

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

Kinds, visibility, flags, topics, labels (scoped labels included), and pipeline/job statuses, all as traits.

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

Curated scalars per kind; timestamps as instants, ::topics and ::labels as lists.

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

A file’s decoded content; an issue’s, MR’s, or release’s description text.

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

::parent~> (a fork’s upstream), ::author~>.

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

member edges (with access-level edge data) from groups and projects; parent from forks; author / assignee / reviewer from issues and merge requests.

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

A project’s forks: <-parent.

fn link_property( &self, source: NodeId, label: &str, target: NodeId, name: &str, ) -> Option<Value>

The member edge carries its access level: $-::access (the numeric level) and $-::role.

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 metadata(&self, node: NodeId, key: &str) -> Option<Value>

Adapter-defined metadata — ::::key (a filesystem adapter’s size, modified, permissions, …). None if absent.

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

The node’s own properties, enumerated — name and value, in the source’s order — for readings that keep values off the tree (the JSON property reading, where an object’s scalar fields are no nodes). The serializers (| json, | xml, | kaiv) merge them with the children, a child winning a shared name. The default is none: for a reading whose values are all nodes, the children already say everything.

fn non_tree_nodes(&self) -> Vec<NodeId>

The nodes of the arbor that are not in the tree — joined to it by crosslinks alone, with no parent and no path. The universal search *// reaches them after the tree, in this order; :::is-non-tree is true on them. The default is none: every shipped adapter puts every node in the tree.

fn child_host(&self, node: NodeId) -> NodeId

The node whose children an explicit child step from node reads. The default is node itself. An adapter whose tree holds transparent links (a filesystem’s symlink to a directory) answers the link’s target, so /link/name lands on the target’s own child — the same node /target/name reaches. The descendant walk never consults this: it reads children alone, so a linked subtree is walked once, under its own parent, and a cycle of links cannot trap it.

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 external_ref( &self, _node: NodeId, _property: &str, _hint: Option<&str>, ) -> Option<String>

The external reference node’s property holds, if any: an adapter-defined identifier of a document outside this arbor — for html, the anchor’s absolute URL, a relative href joined against the document’s own URL. A #fragment part is the crossref within the target document and rides along (URI semantics). Consulted by ::property--> when in-document resolution misses: a mounted document with that identifier answers (the fragment’s element, else its root), an unmounted one lands among the run’s unresolved external references for the host’s acquisition loop. The engine itself never fetches.

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

The element fragment names inside the document node belongs to — html’s id lookup. The landing rung of a fragment-carrying external reference, once its document is mounted.

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

The property carrying node’s own reference, for the bare arrow (//a-->): an html anchor’s href, an iframe’s src. None for a node that references nothing.

fn ref_label(&self, _node: NodeId, _property: &str) -> Option<String>

The relation name a resolution edge from node via property carries — html’s rel attribute. None falls back to the property name as the edge label.

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 descendants_where( &self, _node: NodeId, _name: &str, _property: &str, _value: &Value, ) -> Option<Vec<(NodeId, usize)>>

The descendants of node named name whose property property equals value, each with its depth, in document order — the fast path behind //name[::property = "value"] for an adapter that indexes a property (the corpus reading’s positional index answers //token[::lower = "tom"] from it). None keeps the engine’s walk and its comparison; Some must be exactly what the walk would find under the standard equality, so an adapter answers only the values it can compare as the engine does (text against text).

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.