Support json query list sorting

Related bug: kennknowles#8

Author: sileht

jsonpath_rw/jsonpath.py

@@ -3,6 +3,7 @@
 import six
 from six.moves import xrange
 from itertools import *
+import functools
 
 logger = logging.getLogger(__name__)
 
@@ -508,3 +509,53 @@ def __repr__(self):
 
     def __eq__(self, other):
         return isinstance(other, Slice) and other.start == self.start and self.end == other.end and other.step == self.step
+
+
+class SortedThis(This):
+    """The JSONPath referring to the sorted version of the current object.
+
+    Concrete syntax is [\\field,/field].
+    """
+    def __init__(self, expressions=None):
+        self.expressions = expressions
+
+    def _compare(self, left, right):
+        left = DatumInContext.wrap(left)
+        right = DatumInContext.wrap(right)
+
+        for expr in self.expressions:
+            field, reverse = expr
+            l_datum = field.find(left)
+            r_datum = field.find(right)
+            if (not l_datum or not r_datum or
+                    len(l_datum) > 1 or len(r_datum) > 1 or
+                    l_datum[0].value == r_datum[0].value):
+                # NOTE(sileht): should we do something if the expression
+                # match multiple fields, for now ignore them
+                continue
+            elif l_datum[0].value < r_datum[0].value:
+                return 1 if reverse else -1
+            else:
+                return -1 if reverse else 1
+        return 0
+
+    def find(self, datum):
+        """Return sorted value of This if list or dict."""
+        if isinstance(datum.value, dict) and self.expressions:
+            return datum
+
+        if isinstance(datum.value, dict) or isinstance(datum.value, list):
+            key = (functools.cmp_to_key(self._compare)
+                   if self.expressions else None)
+            return [DatumInContext.wrap(value)
+                    for value in sorted(datum.value, key=key)]
+        return datum
+
+    def __eq__(self, other):
+        return isinstance(other, Len)
+
+    def __repr__(self):
+        return '%s(%r)' % (self.__class__.__name__, self.expressions)
+
+    def __str__(self):
+        return '[?%s]' % self.expressions

jsonpath_rw/lexer.py

@@ -50,7 +50,7 @@ def tokenize(self, string):
 
     reserved_words = { 'where': 'WHERE' }
 
