mercurial-scm/hg: comparison mercurial/extensions.py

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 _extensions = {}
 _disabledextensions = {}
 _aftercallbacks = {}
 _order = []
 _builtin = {
-'hbisect',
+b'hbisect',
-'bookmarks',
+b'bookmarks',
-'color',
+b'color',
-'parentrevspec',
+b'parentrevspec',
-'progress',
+b'progress',
-'interhg',
+b'interhg',
-'inotify',
+b'inotify',
-'hgcia',
+b'hgcia',
-'shelve',
+b'shelve',
 }
 def extensions(ui=None):
 if ui:
 def enabled(name):
-for format in ['%s', 'hgext.%s']:
+for format in [b'%s', b'hgext.%s']:
-conf = ui.config('extensions', format % name)
+conf = ui.config(b'extensions', format % name)
-if conf is not None and not conf.startswith('!'):
+if conf is not None and not conf.startswith(b'!'):
 return True
 else:
 enabled = lambda name: True
 for name in _order:
 mod = None
 try:
 mod = _extensions[name]
 except KeyError:
 for k, v in _extensions.iteritems():
-if k.endswith('.' + name) or k.endswith('/' + name):
+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('.', '_')
+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
 def _importh(name):
 """import and return the <name> module"""
 mod = __import__(pycompat.sysstr(name))
-components = name.split('.')
+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, 'hgext.%s' % name)
+mod = loadpath(path, b'hgext.%s' % name)
 else:
 try:
-mod = _importh("hgext.%s" % name)
+mod = _importh(b"hgext.%s" % name)
 except ImportError as err:
 if reportfunc:
-reportfunc(err, "hgext.%s" % name, "hgext3rd.%s" % name)
+reportfunc(err, b"hgext.%s" % name, b"hgext3rd.%s" % name)
 try:
-mod = _importh("hgext3rd.%s" % name)
+mod = _importh(b"hgext3rd.%s" % name)
 except ImportError as err:
 if reportfunc:
-reportfunc(err, "hgext3rd.%s" % name, name)
+reportfunc(err, b"hgext3rd.%s" % name, name)
 mod = _importh(name)
 return mod
 def _reportimporterror(ui, err, failed, next):
 b'    - could not import %s (%s): trying %s\n',
 failed,
 stringutil.forcebytestr(err),
 next,
 )
-if ui.debugflag and ui.configbool('devel', 'debug.extensions'):
+if ui.debugflag and ui.configbool(b'devel', b'debug.extensions'):
 ui.traceback()
 def _rejectunicode(name, xs):
 if isinstance(xs, (list, set, tuple)):
 _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="use b'' to make it byte string",
+hint=b"use b'' to make it byte string",
 )
 # attributes set by registrar.command
