Fully implement 'sort' and 'join' filters

jinja2cpp · flexferrum · May 19, 2018 · May 7, 2018 · May 7, 2018 · May 7, 2018
commit e9590d7794692bfb767de76a5bcf90d9ba2fb036
diff --git a/src/expression_evaluator.cpp b/src/expression_evaluator.cpp
@@ -382,6 +382,9 @@ ParsedArguments ParseCallParams(const std::initializer_list<ArgumentInfo>& args,
     {
         if (isFirstTime)
         {
+            for (; startPosArg < args.size() && (argsInfo[startPosArg].state == Keyword || argsInfo[startPosArg].state == Positional); ++ startPosArg)
+                ;
+
             isFirstTime = false;
             continue;
         }

diff --git a/src/expression_evaluator.h b/src/expression_evaluator.h
@@ -209,6 +209,13 @@ class BinaryExpression : public Expression
         StringConcat
     };
 
+    enum CompareType
+    {
+        Undefined = 0,
+        CaseSensitive = 0,
+        CaseInsensitive = 1
+    };
+
     BinaryExpression(Operation oper, ExpressionEvaluatorPtr<> leftExpr, ExpressionEvaluatorPtr<> rightExpr)
         : m_oper(oper)
         , m_leftExpr(leftExpr)

diff --git a/src/filters.cpp b/src/filters.cpp
@@ -26,7 +26,11 @@ Value Join::Filter(const Value& baseVal, RenderContext& context)
     if (!baseVal.isList())
         return Value();
 
-    auto& values = baseVal.asList();
+    auto attrExpr = m_args["attribute"];
+    Value attrName = attrExpr ? attrExpr->Evaluate(context) : Value();
+
+    ValuesList values = boost::apply_visitor(visitors::ListEvaluator(attrName), baseVal.data());
+
     bool isFirst = true;
     Value result;
     Value delimiter = m_args["d"]->Evaluate(context);
@@ -45,64 +49,32 @@ Value Join::Filter(const Value& baseVal, RenderContext& context)
 
 Sort::Sort(FilterParams params)
 {
-    ParseParams({{"attribute", true}}, params);
+    ParseParams({{"reverse", false, Value(false)}, {"case_sensitive", false, Value(false)}, {"attribute", false}}, params);
 }
 
-struct GetAsValuesListVisitor : boost::static_visitor<ValuesList>
-{
-    GetAsValuesListVisitor(Value attr = Value())
-        : m_attr(std::move(attr))
-    {}
-
-    ValuesList operator() (const ValuesList& values) const
-    {
-        if (m_attr.isEmpty())
-            return values;
-
-        ValuesList result;
-        std::transform(values.begin(), values.end(), std::back_inserter(result), [this](const Value& val) {return val.subscript(m_attr);});
-        return result;
-    }
-
-    ValuesList operator() (const GenericList& values) const
-    {
-        int64_t size = values.GetSize();
-
-        ValuesList result;
-        for (int64_t idx = 0; idx < size; ++ idx)
-        {
-            auto val = values.GetValueByIndex(idx);
-            if (!m_attr.isEmpty())
-                result.push_back(val.subscript(m_attr));
-            else
-                result.push_back(val);
-        }
-
-        return result;
-    }
-
-    template<typename U>
-    ValuesList operator() (U&&) const
-    {
-        return ValuesList();
-    }
-
-    Value m_attr;
-};
-
 Value Sort::Filter(const Value& baseVal, RenderContext& context)
 {
-    Value attrName = m_args["attribute"]->Evaluate(context);
-    ValuesList values = boost::apply_visitor(GetAsValuesListVisitor(), baseVal.data());
+    auto attrExpr = m_args["attribute"];
+    auto isReverseExpr = m_args["reverse"];
+    auto isCsExpr = m_args["case_sensitive"];
+    Value attrName = attrExpr ? attrExpr->Evaluate(context) : Value();
+    Value isReverseVal = isReverseExpr ? isReverseExpr->Evaluate(context) : Value(false);
+    Value isCsVal = isCsExpr ? isCsExpr->Evaluate(context) : Value(false);
+
+    ValuesList values = Apply<visitors::ListEvaluator>(baseVal);
+    BinaryExpression::Operation oper =
+            Apply<visitors::BooleanEvaluator>(isReverseVal) ? BinaryExpression::LogicalGt : BinaryExpression::LogicalLt;
+    BinaryExpression::CompareType compType =
+            Apply<visitors::BooleanEvaluator>(isCsVal) ? BinaryExpression::CaseSensitive : BinaryExpression::CaseInsensitive;
 
-    std::sort(values.begin(), values.end(), [&attrName](auto& val1, auto& val2) {
+    std::sort(values.begin(), values.end(), [&attrName, oper, compType](auto& val1, auto& val2) {
         Value cmpRes;
         if (attrName.isEmpty())
-            cmpRes = boost::apply_visitor(visitors::BinaryMathOperation(BinaryExpression::LogicalLt), val1.data(), val2.data());
+            cmpRes = boost::apply_visitor(visitors::BinaryMathOperation(oper, compType), val1.data(), val2.data());
         else
-            cmpRes = boost::apply_visitor(visitors::BinaryMathOperation(BinaryExpression::LogicalLt), val1.subscript(attrName).data(), val2.subscript(attrName).data());
+            cmpRes = boost::apply_visitor(visitors::BinaryMathOperation(oper, compType), val1.subscript(attrName).data(), val2.subscript(attrName).data());
 
-        return boost::apply_visitor(visitors::BooleanEvaluator(), cmpRes.data());
+        return Apply<visitors::BooleanEvaluator>(cmpRes);
     });
 
     return values;

diff --git a/src/value_visitors.h b/src/value_visitors.h
@@ -4,6 +4,8 @@
 #include "expression_evaluator.h"
 #include "jinja2cpp/value.h"
 
+#include <boost/algorithm/string/predicate.hpp>
+
 #include <iostream>
 #include <cmath>
 #include <limits>
@@ -217,8 +219,9 @@ struct BinaryMathOperation : BaseVisitor<>
                || std::abs(x - y) < std::numeric_limits<double>::min();
     }
 
-    BinaryMathOperation(BinaryExpression::Operation oper)
+    BinaryMathOperation(BinaryExpression::Operation oper, BinaryExpression::CompareType compType = BinaryExpression::CaseSensitive)
         : m_oper(oper)
+        , m_compType(compType)
     {
     }
 
@@ -333,7 +336,8 @@ struct BinaryMathOperation : BaseVisitor<>
         return this->operator ()(static_cast<double>(left), static_cast<double>(right));
     }
 
-    Value operator() (const std::string& left, const std::string& right) const
+    template<typename CharT>
+    Value operator() (const std::basic_string<CharT>& left, const std::basic_string<CharT>& right) const
     {
         Value result;
         switch (m_oper)
@@ -342,55 +346,36 @@ struct BinaryMathOperation : BaseVisitor<>
             result = left + right;
             break;
         case jinja2::BinaryExpression::LogicalEq:
-            result = left == right;
+            result = m_compType == BinaryExpression::CaseSensitive ? left == right : boost::iequals(left, right);
             break;
         case jinja2::BinaryExpression::LogicalNe:
-            result = left != right;
+            result = m_compType == BinaryExpression::CaseSensitive ? left != right : !boost::iequals(left, right);
             break;
         case jinja2::BinaryExpression::LogicalGt:
-            result = left > right;
+            result = m_compType == BinaryExpression::CaseSensitive ? left > right : boost::lexicographical_compare(right, left, boost::algorithm::is_iless());
             break;
         case jinja2::BinaryExpression::LogicalLt:
-            result = left < right;
+            result = m_compType == BinaryExpression::CaseSensitive ? left < right : boost::lexicographical_compare(left, right, boost::algorithm::is_iless());
             break;
         case jinja2::BinaryExpression::LogicalGe:
-            result = left >= right;
+            if (m_compType == BinaryExpression::CaseSensitive)
+            {
+                result = left >= right;
+            }
+            else
+            {
+                result = boost::iequals(left, right) ? true : boost::lexicographical_compare(right, left, boost::algorithm::is_iless());
+            }
             break;
         case jinja2::BinaryExpression::LogicalLe:
-            result = left <= right;
-            break;
-        default:
-            break;
-        }
-
-        return result;
-    }
-
-    Value operator() (const std::wstring& left, const std::wstring& right) const
-    {
-        Value result;
-        switch (m_oper)
-        {
-        case jinja2::BinaryExpression::Plus:
-            result = left + right;
-            break;
-        case jinja2::BinaryExpression::LogicalEq:
-            result = left == right;
-            break;
-        case jinja2::BinaryExpression::LogicalNe:
-            result = left != right;
-            break;
-        case jinja2::BinaryExpression::LogicalGt:
-            result = left > right;
-            break;
-        case jinja2::BinaryExpression::LogicalLt:
-            result = left < right;
-            break;
-        case jinja2::BinaryExpression::LogicalGe:
-            result = left >= right;
-            break;
-        case jinja2::BinaryExpression::LogicalLe:
-            result = left <= right;
+            if (m_compType == BinaryExpression::CaseSensitive)
+            {
+                result = left <= right;
+            }
+            else
+            {
+                result = boost::iequals(left, right) ? true : boost::lexicographical_compare(left, right, boost::algorithm::is_iless());
+            }
             break;
         default:
             break;
@@ -474,6 +459,7 @@ struct BinaryMathOperation : BaseVisitor<>
     }
 
     BinaryExpression::Operation m_oper;
+    BinaryExpression::CompareType m_compType;
 };
 
 struct BooleanEvaluator : boost::static_visitor<bool>
@@ -536,6 +522,49 @@ struct IntegerEvaluator : public boost::static_visitor<int64_t>
     }
 };
 
