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

Author: springcomp

jmespath/functions.py

@@ -1,5 +1,7 @@
 import math
 import json
+import inspect
+from pydoc import resolve
 
 from jmespath import exceptions
 from jmespath.compat import string_type as STRING_TYPE
@@ -69,7 +71,7 @@ class Functions(metaclass=FunctionRegistry):
     FUNCTION_TABLE = {
     }
 
-    def call_function(self, function_name, resolved_args):
+    def call_function(self, function_name, resolved_args, *args, **kwargs):
         try:
             spec = self.FUNCTION_TABLE[function_name]
         except KeyError:
@@ -78,6 +80,13 @@ def call_function(self, function_name, resolved_args):
         function = spec['function']
         signature = spec['signature']
         self._validate_arguments(resolved_args, signature, function_name)
+
+        # supply extra arguments only if the function expects them
+
+        parameters = [parameter.name for parameter in inspect.signature(function).parameters.values()]
+        if ('kwargs' in parameters):
+            return function(self, *resolved_args, *args, scopes = kwargs.get('scopes'))
+
         return function(self, *resolved_args)
 
     def _validate_arguments(self, args, signature, function_name):
@@ -346,6 +355,12 @@ def _func_max_by(self, array, expref):
         else:
             return None
 
+    @signature({'types': ['object']}, {'types': ['expref']})
+    def _func_let(self, scope, expref, *args, **kwargs):
+        if 'scopes' in kwargs:
+            kwargs.get('scopes').pushScope(scope)
+        return expref.visit(expref.expression, expref.context, *args, **kwargs)
+
     def _create_key_func(self, expref, allowed_types, function_name):
         def keyfunc(x):
             result = expref.visit(expref.expression, x)

jmespath/parser.py

@@ -505,7 +505,7 @@ def __init__(self, expression, parsed):
         self.parsed = parsed
 
     def search(self, value, options=None):
-        interpreter = visitor.TreeInterpreter(options)
+        interpreter = visitor.ScopedInterpreter(options)
         result = interpreter.visit(self.parsed, value)
         return result
 

jmespath/visitor.py

@@ -72,14 +72,14 @@ def __init__(self, dict_cls=None, custom_functions=None):
 
 
 class _Expression(object):
-    def __init__(self, expression, interpreter):
+    def __init__(self, expression, interpreter, context):
         self.expression = expression
         self.interpreter = interpreter
+        self.context = context
 
     def visit(self, node, *args, **kwargs):
         return self.interpreter.visit(node, *args, **kwargs)
 
-
 class Visitor(object):
     def __init__(self):
         self._method_cache = {}
@@ -96,7 +96,6 @@ def visit(self, node, *args, **kwargs):
     def default_visit(self, node, *args, **kwargs):
         raise NotImplementedError("default_visit")
 