-_cmdfuncattrs = ('norepo', 'optionalrepo', 'inferrepo')
+_cmdfuncattrs = (b'norepo', b'optionalrepo', b'inferrepo')
 def _validatecmdtable(ui, cmdtable):
 """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),
+b'missing attributes: %s' % b', '.join(missing),
-hint="use @command decorator to register '%s'" % c,
+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 ['cmdtable', 'colortable', 'configtable']:
+for t in [b'cmdtable', b'colortable', b'configtable']:
 _rejectunicode(t, getattr(mod, t, {}))
 for t in [
-'filesetpredicate',
+b'filesetpredicate',
-'internalmerge',
+b'internalmerge',
-'revsetpredicate',
+b'revsetpredicate',
-'templatefilter',
+b'templatefilter',
-'templatefunc',
+b'templatefunc',
-'templatekeyword',
+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('hgext.') or name.startswith('hgext/'):
+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:
+with util.timedcm(b'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
 # 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):
 msg = _(
-'(third party extension %s requires version %s or newer '
+b'(third party extension %s requires version %s or newer '
-'of Mercurial (current: %s); disabling)\n'
+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:
+with util.timedcm(b'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
 try:
 uisetup(ui)
 except Exception as inst:
 ui.traceback(force=True)
 msg = stringutil.forcebytestr(inst)
-ui.warn(_("*** failed to set up extension %s: %s\n") % (name, msg))
+ui.warn(_(b"*** failed to set up extension %s: %s\n") % (name, msg))
 return False
 return True
 def _runextsetup(name, ui):
 try:
 extsetup(ui)
 except Exception as inst:
 ui.traceback(force=True)
 msg = stringutil.forcebytestr(inst)
-ui.warn(_("*** failed to set up extension %s: %s\n") % (name, msg))
+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("extensions")
+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',
-'additional ' if newindex else '',
+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:
+with util.timedcm(b'load all extensions') as stats:
 for (name, path) in result:
 if path:
-if path[0:1] == '!':
+if path[0:1] == b'!':
 if name not in _disabledextensions:
 ui.log(
 b'extension',
 b'  - skipping disabled extension: %s\n',
 name,
 load(ui, name, path, loadingtime)
 except Exception as inst:
 msg = stringutil.forcebytestr(inst)
 if path:
 ui.warn(
-_("*** failed to import extension %s from %s: %s\n")
+_(b"*** failed to import extension %s from %s: %s\n")
 % (name, path, msg)
 )
 else:
 ui.warn(
-_("*** failed to import extension %s: %s\n")
+_(b"*** failed to import extension %s: %s\n")
 % (name, msg)
 )
 if isinstance(inst, error.Hint) and inst.hint:
-ui.warn(_("*** (%s)\n") % inst.hint)
+ui.warn(_(b"*** (%s)\n") % inst.hint)
 ui.traceback()
 ui.log(
 b'extension',
 b'> loaded %d extensions, total time %s\n',
 # - 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'),
+(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:
+with util.timedcm(b'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:
+with util.timedcm(b'uisetup %s', name) as stats:
 if not _runuisetup(name, ui):
 ui.log(
 b'extension',
 b'    - the %s extension uisetup failed\n',
 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:
+with util.timedcm(b'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:
+with util.timedcm(b'extsetup %s', name) as stats:
 if not _runextsetup(name, ui):
 ui.log(
 b'extension',
 b'    - the %s extension extsetup failed\n',
 name,
 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:
+with util.timedcm(b'aftercallbacks') as stats:
 for shortname in _aftercallbacks:
 if shortname in _extensions:
 continue
 for fn in _aftercallbacks[shortname]:
 # - 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 = [
-('cmdtable', commands, 'loadcmdtable'),
+(b'cmdtable', commands, b'loadcmdtable'),
-('colortable', color, 'loadcolortable'),
+(b'colortable', color, b'loadcolortable'),
-('filesetpredicate', fileset, 'loadpredicate'),
+(b'filesetpredicate', fileset, b'loadpredicate'),
-('internalmerge', filemerge, 'loadinternalmerge'),
+(b'internalmerge', filemerge, b'loadinternalmerge'),
-('revsetpredicate', revset, 'loadpredicate'),
+(b'revsetpredicate', revset, b'loadpredicate'),
-('templatefilter', templatefilters, 'loadfilter'),
+(b'templatefilter', templatefilters, b'loadfilter'),
-('templatefunc', templatefuncs, 'loadfunction'),
+(b'templatefunc', templatefuncs, b'loadfunction'),
-('templatekeyword', templatekw, 'loadkeyword'),
+(b'templatekeyword', templatekw, b'loadkeyword'),
 ]
-with util.timedcm('load registration objects') as stats:
+with util.timedcm(b'load registration objects') as stats:
 _loadextra(ui, newindex, extraloaders)
 ui.log(
 b'extension',
 b'> extension registration object loading took %s\n',
 stats,
 try:
 hook(ui)
 except Exception as inst:
 ui.traceback(force=True)
 ui.warn(
-_('*** failed to populate ui by extension %s: %s\n')
+_(b'*** failed to populate ui by extension %s: %s\n')
 % (name, stringutil.forcebytestr(inst))
 )
 def bind(func, *args):
 except OSError:
 return {}
 exts = {}
 for e in files:
-if e.endswith('.py'):
+if e.endswith(b'.py'):
-name = e.rsplit('.', 1)[0]
+name = e.rsplit(b'.', 1)[0]
 path = os.path.join(extpath, e)
 else:
 name = e
-path = os.path.join(extpath, e, '__init__.py')
+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 == '__init__':
+if name in exts or name in _order or name == b'__init__':
 continue
 exts[name] = path
 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.
 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():
+while line[:1] == b'#' or not line.strip():
 line = file.readline()
 if not line:
 break
 start = line[:3]
-if start == '"""' or start == "'''":
+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)
 line = file.readline()
 else:
 return None
-return ''.join(result)
+return b''.join(result)
 def _disabledhelp(path):
 '''retrieve help synopsis of a disabled extension (without importing)'''
 try:
-with open(path, 'rb') as src:
+with open(path, b'rb') as src:
 doc = _moduledoc(src)
 except IOError:
 return
 if doc:  # extracting localized synopsis
 return gettext(doc)
 else:
-return _('(no help text available)')
+return _(b'(no help text available)')
 def disabled():
 '''find disabled extensions from hgext. returns a dict of {name: desc}'''
 try:
 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:
+with open(path, b'rb') as src:
 root = ast.parse(src.read(), path)
 cmdtable = {}
 for node in _walkcommand(root):
 if not node.args:
 continue
 def enabled(shortname=True):
 '''return a dict of {name: desc} of extensions'''
 exts = {}
 for ename, ext in extensions():
-doc = gettext(ext.__doc__) or _('(no help text available)')
+doc = gettext(ext.__doc__) or _(b'(no help text available)')
 if shortname:
-ename = ename.split('.')[-1]
+ename = ename.split(b'.')[-1]
 exts[ename] = doc.splitlines()[0].strip()
 return exts
 return [name for name, mod in _extensions.iteritems() if mod is None]
 def moduleversion(module):
 '''return version information from given module as a string'''
-if util.safehasattr(module, 'getversion') and callable(module.getversion):
+if util.safehasattr(module, b'getversion') and callable(module.getversion):
 version = module.getversion()
-elif util.safehasattr(module, '__version__'):
+elif util.safehasattr(module, b'__version__'):
 version = module.__version__
 else:
-version = ''
+version = b''
 if isinstance(version, (list, tuple)):
-version = '.'.join(pycompat.bytestr(o) for o in version)
+version = b'.'.join(pycompat.bytestr(o) for o in version)
 return version
 def ismoduleinternal(module):
 exttestedwith = getattr(module, 'testedwith', None)
-return exttestedwith == "ships-with-hg-core"
+return exttestedwith == b"ships-with-hg-core"

changeset 43077	687b865b95ad
parent 43076	2372284d9457
child 43085	eef9a2d67051