Initial commit of improved filters (JEP 9)

Author: jamesls

jmespath/ast.py

@@ -62,6 +62,14 @@ def or_expression(left, right):
     return {"type": "or_expression", "children": [left, right]}
 
 
+def and_expression(left, right):
+    return {"type": "and_expression", "children": [left, right]}
+
+
+def not_expression(expr):
+    return {"type": "not_expression", "children": [expr]}
+
+
 def pipe(left, right):
     return {'type': 'pipe', 'children': [left, right]}
 

jmespath/parser.py

@@ -48,21 +48,27 @@ class Parser(object):
         'expref': 0,
         'colon': 0,
         'pipe': 1,
-        'eq': 2,
-        'gt': 2,
-        'lt': 2,
-        'gte': 2,
-        'lte': 2,
-        'ne': 2,
-        'or': 5,
-        'flatten': 6,
+        'or': 2,
+        'and': 3,
+        'eq': 5,
+        'gt': 5,
+        'lt': 5,
+        'gte': 5,
+        'lte': 5,
+        'ne': 5,
+        'flatten': 9,
+        # Everything above stops a projection.
         'star': 20,
         'filter': 21,
         'dot': 40,
+        'not': 45,
         'lbrace': 50,
         'lbracket': 55,
         'lparen': 60,
     }
+    # The maximum binding power for a token that can stop
+    # a projection.
+    _PROJECTION_STOP = 10
     # The _MAX_SIZE most recent expressions are cached in
     # _CACHE dict.
     _CACHE = {}
@@ -161,12 +167,21 @@ def _token_nud_filter(self, token):
     def _token_nud_lbrace(self, token):
         return self._parse_multi_select_hash()
 
+    def _token_nud_lparen(self, token):
+        expression = self._expression()
+        self._match('rparen')
+        return expression
+
     def _token_nud_flatten(self, token):
         left = ast.flatten(ast.identity())
         right = self._parse_projection_rhs(
             self.BINDING_POWER['flatten'])
         return ast.projection(left, right)
 
+    def _token_nud_not(self, token):
+        expr = self._expression(self.BINDING_POWER['not'])
+        return ast.not_expression(expr)
+
     def _token_nud_lbracket(self, token):
         if self._current_token() in ['number', 'colon']:
             right = self._parse_index_expression()
@@ -254,6 +269,10 @@ def _token_led_or(self, left):
         right = self._expression(self.BINDING_POWER['or'])
         return ast.or_expression(left, right)
 
+    def _token_led_and(self, left):
+        right = self._expression(self.BINDING_POWER['and'])
+        return ast.and_expression(left, right)
+
     def _token_led_lparen(self, left):
         name = left['value']
         args = []
@@ -370,7 +389,7 @@ def _parse_multi_select_hash(self):
 
     def _parse_projection_rhs(self, binding_power):
         # Parse the right hand side of the projection.
-        if self.BINDING_POWER[self._current_token()] < 10:
+        if self.BINDING_POWER[self._current_token()] < self._PROJECTION_STOP:
             # BP of 10 are all the tokens that stop a projection.
             right = ast.identity()
         elif self._current_token() == 'lbracket':

jmespath/visitor.py

@@ -75,6 +75,9 @@ def __init__(self):
         # properly freed.
         self._functions.interpreter = self
 
+    def default_visit(self, node, *args, **kwargs):
+        raise NotImplementedError(node['type'])
+
     def visit_subexpression(self, node, value):
         result = value
         for node in node['children']:
@@ -114,7 +117,7 @@ def visit_filter_projection(self, node, value):
         comparator_node = node['children'][2]
         collected = []
         for element in base:
-            if self.visit(comparator_node, element):
+            if self._is_true(self.visit(comparator_node, element)):
                 current = self.visit(node['children'][1], element)
                 if current is not None:
                     collected.append(current)
@@ -186,6 +189,20 @@ def visit_or_expression(self, node, value):
             matched = self.visit(node['children'][1], value)
         return matched
 
+    def visit_and_expression(self, node, value):
+        matched = self.visit(node['children'][0], value)
+        if self._is_false(matched):
+            return matched
+        return self.visit(node['children'][1], value)
+
+    def visit_not_expression(self, node, value):
+        original_result = self.visit(node['children'][0], value)
+        if original_result is 0:
+            # Special case for 0, !0 should be false, not true.
+            # 0 is not a special cased integer in jmespath.
+            return False
+        return not original_result
+
     def visit_pipe(self, node, value):
         result = value
         for node in node['children']:
@@ -223,6 +240,9 @@ def _is_false(self, value):
         return (value == '' or value == [] or value == {} or value is None or
                 value is False)
 
+    def _is_true(self, value):
+        return not self._is_false(value)
+
 
 class GraphvizVisitor(Visitor):
     def __init__(self):