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

- enable the changeset-evolution feature for Mercurial,

- improves some aspect of the early implementation in Mercurial core,

Note that a version dedicated to server usage only (no local working copy) is

available as 'evolve.serveronly'.

While many feature related to changeset evolution are directly handled by core

this extensions contains significant additions recommended to any user of

changeset evolution.

With the extension various evolution events will display warning (new unstable

changesets, obsolete working copy parent, improved error when accessing hidden

revision, etc).

In addition, the extension contains better discovery protocol for obsolescence

markers. This means less obs-markers will have to be pushed and pulled around,

speeding up such operation.

Some improvement and bug fixes available in newer version of Mercurial are also

backported to older version of Mercurial by this extension. Some older

experimental protocol are also supported for a longer time in the extensions to

help people transitioning. (The extensions is currently compatible down to

Mercurial version 3.8).

New Config:

    [experimental]

    # Set to control the behavior when pushing draft changesets to a publishing

    # repository. Possible value:

    # * ignore: current core behavior (default)

    # * warn: proceed with the push, but issue a warning

    # * abort: abort the push

    auto-publish = ignore

    # For some large repository with few markers, the current  for obsolescence

    # markers discovery can get in the way. You can disable it with the

    # configuration option below. This means all pushes and pulls will

    # re-exchange all markers every time.

    evolution.obsdiscovery = yes

Obsolescence Markers Discovery Experiment

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

We are experimenting with a new protocol to discover common markers between

local and remote repositories. This experiment is still at an early stage but

is already raising better results than the previous version (when usable).

"Large" repositories (hundreds of thousand) are currently unsupported. Some key

algorithm has a naive implementation with too agressive caching, creating

memory consumption issue (this will get fixed).

Medium sized repositories works fine, but be prepared for a noticable initial

cache filling. for the Mercurial repository, this is around 20 seconds

The following config control the experiment::

  [experimental]

  # enable new discovery protocol

  # (needed on both client and server)

  obshashrange = yes

  # avoid cache warming after transaction

  # (recommended 'off' for developer repositories)

  # (recommended 'yes' for server (default))

  obshashrange.warm-cache = no

It is recommended to enable the blackbox extension. It gathers useful data about

    [extensions]

    blackbox =

Finally some extra options are available to help tame the experimental

    [experimental]

    # restrict cache size to reduce memory consumption

    obshashrange.lru-size = 2000 # default is 2000

    # automatically disable obshashrange related computation and capabilities

    # if the repository has more than N revisions.  This is meant to help large

    # server deployement to enable the feature on smaller repositories while

    # ensuring no large repository will get affected.

    obshashrange.max-revs = 100000 # default is None

Effect Flag Experiment

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

We are experimenting with a way to register what changed between a precursor

and its successors (content, description, parent, etc...). For example, having

this information is helpful to show what changed between an obsolete changeset

and its tipmost successors. This experiment is active by default

The following config control the experiment::

  [experimental]

  # deactivate the registration of effect flags in obs markers

  evolution.effect-flags = false

The effect flags are shown in the obslog command output without particular

configuration if you want to inspect them.

Templates

=========

Evolve ship several templates that you can use to have a better visibility

about your obs history:

  - precursors, for each obsolete changeset show the closest visible

    precursors.

  - successors, for each obsolete changeset show the closests visible

    successors. It is useful when your working directory is obsolete to see

    what are its successors. This information can also be retrieved with the

    obslog command and the --all option.

  - obsfate, for each obsolete changeset display a line summarizing what

    changed between the changeset and its successors. Dependending on the

    verbosity level (-q and -v) it display the changeset successors, the users

    that created the obsmarkers and the date range of these changes.

    The template itself is not complex, the data are basically a list of

    successortset. Each successorset is a dict with these fields:

      - "verb", how did the revision changed, pruned or rewritten for the moment

      - "users" a sorted list of users that have create obs marker between current

        changeset and one of its successor

      - "min_date" the tiniest date of the first obs marker between current

        changeset and one of its successor

      - "max_date" the biggest date between current changeset and one of its

        successor

      - "successors" a sorted list of locally know successors node ids

      - "markers" the raw list of changesets.

"""

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,

    dirstate,

    error,

    extensions,

    help,

    hg,

    lock as lockmod,

    merge,

    node,

    obsolete,

    patch,

    phases,

    revset,

    scmutil,

)

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

from mercurial.i18n import _

from mercurial.node import nullid

from . import (

    checkheads,

    compat,

    debugcmd,

    exthelper,

    metadata,

    obscache,

    obsexchange,

    obshistory,

    safeguard,

    templatekw,

    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

colortable = {'evolve.node': 'yellow',

              'evolve.user': 'green',

              'evolve.rev': 'blue',

              'evolve.short_description': '',

              'evolve.date': 'cyan',

              'evolve.current_rev': 'bold',

              'evolve.verb': '',

              }

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

eh.merge(obscache.eh)

eh.merge(obshistory.eh)

eh.merge(templatekw.eh)

eh.merge(compat.eh)

uisetup = eh.final_uisetup

extsetup = eh.final_extsetup

reposetup = eh.final_reposetup

cmdtable = eh.cmdtable

# pre hg 4.0 compat

if not util.safehasattr(dirstate.dirstate, 'parentchange'):

    import contextlib

    @contextlib.contextmanager

    def parentchange(self):

        '''Context manager for handling dirstate parents.

        If an exception occurs in the scope of the context manager,

        the incoherent dirstate won't be written when wlock is

        released.

        '''

        self._parentwriters += 1

        yield

        # Typically we want the "undo" step of a context manager in a

        # finally block so it happens even when an exception

        # occurs. In this case, however, we only want to decrement

        # parentwriters if the code in the with statement exits

        # normally, so we don't have a try/finally here on purpose.

        self._parentwriters -= 1

    dirstate.dirstate.parentchange = parentchange

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

### 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', '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':

            hgexe = ('"%s"' % util.hgexecutable())

            ui.setconfig('alias', 'grab', "! " + hgexe

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

                         + hgexe + " 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