extensions.py
361 lines
| 10.7 KiB
| text/x-python
|
PythonLexer
/ mercurial / extensions.py
|
r4544 | # extensions.py - extension handling for mercurial | ||
# | ||||
|
r4635 | # Copyright 2005-2007 Matt Mackall <mpm@selenic.com> | ||
|
r4544 | # | ||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r4544 | |||
|
r8896 | import imp, os | ||
|
r14317 | import util, cmdutil, error | ||
|
r8871 | from i18n import _, gettext | ||
|
r4544 | |||
_extensions = {} | ||||
|
r5192 | _order = [] | ||
|
r18629 | _ignore = ['hbisect', 'bookmarks', 'parentrevspec', 'interhg'] | ||
|
r5192 | |||
def extensions(): | ||||
for name in _order: | ||||
module = _extensions[name] | ||||
if module: | ||||
yield name, module | ||||
|
r4544 | |||
def find(name): | ||||
'''return module with given extension name''' | ||||
|
r14415 | mod = None | ||
|
r4544 | try: | ||
|
r14415 | mod = _extensions[name] | ||
|
r4544 | except KeyError: | ||
for k, v in _extensions.iteritems(): | ||||
|
r4560 | if k.endswith('.' + name) or k.endswith('/' + name): | ||
|
r14415 | mod = v | ||
break | ||||
if not mod: | ||||
|
r4544 | raise KeyError(name) | ||
|
r14415 | return mod | ||
|
r4544 | |||
|
r7916 | def loadpath(path, module_name): | ||
module_name = module_name.replace('.', '_') | ||||
|
r9610 | path = util.expandpath(path) | ||
|
r7916 | if os.path.isdir(path): | ||
# module/__init__.py style | ||||
|
r7960 | d, f = os.path.split(path.rstrip('/')) | ||
|
r7916 | fd, fpath, desc = imp.find_module(f, [d]) | ||
return imp.load_module(module_name, fd, fpath, desc) | ||||
else: | ||||
|
r17217 | try: | ||
return imp.load_source(module_name, path) | ||||
except IOError, exc: | ||||
if not exc.filename: | ||||
exc.filename = path # python does not fill this | ||||
raise | ||||
|
r7916 | |||
|
r4544 | def load(ui, name, path): | ||
|
r7011 | if name.startswith('hgext.') or name.startswith('hgext/'): | ||
|
r5031 | shortname = name[6:] | ||
else: | ||||
shortname = name | ||||
|
r13349 | if shortname in _ignore: | ||
return None | ||||
|
r5031 | if shortname in _extensions: | ||
|
r12779 | return _extensions[shortname] | ||
|
r5087 | _extensions[shortname] = None | ||
|
r4544 | if path: | ||
# the module will be loaded in sys.modules | ||||
# choose an unique name so that it doesn't | ||||
# conflicts with other modules | ||||
|
r7916 | mod = loadpath(path, 'hgext.%s' % name) | ||
|
r4544 | else: | ||
def importh(name): | ||||
mod = __import__(name) | ||||
components = name.split('.') | ||||
for comp in components[1:]: | ||||
mod = getattr(mod, comp) | ||||
return mod | ||||
try: | ||||
mod = importh("hgext.%s" % name) | ||||
|
r15199 | except ImportError, err: | ||
ui.debug('could not import hgext.%s (%s): trying %s\n' | ||||
% (name, err, name)) | ||||
|
r4544 | mod = importh(name) | ||
|
r5031 | _extensions[shortname] = mod | ||
|
r5192 | _order.append(shortname) | ||
|
r12779 | return mod | ||
|
r4544 | |||
def loadall(ui): | ||||
|
r4617 | result = ui.configitems("extensions") | ||
|
r9410 | newindex = len(_order) | ||
|
r7876 | for (name, path) in result: | ||
|
r4617 | if path: | ||
|
r5469 | if path[0] == '!': | ||
continue | ||||
|
r4544 | try: | ||
load(ui, name, path) | ||||
|
r7644 | except KeyboardInterrupt: | ||
|
r4544 | raise | ||
except Exception, inst: | ||||
|
r6204 | if path: | ||
ui.warn(_("*** failed to import extension %s from %s: %s\n") | ||||
% (name, path, inst)) | ||||
else: | ||||
ui.warn(_("*** failed to import extension %s: %s\n") | ||||
% (name, inst)) | ||||
|
r8206 | if ui.traceback(): | ||
|
r4544 | return 1 | ||
|
r9410 | for name in _order[newindex:]: | ||
uisetup = getattr(_extensions[name], 'uisetup', None) | ||||
if uisetup: | ||||
uisetup(ui) | ||||
|
r9660 | for name in _order[newindex:]: | ||
extsetup = getattr(_extensions[name], 'extsetup', None) | ||||
if extsetup: | ||||
try: | ||||
extsetup(ui) | ||||
except TypeError: | ||||
if extsetup.func_code.co_argcount != 0: | ||||
raise | ||||
extsetup() # old extsetup with no ui argument | ||||
|
r7215 | def wrapcommand(table, command, wrapper): | ||
|
r11519 | '''Wrap the command named `command' in table | ||
Replace command in the command table with wrapper. The wrapped command will | ||||
be inserted into the command table specified by the table argument. | ||||
The wrapper will be called like | ||||
wrapper(orig, *args, **kwargs) | ||||
where orig is the original (wrapped) function, and *args, **kwargs | ||||
are the arguments passed to it. | ||||
''' | ||||
|
r14943 | assert util.safehasattr(wrapper, '__call__') | ||
|
r7215 | aliases, entry = cmdutil.findcmd(command, table) | ||
for alias, e in table.iteritems(): | ||||
if e is entry: | ||||
key = alias | ||||
break | ||||
origfn = entry[0] | ||||
def wrap(*args, **kwargs): | ||||
|
r7388 | return util.checksignature(wrapper)( | ||
util.checksignature(origfn), *args, **kwargs) | ||||
|
r7215 | |||
wrap.__doc__ = getattr(origfn, '__doc__') | ||||
|
r7373 | wrap.__module__ = getattr(origfn, '__module__') | ||
|
r7215 | |||
newentry = list(entry) | ||||
newentry[0] = wrap | ||||
table[key] = tuple(newentry) | ||||
return entry | ||||
def wrapfunction(container, funcname, wrapper): | ||||
|
r11402 | '''Wrap the function named funcname in container | ||
|
r11520 | Replace the funcname member in the given container with the specified | ||
wrapper. The container is typically a module, class, or instance. | ||||
|
r11402 | |||
The wrapper will be called like | ||||
wrapper(orig, *args, **kwargs) | ||||
where orig is the original (wrapped) function, and *args, **kwargs | ||||
are the arguments passed to it. | ||||
Wrapping methods of the repository object is not recommended since | ||||
it conflicts with extensions that extend the repository by | ||||
subclassing. All extensions that need to extend methods of | ||||
localrepository should use this subclassing trick: namely, | ||||
reposetup() should look like | ||||
def reposetup(ui, repo): | ||||
class myrepo(repo.__class__): | ||||
def whatever(self, *args, **kwargs): | ||||
[...extension stuff...] | ||||
super(myrepo, self).whatever(*args, **kwargs) | ||||
[...extension stuff...] | ||||
repo.__class__ = myrepo | ||||
In general, combining wrapfunction() with subclassing does not | ||||
work. Since you cannot control what other extensions are loaded by | ||||
your end users, you should play nicely with others by using the | ||||
subclass trick. | ||||
''' | ||||
|
r14943 | assert util.safehasattr(wrapper, '__call__') | ||
|
r7215 | def wrap(*args, **kwargs): | ||
return wrapper(origfn, *args, **kwargs) | ||||
origfn = getattr(container, funcname) | ||||
|
r14943 | assert util.safehasattr(origfn, '__call__') | ||
|
r7215 | setattr(container, funcname, wrap) | ||
return origfn | ||||
|
r8871 | |||
|
r10364 | def _disabledpaths(strip_init=False): | ||
'''find paths of disabled extensions. returns a dict of {name: path} | ||||
removes /__init__.py from packages if strip_init is True''' | ||||
|
r8872 | import hgext | ||
extpath = os.path.dirname(os.path.abspath(hgext.__file__)) | ||||
|
r8964 | try: # might not be a filesystem path | ||
files = os.listdir(extpath) | ||||
except OSError: | ||||
|
r10363 | return {} | ||
|
r8964 | |||
|
r8871 | exts = {} | ||
|
r8964 | for e in files: | ||
|
r8872 | if e.endswith('.py'): | ||
name = e.rsplit('.', 1)[0] | ||||
path = os.path.join(extpath, e) | ||||
else: | ||||
name = e | ||||
path = os.path.join(extpath, e, '__init__.py') | ||||
|
r8877 | if not os.path.exists(path): | ||
continue | ||||
|
r10364 | if strip_init: | ||
path = os.path.dirname(path) | ||||
|
r10363 | if name in exts or name in _order or name == '__init__': | ||
continue | ||||
exts[name] = path | ||||
return exts | ||||
|
r8872 | |||
|
r14317 | def _moduledoc(file): | ||
'''return the top-level python documentation for the given file | ||||
Loosely inspired by pydoc.source_synopsis(), but rewritten to | ||||
handle triple quotes and to return the whole text instead of just | ||||
the synopsis''' | ||||
result = [] | ||||
line = file.readline() | ||||
while line[:1] == '#' or not line.strip(): | ||||
line = file.readline() | ||||
if not line: | ||||
break | ||||
start = line[:3] | ||||
if start == '"""' or start == "'''": | ||||
line = line[3:] | ||||
while line: | ||||
if line.rstrip().endswith(start): | ||||
line = line.split(start)[0] | ||||
if line: | ||||
result.append(line) | ||||
break | ||||
elif not line: | ||||
return None # unmatched delimiter | ||||
result.append(line) | ||||
line = file.readline() | ||||
else: | ||||
return None | ||||
return ''.join(result) | ||||
|
r10363 | def _disabledhelp(path): | ||
'''retrieve help synopsis of a disabled extension (without importing)''' | ||||
try: | ||||
file = open(path) | ||||
except IOError: | ||||
return | ||||
else: | ||||
|
r14318 | doc = _moduledoc(file) | ||
|
r10363 | file.close() | ||
if doc: # extracting localized synopsis | ||||
return gettext(doc).splitlines()[0] | ||||
else: | ||||
return _('(no help text available)') | ||||
def disabled(): | ||||
|
r14530 | '''find disabled extensions from hgext. returns a dict of {name: desc}''' | ||
|
r14539 | try: | ||
from hgext import __index__ | ||||
return dict((name, gettext(desc)) | ||||
for name, desc in __index__.docs.iteritems() | ||||
if name not in _order) | ||||
except ImportError: | ||||
pass | ||||
|
r10363 | paths = _disabledpaths() | ||
if not paths: | ||||
|
r16709 | return {} | ||
|
r10363 | |||
exts = {} | ||||
for name, path in paths.iteritems(): | ||||
doc = _disabledhelp(path) | ||||
|
r14316 | if doc: | ||
exts[name] = doc | ||||
|
r8871 | |||
|
r14316 | return exts | ||
|
r8871 | |||
|
r10364 | def disabledext(name): | ||
'''find a specific disabled extension from hgext. returns desc''' | ||||
|
r14539 | try: | ||
from hgext import __index__ | ||||
if name in _order: # enabled | ||||
return | ||||
else: | ||||
return gettext(__index__.docs.get(name)) | ||||
except ImportError: | ||||
pass | ||||
|
r10364 | paths = _disabledpaths() | ||
if name in paths: | ||||
return _disabledhelp(paths[name]) | ||||
|
r13191 | def disabledcmd(ui, cmd, strict=False): | ||
|
r10364 | '''import disabled extensions until cmd is found. | ||
|
r16666 | returns (cmdname, extname, module)''' | ||
|
r10364 | |||
paths = _disabledpaths(strip_init=True) | ||||
if not paths: | ||||
raise error.UnknownCommand(cmd) | ||||
def findcmd(cmd, name, path): | ||||
try: | ||||
mod = loadpath(path, 'hgext.%s' % name) | ||||
except Exception: | ||||
return | ||||
try: | ||||
aliases, entry = cmdutil.findcmd(cmd, | ||||
getattr(mod, 'cmdtable', {}), strict) | ||||
except (error.AmbiguousCommand, error.UnknownCommand): | ||||
return | ||||
|
r13191 | except Exception: | ||
ui.warn(_('warning: error finding commands in %s\n') % path) | ||||
ui.traceback() | ||||
return | ||||
|
r10364 | for c in aliases: | ||
if c.startswith(cmd): | ||||
cmd = c | ||||
break | ||||
else: | ||||
cmd = aliases[0] | ||||
return (cmd, name, mod) | ||||
|
r16667 | ext = None | ||
|
r10364 | # first, search for an extension with the same name as the command | ||
path = paths.pop(cmd, None) | ||||
if path: | ||||
ext = findcmd(cmd, cmd, path) | ||||
|
r16667 | if not ext: | ||
# otherwise, interrogate each extension until there's a match | ||||
for name, path in paths.iteritems(): | ||||
ext = findcmd(cmd, name, path) | ||||
if ext: | ||||
break | ||||
if ext and 'DEPRECATED' not in ext.__doc__: | ||||
return ext | ||||
|
r10364 | |||
raise error.UnknownCommand(cmd) | ||||
|
r19769 | def enabled(shortname=True): | ||
|
r14530 | '''return a dict of {name: desc} of extensions''' | ||
|
r8871 | exts = {} | ||
for ename, ext in extensions(): | ||||
doc = (gettext(ext.__doc__) or _('(no help text available)')) | ||||
|
r19769 | if shortname: | ||
ename = ename.split('.')[-1] | ||||
|
r9136 | exts[ename] = doc.splitlines()[0].strip() | ||
|
r8871 | |||
|
r14316 | return exts | ||