# 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 i18n import _

import os, sys, atexit, signal, pdb, socket, errno, shlex, time, traceback, re

import util, commands, hg, fancyopts, extensions, hook, error

import cmdutil, encoding

import ui as uimod

class request(object):

        self.args = args

def run():

    "run the command in sys.argv"

    sys.exit(dispatch(request(sys.argv[1:])))

def dispatch(req):

    "run the command specified in req.args"

    try:

        if '--traceback' in req.args:

    except util.Abort, inst:

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

        if inst.hint:

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

        return -1

    except error.ParseError, inst:

        if len(inst.args) > 1:

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

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

        else:

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

        return -1

    def catchterm(*args):

        raise error.SignalInterrupt

    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

    try:

        try:

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

                pdb.set_trace()

            try:

            finally:

                ui.flush()

        except:

            # enter the debugger when we hit an exception

            if '--debugger' in req.args:

                traceback.print_exc()

                pdb.post_mortem(sys.exc_info()[2])

            ui.traceback()

            raise

    # Global exception handling, alphabetically

    # Mercurial-specific first, followed by built-in and library exceptions

    except error.AmbiguousCommand, inst:

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

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

    except error.ParseError, inst:

        if len(inst.args) > 1:

            ui.warn(_("hg: parse error at %s: %s\n") %

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

        else:

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

        return -1

    except error.LockHeld, inst:

        if inst.errno == errno.ETIMEDOUT:

            reason = _('timed out waiting for lock held by %s') % inst.locker

        else:

            reason = _('lock held by %s') % inst.locker

        ui.warn(_("abort: %s: %s\n") % (inst.desc or inst.filename, reason))

    except error.LockUnavailable, inst:

        ui.warn(_("abort: could not lock %s: %s\n") %

               (inst.desc or inst.filename, inst.strerror))

    except error.CommandError, inst:

        if inst.args[0]:

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

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

        else:

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

            commands.help_(ui, 'shortlist')

    except error.RepoError, inst:

        ui.warn(_("abort: %s!\n") % inst)

    except error.ResponseError, inst:

        ui.warn(_("abort: %s") % inst.args[0])

        if not isinstance(inst.args[1], basestring):

            ui.warn(" %r\n" % (inst.args[1],))

        elif not inst.args[1]:

            ui.warn(_(" empty string\n"))

        else:

            ui.warn("\n%r\n" % util.ellipsis(inst.args[1]))

    except error.RevlogError, inst:

        ui.warn(_("abort: %s!\n") % inst)

    except error.SignalInterrupt:

        ui.warn(_("killed!\n"))

    except error.UnknownCommand, inst:

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

            commands.help_(ui, inst.args[0], unknowncmd=True)

        except error.UnknownCommand:

            commands.help_(ui, 'shortlist')

    except util.Abort, inst:

        ui.warn(_("abort: %s\n") % inst)

        if inst.hint:

            ui.warn(_("(%s)\n") % inst.hint)

    except ImportError, inst:

        ui.warn(_("abort: %s!\n") % inst)

        m = str(inst).split()[-1]

        if m in "mpatch bdiff".split():

            ui.warn(_("(did you forget to compile extensions?)\n"))

        elif m in "zlib".split():

            ui.warn(_("(is your Python install correct?)\n"))

    except IOError, inst:

        if hasattr(inst, "code"):

            ui.warn(_("abort: %s\n") % inst)

        elif hasattr(inst, "reason"):

            try: # usually it is in the form (errno, strerror)

                reason = inst.reason.args[1]

            except (AttributeError, IndexError):

                 # it might be anything, for example a string

                reason = inst.reason

            ui.warn(_("abort: error: %s\n") % reason)

        elif hasattr(inst, "args") and inst.args[0] == errno.EPIPE:

            if ui.debugflag:

                ui.warn(_("broken pipe\n"))

        elif getattr(inst, "strerror", None):

            if getattr(inst, "filename", None):

                ui.warn(_("abort: %s: %s\n") % (inst.strerror, inst.filename))

            else:

                ui.warn(_("abort: %s\n") % inst.strerror)

        else:

            raise

    except OSError, inst:

        if getattr(inst, "filename", None):

            ui.warn(_("abort: %s: %s\n") % (inst.strerror, inst.filename))

        else:

            ui.warn(_("abort: %s\n") % inst.strerror)

    except KeyboardInterrupt:

        try:

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

        except IOError, inst:

            if inst.errno == errno.EPIPE:

                if ui.debugflag:

                    ui.warn(_("\nbroken pipe\n"))

            else:

                raise

    except MemoryError:

        ui.warn(_("abort: out of memory\n"))

    except SystemExit, inst:

        # Commands shouldn't sys.exit directly, but give a return code.

        # Just in case catch this and and pass exit code to caller.

        return inst.code

    except socket.error, inst:

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

    except:

        ui.warn(_("** unknown exception encountered,"

                  " please report by visiting\n"))

        ui.warn(_("**  http://mercurial.selenic.com/wiki/BugTracker\n"))

        ui.warn(_("** Python %s\n") % sys.version.replace('\n', ''))

        ui.warn(_("** Mercurial Distributed SCM (version %s)\n")

               % util.version())

        ui.warn(_("** Extensions loaded: %s\n")

               % ", ".join([x[0] for x in extensions.extensions()]))

        raise

    return -1

def aliasargs(fn, givenargs):

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

    if args and givenargs:

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

        nums = []

        def replacer(m):

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

            nums.append(num)

            return givenargs[num]

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

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

                     if i not in nums]

        args = shlex.split(cmd)

    return args + givenargs

