Implement 'in' tester

* Begin implementing testers

* Test for 'gt', 'ge', 'lt' and 'le' testers

* Implement 'defined' and 'undefined' testers

* Fix build

* Implement 'iterable', 'mapping', 'number', 'sequence' and 'string' testers

* Implement 'in' tester

Author: flexferrum

src/expression_evaluator.cpp

@@ -47,10 +47,23 @@ InternalValue UnaryExpression::Evaluate(RenderContext& values)
     return Apply<visitors::UnaryOperation>(m_expr->Evaluate(values), m_oper);
 }
 
+BinaryExpression::BinaryExpression(BinaryExpression::Operation oper, ExpressionEvaluatorPtr<> leftExpr, ExpressionEvaluatorPtr<> rightExpr)
+    : m_oper(oper)
+    , m_leftExpr(leftExpr)
+    , m_rightExpr(rightExpr)
+{
+    if (m_oper == In)
+    {
+        CallParams params;
+        params.kwParams["seq"] = rightExpr;
+        m_inTester = CreateTester("in", params);
+    }
+}
+
 InternalValue BinaryExpression::Evaluate(RenderContext& context)
 {
     InternalValue leftVal = m_leftExpr->Evaluate(context);
-    InternalValue rightVal = m_rightExpr->Evaluate(context);
+    InternalValue rightVal = m_oper == In ? InternalValue() : m_rightExpr->Evaluate(context);
     InternalValue result;
 
     switch (m_oper)
@@ -64,7 +77,6 @@ InternalValue BinaryExpression::Evaluate(RenderContext& context)
     case jinja2::BinaryExpression::LogicalLt:
     case jinja2::BinaryExpression::LogicalGe:
     case jinja2::BinaryExpression::LogicalLe:
-    case jinja2::BinaryExpression::In:
     case jinja2::BinaryExpression::Plus:
     case jinja2::BinaryExpression::Minus:
     case jinja2::BinaryExpression::Mul:
@@ -74,6 +86,11 @@ InternalValue BinaryExpression::Evaluate(RenderContext& context)
     case jinja2::BinaryExpression::Pow:
         result = Apply2<visitors::BinaryMathOperation>(leftVal, rightVal, m_oper);
         break;
+    case jinja2::BinaryExpression::In:
+    {
+        result = m_inTester->Test(leftVal, context);
+        break;
+    }
     case jinja2::BinaryExpression::StringConcat:
     default:
         break;

src/expression_evaluator.h

@@ -185,6 +185,27 @@ class UnaryExpression : public Expression
     ExpressionEvaluatorPtr<> m_expr;
 };
 
+class IsExpression : public Expression
+{
+public:
+    virtual ~IsExpression() {}
+
+    struct ITester
+    {
+        virtual ~ITester() {}
+        virtual bool Test(const InternalValue& baseVal, RenderContext& context) = 0;
+    };
+
+    using TesterFactoryFn = std::function<std::shared_ptr<ITester> (CallParams params)>;
+
+    IsExpression(ExpressionEvaluatorPtr<> value, std::string tester, CallParams params);
+    InternalValue Evaluate(RenderContext& context) override;
+
+private:
+    ExpressionEvaluatorPtr<> m_value;
+    std::shared_ptr<ITester> m_tester;
+};
+
 class BinaryExpression : public Expression
 {
 public:
@@ -216,38 +237,15 @@ class BinaryExpression : public Expression
         CaseInsensitive = 1
     };
 
-    BinaryExpression(Operation oper, ExpressionEvaluatorPtr<> leftExpr, ExpressionEvaluatorPtr<> rightExpr)
-        : m_oper(oper)
-        , m_leftExpr(leftExpr)
-        , m_rightExpr(rightExpr)
-    {}
+    BinaryExpression(Operation oper, ExpressionEvaluatorPtr<> leftExpr, ExpressionEvaluatorPtr<> rightExpr);
     InternalValue Evaluate(RenderContext&) override;
 private:
     Operation m_oper;
     ExpressionEvaluatorPtr<> m_leftExpr;
     ExpressionEvaluatorPtr<> m_rightExpr;
