tupelo.forest — tupelo 0.9.108

Allows the use of multiple tree structures. Provides tools to create, manipulate, and query the the trees individually and/or collectively.

*enlive-subtree-buffer-size* clj

Default output buffer size for filter-enlive-subtrees.

add-bush clj

(add-bush bush)

Inputs: [bush] Returns: HID

Adds a bush to the forest

add-leaf clj

(add-leaf attrs-arg)

(add-leaf attrs-arg value)

Inputs: ([attrs-arg] [attrs-arg :- (s/either tsk/KeyMap s/Keyword) value :- s/Any]) Returns: HID

add-node clj

(add-node attrs-arg)

(add-node attrs-arg kid-hids)

Inputs: ([attrs-arg] [attrs-arg :- (s/either tsk/KeyMap s/Keyword) kid-hids :- [HID]]) Returns: HID

add-tree clj

(add-tree tree-node)

Inputs: [tree-node] Returns: HID

Adds a tree to the forest.

add-tree-enlive clj

(add-tree-enlive arg)

Inputs: [arg] Returns: HID

Adds an Enlive-format tree to the forest

add-tree-hiccup clj

(add-tree-hiccup arg)

Inputs: [arg] Returns: HID

Adds a Hiccup-format tree to the forest. Tag values are converted to nil attributes: [:a ...] -> {:a nil ...}...

add-tree-xml clj

(add-tree-xml xml-str)

Inputs: [xml-str :- s/Str] Returns: HID

Adds a tree to the forest from an XML string.

all-hids clj

(all-hids)

Inputs: [] Returns: #{HID}

Returns a set of all HIDs in the forest

all-leaf-hids clj

(all-leaf-hids)

Inputs: [] Returns: #{HID}

Returns a set of all leaf HIDs in the forest

all-node-hids clj

(all-node-hids)

Inputs: [] Returns: #{HID}

Returns a set of all node HIDs in the forest

attr-get clj

(attr-get hid attr-name)

Inputs: [hid :- HID attr-name :- s/Keyword] Returns: tsk/KeyMap

Use the supplied function & arguments to update the attr value for a Node as in clojure.core/update

attr-remove clj

(attr-remove hid attr)

Inputs: [hid :- HID attr :- s/Keyword] Returns: tsk/KeyMap

Removes the specified attribute for an element

attr-update clj

(attr-update hid attr-name fn-update-attr & fn-update-attr-args)

Inputs: [hid :- HID attr-name :- s/Keyword fn-update-attr & fn-update-attr-args] Returns: tsk/KeyMap

Use the supplied function & arguments to update the attr value for a Node as in clojure.core/update

attrs-merge clj

(attrs-merge hid attrs-in)

Inputs: [hid :- HID attrs-in :- tsk/KeyMap] Returns: tsk/KeyMap

Merge the supplied attrs map into the attrs of a Node

attrs-reset clj

(attrs-reset hid attrs-new)

Inputs: [hid :- HID attrs-new :- tsk/KeyMap] Returns: tsk/KeyMap

Replace the attrs of a Node with the supplied attrs map

bush->enlive clj

(bush->enlive bush)

Inputs: [bush :- tsk/Vec] Returns: tsk/KeyMap

Converts a Bush to an Enlive-format data structure

bush->hiccup clj

(bush->hiccup arg)

Inputs: [arg :- tsk/Vec] Returns: tsk/Vec

Converts a Bush to a Hiccup-format data structure.

bush->tree clj

(bush->tree bush)

Inputs: [bush] Returns: tsk/KeyMap

Converts a bush to a tree

bush-node? clj

(bush-node? arg)

Inputs: [arg] Returns: s/Bool

consolidate-raw-kids clj

(consolidate-raw-kids node)

Inputs: [node :- tsk/KeyMap] Returns: tsk/Vec

Consolidates ::raw kids for a node into a single Enlive :content vector

edn->tree clj

(edn->tree data)

(edn->tree idx data)

Inputs: ([data :- s/Any] [idx :- (s/either s/Int (s/eq nil)) data :- s/Any])

Creates a tree from an EDN data structure

enlive->bush clj

(enlive->bush arg)

Inputs: [arg :- tsk/KeyMap] Returns: tsk/Vec

Converts an Enlive-format data structure to a Bush.

enlive->hiccup clj

(enlive->hiccup node)

Inputs: [node :- s/Any] Returns: s/Any

enlive->tree clj

(enlive->tree enlive-tree)

Inputs: [enlive-tree :- tsk/KeyMap] Returns: tsk/KeyMap

Convert an Enlive-format data structure to a tree.

enlive-node-lax? clj

(enlive-node-lax? arg)

Returns true for nominal Enlive nodes, else false

enlive-node-strict? clj

(enlive-node-strict? arg)

Returns true for strictly valid Enlive nodes, else false

filter-enlive-subtrees clj