class cmdalias(object):

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

        self.name = self.cmd = name

        self.cmdname = ''

        self.definition = definition

        self.args = []

        self.opts = []

        self.help = ''

        self.norepo = True

        self.badalias = False

        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:

            def fn(ui, *args):

                ui.warn(_("no definition for alias '%s'\n") % self.name)

                return 1

            self.fn = fn

            self.badalias = True

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

                replace = dict((str(i + 1), arg) for i, arg in enumerate(args))

                replace['0'] = self.name

                replace['@'] = ' '.join(args)

                cmd = util.interpolate(r'\$', replace, cmd, escape_prefix=True)

                return util.system(cmd, environ=env)

            self.fn = fn

            return

        args = shlex.split(self.definition)

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

        args = map(util.expandpath, args)

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

            if _earlygetopt([invalidarg], args):

                def fn(ui, *args):

                    ui.warn(_("error in definition for alias '%s': %s may only "

                              "be given on the command line\n")

                            % (self.name, invalidarg))

                    return 1

                self.fn = fn

                self.badalias = True

                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

            self.args = aliasargs(self.fn, args)

            if cmd not in commands.norepo.split(' '):

                self.norepo = False

            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:

            def fn(ui, *args):

                ui.warn(_("alias '%s' resolves to unknown command '%s'\n") \

                            % (self.name, cmd))

                try:

                    # check if the command is in a disabled extension

                    commands.help_(ui, cmd, unknowncmd=True)

                except error.UnknownCommand:

                    pass

                return 1

            self.fn = fn

            self.badalias = True

        except error.AmbiguousCommand:

            def fn(ui, *args):

                ui.warn(_("alias '%s' resolves to ambiguous command '%s'\n") \

                            % (self.name, cmd))

                return 1

            self.fn = fn

            self.badalias = True

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

        if self.shadows:

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

                     (self.name, self.cmdname))

        if hasattr(self, 'shell'):

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

        else:

            try:

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

        aliasdef = cmdalias(alias, definition, cmdtable)

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

        if aliasdef.norepo:

            commands.norepo += ' %s' % alias

def _parse(ui, args):

    options = {}

    cmdoptions = {}

    try:

        args = fancyopts.fancyopts(args, commands.globalopts, options)

    except fancyopts.getopt.GetoptError, inst:

        raise error.CommandError(None, inst)

    if args:

        cmd, args = args[0], args[1:]

        aliases, entry = cmdutil.findcmd(cmd, commands.table,

                                     ui.config("ui", "strict"))

        cmd = aliases[0]

        args = aliasargs(entry[0], args)

        defaults = ui.config("defaults", cmd)

        if defaults:

            args = map(util.expandpath, shlex.split(defaults)) + args

        c = list(entry[1])

    else:

        cmd = None

        c = []

    # combine global options into local

    for o in commands.globalopts:

        c.append((o[0], o[1], options[o[1]], o[3]))

    try:

        args = fancyopts.fancyopts(args, c, cmdoptions, True)

    except fancyopts.getopt.GetoptError, inst:

        raise error.CommandError(cmd, inst)

    # separate global options back out

    for o in commands.globalopts:

        n = o[1]

        options[n] = cmdoptions[n]

        del cmdoptions[n]

    return (cmd, cmd and entry[0] or None, args, options, cmdoptions)

