naga.data — naga 0.1.0

Converts external data into a graph format (triples).

*current-storage* clj

build-list clj

(build-list store pairs)

Inputs: [store :- Storage pairs :- [[s/Keyword s/Any]]] Returns: [s/Any]

Takes property/value pairs and if they represent a list node, returns the list. else, nil.

check-structure clj

(check-structure store prop v)

Inputs: [store :- Storage prop :- s/Any v :- s/Any] Returns: (s/maybe [[s/Keyword s/Any]])

Determines if a value represents a structure. If so, return the property/values for it. Otherwise, return nil.

containership-triples clj

(containership-triples node triples)

Inputs: [node :- s/Any triples :- [Triple]]

Finds the list of entity nodes referred to in a list and builds triples describing a flat 'contains' property

get-naga-first clj

(get-naga-first struct)

Finds the naga/first property in a map, and gets the value.

id->json clj

(id->json store entity-id)

Inputs: [store :- Storage entity-id :- s/Any] Returns: {s/Keyword s/Any}

Uses an id node to load up a nested data structure from the graph

ident->json clj

(ident->json store ident)

Inputs: [store :- Storage ident :- s/Any] Returns: {s/Keyword s/Any}

Converts data in a database to data structures suitable for JSON encoding

ident-map->triples clj

(ident-map->triples j)

Inputs: [j] Returns: [s/Any [Triple]]

Converts a single map to triples for an ID'ed map

json->triples clj

(json->triples storage j)

Inputs: [storage j] Returns: [Triple]

Converts parsed JSON into a sequence of triples for a provided storage.

list-triples clj

(list-triples [v & vs :as vlist])

Inputs: [[v & vs :as vlist]]

Creates the triples for a list

map->triples clj

(map->triples data)

Inputs: [data :- {s/Keyword s/Any}] Returns: [s/Any [Triple]]

Converts a single map to triples. Returns a pair of the map's ID and the triples for the map.

name-for clj

(name-for id)

Inputs: [id :- s/Any]

Convert an id (probably a number) to a keyword for identification

pairs->json clj

(pairs->json store prop-vals)

Inputs: [store :- Storage prop-vals :- [[s/Keyword s/Any]]] Returns: {s/Keyword s/Any}

Uses a set of property-value pairs to load up a nested data structure from the graph

property-vals clj

(property-vals entity-id [property value])

Inputs: [entity-id :- s/Any [property value] :- [s/Keyword s/Any]] Returns: [Triple]

Takes a property-value pair associated with an entity, and builds triples around it

property-values clj

(property-values store entity)

Inputs: [store :- Storage entity :- s/Any] Returns: [[s/Keyword s/Any]]

Return all the property/value pairs for a given entity in the store.

recurse-node clj

(recurse-node store [prop v :as prop-val])

Inputs: [store :- Storage [prop v :as prop-val] :- [s/Keyword s/Any]] Returns: s/Any

Determines if the val of a map entry is a node to be recursed on, and loads if necessary

store->json clj

(store->json store)

Inputs: [store :- Storage] Returns: [{s/Keyword s/Any}]

Pulls all top level JSON out of a store

store->str clj

(store->str store)

Inputs: [store :- Storage] Returns: s/Str

Reads a store into JSON strings

stream->triples clj

(stream->triples storage io)

Inputs: [storage io] Returns: [Triple]

Converts a stream to triples relevant to a store

string->triples clj

(string->triples storage s)

Inputs: [storage :- Storage s :- s/Str] Returns: [Triple]

Converts a string to triples relevant to a store

Triple clj

value-triples clj multimethod

Converts a value into a list of triples. Return the entity ID of the data coupled with the sequence of triples. NOTE: This may need to be dispatched to storage. e.g. Datomic could use properties to determine how to encode data.