+    std::shared_ptr<IsExpression::ITester> m_inTester;
 };
 
-class IsExpression : public Expression
-{
-public:
-    virtual ~IsExpression() {}
-
-    struct ITester
-    {
-        virtual ~ITester() {}
-        virtual bool Test(const InternalValue& baseVal, RenderContext& context) = 0;
-    };
-
-    using TesterFactoryFn = std::function<std::shared_ptr<ITester> (CallParams params)>;
-
-    IsExpression(ExpressionEvaluatorPtr<> value, std::string tester, CallParams params);
-    InternalValue Evaluate(RenderContext& context) override;
-
-private:
-    ExpressionEvaluatorPtr<> m_value;
-    std::shared_ptr<ITester> m_tester;
-};
 
 class CallExpression : public Expression
 {

src/testers.cpp

@@ -108,6 +108,7 @@ ValueTester::ValueTester(TesterParams params, ValueTester::Mode mode)
     case IsEvenMode:
         break;
     case IsInMode:
+        ParseParams({{"seq", true}}, params);
         break;
     case IsIterableMode:
         break;
@@ -212,7 +213,27 @@ bool ValueTester::Test(const InternalValue& baseVal, RenderContext& context)
         result = valKind == ValueKind::Empty;
         break;
     case IsInMode:
+    {
+        bool isConverted = false;
+        auto seq = GetArgumentValue("seq", context);
+        ListAdapter values = ConvertToList(seq, InternalValue(), isConverted);
+
+        if (!isConverted)
+            return false;
+
+        auto equalComparator = [&baseVal](auto& val) {
+            InternalValue cmpRes;
+
+            cmpRes = Apply2<visitors::BinaryMathOperation>(val, baseVal, BinaryExpression::LogicalEq);
+
+            return ConvertToBool(cmpRes);
+        };
+
+        auto p = std::find_if(values.begin(), values.end(), equalComparator);
+        result = p != values.end();
+
         break;
+    }
     case IsEvenMode:
         break;
     case IsOddMode:

test/testers_test.cpp

@@ -204,7 +204,7 @@ INSTANTIATE_TEST_CASE_P(NumberTest, TestersGenericTest, ::testing::Values(
                             InputOutputPair{"reflectedVal is number",   "false"},
                             InputOutputPair{"reflectedList is number",  "false"}
                             ));
-                            
+
 INSTANTIATE_TEST_CASE_P(SequenceTest, TestersGenericTest, ::testing::Values(
                             InputOutputPair{"0 is sequence",              "false"},
                             InputOutputPair{"'intList' is sequence",      "false"},
@@ -225,7 +225,7 @@ INSTANTIATE_TEST_CASE_P(SequenceTest, TestersGenericTest, ::testing::Values(
                             InputOutputPair{"reflectedList is sequence",  "true"}
                             ));
 
-                            
+
 INSTANTIATE_TEST_CASE_P(StringTest, TestersGenericTest, ::testing::Values(
                             InputOutputPair{"0 is string",              "false"},
                             InputOutputPair{"'intList' is string",      "true"},
@@ -245,3 +245,13 @@ INSTANTIATE_TEST_CASE_P(StringTest, TestersGenericTest, ::testing::Values(
                             InputOutputPair{"reflectedVal is string",   "false"},
                             InputOutputPair{"reflectedList is string",  "false"}
                             ));
+
+
+INSTANTIATE_TEST_CASE_P(InTest, TestersGenericTest, ::testing::Values(
+                            InputOutputPair{"0 in (2, 1, 0)",           "true"},
+                            InputOutputPair{"0 in (1, 2, 3)",           "false"},
+                            InputOutputPair{"0 in intList",             "true"},
+                            InputOutputPair{"1000 in intList",          "false"},
+                            InputOutputPair{"'string9' in stringList",  "true"},
+                            InputOutputPair{"'string90' in stringList", "false"}
+                            ));