# mq.py - patch queues for mercurial

#

# Copyright 2005, 2006 Chris Mason <mason@suse.com>

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

'''manage a stack of patches

This extension lets you work with a stack of patches in a Mercurial

repository. It manages two stacks of patches - all known patches, and

applied patches (subset of known patches).

Known patches are represented as patch files in the .hg/patches

directory. Applied patches are both patch files and changesets.

Common tasks (use :hg:`help COMMAND` for more details)::

  create new patch                          qnew

  import existing patch                     qimport

  print patch series                        qseries

  print applied patches                     qapplied

  add known patch to applied stack          qpush

  remove patch from applied stack           qpop

  refresh contents of top applied patch     qrefresh

By default, mq will automatically use git patches when required to

avoid losing file mode changes, copy records, binary files or empty

files creations or deletions. This behavior can be configured with::

  [mq]

  git = auto/keep/yes/no

If set to 'keep', mq will obey the [diff] section configuration while

preserving existing git patches upon qrefresh. If set to 'yes' or

'no', mq will override the [diff] section and always generate git or

regular patches, possibly losing data in the second case.

It may be desirable for mq changesets to be kept in the secret phase (see

:hg:`help phases`), which can be enabled with the following setting::

  [mq]

  secret = True

You will by default be managing a patch queue named "patches". You can

create other, independent patch queues with the :hg:`qqueue` command.

If the working directory contains uncommitted files, qpush, qpop and

qgoto abort immediately. If -f/--force is used, the changes are

discarded. Setting::

  [mq]

  keepchanges = True

make them behave as if --keep-changes were passed, and non-conflicting

local changes will be tolerated and preserved. If incompatible options

such as -f/--force or --exact are passed, this setting is ignored.

This extension used to provide a strip command. This command now lives

in the strip extension.

'''

from __future__ import absolute_import, print_function

import errno

import os

import re

import shutil

import sys

from mercurial.i18n import _

from mercurial.node import (

    bin,

    hex,

    nullrev,

    short,

)

from mercurial.pycompat import (

    delattr,

    getattr,

    open,

)

from mercurial import (

    cmdutil,

    commands,

    dirstateguard,

    encoding,

    error,

    extensions,

    hg,

    localrepo,

    lock as lockmod,

    logcmdutil,

    patch as patchmod,

    phases,

    pycompat,

    registrar,

    revsetlang,

    scmutil,

    smartset,

    strip,

    subrepoutil,

    util,

    vfs as vfsmod,

)

from mercurial.utils import (

    dateutil,

    stringutil,

    urlutil,

)

release = lockmod.release

seriesopts = [(b's', b'summary', None, _(b'print first line of patch header'))]

cmdtable = {}

command = registrar.command(cmdtable)

# Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for

# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should

# be specifying the version(s) of Mercurial they are tested with, or

# leave the attribute unspecified.

testedwith = b'ships-with-hg-core'

configtable = {}

configitem = registrar.configitem(configtable)

configitem(

    b'mq',

    b'git',

    default=b'auto',

)

configitem(

    b'mq',

    b'keepchanges',

    default=False,

)

configitem(

    b'mq',

    b'plain',

    default=False,

)

configitem(

    b'mq',

    b'secret',

    default=False,

)

# force load strip extension formerly included in mq and import some utility

try:

    extensions.find(b'strip')

except KeyError:

    # note: load is lazy so we could avoid the try-except,

    # but I (marmoute) prefer this explicit code.

    class dummyui(object):

        def debug(self, msg):

            pass

        def log(self, event, msgfmt, *msgargs, **opts):

            pass

    extensions.load(dummyui(), b'strip', b'')

strip = strip.strip

def checksubstate(repo, baserev=None):

    """return list of subrepos at a different revision than substate.

    Abort if any subrepos have uncommitted changes."""

    inclsubs = []

    wctx = repo[None]

    if baserev:

        bctx = repo[baserev]

    else:

        bctx = wctx.p1()

    for s in sorted(wctx.substate):

        wctx.sub(s).bailifchanged(True)

        if s not in bctx.substate or bctx.sub(s).dirty():

            inclsubs.append(s)

    return inclsubs

# Patch names looks like unix-file names.

# They must be joinable with queue directory and result in the patch path.

normname = util.normpath

class statusentry(object):

    def __init__(self, node, name):

        self.node, self.name = node, name

    def __bytes__(self):

        return hex(self.node) + b':' + self.name

    __str__ = encoding.strmethod(__bytes__)

    __repr__ = encoding.strmethod(__bytes__)

# The order of the headers in 'hg export' HG patches:

HGHEADERS = [

    #   '# HG changeset patch',

    b'# User ',

    b'# Date ',

    b'#      ',

    b'# Branch ',

    b'# Node ID ',

    b'# Parent  ',  # can occur twice for merges - but that is not relevant for mq

]

# The order of headers in plain 'mail style' patches:

PLAINHEADERS = {

    b'from': 0,

    b'date': 1,

    b'subject': 2,

}

