# Copyright 2011 Peter Arrenbrecht <peter.arrenbrecht@gmail.com>

#                Logilab SA        <contact@logilab.fr>

#                Pierre-Yves David <pierre-yves.david@ens-lyon.org>

#                Patrick Mezard <patrick@mezard.eu>

#

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

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

"""extends Mercurial feature related to Changeset Evolution

This extension provides several commands to mutate history and deal with

resulting issues.

It also:

    - enables the "Changeset Obsolescence" feature of Mercurial,

    - alters core commands and extensions that rewrite history to use

      this feature,

    - improves some aspect of the early implementation in Mercurial core

"""

evolutionhelptext = """

Obsolescence markers make it possible to mark changesets that have been

deleted or superset in a new version of the changeset.

Unlike the previous way of handling such changes, by stripping the old

changesets from the repository, obsolescence markers can be propagated

between repositories. This allows for a safe and simple way of exchanging

mutable history and altering it after the fact. Changeset phases are

respected, such that only draft and secret changesets can be altered (see

:hg:`help phases` for details).

Obsolescence is tracked using "obsolete markers", a piece of metadata

tracking which changesets have been made obsolete, potential successors for

a given changeset, the moment the changeset was marked as obsolete, and the

user who performed the rewriting operation. The markers are stored

separately from standard changeset data can be exchanged without any of the

precursor changesets, preventing unnecessary exchange of obsolescence data.

The complete set of obsolescence markers describes a history of changeset

modifications that is orthogonal to the repository history of file

modifications. This changeset history allows for detection and automatic

resolution of edge cases arising from multiple users rewriting the same part

of history concurrently.

Current feature status

======================

This feature is still in development.  If you see this help, you have enabled an

extension that turned this feature on.

Obsolescence markers will be exchanged between repositories that explicitly

assert support for the obsolescence feature (this can currently only be done

via an extension).""".strip()

import os

import sys

import random

import re

import collections

import errno

import struct

try:

    import StringIO as io

    StringIO = io.StringIO

except ImportError:

    import io

    StringIO = io.StringIO

try:

    from mercurial import registrar

    registrar.templatekeyword # new in hg-3.8

except ImportError:

    from . import metadata

    raise ImportError('evolve needs version %s or above' %

                      min(metadata.testedwith.split()))

import mercurial

from mercurial import util

from mercurial import repair

from mercurial import obsolete

if not obsolete._enabled:

    obsolete._enabled = True

from mercurial import (

    bookmarks as bookmarksmod,

    cmdutil,

    commands,

    context,

    copies,

    error,

    extensions,

    help,

    hg,

    lock as lockmod,

    merge,

    node,

    patch,

    phases,

    revset,

    scmutil,

    templatekw,

)

from mercurial.commands import walkopts, commitopts, commitopts2, mergetoolopts

from mercurial.i18n import _

from mercurial.node import nullid

from . import (

    checkheads,

    debugcmd,

    obsexchange,

    exthelper,

    metadata,

    safeguard,

    utility,

)

__version__ = metadata.__version__

testedwith = metadata.testedwith

minimumhgversion = metadata.minimumhgversion

buglink = metadata.buglink

sha1re = re.compile(r'\b[0-9a-f]{6,40}\b')

# Flags for enabling optional parts of evolve

commandopt = 'allnewcommands'

obsexcmsg = utility.obsexcmsg

_pack = struct.pack

_unpack = struct.unpack

aliases, entry = cmdutil.findcmd('commit', commands.table)

interactiveopt = [['i', 'interactive', None, _('use interactive mode')]]

# This extension contains the following code

#

# - Extension Helper code

# - Obsolescence cache

# - ...

# - Older format compat

eh = exthelper.exthelper()

eh.merge(debugcmd.eh)

eh.merge(obsexchange.eh)

eh.merge(checkheads.eh)

eh.merge(safeguard.eh)

uisetup = eh.final_uisetup

extsetup = eh.final_extsetup

reposetup = eh.final_reposetup

cmdtable = eh.cmdtable

#####################################################################

### Option configuration                                          ###

#####################################################################

@eh.reposetup # must be the first of its kin.

def _configureoptions(ui, repo):

    # If no capabilities are specified, enable everything.

    # This is so existing evolve users don't need to change their config.

    evolveopts = ui.configlist('experimental', 'evolution')

    if not evolveopts:

        evolveopts = ['all']

        ui.setconfig('experimental', 'evolution', evolveopts, 'evolve')

@eh.uisetup

