add delete to index/slice/root/this/where

Author: wangjild

jsonpath_rw/jsonpath.py

@@ -184,6 +184,9 @@ def find(self, data):
     def update(self, data, val):
         return val
 
+    def delete(self, data):
+        return None
+
     def __str__(self):
         return '$'
 
@@ -204,6 +207,9 @@ def find(self, datum):
     def update(self, data, val):
         return val
 
+    def delete(self, data):
+        return None
+
     def __str__(self):
         return '`this`'
 
@@ -239,6 +245,11 @@ def update(self, data, val):
             self.right.update(datum.value, val)
         return data
 
+    def delete(self, data):
+        for datum in self.left.find(data):
+            self.right.delete(datum.value)
+        return data
+
     def __eq__(self, other):
         return isinstance(other, Child) and self.left == other.left and self.right == other.right
 
@@ -291,6 +302,12 @@ def update(self, data, val):
             datum.path.update(data, val)
         return data
 
+    def delete(self, data):
+        for path in reversed([datum.path for datum in self.find(data)]):
+            path.delete(data)
+
+        return data
+
     def __str__(self):
         return '%s where %s' % (self.left, self.right)
 
@@ -343,36 +360,45 @@ def match_recursively(datum):
                 for left_match in left_matches
                 for submatch in match_recursively(left_match)]
 
-    def is_singular():
+    def is_singular(self):
         return False
 
-    def update(self, data, val):
+    def _modify(self, data, val = None, delete = False):
         # Get all left matches into a list
         left_matches = self.left.find(data)
         if not isinstance(left_matches, list):
             left_matches = [left_matches]
 
-        def update_recursively(data):
+        def modify_recursively(data):
             # Update only mutable values corresponding to JSON types
             if not (isinstance(data, list) or isinstance(data, dict)):
                 return
 
-            self.right.update(data, val)
+            if delete:
+                self.right.delete(data)
+            else:
+                self.right.update(data, val)
 
             # Manually do the * or [*] to avoid coercion and recurse just the right-hand pattern
             if isinstance(data, list):
-                for i in range(0, len(data)):
-                    update_recursively(data[i])
+                for i in reversed(range(0, len(data))):
+                    modify_recursively(data[i])
 
             elif isinstance(data, dict):
                 for field in data.keys():
-                    update_recursively(data[field])
+                    modify_recursively(data[field])
 
         for submatch in left_matches:
-            update_recursively(submatch.value)
+            modify_recursively(submatch.value)
 
         return data
 
+    def update(self, data, val):
+        return self._modify(data, val, delete = False)
+
+    def delete(self, data):
+        return self._modify(data, None, delete = True)
+
     def __str__(self):
         return '%s..%s' % (self.left, self.right)
 
@@ -566,6 +592,12 @@ def update(self, data, val):
             datum.path.update(data, val)
         return data
 
+    def delete(self, data):
+        for path in reversed([datum.path for datum in self.find(data)]):
+            path.delete(data)
+
+        return data
+
     def __str__(self):
         if self.start == None and self.end == None and self.step == None:
             return '[*]'

tests/test_jsonpath.py

@@ -310,7 +310,10 @@ def test_update_root(self):
 
     def test_update_this(self):
         self.check_update_cases([
-            ('foo', '`this`', 'bar', 'bar')
+            ('foo', '`this`', 'bar', 'bar'),
+            # TODO: fixme
+            # ({'foo': 'bar'}, 'foo.`this`', 'baz', {'foo': 'baz'}),
+            ({'foo': {'bar': 'baz'}}, 'foo.`this`.bar', 'foo', {'foo': {'bar': 'foo'}})
         ])
 
     def test_update_fields(self):
@@ -358,28 +361,86 @@ def test_update_slice(self):
         ])
 
     def check_delete_cases(self, test_cases):