def inserthgheader(lines, header, value):

    """Assuming lines contains a HG patch header, add a header line with value.

    >>> try: inserthgheader([], b'# Date ', b'z')

    ... except ValueError as inst: print("oops")

    oops

    >>> inserthgheader([b'# HG changeset patch'], b'# Date ', b'z')

    ['# HG changeset patch', '# Date z']

    >>> inserthgheader([b'# HG changeset patch', b''], b'# Date ', b'z')

    ['# HG changeset patch', '# Date z', '']

    >>> inserthgheader([b'# HG changeset patch', b'# User y'], b'# Date ', b'z')

    ['# HG changeset patch', '# User y', '# Date z']

    >>> inserthgheader([b'# HG changeset patch', b'# Date x', b'# User y'],

    ...                b'# User ', b'z')

    ['# HG changeset patch', '# Date x', '# User z']

    >>> inserthgheader([b'# HG changeset patch', b'# Date y'], b'# Date ', b'z')

    ['# HG changeset patch', '# Date z']

    >>> inserthgheader([b'# HG changeset patch', b'', b'# Date y'],

    ...                b'# Date ', b'z')

    ['# HG changeset patch', '# Date z', '', '# Date y']

    >>> inserthgheader([b'# HG changeset patch', b'# Parent  y'],

    ...                b'# Date ', b'z')

    ['# HG changeset patch', '# Date z', '# Parent  y']

    """

    start = lines.index(b'# HG changeset patch') + 1

    newindex = HGHEADERS.index(header)

    bestpos = len(lines)

    for i in range(start, len(lines)):

        line = lines[i]

        if not line.startswith(b'# '):

            bestpos = min(bestpos, i)

            break

        for lineindex, h in enumerate(HGHEADERS):

            if line.startswith(h):

                if lineindex == newindex:

                    lines[i] = header + value

                    return lines

                if lineindex > newindex:

                    bestpos = min(bestpos, i)

                break  # next line

    lines.insert(bestpos, header + value)

    return lines

def insertplainheader(lines, header, value):

    """For lines containing a plain patch header, add a header line with value.

    >>> insertplainheader([], b'Date', b'z')

    ['Date: z']

    >>> insertplainheader([b''], b'Date', b'z')

    ['Date: z', '']

    >>> insertplainheader([b'x'], b'Date', b'z')

    ['Date: z', '', 'x']

    >>> insertplainheader([b'From: y', b'x'], b'Date', b'z')

    ['From: y', 'Date: z', '', 'x']

    >>> insertplainheader([b' date : x', b' from : y', b''], b'From', b'z')

    [' date : x', 'From: z', '']

    >>> insertplainheader([b'', b'Date: y'], b'Date', b'z')

    ['Date: z', '', 'Date: y']

    >>> insertplainheader([b'foo: bar', b'DATE: z', b'x'], b'From', b'y')

    ['From: y', 'foo: bar', 'DATE: z', '', 'x']

    """

    newprio = PLAINHEADERS[header.lower()]

    bestpos = len(lines)

    for i, line in enumerate(lines):

        if b':' in line:

            lheader = line.split(b':', 1)[0].strip().lower()

            lprio = PLAINHEADERS.get(lheader, newprio + 1)

            if lprio == newprio:

                lines[i] = b'%s: %s' % (header, value)

                return lines

            if lprio > newprio and i < bestpos:

                bestpos = i

        else:

            if line:

                lines.insert(i, b'')

            if i < bestpos:

                bestpos = i

            break

    lines.insert(bestpos, b'%s: %s' % (header, value))

    return lines

class patchheader(object):

    def __init__(self, pf, plainmode=False):

        def eatdiff(lines):

            while lines:

                l = lines[-1]

                if (

                    l.startswith(b"diff -")

                    or l.startswith(b"Index:")

                    or l.startswith(b"===========")

                ):

                    del lines[-1]

                else:

                    break

        def eatempty(lines):

            while lines:

                if not lines[-1].strip():

                    del lines[-1]

                else:

                    break

        message = []

        comments = []

        user = None

        date = None

        parent = None

        format = None

        subject = None

        branch = None

        nodeid = None

        diffstart = 0

        for line in open(pf, b'rb'):

            line = line.rstrip()

            if line.startswith(b'diff --git') or (

                diffstart and line.startswith(b'+++ ')

            ):

                diffstart = 2

                break

            diffstart = 0  # reset

            if line.startswith(b"--- "):

                diffstart = 1

                continue

            elif format == b"hgpatch":

                # parse values when importing the result of an hg export

                if line.startswith(b"# User "):

                    user = line[7:]

                elif line.startswith(b"# Date "):

                    date = line[7:]

                elif line.startswith(b"# Parent "):

                    parent = line[9:].lstrip()  # handle double trailing space

                elif line.startswith(b"# Branch "):

                    branch = line[9:]

                elif line.startswith(b"# Node ID "):

                    nodeid = line[10:]

                elif not line.startswith(b"# ") and line:

                    message.append(line)

                    format = None

            elif line == b'# HG changeset patch':

                message = []

                format = b"hgpatch"

            elif format != b"tagdone" and (

                line.startswith(b"Subject: ") or line.startswith(b"subject: ")

            ):

                subject = line[9:]

                format = b"tag"

            elif format != b"tagdone" and (

                line.startswith(b"From: ") or line.startswith(b"from: ")

            ):

                user = line[6:]

                format = b"tag"

            elif format != b"tagdone" and (

                line.startswith(b"Date: ") or line.startswith(b"date: ")

            ):

                date = line[6:]

                format = b"tag"

            elif format == b"tag" and line == b"":

                # when looking for tags (subject: from: etc) they

                # end once you find a blank line in the source

                format = b"tagdone"

            elif message or line:

                message.append(line)

            comments.append(line)

        eatdiff(message)

        eatdiff(comments)

        # Remember the exact starting line of the patch diffs before consuming

        # empty lines, for external use by TortoiseHg and others

        self.diffstartline = len(comments)

        eatempty(message)

        eatempty(comments)

        # make sure message isn't empty

        if format and format.startswith(b"tag") and subject:

            message.insert(0, subject)

        self.message = message

        self.comments = comments

        self.user = user

        self.date = date

        self.parent = parent

        # nodeid and branch are for external use by TortoiseHg and others