copies: iterate over children directly (instead of parents)
Before this change we would gather all parent → child edges and iterate on
all parent, gathering copy information for children and aggregating them from
there.
They are not strict requirement for edges to be processed in that specific
order. We could also simply iterate over all "children" revision and aggregate
data from both parents at the same time. This patch does that.
It make various things simpler:
* since both parents are processed at the same time, we no longer need to
cache data for merge (see next changeset for details),
* we no longer need nested loop to process data,
* we no longer need to store partial merge data for a rev from distinct loop
interaction to another when processing merges,
* we no longer need to build a full parent -> children mapping (we only rely on
a simpler "parent -> number of children" map (for memory efficiency),
* the data access pattern is now simpler (from lower revisions to higher
revisions) and entirely predicable. That predictability open the way to
prefetching and parallel processing.
So that new iterations order requires simpler code and open the way to
interesting optimisation.
The effect on performance is quite good. In the worse case, we don't see any
significant negative impact. And in the best case, the reduction of roundtrip
to Python provide us with a significant speed. Some example below:
Repo Case Source-Rev Dest-Rev # of revisions old time new time Difference Factor time per rev
---------------------------------------------------------------------------------------------------------------------------------------------------------------
mozilla-try x00000_revs_x00000_added_0_copies
dc8a3ca7010e d16fde900c9c : 34414 revs, 0.962867 s, 0.502584 s, -0.460283 s, × 0.5220, 14 µs/rev
mozilla-try x0000_revs_xx000_added_x_copies
156f6e2674f2 4d0f2c178e66 : 8598 revs, 0.110717 s, 0.076323 s, -0.034394 s, × 0.6894, 8 µs/rev
# full comparison between the previous changeset and this one
Repo Case Source-Rev Dest-Rev # of revisions old time new time Difference Factor time per rev
---------------------------------------------------------------------------------------------------------------------------------------------------------------
mercurial x_revs_x_added_0_copies
ad6b123de1c7 39cfcef4f463 : 1 revs, 0.000048 s, 0.000041 s, -0.000007 s, × 0.8542, 41 µs/rev
mercurial x_revs_x_added_x_copies
2b1c78674230 0c1d10351869 : 6 revs, 0.000153 s, 0.000102 s, -0.000051 s, × 0.6667, 17 µs/rev
mercurial x000_revs_x000_added_x_copies
81f8ff2a9bf2 dd3267698d84 : 1032 revs, 0.004209 s, 0.004254 s, +0.000045 s, × 1.0107, 4 µs/rev
pypy x_revs_x_added_0_copies
aed021ee8ae8 099ed31b181b : 9 revs, 0.000203 s, 0.000282 s, +0.000079 s, × 1.3892, 31 µs/rev
pypy x_revs_x000_added_0_copies
4aa4e1f8e19a 359343b9ac0e : 1 revs, 0.000059 s, 0.000048 s, -0.000011 s, × 0.8136, 48 µs/rev
pypy x_revs_x_added_x_copies
ac52eb7bbbb0 72e022663155 : 7 revs, 0.000194 s, 0.000211 s, +0.000017 s, × 1.0876, 30 µs/rev
pypy x_revs_x00_added_x_copies
c3b14617fbd7 ace7255d9a26 : 1 revs, 0.000380 s, 0.000375 s, -0.000005 s, × 0.9868, 375 µs/rev
pypy x_revs_x000_added_x000_copies
df6f7a526b60 a83dc6a2d56f : 6 revs, 0.010588 s, 0.010574 s, -0.000014 s, × 0.9987, 1762 µs/rev
pypy x000_revs_xx00_added_0_copies
89a76aede314 2f22446ff07e : 4785 revs, 0.048961 s, 0.049974 s, +0.001013 s, × 1.0207, 10 µs/rev
pypy x000_revs_x000_added_x_copies
8a3b5bfd266e 2c68e87c3efe : 6780 revs, 0.083612 s, 0.084300 s, +0.000688 s, × 1.0082, 12 µs/rev
pypy x000_revs_x000_added_x000_copies
89a76aede314 7b3dda341c84 : 5441 revs, 0.058579 s, 0.060128 s, +0.001549 s, × 1.0264, 11 µs/rev
pypy x0000_revs_x_added_0_copies
d1defd0dc478 c9cb1334cc78 : 43645 revs, 0.736783 s, 0.686542 s, -0.050241 s, × 0.9318, 15 µs/rev
pypy x0000_revs_xx000_added_0_copies
bf2c629d0071 4ffed77c095c : 2 revs, 0.022050 s, 0.009277 s, -0.012773 s, × 0.4207, 4638 µs/rev
pypy x0000_revs_xx000_added_x000_copies
08ea3258278e d9fa043f30c0 : 11316 revs, 0.120800 s, 0.114733 s, -0.006067 s, × 0.9498, 10 µs/rev
netbeans x_revs_x_added_0_copies
fb0955ffcbcd a01e9239f9e7 : 2 revs, 0.000140 s, 0.000081 s, -0.000059 s, × 0.5786, 40 µs/rev
netbeans x_revs_x000_added_0_copies
6f360122949f 20eb231cc7d0 : 2 revs, 0.000114 s, 0.000107 s, -0.000007 s, × 0.9386, 53 µs/rev
netbeans x_revs_x_added_x_copies
1ada3faf6fb6 5a39d12eecf4 : 3 revs, 0.000224 s, 0.000173 s, -0.000051 s, × 0.7723, 57 µs/rev
netbeans x_revs_x00_added_x_copies
35be93ba1e2c 9eec5e90c05f : 9 revs, 0.000723 s, 0.000698 s, -0.000025 s, × 0.9654, 77 µs/rev
netbeans x000_revs_xx00_added_0_copies
eac3045b4fdd 51d4ae7f1290 : 1421 revs, 0.009665 s, 0.009248 s, -0.000417 s, × 0.9569, 6 µs/rev
netbeans x000_revs_x000_added_x_copies
e2063d266acd 6081d72689dc : 1533 revs, 0.014820 s, 0.015446 s, +0.000626 s, × 1.0422, 10 µs/rev
netbeans x000_revs_x000_added_x000_copies
ff453e9fee32 411350406ec2 : 5750 revs, 0.076049 s, 0.074373 s, -0.001676 s, × 0.9780, 12 µs/rev
netbeans x0000_revs_xx000_added_x000_copies
588c2d1ced70 1aad62e59ddd : 66949 revs, 0.683603 s, 0.639870 s, -0.043733 s, × 0.9360, 9 µs/rev
mozilla-central x_revs_x_added_0_copies
3697f962bb7b 7015fcdd43a2 : 2 revs, 0.000161 s, 0.000088 s, -0.000073 s, × 0.5466, 44 µs/rev
mozilla-central x_revs_x000_added_0_copies
dd390860c6c9 40d0c5bed75d : 8 revs, 0.000234 s, 0.000199 s, -0.000035 s, × 0.8504, 24 µs/rev
mozilla-central x_revs_x_added_x_copies
8d198483ae3b 14207ffc2b2f : 9 revs, 0.000247 s, 0.000171 s, -0.000076 s, × 0.6923, 19 µs/rev
mozilla-central x_revs_x00_added_x_copies
98cbc58cc6bc 446a150332c3 : 7 revs, 0.000630 s, 0.000592 s, -0.000038 s, × 0.9397, 84 µs/rev
mozilla-central x_revs_x000_added_x000_copies
3c684b4b8f68 0a5e72d1b479 : 3 revs, 0.003286 s, 0.003151 s, -0.000135 s, × 0.9589, 1050 µs/rev
mozilla-central x_revs_x0000_added_x0000_copies
effb563bb7e5 c07a39dc4e80 : 6 revs, 0.062441 s, 0.061612 s, -0.000829 s, × 0.9867, 10268 µs/rev
mozilla-central x000_revs_xx00_added_0_copies
6100d773079a 04a55431795e : 1593 revs, 0.005423 s, 0.005381 s, -0.000042 s, × 0.9923, 3 µs/rev
mozilla-central x000_revs_x000_added_x_copies
9f17a6fc04f9 2d37b966abed : 41 revs, 0.005919 s, 0.003742 s, -0.002177 s, × 0.6322, 91 µs/rev
mozilla-central x000_revs_x000_added_x000_copies
7c97034feb78 4407bd0c6330 : 7839 revs, 0.062597 s, 0.061983 s, -0.000614 s, × 0.9902, 7 µs/rev
mozilla-central x0000_revs_xx000_added_0_copies
9eec5917337d 67118cc6dcad : 615 revs, 0.043551 s, 0.019861 s, -0.023690 s, × 0.4560, 32 µs/rev
mozilla-central x0000_revs_xx000_added_x000_copies
f78c615a656c 96a38b690156 : 30263 revs, 0.192475 s, 0.188101 s, -0.004374 s, × 0.9773, 6 µs/rev
mozilla-central x00000_revs_x0000_added_x0000_copies
6832ae71433c 4c222a1d9a00 : 153721 revs, 1.955575 s, 1.806696 s, -0.148879 s, × 0.9239, 11 µs/rev
mozilla-central x00000_revs_x00000_added_x000_copies
76caed42cf7c 1daa622bbe42 : 204976 revs, 2.886501 s, 2.682987 s, -0.203514 s, × 0.9295, 13 µs/rev
mozilla-try x_revs_x_added_0_copies
aaf6dde0deb8 9790f499805a : 2 revs, 0.001181 s, 0.000852 s, -0.000329 s, × 0.7214, 426 µs/rev
mozilla-try x_revs_x000_added_0_copies
d8d0222927b4 5bb8ce8c7450 : 2 revs, 0.001189 s, 0.000859 s, -0.000330 s, × 0.7225, 429 µs/rev
mozilla-try x_revs_x_added_x_copies
092fcca11bdb 936255a0384a : 4 revs, 0.000563 s, 0.000150 s, -0.000413 s, × 0.2664, 37 µs/rev
mozilla-try x_revs_x00_added_x_copies
b53d2fadbdb5 017afae788ec : 2 revs, 0.001548 s, 0.001158 s, -0.000390 s, × 0.7481, 579 µs/rev
mozilla-try x_revs_x000_added_x000_copies
20408ad61ce5 6f0ee96e21ad : 1 revs, 0.027782 s, 0.027240 s, -0.000542 s, × 0.9805, 27240 µs/rev
mozilla-try x_revs_x0000_added_x0000_copies
effb563bb7e5 c07a39dc4e80 : 6 revs, 0.062781 s, 0.062824 s, +0.000043 s, × 1.0007, 10470 µs/rev
mozilla-try x000_revs_xx00_added_0_copies
6100d773079a 04a55431795e : 1593 revs, 0.005778 s, 0.005463 s, -0.000315 s, × 0.9455, 3 µs/rev
mozilla-try x000_revs_x000_added_x_copies
9f17a6fc04f9 2d37b966abed : 41 revs, 0.006192 s, 0.004238 s, -0.001954 s, × 0.6844, 103 µs/rev
mozilla-try x000_revs_x000_added_x000_copies
1346fd0130e4 4c65cbdabc1f : 6657 revs, 0.065391 s, 0.064113 s, -0.001278 s, × 0.9805, 9 µs/rev
mozilla-try x0000_revs_x_added_0_copies
63519bfd42ee a36a2a865d92 : 40314 revs, 0.317216 s, 0.294063 s, -0.023153 s, × 0.9270, 7 µs/rev
mozilla-try x0000_revs_x_added_x_copies
9fe69ff0762d bcabf2a78927 : 38690 revs, 0.303119 s, 0.281493 s, -0.021626 s, × 0.9287, 7 µs/rev
mozilla-try x0000_revs_xx000_added_x_copies
156f6e2674f2 4d0f2c178e66 : 8598 revs, 0.110717 s, 0.076323 s, -0.034394 s, × 0.6894, 8 µs/rev
mozilla-try x0000_revs_xx000_added_0_copies
9eec5917337d 67118cc6dcad : 615 revs, 0.045739 s, 0.020390 s, -0.025349 s, × 0.4458, 33 µs/rev
mozilla-try x0000_revs_xx000_added_x000_copies
89294cd501d9 7ccb2fc7ccb5 : 97052 revs, 3.098021 s, 3.023879 s, -0.074142 s, × 0.9761, 31 µs/rev
mozilla-try x0000_revs_x0000_added_x0000_copies
e928c65095ed e951f4ad123a : 52031 revs, 0.771480 s, 0.735549 s, -0.035931 s, × 0.9534, 14 µs/rev
mozilla-try x00000_revs_x_added_0_copies
6a320851d377 1ebb79acd503 : 363753 revs, 18.813422 s, 18.568900 s, -0.244522 s, × 0.9870, 51 µs/rev
mozilla-try x00000_revs_x00000_added_0_copies
dc8a3ca7010e d16fde900c9c : 34414 revs, 0.962867 s, 0.502584 s, -0.460283 s, × 0.5220, 14 µs/rev
mozilla-try x00000_revs_x_added_x_copies
5173c4b6f97c 95d83ee7242d : 362229 revs, 18.684923 s, 18.356645 s, -0.328278 s, × 0.9824, 50 µs/rev
mozilla-try x00000_revs_x000_added_x_copies
9126823d0e9c ca82787bb23c : 359344 revs, 18.296305 s, 18.250393 s, -0.045912 s, × 0.9975, 50 µs/rev
mozilla-try x00000_revs_x0000_added_x0000_copies
8d3fafa80d4b eb884023b810 : 192665 revs, 3.061887 s, 2.792459 s, -0.269428 s, × 0.9120, 14 µs/rev
mozilla-try x00000_revs_x00000_added_x0000_copies
1b661134e2ca 1ae03d022d6d : 228985 revs, 103.869641 s, 107.697264 s, +3.827623 s, × 1.0369, 470 µs/rev
mozilla-try x00000_revs_x00000_added_x000_copies
9b2a99adc05e 8e29777b48e6 : 382065 revs, 64.262957 s, 63.961040 s, -0.301917 s, × 0.9953, 167 µs/rev
Differential Revision: https://phab.mercurial-scm.org/D9422
# extensions.py - extension handling for mercurial
#
# Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.
from __future__ import absolute_import
import ast
import collections
import functools
import imp
import inspect
import os
from .i18n import (
_,
gettext,
)
from .pycompat import (
getattr,
open,
setattr,
)
from . import (
cmdutil,
configitems,
error,
pycompat,
util,
)
from .utils import stringutil
_extensions = {}
_disabledextensions = {}
_aftercallbacks = {}
_order = []
_builtin = {
b'hbisect',
b'bookmarks',
b'color',
b'parentrevspec',
b'progress',
b'interhg',
b'inotify',
b'hgcia',
b'shelve',
}
def extensions(ui=None):
if ui:
def enabled(name):
for format in [b'%s', b'hgext.%s']:
conf = ui.config(b'extensions', format % name)
if conf is not None and not conf.startswith(b'!'):
return True
else:
enabled = lambda name: True
for name in _order:
module = _extensions[name]
if module and enabled(name):
yield name, module
def find(name):
'''return module with given extension name'''
mod = None
try:
mod = _extensions[name]
except KeyError:
for k, v in pycompat.iteritems(_extensions):
if k.endswith(b'.' + name) or k.endswith(b'/' + name):
mod = v
break
if not mod:
raise KeyError(name)
return mod
def loadpath(path, module_name):
module_name = module_name.replace(b'.', b'_')
path = util.normpath(util.expandpath(path))
module_name = pycompat.fsdecode(module_name)
path = pycompat.fsdecode(path)
if os.path.isdir(path):
# module/__init__.py style
d, f = os.path.split(path)
fd, fpath, desc = imp.find_module(f, [d])
# When https://github.com/python/typeshed/issues/3466 is fixed
# and in a pytype release we can drop this disable.
return imp.load_module(
module_name, fd, fpath, desc # pytype: disable=wrong-arg-types
)
else:
try:
return imp.load_source(module_name, path)
except IOError as exc:
if not exc.filename:
exc.filename = path # python does not fill this
raise
def _importh(name):
"""import and return the <name> module"""
mod = __import__(pycompat.sysstr(name))
components = name.split(b'.')
for comp in components[1:]:
mod = getattr(mod, comp)
return mod
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, b'hgext.%s' % name)
else:
try:
mod = _importh(b"hgext.%s" % name)
except ImportError as err:
if reportfunc:
reportfunc(err, b"hgext.%s" % name, b"hgext3rd.%s" % name)
try:
mod = _importh(b"hgext3rd.%s" % name)
except ImportError as err:
if reportfunc:
reportfunc(err, b"hgext3rd.%s" % name, name)
mod = _importh(name)
return mod
def _reportimporterror(ui, err, failed, next):
# note: this ui.log happens before --debug is processed,
# Use --config ui.debug=1 to see them.
ui.log(
b'extension',
b' - could not import %s (%s): trying %s\n',
failed,
stringutil.forcebytestr(err),
next,
)
if ui.debugflag and ui.configbool(b'devel', b'debug.extensions'):
ui.traceback()
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)
_rejectunicode(b'%s.%s' % (name, stringutil.forcebytestr(k)), v)
elif isinstance(xs, type(u'')):
raise error.ProgrammingError(
b"unicode %r found in %s" % (xs, name),
hint=b"use b'' to make it byte string",
)
# attributes set by registrar.command
_cmdfuncattrs = (b'norepo', b'optionalrepo', b'inferrepo')
def _validatecmdtable(ui, cmdtable):
"""Check if extension commands have required attributes"""
for c, e in pycompat.iteritems(cmdtable):
f = e[0]
missing = [a for a in _cmdfuncattrs if not util.safehasattr(f, a)]
if not missing:
continue
raise error.ProgrammingError(
b'missing attributes: %s' % b', '.join(missing),
hint=b"use @command decorator to register '%s'" % c,
)
def _validatetables(ui, mod):
"""Sanity check for loadable tables provided by extension module"""
for t in [b'cmdtable', b'colortable', b'configtable']:
_rejectunicode(t, getattr(mod, t, {}))
for t in [
b'filesetpredicate',
b'internalmerge',
b'revsetpredicate',
b'templatefilter',
b'templatefunc',
b'templatekeyword',
]:
o = getattr(mod, t, None)
if o:
_rejectunicode(t, o._table)
_validatecmdtable(ui, getattr(mod, 'cmdtable', {}))
def load(ui, name, path, loadingtime=None):
if name.startswith(b'hgext.') or name.startswith(b'hgext/'):
shortname = name[6:]
else:
shortname = name
if shortname in _builtin:
return None
if shortname in _extensions:
return _extensions[shortname]
ui.log(b'extension', b' - loading extension: %s\n', shortname)
_extensions[shortname] = None
with util.timedcm('load extension %s', shortname) as stats:
mod = _importext(name, path, bind(_reportimporterror, ui))
ui.log(b'extension', b' > %s extension loaded in %s\n', shortname, stats)
if loadingtime is not None:
loadingtime[shortname] += stats.elapsed
# 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:
curver = util.versiontuple(n=2)
if None in curver or util.versiontuple(minver, 2) > curver:
msg = _(
b'(third party extension %s requires version %s or newer '
b'of Mercurial (current: %s); disabling)\n'
)
ui.warn(msg % (shortname, minver, util.version()))
return
ui.log(b'extension', b' - validating extension tables: %s\n', shortname)
_validatetables(ui, mod)
_extensions[shortname] = mod
_order.append(shortname)
ui.log(
b'extension', b' - invoking registered callbacks: %s\n', shortname
)
with util.timedcm('callbacks extension %s', shortname) as stats:
for fn in _aftercallbacks.get(shortname, []):
fn(loaded=True)
ui.log(b'extension', b' > callbacks completed in %s\n', stats)
return mod
def _runuisetup(name, ui):
uisetup = getattr(_extensions[name], 'uisetup', None)
if uisetup:
try:
uisetup(ui)
except Exception as inst:
ui.traceback(force=True)
msg = stringutil.forcebytestr(inst)
ui.warn(_(b"*** failed to set up extension %s: %s\n") % (name, msg))
return False
return True
def _runextsetup(name, ui):
extsetup = getattr(_extensions[name], 'extsetup', None)
if extsetup:
try:
extsetup(ui)
except Exception as inst:
ui.traceback(force=True)
msg = stringutil.forcebytestr(inst)
ui.warn(_(b"*** failed to set up extension %s: %s\n") % (name, msg))
return False
return True
def loadall(ui, whitelist=None):
loadingtime = collections.defaultdict(int)
result = ui.configitems(b"extensions")
if whitelist is not None:
result = [(k, v) for (k, v) in result if k in whitelist]
newindex = len(_order)
ui.log(
b'extension',
b'loading %sextensions\n',
b'additional ' if newindex else b'',
)
ui.log(b'extension', b'- processing %d entries\n', len(result))
with util.timedcm('load all extensions') as stats:
for (name, path) in result:
if path:
if path[0:1] == b'!':
if name not in _disabledextensions:
ui.log(
b'extension',
b' - skipping disabled extension: %s\n',
name,
)
_disabledextensions[name] = path[1:]
continue
try:
load(ui, name, path, loadingtime)
except Exception as inst:
msg = stringutil.forcebytestr(inst)
if path:
ui.warn(
_(b"*** failed to import extension %s from %s: %s\n")
% (name, path, msg)
)
else:
ui.warn(
_(b"*** failed to import extension %s: %s\n")
% (name, msg)
)
if isinstance(inst, error.Hint) and inst.hint:
ui.warn(_(b"*** (%s)\n") % inst.hint)
ui.traceback()
ui.log(
b'extension',
b'> loaded %d extensions, total time %s\n',
len(_order) - newindex,
stats,
)
# 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 = [
(b'configtable', configitems, b'loadconfigtable'),
]
ui.log(b'extension', b'- loading configtable attributes\n')
_loadextra(ui, newindex, earlyextraloaders)
broken = set()
ui.log(b'extension', b'- executing uisetup hooks\n')
with util.timedcm('all uisetup') as alluisetupstats:
for name in _order[newindex:]:
ui.log(b'extension', b' - running uisetup for %s\n', name)
with util.timedcm('uisetup %s', name) as stats:
if not _runuisetup(name, ui):
ui.log(
b'extension',
b' - the %s extension uisetup failed\n',
name,
)
broken.add(name)
ui.log(b'extension', b' > uisetup for %s took %s\n', name, stats)
loadingtime[name] += stats.elapsed
ui.log(b'extension', b'> all uisetup took %s\n', alluisetupstats)
ui.log(b'extension', b'- executing extsetup hooks\n')
with util.timedcm('all extsetup') as allextetupstats:
for name in _order[newindex:]:
if name in broken:
continue
ui.log(b'extension', b' - running extsetup for %s\n', name)
with util.timedcm('extsetup %s', name) as stats:
if not _runextsetup(name, ui):
ui.log(
b'extension',
b' - the %s extension extsetup failed\n',
name,
)
broken.add(name)
ui.log(b'extension', b' > extsetup for %s took %s\n', name, stats)
loadingtime[name] += stats.elapsed
ui.log(b'extension', b'> all extsetup took %s\n', allextetupstats)
for name in broken:
ui.log(b'extension', b' - disabling broken %s extension\n', name)
_extensions[name] = None
# Call aftercallbacks that were never met.
ui.log(b'extension', b'- executing remaining aftercallbacks\n')
with util.timedcm('aftercallbacks') as stats:
for shortname in _aftercallbacks:
if shortname in _extensions:
continue
for fn in _aftercallbacks[shortname]:
ui.log(
b'extension',
b' - extension %s not loaded, notify callbacks\n',
shortname,
)
fn(loaded=False)
ui.log(b'extension', b'> remaining aftercallbacks completed in %s\n', stats)
# loadall() is called multiple times and lingering _aftercallbacks
# entries could result in double execution. See issue4646.
_aftercallbacks.clear()
# delay importing avoids cyclic dependency (especially commands)
from . import (
color,
commands,
filemerge,
fileset,
revset,
templatefilters,
templatefuncs,
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
ui.log(b'extension', b'- loading extension registration objects\n')
extraloaders = [
(b'cmdtable', commands, b'loadcmdtable'),
(b'colortable', color, b'loadcolortable'),
(b'filesetpredicate', fileset, b'loadpredicate'),
(b'internalmerge', filemerge, b'loadinternalmerge'),
(b'revsetpredicate', revset, b'loadpredicate'),
(b'templatefilter', templatefilters, b'loadfilter'),
(b'templatefunc', templatefuncs, b'loadfunction'),
(b'templatekeyword', templatekw, b'loadkeyword'),
]
with util.timedcm('load registration objects') as stats:
_loadextra(ui, newindex, extraloaders)
ui.log(
b'extension',
b'> extension registration object loading took %s\n',
stats,
)
# Report per extension loading time (except reposetup)
for name in sorted(loadingtime):
ui.log(
b'extension',
b'> extension %s take a total of %s to load\n',
name,
util.timecount(loadingtime[name]),
)
ui.log(b'extension', b'extension loading complete\n')
def _loadextra(ui, newindex, extraloaders):
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)
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:
# Report loaded as False if the extension is disabled
loaded = _extensions[extension] is not None
callback(loaded=loaded)
else:
_aftercallbacks.setdefault(extension, []).append(callback)
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(
_(b'*** failed to populate ui by extension %s: %s\n')
% (name, stringutil.forcebytestr(inst))
)
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
def _updatewrapper(wrap, origfn, unboundwrapper):
'''Copy and add some useful attributes to wrapper'''
try:
wrap.__name__ = origfn.__name__
except AttributeError:
pass
wrap.__module__ = getattr(origfn, '__module__')
wrap.__doc__ = getattr(origfn, '__doc__')
wrap.__dict__.update(getattr(origfn, '__dict__', {}))
wrap._origfunc = origfn
wrap._unboundwrapper = unboundwrapper
def wrapcommand(table, command, wrapper, synopsis=None, docstring=None):
'''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.
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
known to the repository; ``--remote`` will also suppress the output of the
local bookmarks.
"""
extensions.wrapcommand(commands.table, 'bookmarks', exbookmarks,
synopsis, docstring)
'''
assert callable(wrapper)
aliases, entry = cmdutil.findcmd(command, table)
for alias, e in pycompat.iteritems(table):
if e is entry:
key = alias
break
origfn = entry[0]
wrap = functools.partial(
util.checksignature(wrapper), util.checksignature(origfn)
)
_updatewrapper(wrap, origfn, wrapper)
if docstring is not None:
wrap.__doc__ += docstring
newentry = list(entry)
newentry[0] = wrap
if synopsis is not None:
newentry[2] += synopsis
table[key] = tuple(newentry)
return entry
def wrapfilecache(cls, propname, wrapper):
"""Wraps a filecache property.
These can't be wrapped using the normal wrapfunction.
"""
propname = pycompat.sysstr(propname)
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:
raise AttributeError("type '%s' has no property '%s'" % (cls, propname))
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)
def wrapfunction(container, funcname, wrapper):
"""Wrap the function named funcname in container
Replace the funcname member in the given container with the specified
wrapper. The container is typically a module, class, or instance.
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.
"""
assert callable(wrapper)
origfn = getattr(container, funcname)
assert callable(origfn)
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)
_updatewrapper(wrap, origfn, wrapper)
setattr(container, funcname, wrap)
return origfn
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
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
def _disabledpaths():
'''find paths of disabled extensions. returns a dict of {name: path}'''
import hgext
# The hgext might not have a __file__ attribute (e.g. in PyOxidizer) and
# it might not be on a filesystem even if it does.
if util.safehasattr(hgext, '__file__'):
extpath = os.path.dirname(
os.path.abspath(pycompat.fsencode(hgext.__file__))
)
try:
files = os.listdir(extpath)
except OSError:
return {}
else:
return {}
exts = {}
for e in files:
if e.endswith(b'.py'):
name = e.rsplit(b'.', 1)[0]
path = os.path.join(extpath, e)
else:
name = e
path = os.path.join(extpath, e, b'__init__.py')
if not os.path.exists(path):
continue
if name in exts or name in _order or name == b'__init__':
continue
exts[name] = path
for name, path in pycompat.iteritems(_disabledextensions):
# 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
return exts
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] == b'#' or not line.strip():
line = file.readline()
if not line:
break
start = line[:3]
if start == b'"""' or start == b"'''":
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 b''.join(result)
def _disabledhelp(path):
'''retrieve help synopsis of a disabled extension (without importing)'''
try:
with open(path, b'rb') as src:
doc = _moduledoc(src)
except IOError:
return
if doc: # extracting localized synopsis
return gettext(doc)
else:
return _(b'(no help text available)')
def disabled():
'''find disabled extensions from hgext. returns a dict of {name: desc}'''
try:
from hgext import __index__ # pytype: disable=import-error
return {
name: gettext(desc)
for name, desc in pycompat.iteritems(__index__.docs)
if name not in _order
}
except (ImportError, AttributeError):
pass
paths = _disabledpaths()
if not paths:
return {}
exts = {}
for name, path in pycompat.iteritems(paths):
doc = _disabledhelp(path)
if doc and name != b'__index__':
exts[name] = doc.splitlines()[0]
return exts
def disabled_help(name):
"""Obtain the full help text for a disabled extension, or None."""
paths = _disabledpaths()
if name in paths:
return _disabledhelp(paths[name])
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 != '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, b'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
def _finddisabledcmd(ui, cmd, name, path, strict):
try:
cmdtable = _disabledcmdtable(path)
except (IOError, SyntaxError):
return
try:
aliases, entry = cmdutil.findcmd(cmd, cmdtable, strict)
except (error.AmbiguousCommand, error.UnknownCommand):
return
for c in aliases:
if c.startswith(cmd):
cmd = c
break
else:
cmd = aliases[0]
doc = _disabledhelp(path)
return (cmd, name, doc)
def disabledcmd(ui, cmd, strict=False):
"""find cmd from disabled extensions without importing.
returns (cmdname, extname, doc)"""
paths = _disabledpaths()
if not paths:
raise error.UnknownCommand(cmd)
ext = None
# first, search for an extension with the same name as the command
path = paths.pop(cmd, None)
if path:
ext = _finddisabledcmd(ui, cmd, cmd, path, strict=strict)
if not ext:
# otherwise, interrogate each extension until there's a match
for name, path in pycompat.iteritems(paths):
ext = _finddisabledcmd(ui, cmd, name, path, strict=strict)
if ext:
break
if ext:
return ext
raise error.UnknownCommand(cmd)
def enabled(shortname=True):
'''return a dict of {name: desc} of extensions'''
exts = {}
for ename, ext in extensions():
doc = gettext(ext.__doc__) or _(b'(no help text available)')
if shortname:
ename = ename.split(b'.')[-1]
exts[ename] = doc.splitlines()[0].strip()
return exts
def notloaded():
'''return short names of extensions that failed to load'''
return [
name for name, mod in pycompat.iteritems(_extensions) if mod is None
]
def moduleversion(module):
'''return version information from given module as a string'''
if util.safehasattr(module, b'getversion') and callable(module.getversion):
version = module.getversion()
elif util.safehasattr(module, b'__version__'):
version = module.__version__
else:
version = b''
if isinstance(version, (list, tuple)):
version = b'.'.join(pycompat.bytestr(o) for o in version)
else:
# version data should be bytes, but not all extensions are ported
# to py3.
version = stringutil.forcebytestr(version)
return version
def ismoduleinternal(module):
exttestedwith = getattr(module, 'testedwith', None)
return exttestedwith == b"ships-with-hg-core"