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,57 @@ 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 Sorted(JSONPath):
+    """The JSONPath referring to the sorted version of the current object.
+
+    Concrete syntax is [\\field] , [/field] or [\\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):
+            kwargs = {}
+            if self.expressions:
+                if six.PY3:
+                    kwargs['key'] = functools.cmp_to_key(self._compare)
+                else:
+                    kwargs['cmp'] = self._compare
+            return [DatumInContext.wrap(value)
+                    for value in sorted(datum.value, **kwargs)]
+        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

@@ -170,6 +170,24 @@ 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 = Sorted(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):