code.test.compile.snippet — xyz.zcaudate/code.test 4.0.5

fact-declare clj

(fact-declare m)

creates a declare hook

fact-let-declare clj

(fact-let-declare m)

creates let declarations

(fact-let-declare '{:let [a 1 b 2 c 3] :use [serv]}) => '[(def a nil) (def b nil) (def c nil) (def serv nil)]

fact-let-defs clj

(fact-let-defs m)

create def forms for symbols

(fact-let-defs '{:let [a 1 b 2]}) => '[(def a 1) (def b 2)]

fact-setup clj

(fact-setup m)

creates a setup hook

fact-slim clj

(fact-slim bare)

creates the slim thunk

(fact-slim '[(+ a b)])

fact-teardown clj

(fact-teardown m)

creates a teardown hook

fact-use clj

(fact-use vsym ks)

setup form for use (with component)

fact-use-setup clj

(fact-use-setup vsym)

setup form for 'use'

(fact-use-setup 'serv) => '(start (list :database))

fact-use-setup-eval clj

(fact-use-setup-eval vsym)

setup form form eval

(fact-use-setup-eval 'serv) => '(list :database)

fact-use-teardown clj

(fact-use-teardown vsym)

teardown form for 'use'

(fact-use-teardown 'serv) => '(clojure.core/identity serv)

fact-wrap-bindings clj

(fact-wrap-bindings m)

creates a wrapper for bindings

(fact-wrap-bindings '{:let [a 1 b (+ a 1)]})

fact-wrap-ceremony clj

(fact-wrap-ceremony {:keys [setup teardown guard] :as m})

creates the setup/teardown wrapper

(fact-wrap-ceremony '{:setup [(prn 1 2 3)] :teardown (prn "goodbye")})

fact-wrap-check clj

(fact-wrap-check {:keys [check guard] :as m})

creates a wrapper for before and after arrows

fact-wrap-replace clj

(fact-wrap-replace m)

creates a replace wrapper

(fact-wrap-replace '{:use [serv] :let [a 1 b 2] :replace {+ -}})

replace-bindings clj

(replace-bindings old new)

replaces values of current bindings

(replace-bindings '[a 1 b 2 c 3] '[b 4]) => '[a 1 b 4 c 3]

vecify clj

(vecify obj)

puts the item in a vector if not already

(vecify 1) => [1]

wrap-bindings clj

(wrap-bindings form bindings)

wraps the form in bindings

(wrap-bindings '(+ a b) '[a 1 b (+ a 1)]) => '(clojure.core/binding [a 1] (clojure.core/binding [b (+ a 1)] (+ a b)))