+
+struct ListEvaluator : boost::static_visitor<ValuesList>
+{
+    ListEvaluator(Value attr = Value())
+        : m_attr(std::move(attr))
+    {}
+
+    ValuesList operator() (const ValuesList& values) const
+    {
+        if (m_attr.isEmpty())
+            return values;
+
+        ValuesList result;
+        std::transform(values.begin(), values.end(), std::back_inserter(result), [this](const Value& val) {return val.subscript(m_attr);});
+        return result;
+    }
+
+    ValuesList operator() (const GenericList& values) const
+    {
+        int64_t size = values.GetSize();
+
+        ValuesList result;
+        for (int64_t idx = 0; idx < size; ++ idx)
+        {
+            auto val = values.GetValueByIndex(idx);
+            if (!m_attr.isEmpty())
+                result.push_back(val.subscript(m_attr));
+            else
+                result.push_back(val);
+        }
+
+        return result;
+    }
+
+    template<typename U>
+    ValuesList operator() (U&&) const
+    {
+        return ValuesList();
+    }
+
+    Value m_attr;
+};
+
 struct StringJoiner : BaseVisitor<>
 {
     using BaseVisitor::operator ();
@@ -552,6 +581,19 @@ struct StringJoiner : BaseVisitor<>
 };
 
 } // visitors
