# 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 __future__ import absolute_import

import errno

import os

import re

from .i18n import _

from .node import (

    hex,

    nullid,

    nullrev,

    short,

)

from . import (

    bookmarks,

    changelog,

    copies,

    crecord as crecordmod,

    dirstateguard,

    encoding,

    error,

    formatter,

    logcmdutil,

    match as matchmod,

    merge as mergemod,

    mergeutil,

    obsolete,

    patch,

    pathutil,

    pycompat,

    revlog,

    rewriteutil,

    scmutil,

    smartset,

    subrepoutil,

    templatekw,

    templater,

    util,

    vfs as vfsmod,

)

from .utils import (

    dateutil,

    stringutil,

)

stringio = util.stringio

# templates of common command options

dryrunopts = [

    ('n', 'dry-run', None,

     _('do not perform actions, just print output')),

]

remoteopts = [

    ('e', 'ssh', '',

     _('specify ssh command to use'), _('CMD')),

    ('', 'remotecmd', '',

     _('specify hg command to run on the remote side'), _('CMD')),

    ('', 'insecure', None,

     _('do not verify server certificate (ignoring web.cacerts config)')),

]

walkopts = [

    ('I', 'include', [],

     _('include names matching the given patterns'), _('PATTERN')),

    ('X', 'exclude', [],

     _('exclude names matching the given patterns'), _('PATTERN')),

]

commitopts = [

    ('m', 'message', '',

     _('use text as commit message'), _('TEXT')),

    ('l', 'logfile', '',

     _('read commit message from file'), _('FILE')),

]

commitopts2 = [

    ('d', 'date', '',

     _('record the specified date as commit date'), _('DATE')),

    ('u', 'user', '',

     _('record the specified user as committer'), _('USER')),

]

# hidden for now

formatteropts = [

    ('T', 'template', '',

     _('display with template (EXPERIMENTAL)'), _('TEMPLATE')),

]

templateopts = [

    ('', 'style', '',

     _('display using template map file (DEPRECATED)'), _('STYLE')),

    ('T', 'template', '',

     _('display with template'), _('TEMPLATE')),

]

logopts = [

    ('p', 'patch', None, _('show patch')),

    ('g', 'git', None, _('use git extended diff format')),

    ('l', 'limit', '',

     _('limit number of changes displayed'), _('NUM')),

    ('M', 'no-merges', None, _('do not show merges')),

    ('', 'stat', None, _('output diffstat-style summary of changes')),

    ('G', 'graph', None, _("show the revision DAG")),

] + templateopts

diffopts = [

    ('a', 'text', None, _('treat all files as text')),

    ('g', 'git', None, _('use git extended diff format')),

    ('', 'binary', None, _('generate binary diffs in git mode (default)')),

    ('', 'nodates', None, _('omit dates from diff headers'))

]

diffwsopts = [

    ('w', 'ignore-all-space', None,

     _('ignore white space when comparing lines')),

    ('b', 'ignore-space-change', None,

     _('ignore changes in the amount of white space')),

    ('B', 'ignore-blank-lines', None,

     _('ignore changes whose lines are all blank')),

    ('Z', 'ignore-space-at-eol', None,

     _('ignore changes in whitespace at EOL')),

]

diffopts2 = [

    ('', 'noprefix', None, _('omit a/ and b/ prefixes from filenames')),

    ('p', 'show-function', None, _('show which function each change is in')),

    ('', 'reverse', None, _('produce a diff that undoes the changes')),

] + diffwsopts + [

    ('U', 'unified', '',

     _('number of lines of context to show'), _('NUM')),

    ('', 'stat', None, _('output diffstat-style summary of changes')),

    ('', 'root', '', _('produce diffs relative to subdirectory'), _('DIR')),

]

mergetoolopts = [

    ('t', 'tool', '', _('specify merge tool')),

]

similarityopts = [

    ('s', 'similarity', '',

     _('guess renamed files by similarity (0<=s<=100)'), _('SIMILARITY'))

]

subrepoopts = [

    ('S', 'subrepos', None,

     _('recurse into subrepositories'))

]

debugrevlogopts = [

    ('c', 'changelog', False, _('open changelog')),

    ('m', 'manifest', False, _('open manifest')),

    ('', 'dir', '', _('open directory manifest')),

]

# special string such that everything below this line will be ingored in the

# editor text

_linebelow = "^HG: ------------------------ >8 ------------------------$"

def ishunk(x):

    hunkclasses = (crecordmod.uihunk, patch.recordhunk)

    return isinstance(x, hunkclasses)

