Struct GithubAdapter 

pub struct GithubAdapter { /* private fields */ }

GitHub, exposed as an arbor.

Implementations

impl GithubAdapter

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

Connect to github:, github:OWNER, or github:OWNER/REPO.

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

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

Trait Implementations

impl AstAdapter for GithubAdapter

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

Direct addressing: a login at the root, a repository under its owner, an issue or pull by number (closed ones included) — one GET each, no enumeration.

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

Type traits (<user>, <repo>, <issue>…), boolean flags (<fork>, <archived>, <open>, <merged>, <draft>, <prerelease>), issue labels verbatim (<bug>), and repository topics (<cli>).

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

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

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

A file’s decoded content; an issue’s, pull’s, or release’s body text.

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

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

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

The outgoing fabric: follows, starred, and org from a user; owner, parent, and contributor from a repository; author and assignee from an item.

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

The incoming fabric, from the API’s own reverse indexes: a user’s followers (<-follows), an org’s members (<-org), a repository’s stargazers (<-starred) and forks (<-parent).

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

The contributor edge carries its commit count: $-::contributions.

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 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 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 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 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.