itl.core — coreagile/itl 1.0.1

->out clj

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

-h->k clj

(-h->k ks)

assert-cell clj

(assert-cell r n expected actual)

assert-value clj

(assert-value expected actual)

(assert-value current-state expected actual)

balance-row clj

(balance-row desired-length row)

bdt clj

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

cell-value clj

(cell-value current-state v)

decision-table clj

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

defparser clj macro

(defparser n f)

deftfn clj macro

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

dt clj

(dt current-state args t)

exception clj

exec-file clj

(exec-file indir outdir file)

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

execute clj

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

execute-function clj

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

execute-pages clj

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

executors clj

fail clj

function clj

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

h->k clj

handle-execute-page-row clj

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

handle-function-row clj

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

note clj

parse-bool clj

(parse-bool s__9752__auto__)

parse-date clj

(parse-date s__9752__auto__)

parse-date* clj

(parse-date* s)

parse-double clj

(parse-double s__9752__auto__)

parse-float clj

(parse-float s__9752__auto__)

parse-int clj

(parse-int s__9752__auto__)

parse-long clj

(parse-long s__9752__auto__)

parse-short clj

(parse-short s__9752__auto__)

parse-uuid clj

(parse-uuid s__9752__auto__)

pass clj

printable clj

(printable v)

process-decision-row clj

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

process-query-row clj

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

query clj

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

remove-nil-values clj

(remove-nil-values m)

resolve-values clj

(resolve-values current-state m)

run clj

(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

safe-keyword clj

(safe-keyword s)

stringify-values clj

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

table clj

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

table-types clj

usens clj

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

with-helper-fn clj macro

(with-helper-fn args b & body)

with-max-threads clj macro

(with-max-threads n & body)

with-max-threads* clj

(with-max-threads* n f)

with-parallel-support clj macro

(with-parallel-support args b & body)