# 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 functools

import imp

import inspect

import os

from .i18n import (

    _,

    gettext,

)

from . import (

    cmdutil,

    configitems,

    error,

    pycompat,

    util,

)

_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.debug happens before --debug is processed,

    #       Use --config ui.debug=1 to see them.

    ui.debug('could not import %s (%s): trying %s\n'

             % (failed, util.forcebytestr(err), next))

    if ui.debugflag:

        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, util.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]

        if getattr(f, '_deprecatedregistrar', False):

            ui.deprecwarn("cmdutil.command is deprecated, use "

                          "registrar.command to register '%s'" % c, '4.6')

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

    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]

    _extensions[shortname] = None

    mod = _importext(name, path, bind(_reportimporterror, ui))

    # 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):

        ui.warn(_('(third party extension %s requires version %s or newer '

                  'of Mercurial; disabling)\n') % (shortname, minver))

        return

    _validatetables(ui, mod)

    _extensions[shortname] = mod

    _order.append(shortname)

    for fn in _aftercallbacks.get(shortname, []):

        fn(loaded=True)

    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 = util.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

                extsetup() # old extsetup with no ui argument

        except Exception as inst:

            ui.traceback(force=True)

            msg = util.forcebytestr(inst)

            ui.warn(_("*** failed to set up extension %s: %s\n") % (name, msg))

            return False

    return True

def loadall(ui, whitelist=None):

    result = ui.configitems("extensions")

    if whitelist is not None:

        result = [(k, v) for (k, v) in result if k in whitelist]

    newindex = len(_order)

    for (name, path) in result:

        if path:

            if path[0:1] == '!':

                _disabledextensions[name] = path[1:]

                continue

        try:

            load(ui, name, path)

        except Exception as inst:

            msg = util.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()

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

    ]

    _loadextra(ui, newindex, earlyextraloaders)

    broken = set()

    for name in _order[newindex:]:

        if not _runuisetup(name, ui):

            broken.add(name)

    for name in _order[newindex:]:

        if name in broken:

            continue

        if not _runextsetup(name, ui):

            broken.add(name)

    for name in broken:

        _extensions[name] = None

    # Call aftercallbacks that were never met.

    for shortname in _aftercallbacks:

        if shortname in _extensions:

            continue

        for fn in _aftercallbacks[shortname]:

            fn(loaded=False)

    # 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,

        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

    extraloaders = [

        ('cmdtable', commands, 'loadcmdtable'),

        ('colortable', color, 'loadcolortable'),

        ('filesetpredicate', fileset, 'loadpredicate'),

        ('internalmerge', filemerge, 'loadinternalmerge'),

        ('revsetpredicate', revset, 'loadpredicate'),

        ('templatefilter', templatefilters, 'loadfilter'),

        ('templatekeyword', templatekw, 'loadkeyword'),

    ]

    _loadextra(ui, newindex, extraloaders)

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 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.