diff options
Diffstat (limited to 'Lib/idlelib/CallTips.py')
| -rw-r--r-- | Lib/idlelib/CallTips.py | 214 |
1 files changed, 139 insertions, 75 deletions
diff --git a/Lib/idlelib/CallTips.py b/Lib/idlelib/CallTips.py index cda2be9..3c8c096 100644 --- a/Lib/idlelib/CallTips.py +++ b/Lib/idlelib/CallTips.py @@ -67,18 +67,18 @@ class CallTips: if not sur_paren: return hp.set_index(sur_paren[0]) - name = hp.get_expression() - if not name: + expression = hp.get_expression() + if not expression: return - if not evalfuncs and (name.find('(') != -1): + if not evalfuncs and (expression.find('(') != -1): return - argspec = self.fetch_tip(name) + argspec = self.fetch_tip(expression) if not argspec: return self.active_calltip = self._calltip_window() self.active_calltip.showtip(argspec, sur_paren[0], sur_paren[1]) - def fetch_tip(self, name): + def fetch_tip(self, expression): """Return the argument list and docstring of a function or class. If there is a Python subprocess, get the calltip there. Otherwise, @@ -94,53 +94,59 @@ class CallTips: """ try: rpcclt = self.editwin.flist.pyshell.interp.rpcclt - except: + except AttributeError: rpcclt = None if rpcclt: return rpcclt.remotecall("exec", "get_the_calltip", - (name,), {}) + (expression,), {}) else: - entity = self.get_entity(name) - return get_argspec(entity) - - def get_entity(self, name): - "Lookup name in a namespace spanning sys.modules and __main.dict__." - if name: - namespace = sys.modules.copy() - namespace.update(__main__.__dict__) - try: - return eval(name, namespace) - except (NameError, AttributeError): - return None - -def _find_constructor(class_ob): - "Find the nearest __init__() in the class tree." - try: - return class_ob.__init__.__func__ - except AttributeError: - for base in class_ob.__bases__: - init = _find_constructor(base) - if init: - return init - return None + return get_argspec(get_entity(expression)) + +def get_entity(expression): + """Return the object corresponding to expression evaluated + in a namespace spanning sys.modules and __main.dict__. + """ + if expression: + namespace = sys.modules.copy() + namespace.update(__main__.__dict__) + try: + return eval(expression, namespace) + except BaseException: + # An uncaught exception closes idle, and eval can raise any + # exception, especially if user classes are involved. + return None + +# The following are used in both get_argspec and tests +_first_param = re.compile('(?<=\()\w*\,?\s*') +_default_callable_argspec = "No docstring, see docs." def get_argspec(ob): - """Get a string describing the arguments for the given object.""" + '''Return a string describing the arguments and return of a callable object. + + For Python-coded functions and methods, the first line is introspected. + Delete 'self' parameter for classes (.__init__) and bound methods. + The last line is the first line of the doc string. For builtins, this typically + includes the arguments in addition to the return value. + + ''' argspec = "" - if ob is not None: + if hasattr(ob, '__call__'): if isinstance(ob, type): - fob = _find_constructor(ob) - if fob is None: - fob = lambda: None - elif isinstance(ob, types.MethodType): - fob = ob.__func__ + fob = getattr(ob, '__init__', None) + elif isinstance(ob.__call__, types.MethodType): + fob = ob.__call__ else: fob = ob - if isinstance(fob, (types.FunctionType, types.LambdaType)): + if isinstance(fob, (types.FunctionType, types.MethodType)): argspec = inspect.formatargspec(*inspect.getfullargspec(fob)) - pat = re.compile('self\,?\s*') - argspec = pat.sub("", argspec) - doc = getattr(ob, "__doc__", "") + if (isinstance(ob, (type, types.MethodType)) or + isinstance(ob.__call__, types.MethodType)): + argspec = _first_param.sub("", argspec) + + if isinstance(ob.__call__, types.MethodType): + doc = ob.__call__.__doc__ + else: + doc = getattr(ob, "__doc__", "") if doc: doc = doc.lstrip() pos = doc.find("\n") @@ -149,55 +155,113 @@ def get_argspec(ob): if argspec: argspec += "\n" argspec += doc[:pos] + if not argspec: + argspec = _default_callable_argspec return argspec ################################################# # -# Test code -# +# Test code tests CallTips.fetch_tip, get_entity, and get_argspec + def main(): + # Putting expected in docstrings results in doubled tips for test def t1(): "()" def t2(a, b=None): "(a, b=None)" def t3(a, *args): "(a, *args)" def t4(*args): "(*args)" - def t5(a, *args): "(a, *args)" - def t6(a, b=None, *args, **kw): "(a, b=None, *args, **kw)" + def t5(a, b=None, *args, **kw): "(a, b=None, *args, **kw)" class TC(object): "(ai=None, *b)" - def __init__(self, ai=None, *b): "(ai=None, *b)" - def t1(self): "()" - def t2(self, ai, b=None): "(ai, b=None)" - def t3(self, ai, *args): "(ai, *args)" - def t4(self, *args): "(*args)" - def t5(self, ai, *args): "(ai, *args)" - def t6(self, ai, b=None, *args, **kw): "(ai, b=None, *args, **kw)" - - __main__.__dict__.update(locals()) - - def test(tests): - ct = CallTips() - failed=[] - for t in tests: - expected = t.__doc__ + "\n" + t.__doc__ - name = t.__name__ - # exercise fetch_tip(), not just get_argspec() - try: - qualified_name = "%s.%s" % (t.__self__.__class__.__name__, name) - except AttributeError: - qualified_name = name - argspec = ct.fetch_tip(qualified_name) - if argspec != expected: - failed.append(t) - fmt = "%s - expected %s, but got %s" - print(fmt % (t.__name__, expected, get_argspec(t))) - print("%d of %d tests failed" % (len(failed), len(tests))) + def __init__(self, ai=None, *b): "(self, ai=None, *b)" + def t1(self): "(self)" + def t2(self, ai, b=None): "(self, ai, b=None)" + def t3(self, ai, *args): "(self, ai, *args)" + def t4(self, *args): "(self, *args)" + def t5(self, ai, b=None, *args, **kw): "(self, ai, b=None, *args, **kw)" + def t6(no, self): "(no, self)" + @classmethod + def cm(cls, a): "(cls, a)" + @staticmethod + def sm(b): "(b)" + def __call__(self, ci): "(self, ci)" tc = TC() - tests = (t1, t2, t3, t4, t5, t6, - TC, tc.t1, tc.t2, tc.t3, tc.t4, tc.t5, tc.t6) - test(tests) + # Python classes that inherit builtin methods + class Int(int): "Int(x[, base]) -> integer" + class List(list): "List() -> new empty list" + # Simulate builtin with no docstring for default argspec test + class SB: __call__ = None + + __main__.__dict__.update(locals()) # required for get_entity eval() + + num_tests = num_fail = 0 + tip = CallTips().fetch_tip + + def test(expression, expected): + nonlocal num_tests, num_fail + num_tests += 1 + argspec = tip(expression) + if argspec != expected: + num_fail += 1 + fmt = "%s - expected\n%r\n - but got\n%r" + print(fmt % (expression, expected, argspec)) + + def test_builtins(): + # if first line of a possibly multiline compiled docstring changes, + # must change corresponding test string + test('int', "int(x=0) -> integer") + test('Int', Int.__doc__) + test('types.MethodType', "method(function, instance)") + test('list', "list() -> new empty list") + test('List', List.__doc__) + test('list.__new__', + 'T.__new__(S, ...) -> a new object with type S, a subtype of T') + test('list.__init__', + 'x.__init__(...) initializes x; see help(type(x)) for signature') + append_doc = "L.append(object) -> None -- append object to end" + test('list.append', append_doc) + test('[].append', append_doc) + test('List.append', append_doc) + test('SB()', _default_callable_argspec) + + def test_funcs(): + for func in (t1, t2, t3, t4, t5, TC,): + fdoc = func.__doc__ + test(func.__name__, fdoc + "\n" + fdoc) + for func in (TC.t1, TC.t2, TC.t3, TC.t4, TC.t5, TC.t6, TC.sm, + TC.__call__): + fdoc = func.__doc__ + test('TC.'+func.__name__, fdoc + "\n" + fdoc) + fdoc = TC.cm.__func__.__doc__ + test('TC.cm.__func__', fdoc + "\n" + fdoc) + + def test_methods(): + # test that first parameter is correctly removed from argspec + # using _first_param re to calculate expected masks re errors + for meth, mdoc in ((tc.t1, "()"), (tc.t4, "(*args)"), (tc.t6, "(self)"), + (TC.cm, "(a)"),): + test('tc.'+meth.__name__, mdoc + "\n" + meth.__doc__) + test('tc', "(ci)" + "\n" + tc.__call__.__doc__) + # directly test that re works to delete unicode parameter name + uni = "(A\u0391\u0410\u05d0\u0627\u0905\u1e00\u3042, a)" # various As + assert _first_param.sub('', uni) == '(a)' + + def test_non_callables(): + # expression evaluates, but not to a callable + for expr in ('0', '0.0' 'num_tests', b'num_tests', '[]', '{}'): + test(expr, '') + # expression does not evaluate, but raises an exception + for expr in ('1a', 'xyx', 'num_tests.xyz', '[int][1]', '{0:int}[1]'): + test(expr, '') + + test_builtins() + test_funcs() + test_non_callables() + test_methods() + + print("%d of %d tests failed" % (num_fail, num_tests)) if __name__ == '__main__': main() |