Fix Jinja evaluator to evaluate block expression correctly

If there is a for loop in the Jinja block expression and the item is a complex data type, the current Jinja evaluator converted the item into string type. So if the item is a dictionary, and user tries to access some key value pair, the Jinja evaluator returns an error saying the item is undefined. The Jinja evaluator tries to evaluate individual expression first, even for expression within the for loop, before evaluating the block expression which resulted in the undefined error when the item of the for loop is referenced. To fix, the text is checked to see if there is a Jinja block expression. If there is a Jinja block expression, the entire text is rendered together. Otherwise, if there is no Jinja block expression, then standalone expressions will be rendered individually to preserve type. The method to render Jinja block expression returns string type only.

Author: m4dcoder

CHANGELOG.rst

@@ -13,6 +13,7 @@ Fixed
 ~~~~~
 
 * Allow tasks in the same transition with a "fail" command to run. (bug fix)
+* Fix Jinja block expression to render correctly. (bug fix)
 
 0.5
 ---

orquesta/expressions/jinja.py

@@ -142,42 +142,47 @@ def validate(cls, text):
 
     @classmethod
     def _evaluate_and_expand(cls, text, data=None):
-        output = str_util.unicode(text)
         exprs = cls._regex_parser.findall(text)
         block_exprs = cls._regex_block_parser.findall(text)
         ctx = cls.contextualize(data)
         opts = {'undefined_to_none': False}
 
         try:
-            # Evaluate inline jinja expressions first.
-            for expr in exprs:
-                stripped = cls.strip_delimiter(expr)
-                compiled = cls._jinja_env.compile_expression(stripped, **opts)
-                result = compiled(**ctx)
-
-                if inspect.isgenerator(result):
-                    result = list(result)
-
-                if isinstance(result, six.string_types):
-                    result = cls._evaluate_and_expand(result, data)
-
-                # For StrictUndefined values, UndefinedError only gets raised when the value is
-                # accessed, not when it gets created. The simplest way to access it is to try
-                # and cast it to string. When StrictUndefined is cast to str below, this will
-                # raise an exception with error description.
-                if not isinstance(result, jinja2.runtime.StrictUndefined):
-                    if len(exprs) > 1 or block_exprs or len(output) > len(expr):
-                        output = output.replace(expr, str_util.unicode(result, force=True))
-                    else:
-                        output = str_util.unicode(result)
-
-            # Evaluate jinja block(s) after inline expressions are evaluated.
-            if block_exprs and isinstance(output, six.string_types):
-                output = cls._jinja_env.from_string(output).render(ctx)
+            # If there is a Jinja block expression in the text, then process the whole text.
+            if block_exprs:
+                expr = text
+                output = cls._jinja_env.from_string(expr).render(ctx)
+                output = str_util.unicode(output)
 
                 # Traverse and evaulate again in case additional inline epxressions are
                 # introduced after the jinja block is evaluated.
                 output = cls._evaluate_and_expand(output, data)
+            else:
+                # The output will first be the original text and the expressions
+                # will be substituted by the evaluated value.
+                output = str_util.unicode(text)
+
+                # Evaluate inline jinja expressions first.
+                for expr in exprs:
+                    stripped = cls.strip_delimiter(expr)
+                    compiled = cls._jinja_env.compile_expression(stripped, **opts)
+                    result = compiled(**ctx)
+
+                    if inspect.isgenerator(result):
+                        result = list(result)
+
+                    if isinstance(result, six.string_types):
+                        result = cls._evaluate_and_expand(result, data)
+
+                    # For StrictUndefined values, UndefinedError only gets raised when the value is
+                    # accessed, not when it gets created. The simplest way to access it is to try
+                    # and cast it to string. When StrictUndefined is cast to str below, this will
+                    # raise an exception with error description.
+                    if not isinstance(result, jinja2.runtime.StrictUndefined):
+                        if len(exprs) > 1 or block_exprs or len(output) > len(expr):
+                            output = output.replace(expr, str_util.unicode(result, force=True))
+                        else:
+                            output = str_util.unicode(result)
 
         except jinja2.exceptions.UndefinedError as e:
             msg = "Unable to evaluate expression '%s'. %s: %s"

orquesta/tests/unit/expressions/test_jinja_eval_raw_blocks.py

@@ -43,6 +43,20 @@ def test_block_eval(self):
 
         self.assertEqual('abc', self.evaluator.evaluate(expr, data))
 
+    def test_block_eval_complex_data(self):
+        expr = '{% for i in ctx().x %}{{ i.k }}{{ ctx().z }}{% endfor %}'
+
+        data = {
+            'x': [
+                {'k': 'a'},
+                {'k': 'b'},
+                {'k': 'c'}
+            ],
+            'z': '->'
+        }
+
+        self.assertEqual('a->b->c->', self.evaluator.evaluate(expr, data))
+
     def test_block_eval_undefined(self):
         expr = '{% for i in ctx().x %}{{ ctx().y }}{% endfor %}'