# 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 . import (

    cmdutil,

    configitems,

    error,

    pycompat,

    util,

)

from .utils import (

    stringutil,

)

_extensions = {}

_disabledextensions = {}

_aftercallbacks = {}

_order = []

_builtin = {

    'hbisect',

    'bookmarks',

    'color',

    'parentrevspec',

    'progress',

    'interhg',

    'inotify',

    'hgcia'

}

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

    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 _extensions.iteritems():

            if k.endswith('.' + name) or k.endswith('/' + name):

                mod = v

                break

    if not mod:

        raise KeyError(name)

    return mod

def loadpath(path, module_name):

    module_name = module_name.replace('.', '_')

    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])

        return imp.load_module(module_name, fd, fpath, desc)

    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('.')

    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)

    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

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('devel', '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="use b'' to make it byte string")

# attributes set by registrar.command

_cmdfuncattrs = ('norepo', 'optionalrepo', '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),

            hint="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']:

        _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', {}))

def load(ui, name, path, loadingtime=None):

    if name.startswith('hgext.') or name.startswith('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 and util.versiontuple(minver, 2) > util.versiontuple(n=2):

        msg = _('(third party extension %s requires version %s or newer '

                '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(_("*** 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:

            try:

                extsetup(ui)

            except TypeError:

                if pycompat.getargspec(extsetup).args:

                    raise

                ui.deprecwarn("extsetup for '%s' must take a ui argument"

                              % name, "4.9")

                extsetup() # old extsetup with no ui argument

        except Exception as inst:

            ui.traceback(force=True)

            msg = stringutil.forcebytestr(inst)

            ui.warn(_("*** 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")

    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 '')

    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] == '!':

                    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(_("*** 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()

    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 = [

        ('configtable', configitems, '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 = [