# 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 copy as copymod

import errno

import os

import re

from .i18n import _

from .node import (

    hex,

    nullid,

    nullrev,

    short,

)

from .pycompat import (

    getattr,

    open,

    setattr,

)

from . import (

    bookmarks,

    changelog,

    copies,

    crecord as crecordmod,

    dirstateguard,

    encoding,

    error,

    formatter,

    logcmdutil,

    match as matchmod,

    merge as mergemod,

    mergeutil,

    obsolete,

    patch,

    pathutil,

    phases,

    pycompat,

    repair,

    revlog,

    rewriteutil,

    scmutil,

    smartset,

    state as statemod,

    subrepoutil,

    templatekw,

    templater,

    util,

    vfs as vfsmod,

)

from .utils import (

    dateutil,

    stringutil,

)

if pycompat.TYPE_CHECKING:

    from typing import (

        Any,

        Dict,

    )

    for t in (Any, Dict):

        assert t

stringio = util.stringio

# templates of common command options

dryrunopts = [

    (b'n', b'dry-run', None, _(b'do not perform actions, just print output')),

]

confirmopts = [

    (b'', b'confirm', None, _(b'ask before applying actions')),

]

remoteopts = [

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

    (

        b'',

        b'remotecmd',

        b'',

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

        _(b'CMD'),

    ),

    (

        b'',

        b'insecure',

        None,

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

    ),

]

walkopts = [

    (

        b'I',

        b'include',

        [],

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

        _(b'PATTERN'),

    ),

    (

        b'X',

        b'exclude',

        [],

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

        _(b'PATTERN'),

    ),

]

commitopts = [

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

    (b'l', b'logfile', b'', _(b'read commit message from file'), _(b'FILE')),

]

commitopts2 = [

    (

        b'd',

        b'date',

        b'',

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

        _(b'DATE'),

    ),

    (

        b'u',

        b'user',

        b'',

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

        _(b'USER'),

    ),

]

commitopts3 = [

    (b'D', b'currentdate', None, _(b'record the current date as commit date')),

    (b'U', b'currentuser', None, _(b'record the current user as committer')),

]

formatteropts = [

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

]

templateopts = [

    (

        b'',

        b'style',

        b'',

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

        _(b'STYLE'),

    ),

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

]

logopts = [

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

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

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

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

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

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

] + templateopts

diffopts = [

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

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

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

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

]

diffwsopts = [

    (

        b'w',

        b'ignore-all-space',

        None,

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

    ),

    (

        b'b',

        b'ignore-space-change',

        None,

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

    ),

    (

        b'B',

        b'ignore-blank-lines',

        None,

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

    ),

    (

        b'Z',

        b'ignore-space-at-eol',

        None,

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

    ),

]

diffopts2 = (

    [

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

        (

            b'p',

            b'show-function',

            None,

            _(b'show which function each change is in'),

        ),

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

    ]

    + diffwsopts

    + [

        (

            b'U',

            b'unified',

            b'',

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

            _(b'NUM'),

        ),

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

        (

            b'',

            b'root',

            b'',

            _(b'produce diffs relative to subdirectory'),

            _(b'DIR'),

        ),

    ]

)

mergetoolopts = [

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

]

similarityopts = [

    (

        b's',

        b'similarity',

        b'',

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

        _(b'SIMILARITY'),

    )

]

subrepoopts = [(b'S', b'subrepos', None, _(b'recurse into subrepositories'))]

debugrevlogopts = [

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

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

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

]

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

# editor text

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

def resolvecommitoptions(ui, opts):

    """modify commit options dict to handle related options

    The return value indicates that ``rewrite.update-timestamp`` is the reason

    the ``date`` option is set.

    """

    if opts.get(b'date') and opts.get(b'currentdate'):

        raise error.Abort(_(b'--date and --currentdate are mutually exclusive'))

    if opts.get(b'user') and opts.get(b'currentuser'):

        raise error.Abort(_(b'--user and --currentuser are mutually exclusive'))

    datemaydiffer = False  # date-only change should be ignored?

    if opts.get(b'currentdate'):

        opts[b'date'] = b'%d %d' % dateutil.makedate()

    elif (

        not opts.get(b'date')

        and ui.configbool(b'rewrite', b'update-timestamp')

        and opts.get(b'currentdate') is None

    ):

        opts[b'date'] = b'%d %d' % dateutil.makedate()

        datemaydiffer = True

    if opts.get(b'currentuser'):

        opts[b'user'] = ui.username()

    return datemaydiffer

def checknotesize(ui, opts):

    """ make sure note is of valid format """

    note = opts.get(b'note')

    if not note:

        return

    if len(note) > 255:

        raise error.Abort(_(b"cannot store a note of more than 255 bytes"))

    if b'\n' in note:

        raise error.Abort(_(b"note cannot contain a newline"))

def ishunk(x):

    hunkclasses = (crecordmod.uihunk, patch.recordhunk)

    return isinstance(x, hunkclasses)

def newandmodified(chunks, originalchunks):

    newlyaddedandmodifiedfiles = set()

    alsorestore = set()

    for chunk in chunks:

        if (

            ishunk(chunk)

            and chunk.header.isnewfile()

            and chunk not in originalchunks

        ):

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

            alsorestore.update(

                set(chunk.header.files()) - {chunk.header.filename()}

            )

    return newlyaddedandmodifiedfiles, alsorestore

def parsealiases(cmd):

    return cmd.split(b"|")

def setupwrapcolorwrite(ui):

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

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

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

        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, match, 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(b'%s\n' % e.message)  # pytype: disable=attribute-error

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

    return patch.filterpatch(ui, originalhunks, match, operation)

def recordfilter(ui, originalhunks, match, 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(b'experimental', b'crecordtest')

    oldwrite = setupwrapcolorwrite(ui)

    try:

        newchunks, newopts = filterchunks(

            ui, originalhunks, usecurses, testfile, match, operation

        )

    finally:

        ui.write = oldwrite

    return newchunks, newopts

def dorecord(

    ui, repo, commitfunc, cmdsuggest, backupall, filterfn, *pats, **opts

):