diction.core — diction 0.2.2

*force-sensible* clj

Dynamic force-sensible flag var for generated values for data element docs.

*generate-all-fields* clj

Dynamic generate-all-fields flag var for forcing generation of all document fields.

<-meta clj

(<-meta id)

Returns the metadata of the element with id. nil is none.

boolean! clj

Programmatic registration of a boolean data element.

clean clj

(clean elem)

Cleans the element element by removing type and id fields.

clear-decoration-rules! clj

(clear-decoration-rules! element-id)

Clears decoration rules for element element-id.

clear-dictionary! clj

(clear-dictionary!)

Clear dictionary entries.

clear-undecoration-rules! clj

(clear-undecoration-rules! element-id)

Clears undecoration rules for element element-id.

clear-validation-rules! clj

(clear-validation-rules! element-id)

Clears validation rules for element element-id.

clone! clj

(clone! parent-id id)

(clone! parent-id id ctx)

Clones parent-id to the new element id id.

custom-element! clj

(custom-element! custom-elem element-info)

(custom-element! custom-elem id element)

(custom-element! custom-elem id element ctx)

(custom-element! custom-elem parent-id id element ctx)

Registers custom element with custom element init 'custom-elem, idid, element mapelementwith optional element contextctx and parent element id parent-id. The parent element may be used as a base for the element definition.

data-dictionary clj

(data-dictionary)

(data-dictionary filter-f)

Generates a data dictionary given current element definitions.

decorate clj

(decorate element-id v)

(decorate element-id v ctx)

Decorates element value v using decoration rules for element element-id with optional context map ctx.

decoration-rule! clj

(decoration-rule! {:keys [element-id rule-id rule-f ctx]})

(decoration-rule! element-id rule-id rule-f)

(decoration-rule! element-id rule-id rule-f ctx)

Registers a decoration rule for element element-id, decoration rule id rule-id, rule function rule-f, and optional context map ctx.

decoration-rules clj

Decoration rules as atom.

default-gen-vector-max clj

Default maximum count for vector (16).

default-gen-vector-min clj

Default minimum count for vector (0).

diction-boolean clj

Diction core boolean data element id.

diction-double clj

Diction core double data element id.

diction-double-neg clj

Diction core negative double data element id.

diction-double-pos clj

Diction core positive double data element id.

diction-float clj

Diction core float data element id.

diction-float-neg clj

Diction core negative float data element id.

diction-float-pos clj

Diction core positive float data element id.

diction-int clj

Diction core integer data element id.

diction-int-neg clj

Diction core negative integer data element id.

diction-int-pos clj

Diction core positive integer data element id.

diction-joda clj

Diction core Joda date data element id.

diction-keyword clj

Diction core keyword data element id.

diction-long clj

Diction core long data element id.

diction-long-neg clj

Diction core negative long data element id.

diction-long-pos clj

Diction core positive long data element id.

diction-string clj

Diction core string data element id.

diction-uuid clj

Diction core UUID data element id.

dictionary clj

Atom that holds the dictionary data structure.

dictionary! clj

(dictionary! d)

Set the dictonary atom with new dictionary value d.

document! clj

(document! id req-un)

(document! id req-un opt-un)

(document! id req-un opt-un element)

(document! id req req-un opt opt-un element ctx)

Register a document/map element given element id id, required unqualified nested element ids req-un, optional nested unqualified element ids opt-un, required nested element ids req, optional nested element ids opt-un, element map element and context ctx.

document-or-field clj

(document-or-field m)

Returns either :documents or :fields based on if m is a document/map.

document? clj

(document? m)

Determines if m element is a document/map.

double! clj

Programmatic registration of a double data element.

element! clj

(element! element-info)

(element! id element)

(element! id element ctx)

(element! parent-id id element ctx)

