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

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

import cmdutil, encoding

import ui as uimod

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(sys.argv[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 _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])

        if similar:

            if len(similar) == 1:

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

            else:

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

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

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 = sys.stderr

    try:

        if not req.ui:

            req.ui = uimod.ui()

        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 util.Abort, inst:

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

        if inst.hint:

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

        return -1

    except error.ParseError, inst:

        _formatparse(ferr.write, inst)

        return -1

    msg = ' '.join(' ' in a and repr(a) or a for a in req.args)

    starttime = time.time()

    ret = None

    try:

        ret = _runcatch(req)

        return ret

    finally:

        duration = time.time() - starttime

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

                   msg, ret or 0, duration)

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

    try:

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

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

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

            debugmod = pdb

            if not debugger or ui.plain():

                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

                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)

                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

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

        _formatparse(ui.warn, inst)

        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.OutOfBandError, inst:

        ui.warn(_("abort: remote error:\n"))

        ui.warn(''.join(inst.args))

    except error.RepoError, inst:

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

        if inst.hint:

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

    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.CensoredNodeError, inst:

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

    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:

            suggested = False

            if len(inst.args) == 2:

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

                if sim:

                    ui.warn(_('(did you mean one of %s?)\n') %

                            ', '.join(sorted(sim)))

                    suggested = True

            if not suggested:

                commands.help_(ui, 'shortlist')

    except error.InterventionRequired, inst:

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

        return 1

    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 util.safehasattr(inst, "code"):

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

        elif util.safehasattr(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

            if isinstance(reason, unicode):

                # SSLError of Python 2.7.9 contains a unicode

                reason = reason.encode(encoding.encoding, 'replace')

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

        elif (util.safehasattr(inst, "args")

              and 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) is not 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: # re-raises

        myver = util.version()

        # For compatibility checking, we discard the portion of the hg

        # version after the + on the assumption that if a "normal

        # user" is running a build with a + in it the packager

        # probably built from fairly close to a tag and anyone with a

        # 'make local' copy of hg (where the version number can be out

        # of date) will be clueful enough to notice the implausible

        # version number and try updating.

        compare = myver.split('+')[0]

        ct = tuplever(compare)

        worst = None, ct, ''

        for name, mod in extensions.extensions():

            testedwith = getattr(mod, 'testedwith', '')

            report = getattr(mod, 'buglink', _('the extension author.'))

            if not testedwith.strip():

                # We found an untested extension. It's likely the culprit.

                worst = name, 'unknown', report

                break

            # Never blame on extensions bundled with Mercurial.

            if testedwith == 'internal':

                continue

            tested = [tuplever(t) for t in testedwith.split()]

            if ct in tested:

                continue

            lower = [t for t in tested if t < ct]

            nearest = max(lower or tested)

            if worst[0] is None or nearest < worst[1]:

                worst = name, nearest, report

        if worst[0] is not None:

            name, testedwith, report = worst

            if not isinstance(testedwith, str):

                testedwith = '.'.join([str(c) for c in testedwith])

            warning = (_('** Unknown exception encountered with '

                         'possibly-broken third-party extension %s\n'

                         '** which supports versions %s of Mercurial.\n'

                         '** Please disable %s and try your action again.\n'

                         '** If that fixes the bug please report it to %s\n')

                       % (name, testedwith, name, report))

        else:

            warning = (_("** unknown exception encountered, "

                         "please report by visiting\n") +

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

        warning += ((_("** Python %s\n") % sys.version.replace('\n', '')) +

                    (_("** Mercurial Distributed SCM (version %s)\n") % myver) +

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

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

        ui.log("commandexception", "%s\n%s\n", warning, traceback.format_exc())

        ui.warn(warning)

        raise

    return -1