-
 class TreeInterpreter(Visitor):
     COMPARATOR_FUNC = {
         'eq': _equals,
@@ -131,11 +130,31 @@ def visit_subexpression(self, node, value):
             result = self.visit(node, result)
         return result
 
-    def visit_field(self, node, value):
+    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
+
         try:
-            return value.get(node['value'])
+            result = value.get(identifier) 
+            if result == None:
+                result = get_value_from_current_context_or_scopes()
+            return result
         except AttributeError:
-            return None
+            return get_value_from_current_context_or_scopes()
+
 
     def visit_comparator(self, node, value):
         # Common case: comparator is == or !=
@@ -161,14 +180,14 @@ def visit_current(self, node, value):
         return value
 
     def visit_expref(self, node, value):
-        return _Expression(node['children'][0], self)
+        return _Expression(node['children'][0], self, value)
 
-    def visit_function_expression(self, node, value):
+    def visit_function_expression(self, node, value, *args, **kwargs):
         resolved_args = []
         for child in node['children']:
             current = self.visit(child, value)
             resolved_args.append(current)
-        return self._functions.call_function(node['value'], resolved_args)
+        return self._functions.call_function(node['value'], resolved_args, scopes = kwargs.get('scopes'))
 
     def visit_filter_projection(self, node, value):
         base = self.visit(node['children'][0], value)
@@ -326,3 +345,37 @@ def _visit(self, node, current):
             self._count += 1
             self._lines.append('  %s -> %s' % (current, child_name))
             self._visit(child, child_name)
+
+
+class Scopes:
+    def __init__(self):
+        self._scopes = []
+
+    def pushScope(self, scope):
+        self._scopes.append(scope)
+
+    def popScope(self):
+        if len(self._scopes) > 0:
+            self._scopes.pop()
+
+    def getValue(self, identifier):
+        for scope in self._scopes[::-1]:
+            if scope.get(identifier) != None:
+                return scope[identifier]
+        return None
+
+
+class ScopedInterpreter(TreeInterpreter):
+    def __init__(self, options = None):
+        super().__init__(options)
+        self._scopes = Scopes()
+
+    def visit(self, node, *args, **kwargs):
+        node_type = node['type']
+        if (node_type in ['field', 'function_expression']):
+            kwargs.update({'scopes': self._scopes})
+        else:
+            if 'scopes' in kwargs:
+                kwargs.pop('scopes')
+
+        return super().visit(node, *args, **kwargs)

tests/compliance/lexical_scoping.json

@@ -0,0 +1,170 @@
+[
+	{
+		"given": {
+			"search_for": "foo",
+			"people": [
+				{
+					"name": "a"
+				},
+				{
+					"name": "b"
+				},
+				{
+					"name": "c"
+				},
+				{
+					"name": "foo"
+				},
+				{
+					"name": "bar"
+				},
+				{
+					"name": "baz"
+				},
+				{
+					"name": "qux"
+				},
+				{
+					"name": "x"
+				},
+				{
+					"name": "y"
+				},
+				{
+					"name": "z"
+				}
+			]
+		},
+		"cases": [
+			{
+				"description": "Let function with filters",
+				"expression": "let({search_for: search_for}, &people[?name==search_for].name | [0])",
+				"result": "foo"
+			}
+		]
+	},
+	{
+		"given": {
+			"a": {
+				"mylist": [
+					{
+						"l1": "1",
+						"result": "foo"
+					},
+					{
+						"l2": "2",
+						"result": "bar"
+					},
+					{
+						"l1": "8",
+						"l2": "9"
+					},
+					{
+						"l1": "8",
+						"l2": "9"
+					}
+				],
+				"level2": "2"
+			},
+			"level1": "1",
+			"nested": {
+				"a": {
+					"b": {
+						"c": {
+							"fourth": "fourth"
+						},
+						"third": "third"
+					},
+					"second": "second"
+				},
+				"first": "first"
+			},
+			"precedence": {
+				"a": {
+					"b": {
+						"c": {
+							"variable": "fourth"
+						},
+						"variable": "third",
+						"other": "y"
+					},
+					"variable": "second",
+					"other": "x"
+				},
+				"variable": "first",
+				"other": "w"
+			}
+		},
+		"cases": [
+			{
+				"description": "Basic let from scope",
+				"expression": "let({level1: level1}, &a.[level2, level1])",
+				"result": [
+					"2",
+					"1"
+				]
+			},
+			{
+				"description": "Current object has precedence",
+				"expression": "let({level1: `\"other\"`}, &level1)",
+				"result": "1"
+			},
+			{
+				"description": "No scope specified using literal hash",
+				"expression": "let(`{}`, &a.level2)",
+				"result": "2"
+			},
+			{
+				"description": "Arbitrary variable added",
+				"expression": "let({foo: `\"anything\"`}, &[level1, foo])",
+				"result": [
+					"1",
+					"anything"
+				]
+			},
+			{
+				"description": "Basic let from current object",
+				"expression": "let({other: level1}, &level1)",
+				"result": "1"
+			},
+			{
+				"description": "Nested let function with filters",
+				"expression": "let({level1: level1}, &a.[mylist[?l1==level1].result, let({level2: level2}, &mylist[?l2==level2].result)])[]",
+				"result": [
+					"foo",
+					"bar"
+				]
+			},
+			{
+				"description": "Nested let function with filters with literal scope binding",
+				"expression": "let(`{\"level1\": \"1\"}`, &a.[mylist[?l1==level1].result, let({level2: level2}, &mylist[?l2==level2].result)])[]",
+				"result": [
+					"foo",
+					"bar"
+				]
+			},
+			{
+				"description": "Nested let functions",
+				"expression": "nested.let({level1: first}, &a.let({level2: second}, &b.let({level3: third}, &c.{first: level1, second: level2, third: level3, fourth: fourth})))",
+				"result": {
+					"first": "first",
+					"second": "second",
+					"third": "third",
+					"fourth": "fourth"
+				}
+			},
+			{
+				"description": "Precedence of lexical vars from scope object",
+				"expression": "precedence.let({other: other}, &a.let({other: other}, &b.let({other: other}, &c.{other: other})))",
+				"result": {
+					"other": "y"
+				}
+			},
+			{
+				"description": "Precedence of lexical vars from current object",
+				"expression": "precedence.let({variable: variable}, &a.let({variable: variable}, &b.let({variable: variable}, &c.let({variable: `\"override\"`}, &variable))))",
+				"result": "fourth"
+			}
+		]
+	}
+]

tests/test_scopes.py

@@ -0,0 +1,27 @@
+
+import pytest
+
+from tests import unittest
+from jmespath.visitor import Scopes
+
+class TestScope(unittest.TestCase):
+    def setUp(self):
+        self._scopes = Scopes()
+
+    def test_Scope_missing(self):
+        value = self._scopes.getValue('foo')
+        self.assertEqual(None, value)
+
+    def test_Scope_root(self):
+        self._scopes.pushScope({'foo': 'bar'})
+        value = self._scopes.getValue('foo')
+        self.assertEqual('bar', value)
+
+    def test_Scope_nested(self):
+        self._scopes.pushScope({'foo': 'bar'})
+        self._scopes.pushScope({'foo': 'baz'})
+        value = self._scopes.getValue('foo')
+        self.assertEqual('baz', value)
+
+if __name__ == '__main__':
+	unittest.main()