Feature/ternary operator (#33)

* updated project system around poetry (#29)

* updated project system around poetry

* github workflows

* updated package dependencies

* added compliance CLI tool

* [ternary] supports tokenizing ternary operator expressions

* [ternary] supports parsing ternary operator expressions

* [ternary] supports ternary operator expressions

* Updated reference to compliance tests.

Author: springcomp

jmespath/ast.py

@@ -112,3 +112,7 @@ def value_projection(left, right):
 
 def variable_ref(name):
     return {"type": "variable_ref", "children": [], "value": name}
+
+
+def ternary_operator(condition, left, right):
+    return {"type": "ternary_operator", "children": [condition, left, right]}

jmespath/lexer.py

@@ -24,6 +24,7 @@ class Lexer(object):
         '}': 'rbrace',
         '+': 'plus',
         '%': 'modulo',
+        '?': 'question',
         u'\u2212': 'minus',
         u'\u00d7': 'multiply',
         u'\u00f7': 'divide',

jmespath/parser.py

@@ -53,8 +53,9 @@ class Parser(object):
         'expref': 0,
         'colon': 0,
         'pipe': 1,
-        'or': 2,
-        'and': 3,
+        'question': 2,
+        'or': 3,
+        'and': 4,
         'eq': 5,
         'gt': 5,
         'lt': 5,
@@ -413,6 +414,12 @@ def _token_led_lbracket(self, left):
             self._match('rbracket')
             right = self._parse_projection_rhs(self.BINDING_POWER['star'])
             return ast.projection(left, right)
+    
+    def _token_led_question(self, condition):
+        left = self._expression()
+        self._match('colon')
+        right = self._expression()
+        return ast.ternary_operator(condition, left, right)
 
     def _project_if_slice(self, left, right):
         index_expr = ast.index_expression([left, right])

jmespath/visitor.py

@@ -361,6 +361,17 @@ def visit_variable_ref(self, node, value):
         except KeyError:
             raise exceptions.UndefinedVariable(node['value'])
 
+    def visit_ternary_operator(self, node, value):
+        condition = node['children'][0]
+        evaluation = self.visit(condition, value)
+
+        if self._is_false(evaluation):
+            falsyNode = node['children'][2]
+            return self.visit(falsyNode, value)
+        else:
+            truthyNode = node['children'][1]
+            return self.visit(truthyNode, value)
+
     def visit_value_projection(self, node, value):
         base = self.visit(node['children'][0], value)
         try:

tests/test_lexer.py

@@ -221,6 +221,20 @@ def test_variable(self):
               ]
         )
 
+    def test_ternary(self):
+        tokens = list(self.lexer.tokenize('true ? false : foo'))
+        self.assertEqual(
+            tokens,
+            [
+                { 'type': 'unquoted_identifier', 'value': 'true', 'start': 0, 'end': 4 },
+                { 'type': 'question', 'value': '?', 'start': 5, 'end': 6 },
+                { 'type': 'unquoted_identifier', 'value': 'false', 'start': 7, 'end': 12 },
+                { 'type': 'colon', 'value': ':', 'start': 13, 'end': 14 },
+                { 'type': 'unquoted_identifier', 'value': 'foo', 'start': 15, 'end': 18 },
+                { 'type': 'eof', 'value': '', 'start': 18, 'end': 18 }
+            ]
+        )
+
     def test_unknown_character(self):
         with self.assertRaises(LexerError) as e:
             tokens = list(self.lexer.tokenize('foo[0^]'))

tests/test_parser.py

@@ -352,6 +352,29 @@ def test_trailing_merged_operator(self):
              ["five", "six"], ["seven", "eight"],
              ["nine"], ["ten"]])
 
+class TestTernaryOperatorExpressions(unittest.TestCase):
+    def setUp(self):
+        self.parser = parser.Parser()
+        self.data = {
+            'true': True,
+            'false': False,
+            'foo': 'foo',
+            'bar': 'bar',
+            'baz': 'baz',
+            'qux': 'qux',
+            'quux': 'quux'
+        }
+
+    def test_ternaryOperatorExpression(self):
+        parsed = self.parser.parse('true ? foo : bar')
+        match = parsed.search(self.data)
+        self.assertEqual(match, 'foo')
+
+    def test_nestedTernaryOperatorExpressions(self):
+        parsed = self.parser.parse('foo ? bar ? baz : qux : quux')
+        match = parsed.search(self.data)
+        self.assertEqual(match, 'baz')
+
 
 class TestParserCaching(unittest.TestCase):
     def test_compile_lots_of_expressions(self):