The test named test-render-with-dollar-sign is currently failing on version 1.4.0

(= "Hello, $Felix!" (render "Hello, {{! This is a comment.}}{{name}}!"
                            {:name "$Felix"}))
; => false

(render "Hello, {{! This is a comment.}}{{name}}!"
        {:name "$Felix"})
; => "Hello, \\$Felix!"

Eg 1:

(clostache.parser/render "{{Currency}} {{Price}}" {:Currency "$" :Price 230})

Output:

"\\$ 230"

Expected:

"$ 230"

Eg 2:

(clostache.parser/render "{{Currency}} {{Price}}" {:Currency "USD$" :Price 230})

Output:

"USD\\$ 230"

Expected:

"USD$ 230"

The unit test fail with current Clojure 1.6. It looks like a change between 1.4 and 1.5 broke the escaping of backslashes in the code. Maybe something related to the handling of regular expressions?

% perl -i -pe 's/1\.3\.0/1.6.0/g;' project.clj && lein test
WARNING: :warn-on-reflection is deprecated in project.clj; use :global-vars.
Reflection warning, clojure/core/incubator.clj:84:7 - reference to field getClass can't be resolved.
Reflection warning, clojure/core/incubator.clj:84:7 - reference to field isArray can't be resolved.

lein test clostache.test-parser

lein test :only clostache.test-parser/test-render-html-unescaped

FAIL in (test-render-html-unescaped) (test_parser.clj:22)
expected: (= "&\\\"<>" (render "{{{string}}}" {:string "&\\\"<>"}))
  actual: (not (= "&\\\"<>" "&\\\\\"<>"))

lein test :only clostache.test-parser/test-render-with-dollar-sign

FAIL in (test-render-with-dollar-sign) (test_parser.clj:9)
expected: (= "Hello, $Felix!" (render "Hello, {{! This is a comment.}}{{name}}!" {:name "$Felix"}))
  actual: (not (= "Hello, $Felix!" "Hello, \\$Felix!"))

lein test clostache.test-specs

Ran 42 tests containing 163 assertions.
2 failures, 0 errors.
Tests failed.