(filter-enlive-subtrees enlive-tree-lazy subtree-path)

Lazily read an enlive tree, retaining only rooted subtrees as specified by subtree-path

find-hid clj

(find-hid root-spec tgt-path)

Inputs: [root-spec :- HidRootSpec tgt-path :- tsk/Vec] Returns: HID

find-hids clj

(find-hids root-spec tgt-path)

Inputs: [root-spec :- HidRootSpec tgt-path :- tsk/Vec] Returns: [HID]

find-hids-with clj

(find-hids-with root-spec tgt-path hid-pred)

Inputs: [root-spec :- HidRootSpec tgt-path :- [s/Any] hid-pred :- s/Any]

find-leaf clj

(find-leaf root-spec tgt-path)

Inputs: [root-spec :- HidRootSpec tgt-path :- [s/Any]]

find-leaf-hid clj

(find-leaf-hid root-spec tgt-path)

Inputs: [root-spec :- HidRootSpec tgt-path :- [s/Any]]

find-leaf-hids clj

(find-leaf-hids root-spec tgt-path)

Inputs: [root-spec :- HidRootSpec tgt-path :- [s/Any]] Returns: [HID]

find-leaf-paths clj

(find-leaf-paths root-spec tgt-path)

Inputs: [root-spec :- HidRootSpec tgt-path :- tsk/Vec] Returns: [[HID]]

find-paths clj

(find-paths root-spec tgt-path)

Inputs: [root-spec :- HidRootSpec tgt-path :- tsk/Vec] Returns: [[HID]]

Searches an Enlive-format tree for the specified tgt-path

find-paths-with clj

(find-paths-with root-spec tgt-path path-pred)

Inputs: [root-spec :- HidRootSpec tgt-path :- [s/Any] path-pred :- s/Any]

find-tree clj

(find-tree root-spec tgt-path)

Inputs: [root-spec :- HidRootSpec tgt-path :- [s/Any]]

forest-leaf? clj

(forest-leaf? arg)

Inputs: [arg :- tsk/KeyMap] Returns: s/Bool

Returns true if the arg is a leaf node (empty :tupelo.forest/khids).

forest-node? clj

(forest-node? arg)

Inputs: [arg :- tsk/KeyMap] Returns: s/Bool

Returns true if the arg is a legal forest node

format-path clj

(format-path hids)

Inputs: [hids :- [HID]]

format-paths clj

(format-paths solns)

Inputs: [solns :- [[HID]]]

has-child-leaf? clj

(has-child-leaf? root-spec tgt-path)

Inputs: [root-spec :- HidRootSpec tgt-path :- [s/Any]]

has-child-path-with? clj

(has-child-path-with? root-spec tgt-path path-pred)

Inputs: [root-spec :- HidRootSpec tgt-path :- [s/Any] path-pred :- s/Any]

has-child-path? clj

(has-child-path? root-spec tgt-path)

Inputs: [root-spec :- HidRootSpec tgt-path :- [s/Any]]

hiccup->bush clj

(hiccup->bush arg)

Inputs: [arg :- tsk/Vec] Returns: tsk/Vec

Converts a Hiccup-format data structure to a Bush.

hiccup->enlive clj

(hiccup->enlive node)

Inputs: [node :- s/Any] Returns: s/Any

Converts a data from Hiccup -> Enlive format

hiccup->tree clj

(hiccup->tree arg)

Inputs: [arg :- tsk/Vec] Returns: tsk/KeyMap

Converts a Hiccup-format data structure to a Tree.

hid->attr clj

(hid->attr hid attr)

Inputs: [hid :- HID attr :- s/Keyword] Returns: s/Any

Given an HID, returns a single attr

hid->attrs clj

(hid->attrs hid)

Inputs: [hid :- HID] Returns: tsk/KeyMap

hid->bush clj

(hid->bush hid)

Inputs: [hid :- HID] Returns: tsk/Vec

hid->enlive clj

(hid->enlive hid)

hid->hiccup clj

(hid->hiccup hid)

Inputs: [hid :- HID] Returns: tsk/Vec

hid->kids clj

(hid->kids hid)

Inputs: [hid :- HID] Returns: [HID]

Returns the HIDs for a nodes children.

hid->leaf clj

(hid->leaf hid)

Inputs: [hid :- HID] Returns: Node

Returns the leaf node corresponding to an HID

hid->node clj

(hid->node hid)

Inputs: [hid :- HID] Returns: Node

Returns the node corresponding to an HID

hid->tree clj

(hid->tree hid)

Inputs: [hid :- HID] Returns: tsk/KeyMap

HidRootSpec clj

kids-append clj

(kids-append hid kids-new)

Inputs: [hid :- HID kids-new :- [HID]] Returns: tsk/KeyMap

Appends a list of kids a Node

kids-prepend clj

(kids-prepend hid kids-in)

Inputs: [hid :- HID kids-in :- [HID]] Returns: tsk/KeyMap

