837 lines
27 KiB
C++
837 lines
27 KiB
C++
//
|
|
// Copyright 2015 Kevin Wojniak
|
|
//
|
|
// Boost Software License - Version 1.0 - August 17th, 2003
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person or organization
|
|
// obtaining a copy of the software and accompanying documentation covered by
|
|
// this license (the "Software") to use, reproduce, display, distribute,
|
|
// execute, and transmit the Software, and to prepare derivative works of the
|
|
// Software, and to permit third-parties to whom the Software is furnished to
|
|
// do so, all subject to the following:
|
|
//
|
|
// The copyright notices in the Software and this entire statement, including
|
|
// the above license grant, this restriction and the following disclaimer,
|
|
// must be included in all copies of the Software, in whole or in part, and
|
|
// all derivative works of the Software, unless such copies or derivative
|
|
// works are solely in the form of machine-executable object code generated by
|
|
// a source language processor.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
|
|
// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
|
|
// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
|
|
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
// DEALINGS IN THE SOFTWARE.
|
|
//
|
|
|
|
#ifndef MUSTACHE_HPP
|
|
#define MUSTACHE_HPP
|
|
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <vector>
|
|
#include <functional>
|
|
#include <unordered_map>
|
|
#include <memory>
|
|
|
|
namespace Mustache {
|
|
|
|
template <typename StringType>
|
|
StringType trim(const StringType& s) {
|
|
auto it = s.begin();
|
|
while (it != s.end() && isspace(static_cast<int>(*it))) {
|
|
it++;
|
|
}
|
|
auto rit = s.rbegin();
|
|
while (rit.base() != it && isspace(*rit)) {
|
|
rit++;
|
|
}
|
|
return {it, rit.base()};
|
|
}
|
|
|
|
template <typename StringType>
|
|
StringType escape(const StringType& s) {
|
|
StringType ret;
|
|
ret.reserve(s.size()*2);
|
|
for (const auto ch : s) {
|
|
switch (static_cast<char>(ch)) {
|
|
case '&':
|
|
ret.append("&");
|
|
break;
|
|
case '<':
|
|
ret.append("<");
|
|
break;
|
|
case '>':
|
|
ret.append(">");
|
|
break;
|
|
case '\"':
|
|
ret.append(""");
|
|
break;
|
|
case '\'':
|
|
ret.append("'");
|
|
break;
|
|
default:
|
|
ret.append(1, ch);
|
|
break;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
template <typename StringType>
|
|
class Data {
|
|
public:
|
|
enum class Type {
|
|
Object,
|
|
String,
|
|
List,
|
|
True,
|
|
False,
|
|
Partial,
|
|
Lambda,
|
|
Invalid,
|
|
};
|
|
|
|
using ObjectType = std::unordered_map<StringType, Data>;
|
|
using ListType = std::vector<Data>;
|
|
using PartialType = std::function<StringType()>;
|
|
using LambdaType = std::function<Data(const StringType&)>;
|
|
|
|
// Construction
|
|
Data() : Data(Type::Object) {
|
|
}
|
|
Data(const StringType& string) : type_{Type::String} {
|
|
str_.reset(new StringType(string));
|
|
}
|
|
Data(const typename StringType::value_type* string) : type_{Type::String} {
|
|
str_.reset(new StringType(string));
|
|
}
|
|
Data(const ListType& list) : type_{Type::List} {
|
|
list_.reset(new ListType(list));
|
|
}
|
|
Data(Type type) : type_{type} {
|
|
switch (type_) {
|
|
case Type::Object:
|
|
obj_.reset(new ObjectType);
|
|
break;
|
|
case Type::String:
|
|
str_.reset(new StringType);
|
|
break;
|
|
case Type::List:
|
|
list_.reset(new ListType);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
Data(const StringType& name, const Data& var) : Data{} {
|
|
set(name, var);
|
|
}
|
|
Data(const PartialType& partial) : type_{Type::Partial} {
|
|
partial_.reset(new PartialType(partial));
|
|
}
|
|
Data(const LambdaType& lambda) : type_{Type::Lambda} {
|
|
lambda_.reset(new LambdaType(lambda));
|
|
}
|
|
static Data List() {
|
|
return {Data::Type::List};
|
|
}
|
|
|
|
// Copying
|
|
Data(const Data& data) : type_(data.type_) {
|
|
if (data.obj_) {
|
|
obj_.reset(new ObjectType(*data.obj_));
|
|
} else if (data.str_) {
|
|
str_.reset(new StringType(*data.str_));
|
|
} else if (data.list_) {
|
|
list_.reset(new ListType(*data.list_));
|
|
} else if (data.partial_) {
|
|
partial_.reset(new PartialType(*data.partial_));
|
|
} else if (data.lambda_) {
|
|
lambda_.reset(new LambdaType(*data.lambda_));
|
|
}
|
|
}
|
|
|
|
// Assignment
|
|
Data& operator= (const Data& data) {
|
|
if (&data != this) {
|
|
type_ = data.type_;
|
|
obj_.reset();
|
|
str_.reset();
|
|
list_.reset();
|
|
partial_.reset();
|
|
lambda_.reset();
|
|
if (data.obj_) {
|
|
obj_.reset(new ObjectType(*data.obj_));
|
|
} else if (data.str_) {
|
|
str_.reset(new StringType(*data.str_));
|
|
} else if (data.list_) {
|
|
list_.reset(new ListType(*data.list_));
|
|
} else if (data.partial_) {
|
|
partial_.reset(new PartialType(*data.partial_));
|
|
} else if (data.lambda_) {
|
|
lambda_.reset(new LambdaType(*data.lambda_));
|
|
}
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
// Move
|
|
Data(Data&& data) : type_{data.type_} {
|
|
if (data.obj_) {
|
|
obj_ = std::move(data.obj_);
|
|
} else if (data.str_) {
|
|
str_ = std::move(data.str_);
|
|
} else if (data.list_) {
|
|
list_ = std::move(data.list_);
|
|
} else if (data.partial_) {
|
|
partial_ = std::move(data.partial_);
|
|
} else if (data.lambda_) {
|
|
lambda_ = std::move(data.lambda_);
|
|
}
|
|
data.type_ = Data::Type::Invalid;
|
|
}
|
|
Data& operator= (Data&& data) {
|
|
if (this != &data) {
|
|
obj_.reset();
|
|
str_.reset();
|
|
list_.reset();
|
|
partial_.reset();
|
|
lambda_.reset();
|
|
if (data.obj_) {
|
|
obj_ = std::move(data.obj_);
|
|
} else if (data.str_) {
|
|
str_ = std::move(data.str_);
|
|
} else if (data.list_) {
|
|
list_ = std::move(data.list_);
|
|
} else if (data.partial_) {
|
|
partial_ = std::move(data.partial_);
|
|
} else if (data.lambda_) {
|
|
lambda_ = std::move(data.lambda_);
|
|
}
|
|
type_ = data.type_;
|
|
data.type_ = Data::Type::Invalid;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
// Type info
|
|
Type type() const {
|
|
return type_;
|
|
}
|
|
bool isObject() const {
|
|
return type_ == Type::Object;
|
|
}
|
|
bool isString() const {
|
|
return type_ == Type::String;
|
|
}
|
|
bool isList() const {
|
|
return type_ == Type::List;
|
|
}
|
|
bool isBool() const {
|
|
return type_ == Type::True || type_ == Type::False;
|
|
}
|
|
bool isTrue() const {
|
|
return type_ == Type::True;
|
|
}
|
|
bool isFalse() const {
|
|
return type_ == Type::False;
|
|
}
|
|
bool isPartial() const {
|
|
return type_ == Type::Partial;
|
|
}
|
|
bool isLambda() const {
|
|
return type_ == Type::Lambda;
|
|
}
|
|
|
|
// Object data
|
|
void set(const StringType& name, const Data& var) {
|
|
if (isObject()) {
|
|
obj_->insert(std::pair<StringType,Data>{name, var});
|
|
}
|
|
}
|
|
bool exists(const StringType& name) const {
|
|
if (isObject() && obj_->find(name) == obj_->end()) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
const Data* get(const StringType& name) const {
|
|
if (!isObject()) {
|
|
return nullptr;
|
|
}
|
|
const auto& it = obj_->find(name);
|
|
if (it == obj_->end()) {
|
|
return nullptr;
|
|
}
|
|
return &it->second;
|
|
}
|
|
|
|
// List data
|
|
void push_back(const Data& var) {
|
|
if (isList()) {
|
|
list_->push_back(var);
|
|
}
|
|
}
|
|
const ListType& list() const {
|
|
return *list_;
|
|
}
|
|
bool isEmptyList() const {
|
|
return isList() && list_->empty();
|
|
}
|
|
bool isNonEmptyList() const {
|
|
return isList() && !list_->empty();
|
|
}
|
|
Data& operator<< (const Data& data) {
|
|
push_back(data);
|
|
return *this;
|
|
}
|
|
|
|
// String data
|
|
const StringType& stringValue() const {
|
|
return *str_;
|
|
}
|
|
|
|
Data& operator[] (const StringType& key) {
|
|
return (*obj_)[key];
|
|
}
|
|
|
|
const PartialType& partial() const {
|
|
return (*partial_);
|
|
}
|
|
|
|
const LambdaType& lambda() const {
|
|
return (*lambda_);
|
|
}
|
|
|
|
Data<StringType> callLambda(const StringType& text) const {
|
|
return (*lambda_)(text);
|
|
}
|
|
|
|
private:
|
|
Type type_;
|
|
std::unique_ptr<ObjectType> obj_;
|
|
std::unique_ptr<StringType> str_;
|
|
std::unique_ptr<ListType> list_;
|
|
std::unique_ptr<PartialType> partial_;
|
|
std::unique_ptr<LambdaType> lambda_;
|
|
};
|
|
|
|
template <typename StringType>
|
|
class Mustache {
|
|
public:
|
|
Mustache(const StringType& input) {
|
|
Context ctx;
|
|
parse(input, ctx);
|
|
}
|
|
|
|
bool isValid() const {
|
|
return errorMessage_.empty();
|
|
}
|
|
|
|
const StringType& errorMessage() const {
|
|
return errorMessage_;
|
|
}
|
|
|
|
template <typename StreamType>
|
|
StreamType& render(const Data<StringType>& data, StreamType& stream) {
|
|
render(data, [&stream](const StringType& str) {
|
|
stream << str;
|
|
});
|
|
return stream;
|
|
}
|
|
|
|
StringType render(const Data<StringType>& data) {
|
|
std::basic_ostringstream<typename StringType::value_type> ss;
|
|
return render(data, ss).str();
|
|
}
|
|
|
|
using RenderHandler = std::function<void(const StringType&)>;
|
|
void render(const Data<StringType>& data, const RenderHandler& handler) {
|
|
Context ctx{&data};
|
|
render(handler, ctx);
|
|
}
|
|
|
|
private:
|
|
using StringSizeType = typename StringType::size_type;
|
|
|
|
class DelimiterSet {
|
|
public:
|
|
StringType begin;
|
|
StringType end;
|
|
DelimiterSet() {
|
|
reset();
|
|
}
|
|
DelimiterSet(const StringType& b, const StringType& e) : begin(b), end(e) {}
|
|
bool isDefault() const { return begin == defaultBegin() && end == defaultEnd(); }
|
|
void reset() {
|
|
begin = defaultBegin();
|
|
end = defaultEnd();
|
|
}
|
|
static StringType defaultBegin() {
|
|
return StringType(2, '{');
|
|
}
|
|
static StringType defaultEnd() {
|
|
return StringType(2, '}');
|
|
}
|
|
};
|
|
|
|
class Tag {
|
|
public:
|
|
enum class Type {
|
|
Invalid,
|
|
Variable,
|
|
UnescapedVariable,
|
|
SectionBegin,
|
|
SectionEnd,
|
|
SectionBeginInverted,
|
|
Comment,
|
|
Partial,
|
|
SetDelimiter,
|
|
};
|
|
StringType name;
|
|
Type type = Type::Invalid;
|
|
std::shared_ptr<StringType> sectionText;
|
|
std::shared_ptr<DelimiterSet> delimiterSet;
|
|
bool isSectionBegin() const {
|
|
return type == Type::SectionBegin || type == Type::SectionBeginInverted;
|
|
}
|
|
bool isSectionEnd() const {
|
|
return type == Type::SectionEnd;
|
|
}
|
|
};
|
|
|
|
class Component {
|
|
public:
|
|
StringType text;
|
|
Tag tag;
|
|
std::vector<Component> children;
|
|
StringSizeType position = StringType::npos;
|
|
bool isText() const {
|
|
return tag.type == Tag::Type::Invalid;
|
|
}
|
|
bool isTag() const {
|
|
return tag.type != Tag::Type::Invalid;
|
|
}
|
|
Component() {}
|
|
Component(const StringType& t, StringSizeType p) : text(t), position(p) {}
|
|
};
|
|
|
|
class Context {
|
|
public:
|
|
using DataType = Data<StringType>;
|
|
|
|
Context(const DataType* data) {
|
|
push(data);
|
|
}
|
|
|
|
Context() {
|
|
}
|
|
|
|
void push(const DataType* data) {
|
|
items_.insert(items_.begin(), data);
|
|
}
|
|
|
|
void pop() {
|
|
items_.erase(items_.begin());
|
|
}
|
|
|
|
static std::vector<StringType> split(const StringType& s, char delim) {
|
|
std::vector<StringType> elems;
|
|
std::stringstream ss(s);
|
|
std::string item;
|
|
while (std::getline(ss, item, delim)) {
|
|
elems.push_back(item);
|
|
}
|
|
return elems;
|
|
}
|
|
|
|
const DataType* get(const StringType& name) const {
|
|
// process {{.}} name
|
|
if (name.size() == 1 && name.at(0) == '.') {
|
|
return items_.front();
|
|
}
|
|
// process {{a.b.c}} name
|
|
if (name.find('.', 1) != StringType::npos) {
|
|
const DataType* var{items_.front()};
|
|
for (const auto& n : split(name, '.')) {
|
|
var = var->get(n);
|
|
if (!var) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
return var;
|
|
}
|
|
// process normal name
|
|
for (const auto& item : items_) {
|
|
const auto var = item->get(name);
|
|
if (var) {
|
|
return var;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
Context(const Context&) = delete;
|
|
Context& operator= (const Context&) = delete;
|
|
|
|
DelimiterSet delimiterSet;
|
|
|
|
private:
|
|
std::vector<const DataType*> items_;
|
|
};
|
|
|
|
class ContextPusher {
|
|
public:
|
|
ContextPusher(Context& ctx, const Data<StringType>* data) : ctx_(ctx) {
|
|
ctx.push(data);
|
|
}
|
|
~ContextPusher() {
|
|
ctx_.pop();
|
|
}
|
|
ContextPusher(const ContextPusher&) = delete;
|
|
ContextPusher& operator= (const ContextPusher&) = delete;
|
|
private:
|
|
Context& ctx_;
|
|
};
|
|
|
|
Mustache(const StringType& input, Context& ctx) {
|
|
parse(input, ctx);
|
|
}
|
|
|
|
void parse(const StringType& input, Context& ctx) {
|
|
using streamstring = std::basic_ostringstream<typename StringType::value_type>;
|
|
|
|
const StringType braceDelimiterEndUnescaped(3, '}');
|
|
const StringSizeType inputSize{input.size()};
|
|
|
|
bool currentDelimiterIsBrace{ctx.delimiterSet.isDefault()};
|
|
|
|
std::vector<Component*> sections{&rootComponent_};
|
|
std::vector<StringSizeType> sectionStarts;
|
|
|
|
StringSizeType inputPosition{0};
|
|
while (inputPosition != inputSize) {
|
|
|
|
// Find the next tag start delimiter
|
|
const StringSizeType tagLocationStart{input.find(ctx.delimiterSet.begin, inputPosition)};
|
|
if (tagLocationStart == StringType::npos) {
|
|
// No tag found. Add the remaining text.
|
|
const Component comp{{input, inputPosition, inputSize - inputPosition}, inputPosition};
|
|
sections.back()->children.push_back(comp);
|
|
break;
|
|
} else if (tagLocationStart != inputPosition) {
|
|
// Tag found, add text up to this tag.
|
|
const Component comp{{input, inputPosition, tagLocationStart - inputPosition}, inputPosition};
|
|
sections.back()->children.push_back(comp);
|
|
}
|
|
|
|
// Find the next tag end delimiter
|
|
StringSizeType tagContentsLocation{tagLocationStart + ctx.delimiterSet.begin.size()};
|
|
const bool tagIsUnescapedVar{currentDelimiterIsBrace && tagLocationStart != (inputSize - 2) && input.at(tagContentsLocation) == ctx.delimiterSet.begin.at(0)};
|
|
const StringType& currentTagDelimiterEnd{tagIsUnescapedVar ? braceDelimiterEndUnescaped : ctx.delimiterSet.end};
|
|
const auto currentTagDelimiterEndSize = currentTagDelimiterEnd.size();
|
|
if (tagIsUnescapedVar) {
|
|
++tagContentsLocation;
|
|
}
|
|
StringSizeType tagLocationEnd{input.find(currentTagDelimiterEnd, tagContentsLocation)};
|
|
if (tagLocationEnd == StringType::npos) {
|
|
streamstring ss;
|
|
ss << "Unclosed tag at " << tagLocationStart;
|
|
errorMessage_.assign(ss.str());
|
|
return;
|
|
}
|
|
|
|
// Parse tag
|
|
const StringType tagContents{trim(StringType{input, tagContentsLocation, tagLocationEnd - tagContentsLocation})};
|
|
Component comp;
|
|
if (!tagContents.empty() && tagContents[0] == '=') {
|
|
if (!parseSetDelimiterTag(tagContents, ctx.delimiterSet)) {
|
|
streamstring ss;
|
|
ss << "Invalid set delimiter tag at " << tagLocationStart;
|
|
errorMessage_.assign(ss.str());
|
|
return;
|
|
}
|
|
currentDelimiterIsBrace = ctx.delimiterSet.isDefault();
|
|
comp.tag.type = Tag::Type::SetDelimiter;
|
|
comp.tag.delimiterSet.reset(new DelimiterSet(ctx.delimiterSet));
|
|
}
|
|
if (comp.tag.type != Tag::Type::SetDelimiter) {
|
|
parseTagContents(tagIsUnescapedVar, tagContents, comp.tag);
|
|
}
|
|
comp.position = tagLocationStart;
|
|
sections.back()->children.push_back(comp);
|
|
|
|
// Start next search after this tag
|
|
inputPosition = tagLocationEnd + currentTagDelimiterEndSize;
|
|
|
|
// Push or pop sections
|
|
if (comp.tag.isSectionBegin()) {
|
|
sections.push_back(§ions.back()->children.back());
|
|
sectionStarts.push_back(inputPosition);
|
|
} else if (comp.tag.isSectionEnd()) {
|
|
if (sections.size() == 1) {
|
|
streamstring ss;
|
|
ss << "Unopened section \"" << comp.tag.name << "\" at " << comp.position;
|
|
errorMessage_.assign(ss.str());
|
|
return;
|
|
}
|
|
sections.back()->tag.sectionText.reset(new StringType(input.substr(sectionStarts.back(), tagLocationStart - sectionStarts.back())));
|
|
sections.pop_back();
|
|
sectionStarts.pop_back();
|
|
}
|
|
}
|
|
|
|
// Check for sections without an ending tag
|
|
walk([this](Component& comp, int) -> WalkControl {
|
|
if (!comp.tag.isSectionBegin()) {
|
|
return WalkControl::Continue;
|
|
}
|
|
if (comp.children.empty() || !comp.children.back().tag.isSectionEnd() || comp.children.back().tag.name != comp.tag.name) {
|
|
streamstring ss;
|
|
ss << "Unclosed section \"" << comp.tag.name << "\" at " << comp.position;
|
|
errorMessage_.assign(ss.str());
|
|
return WalkControl::Stop;
|
|
}
|
|
comp.children.pop_back(); // remove now useless end section component
|
|
return WalkControl::Continue;
|
|
});
|
|
if (!errorMessage_.empty()) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
enum class WalkControl {
|
|
Continue,
|
|
Stop,
|
|
Skip,
|
|
};
|
|
using WalkCallback = std::function<WalkControl(Component&, int)>;
|
|
|
|
void walk(const WalkCallback& callback) const {
|
|
walkChildren(callback, rootComponent_);
|
|
}
|
|
|
|
void walkChildren(const WalkCallback& callback, const Component& comp) const {
|
|
for (auto childComp : comp.children) {
|
|
if (walkComponent(callback, childComp) != WalkControl::Continue) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
WalkControl walkComponent(const WalkCallback& callback, Component& comp, int depth = 0) const {
|
|
WalkControl control{callback(comp, depth)};
|
|
if (control == WalkControl::Stop) {
|
|
return control;
|
|
} else if (control == WalkControl::Skip) {
|
|
return WalkControl::Continue;
|
|
}
|
|
++depth;
|
|
for (auto childComp : comp.children) {
|
|
control = walkComponent(callback, childComp, depth);
|
|
if (control == WalkControl::Stop) {
|
|
return control;
|
|
} else if (control == WalkControl::Skip) {
|
|
control = WalkControl::Continue;
|
|
break;
|
|
}
|
|
}
|
|
--depth;
|
|
return control;
|
|
}
|
|
|
|
bool parseSetDelimiterTag(const StringType& contents, DelimiterSet& delimiterSet) {
|
|
// Smallest legal tag is "=X X="
|
|
if (contents.size() < 5) {
|
|
return false;
|
|
}
|
|
if (contents.back() != '=') {
|
|
return false;
|
|
}
|
|
const auto contentsSubstr = trim(contents.substr(1, contents.size() - 2));
|
|
const auto spacepos = contentsSubstr.find(' ');
|
|
if (spacepos == StringType::npos) {
|
|
return false;
|
|
}
|
|
const auto nonspace = contentsSubstr.find_first_not_of(' ', spacepos + 1);
|
|
if (nonspace == StringType::npos) {
|
|
return false;
|
|
}
|
|
delimiterSet.begin = contentsSubstr.substr(0, spacepos);
|
|
delimiterSet.end = contentsSubstr.substr(nonspace, contentsSubstr.size() - nonspace);
|
|
return true;
|
|
}
|
|
|
|
void parseTagContents(bool isUnescapedVar, const StringType& contents, Tag& tag) {
|
|
if (isUnescapedVar) {
|
|
tag.type = Tag::Type::UnescapedVariable;
|
|
tag.name = contents;
|
|
} else if (contents.empty()) {
|
|
tag.type = Tag::Type::Variable;
|
|
tag.name.clear();
|
|
} else {
|
|
switch (static_cast<char>(contents.at(0))) {
|
|
case '#':
|
|
tag.type = Tag::Type::SectionBegin;
|
|
break;
|
|
case '^':
|
|
tag.type = Tag::Type::SectionBeginInverted;
|
|
break;
|
|
case '/':
|
|
tag.type = Tag::Type::SectionEnd;
|
|
break;
|
|
case '>':
|
|
tag.type = Tag::Type::Partial;
|
|
break;
|
|
case '&':
|
|
tag.type = Tag::Type::UnescapedVariable;
|
|
break;
|
|
case '!':
|
|
tag.type = Tag::Type::Comment;
|
|
break;
|
|
default:
|
|
tag.type = Tag::Type::Variable;
|
|
break;
|
|
}
|
|
if (tag.type == Tag::Type::Variable) {
|
|
tag.name = contents;
|
|
} else {
|
|
StringType name{contents};
|
|
name.erase(name.begin());
|
|
tag.name = trim(name);
|
|
}
|
|
}
|
|
}
|
|
|
|
void render(const RenderHandler& handler, Context& ctx) {
|
|
walk([&handler, &ctx, this](Component& comp, int) -> WalkControl {
|
|
return renderComponent(handler, ctx, comp);
|
|
});
|
|
}
|
|
|
|
StringType render(Context& ctx) {
|
|
std::basic_ostringstream<typename StringType::value_type> ss;
|
|
render([&ss](const StringType& str) {
|
|
ss << str;
|
|
}, ctx);
|
|
return ss.str();
|
|
}
|
|
|
|
WalkControl renderComponent(const RenderHandler& handler, Context& ctx, Component& comp) {
|
|
if (comp.isText()) {
|
|
handler(comp.text);
|
|
return WalkControl::Continue;
|
|
}
|
|
|
|
const Tag& tag{comp.tag};
|
|
const Data<StringType>* var = nullptr;
|
|
switch (tag.type) {
|
|
case Tag::Type::Variable:
|
|
case Tag::Type::UnescapedVariable:
|
|
if ((var = ctx.get(tag.name)) != nullptr) {
|
|
if (!renderVariable(handler, var, ctx, tag.type == Tag::Type::Variable)) {
|
|
return WalkControl::Stop;
|
|
}
|
|
}
|
|
break;
|
|
case Tag::Type::SectionBegin:
|
|
if ((var = ctx.get(tag.name)) != nullptr) {
|
|
if (var->isLambda()) {
|
|
if (!renderLambda(handler, var, ctx, false, *comp.tag.sectionText, true)) {
|
|
return WalkControl::Stop;
|
|
}
|
|
} else if (!var->isFalse() && !var->isEmptyList()) {
|
|
renderSection(handler, ctx, comp, var);
|
|
}
|
|
}
|
|
return WalkControl::Skip;
|
|
case Tag::Type::SectionBeginInverted:
|
|
if ((var = ctx.get(tag.name)) == nullptr || var->isFalse() || var->isEmptyList()) {
|
|
renderSection(handler, ctx, comp, var);
|
|
}
|
|
return WalkControl::Skip;
|
|
case Tag::Type::Partial:
|
|
if ((var = ctx.get(tag.name)) != nullptr && var->isPartial()) {
|
|
const auto partial = var->partial();
|
|
Mustache tmpl{partial()};
|
|
if (!tmpl.isValid()) {
|
|
errorMessage_ = tmpl.errorMessage();
|
|
} else {
|
|
tmpl.render(handler, ctx);
|
|
if (!tmpl.isValid()) {
|
|
errorMessage_ = tmpl.errorMessage();
|
|
}
|
|
}
|
|
if (!tmpl.isValid()) {
|
|
return WalkControl::Stop;
|
|
}
|
|
}
|
|
break;
|
|
case Tag::Type::SetDelimiter:
|
|
ctx.delimiterSet = *comp.tag.delimiterSet;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return WalkControl::Continue;
|
|
}
|
|
|
|
bool renderLambda(const RenderHandler& handler, const Data<StringType>* var, Context& ctx, bool escaped, const StringType& text, bool parseWithSameContext) {
|
|
const auto lambdaResult = var->callLambda(text);
|
|
if (!lambdaResult.isString()) {
|
|
return true;
|
|
}
|
|
Mustache tmpl = parseWithSameContext ? Mustache{lambdaResult.stringValue(), ctx} : Mustache{lambdaResult.stringValue()};
|
|
if (!tmpl.isValid()) {
|
|
errorMessage_ = tmpl.errorMessage();
|
|
} else {
|
|
const StringType str{tmpl.render(ctx)};
|
|
if (!tmpl.isValid()) {
|
|
errorMessage_ = tmpl.errorMessage();
|
|
} else {
|
|
handler(escaped ? escape(str) : str);
|
|
}
|
|
}
|
|
return tmpl.isValid();
|
|
}
|
|
|
|
bool renderVariable(const RenderHandler& handler, const Data<StringType>* var, Context& ctx, bool escaped) {
|
|
if (var->isString()) {
|
|
const auto varstr = var->stringValue();
|
|
handler(escaped ? escape(varstr) : varstr);
|
|
} else if (var->isLambda()) {
|
|
return renderLambda(handler, var, ctx, escaped, {}, false);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void renderSection(const RenderHandler& handler, Context& ctx, Component& incomp, const Data<StringType>* var) {
|
|
const auto callback = [&handler, &ctx, this](Component& comp, int) -> WalkControl {
|
|
return renderComponent(handler, ctx, comp);
|
|
};
|
|
if (var && var->isNonEmptyList()) {
|
|
for (const auto& item : var->list()) {
|
|
const ContextPusher ctxpusher{ctx, &item};
|
|
walkChildren(callback, incomp);
|
|
}
|
|
} else if (var && var->isObject()) {
|
|
const ContextPusher ctxpusher{ctx, var};
|
|
walkChildren(callback, incomp);
|
|
} else {
|
|
walkChildren(callback, incomp);
|
|
}
|
|
}
|
|
|
|
private:
|
|
StringType errorMessage_;
|
|
Component rootComponent_;
|
|
};
|
|
|
|
} // namespace
|
|
|
|
#endif // MUSTACHE_HPP
|