pallet.script — dda/stevedore 0.9.0-beta.1

Base infrastructure for script generation, and operating system abstraction.

defscript defines an abstract script function, that can be implemented for different operating system (and version) targets.

implement is used to add an implementation to a function defined with defscript.

Dispatch of defscript is based on an implementation's specialisers vector. All elements of the specialisers vector must match *script-context*. The specialisers vector may contain keywords that match if the are in *script-context*, sets of keywords that match if any of the set values are in *script-context*, or functions that will be passed *script-context* as an argument and should return a truth value indicating whether a match occured.

Mutiple implementations may match the *script-context* vector, and the best fit is determined by the highest number of matching specialiser functions, with ties decided by the earliest defined implementation.

*script-context* clj

Determine the target to generate script for. defscript implementations are dispatched on this. The value should be a vector, containing os-family values (e.g. :ubuntu), os-family and os-version values (e.g. :centos-5.3), or other keywords.

defimpl clj/s macro

(defimpl script specialisers [& args] & body)

Define a script function implementation for the given specialisers.

specialisers should be the :default keyword, or a vector. The specialisers vector may contain keywords, a set of keywords that provide an inclusive or match, or functions that return a truth value indication whether the implementation is a match for the script template passed as the function's first argument.

body is wrapped in an implicit script form.

(pallet.script/defscript ls [& args])
(defimpl ls :default [& args] (ls ~@args))
(defimpl ls [:windows] [& args] (dir ~@args))

defscript clj/s macro

(defscript fn-name & args)

Define a top level var with an abstract script function, that can be implemented differently for different operating systems. Calls to functions defined by defscript are dispatched based on the *script-context* vector.

dispatch clj

(dispatch script args)

(dispatch script args file line)

Invoke script with the given args. The implementations of script is found based on the current *script-context* value. If no matching implementation is found, then a :no-script-implementation condition is raised.

implement clj

(implement script specialisers f)

Add an implementation of script for the given specialisers. The default implementation can be set by passing :default as the specialisers argument. specialisers should be the :default keyword, or a vector. The specialisers vector may contain keywords, a set of keywords that provide an inclusive or match, or functions that return a truth value indication whether the implementation is a match for the *script-context* passed as the function's first argument.

script-fn clj/s macro

(script-fn [& args])

(script-fn fn-name [& args])

Define an abstract script function, that can be implemented differently for different operating systems. Calls to functions defined by script-fn are dispatched based on the *script-context* vector.

script-fn* clj

(script-fn* fn-name args)

Define an abstract script function, that can be implemented differently for different operating systems. Calls to functions defined by script-fn* are dispatched based on the *script-context* vector.

with-script-context clj/s macro

(with-script-context template & body)

Specify the target for script generation. template should be a vector of os-family, os-family and os-version, or other keywords.

with-template clj/s macro deprecated

(with-template template & body)

Specify the target for script generation. template should be a vector of os-family, os-family and os-version, or other keywords. DEPRECATED - see with-script-context