Partially implement recursive loops

Author: flexferrum

src/statements.cpp

@@ -1,3 +1,4 @@
+#include "expression_evaluator.h"
 #include "statements.h"
 #include "template_impl.h"
 #include "value_visitors.h"
@@ -10,10 +11,31 @@ void ForStatement::Render(OutStream& os, RenderContext& values)
 {
     InternalValue loopVal = m_value->Evaluate(values);
 
+    RenderLoop(loopVal, os, values);
+}
+
+void ForStatement::RenderLoop(const InternalValue& loopVal, OutStream& os, RenderContext& values)
+{
     auto& context = values.EnterScope();
 
     InternalValueMap loopVar;
     context["loop"] = MapAdapter::CreateAdapter(&loopVar);
+    if (m_isRecursive)
+    {
+        loopVar["operator()"] = Callable([this](const CallParams& params, OutStream& stream, RenderContext& context) {
+                bool isSucceeded = false;
+                auto parsedParams = helpers::ParseCallParams({{"var", true}}, params, isSucceeded);
+                if (!isSucceeded)
+                    return;
+                    
+                auto var = parsedParams["var"];
+                if (!var)
+                    return;
+                    
+                RenderLoop(var->Evaluate(context), stream, context);
+            });
+        
+    }
 
     bool isConverted = false;
     auto loopItems = ConvertToList(loopVal, InternalValue(), isConverted);

src/statements.h

@@ -22,10 +22,11 @@ class TemplateImpl;
 class ForStatement : public Statement
 {
 public:
-    ForStatement(std::vector<std::string> vars, ExpressionEvaluatorPtr<> expr, ExpressionEvaluatorPtr<> ifExpr)
+    ForStatement(std::vector<std::string> vars, ExpressionEvaluatorPtr<> expr, ExpressionEvaluatorPtr<> ifExpr, bool isRecursive)
         : m_vars(std::move(vars))
         , m_value(expr)
         , m_ifExpr(ifExpr)
+        , m_isRecursive(isRecursive)
     {
     }
 
@@ -40,11 +41,15 @@ class ForStatement : public Statement
     }
 
     void Render(OutStream& os, RenderContext& values) override;
+    
+private:
+    void RenderLoop(const InternalValue& val, OutStream& os, RenderContext& values);
 
 private:
     std::vector<std::string> m_vars;
     ExpressionEvaluatorPtr<> m_value;
     ExpressionEvaluatorPtr<> m_ifExpr;
+    bool m_isRecursive;
     RendererPtr m_mainBody;
     RendererPtr m_elseBody;
 };

src/template_parser.cpp

@@ -85,12 +85,23 @@ bool StatementsParser::ParseFor(LexScanner& lexer, StatementInfoList& statements
     auto valueExpr = exprPraser.ParseFullExpression(lexer, false);
     if (!valueExpr)
         return false;
+        
+    Token flagsTok;
+    bool isRecursive = false;
+    if (lexer.EatIfEqual(Token::Identifier, &flagsTok))
+    {
+        auto flagsName = AsString(flagsTok.value);
+        if (flagsName != "recursive")
+            return false;
+
+        isRecursive = true;
+    }
 
     ExpressionEvaluatorPtr<> ifExpr;
     if (lexer.EatIfEqual(Token::If))
         ifExpr = exprPraser.ParseFullExpression(lexer, false);
 
-    auto renderer = std::make_shared<ForStatement>(vars, valueExpr, ifExpr);
+    auto renderer = std::make_shared<ForStatement>(vars, valueExpr, ifExpr, isRecursive);
     StatementInfo statementInfo = StatementInfo::Create(StatementInfo::ForStatement, pos);
     statementInfo.renderer = renderer;
     statementsInfo.push_back(statementInfo);

test/forloop_test.cpp

@@ -337,3 +337,50 @@ b[1] = image[1];
 }
 
 
+TEST(ForLoopTest, DISABLED_RecursiveLoop)
+{
+    std::string source = R"(
+{%set items=[
+    {'name'='root1', 'children'=[
+            {'name'='child1_1'},
+            {'name'='child1_2'},
+            {'name'='child1_3'}
+        ]},
+    {'name'='root2', 'children'=[
+            {'name'='child2_1'},
+            {'name'='child2_2'},
+            {'name'='child2_3'}
+        ]},
+    {'name'='root3', 'children'=[
+            {'name'='child3_1'},
+            {'name'='child3_2'},
+            {'name'='child3_3'}
+        ]}
+    ] %}
+{% for i in items recursive %}
+{{i.name}} -> {{loop(i.children)}}
+{% endfor %}
+)";
+
+    Template tpl;
+    ASSERT_TRUE(tpl.Load(source));
+
+    ValuesMap params = {};
+
+    std::string result = tpl.RenderAsString(params);
+    std::cout << "[" << result << "]" << std::endl;
+    std::string expectedResult = R"DELIM(
+a[0] = image[0];
+b[0] = image[0];
+b[1] = image[1];
+a[1] = image[1];
+b[0] = image[0];
+b[1] = image[1];
+a[2] = image[2];
+b[0] = image[0];
+b[1] = image[1];
+)DELIM";
+
+    EXPECT_EQ(expectedResult, result);
+}
+