mstch is a complete implementation of {{mustache}} templates using modern C++. It's compliant with specifications v1.4.2, including the lambda module.
mstch supports the complete feature set described in the mustache(5) manpage:
- JSON-like data structure using standard C++ types
- variables, sections, inverted sections
- partials
- changing the delimiter
- C++ lambdas
- C++ objects as view models
#include <iostream>
#include <mstch/mstch.hpp>
int main() {
std::string view{"{{#names}}Hi {{name}}!\n{{/names}}"};
mstch::map context{
{"names", mstch::array{
mstch::map{{"name", std::string{"Chris"}}},
mstch::map{{"name", std::string{"Mark"}}},
mstch::map{{"name", std::string{"Scott"}}},
}}
};
std::cout << mstch::render(view, context) << std::endl;
return 0;
}
The output of this example will be:
Hi Chris!
Hi Mark!
Hi Scott!The types in the example above, mstch::array and mstch::map are actually
aliases for standard types:
using map = std::map<const std::string, node>;
using array = std::vector<node>;mstch::node is a std::variant type that can hold a std::string, int,
double, bool, mstch::lambda or a std::shared_ptr<mstch::object>
(see below), also a map or an array recursively. Essentially it works just like
a JSON object.
Note that when using a std::string as value you must explicitly specify the
type, since a const char* literal like "foobar" would be implicitly
converted to bool. Alternatively you can use C++14 string_literals
if your compiler supports it.
Partials can be passed in a std::map as the third parameter of the
mstch::render function:
std::string view{"{{#names}}{{> user}}{{/names}}"};
std::string user_view{"<strong>{{name}}\n</strong>"};
mstch::map context{
{"names", mstch::array{
mstch::map{{"name", std::string{"Chris"}}},
mstch::map{{"name", std::string{"Mark"}}},
mstch::map{{"name", std::string{"Scott"}}},
}}
};
std::cout << mstch::render(view, context, {{"user", user_view}}) << std::endl;Output:
<strong>Chris</strong>
<strong>Mark</strong>
<strong>Scott</strong>C++ lambdas can be used to add logic to your templates. Like a
const char* literal, lambdas can be implicitly converted to bool, so they
must be wrapped in a mstch::lambda object when used in a mstch::node. The
lambda expression passed to mstch::lambda must itself return a mstch::node.
The returned node will be rendered to a string, then it will be parsed as a
template.
The lambda expression accepts either no parameters:
std::string view{"Hello {{lambda}}!"};
mstch::map context{
{"lambda", mstch::lambda{[]() -> mstch::node {
return std::string{"World"};
}}}
};
std::cout << mstch::render(view, context) << std::endl;Output:
Hello World!Or it accepts a const std::string& that gets the unrendered literal block:
std::string view{"{{#bold}}{{yay}} :){{/bold}}"};
mstch::map context{
{"yay", std::string{"Yay!"}},
{"bold", mstch::lambda{[](const std::string& text) -> mstch::node {
return "<b>" + text + "</b>";
}}}
};
std::cout << mstch::render(view, context) << std::endl;Output:
<b>Yay! :)</b>Custom objects can also be used as context for rendering templates. The class
must inherit from mstch::object, and register it's exported methods with
register_methods. Exported methods must have the return type of mstch::node.
Objects must be created as a std::shared_ptr.
class example: public mstch::object {
public:
example(): m_value(1) {
register_methods(this, {
{"count", &example::count},
{"names", &example::names}
});
}
mstch::node count() {
return m_value++;
}
mstch::node names() {
return mstch::array{
std::string{"Chris"}, std::string{"Mark"}, std::string{"Scott"}};
}
private:
int m_value;
};
std::string view{"{{#names}}<b>{{count}}</b>: {{.}}\n{{/names}}"};
const auto context = std::make_shared<example>();
std::cout << mstch::render(view, context) << std::endl;Output:
<b>1</b>: Chris
<b>2</b>: Mark
<b>3</b>: ScottBy default, mstch uses HTML escaping on the output, as per specification. This
is not useful if your output is not HTML, so mstch provides a way to supply
your own escape implementation. Just assign any callable object to the static
mstch::config::escape, which is an initially empty
std::function<std::string(const std::string&)>.
For example you can turn off escaping entirely with a lambda:
mstch::config::escape = [](const std::string& str) -> std::string {
return str;
};- A C++17 compliant compiler. Currently tested with:
- GCC 7.0+
- Clang 5.0+
- MSVC 2017+
- Bazel 7.0+ for building
If you are using Bazel, you can include mstch in your project by adding it as a dependency in your MODULE.bazel file:
bazel_dep(name = "mstch", version = "2.0.0")Then in your BUILD file:
cc_library(
name = "your_library",
deps = ["@mstch//:mstch"],
)To build the library and run tests:
# Build the library
bazel build //:mstch
# Run tests
bazel test //:mstch_test
# Run benchmarks
bazel run //:benchmarkThe project includes Google Benchmark for performance testing. To run the benchmarks:
# Run with optimizations enabled
bazel build -c opt //:benchmark
./bazel-bin/benchmark --benchmark_repetitions=5 --benchmark_report_aggregates_only=trueThe benchmarks will provide detailed timing information for various template operations.
mstch is licensed under the MIT license.