+
+template<typename V, typename ValType, typename ... Args>
+auto Apply(ValType&& val, Args&& ... args)
+{
+    return boost::apply_visitor(V(std::forward<Args>(args)...), std::forward<ValType>(val).data());
+}
+
+template<typename V, typename ValType, typename ... Args>
+auto Apply(ValType&& val1, ValType&& val2, Args&& ... args)
+{
+    return boost::apply_visitor(V(std::forward<Args>(args)...), std::forward<ValType>(val1).data(), std::forward<ValType>(val2).data());
+}
+
 } // jinja2
 
 #endif // VALUE_VISITORS_H
diff --git a/test/filters_test.cpp b/test/filters_test.cpp
@@ -6,53 +6,55 @@
 
 using namespace jinja2;
 
-struct JoinTestTag;
-using JoinTest = InputOutputPairTest<JoinTestTag>;
+struct FilterGenericTestTag;
+using FilterGenericTest = InputOutputPairTest<FilterGenericTestTag>;
 
-TEST_P(JoinTest, IntegersRangeLoop)
+struct ListIteratorTestTag;
+using ListIteratorTest = InputOutputPairTest<ListIteratorTestTag>;
+
+TEST_P(FilterGenericTest, Test)
 {
     auto& testParam = GetParam();
     std::string source = "{{" + testParam.tpl + "}}";
 
     Template tpl;
     ASSERT_TRUE(tpl.Load(source));
 
-    ValuesList testData;
-    for (int n = 0; n < 10; ++ n)
-    {
-        TestStruct s;
-        std::ostringstream str;
-        std::wostringstream wstr;
-
-        str << "test string " << n;
-        wstr << L"test string " << n;
-
-        s.intValue = n;
-        s.dblValue = static_cast<double>(n) / 2;
-        s.boolValue = n % 2 == 1;
-        s.strValue = str.str();
-        s.wstrValue = wstr.str();
-
-        testData.push_back(Reflect(std::move(s)));
-    }
-
-    ValuesMap params = {
-        {"intValue", 3},
-        {"doubleValue", 12.123f},
-        {"stringValue", "rain"},
-        {"boolFalseValue", false},
-        {"boolTrueValue", true},
-        {"reflectedList", std::move(testData)}
-    };
-
-    std::string result = tpl.RenderAsString(params);
+    std::string result = tpl.RenderAsString(PrepareTestData());
+    std::cout << result << std::endl;
+    std::string expectedResult = testParam.result;
+    EXPECT_EQ(expectedResult, result);
+}
+
+TEST_P(ListIteratorTest, Test)
+{
+    auto& testParam = GetParam();
+    std::string source = "{% for i in " + testParam.tpl + "%}{{i}}{{', ' if not loop.last}}{% endfor %}";
+
+    Template tpl;
+    ASSERT_TRUE(tpl.Load(source));
+
+    std::string result = tpl.RenderAsString(PrepareTestData());
     std::cout << result << std::endl;
     std::string expectedResult = testParam.result;
     EXPECT_EQ(expectedResult, result);
 }
 
