Liking cljdoc? Tell your friends :D

itl.core


->outclj

(->out m)

Converts a map into something you can use for assertions. Basically takes every keyword at the root that doesn't have a question mark at the end and adds a question mark to it.

Converts a map into something you can use for assertions. Basically
takes every keyword at the root that doesn't have a question mark
at the end and adds a question mark to it.
raw docstring

-h->kclj

(-h->k ks)

assert-cellclj

(assert-cell r n expected actual)

assert-valueclj

(assert-value expected actual)
(assert-value current-state expected actual)

balance-rowclj

(balance-row desired-length row)

bdtclj

(bdt current-state args {:keys [rows] :as t})

cell-valueclj

(cell-value current-state v)

decision-tableclj

(decision-table args {:keys [rows] :as t} process-row-fn)

defparsercljmacro

(defparser n f)

deftfncljmacro

(deftfn n args & body)

Define a table processing function or helper. The structure of the args differs depending on the contexts in which it is intended to be used.

If you give args as a map instead of a vector, then your function is assumed to take a single map. You can describe how that map's values get coerced upon invocation by declaring a [symbol fn] pair inside a vector bound to :in. The keyword form of the symbol is the key into the given map whereby its value can be retrieved. The fn will be invoked on that value, and its result bound to the given symbol. If you don't want a coercion to occur, simply put the symbol into the vector directly.

Another thing you can do with this map-based table function declaration is declare a series of output coercions. All table functions must return a map, so you can specify how the values in those maps are converted to Strings. By default, we will invoke str on any non-string, non-nil values. However, you can force the issue with a map associated to :out which specifies which function to invoke on each value mapped to the given key. If a function is given, regardless of whether there is even a value present in the resultant map, that function will be invoked. If there is no value present, then that function will be invoked on nil.

Note that, if your function returns something other than a map, (for example, the table table fixture requires the result to be a vector of maps), the :out keyword is simply ignored.

You can see a complete example of this macro in action in the itl.example.bank namespace.

Otherwise, args should be a vector and all the normal defn things apply.

Define a table processing function or helper. The structure of the `args`
differs depending on the contexts in which it is intended to be used.

If you give `args` as a map instead of a vector, then your function is assumed
to take a single map. You can describe how that map's values get coerced upon
invocation by declaring a `[symbol fn]` pair inside a vector bound to `:in`.
The keyword form of the `symbol` is the key into the given map whereby its
value can be retrieved. The `fn` will be invoked on that value, and its result
bound to the given symbol. If you don't want a coercion to occur, simply
put the `symbol` into the vector directly.

Another thing you can do with this map-based table function declaration is
declare a series of output coercions. All table functions must return
a map, so you can specify how the values in those maps are converted to
Strings. By default, we will invoke `str` on any non-string, non-nil values.
However, you can force the issue with a map associated to `:out` which
specifies which function to invoke on each value mapped to the given key.
If a function is given, regardless of whether there is even a value present
in the resultant map, that function will be invoked. If there is no value
present, then that function will be invoked on `nil`.

Note that, if your function returns something other than a map, (for example,
the table table fixture requires the result to be a vector of maps), the
`:out` keyword is simply ignored.

You can see a complete example of this macro in action in the
`itl.example.bank` namespace.

Otherwise, `args` should be a vector and all the normal `defn` things apply.
raw docstring

dtclj

(dt current-state args t)

exceptionclj


exec-fileclj

(exec-file indir outdir file)

Run a file on the classpath through the asciidoc parser/generator

Run a file on the classpath through the asciidoc parser/generator
raw docstring

executeclj

(execute execute-fn status-fn initial-state in out)

Parse a document on in that contains bindings, assertions, and/or operations, executing them, and writing the modified markdown into the given out. The initial-state is a map of bindings that the document can use.

Parse a document on `in` that contains bindings, assertions, and/or
operations, executing them, and writing the modified markdown into the given
`out`. The `initial-state` is a map of bindings that the document can use.
raw docstring

execute-functionclj

(execute-function current-state expected f-name f args out-name)

execute-pagesclj

(execute-pages current-state
               {:strs [indir outdir] :as args}
               {:keys [rows] :as t})

executorsclj


failclj


functionclj

(function current-state _ {:keys [raw-rows] :as t})

h->kclj


handle-execute-page-rowclj

(handle-execute-page-row indir
                         outdir
                         {:strs [File Pass Fail Result Exception] :as r})

handle-function-rowclj

(handle-function-row {:keys [current-state max-length] :as reduction}
                     [expected & rest-of-row])

noteclj


parse-boolclj

(parse-bool s__9752__auto__)

parse-dateclj

(parse-date s__9752__auto__)

parse-date*clj

(parse-date* s)

parse-doubleclj

(parse-double s__9752__auto__)

parse-floatclj

(parse-float s__9752__auto__)

parse-intclj

(parse-int s__9752__auto__)

parse-longclj

(parse-long s__9752__auto__)

parse-shortclj

(parse-short s__9752__auto__)

parse-uuidclj

(parse-uuid s__9752__auto__)

passclj


printableclj

(printable v)

process-decision-rowclj

(process-decision-row current-state f row)

process-query-rowclj

(process-query-row [expected-row actual-row])

queryclj

(query current-state args {:keys [rows] :as t})

remove-nil-valuesclj

(remove-nil-values m)

resolve-valuesclj

(resolve-values current-state m)

runclj

(run file)
(run file out-file)

Execute file. If out-file is specified, results will be written there. Otherwise they will be written to file replacing the extension with .html. AKA: README.md -> README.html

Execute `file`. If `out-file` is specified, results will be written there.
Otherwise they will be written to `file` replacing the extension with
`.html`. AKA: `README.md -> README.html`
raw docstring

safe-keywordclj

(safe-keyword s)

stringify-valuesclj

(stringify-values stringifiers m)

Given a map m, cause all its non-nil values to become strings. If any given key also is present in stringifers, then invoke the function referred to by that key on the value instead. That function must also emit a string.

If m is not a map, it is simply returned untouched.

Given a map `m`, cause all its non-nil values to become strings. If any
given key also is present in `stringifers`, then invoke the function
referred to by that key on the value instead. That function must also
emit a string.

If `m` is not a map, it is simply returned untouched.
raw docstring

tableclj

(table current-state args {:keys [raw-rows]})

table-typesclj


usensclj

(usens current-state _ {:keys [rows] :as t})

with-helper-fncljmacro

(with-helper-fn args b & body)

with-max-threadscljmacro

(with-max-threads n & body)

with-max-threads*clj

(with-max-threads* n f)

with-parallel-supportcljmacro

(with-parallel-support args b & body)

cljdoc is a website building & hosting documentation for Clojure/Script libraries

× close