As far as I can tell, this implementation doesn't follow the Mustache spec when it comes to trimming lines that only contain tags (and whitespace).

Any reason why you're not testing against the official spec tests?

In my case it would be far more convenient to use an existing function for looking up the values of variables embedded in Mustache templates, but this doesn't currently possible and all variables and partials need to be defined beforehand. This is especially annoying for the latter, as partials are basically just files, so they need to be read from disk and provided as part of the data, even if they end up not being used at all by the current template.

So I'd basically like to be able to provide my own Context and override its get() method. I realize that it's not completely trivial because it would need to be refactored to separate push/pop() and get() methods, but it would be nice to be able to do this.

I think it would be particularly useful if there was a way to set what the tag delimiters were on the mustache object directly.

Example:

mustache tmpl{"Hello <%%what%%>!"};

tmpl.set_delimiters("<%% %%>");
std::cout << tmpl.render({"what", "World"}) << std::endl;

this MR improves the usage of this library in the context of a cmake based project.

this MR adds the needed patches to install the header file as well as cmake files which can be used to do find_package by consumer projects

Take the following example:

 kainjow::mustache::mustache tmpl{
 "It is true that {{#wrapped}}{{name}} is awesome.{{/wrapped}}"};

 kainjow::mustache::data data;
 data["name"] = "Willy";
 data["wrapped"] = kainjow::mustache::lambda2{
 [](const std::string& text, const kainjow::mustache::renderer& render) {
    const auto renderedText = render(text);
    return "<b>" + renderedText + "</b>";
  }};

Here, we'd expect the output of rendering the template to be: "It is true that <b>Willy is awesome.</b>"

Instead we get: "<b>It is true that Willy is awesome.</b>"

What's also interesting is that the pre-lambda text is only rendered for the first time render is called within the lambda:

kainjow::mustache::data data;
data["name"] = "Willy";
data["wrapped"] = kainjow::mustache::lambda2{
  [](const std::string& text, const kainjow::mustache::renderer& render) {
   const auto& pre_lambda_text = render("");
    const auto& renderedText = render(text);
    return pre_lambda_text + "`<b>`" + renderedText + "`</b>`";
  }};

The above actually produces the output we desire, but the issue is that the lambda should not capture text outside of the wrapping tags.

I was wondering if your parsing is really compile-time? If not, then you may want to consider to use constexpr for example or other ways to make sure of it is since the mustache syntax won't change during runtime (obviously).

You may also consider using the excellent and insanely fast header-only fmt lib (soon in C++20), that would be awesome then I won't have to convert strings all the time with my code. https://github.com/fmtlib/fmt

Example of a compile-time regex lib: https://github.com/hanickadot/compile-time-regular-expressions

If the template contains dangling open tags, there will be no output (note, this works with https://github.com/no1msd/mstch).

Example:

int main()
{
    mustache tmpl{"Hello {{what}}! {{"};

    std::cout << "Rendered: " << tmpl.render({"what", "there"}) << std::endl;

    return 0;
}

Output: Rendered:

Expected: Rendered: Hello there! {{

It would be nice to have a mustache version available in the code. (It is currently present in the comments but it is not easy to use/parse).

Something like #define MUSTACHE_VERSION "4.1"

It would allow build script to check the mustache version at configure step. For example, using meson syntax (not tested) :

compiler = meson.get_compiler('cpp')
if not compiler.check_header('mustache.hpp')
  error("Cannot find mustache")
endif
result = compiler.run("#include <iostream>\n#include <mustache.hpp>\nint main() { std::cout << MUSTACHE_VERSION << std::endl; }")
mustache_version = result.stdout()
if not mustache_version.version_compare(">=4.1")
  error("Mustache is too old")
endif

Hi! I made those changes on my own fork and you might be interested.

• I'm using more modern CMake when possible. This reduce CMake code to write when using Mustache and CMake, just have to specify Mustache as dependency and the correct directory should be known and C++17 is enabled as well.
• I renamed the executable generated by the test target to make it obvious this executable is a test.

I'm trying to use the {{>filename}} mustache syntax but it always results in a blank in the generated output. Reading the test code in this repository I seem to understand that I need to register all the filenames beforehand, for example:

    dat["filename"] = partial([](){
        std::ifstream all_data("filename.mstch");
        all_data >> std::noskipws;
        return std::string(
            std::istream_iterator<uint8_t>(all_data),
            std::istream_iterator<uint8_t>()
        );
    };

While it's fine with me to provide such a function, I don't see how I could foresee all the possible filenames the end user could come up with. How can I deal with the generic case of users wanting to do {{>filename}} one day and {{>donaldduck}} the next?

make install does not work.

https://github.com/kiwix/kiwix-lib/ says

Just copy the header mustache.hpp somewhere it can be found by the compiler and/or set CPPFLAGS with correct '-I' option

but I find that much more complicated than just running make install and be done with it.

Is there a reason (other than the project being designed for older C++ versions) that basic_data isn't std::variant or at least implemented a bit like std::variant? Why so many unique_ptrs laying around?

private:
    type type_;
    std::unique_ptr<basic_object<string_type>> obj_;
    std::unique_ptr<string_type> str_;
    std::unique_ptr<basic_list<string_type>> list_;
    std::unique_ptr<basic_partial<string_type>> partial_;
    std::unique_ptr<basic_lambda_t<string_type>> lambda_;