I'm trying to use clostache to insert values into a latex template. I've changed the set delimeters to <% %> because {{ occurs in latex. However, I ran into a case where I have a template like the following:

\name{<% name %>}

The resulting template (when name is "Foo") is:

\nameFoo

I looked at the code, and this seems to be a result of process-set-delimiters replacing instances of the chosen delimiters with {{ and }}, so in my example, after process-set-delimiters, template becomes:

\name{{{ name }}}

And because mustache uses {{{ as a delimiter for unescaped insertion, this is a problem. I've tested this using mustache from the command-line, and there it works as expected.

Here's a failing test case:

(deftest test-set-delimiters-with-curly-braces
  (is (= (render "{{=<% %>=}}\n{<% foo %>}" {:foo "bar"}) "{bar}")))

I looked at the code, but sadly, I'm very new to clojure and so I'm a little lost as to how to proceed to resolve this situation. If you could give me any pointers as to how this might be solved, I'll be glad to make an attempt at it.

Thanks!

https://github.com/mustache/spec

Having

(clostache.parser/render "{{variable}} does not exist" {})

renders as

"{{variable}} does not exist"

and it should render as

" does not exist"

according to the spec.

We're running into a bit of a licensing issue which I'm hoping could be solved. Most clojure dependencies are distributed under EPL rather LGPL. One of the finer points of EPL is you can create closed-source applications that use your library. The LGPL requires you distribute your library SxS for dynamic relinking should someone want to swap versions.

On some level this doesn't really matter for clostache itself - clostache is Clojure only. Jars let you do the above pretty easily. If you just use clostache server-side without giving users software binaries, there aren't any disclosure requirements to your end users.

The rough part is cljstache - the clojurescript fork of clostache. Given the way clojurescript compiles code (under advanced compilation), making a library dynamically linkable is extremely difficult. It's not really a design goal for most javascript.

I know this might be a long shot, but would this project consider re-licensing it's code under the EPL? There's only about 15 contributors so it might be doable. The license is extremely similar but allows for unmodified closed-source use.

My template is rendered without some special language symbols. Does it support UTF-8?

The doc section about implicit iterators lists the opening tag as {#names}} when it should be {{#names}}.

It's a nit, but it seemed worth mentioning.

Hello there,

Given this data:
{:format #(format-date %)}
{:user {:created-at (now)}}

And this template:
{{#format}}{{user.created-at}}{{/format}}

The "format-date" function receives {{#user}}{{created-at}}{{/user}}.

Is this expected behavior? Shouldn't the parser parse the expressions inside out?

I am using a simple guava based caching implementation for avoiding IO to load templates on each request. (Sample: https://github.com/Rcmmndr/rcmmndr-clojure-sample/tree/master/src/rcmmndr)
Do you think that this is worth to be integrated into clostache? I have put this feature inside a sample webapp now but i can fork and add to the codebase if this seems reasonable. What do you think?

Cheers

From the mustache manual:

When the value is a callable object, such as a function or lambda, the object will be invoked and passed the block of text. The text passed is the literal block, unrendered. {{tags}} will not have been expanded - the lambda should do that on its own. In this way you can implement filters or caching.

After looking at the code appears that if a section is a function we apply it to the body

(if (fn? section-data) 
  (section-data (:body section))
   ...)

Which means there is no way for the lambda to render that text. Perhaps like the javascript mustache implementation a additional parameter should be passed into the lambda (https://github.com/janl/mustache.js#functions) for use in rendering the section contents if necessary.

An example:

(def template "{{#people}}Hi {{#upper}}{{name}}{{/upper}} {{/people}}")

(def data 
  {:people [{:name "Tom"}, {:name "Bob"}] 
   :upper (fn [text render-fn] (clojure.string/upper-case (render-fn text)))})

(render template data)
=> "Hi TOM Hi BOB"

Hi there 👋

I've hit an issue where a call to render never returns: (Using [cljstache "2.0.1"])

user=> (require 'cljstache.core)
nil
user=> (cljstache.core/render "{{ foo }}" {:foo "{{ foo }}"})
"{{ foo }}" ;; This works OK
user=> (cljstache.core/render "{{ foo.a }}" {:foo {:a "{{ foo.a }}"}})
;; This never returns

https://clojure.org/reference/java_interop#typehints (last paragraph)

https://gist.github.com/pjstadig/6fa4ebf465f6d438b4dcc2a5bfbb3db6

Hi the corrected snippet is:
(render "Hello, {{name}}!" {:name "Felix"})

You can (ab)use sections and {{.}} to conditionally include passages like this in mustache:

Template: {{#foo}}quox: {{.}}{{/foo}}
Data (JSON): {"foo": "bar"}
Output: quox: bar

This does not work in clostache:

(render "{{#foo}}quox: {{.}}{{/foo}}" {:foo "bar"})
;=> "quox: bquox: aquox: r"

If this is not going to be addressed anytime soon, is there another way to achieve conditionals without nesting data? I want to fill a template with data from a CSV file, which is necessarily flat, so I can't just use the more reasonable {:foo {:value "bar"}} and {{#foo}} {{value}} {{/foo}}.

I would like to be able to pass a function that takes a partial name and returns the template, instead of a map of names to partial templates. Using a memoized function would enable lazy loading of partial resources rather than having to load every partial that a template may use ahead of time.

Hi,

having Clostache in the dependecy chain causes the following warning to be printed:

WARNING: seqable? already refers to: #'clojure.core/seqable? in namespace: clostache.parser, being replaced by: #'clojure.core.incubator/seqable?

It can be fixed by simply replacing :use with :require - particularly when :use was already using its most conservative variant (:only).

As a further hint, there's https://github.com/bbatsov/clojure-style-guide/tree/e3be6b321447939371f2318e620a281ef4367a58#prefer-require-over-use

Thanks!

-V

Imagine you're working on

(render "{{#x}}0{{/x}}" { :x "hello" })

This prints "XXXXX". I'm inclined to think that it should print "X", and I imagine the equivalent code does in ruby (don't have it to hand). I'll send through a pull if we agree it's a bug.

(render "{{@data}}" {:data "test"}) yields an empty string instead of "test". Tested with Clojure 1.7.0.

In particular, at the moment it's not possible to render sorted-maps, which is actually pretty useful.

(def l [{:x 1} {:x 5} {:x 3}])
(def l2 (apply sorted-set-by #(compare (:x %1) (:x %2)) l))

(clostache.parser/render "{{#y}}{{x}}{{/y}}" {:y l})
; "153"
(clostache.parser/render "{{#y}}{{x}}{{/y}}" {:y l2})
; "", should have been "135"

Hope you agree this needs fixing. Will try to put together a patch for it myself.

See #45.

(render "{{hotels.tripadvisor.popularity-rank}}"
        {:hotels {:tripadvisor {:popularity-rank 12}}})
=>"12"

But

(render "{{#hotels}}{{tripadvisor.popularity-rank}}{{/hotels}}"
        {:hotels [{:tripadvisor {:popularity-rank 12}}]})
=> ""

Hi Felix,

Thanks for making clostache, I've really enjoyed using it!

While tracking down a bug in my code, I realized that partials on their own lines don't save the newline at the end of partial, instead replacing it with whatever the partial contains, and looking through the clostache source, I found join-standalone-tags, which seemed the likely source of this behavior.

The commit messages for that function didn't give a lot of context for why this change was made, but it looks like this no longer follows the mustache spec for partials, which I found here. The overview of the partials spec doesn't define how to handle newlines at the EOL in the case of standalone partials, however, the test for the spec -- line 54 -- shows it as keeping the newlines at the end of standalone partials.

Is this the desired behavior for partials in clostache?

Thank you,
Evan

It looks like both render and render-resource require a data map. Would it be possible to add an additional function overload to allow one to exclude the data map, if it's not used?

I'll happily write this and send a pull request. At the moment, my plan is to

1. allow you to specify a string as a partial, in which case it is interpreted as a clostache template
2. allow you to specify a function, in which case it is invoked and assumed to return HTML.

My principal reason for wanting to do this is to handle small nasty pieces of code where hiccup is a better fit, but you could use it to mix and match template engines as well.

I render e-mails content and i have signature on the end of e-mails. I can use partials as {{>siganture}}but i feel it is not the right way. I can also use my own function {{#include}}signature{{/include}} to load another file. But i guess it is something common and should be something to include file as standard. What do you think about that?

If you try to iterate over a collection:
{{#things}} {{id}} {{/things}}
But things happens to be a set, nothing gets rendered.

https://github.com/davidsantiago/stencil/ which is used in Leiningen?