Merge tag 'JEP-17' into feature/vnext-preview

Author: springcomp

jmespath/ast.py

@@ -18,6 +18,10 @@ def current_node():
     return {'type': 'current', 'children': []}
 
 
+def root_node():
+    return {'type': 'root', 'children': []}
+
+
 def expref(expression):
     return {'type': 'expref', 'children': [expression]}
 

jmespath/lexer.py

@@ -17,6 +17,7 @@ class Lexer(object):
         ',': 'comma',
         ':': 'colon',
         '@': 'current',
+        '$': 'root',
         '(': 'lparen',
         ')': 'rparen',
         '{': 'lbrace',

jmespath/parser.py

@@ -27,6 +27,7 @@
 """
 import random
 
+
 from jmespath import lexer
 from jmespath.compat import with_repr_method
 from jmespath import ast
@@ -46,6 +47,7 @@ class Parser(object):
         'rbrace': 0,
         'number': 0,
         'current': 0,
+        'root': 0,
         'expref': 0,
         'colon': 0,
         'pipe': 1,
@@ -251,6 +253,9 @@ def _parse_slice_expression(self):
     def _token_nud_current(self, token):
         return ast.current_node()
 
+    def _token_nud_root(self, token):
+        return ast.root_node()
+
     def _token_nud_expref(self, token):
         expression = self._expression(self.BINDING_POWER['expref'])
         return ast.expref(expression)
@@ -546,9 +551,8 @@ def __init__(self, expression, parsed):
         self.parsed = parsed
 
     def search(self, value, options=None):
-        interpreter = visitor.ScopedInterpreter(options)
-        result = interpreter.visit(self.parsed, value)
-        return result
+        evaluator = visitor.ScopedInterpreter(options)
+        return evaluator.evaluate(self.parsed, value)
 
     def _render_dot_file(self):
         """Render the parsed AST as a dot file.
@@ -563,6 +567,3 @@ def _render_dot_file(self):
         renderer = visitor.GraphvizVisitor()
         contents = renderer.visit(self.parsed)
         return contents
-
-    def __repr__(self):
-        return repr(self.parsed)

jmespath/visitor.py

@@ -2,6 +2,7 @@
 
 from jmespath import functions
 from jmespath.compat import string_type
+from jmespath.compat import with_str_method
 from numbers import Number
 
 
@@ -143,30 +144,23 @@ def visit_subexpression(self, node, value):
         return result
 
     def visit_field(self, node, value, *args, **kwargs):
-
         identifier = node['value']
-
-        ## inner function to retrieve the given
-        ## value from the scopes stack
-        
-        def get_value_from_current_context_or_scopes():
-            ##try:
-            ##    return getattr(value, identifier)
-            ##except AttributeError:
-            if 'scopes' in kwargs:
-                return kwargs['scopes'].getValue(identifier) 
-            return None
-
-        ## search for identifier value
+        scopes = kwargs.get('scopes')
 
         try:
             result = value.get(identifier) 
             if result == None:
-                result = get_value_from_current_context_or_scopes()
+                result = self._get_from_scopes(
+                    identifier, *args, scopes=scopes)
             return result
         except AttributeError:
-            return get_value_from_current_context_or_scopes()
+            return self._get_from_scopes(
+                identifier, *args, scopes=scopes)
 
+    def _get_from_scopes(self, identifier, *args, **kwargs):
+        if 'scopes' in kwargs:
+            return kwargs['scopes'].getValue(identifier) 
+        return None
 
     def visit_comparator(self, node, value):
         # Common case: comparator is == or !=
@@ -204,6 +198,11 @@ def visit_arithmetic(self, node, value):
     def visit_current(self, node, value):
         return value
 
+    def visit_root(self, *args, **kwargs):
+        if 'scopes' in kwargs:
+            return kwargs['scopes'].getValue('$')
+        return None
+
     def visit_expref(self, node, value):
         return _Expression(node['children'][0], self, value)
 
@@ -372,6 +371,7 @@ def _visit(self, node, current):
             self._visit(child, child_name)
 
 
+@with_str_method
 class Scopes:
     def __init__(self):
         self._scopes = []
@@ -389,15 +389,22 @@ def getValue(self, identifier):
                 return scope[identifier]
         return None
 
+    def __str__(self):
+        return '{}'.format(self._scopes)
+
 
 class ScopedInterpreter(TreeInterpreter):
     def __init__(self, options = None):
         super().__init__(options)
         self._scopes = Scopes()
 
+    def evaluate(self, ast, root_scope):
+        self._scopes.pushScope({'$': root_scope})
+        return self.visit(ast, root_scope)
+
     def visit(self, node, *args, **kwargs):
-        node_type = node['type']
-        if (node_type in ['field', 'function_expression']):
+        scoped_types = ['field', 'function_expression', 'root']
+        if (node['type'] in scoped_types):
             kwargs.update({'scopes': self._scopes})
         else:
             if 'scopes' in kwargs:

tests/compliance/lexical_scoping.json

@@ -166,5 +166,40 @@
 				"result": "fourth"
 			}
 		]
+	},
+	{
+		"given": {
+			"first_choice": "WA",
+			"states": [
+				{
+					"name": "WA",
+					"cities": [
+						"Seattle",
+						"Bellevue",
+						"Olympia"
+					]
+				},
+				{
+					"name": "CA",
+					"cities": [
+						"Los Angeles",
+						"San Francisco"
+					]
+				},
+				{
+					"name": "NY",
+					"cities": [
+						"New York City",
+						"Albany"
+					]
+				}
+			]
+		},
+		"cases": [
+			{
+				"expression": "states[?name==$.first_choice].cities[]",
+				"result": ["Seattle", "Bellevue", "Olympia"]
+			}
+		]
 	}
 ]

tests/test_lexer.py

@@ -187,6 +187,23 @@ def test_adds_quotes_when_invalid_json(self):
              ]
         )
 
+    def test_root_reference(self):
+        tokens = list(self.lexer.tokenize('$[0]'))
+        self.assertEqual(
+            tokens,
+            [{'type': 'root', 'value': '$',
+                'start': 0, 'end': 1},
+            {'type': 'lbracket', 'value':
+                '[', 'start': 1, 'end': 2},
+            {'type': 'number', 'value': 0,
+                'start': 2, 'end': 3},
+            {'type': 'rbracket', 'value': ']',
+                'start': 3, 'end': 4},
+            {'type': 'eof', 'value': '',
+                'start': 4, 'end': 4}
+            ]
+        )
+
     def test_unknown_character(self):
         with self.assertRaises(LexerError) as e:
             tokens = list(self.lexer.tokenize('foo[0^]'))

tests/test_parser.py

@@ -156,6 +156,17 @@ def test_function_call_with_and_statement(self):
              'type': 'function_expression',
              'value': 'f'})
 
+    def test_root_node(self):
+        self.assert_parsed_ast(
+            '$[0]',
+            {
+                'type': 'index_expression',
+                'children': [
+                    {'type': 'root', 'children': []},
+                    {'type': 'index', 'value': 0, 'children': []}
+                ]
+            })
+
 
 class TestErrorMessages(unittest.TestCase):