From 67b595a2904e477aa06913ebf46e7ce7130801f9 Mon Sep 17 00:00:00 2001 From: Stefan Monnier Date: Sun, 20 Aug 2006 17:54:48 +0000 Subject: [PATCH] Update to Dave Love's latest version. (__all__): Fix args -> eargs. Add new `modpath' fun. (eargs): Add `imports' arg. (all_names): New fun. (complete): Rewrite without using rlcompleter. Remove `namespace' arg, add `imports' arg. (ehelp): Replace g and l args with `imports'. (eimport): Use __main__ rather than `emacs' namespace. (modpath): New fun. --- etc/ChangeLog | 12 +++++ etc/emacs.py | 140 +++++++++++++++++++++++++++++++++++++++----------- 2 files changed, 122 insertions(+), 30 deletions(-) diff --git a/etc/ChangeLog b/etc/ChangeLog index ec2b017c25c..6f177e3b890 100644 --- a/etc/ChangeLog +++ b/etc/ChangeLog @@ -1,3 +1,15 @@ +2006-08-20 Dave Love + + * emacs.py: Update to Dave Love's latest version. + (__all__): Fix args -> eargs. Add new `modpath' fun. + (eargs): Add `imports' arg. + (all_names): New fun. + (complete): Rewrite without using rlcompleter. + Remove `namespace' arg, add `imports' arg. + (ehelp): Replace g and l args with `imports'. + (eimport): Use __main__ rather than `emacs' namespace. + (modpath): New fun. + 2006-08-20 Slawomir Nowaczyk (tiny change) * emacs.py (eexecfile): Use the __main__ rather than `emacs' namespace. diff --git a/etc/emacs.py b/etc/emacs.py index bc6c5bb034d..7614f0927df 100644 --- a/etc/emacs.py +++ b/etc/emacs.py @@ -1,7 +1,7 @@ """Definitions used by commands sent to inferior Python in python.el.""" -# Copyright (C) 2004, 2005, 2006 Free Software Foundation, Inc. -# Author: Dave Love +# Copyright (C) 2004, 2005, 2006 Free Software Foundation, Inc. +# Author: Dave Love # This file is part of GNU Emacs. @@ -20,9 +20,10 @@ # Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, # Boston, MA 02110-1301, USA. -import os, sys, traceback, inspect, rlcompleter, __main__ +import os, sys, traceback, inspect, __main__ +from sets import Set -__all__ = ["eexecfile", "args", "complete", "ehelp", "eimport"] +__all__ = ["eexecfile", "eargs", "complete", "ehelp", "eimport", "modpath"] def eexecfile (file): """Execute FILE and then remove it. @@ -32,8 +33,8 @@ def eexecfile (file): try: try: execfile (file, __main__.__dict__) except: - (type, value, tb) = sys.exc_info () - # Lose the stack frame for this location. + (type, value, tb) = sys.exc_info () + # Lose the stack frame for this location. tb = tb.tb_next if tb is None: # print_exception won't do it print "Traceback (most recent call last):" @@ -41,9 +42,10 @@ def eexecfile (file): finally: os.remove (file) -def eargs (name): +def eargs (name, imports): "Get arglist of NAME for Eldoc &c." try: + if imports: exec imports parts = name.split ('.') if len (parts) > 1: exec 'import ' + parts[0] # might fail @@ -57,8 +59,7 @@ def eargs (name): return if inspect.ismethod (func): func = func.im_func - if not inspect.isfunction (func): - return + if not inspect.isfunction (func): return (args, varargs, varkw, defaults) = inspect.getargspec (func) # No space between name and arglist for consistency with builtins. print '_emacs_out', \ @@ -66,41 +67,109 @@ def eargs (name): defaults) except: pass -def complete (text, namespace = None): +def all_names (object): + """Return (an approximation to) a list of all possible attribute + names reachable via the attributes of OBJECT, i.e. roughly the + leaves of the dictionary tree under it.""" + + def do_object (object, names): + if inspect.ismodule (object): + do_module (object, names) + elif inspect.isclass (object): + do_class (object, names) + # Might have an object without its class in scope. + elif hasattr (object, '__class__'): + names.add ('__class__') + do_class (object.__class__, names) + # Probably not a good idea to try to enumerate arbitrary + # dictionaries... + return names + + def do_module (module, names): + if hasattr (module, '__all__'): # limited export list + names.union_update (module.__all__) + for i in module.__all__: + do_object (getattr (module, i), names) + else: # use all names + names.union_update (dir (module)) + for i in dir (module): + do_object (getattr (module, i), names) + return names + + def do_class (object, names): + ns = dir (object) + names.union_update (ns) + if hasattr (object, '__bases__'): # superclasses + for i in object.__bases__: do_object (i, names) + return names + + return do_object (object, Set ([])) + +def complete (name, imports): """Complete TEXT in NAMESPACE and print a Lisp list of completions. - NAMESPACE is currently not used.""" - if namespace is None: namespace = __main__.__dict__ - c = rlcompleter.Completer (namespace) + Exec IMPORTS first.""" + import __main__, keyword + + def class_members(object): + names = dir (object) + if hasattr (object, '__bases__'): + for super in object.__bases__: + names = class_members (super) + return names + + names = Set ([]) + base = None try: - if '.' in text: - matches = c.attr_matches (text) - else: - matches = c.global_matches (text) - print '_emacs_out (', - for elt in matches: - print '"%s"' % elt, - print ')' - except: - print '_emacs_out ()' + dict = __main__.__dict__.copy() + if imports: exec imports in dict + l = len (name) + if not "." in name: + for list in [dir (__builtins__), keyword.kwlist, dict.keys()]: + for elt in list: + if elt[:l] == name: names.add(elt) + else: + base = name[:name.rfind ('.')] + name = name[name.rfind('.')+1:] + try: + object = eval (base, dict) + names = Set (dir (object)) + if hasattr (object, '__class__'): + names.add('__class__') + names.union_update (class_members (object)) + except: names = all_names (dict) + except: return [] + l = len(name) + print '_emacs_out (', + for n in names: + if name == n[:l]: + if base: print '"%s.%s"' % (base, n), + else: print '"%s"' % n, + print ')' -def ehelp (name, g, l): - """Get help on string NAME using globals G and locals L. +def ehelp (name, imports): + """Get help on string NAME. First try to eval name for, e.g. user definitions where we need the object. Otherwise try the string form.""" - try: help (eval (name, g, l)) + locls = {} + if imports: + try: exec imports in locls + except: pass + try: help (eval (name, globals(), locls)) except: help (name) def eimport (mod, dir): """Import module MOD with directory DIR at the head of the search path. NB doesn't load from DIR if MOD shadows a system module.""" + from __main__ import __dict__ + path0 = sys.path[0] sys.path[0] = dir try: try: - if globals().has_key(mod) and inspect.ismodule (eval (mod)): - reload(eval (mod)) + if __dict__.has_key(mod) and inspect.ismodule (__dict__[mod]): + reload (__dict__[mod]) else: - globals ()[mod] = __import__ (mod) + __dict__[mod] = __import__ (mod) except: (type, value, tb) = sys.exc_info () print "Traceback (most recent call last):" @@ -108,6 +177,17 @@ def eimport (mod, dir): finally: sys.path[0] = path0 -print '_emacs_ok' # ready for input and can call continuation +def modpath (module): + """Return the source file for the given MODULE (or None). +Assumes that MODULE.py and MODULE.pyc are in the same directory.""" + try: + path = __import__ (module).__file__ + if path[-4:] == '.pyc' and os.path.exists (path[0:-1]): + path = path[:-1] + print "_emacs_out", path + except: + print "_emacs_out ()" + +# print '_emacs_ok' # ready for input and can call continuation # arch-tag: d90408f3-90e2-4de4-99c2-6eb9c7b9ca46 -- 2.39.2