diction.core — diction 0.2.1

*force-sensible* clj

*generate-all-fields* clj

<-meta clj

(<-meta id)

boolean! clj

capture-un-fields clj

(capture-un-fields unf)

clean clj

(clean elem)

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

default-gen-double-max clj

default-gen-double-min clj

default-gen-float-max clj

default-gen-float-min clj

default-gen-int-max clj

default-gen-int-min clj

default-gen-joda-max clj

default-gen-joda-min clj

default-gen-long-max clj

default-gen-long-min clj

default-gen-vector-max clj

default-gen-vector-min clj

default-random-count clj

default-test-function-count clj

default-type-normalizers clj

dev-export clj

diction-boolean clj

diction-double clj

diction-double-neg clj

diction-double-pos clj

diction-float clj

diction-float-neg clj

diction-float-pos clj

diction-int clj

diction-int-neg clj

diction-int-pos clj

diction-joda clj

diction-keyword clj

diction-long clj

diction-long-neg clj

diction-long-pos clj

diction-string clj

diction-uuid clj

dictionary clj

dictionary! clj

(dictionary! 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-field-element-ids clj

(document-field-element-ids id)

Generates the field elements for document element id for both namespaced and unqualified fields.

document-keys clj

document-keys-ns clj

document-keys-un clj

document-or-field clj

(document-or-field m)

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

document-type? clj

(document-type? entry)

Determines if diction entry is document type or not.

document? clj

(document? m)

Determines if m element is a document/map.

double! clj

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

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.

exclude-export-keys clj

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.

explain-map clj

(explain-map nested-id
             required-element-ids
             required-element-ids-un
             optional-element-ids
             optional-element-ids-un
             v
             id
             entry)

Explains nested required element entries with the nested-id, listing of required element ids required-element-ids, element value v, element id id, and element element.

explain-nested-elements clj

(explain-nested-elements nested-id parent-element-id v element-ids)

(explain-nested-elements nested-id parent-element-id v element-ids unqualified?)

(explain-nested-elements nested-id
                         parent-element-id
                         v
                         element-ids
                         unqualified?
                         optional?)

Explain nested elements.

export-elements! clj

(export-elements!)

export-elements-to! clj

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

export-exclude-prefix clj

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

force-generate clj

(force-generate id)

Generates a valid value of element id id.

func-types clj

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

functions! clj

(functions! fs)

Registers list of function fs.

generate clj

generate-export-entry clj

(generate-export-entry entry)

Generates export entry map from element entry entry.

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

groom-vector clj

(groom-vector parent-id id v)

(groom-vector parent-id id v ctx)

Grooms a vector of elements for parent-id, id, value v and optional context ctx.

help clj

import! clj

(import! elem)

Import element elem to diction data dictionary.

import-boolean! clj

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-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-float! clj

import-from-file! clj

(import-from-file! source)

Import elements from source file.

import-keyword! clj

import-long! clj

import-neg-double! clj

import-neg-float! clj

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-pos-double! clj

import-pos-float! clj

import-set! clj

import-string! clj

import-tuple! clj

import-vector! clj

imports! clj

(imports! elements)

Imports elements elements to diction data dictionary.

info clj

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.

initialize-diction-elements! clj

(initialize-diction-elements!)

int! clj

joda! clj

keyword! clj

long! clj

lookup clj

(lookup id)

Lookup of element by element id id.

map! clj

merge! clj

(merge! {:keys [parent-id id element ctx]})

(merge! parent-id id)

(merge! parent-id id element)

(merge! parent-id id element ctx)

Merges and registers parent id parent-id for element id with optional element map element and context map ctx.

merge-entities! clj

(merge-entities! {:keys [parent-ids id element ctx]})

(merge-entities! parent-ids id)

(merge-entities! parent-ids id element)

(merge-entities! parent-ids id element ctx)

Merges and registers parent id parent-id for element id with optional element map element and context map ctx.

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

neg-float! clj

neg-int! clj

neg-long! clj

normalize-any clj

(normalize-any m)

Normalizes the any entry type elements (if necessary) given element map m. If not a string type, passhtru the element map m.

normalize-boolean clj

(normalize-boolean m)

Normalizes the boolean type elements (if necessary) given element map m. If not a boolean type, passhtru the element map m.

normalize-class clj

(normalize-class m)

Normalizes the class entry type elements (if necessary) given element map m. If not a class type, passhtru the element map m.

normalize-double clj

(normalize-double m)

Normalizes the double number entry type elements (if necessary) given element map m. If not a double number type, passhtru the element map m.

normalize-element clj

(normalize-element parent-id id original-element ctx merged-element)

Generates entry settings for element id id given the original element map original-element (from the call argument), merged element from parent and original element merged-element``, and optionalparent-idand context mapctx`.

normalize-enum clj

(normalize-enum m)

Normalizes the enumeration entry type elements (if necessary) given element map m. If not an enum type, passhtru the element map m.

normalize-float clj

(normalize-float m)

Normalizes the float number entry type elements (if necessary) given element map m. If not a float number type, passhtru the element map m.

normalize-int clj

(normalize-int m)

Normalizes the int number entry type elements (if necessary) given element map m. If not a int number type, passhtru the element map m.

normalize-joda clj

(normalize-joda m)

Normalizes the joda entry type elements (if necessary) given element map m. If not a string type, passhtru the element map m.

normalize-keyword clj

(normalize-keyword m)

Normalizes the keyword entry type elements (if necessary) given element map m. If not a string type, passhtru the element map m.

normalize-long clj

(normalize-long m)

Normalizes the long number entry type elements (if necessary) given element map m. If not a long number type, passhtru the element map m.

normalize-map clj

(normalize-map m)

Normalizes the required-optional/map entry type elements (if necessary) given entry map m. If not a required-optiona/map type, passhtru the entry map m.

normalize-poly-vector clj

(normalize-poly-vector m)

Normalizes the poly-vector-of entry type elements (if necessary) given element map m. If not a poly-vector-of type, passhtru the element map m.

normalize-set clj

(normalize-set m)

Normalizes the set entry type elements (if necessary) given element map m. If not a set type, passhtru the element map m.

normalize-string clj

(normalize-string m)

Normalizes the string entry type elements (if necessary) given element map m. If not a string type, passhtru the element map m.

normalize-tuple clj

(normalize-tuple m)

Normalizes the poly-tuple-of entry type elements (if necessary) given element map m. If not a tuple type, passhtru the element map m.

normalize-vector clj

(normalize-vector m)

Normalizes the vector-of entry type elements (if necessary) given element map m. If not a vector-of type, passhtru the element map m.

opt-key clj

opt-un-key clj

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

pos-float! clj

pos-int! clj

pos-long! clj

random-chars clj

random-kw-chars clj

random-sensible-value clj

(random-sensible-value id)

(random-sensible-value id generate-as-fallback?)

Returns random sensible value (:element :meta :sensible-values) for element id and optional generate-as-fallback? flag. Returns nil if no sensible values are found and optional genereate-as-fallback? flag is false or nil. If no sensible values are found and optional generate-as-fallback? flag is truthy, then attempt to generate value for element id.

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

req-un-key clj

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.

resolve-merged-entities clj

(resolve-merged-entities e & es)

Resolve merged entites e and variadic entites es.

resolve-req-opt-un clj

(resolve-req-opt-un req-un opt-un)

Resolves optional unqualified given the existing required unqualified req-un and the initial opertional unqualified opt-un so that there are no unqualified element keys in opertional that are also in the required unqualified.

resolve-unqualified clj

(resolve-unqualified key es)

Resolve unqualified element keys given entitiy maps es and the key of either required-un or optional-un.

safe-ns clj

(safe-ns x)

sensible clj

sensible! clj

(sensible! 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.

split-meta-query clj

(split-meta-query q)

Splits query map q into functions and non-functions based on values. Function kvs are in {true : {}} and non-function kvs are in {false : {}}.

string! clj

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-func clj

type-normalizer! clj

(type-normalizer! normalizer-f)

Register register normalizer function normalizer-f.

type-normalizers clj

type-normalizers! clj

(type-normalizers! normalizer-fs)

Registers register normalizer fuction normalizer-fs.

types->functions clj

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

uuid! clj

uuid-regex clj

uuid-regex-legacy clj

uuid-regex-pattern clj

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.

validate-boolean clj

(validate-boolean v id entry)

Validates if value v is boolean.

validate-class clj

(validate-class c v id entry)

Validates that the class c is the same as the class of v given optional element id id and entry entry.

validate-double clj

(validate-double min max v id entry)

Validates that a double number value v is valid given the optional minimum min, maximum max, element id id, and element entry.

validate-enum clj

(validate-enum enum-s v id entry)

Validates an enum type set enum-s against element value v given element id id and entry entry for better validation failure messages.

validate-float clj

(validate-float min max v id entry)

Validates that a float number value v is valid given the optional minimum min, maximum max, element id id, and element entry.

validate-int clj

(validate-int min max v id entry)

Validates that an int number value v is valid given the optional minimum min, maximum max, element id id, and element entry.

validate-joda clj

(validate-joda min max v id entry)

Validates that a Joda datetime value v is valid given the optional minimum min, maximum max, element id id, and entry entry.

validate-keyword clj

(validate-keyword min max regex v id entry)

Validates a string value v given minimum length min (if non-nil), maximum length max (if non-nil), and regular expression regex (if non-nil). The element id id of the string element as well as the element entry entry of the string element is also provided for better validation failure messages.

validate-long clj

(validate-long min max v id entry)

Validates that a long number value v is valid given the optional minimum min, maximum max, element id id, and element entry.

validate-poly-vector-of clj

(validate-poly-vector-of vector-of-element-ids min max v id entry)

Validates the poly vector of element ids vector-of-element-ids given a mininum length min, maximum length max, element poly vector value v, parent element id id, and entry entry.

validate-set-of clj

(validate-set-of set-of-element-id min max v id entry)

Validates the set of element id set-of-element-id given a mininum length min, maximum length max, element value v, parent element id id, and entry entry.

validate-string clj

(validate-string min max regex v id entry)

Validates a string value v given minimum length min (if non-nil), maximum length max (if non-nil), and regular expression regex (if non-nil). The element id id of the string element as well as the element entry entry of the string element is also provided for better validation failure messages.

validate-tuple-of clj

(validate-tuple-of vector-of-element-ids v id entry)

Validates the tuple of element ids vector-of-element-ids given element tuple value v, parent element id id, and entry entry.

validate-vector-of clj

(validate-vector-of vector-of-element-id min max v id entry)

Validates the vector of element id vector-of-element-id given a mininum length min, maximum length max, element value v, parent element id id, and entry entry.

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

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.

years-millis clj