-INSTANTIATE_TEST_CASE_P(StringJoin, JoinTest, ::testing::Values(
-                            InputOutputPair{"['str1', 'str2', 'str3'] | join", "str1str2str3"},
-                            InputOutputPair{"['str1', 'str2', 'str3'] | join(' ')", "str1 str2 str3"},
-                            InputOutputPair{"['str1', 'str2', 'str3'] | join(d='-')", "str1-str2-str3"}
+INSTANTIATE_TEST_CASE_P(StringJoin, FilterGenericTest, ::testing::Values(
+                            InputOutputPair{"['str1', 'str2', 'str3'] | join",                   "str1str2str3"},
+                            InputOutputPair{"['str1', 'str2', 'str3'] | join(' ')",              "str1 str2 str3"},
+                            InputOutputPair{"['str1', 'str2', 'str3'] | join(d='-')",            "str1-str2-str3"},
+                            InputOutputPair{"reflectedList | join(d='-', 'strValue')",           "test string 0-test string 1-test string 2-test string 3-test string 4-test string 5-test string 6-test string 7-test string 8-test string 9"},
+                            InputOutputPair{"reflectedList | join(attribute='strValue', '-')",   "test string 0-test string 1-test string 2-test string 3-test string 4-test string 5-test string 6-test string 7-test string 8-test string 9"},
+                            InputOutputPair{"reflectedList | join(attribute='strValue', d='-')", "test string 0-test string 1-test string 2-test string 3-test string 4-test string 5-test string 6
5F2F
-test string 7-test string 8-test string 9"}
+                            ));
+
+INSTANTIATE_TEST_CASE_P(Sort, ListIteratorTest, ::testing::Values(
+                            InputOutputPair{"['str1', 'str2', 'str3'] | sort",                                    "str1, str2, str3"},
+                            InputOutputPair{"['str2', 'str1', 'str3'] | sort",                                    "str1, str2, str3"},
+                            InputOutputPair{"['Str2', 'str1', 'str3'] | sort",                                    "str1, Str2, str3"},
+                            InputOutputPair{"['Str2', 'str1', 'str3'] | sort(reverse=true)",                      "str3, Str2, str1"},
+                            InputOutputPair{"['Str2', 'str1', 'str3'] | sort(case_sensitive=true)",               "Str2, str1, str3"},
+                            InputOutputPair{"['Str2', 'str1', 'str3'] | sort(case_sensitive=true, reverse=true)", "str3, str1, Str2"},
+                            InputOutputPair{"[3, 1, 2] | sort",                                                   "1, 2, 3"}
                             ));