You do mention the MIT license in the _oasis and opam files, but you do not embed the license's text into your source files.

I needed to copy/paste some of the source files in my code base so I added the license text as found here in them, with your full name and the year 2015. Are you okay with it?

(version: 2.1.0)

# Mustache.(render (of_string "{{foo}}") @@ `O [ "foo", `Float 3. ]);;
- : string = u"3."

Mustache uses string_of_float, which adds the trailing '.'.

The proper way to render float values is not specified in the mustache (5) manpage, but there's an example which does show an integer being rendered without decimal part, and http://trymustache.com behaves that way too.

Precise control over the formatting requires going through String values, but removing the trailing period for integer values seems sensible.

Currently mustache_cli.ml is installed as a mustache binary in the user PATH. This is a natural choice that is easy for users to guess, but it has the downside of conflicting with the binary name chosen by... any other Mustache implementation. For example, the original implementation in Ruby provides the mustache(1) command that is easy to find over the net. If you run gem install mustache, it installs a Ruby library and also a mustache binary. (When trying to compare the behavior of the two tools, I would keep uninstalling and reinstalling the Ruby tool to avoid name conflicts.)

Should one consider changing the name of the OCaml tool to avoid naming conflicts with other implementations? I'm not saying that the name should change, but I'm creating this issue to get an idea of what people (and in particular @rgrinberg) think.

Naming conflicts are maybe not much of an issue, given that most users are going to use just one tool anyway. But some systems/distributions want to avoid conflicts globally; if someone someday decided to package ocaml-mustache for Debian, then the naming clash would be an annoying issue to deal with.

My only idea for an alternative name would be mustacho, which sounds somewhat like a contraction of "mustache in OCaml", and is an alternative spelling for "mustache" in some languages (in English it exists, but "mustachio" is more commonly used; it exists in some variants of Spanish but "mostacho" is more common, etc.). (I'm afraid that camels don't have mustaches; search for this on the web led me to the Mustache Contest at the Pushkar Camel Fair, which does not bring any clear name suggestion.)

I am a newbie to Ocaml. After 2 hours searching source code and figure out types, I still have no idea how to use this library to render simple template.

Please add more example in README.md to guide some newbie like me. We are not as smart as you are.

Hi,

Currently -- (i.e. with

> george@calliope:~$ opam list | grep mustache
> mustache                      3.1.0       Mustache logic-less templates in OCaml 

)

if I do

$ mustache foo.json bar.template

then as specified in mustache_cli.ml the result is to first print_endline the content of foo.json, followed by the output of apply_mustache.

Outputting the json at the top feels a bit like a debugging step that wasn't removed, though maybe there is some reason you want to see this bit in the output? Anyhow, I happened to find a use for the tool and noticed this property. (The extra "json" actually gave me a motive to learn to use sed to snip the stuff at the top of the output -- somehow I'd always avoided sed til now! )

Anyhow, I thought I'd report the matter.

Thanks, and all the best,
george

A minimal example:

let () =
  ignore (Mustache.of_string "{{.name}}")

Which crashes with

Fatal error: exception Mustache_parser.MenhirBasics.Error

A first-level fix would be to catch this error and raise something a bit more informative (e.g., Invalid_mustache_template). A better fix would be to identify the location of the syntax error.

I'm happy to help with the first part, at least, if that would be welcome.

It would be nice to put the ocamldoc-generated docs of the API online. For that we need a make doc target, and I don't know how to do that with jbuilder.

I came across this while trying to write the following template fragment:

{{#scripts}}
<script src="{{& src}}" {{#charset}}charset="{{& charset}}">{{/charset}}</script>
{{/scripts}}

Attempting to parse this resulted in the following exception:

Mustache_types.Invalid_template("Mismatched section charset with scripts")

Example JSON:

{
  "scripts" : [
    {
      "src" : "d3.js",
      "charset" : "utf-8"
     }
  ] 
}

Hello,

I was trying to use Mustache to render a string only when it is non-null. This should essentially be the following template:

Hello
{{#key}}- The key exists: {{key}}{{/key}}
Good bye

It works as expected with the Ruby implementation of Mustache in both cases. It does not however work with the OCaml implementation in the case where key exists. I get Mustache_types.Invalid_param("str. not an object").

My guess is that Mustache is happy with the test {{#key}} and puts the JSON for key in the context. When later rendering {{key}} it fails because the context is not an object. It's actually a bit more than a guess:

In render_fmt, when rendering sections, we have:

where add_context is:

which means that when ctx is not an object, the context becomes this non-object. And when we try to render something afterwards, we have a failure. I would rather have something like:

    let add_context ctx js =
      match (ctx, js) with
      | `O ctx_o, `O js_o -> `O (ctx_o @ js_o)
      | _, `O _ -> js
      | _, _ -> ctx
    in

Does that seem reasonable to you?

Currently mustache utility supports only JSON format. But according to https://mustache.github.io/mustache.1.html this needs to be YAML.

It would be nice if we had a new Mustache release; currently I write code with mustache pinned on master, but this makes distributing the resulting software awkward.

In an ideal world, we would have found time to solve #61, #66 and maybe even #40 before the next release.
In practice we are all very busy, and having a release in the current state would be strictly more convenient (for me) than no release at all.

(If someone, presumably @rgrinberg, is willing to take care of the release, and has a small amount of time to look at some of those issues, I would suggest maybe trying to merge #66 (package split), using mustache-ocaml (my best suggestion in #61) as the binary name, squashing those two issues at once. Then we can discuss #40 on its own terms, independently of the release schedule; it sounds like more work.)

See output:

$ make doc
dune build @doc
File "lib/mustache.mli", line 79, character 4 to line 80, character 65:
Warning: '{| try ignore (Mustache.of_string "{{!") with Mustache.Parse_error err ->
    Format.eprintf "%a@." Mustache.pp_template_parse_error err |}': bad markup.
Suggestion: did you mean '{!| try ignore (Mustache.of_string "{{!") with Mustache.Parse_error err ->
    Format.eprintf "%a@." Mustache.pp_template_parse_error err |}' or '[| try ignore (Mustache.of_string "{{!") with Mustache.Parse_error err ->
    Format.eprintf "%a@." Mustache.pp_template_parse_error err |]'?

The delimiters for the ocaml code here are not expected by odoc-parser, {[ and ]} should be used instead

I do not understand what is sexplib used for.

Could not it be removed?