selmer.parser — selmer 1.12.44

Parsing and handling of compile-time vs. run-time. Avoiding unnecessary work by pre-processing the template structure and content and reacting to the runtime context map with a prepared data structure instead of a raw template. Anything other than a raw tag value injection is a runtime dispatch fn. Compile-time here means the first time we see a template at runtime, not the implementation's compile-time.

<< clj macro

(<< s)

Resolves the variables from your template string from the local-env, or the namespace and puts them into your template for you.

e.g. (let [a 1] (<< "{{a}} + {{a}} = 2")) ;;=> "1 + 1 = 2"

add-node clj

(add-node template buf rdr)

add-tag! clj macro

(add-tag! k handler & tags)

tag name, fn handler, and maybe tags

append-node clj

(append-node content tag buf rdr)

cache-off! clj

(cache-off!)

cache-on! clj

(cache-on!)

cache? clj

ensure-list clj

(ensure-list list-maybe)

Turns the argument into a list if it isn't a list already.

expr-tag clj

(expr-tag {:keys [tag-name args]} rdr)

filter-tag clj

(filter-tag {:keys [tag-value]})

Compile-time parser of var tag filters.

known-variables clj

(known-variables input)

parse clj

(parse parse-fn
       input
       &
       [{:keys [tag-open tag-close filter-open filter-close tag-second
                short-comment-second]
         :or {tag-open *tag-open*
              tag-close *tag-close*
              filter-open *filter-open*
              filter-close *filter-close*
              tag-second *tag-second*
              short-comment-second *short-comment-second*}
         :as params}])

parse* clj

(parse* input)

parse-file clj

(parse-file file params)

parse-input clj

(parse-input input & [{:keys [custom-tags custom-filters]}])

parse-tag clj

(parse-tag {:keys [tag-type] :as tag} rdr)

remove-tag! clj

(remove-tag! k)

render clj

(render s context-map & [opts])

render takes the string, the context-map and possibly also opts.

render-file clj

(render-file filename-or-url
             context-map
             &
             [{:keys [cache custom-resource-path url-stream-handler]
               :or {cache (clojure.core/deref cache?)
                    custom-resource-path *custom-resource-path*
                    url-stream-handler *url-stream-handler*}
               :as opts}])

Parses files if there isn't a memoized post-parse vector ready to go, renders post-parse vector with passed context-map regardless. Double-checks last-modified on files. Uses classpath for filename-or-url path

render-template clj

(render-template template context-map)

vector of ^selmer.node.INodes and a context map.

set-closing-tags! clj

(set-closing-tags! & tags)

set-resource-path! clj

(set-resource-path! path)

set custom location, where templates are being searched for. path may be a java.net.URL instance or a string. If it's a string, we first try to convert it to a java.net.URL instance and if it doesn't work it's interpreted as a path in the local filesystem.

skip-short-comment-tag clj

(skip-short-comment-tag rdr)

tag-content clj

(tag-content rdr start-tag & end-tags)

Parses the content of a tag. Returns a map of tag-name -> args & content, which can then be interpreted by the calling function.

templates clj

update-tag clj

(update-tag tag-map tag tags)

update-tags clj

(update-tags tag tags content args buf)

Assocs in the passed tag to the tags map.