Registers element with id id, element map element with optional element context ctx and parent element idparent-id`. The parent element may be used as a base for the element definition.

entity! clj

Alias for document! function

enum! clj

(enum! id enums)

(enum! id enums element)

(enum! id enums element ctx)

Register an enum element given element id id, enum set/list/vector enums, element map element and context ctx.

explain clj

(explain id v)

Explains validation failures for element id against element value v as a vector of maps with validation failure messages and info. If no validation failure occurs, returns nil.

explain-all clj

(explain-all id v)

Explains validation failures for element id against element value v as a vector of maps with validation failure messages and info. If no validation failure occurs, returns nil.

export-elements! clj

(export-elements!)

Generates the current data elements list.

export-elements-to! clj

(export-elements-to! target)

Exports elements to target.

export-entries clj

(export-entries)

Generates export vector of element entries.

export-entries-to-file! clj

(export-entries-to-file! fn)

Exports element entries to file fn.

field-element-id clj

(field-element-id id fld-id)

Returns the namespaced (if available) field id for document element id given a field id id.

filter-out-diction-elements clj

(filter-out-diction-elements x)

Filters out diction elements given element x.

float! clj

Programmatic registration of a float data element.

force-generate clj

(force-generate id)

Generates a valid value of element id id.

function! clj

(function! {:keys [id f argument-element-ids result-element-id]})

(function! function-id f argument-element-ids result-element-id)

Registers function id id for function f and vector of element ids for the arguments arugment-element-ids, and result element id result-element-id.

functions clj

Generative functions registry as atom.

functions! clj

(functions! fs)

Registers list of generative testing functions fs.

generate clj

Alias for generate-sensibly function call

generate-nested-elements clj

(generate-nested-elements element-ids)

(generate-nested-elements element-ids unqualified?)

(generate-nested-elements element-ids unqualified? optional?)

Generates nested elements element-ids with optional flags unqualified? for element id keys and optional? for the nested elements.

generate-random-boolean clj

(generate-random-boolean)

Generates a randome boolean true or false.

generate-random-double clj

(generate-random-double)

(generate-random-double max)

(generate-random-double min max)

Generates random double numbers given optional minimum min and maximum max. Default min is Double/MIN_VALUE. Default max is Double/MAX_VALUE.

generate-random-float clj

(generate-random-float)

(generate-random-float max)

(generate-random-float min max)

Generates random float numbers given optional minimum min and maximum max. Default min is Float/MIN_VALUE. Default max is Float/MAX_VALUE.

generate-random-int clj

(generate-random-int)

(generate-random-int max)

(generate-random-int min max)

Generates random int numbers given optional minimum min and maximum max. Default min is Integer/MIN_VALUE. Default max is Integer/MAX_VALUE.

generate-random-joda clj

(generate-random-joda)

(generate-random-joda max)

(generate-random-joda min max)

Generates random int numbers given optional minimum min and maximum max. Default min is Integer/MIN_VALUE. Default max is Integer/MAX_VALUE.

generate-random-keyword clj

(generate-random-keyword)

(generate-random-keyword max)

(generate-random-keyword min max)

(generate-random-keyword min max random-str)

Generates a random keyword given optional minimum length min and maximum lenghts max. Default min is 0. Default max is 64.

generate-random-long clj

(generate-random-long)

(generate-random-long max)

(generate-random-long min max)

Generates random long numbers given optional minimum min and maximum max. Default min is Long/MIN_VALUE. Default max is Long/MAX_VALUE.

generate-random-map clj

(generate-random-map element-id)

Generates a random map.

generate-random-poly-vector clj

(generate-random-poly-vector element-ids)

(generate-random-poly-vector element-ids max)

(generate-random-poly-vector element-ids min max)

(generate-random-poly-vector element-ids min max meta)

Generates a random poly vector of elements element-ids given optional minimum size min and maximum size max. Default min is 0. Default max is 16.

generate-random-set clj

(generate-random-set element-id)

(generate-random-set element-id max)

(generate-random-set element-id min max)

(generate-random-set element-id min max meta)

Generates a random set of element element-id given optional minimum size min and maximum size max. Default min is 0. Default max is 16.

generate-random-string clj

(generate-random-string)

(generate-random-string max)

(generate-random-string min max)

(generate-random-string min max random-str)

Generates a random string given optional minimum length min and maximum lenghts max. Default min is 0. Default max is 64.

generate-random-tuple clj

(generate-random-tuple element-ids)

Generates a random tuple of elements element-ids

generate-random-vector clj

(generate-random-vector element-id)

(generate-random-vector element-id max)

(generate-random-vector element-id min max)

(generate-random-vector element-id min max meta)

Generates a random vector of element element-id given optional minimum size min and maximum size max. Default min is 0. Default max is 16.

generate-regex-keyword clj

(generate-regex-keyword regex)

Generates a keyword using the regular expression regex. Basic regex is supported only.

generate-regex-string clj

(generate-regex-string regex)

Generates a string using the regular expression regex. Basic regex is supported only.

generate-sensibly clj

(generate-sensibly id)

(generate-sensibly id generate-as-fallback?)

Generates a sensible value for element with id and optional generate-as-fallback? flag to use the generative function for the element if no sensible values exist in the meta of the element (:element :meta :sensible-values).

generate-test-arguments clj

(generate-test-arguments arguments)

Generates test

groom clj

(groom id v)

(groom id v ctx)

(groom parent-id id v ctx)

Grooms the value of element id to align with only the registered diction elements. If the value is a map, then groom acts recursively like select-keys to groom unregistered keys and only passthru registered diction element keys (required and optional).

help clj

Alias for element lookup function

import! clj

(import! elem)

Import element elem to diction data dictionary.

import-boolean! clj

Import declarative boolean data element.

import-clone! clj

(import-clone! elem)

Import a clone element elem.

import-document! clj

(import-document! elem)

Import the document element elem.

import-double! clj

Import declarative double data element.

import-element! clj

(import-element! elem)

(import-element! diction-f elem)

Import element elem with optional diction function diction-f.

import-entries! clj

(import-entries! entries)

Imports element entries entries.

import-entries-from-file! clj

(import-entries-from-file! fn)

Imports element entries from file fn.

import-enum! clj

Import declarative enum data element.

import-float! clj

Import declarative float data element.

import-from-file! clj

(import-from-file! source)

Import elements from source file.

import-keyword! clj

Import declarative keyword data element.

import-long! clj

Import declarative long data element.

import-neg-double! clj

Import declarative negative double data element.

import-neg-float! clj

Import declarative negative float data element.

import-neg-long! clj

Import declarative negative long data element.

import-ofs! clj

(import-ofs! register-f of-key elem)

Import collection of of-key elements for element elem with the diction register-f function.

import-poly-vector! clj

Import declarative poly-vector data element.

import-pos-double! clj

Import declarative positive double data element.

import-pos-float! clj

Import declarative positive float data element.

import-pos-long! clj

Import declarative positive long data element.

import-set! clj

Import declarative set data element.

import-string! clj

Import declarative string data element.

import-tuple! clj

Import declarative tuple data element.

import-vector! clj

Import declarative vector data element.

imports! clj

(imports! elements)

Imports elements elements to diction data dictionary.

info clj

Alias for element lookup function

inherit! clj

(inherit! parent-id id)

(inherit! parent-id id element)

(inherit! parent-id id element ctx)

Register a child element given element id id, parent element id parent-id, element map element and context ctx.

int! clj

Programmatic registration of an integer data element.

joda! clj

Programmatic registration of a Joda date data element.

keyword! clj

Programmatic registration of a keyword data element.

long! clj

Programmatic registration of a long data element.

lookup clj

(lookup id)

Lookup of element by element id id.

map! clj

Alias for document! function

meta-query clj

(meta-query {:keys [element-ids query query-f mask] :as meta-query-map})

Query diction element metadata with map meta-query-map and keys element-ids (optional) : subset of element ids to search; query (required) : query map that will simple try to match the element meta data map

neg-double! clj

Programmatic registration of a negative data element.

neg-float! clj

Programmatic registration of a negative float data element.

neg-int! clj

Programmatic registration of a negative integer data element.

neg-long! clj

Programmatic registration of a negative long data element.

opt-key clj

Optional qualified/ns fields key.

opt-un-key clj

Optional unqualified fields keys.

poly-vector! clj

(poly-vector! id vector-of-element-ids)

(poly-vector! id vector-of-element-ids element)

(poly-vector! id vector-of-element-ids element ctx)

Register a poly vector (polyglot of element ids) element given element id id, vector element ids vector-of-element-ids, element map element and context ctx.

pos-double! clj

Programmatic registration of a positive double data element.

pos-float! clj

Programmatic registration of a positive float data element.

pos-int! clj

Programmatic registration of a positive integer data element.

pos-long! clj

Programmatic registration of a positive long data element.

references clj

(references element-id)

Determine the documents that reference the element element-id.

register-element! clj

(register-element! elem)

Register element elem using declarative data.

remove-decoration-rule! clj

(remove-decoration-rule! element-id rule-id)

Removes decoration rule rule-id from element element-id.

remove-undecoration-rule! clj

(remove-undecoration-rule! element-id rule-id)

Removes undecoration rule rule-id from element element-id.

remove-validation-rule! clj

(remove-validation-rule! element-id rule-id)

Removes validation rule rule-id from element element-id.

req-key clj

Required qualified/ns fields key.

req-un-key clj

Required unqualified fields key.

reset-decoration-rules! clj

(reset-decoration-rules!)

(reset-decoration-rules! x)

Resets the decoration rules. Clears all decoration rules if no arguments or x is nil. Otherwise, reset the decoration rules to x.

reset-undecoration-rules! clj

(reset-undecoration-rules!)

(reset-undecoration-rules! x)

Resets the undecoration rules. Clears all undecoration rules if no arguments or x is nil. Otherwise, reset the undecoration rules to x.

reset-validation-rules! clj

(reset-validation-rules!)

(reset-validation-rules! x)

Resets the validation rules. Clears all validation rules if no arguments or x is nil. Otherwise, reset the validation rules to x.

sensible clj

Atom that is the flag to force sensible values during documentation generation

sensible! clj

(sensible! s)

Sets the sensible flag atom to value s.

set-of! clj

(set-of! id set-of-element-id)

(set-of! id set-of-element-id element)

(set-of! id set-of-element-id element ctx)

Register a set element given element id id, set element id set-of-element-id, element map element and context ctx.

string! clj

Programmatic registration of a string data element.

summary-entry clj

(summary-entry entry)

Generates an index entry for element entry entry.

test-all-functions clj

(test-all-functions)

(test-all-functions test-function-count)

Generatively test all registered functions with optional test function count test-function-count.

test-function clj

(test-function function-id)

(test-function function-id test-function-count)

Generatively tests registered function function-id with optional test count test-function-count. Returns nil is all generative test function calls pass. Otherwise, return failures.

tuple! clj

(tuple! id vector-of-element-ids)

(tuple! id vector-of-element-ids element)

(tuple! id vector-of-element-ids element ctx)

Register a tuple (polyglot of element ids) element given element id id, vector element ids vector-of-element-ids, element map element and context ctx.

type-normalizer! clj

(type-normalizer! normalizer-f)

Register register normalizer function normalizer-f.

type-normalizers clj

Atom with type normalizers to auto-register/decorate data elements.

type-normalizers! clj

(type-normalizers! normalizer-fs)

Registers register normalizer fuction normalizer-fs.

types->functions clj

Maps data element types to import functions.

undecorate clj

(undecorate element-id v)

(undecorate element-id v ctx)

Undecorates element value v using undecoration rules for element element-id with optional context map ctx.

undecoration-rule! clj

(undecoration-rule! {:keys [element-id rule-id rule-f ctx]})

(undecoration-rule! element-id rule-id rule-f)

(undecoration-rule! element-id rule-id rule-f ctx)

Registers an undecoration rule for element element-id, undecoration rule id rule-id, rule function rule-f, and optional context map ctx.

undecoration-rules clj

Undecoration rules as an atom.

uuid! clj

Programmatic registration of a UUID data element.

valid-all? clj

(valid-all? id v)

Determines if the element value v of element id is valid.

valid? clj

(valid? id v)

Determines if the element value v of element id is valid.

validation-rule! clj

(validation-rule! {:keys [element-id rule-id rule-f ctx]})

(validation-rule! element-id rule-id rule-f)

(validation-rule! element-id rule-id rule-f ctx)

Registers a validation rule for element id element-id, rule id id, rule function rule-f, and optional conext map ctx.

validation-rules clj

Validation rules as atom.

vector! clj

(vector! id vector-of-element-id)

(vector! id vector-of-element-id element)

(vector! id vector-of-element-id element ctx)

Register a vector element given element id id, vector element id vector-of-element-id, element map element and context ctx.

wrap-gen-f clj

(wrap-gen-f gen-f)

Wraps generatior function gen-f with a function that ignores the element id id and element entry entry trailing paramsters when called by the framework to generate a element value. This may be used when the element value generator function does not need the id or entry to generate the value.