Appends a list of kids a Node

kids-set clj

(kids-set hid kids-new)

Inputs: [hid :- HID kids-new :- [HID]] Returns: Node

Resets the kids of a Node to the supplied list

kids-update clj

(kids-update hid fn-update-kids & fn-update-kids-args)

Inputs: [hid :- HID fn-update-kids & fn-update-kids-args] Returns: tsk/KeyMap

Updates the kids for a Node using a function, as in clojure.core/update

leaf-hid? clj

(leaf-hid? hid)

Inputs: [hid :- HID]

Returns true iff an HID is a leaf

leaf-path? clj

(leaf-path? path)

Inputs: [path :- [HID]] Returns: s/Bool

Returns true if an HID path ends in a leaf

leaf-value-hid? clj

(leaf-value-hid? hid)

Inputs: [hid :- HID] Returns: s/Bool

Returns true iff an HID is a leaf and has the :value attribute

new-forest clj

(new-forest)

Returns a new, empty forest.

new-hid clj

(new-hid)

Inputs: [] Returns: HID

Returns a new HexID

Node clj

node-hid? clj

(node-hid? hid)

Inputs: [hid :- HID]

Returns true iff an HID is a Node

raw-kids-node? clj

(raw-kids-node? node)

Inputs: [node :- tsk/KeyMap] Returns: s/Bool

Returns true if all of a node's kids are raw leaf nodes.

raw-leaf-node? clj

(raw-leaf-node? node)

Inputs: [node :- tsk/KeyMap] Returns: s/Bool

Returns true if a node is a leaf with {:tag ::raw}.

remove-all-kids clj

(remove-all-kids hid)

Inputs: [hid :- HID] Returns: tsk/KeyMap

Removes all children from a Node.

remove-hid clj

(remove-hid & hids-leaving)

Inputs: [& hids-leaving :- [HID]] Returns: #{HID}

Removes one or more nodes and all references to them from the database. May create orphaned nodes.

remove-kids clj

(remove-kids hid kids-leaving)

(remove-kids hid kids-leaving missing-kids-ok?)

Inputs: ([hid :- HID kids-leaving :- (s/either [HID] #{HID})] [hid :- HID kids-leaving :- (s/either [HID] #{HID}) missing-kids-ok? :- s/Bool]) Returns: tsk/KeyMap

Removes a set of children from a Node (including any duplcates).

remove-whitespace-leaves clj

(remove-whitespace-leaves)

Removes leaves from all trees in the forest that are whitespace-only strings (including zero-length strings).

root-hids clj

(root-hids)

Inputs: [] Returns: #{HID}

Return a vector of all root HID's

set-node clj

(set-node hid node)

(set-node hid attrs kids)

Inputs: ([hid :- HID node :- Node] [hid :- HID attrs :- tsk/KeyMap kids :- [HID]])

Unconditionally sets the value of a Node in the forest

tree->bush clj

(tree->bush tree-node)

Inputs: [tree-node :- tsk/Map] Returns: tsk/Vec

tree->edn clj

(tree->edn node)

Converts a tree to an EDN data structure

tree->enlive clj

(tree->enlive tree-node)

Inputs: [tree-node :- tsk/KeyMap] Returns: (s/either tsk/KeyMap tsk/Vec)

tree->hiccup clj

(tree->hiccup arg)

Inputs: [arg :- tsk/KeyMap] Returns: tsk/Vec

Converts a Tree to a Hiccup-format data structure.

tree-leaf? clj

(tree-leaf? arg)

Inputs: [arg :- tsk/KeyMap] Returns: s/Bool

Returns true if the arg is a leaf node (no kids).

tree-node? clj

(tree-node? arg)

Inputs: [arg :- tsk/KeyMap] Returns: s/Bool

Returns true if the arg is a legal tree node

validate-attrs clj

(validate-attrs attrs)

Inputs: [attrs :- tsk/KeyMap]

validate-forest clj

(validate-forest)

validate-hid clj

(validate-hid hid)

Inputs: [hid :- HID]

Returns HID arg iff it exists in the forest, else throws.

value-set clj

(value-set hid value-new)

Inputs: [hid :- HID value-new :- s/Any] Returns: Node

Resets the value of a leaf

value-update clj

(value-update hid fn-update-value & fn-update-value-args)

Inputs: [hid :- HID fn-update-value & fn-update-value-args] Returns: Node

Given a leaf with a value, updates that value using a function

whitespace-leaf-hid? clj

(whitespace-leaf-hid? hid)

Inputs: [hid :- HID] Returns: s/Bool

with-debug-hid clj macro

(with-debug-hid & forms)

with-forest clj macro

(with-forest forest-arg & forms)

with-forest-result clj macro

(with-forest-result forest-arg & forms)

xml->enlive clj

(xml->enlive xml-str)

Inputs: [xml-str :- s/Str] Returns: tsk/KeyMap