def newandmodified(chunks, originalchunks):

    newlyaddedandmodifiedfiles = set()

    for chunk in chunks:

        if ishunk(chunk) and chunk.header.isnewfile() and chunk not in \

            originalchunks:

            newlyaddedandmodifiedfiles.add(chunk.header.filename())

    return newlyaddedandmodifiedfiles

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(r'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, operation=None):

    try:

        if usecurses:

            if testfile:

                recordfn = crecordmod.testdecorator(

                    testfile, crecordmod.testchunkselector)

            else:

                recordfn = crecordmod.chunkselector

            return crecordmod.filterpatch(ui, originalhunks, recordfn,

                                          operation)

    except crecordmod.fallbackerror as e:

        ui.warn('%s\n' % e.message)

        ui.warn(_('falling back to text mode\n'))

    return patch.filterpatch(ui, originalhunks, operation)

def recordfilter(ui, originalhunks, operation=None):

    """ Prompts the user to filter the originalhunks and return a list of

    selected hunks.

    *operation* is used for to build ui messages to indicate the user what

    kind of filtering they are doing: reverting, committing, shelving, etc.

    (see patch.filterpatch).

    """

    usecurses = crecordmod.checkcurses(ui)

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

    oldwrite = setupwrapcolorwrite(ui)

    try:

        newchunks, newopts = filterchunks(ui, originalhunks, usecurses,

                                          testfile, operation)

    finally:

        ui.write = oldwrite

    return newchunks, newopts

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

            filterfn, *pats, **opts):

    opts = pycompat.byteskwargs(opts)

    if not ui.interactive():

        if cmdsuggest:

            msg = _('running non-interactively, use %s instead') % cmdsuggest

        else:

            msg = _('running non-interactively')

        raise error.Abort(msg)

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

        wctx = repo[None]

        merge = len(wctx.parents()) > 1

        if merge:

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

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

        def fail(f, msg):

            raise error.Abort('%s: %s' % (f, msg))

        force = opts.get('force')

        if not force:

            vdirs = []

            match.explicitdir = vdirs.append

            match.bad = fail

        status = repo.status(match=match)

        if not force:

            repo.checkcommitpatterns(wctx, vdirs, match, status, fail)

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

        diffopts.nodates = True

        diffopts.git = True

        diffopts.showfunc = True

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

        originalchunks = patch.parsepatch(originaldiff)

        # 1. filter patch, since we are intending to apply subset of it

        try:

            chunks, newopts = filterfn(ui, originalchunks)

        except error.PatchError as err:

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

        opts.update(newopts)

        # We need to keep a backup of files that have been newly added and

        # modified during the recording process because there is a previous

        # version without the edit in the workdir

        newlyaddedandmodifiedfiles = newandmodified(chunks, originalchunks)

        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

        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 \

                    newlyaddedandmodifiedfiles]

        backups = {}

        if tobackup:

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

            try:

                os.mkdir(backupdir)

            except OSError as err:

                if err.errno != errno.EEXIST:

                    raise

        try:

            # backup continues

            for f in tobackup:

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

                                               dir=backupdir)

                os.close(fd)

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

                util.copyfile(repo.wjoin(f), tmpname, copystat=True)

                backups[f] = tmpname

            fp = stringio()

            for c in chunks:

                fname = c.filename()

                if fname in backups:

                    c.write(fp)

            dopatch = fp.tell()

            fp.seek(0)

            # 2.5 optionally review / modify patch in text editor

            if opts.get('review', False):

                patchtext = (crecordmod.diffhelptext

                             + crecordmod.patchhelptext

                             + fp.read())

                reviewedpatch = ui.edit(patchtext, "",

                                        action="diff",

                                        repopath=repo.path)

                fp.truncate(0)

                fp.write(reviewedpatch)

                fp.seek(0)

            [os.unlink(repo.wjoin(c)) for c in newlyaddedandmodifiedfiles]

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

            if backups:

                # Equivalent to hg.revert

                m = scmutil.matchfiles(repo, backups.keys())

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

                        False, True, matcher=m)

            # 3b. (apply)

            if dopatch:

                try:

                    ui.debug('applying patch\n')

                    ui.debug(fp.getvalue())

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

                except error.PatchError as err:

                    raise error.Abort(pycompat.bytestr(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]

            return commitfunc(ui, repo, *newfiles, **pycompat.strkwargs(opts))

        finally:

            # 5. finally restore backed-up files

            try:

                dirstate = repo.dirstate

                for realname, tmpname in backups.iteritems():

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

                    if dirstate[realname] == 'n':

                        # without normallookup, restoring timestamp

                        # may cause partially committed files

                        # to be treated as unmodified

                        dirstate.normallookup(realname)

                    # copystat=True 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.

                    util.copyfile(tmpname, repo.wjoin(realname), copystat=True)

                    os.unlink(tmpname)

                if tobackup:

                    os.rmdir(backupdir)

            except OSError:

                pass

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

        with repo.wlock():

            return recordfunc(ui, repo, message, match, opts)

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

class dirnode(object):

    """

    Represent a directory in user working copy with information required for

    the purpose of tersing its status.

    path is the path to the directory, without a trailing '/'

    statuses is a set of statuses of all files in this directory (this includes

    all the files in all the subdirectories too)

    files is a list of files which are direct child of this directory

    subdirs is a dictionary of sub-directory name as the key and it's own

    dirnode object as the value

    """

    def __init__(self, dirpath):

        self.path = dirpath

        self.statuses = set([])

        self.files = []

        self.subdirs = {}

    def _addfileindir(self, filename, status):

        """Add a file in this directory as a direct child."""

        self.files.append((filename, status))

    def addfile(self, filename, status):

        """

        Add a file to this directory or to its direct parent directory.

        If the file is not direct child of this directory, we traverse to the

        directory of which this file is a direct child of and add the file

        there.

        """

        # the filename contains a path separator, it means it's not the direct

        # child of this directory

        if '/' in filename:

            subdir, filep = filename.split('/', 1)

            # does the dirnode object for subdir exists

            if subdir not in self.subdirs:

                subdirpath = pathutil.join(self.path, subdir)

                self.subdirs[subdir] = dirnode(subdirpath)

            # try adding the file in subdir

            self.subdirs[subdir].addfile(filep, status)

        else:

            self._addfileindir(filename, status)

        if status not in self.statuses:

            self.statuses.add(status)

    def iterfilepaths(self):

        """Yield (status, path) for files directly under this directory."""

        for f, st in self.files:

            yield st, pathutil.join(self.path, f)

    def tersewalk(self, terseargs):

        """

        Yield (status, path) obtained by processing the status of this

        dirnode.

        terseargs is the string of arguments passed by the user with `--terse`

        flag.

        Following are the cases which can happen:

        1) All the files in the directory (including all the files in its

        subdirectories) share the same status and the user has asked us to terse

        that status. -> yield (status, dirpath).  dirpath will end in '/'.

        2) Otherwise, we do following: