Merge branch 'better-filters' into develop

Implements JEP-9.

Closes #96.
Fixes #83.

* better-filters:
  Fix failing test
  Add failing test
  Incorporate new JEP-9 tokens into new lexer
  Allow for newlines within tokens
  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/lexer.py

@@ -18,11 +18,10 @@ class Lexer(object):
         ',': 'comma',
         ':': 'colon',
         '@': 'current',
-        '&': 'expref',
         '(': 'lparen',
         ')': 'rparen',
         '{': 'lbrace',
-        '}': 'rbrace'
+        '}': 'rbrace',
     }
 
     def tokenize(self, expression):
@@ -60,6 +59,8 @@ def tokenize(self, expression):
                 yield self._consume_raw_string_literal()
             elif self._current == '|':
                 yield self._match_or_else('|', 'or', 'pipe')
+            elif self._current == '&':
+                yield self._match_or_else('&', 'and', 'expref')
             elif self._current == '`':
                 yield self._consume_literal()
             elif self._current in self.START_NUMBER:
@@ -76,7 +77,7 @@ def tokenize(self, expression):
             elif self._current == '>':
                 yield self._match_or_else('=', 'gte', 'gt')
             elif self._current == '!':
-                yield self._match_or_else('=', 'ne', 'unknown')
+                yield self._match_or_else('=', 'ne', 'not')
             elif self._current == '=':
                 yield self._match_or_else('=', 'eq', 'unknown')
             else:

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,15 +269,15 @@ 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 = []
         while not self._current_token() == 'rparen':
-            if self._current_token() == 'current':
-                expression = ast.current_node()
-                self._advance()
-            else:
-                expression = self._expression()
+            expression = self._expression()
             if self._current_token() == 'comma':
                 self._match('comma')
             args.append(expression)
@@ -370,7 +385,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

@@ -93,6 +93,9 @@ def __init__(self, options=None):
         # 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']:
@@ -132,7 +135,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)
@@ -204,6 +207,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']:
@@ -241,6 +258,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):

tests/compliance/basic.json

@@ -14,6 +14,10 @@
             "expression": "foo.bar.baz",
             "result": "correct"
          },
+         {
+            "expression": "foo\n.\nbar\n.baz",
+            "result": "correct"
+         },
          {
             "expression": "foo.bar.baz.bad",
             "result": null