# cmdutil.py - help for command processing in 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 node import hex, nullid, nullrev, short

from i18n import _

import os, sys, errno, re, tempfile, cStringIO, shutil

import util, scmutil, templater, patch, error, templatekw, revlog, copies

import match as matchmod

import context, repair, graphmod, revset, phases, obsolete, pathutil

import changelog

import bookmarks

import encoding

import crecord as crecordmod

import lock as lockmod

def parsealiases(cmd):

    return cmd.lstrip("^").split("|")

def setupwrapcolorwrite(ui):

    # wrap ui.write so diff output can be labeled/colorized

    def wrapwrite(orig, *args, **kw):

        label = kw.pop('label', '')

        for chunk, l in patch.difflabel(lambda: args):

            orig(chunk, label=label + l)

    oldwrite = ui.write

    def wrap(*args, **kwargs):

        return wrapwrite(oldwrite, *args, **kwargs)

    setattr(ui, 'write', wrap)

    return oldwrite

def filterchunks(ui, originalhunks, usecurses, testfile):

    if usecurses:

        if testfile:

            recordfn = crecordmod.testdecorator(testfile,

                                                crecordmod.testchunkselector)

        else:

            recordfn = crecordmod.chunkselector

        return crecordmod.filterpatch(ui, originalhunks, recordfn)

    else:

        return patch.filterpatch(ui, originalhunks)

def recordfilter(ui, originalhunks):

    usecurses =  ui.configbool('experimental', 'crecord', False)

    testfile = ui.config('experimental', 'crecordtest', None)

    oldwrite = setupwrapcolorwrite(ui)

    try:

        newchunks = filterchunks(ui, originalhunks, usecurses, testfile)

    finally:

        ui.write = oldwrite

    return newchunks

def dorecord(ui, repo, commitfunc, cmdsuggest, backupall,

            filterfn, *pats, **opts):

    import merge as mergemod

    hunkclasses = (crecordmod.uihunk, patch.recordhunk)

    ishunk = lambda x: isinstance(x, hunkclasses)

    if not ui.interactive():

        raise util.Abort(_('running non-interactively, use %s instead') %

                         cmdsuggest)

    # make sure username is set before going interactive

    if not opts.get('user'):

        ui.username() # raise exception, username not provided

    def recordfunc(ui, repo, message, match, opts):

        """This is generic record driver.

        Its job is to interactively filter local changes, and

        accordingly prepare working directory into a state in which the

        job can be delegated to a non-interactive commit command such as

        'commit' or 'qrefresh'.

        After the actual job is done by non-interactive command, the

        working directory is restored to its original state.

        In the end we'll record interesting changes, and everything else

        will be left in place, so the user can continue working.

        """

        checkunfinished(repo, commit=True)

        merge = len(repo[None].parents()) > 1

        if merge:

            raise util.Abort(_('cannot partially commit a merge '

                               '(use "hg commit" instead)'))

        status = repo.status(match=match)

        diffopts = patch.difffeatureopts(ui, opts=opts, whitespace=True)

        diffopts.nodates = True

        diffopts.git = True

        originaldiff =  patch.diff(repo, changes=status, opts=diffopts)

        originalchunks = patch.parsepatch(originaldiff)

        # 1. filter patch, so we have intending-to apply subset of it

        try:

            chunks = filterfn(ui, originalchunks)

        except patch.PatchError, err:

            raise util.Abort(_('error parsing patch: %s') % err)

        contenders = set()

        for h in chunks:

            try:

                contenders.update(set(h.files()))

            except AttributeError:

                pass

        changed = status.modified + status.added + status.removed

        newfiles = [f for f in changed if f in contenders]

        if not newfiles:

            ui.status(_('no changes to record\n'))

            return 0

        newandmodifiedfiles = set()

        for h in chunks:

            isnew = h.filename() in status.added

            if ishunk(h) and isnew and not h in originalchunks:

                newandmodifiedfiles.add(h.filename())

        modified = set(status.modified)

        # 2. backup changed files, so we can restore them in the end

        if backupall:

            tobackup = changed

        else:

            tobackup = [f for f in newfiles

                        if f in modified or f in newandmodifiedfiles]

        backups = {}

        if tobackup:

            backupdir = repo.join('record-backups')

            try:

                os.mkdir(backupdir)

            except OSError, err:

                if err.errno != errno.EEXIST:

                    raise

        try:

            # backup continues

            for f in tobackup:

                fd, tmpname = tempfile.mkstemp(prefix=f.replace('/', '_')+'.',

                                               dir=backupdir)

                os.close(fd)

                ui.debug('backup %r as %r\n' % (f, tmpname))

                util.copyfile(repo.wjoin(f), tmpname)

                shutil.copystat(repo.wjoin(f), tmpname)

                backups[f] = tmpname

            fp = cStringIO.StringIO()

            for c in chunks:

                fname = c.filename()

                if fname in backups or fname in newandmodifiedfiles:

                    c.write(fp)

            dopatch = fp.tell()

            fp.seek(0)

            [os.unlink(c) for c in newandmodifiedfiles]

            # 3a. apply filtered patch to clean repo  (clean)

            if backups:

                # Equivalent to hg.revert

                choices = lambda key: key in backups

                mergemod.update(repo, repo.dirstate.p1(),

                        False, True, choices)

            # 3b. (apply)

            if dopatch:

                try:

                    ui.debug('applying patch\n')

                    ui.debug(fp.getvalue())

                    patch.internalpatch(ui, repo, fp, 1, eolmode=None)

                except patch.PatchError, err:

                    raise util.Abort(str(err))

            del fp

            # 4. We prepared working directory according to filtered

            #    patch. Now is the time to delegate the job to

            #    commit/qrefresh or the like!

            # Make all of the pathnames absolute.

            newfiles = [repo.wjoin(nf) for nf in newfiles]

            commitfunc(ui, repo, *newfiles, **opts)

            return 0

        finally:

            # 5. finally restore backed-up files

            try:

                for realname, tmpname in backups.iteritems():

                    ui.debug('restoring %r to %r\n' % (tmpname, realname))

                    util.copyfile(tmpname, repo.wjoin(realname))

                    # Our calls to copystat() here and above are a

                    # hack to trick any editors that have f open that

                    # we haven't modified them.

                    #

                    # Also note that this racy as an editor could

                    # notice the file's mtime before we've finished

                    # writing it.

                    shutil.copystat(tmpname, repo.wjoin(realname))

                    os.unlink(tmpname)

                if tobackup:

                    os.rmdir(backupdir)

            except OSError:

                pass

    return commit(ui, repo, recordfunc, pats, opts)