def _configurecmdoptions(ui):

    # Unregister evolve commands if the command capability is not specified.

    #

    # This must be in the same function as the option configuration above to

    # guarantee it happens after the above configuration, but before the

    # extsetup functions.

    evolvecommands = ui.configlist('experimental', 'evolutioncommands')

    evolveopts = ui.configlist('experimental', 'evolution')

    if evolveopts and (commandopt not in evolveopts and

                       'all' not in evolveopts):

        # We build whitelist containing the commands we want to enable

        whitelist = set()

        for cmd in evolvecommands:

            matchingevolvecommands = [e for e in cmdtable.keys() if cmd in e]

            if not matchingevolvecommands:

                raise error.Abort(_('unknown command: %s') % cmd)

            elif len(matchingevolvecommands) > 1:

                msg = _('ambiguous command specification: "%s" matches %r')

                raise error.Abort(msg % (cmd, matchingevolvecommands))

            else:

                whitelist.add(matchingevolvecommands[0])

        for disabledcmd in set(cmdtable) - whitelist:

            del cmdtable[disabledcmd]

#####################################################################

### experimental behavior                                         ###

#####################################################################

commitopts3 = [

    ('D', 'current-date', None,

     _('record the current date as commit date')),

    ('U', 'current-user', None,

     _('record the current user as committer')),

]

def _resolveoptions(ui, opts):

    """modify commit options dict to handle related options

    For now, all it does is figure out the commit date: respect -D unless

    -d was supplied.

    """

    # N.B. this is extremely similar to setupheaderopts() in mq.py

    if not opts.get('date') and opts.get('current_date'):

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

    if not opts.get('user') and opts.get('current_user'):

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

getrevs = obsolete.getrevs

#####################################################################

### Additional Utilities                                          ###

#####################################################################

# This section contains a lot of small utility function and method

# - Function to create markers

# - useful alias pstatus and pdiff (should probably go in evolve)

# - "troubles" method on changectx

# - function to travel through the obsolescence graph

# - function to find useful changeset to stabilize

### Useful alias

@eh.uisetup

def _installalias(ui):

    if ui.config('alias', 'pstatus', None) is None:

        ui.setconfig('alias', 'pstatus', 'status --rev .^', 'evolve')

    if ui.config('alias', 'pdiff', None) is None:

        ui.setconfig('alias', 'pdiff', 'diff --rev .^', 'evolve')

    if ui.config('alias', 'olog', None) is None:

        ui.setconfig('alias', 'olog', "log -r 'precursors(.)' --hidden",

                     'evolve')

    if ui.config('alias', 'odiff', None) is None:

        ui.setconfig('alias', 'odiff',

                     "diff --hidden --rev 'limit(precursors(.),1)' --rev .",

                     'evolve')

    if ui.config('alias', 'grab', None) is None:

        if os.name == 'nt':

            ui.setconfig('alias', 'grab',

                         "! " + util.hgexecutable()

                         + " rebase --dest . --rev $@ && "

                         + util.hgexecutable() + " up tip",

                         'evolve')

        else:

            ui.setconfig('alias', 'grab',

                         "! $HG rebase --dest . --rev $@ && $HG up tip",

                         'evolve')

### Troubled revset symbol

@eh.revset('troubled')

def revsettroubled(repo, subset, x):

    """``troubled()``

    Changesets with troubles.

    """

    revset.getargs(x, 0, 0, 'troubled takes no arguments')

    troubled = set()

    troubled.update(getrevs(repo, 'unstable'))

    troubled.update(getrevs(repo, 'bumped'))

    troubled.update(getrevs(repo, 'divergent'))

    troubled = revset.baseset(troubled)

    troubled.sort() # set is non-ordered, enforce order

    return subset & troubled

### Obsolescence graph

# XXX SOME MAJOR CLEAN UP TO DO HERE XXX

def _precursors(repo, s):

    """Precursor of a changeset"""

    cs = set()

    nm = repo.changelog.nodemap

    markerbysubj = repo.obsstore.precursors

    node = repo.changelog.node

    for r in s:

        for p in markerbysubj.get(node(r), ()):

            pr = nm.get(p[0])

            if pr is not None:

                cs.add(pr)

    cs -= repo.changelog.filteredrevs # nodemap has no filtering

    return cs

