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

#                Octobus <contact@octobus.net>

#

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

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

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

The evolve extension containts an experimental new protocol to discover common

markers between local and remote repositories.

"Large" repositories (hundreds of thousands) will take some time to warm the

necessary cache. Some key algorithm has a naive implementation that can result

in large memory or CPU Load.

The following config controls the new protocol::

  [experimental]

  # enable new discovery protocol

  # default to "yes"

  obshashrange = yes

  # control cache warming at the end of transaction

  #   yes:  warm all caches at the end of each transaction

  #         (recommended for server),

  #   off:  warm no caches at the end of transaction,

  #         (no cache overhead during transaction,

  #          but cache will be warm from scratch on usage)

  #   auto: warm cache at the end of server side transaction(ie: push)

  #         (default).

  obshashrange.warm-cache = 'auto'

When you switch to using this protocol, we recommand that you explicitly warm

cache for your server side repositories.::

  $ hg debugupdatecache

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 deployment 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 might be useful 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 closest 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. Depending 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

===========

Rewriting changesets might introduce instability.

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

Orphans are changesets left behind when their ancestors are rewritten.

Divergence has two variants:

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

  lead to different results.

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

  becomes public.

It is 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 sys

import struct

try:

    from mercurial import registrar

    registrar.templatekeyword # new in hg-3.8

except ImportError:

    from . import metadata

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

                      min(metadata.testedwith.split()))

import mercurial

from mercurial import util

from mercurial import obsolete

from mercurial import (

    bookmarks as bookmarksmod,

    cmdutil,

    commands,

    context,

    dirstate,

    error,

    help,

    hg,

    lock as lockmod,

    node,

    patch,

    pycompat,

    revset,

    scmutil,

)

from mercurial.i18n import _

from mercurial.node import nullid

from . import (

    compat,

    debugcmd,

    cmdrewrite,

    state,

    evolvecmd,

    exthelper,

    metadata,

    obscache,

    obsexchange,

    obshashtree,

    obshistory,

    rewind,

    safeguard,

    templatekw,

    utility,

)

TROUBLES = compat.TROUBLES

__version__ = metadata.__version__

testedwith = metadata.testedwith

minimumhgversion = metadata.minimumhgversion

buglink = metadata.buglink

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

              'evolve.operation': 'bold'

              }

_pack = struct.pack

_unpack = struct.unpack

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

# This extension contains the following code

#

# - Extension Helper code

# - Obsolescence cache

# - ...

# - Older format compat

eh = exthelper.exthelper()

eh.merge(debugcmd.eh)

eh.merge(evolvecmd.eh)

eh.merge(obsexchange.eh)

eh.merge(obshashtree.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)

eh.merge(rewind.eh)

uisetup = eh.finaluisetup

extsetup = eh.finalextsetup

reposetup = eh.finalreposetup

cmdtable = eh.cmdtable

configtable = eh.configtable

revsetpredicate = eh.revsetpredicate

templatekeyword = eh.templatekeyword

# Configuration

eh.configitem('experimental', 'evolutioncommands', [])

eh.configitem('experimental', 'evolution.allnewcommands', None)

eh.configitem('experimental', 'prunestrip', False)

# 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 = repo.ui.configlist('experimental', 'evolution')

    if not evolveopts:

        evolveopts = ['all']

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

    if obsolete.isenabled(repo, 'exchange'):

        # if no config explicitly set, disable bundle1

        if not isinstance(repo.ui.config('server', 'bundle1'), bytes):

            repo.ui.setconfig('server', 'bundle1', False)

    class trdescrepo(repo.__class__):

        def transaction(self, desc, *args, **kwargs):

            tr = super(trdescrepo, self).transaction(desc, *args, **kwargs)

            tr.desc = desc

            return tr

    repo.__class__ = trdescrepo

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