-    tokens = ['DOUBLEDOT', 'NUMBER', 'ID', 'NAMED_OPERATOR'] + list(reserved_words.values())
+    tokens = ['DOUBLEDOT', 'NUMBER', 'ID', 'NAMED_OPERATOR', 'SORT_DIRECTION'] + list(reserved_words.values())
 
     states = [ ('singlequote', 'exclusive'),
                ('doublequote', 'exclusive'),
@@ -70,6 +70,10 @@ def t_NUMBER(self, t):
         t.value = int(t.value)
         return t
 
+    def t_SORT_DIRECTION(self, t):
+        r',?\s*(/|\\)'
+        t.value = t.value[-1]
+        return t
 
     # Single-quoted strings
     t_singlequote_ignore = ''

jsonpath_rw/parser.py

@@ -17,7 +17,7 @@ class JsonPathParser(object):
     '''
     An LALR-parser for JsonPath
     '''
-    
+
     tokens = JsonPathLexer.tokens
 
     def __init__(self, debug=False, lexer_class=None):
@@ -40,7 +40,7 @@ def parse_token_stream(self, token_iterator, start_symbol='jsonpath'):
             module_name = os.path.splitext(os.path.split(__file__)[1])[0]
         except:
             module_name = __name__
-        
+
         parsing_table_module = '_'.join([module_name, start_symbol, 'parsetab'])
 
         # And we regenerate the parse table every time; it doesn't actually take that long!
@@ -55,7 +55,7 @@ def parse_token_stream(self, token_iterator, start_symbol='jsonpath'):
         return new_parser.parse(lexer = IteratorToTokenStream(token_iterator))
 
     # ===================== PLY Parser specification =====================
-    
+
     precedence = [
         ('left', ','),
         ('left', 'DOUBLEDOT'),
@@ -66,10 +66,10 @@ def parse_token_stream(self, token_iterator, start_symbol='jsonpath'):
     ]
 
     def p_error(self, t):
-        raise Exception('Parse error at %s:%s near token %s (%s)' % (t.lineno, t.col, t.value, t.type)) 
+        raise Exception('Parse error at %s:%s near token %s (%s)' % (t.lineno, t.col, t.value, t.type))
 
     def p_jsonpath_binop(self, p):
-        """jsonpath : jsonpath '.' jsonpath 
+        """jsonpath : jsonpath '.' jsonpath
                     | jsonpath DOUBLEDOT jsonpath
                     | jsonpath WHERE jsonpath
                     | jsonpath '|' jsonpath
@@ -134,7 +134,7 @@ def p_jsonpath_parens(self, p):
 
     # Because fields in brackets cannot be '*' - that is reserved for array indices
     def p_fields_or_any(self, p):
-        """fields_or_any : fields 
+        """fields_or_any : fields
                          | '*'    """
         if p[1] == '*':
             p[0] = ['*']
@@ -165,11 +165,29 @@ def p_maybe_int(self, p):
         """maybe_int : NUMBER
                      | empty"""
         p[0] = p[1]
-    
+
     def p_empty(self, p):
         'empty :'
         p[0] = None
 
+    def p_sort(self, p):
+        "sort : SORT_DIRECTION jsonpath"
+        p[0] = (p[2], p[1] != "/")
+
+    def p_sorts_sort(self, p):
+        "sorts : sort"
+        p[0] = [p[1]]
+
+    def p_sorts_comma(self, p):
+        "sorts : sorts sorts"
+        p[0] = p[1] + p[2]
+
+    def p_jsonpath_sort(self, p):
+        "jsonpath : jsonpath '[' sorts ']'"
+        sort = SortedThis(p[3])
+        p[0] = Child(p[1], sort)
+
+
 class IteratorToTokenStream(object):
     def __init__(self, iterator):
         self.iterator = iterator

tests/test_jsonpath.py

@@ -110,6 +110,24 @@ def test_fields_value(self):
         jsonpath.auto_id_field = 'id'
         self.check_cases([ ('*', {'foo': 1, 'baz': 2}, set([1, 2, '`this`'])) ])
 
+    def test_sort_value(self):
+        jsonpath.auto_id_field = None
+        self.check_cases([
+            ('objects[/cow]', {'objects': [{'cat': 1, 'cow': 2}, {'cat': 2, 'cow': 1}, {'cat': 3, 'cow': 3}]},
+             [{'cat': 2, 'cow': 1}, {'cat': 1, 'cow': 2}, {'cat': 3, 'cow': 3}]),
+            ('objects[\cat]', {'objects': [{'cat': 2}, {'cat': 1}, {'cat': 3}]},
+             [{'cat': 3}, {'cat': 2}, {'cat': 1}]),
+            ('objects[/cow,\cat]', {'objects': [{'cat': 1, 'cow': 2}, {'cat': 2, 'cow': 1}, {'cat': 3, 'cow': 1}, {'cat': 3, 'cow': 3}]},
+             [{'cat': 3, 'cow': 1}, {'cat': 2, 'cow': 1}, {'cat': 1, 'cow': 2}, {'cat': 3, 'cow': 3}]),
+            ('objects[\cow , /cat]', {'objects': [{'cat': 1, 'cow': 2}, {'cat': 2, 'cow': 1}, {'cat': 3, 'cow': 1}, {'cat': 3, 'cow': 3}]},
+             [{'cat': 3, 'cow': 3}, {'cat': 1, 'cow': 2}, {'cat': 2, 'cow': 1}, {'cat': 3, 'cow': 1}]),
+            ('objects[/cat.cow]', {'objects': [{'cat': {'dog': 1, 'cow': 2}}, {'cat': {'dog': 2, 'cow': 1}}, {'cat': {'dog': 3, 'cow': 3}}]},
+             [{'cat': {'dog': 2, 'cow': 1}}, {'cat': {'dog': 1, 'cow': 2}}, {'cat': {'dog': 3, 'cow': 3}}]),
+            ('objects[/cat.(cow,bow)]', {'objects': [{'cat': {'dog': 1, 'bow': 3}}, {'cat': {'dog': 2, 'cow': 1}}, {'cat': {'dog': 2, 'bow': 2}}, {'cat': {'dog': 3, 'cow': 2}}]},
+             [{'cat': {'dog': 2, 'cow': 1}}, {'cat': {'dog': 2, 'bow': 2}}, {'cat': {'dog': 3, 'cow': 2}}, {'cat': {'dog': 1, 'bow': 3}}]),
+        ])
+
+
     def test_root_value(self):
         jsonpath.auto_id_field = None
         self.check_cases([ 

tests/test_lexer.py

@@ -53,6 +53,8 @@ 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('/', [self.token('/', 'SORT_DIRECTION')])
+        self.assert_lex_equiv('\\', [self.token('\\', 'SORT_DIRECTION')])
 
     def test_basic_errors(self):
         def tokenize(s):