def _allprecursors(repo, s):  # XXX we need a better naming

    """transitive precursors of a subset"""

    node = repo.changelog.node

    toproceed = [node(r) for r in s]

    seen = set()

    allsubjects = repo.obsstore.precursors

    while toproceed:

        nc = toproceed.pop()

        for mark in allsubjects.get(nc, ()):

            np = mark[0]

            if np not in seen:

                seen.add(np)

                toproceed.append(np)

    nm = repo.changelog.nodemap

    cs = set()

    for p in seen:

        pr = nm.get(p)

        if pr is not None:

            cs.add(pr)

    cs -= repo.changelog.filteredrevs # nodemap has no filtering

    return cs

def _successors(repo, s):

    """Successors of a changeset"""

    cs = set()

    node = repo.changelog.node

    nm = repo.changelog.nodemap

    markerbyobj = repo.obsstore.successors

    for r in s:

        for p in markerbyobj.get(node(r), ()):

            for sub in p[1]:

                sr = nm.get(sub)

                if sr is not None:

                    cs.add(sr)

    cs -= repo.changelog.filteredrevs # nodemap has no filtering

    return cs

def _allsuccessors(repo, s, haltonflags=0):  # XXX we need a better naming

    """transitive successors of a subset

    haltonflags allows to provide flags which prevent the evaluation of a

    marker.  """

    node = repo.changelog.node

    toproceed = [node(r) for r in s]

    seen = set()

    allobjects = repo.obsstore.successors

    while toproceed:

        nc = toproceed.pop()

        for mark in allobjects.get(nc, ()):

            if mark[2] & haltonflags:

                continue

            for sub in mark[1]:

                if sub == nullid:

                    continue # should not be here!

                if sub not in seen:

                    seen.add(sub)

                    toproceed.append(sub)

    nm = repo.changelog.nodemap

    cs = set()

    for s in seen:

        sr = nm.get(s)

        if sr is not None:

            cs.add(sr)

    cs -= repo.changelog.filteredrevs # nodemap has no filtering

    return cs

#####################################################################

### Extending revset and template                                 ###

#####################################################################

# this section add several useful revset symbol not yet in core.

# they are subject to changes

### XXX I'm not sure this revset is useful

@eh.revset('suspended')

def revsetsuspended(repo, subset, x):

    """``suspended()``

    Obsolete changesets with non-obsolete descendants.

    """

    revset.getargs(x, 0, 0, 'suspended takes no arguments')

    suspended = revset.baseset(getrevs(repo, 'suspended'))

    suspended.sort()

    return subset & suspended

@eh.revset('precursors')

def revsetprecursors(repo, subset, x):

    """``precursors(set)``

    Immediate precursors of changesets in set.

    """

    s = revset.getset(repo, revset.fullreposet(repo), x)

    s = revset.baseset(_precursors(repo, s))

    s.sort()

    return subset & s

@eh.revset('allprecursors')

def revsetallprecursors(repo, subset, x):

    """``allprecursors(set)``

    Transitive precursors of changesets in set.

    """

    s = revset.getset(repo, revset.fullreposet(repo), x)

    s = revset.baseset(_allprecursors(repo, s))

    s.sort()

    return subset & s

@eh.revset('successors')

def revsetsuccessors(repo, subset, x):

    """``successors(set)``

    Immediate successors of changesets in set.

    """

    s = revset.getset(repo, revset.fullreposet(repo), x)

    s = revset.baseset(_successors(repo, s))

    s.sort()

    return subset & s

@eh.revset('allsuccessors')

def revsetallsuccessors(repo, subset, x):

    """``allsuccessors(set)``

    Transitive successors of changesets in set.

    """

    s = revset.getset(repo, revset.fullreposet(repo), x)

    s = revset.baseset(_allsuccessors(repo, s))

    s.sort()

    return subset & s

### template keywords

# XXX it does not handle troubles well :-/

@eh.templatekw('obsolete')

def obsoletekw(repo, ctx, templ, **args):

    """:obsolete: String. Whether the changeset is ``obsolete``.

    """

    if ctx.obsolete():

        return 'obsolete'

    return ''

@eh.templatekw('troubles')

def showtroubles(**args):

    """:troubles: List of strings. Evolution troubles affecting the changeset

    (zero or more of "unstable", "divergent" or "bumped")."""

    ctx = args['ctx']

    try:

        # specify plural= explicitly to trigger TypeError on hg < 4.2

        return templatekw.showlist('trouble', ctx.troubles(), args,

                                   plural='troubles')

    except TypeError:

        return templatekw.showlist('trouble', ctx.troubles(), plural='troubles',

                                   **args)

#####################################################################

### Various trouble warning                                       ###

#####################################################################

# This section take care of issue warning to the user when troubles appear

def _warnobsoletewc(ui, repo):