def _parseconfig(ui, config):

    """parse the --config options from the command line"""

    for cfg in config:

        try:

            name, value = cfg.split('=', 1)

            section, name = name.split('.', 1)

            if not section or not name:

                raise IndexError

            ui.setconfig(section, name, value)

        except (IndexError, ValueError):

            raise util.Abort(_('malformed --config option: %r '

                               '(use --config section.name=value)') % cfg)

def _earlygetopt(aliases, args):

    """Return list of values for an option (or aliases).

    The values are listed in the order they appear in args.

    The options and values are removed from args.

    """

    try:

        argcount = args.index("--")

    except ValueError:

        argcount = len(args)

    shortopts = [opt for opt in aliases if len(opt) == 2]

    values = []

    pos = 0

    while pos < argcount:

        if args[pos] in aliases:

            if pos + 1 >= argcount:

                # ignore and let getopt report an error if there is no value

                break

            del args[pos]

            values.append(args.pop(pos))

            argcount -= 2

        elif args[pos][:2] in shortopts:

            # short option can have no following space, e.g. hg log -Rfoo

            values.append(args.pop(pos)[2:])

            argcount -= 1

        else:

            pos += 1

    return values

def runcommand(lui, repo, cmd, fullargs, ui, options, d, cmdpats, cmdoptions):

    # run pre-hook, and abort if it fails

    ret = hook.hook(lui, repo, "pre-%s" % cmd, False, args=" ".join(fullargs),

                    pats=cmdpats, opts=cmdoptions)

    if ret:

        return ret

    ret = _runcommand(ui, options, cmd, d)

    # run post-hook, passing command result

    hook.hook(lui, repo, "post-%s" % cmd, False, args=" ".join(fullargs),

              result=ret, pats=cmdpats, opts=cmdoptions)

    return ret

def _getlocal(ui, rpath):

    """Return (path, local ui object) for the given target path.

    Takes paths in [cwd]/.hg/hgrc into account."

    """

    try:

        wd = os.getcwd()

    except OSError, e:

        raise util.Abort(_("error getting current working directory: %s") %

                         e.strerror)

    path = cmdutil.findrepo(wd) or ""

    if not path:

        lui = ui

    else:

        lui = ui.copy()

        lui.readconfig(os.path.join(path, ".hg", "hgrc"), path)

    if rpath:

        path = lui.expandpath(rpath[-1])

        lui = ui.copy()

        lui.readconfig(os.path.join(path, ".hg", "hgrc"), path)

    return path, lui

def _checkshellalias(ui, args):

    cwd = os.getcwd()

    norepo = commands.norepo

    options = {}

    try:

        args = fancyopts.fancyopts(args, commands.globalopts, options)

    except fancyopts.getopt.GetoptError:

        return

    if not args:

        return

    _parseconfig(ui, options['config'])

    if options['cwd']:

        os.chdir(options['cwd'])

    path, lui = _getlocal(ui, [options['repository']])

    cmdtable = commands.table.copy()

    addaliases(lui, cmdtable)

    cmd = args[0]

    try:

        aliases, entry = cmdutil.findcmd(cmd, cmdtable, lui.config("ui", "strict"))

    except (error.AmbiguousCommand, error.UnknownCommand):

        commands.norepo = norepo

        os.chdir(cwd)

        return

    cmd = aliases[0]

    fn = entry[0]

    if cmd and hasattr(fn, 'shell'):

        d = lambda: fn(ui, *args[1:])

        return lambda: runcommand(lui, None, cmd, args[:1], ui, options, d, [], {})

    commands.norepo = norepo