Add wherenot

Author: kaapstorm

README.rst

@@ -109,19 +109,21 @@ Atomic expressions:
 
 Jsonpath operators:
 
-+-------------------------------------+------------------------------------------------------------------------------------+
-| Syntax                              | Meaning                                                                            |
-+=====================================+====================================================================================+
-| *jsonpath1* ``.`` *jsonpath2*       | All nodes matched by *jsonpath2* starting at any node matching *jsonpath1*         |
-+-------------------------------------+------------------------------------------------------------------------------------+
-| *jsonpath* ``[`` *whatever* ``]``   | Same as *jsonpath*\ ``.``\ *whatever*                                              |
-+-------------------------------------+------------------------------------------------------------------------------------+
-| *jsonpath1* ``..`` *jsonpath2*      | All nodes matched by *jsonpath2* that descend from any node matching *jsonpath1*   |
-+-------------------------------------+------------------------------------------------------------------------------------+
-| *jsonpath1* ``where`` *jsonpath2*   | Any nodes matching *jsonpath1* with a child matching *jsonpath2*                   |
-+-------------------------------------+------------------------------------------------------------------------------------+
-| *jsonpath1* ``|`` *jsonpath2*       | Any nodes matching the union of *jsonpath1* and *jsonpath2*                        |
-+-------------------------------------+------------------------------------------------------------------------------------+
++--------------------------------------+-----------------------------------------------------------------------------------+
+| Syntax                               | Meaning                                                                           |
++======================================+===================================================================================+
+| *jsonpath1* ``.`` *jsonpath2*        | All nodes matched by *jsonpath2* starting at any node matching *jsonpath1*        |
++--------------------------------------+-----------------------------------------------------------------------------------+
+| *jsonpath* ``[`` *whatever* ``]``    | Same as *jsonpath*\ ``.``\ *whatever*                                             |
++--------------------------------------+-----------------------------------------------------------------------------------+
+| *jsonpath1* ``..`` *jsonpath2*       | All nodes matched by *jsonpath2* that descend from any node matching *jsonpath1*  |
++--------------------------------------+-----------------------------------------------------------------------------------+
+| *jsonpath1* ``where`` *jsonpath2*    | Any nodes matching *jsonpath1* with a child matching *jsonpath2*                  |
++--------------------------------------+-----------------------------------------------------------------------------------+
+| *jsonpath1* ``wherenot`` *jsonpath2* | Any nodes matching *jsonpath1* with a child not matching *jsonpath2*              |
++--------------------------------------+-----------------------------------------------------------------------------------+
+| *jsonpath1* ``|`` *jsonpath2*        | Any nodes matching the union of *jsonpath1* and *jsonpath2*                       |
++--------------------------------------+-----------------------------------------------------------------------------------+
 
 Field specifiers ( *field* ):
 

jsonpath_ng/jsonpath.py

@@ -330,6 +330,36 @@ def __str__(self):
     def __eq__(self, other):
         return isinstance(other, Where) and other.left == self.left and other.right == self.right
 
+
+class WhereNot(Where):
+    """
+    Identical to ``Where``, but filters for only those nodes that
+    do *not* have a match on the right.
+
+    >>> jsonpath = WhereNot(Fields('spam'), Fields('spam'))
+    >>> jsonpath.find({"spam": {"spam": 1}})
+    []
+    >>> matches = jsonpath.find({"spam": 1})
+    >>> matches[0].value
+    1
+
+    """
+    def find(self, data):
+        return [subdata for subdata in self.left.find(data)
+                if not self.right.find(subdata)]
+
+    def __str__(self):
+        return '%s wherenot %s' % (self.left, self.right)
+
+    def __eq__(self, other):
+        return (isinstance(other, WhereNot)
+                and other.left == self.left
+                and other.right == self.right)
+
+    def __hash__(self):
+        return hash(str(self))
+
+
 class Descendants(JSONPath):
     """
     JSONPath that matches first the left expression then any descendant

jsonpath_ng/lexer.py

@@ -50,7 +50,10 @@ def tokenize(self, string):
 
     literals = ['*', '.', '[', ']', '(', ')', '$', ',', ':', '|', '&', '~']
 
-    reserved_words = { 'where': 'WHERE' }
+    reserved_words = {
+        'where': 'WHERE',
+        'wherenot': 'WHERENOT',
+    }
 
     tokens = ['DOUBLEDOT', 'NUMBER', 'ID', 'NAMED_OPERATOR'] + list(reserved_words.values())
 

jsonpath_ng/parser.py

@@ -63,6 +63,7 @@ def parse_token_stream(self, token_iterator, start_symbol='jsonpath'):
         ('left', '|'),
         ('left', '&'),
         ('left', 'WHERE'),
+        ('left', 'WHERENOT'),
     ]
 
     def p_error(self, t):
@@ -72,6 +73,7 @@ def p_jsonpath_binop(self, p):
         """jsonpath : jsonpath '.' jsonpath
                     | jsonpath DOUBLEDOT jsonpath
                     | jsonpath WHERE jsonpath
+                    | jsonpath WHERENOT jsonpath
                     | jsonpath '|' jsonpath
                     | jsonpath '&' jsonpath"""
         op = p[2]
@@ -82,6 +84,8 @@ def p_jsonpath_binop(self, p):
             p[0] = Descendants(p[1], p[3])
         elif op == 'where':
             p[0] = Where(p[1], p[3])
+        elif op == 'wherenot':
+            p[0] = WhereNot(p[1], p[3])
         elif op == '|':
             p[0] = Union(p[1], p[3])
         elif op == '&':

tests/test_jsonpath.py

@@ -335,6 +335,13 @@ def test_update_descendants_where(self):
              {'foo': {'bar': 3, 'flag': 1}, 'baz': {'bar': 2}})
         ])
 
+    def test_update_descendants_wherenot(self):
+        self.check_update_cases([
+            ({'foo': {'bar': 1, 'flag': 1}, 'baz': {'bar': 2}},
+             '(* wherenot flag) .. bar', 4,
+             {'foo': {'bar': 1, 'flag': 1}, 'baz': {'bar': 4}})
+        ])
+
     def test_update_descendants(self):
         self.check_update_cases([
             ({'somefield': 1}, '$..somefield', 42, {'somefield': 42}),

tests/test_lexer.py

@@ -53,6 +53,7 @@ def test_simple_inputs(self):
         self.assert_lex_equiv('`this`', [self.token('this', 'NAMED_OPERATOR')])
         self.assert_lex_equiv('|', [self.token('|', '|')])
         self.assert_lex_equiv('where', [self.token('where', 'WHERE')])
+        self.assert_lex_equiv('wherenot', [self.token('wherenot', 'WHERENOT')])
 
     def test_basic_errors(self):
         def tokenize(s):

tests/test_parser.py

@@ -54,6 +54,7 @@ def test_atomic(string, parsed):
     ('foo.baz', Child(Fields('foo'), Fields('baz'))),
     ('foo.baz,bizzle', Child(Fields('foo'), Fields('baz', 'bizzle'))),
     ('foo where baz', Where(Fields('foo'), Fields('baz'))),
+    ('foo wherenot baz', WhereNot(Fields('foo'), Fields('baz'))),
     ('foo..baz', Descendants(Fields('foo'), Fields('baz'))),
     ('foo..baz.bing', Descendants(Fields('foo'), Child(Fields('baz'), Fields('bing'))))
 ])