def findpossible(cmd, table, strict=False):

    """

    Return cmd -> (aliases, command table entry)

    for each matching command.

    Return debug commands (or their aliases) only if no normal command matches.

    """

    choice = {}

    debugchoice = {}

    if cmd in table:

        # short-circuit exact matches, "log" alias beats "^log|history"

        keys = [cmd]

    else:

        keys = table.keys()

    allcmds = []

    for e in keys:

        aliases = parsealiases(e)

        allcmds.extend(aliases)

        found = None

        if cmd in aliases:

            found = cmd

        elif not strict:

            for a in aliases:

                if a.startswith(cmd):

                    found = a

                    break

        if found is not None:

            if aliases[0].startswith("debug") or found.startswith("debug"):

                debugchoice[found] = (aliases, table[e])

            else:

                choice[found] = (aliases, table[e])

    if not choice and debugchoice:

        choice = debugchoice

    return choice, allcmds

def findcmd(cmd, table, strict=True):

    """Return (aliases, command table entry) for command string."""

    choice, allcmds = findpossible(cmd, table, strict)

    if cmd in choice:

        return choice[cmd]

    if len(choice) > 1:

        clist = choice.keys()

        clist.sort()

        raise error.AmbiguousCommand(cmd, clist)

    if choice:

        return choice.values()[0]

    raise error.UnknownCommand(cmd, allcmds)

def findrepo(p):

    while not os.path.isdir(os.path.join(p, ".hg")):

        oldp, p = p, os.path.dirname(p)

        if p == oldp:

            return None

    return p

def bailifchanged(repo):

    if repo.dirstate.p2() != nullid:

        raise util.Abort(_('outstanding uncommitted merge'))

    modified, added, removed, deleted = repo.status()[:4]

    if modified or added or removed or deleted:

        raise util.Abort(_('uncommitted changes'))

    ctx = repo[None]

    for s in sorted(ctx.substate):

        if ctx.sub(s).dirty():

            raise util.Abort(_("uncommitted changes in subrepo %s") % s)

def logmessage(ui, opts):

    """ get the log message according to -m and -l option """

    message = opts.get('message')

    logfile = opts.get('logfile')

    if message and logfile:

        raise util.Abort(_('options --message and --logfile are mutually '

                           'exclusive'))

    if not message and logfile:

        try:

            if logfile == '-':

                message = ui.fin.read()

            else:

                message = '\n'.join(util.readfile(logfile).splitlines())

        except IOError, inst:

            raise util.Abort(_("can't read commit message '%s': %s") %

                             (logfile, inst.strerror))

    return message

def mergeeditform(ctxorbool, baseformname):

    """return appropriate editform name (referencing a committemplate)

    'ctxorbool' is either a ctx to be committed, or a bool indicating whether

    merging is committed.

    This returns baseformname with '.merge' appended if it is a merge,

    otherwise '.normal' is appended.

    """

    if isinstance(ctxorbool, bool):

        if ctxorbool:

            return baseformname + ".merge"

    elif 1 < len(ctxorbool.parents()):

        return baseformname + ".merge"

    return baseformname + ".normal"

def getcommiteditor(edit=False, finishdesc=None, extramsg=None,

                    editform='', **opts):

    """get appropriate commit message editor according to '--edit' option

    'finishdesc' is a function to be called with edited commit message

    (= 'description' of the new changeset) just after editing, but

    before checking empty-ness. It should return actual text to be

    stored into history. This allows to change description before

    storing.

    'extramsg' is a extra message to be shown in the editor instead of

    'Leave message empty to abort commit' line. 'HG: ' prefix and EOL

    is automatically added.

    'editform' is a dot-separated list of names, to distinguish

    the purpose of commit text editing.

    'getcommiteditor' returns 'commitforceeditor' regardless of

    'edit', if one of 'finishdesc' or 'extramsg' is specified, because

    they are specific for usage in MQ.

    """

    if edit or finishdesc or extramsg:

        return lambda r, c, s: commitforceeditor(r, c, s,

                                                 finishdesc=finishdesc,

                                                 extramsg=extramsg,

                                                 editform=editform)

    elif editform:

        return lambda r, c, s: commiteditor(r, c, s, editform=editform)

    else:

        return commiteditor

def loglimit(opts):

    """get the log limit according to option -l/--limit"""

    limit = opts.get('limit')

    if limit:

        try:

            limit = int(limit)

        except ValueError:

            raise util.Abort(_('limit must be a positive integer'))

        if limit <= 0:

            raise util.Abort(_('limit must be positive'))

    else:

        limit = None

    return limit

def makefilename(repo, pat, node, desc=None,

                  total=None, seqno=None, revwidth=None, pathname=None):

    node_expander = {

        'H': lambda: hex(node),

        'R': lambda: str(repo.changelog.rev(node)),

        'h': lambda: short(node),

        'm': lambda: re.sub('[^\w]', '_', str(desc))