# dispatch.py - command dispatching 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, print_function

import atexit

import difflib

import errno

import getopt

import os

import pdb

import re

import signal

import sys

import time

import traceback

from .i18n import _

from . import (

    cmdutil,

    color,

    commands,

    debugcommands,

    demandimport,

    encoding,

    error,

    extensions,

    fancyopts,

    fileset,

    help,

    hg,

    hook,

    profiling,

    pycompat,

    revset,

    scmutil,

    templatefilters,

    templatekw,

    templater,

    ui as uimod,

    util,

)

class request(object):

    def __init__(self, args, ui=None, repo=None, fin=None, fout=None,

                 ferr=None):

        self.args = args

        self.ui = ui

        self.repo = repo

        # input/output/error streams

        self.fin = fin

        self.fout = fout

        self.ferr = ferr

def run():

    "run the command in sys.argv"

    sys.exit((dispatch(request(pycompat.sysargv[1:])) or 0) & 255)

def _getsimilar(symbols, value):

    sim = lambda x: difflib.SequenceMatcher(None, value, x).ratio()

    # The cutoff for similarity here is pretty arbitrary. It should

    # probably be investigated and tweaked.

    return [s for s in symbols if sim(s) > 0.6]

def _reportsimilar(write, similar):

    if len(similar) == 1:

        write(_("(did you mean %s?)\n") % similar[0])

    elif similar:

        ss = ", ".join(sorted(similar))

        write(_("(did you mean one of %s?)\n") % ss)

def _formatparse(write, inst):

    similar = []

    if isinstance(inst, error.UnknownIdentifier):

        # make sure to check fileset first, as revset can invoke fileset

        similar = _getsimilar(inst.symbols, inst.function)

    if len(inst.args) > 1:

        write(_("hg: parse error at %s: %s\n") %

                         (inst.args[1], inst.args[0]))

        if (inst.args[0][0] == ' '):

            write(_("unexpected leading whitespace\n"))

    else:

        write(_("hg: parse error: %s\n") % inst.args[0])

        _reportsimilar(write, similar)

    if inst.hint:

        write(_("(%s)\n") % inst.hint)

def _formatargs(args):

    return ' '.join(util.shellquote(a) for a in args)

def dispatch(req):

    "run the command specified in req.args"

    if req.ferr:

        ferr = req.ferr

    elif req.ui:

        ferr = req.ui.ferr

    else:

        ferr = util.stderr

    try:

        if not req.ui:

            req.ui = uimod.ui.load()

        if '--traceback' in req.args:

            req.ui.setconfig('ui', 'traceback', 'on', '--traceback')

        # set ui streams from the request

        if req.fin:

            req.ui.fin = req.fin

        if req.fout:

            req.ui.fout = req.fout

        if req.ferr:

            req.ui.ferr = req.ferr

    except error.Abort as inst:

        ferr.write(_("abort: %s\n") % inst)

        if inst.hint:

            ferr.write(_("(%s)\n") % inst.hint)

        return -1

    except error.ParseError as inst:

        _formatparse(ferr.write, inst)

        return -1

    msg = _formatargs(req.args)

    starttime = util.timer()

    ret = None

    try:

        ret = _runcatch(req)

    except KeyboardInterrupt:

        try:

            req.ui.warn(_("interrupted!\n"))

        except IOError as inst:

            if inst.errno != errno.EPIPE:

                raise

        ret = -1

    finally:

        duration = util.timer() - starttime

        req.ui.flush()

        if req.ui.logblockedtimes:

            req.ui._blockedtimes['command_duration'] = duration * 1000

            req.ui.log('uiblocked', 'ui blocked ms', **req.ui._blockedtimes)

        req.ui.log("commandfinish", "%s exited %s after %0.2f seconds\n",

                   msg, ret or 0, duration)

    return ret

