# 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

The initial cache warming is currently a bit slow. To make sure it is build you

can run the following commands in your repository::

    $ hg debugobshashrange --rev 'head()

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

the experiment. It is shipped with Mercurial so no extra install is needed::

    [extensions]

    blackbox =

Finally some extra options are available to help tame the experimental

implementation of some of the algorithms::

    [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

For very large repositories. it is currently recommended to disable obsmarkers

discovery (Make sure you follow release announcement to know when you can turn

it back on).

    [experimental]

    evolution.obsdiscovery = no

Effect Flag Experiment

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

Evolve also records what changed between two evolutions of a changeset. For

example, having this information is helpful to understand what changed between

an obsolete changeset and its tipmost successors.

Evolve currently records:

    - Meta changes, user, date

    - Tree movement, branch and parent, did the changeset moved?

    - Description, was the commit description edited

    - Diff, was there apart from potential diff change due to rebase a change in the diff?

These flags are lightweight and can be combined, so it's easy to see if 4

evolutions of the same changeset has just updated the description or if the

content changed and you need to review again the diff.

The effect flag recording is enabled by default in Evolve 6.4.0 so you have

nothing to do to enjoy it. Now every new evolution that you create will have

the effect flag attached.

The following config control the effect flag recording::

  [experimental]

  # uncomment to deactivate the registration of effect flags in obs markers

  # evolution.effect-flags = false

You can display the effect flags with the command obslog, so if you have a

changeset and you update only the message, you will see:

    $ hg commit -m "WIP

    $ hg commit -m "A better commit message!"

    $ hg obslog .

   @  8e9045855628 (3133) A better commit message!

   |

   x  7863a5bb5763 (3132) WIP

        rewritten(description) by Boris Feld <boris.feld@octobus.net> (Fri Jun 02 12:00:24 2017 +0200) as 8e9045855628

Servers does not need to activate the effect flag recording. Effect flags that

you create will not cause interference with other clients or servers without

the effect flag recording.

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

Instability

==========

(note: the vocabulary is in the process of being updated)

Rewriting changesets might introduce instability (currently 'trouble').

There are two main kinds of instability: orphaning and diverging.

Orphans are changesets left behind when their ancestors are rewritten, (currently: 'unstable').

Divergence has two variants:

* Content-divergence occurs when independent rewrites of the same changesets

  lead to different results. (currently: 'divergent')

* Phase-divergence occurs when the old (obsolete) version of a changeset

  becomes public. (currently: 'bumped')

If it possible to prevent local creation of orphans by using the following config::

    [experimental]

    evolution=createmarkers,allnewcommands,exchange

You can also enable that option explicitly::

    [experimental]

    evolution=createmarkers,allnewcommands,allowunstable,exchange

or simply::

    [experimental]

    evolution=all

""".strip()

import os

import sys

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 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 mergetoolopts

from mercurial.i18n import _

from mercurial.node import nullid

from . import (

    checkheads,

    compat,

    debugcmd,

    cmdrewrite,

    exthelper,

    metadata,

    obscache,

    obsexchange,

    obshistory,

    rewriteutil,

    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

shorttemplate = utility.shorttemplate

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)

commitopts3 = cmdrewrite.commitopts3

interactiveopt = cmdrewrite.interactiveopt

_bookmarksupdater = rewriteutil.bookmarksupdater

rewrite = rewriteutil.rewrite

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

eh.merge(cmdrewrite.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: