[lexical-scoping] Deprecated function let().

Author: springcomp

jmespath.test

@@ -85,12 +85,6 @@ def call_function(self, function_name, resolved_args, *args, **kwargs):
         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):
@@ -540,12 +534,6 @@ 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)
-
     @signature({'types': ['array'], 'variadic': True})
     def _func_zip(self, *arguments):
         return list(map(list, zip(*arguments)))

jmespath/functions.py

@@ -585,7 +585,7 @@ def __init__(self, expression, parsed):
         self.parsed = parsed
 
     def search(self, value, options=None):
-        evaluator = visitor.ScopedInterpreter(options)
+        evaluator = visitor.TreeInterpreter(options)
         return evaluator.evaluate(self.parsed, value)
 
     def _render_dot_file(self):

jmespath/parser.py

@@ -3,7 +3,6 @@
 from jmespath import exceptions
 from jmespath import functions
 from jmespath.compat import string_type
-from jmespath.compat import with_str_method
 from jmespath.scope import ScopedChainDict
 from numbers import Number
 
@@ -84,10 +83,9 @@ def __init__(self, dict_cls=None,
 
 
 class _Expression(object):
-    def __init__(self, expression, interpreter, context):
+    def __init__(self, expression, interpreter):
         self.expression = expression
         self.interpreter = interpreter
-        self.context = context
 
     def visit(self, node, *args, **kwargs):
         return self.interpreter.visit(node, *args, **kwargs)
@@ -144,11 +142,16 @@ def __init__(self, options=None):
             self._functions = self._options.custom_functions
         else:
             self._functions = functions.Functions()
+        self._root = None
         self._scope = ScopedChainDict()
 
     def default_visit(self, node, *args, **kwargs):
         raise NotImplementedError(node['type'])
 
+    def evaluate(self, ast, root):
+        self._root = root
+        return self.visit(ast, root)
+
     def visit_subexpression(self, node, value):
         result = value
         for node in node['children']:
@@ -158,23 +161,10 @@ def visit_subexpression(self, node, value):
         return result
 
     def visit_field(self, node, value, *args, **kwargs):
-        identifier = node['value']
-        scopes = kwargs.get('scopes')
-
         try:
-            result = value.get(identifier) 
-            if result == None:
-                result = self._get_from_scopes(
-                    identifier, *args, scopes=scopes)
-            return result
+           return value.get(node['value']) 
         except AttributeError:
-            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
+            return None
 
     def visit_comparator(self, node, value):
         # Common case: comparator is == or !=
@@ -212,13 +202,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'].getRoot()
-        return None
+    def visit_root(self, node, value):
+        return self._root
 
     def visit_expref(self, node, value):
-        return _Expression(node['children'][0], self, value)
+        return _Expression(node['children'][0], self)
 
     def visit_function_expression(self, node, value, *args, **kwargs):
         resolved_args = []
@@ -417,48 +405,3 @@ def _visit(self, node, current):
             self._count += 1
             self._lines.append('  %s -> %s' % (current, child_name))
             self._visit(child, child_name)
-
-
-@with_str_method
-class Scopes:
-    def __init__(self, root):
-        self._scopes = []
-        self._root = root
-
-    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
-
-    def getRoot(self):
-        return self._root
-
-    def __str__(self):
-        return '{}'.format(self._scopes)
-
-
-class ScopedInterpreter(TreeInterpreter):
-    def __init__(self, options = None):
-        super().__init__(options)
-
-    def evaluate(self, ast, root_scope):
-        self._scopes = Scopes(root_scope)
-        return self.visit(ast, root_scope)
-
-    def visit(self, node, *args, **kwargs):
-        scoped_types = ['field', 'function_expression', 'root']
-        if (node['type'] in scoped_types):
-            kwargs.update({'scopes': self._scopes})
-        else:
-            if 'scopes' in kwargs:
-                kwargs.pop('scopes')
-
-        return super().visit(node, *args, **kwargs)