def _runcatch(req):

    def catchterm(*args):

        raise error.SignalInterrupt

    ui = req.ui

    try:

        for name in 'SIGBREAK', 'SIGHUP', 'SIGTERM':

            num = getattr(signal, name, None)

            if num:

                signal.signal(num, catchterm)

    except ValueError:

        pass # happens if called in a thread

    def _runcatchfunc():

        try:

            debugger = 'pdb'

            debugtrace = {

                'pdb' : pdb.set_trace

            }

            debugmortem = {

                'pdb' : pdb.post_mortem

            }

            # read --config before doing anything else

            # (e.g. to change trust settings for reading .hg/hgrc)

            cfgs = _parseconfig(req.ui, _earlygetopt(['--config'], req.args))

            if req.repo:

                # copy configs that were passed on the cmdline (--config) to

                # the repo ui

                for sec, name, val in cfgs:

                    req.repo.ui.setconfig(sec, name, val, source='--config')

            # developer config: ui.debugger

            debugger = ui.config("ui", "debugger")

            debugmod = pdb

            if not debugger or ui.plain():

                # if we are in HGPLAIN mode, then disable custom debugging

                debugger = 'pdb'

            elif '--debugger' in req.args:

                # This import can be slow for fancy debuggers, so only

                # do it when absolutely necessary, i.e. when actual

                # debugging has been requested

                with demandimport.deactivated():

                    try:

                        debugmod = __import__(debugger)

                    except ImportError:

                        pass # Leave debugmod = pdb

            debugtrace[debugger] = debugmod.set_trace

            debugmortem[debugger] = debugmod.post_mortem

            # enter the debugger before command execution

            if '--debugger' in req.args:

                ui.warn(_("entering debugger - "

                        "type c to continue starting hg or h for help\n"))

                if (debugger != 'pdb' and

                    debugtrace[debugger] == debugtrace['pdb']):

                    ui.warn(_("%s debugger specified "

                              "but its module was not found\n") % debugger)

                with demandimport.deactivated():

                    debugtrace[debugger]()

            try:

                return _dispatch(req)

            finally:

                ui.flush()

        except: # re-raises

            # enter the debugger when we hit an exception

            if '--debugger' in req.args:

                traceback.print_exc()

                debugmortem[debugger](sys.exc_info()[2])

            ui.traceback()

            raise

    return callcatch(ui, _runcatchfunc)

def callcatch(ui, func):

    """like scmutil.callcatch but handles more high-level exceptions about

    config parsing and commands. besides, use handlecommandexception to handle

    uncaught exceptions.

    """

    try:

        return scmutil.callcatch(ui, func)

    except error.AmbiguousCommand as inst:

        ui.warn(_("hg: command '%s' is ambiguous:\n    %s\n") %

                (inst.args[0], " ".join(inst.args[1])))

    except error.CommandError as inst:

        if inst.args[0]:

            ui.pager('help')

            ui.warn(_("hg %s: %s\n") % (inst.args[0], inst.args[1]))

            commands.help_(ui, inst.args[0], full=False, command=True)

        else:

            ui.pager('help')

            ui.warn(_("hg: %s\n") % inst.args[1])

            commands.help_(ui, 'shortlist')

    except error.ParseError as inst:

        _formatparse(ui.warn, inst)

        return -1

    except error.UnknownCommand as inst:

        nocmdmsg = _("hg: unknown command '%s'\n") % inst.args[0]

        try:

            # check if the command is in a disabled extension

            # (but don't check for extensions themselves)

            formatted = help.formattedhelp(ui, inst.args[0], unknowncmd=True)

            ui.warn(nocmdmsg)

            ui.write(formatted)

        except (error.UnknownCommand, error.Abort):

            suggested = False

            if len(inst.args) == 2:

                sim = _getsimilar(inst.args[1], inst.args[0])

                if sim:

                    ui.warn(nocmdmsg)

                    _reportsimilar(ui.warn, sim)

                    suggested = True

            if not suggested:

                ui.pager('help')

                ui.warn(nocmdmsg)

                commands.help_(ui, 'shortlist')

    except IOError:

        raise

    except KeyboardInterrupt:

        raise

    except:  # probably re-raises

        if not handlecommandexception(ui):

            raise

    return -1

def aliasargs(fn, givenargs):

    args = getattr(fn, 'args', [])

    if args:

        cmd = ' '.join(map(util.shellquote, args))

        nums = []

        def replacer(m):

            num = int(m.group(1)) - 1

            nums.append(num)

            if num < len(givenargs):

                return givenargs[num]

            raise error.Abort(_('too few arguments for command alias'))

        cmd = re.sub(br'\$(\d+|\$)', replacer, cmd)

        givenargs = [x for i, x in enumerate(givenargs)

                     if i not in nums]

        args = pycompat.shlexsplit(cmd)

    return args + givenargs

def aliasinterpolate(name, args, cmd):

    '''interpolate args into cmd for shell aliases

    This also handles $0, $@ and "$@".

    '''

    # util.interpolate can't deal with "$@" (with quotes) because it's only

    # built to match prefix + patterns.

    replacemap = dict(('$%d' % (i + 1), arg) for i, arg in enumerate(args))

    replacemap['$0'] = name

    replacemap['$$'] = '$'

    replacemap['$@'] = ' '.join(args)

    # Typical Unix shells interpolate "$@" (with quotes) as all the positional

    # parameters, separated out into words. Emulate the same behavior here by

    # quoting the arguments individually. POSIX shells will then typically

    # tokenize each argument into exactly one word.

    replacemap['"$@"'] = ' '.join(util.shellquote(arg) for arg in args)

    # escape '\$' for regex

    regex = '|'.join(replacemap.keys()).replace('$', r'\$')

    r = re.compile(regex)

    return r.sub(lambda x: replacemap[x.group()], cmd)

