From 2c96b3bdf54a31a9c24cd982d9434f7637b8acf0 Mon Sep 17 00:00:00 2001 From: pantor Date: Tue, 21 Nov 2017 21:19:52 +0100 Subject: [PATCH] templates, split parser and renderer, c++ class parser --- README.md | 10 +- src/inja.hpp | 489 +++++++++++++++++--------------- test/src/unit-files.cpp | 4 +- test/src/unit-json-helper.cpp | 10 - test/src/unit-parser.cpp | 131 --------- test/src/unit-renderer.cpp | 101 +++++-- test/src/unit-string-helper.cpp | 23 +- 7 files changed, 370 insertions(+), 398 deletions(-) delete mode 100644 test/src/unit-json-helper.cpp delete mode 100644 test/src/unit-parser.cpp diff --git a/README.md b/README.md index 8e8ad04..1231f1f 100644 --- a/README.md +++ b/README.md @@ -57,13 +57,17 @@ Environment env = Environment(); std::string result = env.render("Hello {{ name }}!", data); // Or directly read a template file -result = env.render_template("./template.txt", data); +Template temp = env.parse_template("./template.txt"); +std::string result = temp.render(data); // "Hello World!" -// And read a json file for data +data["name"] = "Inja"; +std::string result = temp.render(data); // "Hello Inja!" + +// Or read a json file for data directly from the environment result = env.render_template("./template.txt", "./data.json"); // Or write a rendered template file -env.write("./template.txt", data, "./result.txt") +temp.write(data, "./result.txt") env.write("./template.txt", "./data.json", "./result.txt") ``` diff --git a/src/inja.hpp b/src/inja.hpp index f0a41b9..f7329c1 100644 --- a/src/inja.hpp +++ b/src/inja.hpp @@ -42,12 +42,17 @@ inline std::string dot_to_json_pointer_notation(std::string dot) { } + enum class ElementNotation { Pointer, Dot }; + +/*! +@brief inja regex class, saves string pattern in addition to std::regex +*/ class Regex: public std::regex { std::string pattern_; @@ -59,6 +64,7 @@ public: }; + class Match: public std::smatch { size_t offset_ = 0; int group_offset_ = 0; @@ -84,6 +90,7 @@ public: }; + class MatchClosed { public: Match open_match, close_match; @@ -186,12 +193,13 @@ inline Match match(const std::string& input, std::vector regexes) { struct Parsed { enum class Type { + Main, String, + Comment, + Expression, Loop, Condition, - ConditionBranch, - Comment, - Expression + ConditionBranch }; enum class Delimiter { @@ -207,7 +215,7 @@ struct Parsed { Include }; - enum class ConditionOperators { + enum class Function { Not, And, Or, @@ -217,10 +225,7 @@ struct Parsed { Less, GreaterEqual, LessEqual, - Different - }; - - enum class Function { + Different, Upper, Lower, Range, @@ -228,7 +233,56 @@ struct Parsed { Round, DivisibleBy, Odd, - Even + Even, + ReadJson + }; + + struct Element { + Parsed::Type type; + std::string inner; + std::vector> children; + + explicit Element(Parsed::Type type): Element(type, "") { } + explicit Element(Parsed::Type type, std::string inner): type(type), inner(inner), children({}) { } + }; + + struct ElementString: public Element { + std::string text; + + explicit ElementString(std::string text): Element(Parsed::Type::String), text(text) { } + }; + + struct ElementComment: public Element { + std::string text; + + explicit ElementComment(std::string text): Element(Parsed::Type::Comment), text(text) { } + }; + + struct ElementExpression: public Element { + Function function; + std::vector args; + std::string command; + + explicit ElementExpression(): ElementExpression(Parsed::Function::ReadJson) { } + explicit ElementExpression(Parsed::Function function): Element(Parsed::Type::Expression), function(function), args({}), command("") { } + }; + + struct ElementLoop: public Element { + std::string item; + ElementExpression list; + + explicit ElementLoop(std::string item, ElementExpression list, std::string inner): Element(Parsed::Type::Loop, inner), item(item), list(list) { } + }; + + struct ElementConditionContainer: public Element { + explicit ElementConditionContainer(): Element(Parsed::Type::Condition) { } + }; + + struct ElementConditionBranch: public Element { + std::string condition_type; + ElementExpression condition; + + explicit ElementConditionBranch(std::string inner, std::string condition_type, ElementExpression condition): Element(Parsed::Type::ConditionBranch, inner), condition_type(condition_type), condition(condition) { } }; }; @@ -236,143 +290,136 @@ struct Parsed { class Template { public: - const json parsed_template; + const Parsed::Element parsed_template; ElementNotation elementNotation; - explicit Template(const json parsed_template): parsed_template(parsed_template) { } - explicit Template(const json parsed_template, ElementNotation elementNotation): parsed_template(parsed_template), elementNotation(elementNotation) { } + explicit Template(const Parsed::Element parsed_template): Template(parsed_template, ElementNotation::Pointer) { } + explicit Template(const Parsed::Element parsed_template, ElementNotation elementNotation): parsed_template(parsed_template), elementNotation(elementNotation) { } template - T eval_variable(json element, json data) { + T eval_variable(Parsed::ElementExpression element, json data) { const json var = eval_variable(element, data, true); if (std::is_same::value) { return var; } return var.get(); } - json eval_variable(json element, json data, bool throw_error) { - if (element.find("function") != element.end()) { - switch ( static_cast(element["function"]) ) { - case Parsed::Function::Upper: { - std::string str = eval_variable(element["arg1"], data); - std::transform(str.begin(), str.end(), str.begin(), toupper); - return str; - } - case Parsed::Function::Lower: { - std::string str = eval_variable(element["arg1"], data); - std::transform(str.begin(), str.end(), str.begin(), tolower); - return str; - } - case Parsed::Function::Range: { - const int number = eval_variable(element["arg1"], data); - std::vector result(number); - std::iota(std::begin(result), std::end(result), 0); - return result; - } - case Parsed::Function::Length: { - const std::vector list = eval_variable>(element["arg1"], data); - return list.size(); - } - case Parsed::Function::Round: { - const double number = eval_variable(element["arg1"], data); - const int precision = eval_variable(element["arg2"], data); - return std::round(number * std::pow(10.0, precision)) / std::pow(10.0, precision); - } - case Parsed::Function::DivisibleBy: { - const int number = eval_variable(element["arg1"], data); - const int divisor = eval_variable(element["arg2"], data); - return (number % divisor == 0); - } - case Parsed::Function::Odd: { - const int number = eval_variable(element["arg1"], data); - return (number % 2 != 0); - } - case Parsed::Function::Even: { - const int number = eval_variable(element["arg1"], data); - return (number % 2 == 0); + json eval_variable(Parsed::ElementExpression element, json data, bool throw_error) { + switch (element.function) { + case Parsed::Function::Upper: { + std::string str = eval_variable(element.args[0], data); + std::transform(str.begin(), str.end(), str.begin(), toupper); + return str; + } + case Parsed::Function::Lower: { + std::string str = eval_variable(element.args[0], data); + std::transform(str.begin(), str.end(), str.begin(), tolower); + return str; + } + case Parsed::Function::Range: { + const int number = eval_variable(element.args[0], data); + std::vector result(number); + std::iota(std::begin(result), std::end(result), 0); + return result; + } + case Parsed::Function::Length: { + const std::vector list = eval_variable>(element.args[0], data); + return list.size(); + } + case Parsed::Function::Round: { + const double number = eval_variable(element.args[0], data); + const int precision = eval_variable(element.args[1], data); + return std::round(number * std::pow(10.0, precision)) / std::pow(10.0, precision); + } + case Parsed::Function::DivisibleBy: { + const int number = eval_variable(element.args[0], data); + const int divisor = eval_variable(element.args[1], data); + return (number % divisor == 0); + } + case Parsed::Function::Odd: { + const int number = eval_variable(element.args[0], data); + return (number % 2 != 0); + } + case Parsed::Function::Even: { + const int number = eval_variable(element.args[0], data); + return (number % 2 == 0); + } + case Parsed::Function::Not: { + return not eval_condition(element.args[0], data); + } + case Parsed::Function::And: { + return (eval_condition(element.args[0], data) and eval_condition(element.args[1], data)); + } + case Parsed::Function::Or: { + return (eval_condition(element.args[0], data) or eval_condition(element.args[1], data)); + } + case Parsed::Function::In: { + const json item = eval_variable(element.args[0], data); + const json list = eval_variable(element.args[1], data); + return (std::find(list.begin(), list.end(), item) != list.end()); + } + case Parsed::Function::Equal: { + return eval_variable(element.args[0], data) == eval_variable(element.args[1], data); + } + case Parsed::Function::Greater: { + return eval_variable(element.args[0], data) > eval_variable(element.args[1], data); + } + case Parsed::Function::Less: { + return eval_variable(element.args[0], data) < eval_variable(element.args[1], data); + } + case Parsed::Function::GreaterEqual: { + return eval_variable(element.args[0], data) >= eval_variable(element.args[1], data); + } + case Parsed::Function::LessEqual: { + return eval_variable(element.args[0], data) <= eval_variable(element.args[1], data); + } + case Parsed::Function::Different: { + return eval_variable(element.args[0], data) != eval_variable(element.args[1], data); + } + case Parsed::Function::ReadJson: { + // Json Raw Data + if ( json::accept(element.command) ) { return json::parse(element.command); } + + std::string input = element.command; + switch (elementNotation) { + case ElementNotation::Pointer: { + if (input[0] != '/') { input.insert(0, "/"); } + break; + } + case ElementNotation::Dot: { + input = dot_to_json_pointer_notation(input); + break; + } } + + const json::json_pointer ptr(input); + const json result = data[ptr]; + + if (throw_error && result.is_null()) { throw std::runtime_error("Did not found json element: " + element.command); } + return result; } } - - const std::string input = element["command"]; - - // Json Raw Data - if ( json::accept(input) ) { return json::parse(input); } - - std::string input_copy = input; - switch (elementNotation) { - case ElementNotation::Pointer: { - if (input_copy[0] != '/') { input_copy.insert(0, "/"); } - break; - } - case ElementNotation::Dot: { - input_copy = dot_to_json_pointer_notation(input_copy); - break; - } - } - - json::json_pointer ptr(input_copy); - json result = data[ptr]; - - if (throw_error && result.is_null()) { throw std::runtime_error("JSON pointer found no element."); } - return result; } - bool eval_condition(json element, json data) { - if (element.find("condition") != element.end()) { - switch ( static_cast(element["condition"]) ) { - case Parsed::ConditionOperators::Not: { - return not eval_condition(element["arg1"], data); - } - case Parsed::ConditionOperators::And: { - return (eval_condition(element["arg1"], data) and eval_condition(element["arg2"], data)); - } - case Parsed::ConditionOperators::Or: { - return (eval_condition(element["arg1"], data) or eval_condition(element["arg2"], data)); - } - case Parsed::ConditionOperators::In: { - const json item = eval_variable(element["arg1"], data); - const json list = eval_variable(element["arg2"], data); - return (std::find(list.begin(), list.end(), item) != list.end()); - } - case Parsed::ConditionOperators::Equal: { - return eval_variable(element["arg1"], data) == eval_variable(element["arg2"], data); - } - case Parsed::ConditionOperators::Greater: { - return eval_variable(element["arg1"], data) > eval_variable(element["arg2"], data); - } - case Parsed::ConditionOperators::Less: { - return eval_variable(element["arg1"], data) < eval_variable(element["arg2"], data); - } - case Parsed::ConditionOperators::GreaterEqual: { - return eval_variable(element["arg1"], data) >= eval_variable(element["arg2"], data); - } - case Parsed::ConditionOperators::LessEqual: { - return eval_variable(element["arg1"], data) <= eval_variable(element["arg2"], data); - } - case Parsed::ConditionOperators::Different: { - return eval_variable(element["arg1"], data) != eval_variable(element["arg2"], data); - } - } - } - + bool eval_condition(Parsed::ElementExpression element, json data) { const json var = eval_variable(element, data, false); if (var.empty()) { return false; } - else if (var.is_boolean()) { return var; } else if (var.is_number()) { return (var != 0); } else if (var.is_string()) { return not var.empty(); } - return true; + return var; } std::string render(json data) { std::string result = ""; - for (auto element: parsed_template) { - switch ( static_cast(element["type"]) ) { + for (auto element: parsed_template.children) { + switch (element->type) { case Parsed::Type::String: { - result += element["text"].get(); + auto elementString = std::static_pointer_cast(element); + result += elementString->text; break; } case Parsed::Type::Expression: { - json variable = eval_variable(element, data); + auto elementExpression = std::static_pointer_cast(element); + json variable = eval_variable(*elementExpression, data); if (variable.is_string()) { result += variable.get(); } else { @@ -383,9 +430,10 @@ public: break; } case Parsed::Type::Loop: { - const std::string item_name = element["item"].get(); + auto elementLoop = std::static_pointer_cast(element); + const std::string item_name = elementLoop->item; - std::vector list = eval_variable>(element["list"], data); + const std::vector list = eval_variable>(elementLoop->list, data); for (int i = 0; i < list.size(); i++) { json data_loop = data; data_loop[item_name] = list[i]; @@ -393,14 +441,16 @@ public: data_loop["index1"] = i + 1; data_loop["is_first"] = (i == 0); data_loop["is_last"] = (i == list.size() - 1); - result += Template(element["children"], elementNotation).render(data_loop); + result += Template(*elementLoop, elementNotation).render(data_loop); } break; } case Parsed::Type::Condition: { - for (auto branch: element["children"]) { - if (eval_condition(branch["condition"], data) || branch["condition_type"] == "else") { - result += Template(branch["children"], elementNotation).render(data); + auto elementCondition = std::static_pointer_cast(element); + for (auto branch: elementCondition->children) { + auto elementBranch = std::static_pointer_cast(branch); + if (eval_condition(elementBranch->condition, data) || elementBranch->condition_type == "else") { + result += Template(*elementBranch, elementNotation).render(data); break; } } @@ -439,20 +489,18 @@ public: const Regex regex_condition_else{"else"}; const Regex regex_condition_close{"endif"}; - const std::map regex_map_condition_operators = { - {Parsed::ConditionOperators::Not, Regex{"not (.+)"}}, - {Parsed::ConditionOperators::And, Regex{"(.+) and (.+)"}}, - {Parsed::ConditionOperators::Or, Regex{"(.+) or (.+)"}}, - {Parsed::ConditionOperators::In, Regex{"(.+) in (.+)"}}, - {Parsed::ConditionOperators::Equal, Regex{"(.+) == (.+)"}}, - {Parsed::ConditionOperators::Greater, Regex{"(.+) > (.+)"}}, - {Parsed::ConditionOperators::Less, Regex{"(.+) < (.+)"}}, - {Parsed::ConditionOperators::GreaterEqual, Regex{"(.+) >= (.+)"}}, - {Parsed::ConditionOperators::LessEqual, Regex{"(.+) <= (.+)"}}, - {Parsed::ConditionOperators::Different, Regex{"(.+) != (.+)"}} - }; const std::map regex_map_functions = { + {Parsed::Function::Not, Regex{"not (.+)"}}, + {Parsed::Function::And, Regex{"(.+) and (.+)"}}, + {Parsed::Function::Or, Regex{"(.+) or (.+)"}}, + {Parsed::Function::In, Regex{"(.+) in (.+)"}}, + {Parsed::Function::Equal, Regex{"(.+) == (.+)"}}, + {Parsed::Function::Greater, Regex{"(.+) > (.+)"}}, + {Parsed::Function::Less, Regex{"(.+) < (.+)"}}, + {Parsed::Function::GreaterEqual, Regex{"(.+) >= (.+)"}}, + {Parsed::Function::LessEqual, Regex{"(.+) <= (.+)"}}, + {Parsed::Function::Different, Regex{"(.+) != (.+)"}}, {Parsed::Function::Upper, Regex{"upper\\(\\s*(.*?)\\s*\\)"}}, {Parsed::Function::Lower, Regex{"lower\\(\\s*(.*?)\\s*\\)"}}, {Parsed::Function::Range, Regex{"range\\(\\s*(.*?)\\s*\\)"}}, @@ -460,33 +508,24 @@ public: {Parsed::Function::Round, Regex{"round\\(\\s*(.*?)\\s*,\\s*(.*?)\\s*\\)"}}, {Parsed::Function::DivisibleBy, Regex{"divisibleBy\\(\\s*(.*?)\\s*,\\s*(.*?)\\s*\\)"}}, {Parsed::Function::Odd, Regex{"odd\\(\\s*(.*?)\\s*\\)"}}, - {Parsed::Function::Even, Regex{"even\\(\\s*(.*?)\\s*\\)"}} + {Parsed::Function::Even, Regex{"even\\(\\s*(.*?)\\s*\\)"}}, + {Parsed::Function::ReadJson, Regex{"\\s*(.*?)\\s*"}} }; Parser() { } - json element(Parsed::Type type, json element_data) { - element_data["type"] = type; - return element_data; - } - - json element_function(Parsed::Function func, int number_args, Match match) { - json result = element(Parsed::Type::Expression, {{"function", func}}); - for (int i = 1; i < number_args + 1; i++) { - result["arg" + std::to_string(i)] = parse_expression(match.str(i)); + Parsed::ElementExpression element_function(Parsed::Function func, int number_args, Match match) { + std::vector args = {}; + for (int i = 0; i < number_args; i++) { + args.push_back( parse_expression(match.str(i + 1)) ); } + + Parsed::ElementExpression result = Parsed::ElementExpression(func); + result.args = args; return result; } - json element_condition(Parsed::ConditionOperators op, int number_args, Match match) { - json result = element(Parsed::Type::Expression, {{"condition", op}}); - for (int i = 1; i < number_args + 1; i++) { - result["arg" + std::to_string(i)] = parse_expression(match.str(i)); - } - return result; - } - - json parse_expression(const std::string& input) { + Parsed::ElementExpression parse_expression(const std::string& input) { Match match_function = match(input, get_values(regex_map_functions)); switch ( static_cast(match_function.regex_number()) ) { case Parsed::Function::Upper: { @@ -513,52 +552,46 @@ public: case Parsed::Function::Even: { return element_function(Parsed::Function::Even, 1, match_function); } - } - - return element(Parsed::Type::Expression, {{"command", input}}); - } - - json parse_condition(const std::string& input) { - Match match_condition = match(input, get_values(regex_map_condition_operators)); - - switch ( static_cast(match_condition.regex_number()) ) { - case Parsed::ConditionOperators::Not: { - return element_condition(Parsed::ConditionOperators::Not, 1, match_condition); + case Parsed::Function::Not: { + return element_function(Parsed::Function::Not, 1, match_function); } - case Parsed::ConditionOperators::And: { - return element_condition(Parsed::ConditionOperators::And, 2, match_condition); + case Parsed::Function::And: { + return element_function(Parsed::Function::And, 2, match_function); } - case Parsed::ConditionOperators::Or: { - return element_condition(Parsed::ConditionOperators::Or, 2, match_condition); + case Parsed::Function::Or: { + return element_function(Parsed::Function::Or, 2, match_function); } - case Parsed::ConditionOperators::In: { - return element_condition(Parsed::ConditionOperators::In, 2, match_condition); + case Parsed::Function::In: { + return element_function(Parsed::Function::In, 2, match_function); } - case Parsed::ConditionOperators::Equal: { - return element_condition(Parsed::ConditionOperators::Equal, 2, match_condition); + case Parsed::Function::Equal: { + return element_function(Parsed::Function::Equal, 2, match_function); } - case Parsed::ConditionOperators::Greater: { - return element_condition(Parsed::ConditionOperators::Greater, 2, match_condition); + case Parsed::Function::Greater: { + return element_function(Parsed::Function::Greater, 2, match_function); } - case Parsed::ConditionOperators::Less: { - return element_condition(Parsed::ConditionOperators::Less, 2, match_condition); + case Parsed::Function::Less: { + return element_function(Parsed::Function::Less, 2, match_function); } - case Parsed::ConditionOperators::GreaterEqual: { - return element_condition(Parsed::ConditionOperators::GreaterEqual, 2, match_condition); + case Parsed::Function::GreaterEqual: { + return element_function(Parsed::Function::GreaterEqual, 2, match_function); } - case Parsed::ConditionOperators::LessEqual: { - return element_condition(Parsed::ConditionOperators::LessEqual, 2, match_condition); + case Parsed::Function::LessEqual: { + return element_function(Parsed::Function::LessEqual, 2, match_function); } - case Parsed::ConditionOperators::Different: { - return element_condition(Parsed::ConditionOperators::Different, 2, match_condition); + case Parsed::Function::Different: { + return element_function(Parsed::Function::Different, 2, match_function); + } + case Parsed::Function::ReadJson: { + Parsed::ElementExpression result = Parsed::ElementExpression(Parsed::Function::ReadJson); + result.command = input; + return result; } } - - return element(Parsed::Type::Expression, {{"command", input}}); } - json parse_level(const std::string& input, const std::string& path) { - json result; + std::vector> parse_level(const std::string& input, const std::string& path) { + std::vector> result; std::vector regex_delimiters = get_values(regex_map_delimiters); @@ -568,7 +601,7 @@ public: current_position = match_delimiter.end_position(); std::string string_prefix = match_delimiter.prefix(); if (not string_prefix.empty()) { - result += element(Parsed::Type::String, {{"text", string_prefix}}); + result.emplace_back( std::make_shared(string_prefix) ); } std::string delimiter_inner = match_delimiter.str(1); @@ -590,27 +623,24 @@ public: const std::string item_name = match_command.str(1); const std::string list_name = match_command.str(2); - result += element(Parsed::Type::Loop, {{"item", item_name}, {"list", parse_expression(list_name)}, {"inner", loop_match.inner()}}); + result.emplace_back( std::make_shared(item_name, parse_expression(list_name), loop_match.inner())); } else { throw std::runtime_error("Parser error: Unknown loop command."); } - break; } case Parsed::Statement::Condition: { - json condition_result = element(Parsed::Type::Condition, {{"children", json::array()}}); + auto condition_container = std::make_shared(); const Regex regex_condition{"(if|else if|else) ?(.*)"}; - Match condition_match = match_delimiter; - MatchClosed else_if_match = search_closed_on_level(input, match_delimiter.regex(), regex_condition_open, regex_condition_close, regex_condition_else_if, condition_match); while (else_if_match.found()) { condition_match = else_if_match.close_match; Match match_command; if (std::regex_match(else_if_match.open_match.str(1), match_command, regex_condition)) { - condition_result["children"] += element(Parsed::Type::ConditionBranch, {{"inner", else_if_match.inner()}, {"condition_type", match_command.str(1)}, {"condition", parse_condition(match_command.str(2))}}); + condition_container->children.push_back( std::make_shared(else_if_match.inner(), match_command.str(1), parse_expression(match_command.str(2))) ); } else_if_match = search_closed_on_level(input, match_delimiter.regex(), regex_condition_open, regex_condition_close, regex_condition_else_if, condition_match); @@ -622,7 +652,7 @@ public: Match match_command; if (std::regex_match(else_match.open_match.str(1), match_command, regex_condition)) { - condition_result["children"] += element(Parsed::Type::ConditionBranch, {{"inner", else_match.inner()}, {"condition_type", match_command.str(1)}, {"condition", parse_condition(match_command.str(2))}}); + condition_container->children.push_back( std::make_shared(else_match.inner(), match_command.str(1), parse_expression(match_command.str(2))) ); } } @@ -630,18 +660,18 @@ public: Match match_command; if (std::regex_match(last_if_match.open_match.str(1), match_command, regex_condition)) { - condition_result["children"] += element(Parsed::Type::ConditionBranch, {{"inner", last_if_match.inner()}, {"condition_type", match_command.str(1)}, {"condition", parse_condition(match_command.str(2))}}); + condition_container->children.push_back( std::make_shared(last_if_match.inner(), match_command.str(1), parse_expression(match_command.str(2))) ); } current_position = last_if_match.end_position(); - result += condition_result; + result.emplace_back(condition_container); break; } case Parsed::Statement::Include: { std::string included_filename = path + match_statement.str(1); Template included_template = parse_template(included_filename); - for (json element : included_template.parsed_template) { - result += element; + for (auto element : included_template.parsed_template.children) { + result.emplace_back(element); } break; } @@ -651,11 +681,11 @@ public: break; } case Parsed::Delimiter::Expression: { - result += parse_expression(delimiter_inner); + result.emplace_back( std::make_shared(parse_expression(delimiter_inner)) ); break; } case Parsed::Delimiter::Comment: { - result += element(Parsed::Type::Comment, {{"text", delimiter_inner}}); + result.emplace_back( std::make_shared(delimiter_inner) ); break; } default: { throw std::runtime_error("Parser error: Unknown delimiter."); } @@ -664,19 +694,20 @@ public: match_delimiter = search(input, regex_delimiters, current_position); } if (current_position < input.length()) { - result += element(Parsed::Type::String, {{"text", input.substr(current_position)}}); + result.emplace_back( std::make_shared(input.substr(current_position)) ); } return result; } - json parse_tree(json current_element, const std::string& path) { - if (current_element.find("inner") != current_element.end()) { - current_element["children"] = parse_level(current_element["inner"], path); - current_element.erase("inner"); + std::shared_ptr parse_tree(std::shared_ptr current_element, const std::string& path) { + if (not current_element->inner.empty()) { + current_element->children = parse_level(current_element->inner, path); + current_element->inner.clear(); } - if (current_element.find("children") != current_element.end()) { - for (auto& child: current_element["children"]) { + + if (not current_element->children.empty()) { + for (auto& child: current_element->children) { child = parse_tree(child, path); } } @@ -684,15 +715,15 @@ public: } Template parse(const std::string& input) { - json parsed = parse_tree({{"inner", input}}, "./")["children"]; - return Template(parsed); + auto parsed = parse_tree(std::make_shared(Parsed::Element(Parsed::Type::String, input)), "./"); + return Template(*parsed); } Template parse_template(const std::string& filename) { - std::string text = load_file(filename); + std::string input = load_file(filename); std::string path = filename.substr(0, filename.find_last_of("/\\") + 1); - json parsed = parse_tree({{"inner", text}}, path)["children"]; - return Template(parsed); + auto parsed = parse_tree(std::make_shared(Parsed::Element(Parsed::Type::String, input)), path); + return Template(*parsed); } std::string load_file(const std::string& filename) { @@ -704,12 +735,15 @@ public: +/*! +@brief Environment class +*/ class Environment { const std::string global_path; ElementNotation elementNotation = ElementNotation::Pointer; - Parser parser; + Parser parser = Parser(); public: Environment(): Environment("./") { } @@ -735,16 +769,25 @@ public: elementNotation = elementNotation_; } - std::string render(const std::string& input, json data) { + + Template parse(const std::string& input) { Template parsed = parser.parse(input); parsed.elementNotation = elementNotation; - return parsed.render(data); + return parsed; + } + + Template parse_template(const std::string& filename) { + Template parsed = parser.parse_template(global_path + filename); + parsed.elementNotation = elementNotation; + return parsed; + } + + std::string render(const std::string& input, json data) { + return parse(input).render(data); } std::string render_template(const std::string& filename, json data) { - Template parsed = parser.parse_template(global_path + filename); - parsed.elementNotation = elementNotation; - return parsed.render(data); + return parse_template(filename).render(data); } std::string render_template_with_json_file(const std::string& filename, const std::string& filename_data) { @@ -754,7 +797,7 @@ public: void write(const std::string& filename, json data, const std::string& filename_out) { std::ofstream file(global_path + filename_out); - file << render_template_with_json_file(filename, data); + file << render_template(filename, data); file.close(); } diff --git a/test/src/unit-files.cpp b/test/src/unit-files.cpp index 6bb6c58..c1450a1 100644 --- a/test/src/unit-files.cpp +++ b/test/src/unit-files.cpp @@ -6,7 +6,7 @@ using json = nlohmann::json; -TEST_CASE("Files handling") { +TEST_CASE("loading") { inja::Environment env = inja::Environment(); json data; data["name"] = "Jeff"; @@ -24,7 +24,7 @@ TEST_CASE("Files handling") { } } -TEST_CASE("Complete files") { +TEST_CASE("complete-files") { inja::Environment env = inja::Environment("data/"); for (std::string test_name : {"simple-file", "nested", "nested-line"}) { diff --git a/test/src/unit-json-helper.cpp b/test/src/unit-json-helper.cpp deleted file mode 100644 index 385fe31..0000000 --- a/test/src/unit-json-helper.cpp +++ /dev/null @@ -1,10 +0,0 @@ -#include "catch.hpp" -#include "nlohmann/json.hpp" -#include "inja.hpp" - - - -TEST_CASE("Dot to pointer notation") { - CHECK( inja::dot_to_json_pointer_notation("person.names.surname") == "/person/names/surname" ); - CHECK( inja::dot_to_json_pointer_notation("guests.2") == "/guests/2" ); -} diff --git a/test/src/unit-parser.cpp b/test/src/unit-parser.cpp deleted file mode 100644 index 716d9e1..0000000 --- a/test/src/unit-parser.cpp +++ /dev/null @@ -1,131 +0,0 @@ -#include "catch.hpp" -#include "nlohmann/json.hpp" -#include "inja.hpp" - - -using json = nlohmann::json; -using Type = inja::Parsed::Type; - - - -/* TEST_CASE("Parse structure") { - inja::Parser parser = inja::Parser(); - - SECTION("Basic string") { - std::string test = "lorem ipsum"; - json result = {{{"type", Type::String}, {"text", "lorem ipsum"}}}; - CHECK( parser.parse(test) == result ); - } - - SECTION("Empty string") { - std::string test = ""; - json result = {}; - CHECK( parser.parse(test) == result ); - } - - SECTION("Variable") { - std::string test = "{{ name }}"; - json result = {{{"type", Type::Expression}, {"command", "name"}}}; - CHECK( parser.parse(test) == result ); - } - - SECTION("Combined string and variables") { - std::string test = "Hello {{ name }}!"; - json result = { - {{"type", Type::String}, {"text", "Hello "}}, - {{"type", Type::Expression}, {"command", "name"}}, - {{"type", Type::String}, {"text", "!"}} - }; - CHECK( parser.parse(test) == result ); - } - - SECTION("Multiple variables") { - std::string test = "Hello {{ name }}! I come from {{ city }}."; - json result = { - {{"type", Type::String}, {"text", "Hello "}}, - {{"type", Type::Expression}, {"command", "name"}}, - {{"type", Type::String}, {"text", "! I come from "}}, - {{"type", Type::Expression}, {"command", "city"}}, - {{"type", Type::String}, {"text", "."}} - }; - CHECK( parser.parse(test) == result ); - } - - SECTION("Loops") { - std::string test = "open {% for e in list %}lorem{% endfor %} closing"; - json result = { - {{"type", Type::String}, {"text", "open "}}, - {{"type", Type::Loop}, {"item", "e"}, {"list", "list"}, {"children", { - {{"type", Type::String}, {"text", "lorem"}} - }}}, - {{"type", Type::String}, {"text", " closing"}} - }; - CHECK( parser.parse(test) == result ); - } - - SECTION("Nested loops") { - std::string test = "{% for e in list %}{% for b in list2 %}lorem{% endfor %}{% endfor %}"; - json result = { - {{"type", Type::Loop}, {"item", "e"}, {"list", "list"}, {"children", { - {{"type", Type::Loop}, {"item", "b"}, {"list", "list2"}, {"children", { - {{"type", Type::String}, {"text", "lorem"}} - }}} - }}} - }; - CHECK( parser.parse(test) == result ); - } - - SECTION("Basic conditional") { - std::string test = "{% if true %}Hello{% endif %}"; - json result = { - {{"type", Type::Condition}, {"children", { - {{"type", Type::ConditionBranch}, {"command", "if true"}, {"children", { - {{"type", Type::String}, {"text", "Hello"}} - }}} - }}} - }; - CHECK( parser.parse(test) == result ); - } - - SECTION("If/else if/else conditional") { - std::string test = "if: {% if maybe %}first if{% else if perhaps %}first else if{% else if sometimes %}second else if{% else %}test else{% endif %}"; - json result = { - {{"type", Type::String}, {"text", "if: "}}, - {{"type", Type::Condition}, {"children", { - {{"type", Type::ConditionBranch}, {"command", "if maybe"}, {"children", { - {{"type", Type::String}, {"text", "first if"}} - }}}, - {{"type", Type::ConditionBranch}, {"command", "else if perhaps"}, {"children", { - {{"type", Type::String}, {"text", "first else if"}} - }}}, - {{"type", Type::ConditionBranch}, {"command", "else if sometimes"}, {"children", { - {{"type", Type::String}, {"text", "second else if"}} - }}}, - {{"type", Type::ConditionBranch}, {"command", "else"}, {"children", { - {{"type", Type::String}, {"text", "test else"}} - }}}, - }}} - }; - CHECK( parser.parse(test) == result ); - } - - SECTION("Comments") { - std::string test = "{# lorem ipsum #}"; - json result = {{{"type", Type::Comment}, {"text", "lorem ipsum"}}}; - CHECK( parser.parse(test) == result ); - } - - SECTION("Line Statements") { - std::string test = R"(## if true -lorem ipsum -## endif)"; - json result = { - {{"type", Type::Condition}, {"children", { - {{"type", Type::ConditionBranch}, {"command", "if true"}, {"children", { - {{"type", Type::String}, {"text", "lorem ipsum"}} - }}} - }}} - }; - CHECK( parser.parse(test) == result ); - } -} */ diff --git a/test/src/unit-renderer.cpp b/test/src/unit-renderer.cpp index 74c4205..4b04184 100644 --- a/test/src/unit-renderer.cpp +++ b/test/src/unit-renderer.cpp @@ -3,10 +3,11 @@ #include "inja.hpp" + using json = nlohmann::json; -TEST_CASE("Renderer") { +TEST_CASE("types") { inja::Environment env = inja::Environment(); json data; data["name"] = "Peter"; @@ -18,12 +19,12 @@ TEST_CASE("Renderer") { data["brother"]["daughter0"] = { { "name", "Maria" } }; data["is_happy"] = true; - SECTION("Basic") { - CHECK( env.render("Hello World!", data) == "Hello World!" ); + SECTION("basic") { CHECK( env.render("", data) == "" ); + CHECK( env.render("Hello World!", data) == "Hello World!" ); } - SECTION("Variables") { + SECTION("variables") { CHECK( env.render("Hello {{ name }}!", data) == "Hello Peter!" ); CHECK( env.render("{{ name }}", data) == "Peter" ); CHECK( env.render("{{name}}", data) == "Peter" ); @@ -32,19 +33,22 @@ TEST_CASE("Renderer") { CHECK( env.render("Hello {{ names/1 }}!", data) == "Hello Seb!" ); CHECK( env.render("Hello {{ brother/name }}!", data) == "Hello Chris!" ); CHECK( env.render("Hello {{ brother/daughter0/name }}!", data) == "Hello Maria!" ); + + CHECK_THROWS_WITH( env.render("{{unknown}}", data), "Did not found json element: unknown" ); } - SECTION("Comments") { + SECTION("comments") { CHECK( env.render("Hello{# This is a comment #}!", data) == "Hello!" ); CHECK( env.render("{# --- #Todo --- #}", data) == "" ); } - SECTION("Loops") { + SECTION("loops") { + CHECK( env.render("{% for name in names %}a{% endfor %}", data) == "aa" ); CHECK( env.render("Hello {% for name in names %}{{ name }} {% endfor %}!", data) == "Hello Jeff Seb !" ); CHECK( env.render("Hello {% for name in names %}{{ index }}: {{ name }}, {% endfor %}!", data) == "Hello 0: Jeff, 1: Seb, !" ); } - SECTION("Conditionals") { + SECTION("conditionals") { CHECK( env.render("{% if is_happy %}Yeah!{% endif %}", data) == "Yeah!" ); CHECK( env.render("{% if is_sad %}Yeah!{% endif %}", data) == "" ); CHECK( env.render("{% if is_sad %}Yeah!{% else %}Nooo...{% endif %}", data) == "Nooo..." ); @@ -54,10 +58,12 @@ TEST_CASE("Renderer") { CHECK( env.render("{% if age != 28 %}Right{% else %}Wrong{% endif %}", data) == "Right" ); CHECK( env.render("{% if age >= 30 %}Right{% else %}Wrong{% endif %}", data) == "Wrong" ); CHECK( env.render("{% if age in [28, 29, 30] %}True{% endif %}", data) == "True" ); + CHECK( env.render("{% if age == 28 %}28{% else if age == 29 %}29{% endif %}", data) == "29" ); + CHECK( env.render("{% if age == 26 %}26{% else if age == 27 %}27{% else if age == 28 %}28{% else %}29{% endif %}", data) == "29" ); } } -TEST_CASE("Render functions") { +TEST_CASE("functions") { inja::Environment env = inja::Environment(); json data; @@ -66,60 +72,115 @@ TEST_CASE("Render functions") { data["names"] = {"Jeff", "Seb", "Peter", "Tom"}; data["temperature"] = 25.6789; - SECTION("Upper") { + SECTION("upper") { CHECK( env.render("{{ upper(name) }}", data) == "PETER" ); + CHECK( env.render("{{ upper( name ) }}", data) == "PETER" ); CHECK( env.render("{{ upper(city) }}", data) == "NEW YORK" ); + CHECK( env.render("{{ upper(upper(name)) }}", data) == "PETER" ); CHECK_THROWS_WITH( env.render("{{ upper(5) }}", data), "[json.exception.type_error.302] type must be string, but is number" ); + CHECK_THROWS_WITH( env.render("{{ upper(true) }}", data), "[json.exception.type_error.302] type must be string, but is boolean" ); } - SECTION("Lower") { + SECTION("lower") { CHECK( env.render("{{ lower(name) }}", data) == "peter" ); CHECK( env.render("{{ lower(city) }}", data) == "new york" ); CHECK_THROWS_WITH( env.render("{{ lower(5.45) }}", data), "[json.exception.type_error.302] type must be string, but is number" ); } - SECTION("Range") { - // CHECK( env.render("range(4)", data) == std::vector({0, 1, 2, 3}) ); + SECTION("range") { + CHECK( env.render("{{ range(2) }}", data) == "[0,1]" ); + CHECK( env.render("{{ range(4) }}", data) == "[0,1,2,3]" ); CHECK_THROWS_WITH( env.render("{{ range(name) }}", data), "[json.exception.type_error.302] type must be number, but is string" ); } - SECTION("Length") { + SECTION("length") { CHECK( env.render("{{ length(names) }}", data) == "4" ); CHECK_THROWS_WITH( env.render("{{ length(5) }}", data), "[json.exception.type_error.302] type must be array, but is number" ); } - SECTION("Round") { + SECTION("round") { CHECK( env.render("{{ round(4, 0) }}", data) == "4.0" ); CHECK( env.render("{{ round(temperature, 2) }}", data) == "25.68" ); CHECK_THROWS_WITH( env.render("{{ round(name, 2) }}", data), "[json.exception.type_error.302] type must be number, but is string" ); } - SECTION("DivisibleBy") { + SECTION("divisibleBy") { CHECK( env.render("{{ divisibleBy(50, 5) }}", data) == "true" ); CHECK( env.render("{{ divisibleBy(12, 3) }}", data) == "true" ); CHECK( env.render("{{ divisibleBy(11, 3) }}", data) == "false" ); CHECK_THROWS_WITH( env.render("{{ divisibleBy(name, 2) }}", data), "[json.exception.type_error.302] type must be number, but is string" ); } - SECTION("Odd") { + SECTION("odd") { CHECK( env.render("{{ odd(11) }}", data) == "true" ); CHECK( env.render("{{ odd(12) }}", data) == "false" ); CHECK_THROWS_WITH( env.render("{{ odd(name) }}", data), "[json.exception.type_error.302] type must be number, but is string" ); } - SECTION("Even") { + SECTION("even") { CHECK( env.render("{{ even(11) }}", data) == "false" ); CHECK( env.render("{{ even(12) }}", data) == "true" ); CHECK_THROWS_WITH( env.render("{{ even(name) }}", data), "[json.exception.type_error.302] type must be number, but is string" ); } } -TEST_CASE("Renderer other syntax") { +TEST_CASE("combinations") { + inja::Environment env = inja::Environment(); json data; data["name"] = "Peter"; + data["city"] = "Brunswick"; + data["age"] = 29; data["names"] = {"Jeff", "Seb"}; + data["brother"]["name"] = "Chris"; + data["brother"]["daughters"] = {"Maria", "Helen"}; + data["brother"]["daughter0"] = { { "name", "Maria" } }; + data["is_happy"] = true; - SECTION("Other expression syntax") { + CHECK( env.render("{% if upper(\"Peter\") == \"PETER\" %}TRUE{% endif %}", data) == "TRUE" ); + CHECK( env.render("{% if lower(upper(name)) == \"peter\" %}TRUE{% endif %}", data) == "TRUE" ); + CHECK( env.render("{% for i in range(4) %}{{ index1 }}{% endfor %}", data) == "1234" ); +} + +TEST_CASE("templates") { + inja::Environment env = inja::Environment(); + inja::Template temp = env.parse("{% if is_happy %}{{ name }}{% else %}{{ city }}{% endif %}"); + + json data; + data["name"] = "Peter"; + data["city"] = "Brunswick"; + data["is_happy"] = true; + + CHECK( temp.render(data) == "Peter" ); + + data["is_happy"] = false; + + CHECK( temp.render(data) == "Brunswick" ); +} + +TEST_CASE("other-syntax") { + json data; + data["name"] = "Peter"; + data["city"] = "Brunswick"; + data["age"] = 29; + data["names"] = {"Jeff", "Seb"}; + data["brother"]["name"] = "Chris"; + data["brother"]["daughters"] = {"Maria", "Helen"}; + data["brother"]["daughter0"] = { { "name", "Maria" } }; + data["is_happy"] = true; + + SECTION("variables") { + inja::Environment env = inja::Environment(); + env.setElementNotation(inja::ElementNotation::Dot); + + CHECK( env.render("{{ name }}", data) == "Peter" ); + CHECK( env.render("Hello {{ names.1 }}!", data) == "Hello Seb!" ); + CHECK( env.render("Hello {{ brother.name }}!", data) == "Hello Chris!" ); + CHECK( env.render("Hello {{ brother.daughter0.name }}!", data) == "Hello Maria!" ); + + CHECK_THROWS_WITH( env.render("{{unknown}}", data), "Did not found json element: unknown" ); + } + + SECTION("other expression syntax") { inja::Environment env = inja::Environment(); CHECK( env.render("Hello {{ name }}!", data) == "Hello Peter!" ); @@ -130,7 +191,7 @@ TEST_CASE("Renderer other syntax") { CHECK( env.render("Hello (& name &)!", data) == "Hello Peter!" ); } - SECTION("Other comment syntax") { + SECTION("other comment syntax") { inja::Environment env = inja::Environment(); env.setComment("\\(&", "&\\)"); diff --git a/test/src/unit-string-helper.cpp b/test/src/unit-string-helper.cpp index 8436997..e3e1d03 100644 --- a/test/src/unit-string-helper.cpp +++ b/test/src/unit-string-helper.cpp @@ -4,11 +4,16 @@ -TEST_CASE("Basic search in string") { +TEST_CASE("dot to pointer") { + CHECK( inja::dot_to_json_pointer_notation("person.names.surname") == "/person/names/surname" ); + CHECK( inja::dot_to_json_pointer_notation("guests.2") == "/guests/2" ); +} + +TEST_CASE("basic-search") { std::string input = "lorem ipsum dolor it"; inja::Regex regex("i(.*)m"); - SECTION("Basic search from start") { + SECTION("from start") { inja::Match match = inja::search(input, regex, 0); CHECK( match.found() == true ); CHECK( match.position() == 6 ); @@ -18,17 +23,17 @@ TEST_CASE("Basic search in string") { CHECK( match.str(1) == "psu" ); } - SECTION("Basic search from position") { + SECTION("from position") { inja::Match match = inja::search(input, regex, 8); CHECK( match.found() == false ); CHECK( match.length() == 0 ); } } -TEST_CASE("Search in string with multiple possible regexes") { +TEST_CASE("search-with-multiple-possible-regexes") { std::string input = "lorem ipsum dolor amit estas tronum."; - SECTION("Basic 1") { + SECTION("basic 1") { std::vector regex_patterns = { inja::Regex("tras"), inja::Regex("do(\\w*)or"), inja::Regex("es(\\w*)as"), inja::Regex("ip(\\w*)um") }; inja::Match match = inja::search(input, regex_patterns, 0); CHECK( match.regex_number() == 3 ); @@ -36,7 +41,7 @@ TEST_CASE("Search in string with multiple possible regexes") { CHECK( match.str(1) == "s" ); } - SECTION("Basic 2") { + SECTION("basic 2") { std::vector regex_patterns = { inja::Regex("tras"), inja::Regex("ip(\\w*)um"), inja::Regex("do(\\w*)or"), inja::Regex("es(\\w*)as") }; inja::Match match = inja::search(input, regex_patterns, 0); CHECK( match.regex_number() == 1 ); @@ -45,7 +50,7 @@ TEST_CASE("Search in string with multiple possible regexes") { } } -TEST_CASE("Search on level") { +TEST_CASE("search-on-level") { std::string input = "(% up %)(% up %)Test(% N1 %)(% down %)...(% up %)(% N2 %)(% up %)(% N3 %)(% down %)(% N4 %)(% down %)(% N5 %)(% down %)"; inja::Regex regex_statement("\\(\\% (.*?) \\%\\)"); @@ -53,7 +58,7 @@ TEST_CASE("Search on level") { inja::Regex regex_level_down("down"); inja::Regex regex_search("N(\\d+)"); - SECTION("First instance") { + SECTION("first instance") { inja::Match open_match = inja::search(input, regex_statement, 0); CHECK( open_match.position() == 0 ); CHECK( open_match.end_position() == 8 ); @@ -64,7 +69,7 @@ TEST_CASE("Search on level") { CHECK( match.end_position() == 109 ); } - SECTION("Second instance") { + SECTION("second instance") { inja::Match open_match = inja::search(input, regex_statement, 4); CHECK( open_match.position() == 8 );