sweet-tooth.describe — sweet-tooth/describe 0.2.0

add-description clj/s

(add-description descriptions rule result)

If dscr is a function apply it to result of pred function Otherwise return dscr

base-arity clj/s

(base-arity name args rule)

blank clj

(blank arg)

(blank arg dscr)

context clj/s

(context cfn)

Used in rules to access the context passed in to describe.

count-not-in-range clj

(count-not-in-range arg)

(count-not-in-range arg m n)

(count-not-in-range arg m n dscr)

default-translations clj/s

defrule clj/s macro

(defrule name args rule)

describe clj/s

(describe x rules & [additional-ctx])

does-not-match clj

(does-not-match arg)

(does-not-match arg regex)

(does-not-match arg regex dscr)

empty clj

(empty arg)

(empty arg dscr)

graph clj/s

(graph node-defs)

Allows slightly more compact syntax for defining graphs by treating a vector of [:a :b :c] as pairs [:a :b] [:b :c] and by treating rule maps as nodes instead of attempting to treat them as maps describing nodes and edges

key-rule clj/s

(key-rule key-fn rules)

Treats value returned by key-fn as new context that you're applying rules to

map-describe clj/s

(map-describe rules xs)

(map-describe rules additional-ctx xs)

Apply rules to xs; return nil if all descriptions nil

map-rollup-descriptions clj/s

(map-rollup-descriptions descriptions)

Converts set of descriptions to a map roughly reflecting the original map described. Descriptions take the form of:

#{[:a [::y]] [:a [::z]] [:b [::x]]}

This returns a map of the form:

{:a #{::y ::z} :b #{::x}}

A concession to people who insist that this is about validation and not describing.

matches clj

(matches arg)

(matches arg regex)

(matches arg regex dscr)

not-alnum clj/s

(not-alnum arg)

not-in-range clj

(not-in-range arg)

(not-in-range arg m n)

(not-in-range arg m n dscr)

not= clj

(not= arg)

(not= arg compare-to)

(not= arg compare-to dscr)

path-rule clj/s

(path-rule key-fns rules)

Nested key rules

remove-rule-subgraph clj/s

(remove-rule-subgraph rule-graph rule)

Remove all downstream rules so that we don't attempt to apply them

resolve-args clj/s

(resolve-args ctx args)

Rule args come in four flavors:

• A function wrapped with context. This resolves by applying the fn to the context.
• A fn with the :const keyword in metadata. This resolves to itself.
• A keyword or fn. This resolves by being applied to the subject (the thing being described).
• Something else. This resolves to itself.

rule-applies? clj/s

(rule-applies? ctx rule-graph rule)

Apply the predicate function to args.

rules->graph clj/s

(rules->graph rules)

Convert data structure describing graph to an actual graph.

spec-explain-data clj

(spec-explain-data arg)

(spec-explain-data arg spec)

(spec-explain-data arg spec dscr)

spec-not-valid clj

(spec-not-valid arg)

(spec-not-valid arg spec)

(spec-not-valid arg spec dscr)

translate clj/s

(translate descriptions)

(translate translations descriptions)

translate-description clj/s

(translate-description [arg dscr] translations)