class cmdalias(object):

    def __init__(self, name, definition, cmdtable, source):

        self.name = self.cmd = name

        self.cmdname = ''

        self.definition = definition

        self.fn = None

        self.givenargs = []

        self.opts = []

        self.help = ''

        self.badalias = None

        self.unknowncmd = False

        self.source = source

        try:

            aliases, entry = cmdutil.findcmd(self.name, cmdtable)

            for alias, e in cmdtable.iteritems():

                if e is entry:

                    self.cmd = alias

                    break

            self.shadows = True

        except error.UnknownCommand:

            self.shadows = False

        if not self.definition:

            self.badalias = _("no definition for alias '%s'") % self.name

            return

        if self.definition.startswith('!'):

            self.shell = True

            def fn(ui, *args):

                env = {'HG_ARGS': ' '.join((self.name,) + args)}

                def _checkvar(m):

                    if m.groups()[0] == '$':

                        return m.group()

                    elif int(m.groups()[0]) <= len(args):

                        return m.group()

                    else:

                        ui.debug("No argument found for substitution "

                                 "of %i variable in alias '%s' definition."

                                 % (int(m.groups()[0]), self.name))

                        return ''

                cmd = re.sub(r'\$(\d+|\$)', _checkvar, self.definition[1:])

                cmd = aliasinterpolate(self.name, args, cmd)

                return ui.system(cmd, environ=env,

                                 blockedtag='alias_%s' % self.name)

            self.fn = fn

            return

        try:

            args = pycompat.shlexsplit(self.definition)

        except ValueError as inst:

            self.badalias = (_("error in definition for alias '%s': %s")

                             % (self.name, inst))

            return

        self.cmdname = cmd = args.pop(0)

        self.givenargs = args

        for invalidarg in ("--cwd", "-R", "--repository", "--repo", "--config"):

            if _earlygetopt([invalidarg], args):

                self.badalias = (_("error in definition for alias '%s': %s may "

                                   "only be given on the command line")

                                 % (self.name, invalidarg))

                return

        try:

            tableentry = cmdutil.findcmd(cmd, cmdtable, False)[1]

            if len(tableentry) > 2:

                self.fn, self.opts, self.help = tableentry

            else:

                self.fn, self.opts = tableentry

            if self.help.startswith("hg " + cmd):

                # drop prefix in old-style help lines so hg shows the alias

                self.help = self.help[4 + len(cmd):]

            self.__doc__ = self.fn.__doc__

        except error.UnknownCommand:

            self.badalias = (_("alias '%s' resolves to unknown command '%s'")

                             % (self.name, cmd))

            self.unknowncmd = True

        except error.AmbiguousCommand:

            self.badalias = (_("alias '%s' resolves to ambiguous command '%s'")

                             % (self.name, cmd))

    @property

    def args(self):

        args = pycompat.maplist(util.expandpath, self.givenargs)

        return aliasargs(self.fn, args)

    def __getattr__(self, name):

        adefaults = {'norepo': True, 'optionalrepo': False, 'inferrepo': False}

        if name not in adefaults:

            raise AttributeError(name)

        if self.badalias or util.safehasattr(self, 'shell'):

            return adefaults[name]

        return getattr(self.fn, name)

    def __call__(self, ui, *args, **opts):

        if self.badalias:

            hint = None

            if self.unknowncmd:

                try:

                    # check if the command is in a disabled extension

                    cmd, ext = extensions.disabledcmd(ui, self.cmdname)[:2]

                    hint = _("'%s' is provided by '%s' extension") % (cmd, ext)

                except error.UnknownCommand:

                    pass

            raise error.Abort(self.badalias, hint=hint)

        if self.shadows:

            ui.debug("alias '%s' shadows command '%s'\n" %

                     (self.name, self.cmdname))

        ui.log('commandalias', "alias '%s' expands to '%s'\n",

               self.name, self.definition)

        if util.safehasattr(self, 'shell'):

            return self.fn(ui, *args, **opts)

        else:

            try:

                return util.checksignature(self.fn)(ui, *args, **opts)

            except error.SignatureError:

                args = ' '.join([self.cmdname] + self.args)

                ui.debug("alias '%s' expands to '%s'\n" % (self.name, args))

                raise

def addaliases(ui, cmdtable):

    # aliases are processed after extensions have been loaded, so they

    # may use extension commands. Aliases can also use other alias definitions,

    # but only if they have been defined prior to the current definition.

    for alias, definition in ui.configitems('alias'):

        source = ui.configsource('alias', alias)

        aliasdef = cmdalias(alias, definition, cmdtable, source)

        try:

            olddef = cmdtable[aliasdef.cmd][0]

            if olddef.definition == aliasdef.definition:

                continue

        except (KeyError, AttributeError):

            # definition might not exist or it might not be a cmdalias

            pass

        cmdtable[aliasdef.name] = (aliasdef, aliasdef.opts, aliasdef.help)

def _parse(ui, args):