-        for string, original, expected in test_cases:
+        for original, string, expected in test_cases:
             logging.debug('parse("%s").delete(%s) =?= %s' % (string, original, expected))
             actual = parse(string).delete(original)
             assert actual == expected
 
     def test_delete_fields(self):
         jsonpath.auto_id_field = None
         self.check_delete_cases([
-            ('foo', {'foo': 'baz'}, {}),
-            ('foo', {'foo': 1, 'baz': 2}, {'baz': 2}),
-            ('foo,baz', {'foo': 1, 'baz': 2}, {}),
-            ('@foo', {'@foo': 1}, {}),
-            ('@foo', {'@foo': 1, 'baz': 2}, {'baz': 2}),
-            ('*', {'foo': 1, 'baz': 2}, {})
+            ({'foo': 'baz'}, 'foo', {}),
+            ({'foo': 1, 'baz': 2}, 'foo', {'baz': 2}),
+            ({'foo': 1, 'baz': 2}, 'foo,baz', {}),
+            ({'@foo': 1}, '@foo', {}),
+            ({'@foo': 1, 'baz': 2}, '@foo', {'baz': 2}),
+            ({'foo': 1, 'baz': 2}, '*', {})
+        ])
+
+    def test_delete_root(self):
+        self.check_delete_cases([
+            ('foo', '$', None),
+        ])
+
+    def test_delete_this(self):
+        self.check_delete_cases([
+            ('foo', '`this`', None),
+            ({}, '`this`', None),
+            ({'foo': 1}, '`this`', None),
+            # TODO: fixme
+            #({'foo': 1}, 'foo.`this`', {}),
+            ({'foo': {'bar': 1}}, 'foo.`this`.bar', {'foo': {}}),
+            ({'foo': {'bar': 1, 'baz': 2}}, 'foo.`this`.bar', {'foo': {'baz': 2}})
+        ])
+
+    def test_delete_child(self):
+        self.check_delete_cases([
+            ({'foo': 'bar'}, '$.foo', {}),
+            ({'foo': 'bar'}, 'foo', {}),
+            ({'foo': {'bar': 1}}, 'foo.bar', {'foo': {}}),
+            ({'foo': {'bar': 1}}, 'foo.$.foo.bar', {'foo': {}})
+        ])
+
+    def test_delete_where(self):
+        self.check_delete_cases([
+            ({'foo': {'bar': {'baz': 1}}, 'bar': {'baz': 2}},
+             '*.bar where none', {'foo': {'bar': {'baz': 1}}, 'bar': {'baz': 2}}),
+
+            ({'foo': {'bar': {'baz': 1}}, 'bar': {'baz': 2}},
+             '*.bar where baz', {'foo': {}, 'bar': {'baz': 2}})
+        ])
+
+    def test_delete_descendants(self):
+        self.check_delete_cases([
+            ({'somefield': 1}, '$..somefield', {}),
+            ({'outer': {'nestedfield': 1}}, '$..nestedfield', {'outer': {}}),
+            ({'outs': {'bar': 1, 'ins': {'bar': 9}}, 'outs2': {'bar': 2}},
+             '$..bar',
+             {'outs': {'ins': {}}, 'outs2': {}})
+        ])
+
+    def test_delete_descendants_where(self):
+        self.check_delete_cases([
+            ({'foo': {'bar': 1, 'flag': 1}, 'baz': {'bar': 2}},
+             '(* where flag) .. bar',
+             {'foo': {'flag': 1}, 'baz': {'bar': 2}})
         ])
 
     def test_delete_index(self):
         self.check_delete_cases([
-            ('[0]', [42], []),
-            ('[5]', [42], [42]),
-            ('[2]', [34, 65, 29, 59], [34, 65, 59]),
-            ('[0]', None, None),
-            ('[0]', [], []),
-            ('[0]', ['foo', 'bar', 'baz'], ['bar', 'baz']),
-        ])
+            ([42], '[0]', []),
+            ([42], '[5]', [42]),
+            ([34, 65, 29, 59], '[2]', [34, 65, 59]),
+            (None, '[0]', None),
+            ([], '[0]', []),
+            (['foo', 'bar', 'baz'], '[0]', ['bar', 'baz']),
+        ])
+
+    def test_delete_slice(self):
+        self.check_delete_cases([
+            (['foo', 'bar', 'baz'], '[0:2]', ['baz']),
+            (['foo', 'bar', 'baz'], '[0:1]', ['bar', 'baz']),
+            (['foo', 'bar', 'baz'], '[0:]', []),
+            (['foo', 'bar', 'baz'], '[:2]', ['baz']),
+            (['foo', 'bar', 'baz'], '[:3]', [])
+        ])

tests/test_lexer.py

@@ -23,13 +23,14 @@ def assert_lex_equiv(self, s, stream2):
         stream2 = list(stream2)
         assert len(stream1) == len(stream2)
         for token1, token2 in zip(stream1, stream2):
-            print(token1, token2)
+            logging.debug(token1, token2)
             assert token1.type  == token2.type
             assert token1.value == token2.value
 
     @classmethod
     def setup_class(cls):
-        logging.basicConfig()
+        logging.basicConfig(format = '%(levelname)s:%(funcName)s:%(message)s',
+                            level = logging.DEBUG)
 
     def test_simple_inputs(self):
         self.assert_lex_equiv('$', [self.token('$', '$')])
@@ -51,6 +52,9 @@ def test_simple_inputs(self):
         self.assert_lex_equiv('&', [self.token('&', '&')])
         self.assert_lex_equiv('@', [self.token('@', 'ID')])
         self.assert_lex_equiv('`this`', [self.token('this', 'NAMED_OPERATOR')])
+        self.assert_lex_equiv('fuzz.`this`', [self.token('fuzz', 'ID'),
+                                              self.token('.', '.'),
+                                              self.token('this', 'NAMED_OPERATOR')])
         self.assert_lex_equiv('|', [self.token('|', '|')])
         self.assert_lex_equiv('where', [self.token('where', 'WHERE')])
 

tests/test_parser.py

@@ -10,13 +10,14 @@ class TestParser(unittest.TestCase):
 
     @classmethod
     def setup_class(cls):
-        logging.basicConfig()
+        logging.basicConfig(format = '%(levelname)s:%(funcName)s:%(message)s',
+                            level = logging.DEBUG)
 
     def check_parse_cases(self, test_cases):
         parser = JsonPathParser(debug=True, lexer_class=lambda:JsonPathLexer(debug=False)) # Note that just manually passing token streams avoids this dep, but that sucks
 
         for string, parsed in test_cases:
-            print(string, '=?=', parsed) # pytest captures this and we see it only on a failure, for debugging
+            logging.debug(string, '=?=', parsed) # pytest captures this and we see it only on a failure, for debugging
             assert parser.parse(string) == parsed
 
     def test_atomic(self):
@@ -36,5 +37,7 @@ def test_nested(self):
         self.check_parse_cases([('foo.baz', Child(Fields('foo'), Fields('baz'))),
                                 ('foo.baz,bizzle', Child(Fields('foo'), Fields('baz', 'bizzle'))),
                                 ('foo where baz', Where(Fields('foo'), Fields('baz'))),
+                                ('`this`', This()),
+                                ('foo.`this`', Child(Fields('foo'), This())),
                                 ('foo..baz', Descendants(Fields('foo'), Fields('baz'))),
                                 ('foo..baz.bing', Descendants(Fields('foo'), Child(Fields('baz'), Fields('bing'))))])