246 lines
8.3 KiB
Python
246 lines
8.3 KiB
Python
import rope.base.exceptions
|
|
import rope.base.pyobjects
|
|
from rope.base.builtins import Lambda
|
|
from rope.base import worder
|
|
|
|
|
|
class DefinitionInfo(object):
|
|
def __init__(
|
|
self, function_name, is_method, args_with_defaults, args_arg, keywords_arg
|
|
):
|
|
self.function_name = function_name
|
|
self.is_method = is_method
|
|
self.args_with_defaults = args_with_defaults
|
|
self.args_arg = args_arg
|
|
self.keywords_arg = keywords_arg
|
|
|
|
def to_string(self):
|
|
return "%s(%s)" % (self.function_name, self.arguments_to_string())
|
|
|
|
def arguments_to_string(self, from_index=0):
|
|
params = []
|
|
for arg, default in self.args_with_defaults:
|
|
if default is not None:
|
|
params.append("%s=%s" % (arg, default))
|
|
else:
|
|
params.append(arg)
|
|
if self.args_arg is not None:
|
|
params.append("*" + self.args_arg)
|
|
if self.keywords_arg:
|
|
params.append("**" + self.keywords_arg)
|
|
return ", ".join(params[from_index:])
|
|
|
|
@staticmethod
|
|
def _read(pyfunction, code):
|
|
kind = pyfunction.get_kind()
|
|
is_method = kind == "method"
|
|
is_lambda = kind == "lambda"
|
|
info = _FunctionParser(code, is_method, is_lambda)
|
|
args, keywords = info.get_parameters()
|
|
args_arg = None
|
|
keywords_arg = None
|
|
if args and args[-1].startswith("**"):
|
|
keywords_arg = args[-1][2:]
|
|
del args[-1]
|
|
if args and args[-1].startswith("*"):
|
|
args_arg = args[-1][1:]
|
|
del args[-1]
|
|
args_with_defaults = [(name, None) for name in args]
|
|
args_with_defaults.extend(keywords)
|
|
return DefinitionInfo(
|
|
info.get_function_name(),
|
|
is_method,
|
|
args_with_defaults,
|
|
args_arg,
|
|
keywords_arg,
|
|
)
|
|
|
|
@staticmethod
|
|
def read(pyfunction):
|
|
pymodule = pyfunction.get_module()
|
|
word_finder = worder.Worder(pymodule.source_code)
|
|
lineno = pyfunction.get_ast().lineno
|
|
start = pymodule.lines.get_line_start(lineno)
|
|
if isinstance(pyfunction, Lambda):
|
|
call = word_finder.get_lambda_and_args(start)
|
|
else:
|
|
call = word_finder.get_function_and_args_in_header(start)
|
|
return DefinitionInfo._read(pyfunction, call)
|
|
|
|
|
|
class CallInfo(object):
|
|
def __init__(
|
|
self,
|
|
function_name,
|
|
args,
|
|
keywords,
|
|
args_arg,
|
|
keywords_arg,
|
|
implicit_arg,
|
|
constructor,
|
|
):
|
|
self.function_name = function_name
|
|
self.args = args
|
|
self.keywords = keywords
|
|
self.args_arg = args_arg
|
|
self.keywords_arg = keywords_arg
|
|
self.implicit_arg = implicit_arg
|
|
self.constructor = constructor
|
|
|
|
def to_string(self):
|
|
function = self.function_name
|
|
if self.implicit_arg:
|
|
function = self.args[0] + "." + self.function_name
|
|
params = []
|
|
start = 0
|
|
if self.implicit_arg or self.constructor:
|
|
start = 1
|
|
if self.args[start:]:
|
|
params.extend(self.args[start:])
|
|
if self.keywords:
|
|
params.extend(["%s=%s" % (name, value) for name, value in self.keywords])
|
|
if self.args_arg is not None:
|
|
params.append("*" + self.args_arg)
|
|
if self.keywords_arg:
|
|
params.append("**" + self.keywords_arg)
|
|
return "%s(%s)" % (function, ", ".join(params))
|
|
|
|
@staticmethod
|
|
def read(primary, pyname, definition_info, code):
|
|
is_method_call = CallInfo._is_method_call(primary, pyname)
|
|
is_constructor = CallInfo._is_class(pyname)
|
|
is_classmethod = CallInfo._is_classmethod(pyname)
|
|
info = _FunctionParser(code, is_method_call or is_classmethod)
|
|
args, keywords = info.get_parameters()
|
|
args_arg = None
|
|
keywords_arg = None
|
|
if args and args[-1].startswith("**"):
|
|
keywords_arg = args[-1][2:]
|
|
del args[-1]
|
|
if args and args[-1].startswith("*"):
|
|
args_arg = args[-1][1:]
|
|
del args[-1]
|
|
if is_constructor:
|
|
args.insert(0, definition_info.args_with_defaults[0][0])
|
|
return CallInfo(
|
|
info.get_function_name(),
|
|
args,
|
|
keywords,
|
|
args_arg,
|
|
keywords_arg,
|
|
is_method_call or is_classmethod,
|
|
is_constructor,
|
|
)
|
|
|
|
@staticmethod
|
|
def _is_method_call(primary, pyname):
|
|
return (
|
|
primary is not None
|
|
and isinstance(primary.get_object().get_type(), rope.base.pyobjects.PyClass)
|
|
and CallInfo._is_method(pyname)
|
|
)
|
|
|
|
@staticmethod
|
|
def _is_class(pyname):
|
|
return pyname is not None and isinstance(
|
|
pyname.get_object(), rope.base.pyobjects.PyClass
|
|
)
|
|
|
|
@staticmethod
|
|
def _is_method(pyname):
|
|
if pyname is not None and isinstance(
|
|
pyname.get_object(), rope.base.pyobjects.PyFunction
|
|
):
|
|
return pyname.get_object().get_kind() == "method"
|
|
return False
|
|
|
|
@staticmethod
|
|
def _is_classmethod(pyname):
|
|
if pyname is not None and isinstance(
|
|
pyname.get_object(), rope.base.pyobjects.PyFunction
|
|
):
|
|
return pyname.get_object().get_kind() == "classmethod"
|
|
return False
|
|
|
|
|
|
class ArgumentMapping(object):
|
|
def __init__(self, definition_info, call_info):
|
|
self.call_info = call_info
|
|
self.param_dict = {}
|
|
self.keyword_args = []
|
|
self.args_arg = []
|
|
for index, value in enumerate(call_info.args):
|
|
if index < len(definition_info.args_with_defaults):
|
|
name = definition_info.args_with_defaults[index][0]
|
|
self.param_dict[name] = value
|
|
else:
|
|
self.args_arg.append(value)
|
|
for name, value in call_info.keywords:
|
|
index = -1
|
|
for pair in definition_info.args_with_defaults:
|
|
if pair[0] == name:
|
|
self.param_dict[name] = value
|
|
break
|
|
else:
|
|
self.keyword_args.append((name, value))
|
|
|
|
def to_call_info(self, definition_info):
|
|
args = []
|
|
keywords = []
|
|
for index in range(len(definition_info.args_with_defaults)):
|
|
name = definition_info.args_with_defaults[index][0]
|
|
if name in self.param_dict:
|
|
args.append(self.param_dict[name])
|
|
else:
|
|
for i in range(index, len(definition_info.args_with_defaults)):
|
|
name = definition_info.args_with_defaults[i][0]
|
|
if name in self.param_dict:
|
|
keywords.append((name, self.param_dict[name]))
|
|
break
|
|
args.extend(self.args_arg)
|
|
keywords.extend(self.keyword_args)
|
|
return CallInfo(
|
|
self.call_info.function_name,
|
|
args,
|
|
keywords,
|
|
self.call_info.args_arg,
|
|
self.call_info.keywords_arg,
|
|
self.call_info.implicit_arg,
|
|
self.call_info.constructor,
|
|
)
|
|
|
|
|
|
class _FunctionParser(object):
|
|
def __init__(self, call, implicit_arg, is_lambda=False):
|
|
self.call = call
|
|
self.implicit_arg = implicit_arg
|
|
self.word_finder = worder.Worder(self.call)
|
|
if is_lambda:
|
|
self.last_parens = self.call.rindex(":")
|
|
else:
|
|
self.last_parens = self.call.rindex(")")
|
|
self.first_parens = self.word_finder._find_parens_start(self.last_parens)
|
|
|
|
def get_parameters(self):
|
|
args, keywords = self.word_finder.get_parameters(
|
|
self.first_parens, self.last_parens
|
|
)
|
|
if self.is_called_as_a_method():
|
|
instance = self.call[: self.call.rindex(".", 0, self.first_parens)]
|
|
args.insert(0, instance.strip())
|
|
return args, keywords
|
|
|
|
def get_instance(self):
|
|
if self.is_called_as_a_method():
|
|
return self.word_finder.get_primary_at(
|
|
self.call.rindex(".", 0, self.first_parens) - 1
|
|
)
|
|
|
|
def get_function_name(self):
|
|
if self.is_called_as_a_method():
|
|
return self.word_finder.get_word_at(self.first_parens - 1)
|
|
else:
|
|
return self.word_finder.get_primary_at(self.first_parens - 1)
|
|
|
|
def is_called_as_a_method(self):
|
|
return self.implicit_arg and "." in self.call[: self.first_parens]
|