extensions.py
840 lines
| 28.3 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 | |||
|
r25946 | from __future__ import absolute_import | ||
|
r38180 | import ast | ||
import collections | ||||
|
r34089 | import functools | ||
|
r25946 | import imp | ||
|
r31263 | import inspect | ||
|
r25946 | import os | ||
from .i18n import ( | ||||
_, | ||||
gettext, | ||||
) | ||||
from . import ( | ||||
cmdutil, | ||||
r33127 | configitems, | |||
|
r25946 | error, | ||
|
r30570 | pycompat, | ||
|
r25946 | util, | ||
) | ||||
|
r4544 | |||
|
r37102 | from .utils import ( | ||
stringutil, | ||||
) | ||||
|
r4544 | _extensions = {} | ||
|
r29895 | _disabledextensions = {} | ||
|
r24065 | _aftercallbacks = {} | ||
|
r5192 | _order = [] | ||
|
r33526 | _builtin = { | ||
'hbisect', | ||||
'bookmarks', | ||||
|
r33527 | 'color', | ||
|
r33526 | 'parentrevspec', | ||
'progress', | ||||
'interhg', | ||||
'inotify', | ||||
|
r42750 | 'hgcia', | ||
'shelve', | ||||
|
r33526 | } | ||
|
r5192 | |||
|
r19777 | def extensions(ui=None): | ||
if ui: | ||||
def enabled(name): | ||||
for format in ['%s', 'hgext.%s']: | ||||
conf = ui.config('extensions', format % name) | ||||
if conf is not None and not conf.startswith('!'): | ||||
return True | ||||
else: | ||||
enabled = lambda name: True | ||||
|
r5192 | for name in _order: | ||
module = _extensions[name] | ||||
|
r19777 | if module and enabled(name): | ||
|
r5192 | yield name, module | ||
|
r4544 | |||
def find(name): | ||||
'''return module with given extension name''' | ||||
|
r14415 | mod = None | ||
|
r4544 | try: | ||
|
r27637 | 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('.', '_') | ||||
|
r20645 | path = util.normpath(util.expandpath(path)) | ||
|
r30575 | module_name = pycompat.fsdecode(module_name) | ||
path = pycompat.fsdecode(path) | ||||
|
r7916 | if os.path.isdir(path): | ||
# module/__init__.py style | ||||
|
r20645 | d, f = os.path.split(path) | ||
|
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) | ||||
|
r25660 | except IOError as exc: | ||
|
r17217 | if not exc.filename: | ||
exc.filename = path # python does not fill this | ||||
raise | ||||
|
r7916 | |||
|
r28505 | def _importh(name): | ||
"""import and return the <name> module""" | ||||
|
r30570 | mod = __import__(pycompat.sysstr(name)) | ||
|
r28505 | components = name.split('.') | ||
for comp in components[1:]: | ||||
mod = getattr(mod, comp) | ||||
return mod | ||||
|
r30058 | def _importext(name, path=None, reportfunc=None): | ||
if path: | ||||
# the module will be loaded in sys.modules | ||||
# choose an unique name so that it doesn't | ||||
# conflicts with other modules | ||||
mod = loadpath(path, 'hgext.%s' % name) | ||||
else: | ||||
try: | ||||
mod = _importh("hgext.%s" % name) | ||||
except ImportError as err: | ||||
if reportfunc: | ||||
reportfunc(err, "hgext.%s" % name, "hgext3rd.%s" % name) | ||||
try: | ||||
mod = _importh("hgext3rd.%s" % name) | ||||
except ImportError as err: | ||||
if reportfunc: | ||||
reportfunc(err, "hgext3rd.%s" % name, name) | ||||
mod = _importh(name) | ||||
return mod | ||||
|
r28506 | def _reportimporterror(ui, err, failed, next): | ||
|
r41032 | # note: this ui.log happens before --debug is processed, | ||
|
r30028 | # Use --config ui.debug=1 to see them. | ||
|
r41032 | ui.log(b'extension', b' - could not import %s (%s): trying %s\n', | ||
failed, stringutil.forcebytestr(err), next) | ||||
if ui.debugflag and ui.configbool('devel', 'debug.extensions'): | ||||
ui.traceback() | ||||
|
r28506 | |||
|
r36283 | def _rejectunicode(name, xs): | ||
if isinstance(xs, (list, set, tuple)): | ||||
for x in xs: | ||||
_rejectunicode(name, x) | ||||
elif isinstance(xs, dict): | ||||
for k, v in xs.items(): | ||||
_rejectunicode(name, k) | ||||
|
r37102 | _rejectunicode(b'%s.%s' % (name, stringutil.forcebytestr(k)), v) | ||
|
r36283 | elif isinstance(xs, type(u'')): | ||
raise error.ProgrammingError(b"unicode %r found in %s" % (xs, name), | ||||
hint="use b'' to make it byte string") | ||||
|
r32342 | # attributes set by registrar.command | ||
_cmdfuncattrs = ('norepo', 'optionalrepo', 'inferrepo') | ||||
|
r32343 | def _validatecmdtable(ui, cmdtable): | ||
|
r32342 | """Check if extension commands have required attributes""" | ||
for c, e in cmdtable.iteritems(): | ||||
f = e[0] | ||||
missing = [a for a in _cmdfuncattrs if not util.safehasattr(f, a)] | ||||
if not missing: | ||||
continue | ||||
raise error.ProgrammingError( | ||||
'missing attributes: %s' % ', '.join(missing), | ||||
hint="use @command decorator to register '%s'" % c) | ||||
|
r36283 | def _validatetables(ui, mod): | ||
"""Sanity check for loadable tables provided by extension module""" | ||||
for t in ['cmdtable', 'colortable', 'configtable']: | ||||
_rejectunicode(t, getattr(mod, t, {})) | ||||
for t in ['filesetpredicate', 'internalmerge', 'revsetpredicate', | ||||
'templatefilter', 'templatefunc', 'templatekeyword']: | ||||
o = getattr(mod, t, None) | ||||
if o: | ||||
_rejectunicode(t, o._table) | ||||
_validatecmdtable(ui, getattr(mod, 'cmdtable', {})) | ||||
|
r41032 | def load(ui, name, path, loadingtime=None): | ||
|
r7011 | if name.startswith('hgext.') or name.startswith('hgext/'): | ||
|
r5031 | shortname = name[6:] | ||
else: | ||||
shortname = name | ||||
|
r27111 | if shortname in _builtin: | ||
|
r13349 | return None | ||
|
r5031 | if shortname in _extensions: | ||
|
r12779 | return _extensions[shortname] | ||
|
r41032 | ui.log(b'extension', b' - loading extension: %s\n', shortname) | ||
|
r5087 | _extensions[shortname] = None | ||
|
r40467 | with util.timedcm('load extension %s', shortname) as stats: | ||
|
r38834 | mod = _importext(name, path, bind(_reportimporterror, ui)) | ||
|
r41032 | ui.log(b'extension', b' > %s extension loaded in %s\n', shortname, stats) | ||
|
r39547 | if loadingtime is not None: | ||
loadingtime[shortname] += stats.elapsed | ||||
|
r27142 | |||
# Before we do anything with the extension, check against minimum stated | ||||
# compatibility. This gives extension authors a mechanism to have their | ||||
# extensions short circuit when loaded with a known incompatible version | ||||
# of Mercurial. | ||||
minver = getattr(mod, 'minimumhgversion', None) | ||||
if minver and util.versiontuple(minver, 2) > util.versiontuple(n=2): | ||||
|
r40499 | msg = _('(third party extension %s requires version %s or newer ' | ||
'of Mercurial (current: %s); disabling)\n') | ||||
ui.warn(msg % (shortname, minver, util.version())) | ||||
|
r27142 | return | ||
|
r41032 | ui.log(b'extension', b' - validating extension tables: %s\n', shortname) | ||
|
r36283 | _validatetables(ui, mod) | ||
|
r27142 | |||
|
r5031 | _extensions[shortname] = mod | ||
|
r5192 | _order.append(shortname) | ||
|
r41032 | ui.log(b'extension', b' - invoking registered callbacks: %s\n', | ||
shortname) | ||||
|
r40467 | with util.timedcm('callbacks extension %s', shortname) as stats: | ||
|
r38834 | for fn in _aftercallbacks.get(shortname, []): | ||
fn(loaded=True) | ||||
|
r41032 | ui.log(b'extension', b' > callbacks completed in %s\n', stats) | ||
|
r12779 | return mod | ||
|
r4544 | |||
|
r29461 | def _runuisetup(name, ui): | ||
uisetup = getattr(_extensions[name], 'uisetup', None) | ||||
if uisetup: | ||||
|
r32724 | try: | ||
uisetup(ui) | ||||
except Exception as inst: | ||||
|
r34846 | ui.traceback(force=True) | ||
|
r37102 | msg = stringutil.forcebytestr(inst) | ||
|
r32724 | ui.warn(_("*** failed to set up extension %s: %s\n") % (name, msg)) | ||
return False | ||||
return True | ||||
|
r29461 | |||
def _runextsetup(name, ui): | ||||
extsetup = getattr(_extensions[name], 'extsetup', None) | ||||
if extsetup: | ||||
try: | ||||
|
r42522 | extsetup(ui) | ||
|
r32724 | except Exception as inst: | ||
|
r34846 | ui.traceback(force=True) | ||
|
r37102 | msg = stringutil.forcebytestr(inst) | ||
|
r32724 | ui.warn(_("*** failed to set up extension %s: %s\n") % (name, msg)) | ||
return False | ||||
return True | ||||
|
r29461 | |||
|
r32416 | def loadall(ui, whitelist=None): | ||
|
r39547 | loadingtime = collections.defaultdict(int) | ||
|
r4617 | result = ui.configitems("extensions") | ||
|
r32417 | if whitelist is not None: | ||
|
r32416 | result = [(k, v) for (k, v) in result if k in whitelist] | ||
|
r9410 | newindex = len(_order) | ||
|
r41032 | ui.log(b'extension', b'loading %sextensions\n', | ||
'additional ' if newindex else '') | ||||
ui.log(b'extension', b'- processing %d entries\n', len(result)) | ||||
|
r39294 | with util.timedcm('load all extensions') as stats: | ||
|
r38834 | for (name, path) in result: | ||
|
r6204 | if path: | ||
|
r38834 | if path[0:1] == '!': | ||
if name not in _disabledextensions: | ||||
|
r41032 | ui.log(b'extension', | ||
b' - skipping disabled extension: %s\n', name) | ||||
|
r38834 | _disabledextensions[name] = path[1:] | ||
continue | ||||
try: | ||||
|
r41032 | load(ui, name, path, loadingtime) | ||
|
r38834 | except Exception as inst: | ||
msg = stringutil.forcebytestr(inst) | ||||
if path: | ||||
ui.warn(_("*** failed to import extension %s from %s: %s\n") | ||||
% (name, path, msg)) | ||||
else: | ||||
ui.warn(_("*** failed to import extension %s: %s\n") | ||||
% (name, msg)) | ||||
if isinstance(inst, error.Hint) and inst.hint: | ||||
ui.warn(_("*** (%s)\n") % inst.hint) | ||||
ui.traceback() | ||||
|
r41032 | ui.log(b'extension', b'> loaded %d extensions, total time %s\n', | ||
len(_order) - newindex, stats) | ||||
|
r34188 | # list of (objname, loadermod, loadername) tuple: | ||
# - objname is the name of an object in extension module, | ||||
# from which extra information is loaded | ||||
# - loadermod is the module where loader is placed | ||||
# - loadername is the name of the function, | ||||
# which takes (ui, extensionname, extraobj) arguments | ||||
# | ||||
# This one is for the list of item that must be run before running any setup | ||||
earlyextraloaders = [ | ||||
('configtable', configitems, 'loadconfigtable'), | ||||
] | ||||
|
r38834 | |||
|
r41032 | ui.log(b'extension', b'- loading configtable attributes\n') | ||
|
r34188 | _loadextra(ui, newindex, earlyextraloaders) | ||
|
r4544 | |||
|
r32724 | broken = set() | ||
|
r41032 | ui.log(b'extension', b'- executing uisetup hooks\n') | ||
|
r39544 | with util.timedcm('all uisetup') as alluisetupstats: | ||
for name in _order[newindex:]: | ||||
|
r41032 | ui.log(b'extension', b' - running uisetup for %s\n', name) | ||
|
r40467 | with util.timedcm('uisetup %s', name) as stats: | ||
|
r39544 | if not _runuisetup(name, ui): | ||
|
r41032 | ui.log(b'extension', | ||
b' - the %s extension uisetup failed\n', name) | ||||
|
r39544 | broken.add(name) | ||
|
r41032 | ui.log(b'extension', b' > uisetup for %s took %s\n', name, stats) | ||
|
r39547 | loadingtime[name] += stats.elapsed | ||
|
r41032 | ui.log(b'extension', b'> all uisetup took %s\n', alluisetupstats) | ||
|
r9410 | |||
|
r41032 | ui.log(b'extension', b'- executing extsetup hooks\n') | ||
|
r39545 | with util.timedcm('all extsetup') as allextetupstats: | ||
for name in _order[newindex:]: | ||||
if name in broken: | ||||
continue | ||||
|
r41032 | ui.log(b'extension', b' - running extsetup for %s\n', name) | ||
|
r40467 | with util.timedcm('extsetup %s', name) as stats: | ||
|
r39545 | if not _runextsetup(name, ui): | ||
|
r41032 | ui.log(b'extension', | ||
b' - the %s extension extsetup failed\n', name) | ||||
|
r39545 | broken.add(name) | ||
|
r41032 | ui.log(b'extension', b' > extsetup for %s took %s\n', name, stats) | ||
|
r39547 | loadingtime[name] += stats.elapsed | ||
|
r41032 | ui.log(b'extension', b'> all extsetup took %s\n', allextetupstats) | ||
|
r32724 | |||
for name in broken: | ||||
|
r41032 | ui.log(b'extension', b' - disabling broken %s extension\n', name) | ||
|
r32724 | _extensions[name] = None | ||
|
r9660 | |||
|
r24065 | # Call aftercallbacks that were never met. | ||
|
r41032 | ui.log(b'extension', b'- executing remaining aftercallbacks\n') | ||
|
r39294 | with util.timedcm('aftercallbacks') as stats: | ||
|
r38834 | for shortname in _aftercallbacks: | ||
if shortname in _extensions: | ||||
continue | ||||
|
r24065 | |||
|
r38834 | for fn in _aftercallbacks[shortname]: | ||
|
r41032 | ui.log(b'extension', | ||
b' - extension %s not loaded, notify callbacks\n', | ||||
shortname) | ||||
|
r38834 | fn(loaded=False) | ||
|
r41032 | ui.log(b'extension', b'> remaining aftercallbacks completed in %s\n', stats) | ||
|
r24065 | |||
|
r24950 | # loadall() is called multiple times and lingering _aftercallbacks | ||
# entries could result in double execution. See issue4646. | ||||
_aftercallbacks.clear() | ||||
|
r33052 | # delay importing avoids cyclic dependency (especially commands) | ||
from . import ( | ||||
color, | ||||
commands, | ||||
|
r33663 | filemerge, | ||
|
r33052 | fileset, | ||
revset, | ||||
templatefilters, | ||||
|
r36940 | templatefuncs, | ||
|
r33052 | templatekw, | ||
) | ||||
# list of (objname, loadermod, loadername) tuple: | ||||
# - objname is the name of an object in extension module, | ||||
# from which extra information is loaded | ||||
# - loadermod is the module where loader is placed | ||||
# - loadername is the name of the function, | ||||
# which takes (ui, extensionname, extraobj) arguments | ||||
|
r41032 | ui.log(b'extension', b'- loading extension registration objects\n') | ||
|
r33052 | extraloaders = [ | ||
('cmdtable', commands, 'loadcmdtable'), | ||||
('colortable', color, 'loadcolortable'), | ||||
('filesetpredicate', fileset, 'loadpredicate'), | ||||
|
r33663 | ('internalmerge', filemerge, 'loadinternalmerge'), | ||
|
r33052 | ('revsetpredicate', revset, 'loadpredicate'), | ||
('templatefilter', templatefilters, 'loadfilter'), | ||||
|
r36940 | ('templatefunc', templatefuncs, 'loadfunction'), | ||
|
r33052 | ('templatekeyword', templatekw, 'loadkeyword'), | ||
] | ||||
|
r39294 | with util.timedcm('load registration objects') as stats: | ||
|
r38834 | _loadextra(ui, newindex, extraloaders) | ||
|
r41032 | ui.log(b'extension', b'> extension registration object loading took %s\n', | ||
stats) | ||||
|
r39547 | |||
# Report per extension loading time (except reposetup) | ||||
for name in sorted(loadingtime): | ||||
|
r41032 | ui.log(b'extension', b'> extension %s take a total of %s to load\n', | ||
name, util.timecount(loadingtime[name])) | ||||
|
r39547 | |||
|
r41032 | ui.log(b'extension', b'extension loading complete\n') | ||
|
r33052 | |||
|
r34187 | def _loadextra(ui, newindex, extraloaders): | ||
|
r33052 | for name in _order[newindex:]: | ||
module = _extensions[name] | ||||
if not module: | ||||
continue # loading this module failed | ||||
for objname, loadermod, loadername in extraloaders: | ||||
extraobj = getattr(module, objname, None) | ||||
if extraobj is not None: | ||||
getattr(loadermod, loadername)(ui, name, extraobj) | ||||
|
r24065 | def afterloaded(extension, callback): | ||
'''Run the specified function after a named extension is loaded. | ||||
If the named extension is already loaded, the callback will be called | ||||
immediately. | ||||
If the named extension never loads, the callback will be called after | ||||
all extensions have been loaded. | ||||
The callback receives the named argument ``loaded``, which is a boolean | ||||
indicating whether the dependent extension actually loaded. | ||||
''' | ||||
if extension in _extensions: | ||||
|
r33014 | # Report loaded as False if the extension is disabled | ||
loaded = (_extensions[extension] is not None) | ||||
callback(loaded=loaded) | ||||
|
r24065 | else: | ||
_aftercallbacks.setdefault(extension, []).append(callback) | ||||
|
r40760 | def populateui(ui): | ||
"""Run extension hooks on the given ui to populate additional members, | ||||
extend the class dynamically, etc. | ||||
This will be called after the configuration is loaded, and/or extensions | ||||
are loaded. In general, it's once per ui instance, but in command-server | ||||
and hgweb, this may be called more than once with the same ui. | ||||
""" | ||||
for name, mod in extensions(ui): | ||||
hook = getattr(mod, 'uipopulate', None) | ||||
if not hook: | ||||
continue | ||||
try: | ||||
hook(ui) | ||||
except Exception as inst: | ||||
ui.traceback(force=True) | ||||
ui.warn(_('*** failed to populate ui by extension %s: %s\n') | ||||
% (name, stringutil.forcebytestr(inst))) | ||||
|
r24734 | def bind(func, *args): | ||
'''Partial function application | ||||
Returns a new function that is the partial application of args and kwargs | ||||
to func. For example, | ||||
f(1, 2, bar=3) === bind(f, 1)(2, bar=3)''' | ||||
assert callable(func) | ||||
def closure(*a, **kw): | ||||
return func(*(args + a), **kw) | ||||
return closure | ||||
|
r29763 | def _updatewrapper(wrap, origfn, unboundwrapper): | ||
'''Copy and add some useful attributes to wrapper''' | ||||
|
r34130 | try: | ||
wrap.__name__ = origfn.__name__ | ||||
except AttributeError: | ||||
pass | ||||
|
r28310 | wrap.__module__ = getattr(origfn, '__module__') | ||
wrap.__doc__ = getattr(origfn, '__doc__') | ||||
|
r28312 | wrap.__dict__.update(getattr(origfn, '__dict__', {})) | ||
|
r29763 | wrap._origfunc = origfn | ||
wrap._unboundwrapper = unboundwrapper | ||||
|
r28310 | |||
|
r24124 | def wrapcommand(table, command, wrapper, synopsis=None, docstring=None): | ||
|
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. | ||||
|
r24124 | |||
Optionally append to the command synopsis and docstring, used for help. | ||||
For example, if your extension wraps the ``bookmarks`` command to add the | ||||
flags ``--remote`` and ``--all`` you might call this function like so: | ||||
synopsis = ' [-a] [--remote]' | ||||
docstring = """ | ||||
The ``remotenames`` extension adds the ``--remote`` and ``--all`` (``-a``) | ||||
flags to the bookmarks command. Either flag will show the remote bookmarks | ||||
|
r26781 | known to the repository; ``--remote`` will also suppress the output of the | ||
|
r24124 | local bookmarks. | ||
""" | ||||
extensions.wrapcommand(commands.table, 'bookmarks', exbookmarks, | ||||
synopsis, docstring) | ||||
|
r11519 | ''' | ||
|
r21795 | assert callable(wrapper) | ||
|
r7215 | aliases, entry = cmdutil.findcmd(command, table) | ||
for alias, e in table.iteritems(): | ||||
if e is entry: | ||||
key = alias | ||||
break | ||||
origfn = entry[0] | ||||
|
r34090 | wrap = functools.partial(util.checksignature(wrapper), | ||
util.checksignature(origfn)) | ||||
|
r29763 | _updatewrapper(wrap, origfn, wrapper) | ||
|
r24124 | if docstring is not None: | ||
|
r28310 | wrap.__doc__ += docstring | ||
|
r24124 | |||
|
r7215 | newentry = list(entry) | ||
newentry[0] = wrap | ||||
|
r24124 | if synopsis is not None: | ||
newentry[2] += synopsis | ||||
|
r7215 | table[key] = tuple(newentry) | ||
return entry | ||||
|
r32722 | def wrapfilecache(cls, propname, wrapper): | ||
"""Wraps a filecache property. | ||||
These can't be wrapped using the normal wrapfunction. | ||||
""" | ||||
|
r33835 | propname = pycompat.sysstr(propname) | ||
|
r32722 | assert callable(wrapper) | ||
for currcls in cls.__mro__: | ||||
if propname in currcls.__dict__: | ||||
origfn = currcls.__dict__[propname].func | ||||
assert callable(origfn) | ||||
def wrap(*args, **kwargs): | ||||
return wrapper(origfn, *args, **kwargs) | ||||
currcls.__dict__[propname].func = wrap | ||||
break | ||||
if currcls is object: | ||||
|
r33836 | raise AttributeError(r"type '%s' has no property '%s'" % ( | ||
cls, propname)) | ||||
|
r32722 | |||
|
r34016 | class wrappedfunction(object): | ||
'''context manager for temporarily wrapping a function''' | ||||
def __init__(self, container, funcname, wrapper): | ||||
assert callable(wrapper) | ||||
self._container = container | ||||
self._funcname = funcname | ||||
self._wrapper = wrapper | ||||
def __enter__(self): | ||||
wrapfunction(self._container, self._funcname, self._wrapper) | ||||
def __exit__(self, exctype, excvalue, traceback): | ||||
unwrapfunction(self._container, self._funcname, self._wrapper) | ||||
|
r7215 | 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. | ||||
''' | ||||
|
r21795 | assert callable(wrapper) | ||
|
r7215 | |||
origfn = getattr(container, funcname) | ||||
|
r21795 | assert callable(origfn) | ||
|
r34089 | if inspect.ismodule(container): | ||
# origfn is not an instance or class method. "partial" can be used. | ||||
# "partial" won't insert a frame in traceback. | ||||
wrap = functools.partial(wrapper, origfn) | ||||
else: | ||||
# "partial" cannot be safely used. Emulate its effect by using "bind". | ||||
# The downside is one more frame in traceback. | ||||
wrap = bind(wrapper, origfn) | ||||
|
r29763 | _updatewrapper(wrap, origfn, wrapper) | ||
|
r28311 | setattr(container, funcname, wrap) | ||
|
r7215 | return origfn | ||
|
r8871 | |||
|
r29765 | def unwrapfunction(container, funcname, wrapper=None): | ||
'''undo wrapfunction | ||||
If wrappers is None, undo the last wrap. Otherwise removes the wrapper | ||||
from the chain of wrappers. | ||||
Return the removed wrapper. | ||||
Raise IndexError if wrapper is None and nothing to unwrap; ValueError if | ||||
wrapper is not None but is not found in the wrapper chain. | ||||
''' | ||||
chain = getwrapperchain(container, funcname) | ||||
origfn = chain.pop() | ||||
if wrapper is None: | ||||
wrapper = chain[0] | ||||
chain.remove(wrapper) | ||||
setattr(container, funcname, origfn) | ||||
for w in reversed(chain): | ||||
wrapfunction(container, funcname, w) | ||||
return wrapper | ||||
|
r29764 | def getwrapperchain(container, funcname): | ||
'''get a chain of wrappers of a function | ||||
Return a list of functions: [newest wrapper, ..., oldest wrapper, origfunc] | ||||
The wrapper functions are the ones passed to wrapfunction, whose first | ||||
argument is origfunc. | ||||
''' | ||||
result = [] | ||||
fn = getattr(container, funcname) | ||||
while fn: | ||||
assert callable(fn) | ||||
result.append(getattr(fn, '_unboundwrapper', fn)) | ||||
fn = getattr(fn, '_origfunc', None) | ||||
return result | ||||
|
r38181 | def _disabledpaths(): | ||
'''find paths of disabled extensions. returns a dict of {name: path}''' | ||||
|
r8872 | import hgext | ||
|
r31074 | extpath = os.path.dirname( | ||
os.path.abspath(pycompat.fsencode(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 | ||||
|
r10363 | if name in exts or name in _order or name == '__init__': | ||
continue | ||||
exts[name] = path | ||||
|
r33327 | for name, path in _disabledextensions.iteritems(): | ||
# If no path was provided for a disabled extension (e.g. "color=!"), | ||||
# don't replace the path we already found by the scan above. | ||||
if path: | ||||
exts[name] = path | ||||
|
r10363 | 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: | ||||
|
r38363 | with open(path, 'rb') as src: | ||
doc = _moduledoc(src) | ||||
|
r10363 | except IOError: | ||
return | ||||
if doc: # extracting localized synopsis | ||||
|
r30306 | return gettext(doc) | ||
|
r10363 | 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) | ||||
|
r21229 | except (ImportError, AttributeError): | ||
|
r14539 | pass | ||
|
r10363 | paths = _disabledpaths() | ||
if not paths: | ||||
|
r16709 | return {} | ||
|
r10363 | |||
exts = {} | ||||
for name, path in paths.iteritems(): | ||||
doc = _disabledhelp(path) | ||||
|
r14316 | if doc: | ||
|
r30306 | exts[name] = doc.splitlines()[0] | ||
|
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)) | ||||
|
r21229 | except (ImportError, AttributeError): | ||
|
r14539 | pass | ||
|
r10364 | paths = _disabledpaths() | ||
if name in paths: | ||||
return _disabledhelp(paths[name]) | ||||
|
r38180 | def _walkcommand(node): | ||
"""Scan @command() decorators in the tree starting at node""" | ||||
todo = collections.deque([node]) | ||||
while todo: | ||||
node = todo.popleft() | ||||
if not isinstance(node, ast.FunctionDef): | ||||
todo.extend(ast.iter_child_nodes(node)) | ||||
continue | ||||
for d in node.decorator_list: | ||||
if not isinstance(d, ast.Call): | ||||
continue | ||||
if not isinstance(d.func, ast.Name): | ||||
continue | ||||
if d.func.id != r'command': | ||||
continue | ||||
yield d | ||||
def _disabledcmdtable(path): | ||||
"""Construct a dummy command table without loading the extension module | ||||
This may raise IOError or SyntaxError. | ||||
""" | ||||
with open(path, 'rb') as src: | ||||
root = ast.parse(src.read(), path) | ||||
cmdtable = {} | ||||
for node in _walkcommand(root): | ||||
if not node.args: | ||||
continue | ||||
a = node.args[0] | ||||
if isinstance(a, ast.Str): | ||||
name = pycompat.sysbytes(a.s) | ||||
elif pycompat.ispy3 and isinstance(a, ast.Bytes): | ||||
name = a.s | ||||
else: | ||||
continue | ||||
cmdtable[name] = (None, [], b'') | ||||
return cmdtable | ||||
|
r37995 | def _finddisabledcmd(ui, cmd, name, path, strict): | ||
try: | ||||
|
r38180 | cmdtable = _disabledcmdtable(path) | ||
except (IOError, SyntaxError): | ||||
|
r37995 | return | ||
try: | ||||
|
r38180 | aliases, entry = cmdutil.findcmd(cmd, cmdtable, strict) | ||
|
r37995 | except (error.AmbiguousCommand, error.UnknownCommand): | ||
return | ||||
for c in aliases: | ||||
if c.startswith(cmd): | ||||
cmd = c | ||||
break | ||||
else: | ||||
cmd = aliases[0] | ||||
|
r38180 | doc = _disabledhelp(path) | ||
|
r37996 | return (cmd, name, doc) | ||
|
r37995 | |||
|
r13191 | def disabledcmd(ui, cmd, strict=False): | ||
|
r38180 | '''find cmd from disabled extensions without importing. | ||
|
r37996 | returns (cmdname, extname, doc)''' | ||
|
r10364 | |||
|
r38180 | paths = _disabledpaths() | ||
|
r10364 | if not paths: | ||
raise error.UnknownCommand(cmd) | ||||
|
r16667 | ext = None | ||
|
r10364 | # first, search for an extension with the same name as the command | ||
path = paths.pop(cmd, None) | ||||
if path: | ||||
|
r37995 | ext = _finddisabledcmd(ui, cmd, cmd, path, strict=strict) | ||
|
r16667 | if not ext: | ||
# otherwise, interrogate each extension until there's a match | ||||
for name, path in paths.iteritems(): | ||||
|
r37995 | ext = _finddisabledcmd(ui, cmd, name, path, strict=strict) | ||
|
r16667 | if ext: | ||
break | ||||
|
r37994 | if ext: | ||
|
r16667 | 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 | ||
|
r21848 | |||
|
r28155 | def notloaded(): | ||
'''return short names of extensions that failed to load''' | ||||
return [name for name, mod in _extensions.iteritems() if mod is None] | ||||
|
r21848 | def moduleversion(module): | ||
'''return version information from given module as a string''' | ||||
if (util.safehasattr(module, 'getversion') | ||||
and callable(module.getversion)): | ||||
version = module.getversion() | ||||
elif util.safehasattr(module, '__version__'): | ||||
version = module.__version__ | ||||
else: | ||||
version = '' | ||||
if isinstance(version, (list, tuple)): | ||||
|
r38040 | version = '.'.join(pycompat.bytestr(o) for o in version) | ||
|
r21848 | return version | ||
|
r27990 | |||
def ismoduleinternal(module): | ||||
exttestedwith = getattr(module, 'testedwith', None) | ||||
|
r29841 | return exttestedwith == "ships-with-hg-core" | ||