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

     2 #                Logilab SA        <contact@logilab.fr>

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

     4 #                Patrick Mezard <patrick@mezard.eu>

     5 #

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

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

     8 

     9 '''extends Mercurial feature related to Changeset Evolution

    10 

    11 This extension provides several commands to mutate history and deal with

    12 resulting issues.

    13 

    14 It also:

    15 

    16     - enables the "Changeset Obsolescence" feature of Mercurial,

    17     - alters core commands and extensions that rewrite history to use

    18       this feature,

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

    20 '''

    21 

    22 __version__ = '5.6.0'

    23 testedwith = '3.4.3 3.5.2 3.6.2 3.7.3 3.8.1 3.9 4.0 4.1'

    24 buglink = 'https://bz.mercurial-scm.org/'

    25 

    26 

    27 evolutionhelptext = """

    28 Obsolescence markers make it possible to mark changesets that have been

    29 deleted or superset in a new version of the changeset.

    30 

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

    32 changesets from the repository, obsolescence markers can be propagated

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

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

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

    36 :hg:`help phases` for details).

    37 

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

    39 tracking which changesets have been made obsolete, potential successors for

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

    41 user who performed the rewriting operation. The markers are stored

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

    43 precursor changesets, preventing unnecessary exchange of obsolescence data.

    44 

    45 The complete set of obsolescence markers describes a history of changeset

    46 modifications that is orthogonal to the repository history of file

    47 modifications. This changeset history allows for detection and automatic

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

    49 of history concurrently.

    50 

    51 Current feature status

    52 ======================

    53 

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

    55 extension that turned this feature on.

    56 

    57 Obsolescence markers will be exchanged between repositories that explicitly

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

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

    60 

    61 

    62 import sys, os

    63 import random

    64 try:

    65     import StringIO as io

    66     StringIO = io.StringIO

    67 except ImportError:

    68     import io

    69     StringIO = io.StringIO

    70 import re

    71 import collections

    72 import socket

    73 import errno

    74 import hashlib

    75 import struct

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

    77 

    78 import mercurial

    79 from mercurial import util

    80 from mercurial import repair

    81 

    82 try:

    83     from mercurial import obsolete

    84     if not obsolete._enabled:

    85         obsolete._enabled = True

    86     from mercurial import wireproto

    87     gboptslist = getattr(wireproto, 'gboptslist', None)

    88     gboptsmap = getattr(wireproto, 'gboptsmap', None)

    89 except (ImportError, AttributeError):

    90     gboptslist = gboptsmap = None

    91 

    92 # Flags for enabling optional parts of evolve

    93 commandopt = 'allnewcommands'

    94 

    95 from mercurial import bookmarks as bookmarksmod

    96 from mercurial import cmdutil

    97 from mercurial import commands

    98 from mercurial import context

    99 from mercurial import copies

   100 from mercurial import error

   101 from mercurial import exchange

   102 from mercurial import extensions

   103 from mercurial import help

   104 from mercurial import httppeer

   105 from mercurial import hg

   106 from mercurial import lock as lockmod

   107 from mercurial import merge

   108 from mercurial import node

   109 from mercurial import phases

   110 from mercurial import patch

   111 from mercurial import revset

   112 from mercurial import scmutil

   113 from mercurial import templatekw

   114 from mercurial.i18n import _

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

   116 from mercurial.node import nullid

   117 from mercurial import wireproto

   118 from mercurial import localrepo

   119 from mercurial.hgweb import hgweb_mod

   120 

   121 cmdtable = {}

   122 command = cmdutil.command(cmdtable)

   123 

   124 _pack = struct.pack

   125 _unpack = struct.unpack

   126 

   127 if gboptsmap is not None:

   128     memfilectx = context.memfilectx

   129 elif gboptslist is not None:

   130     oldmemfilectx = context.memfilectx

   131     def memfilectx(repo, *args, **kwargs):

   132         return oldmemfilectx(*args, **kwargs)

   133 else:

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

   135                       min(testedwith.split()))

   136 

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

   138 hasinteractivemode = any(['interactive' in e for e in entry[1]])

   139 if hasinteractivemode:

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

   141 else:

   142     interactiveopt = []

   143 # This extension contains the following code

   144 #

   145 # - Extension Helper code

   146 # - Obsolescence cache

   147 # - ...

   148 # - Older format compat

   149 

   150 

   151 #####################################################################

   152 ### Extension helper                                              ###

   153 #####################################################################

   154 

   155 class exthelper(object):

   156     """Helper for modular extension setup

   157 

   158     A single helper should be instantiated for each extension. Helper

   159     methods are then used as decorators for various purpose.

   160 

   161     All decorators return the original function and may be chained.

   162     """

   163 

   164     def __init__(self):

   165         self._uicallables = []

   166         self._extcallables = []

   167         self._repocallables = []

   168         self._revsetsymbols = []

   169         self._templatekws = []

   170         self._commandwrappers = []

   171         self._extcommandwrappers = []

   172         self._functionwrappers = []

   173         self._duckpunchers = []

   174 

   175     def final_uisetup(self, ui):

   176         """Method to be used as the extension uisetup

   177 

   178         The following operations belong here:

   179 

   180         - Changes to ui.__class__ . The ui object that will be used to run the

   181           command has not yet been created. Changes made here will affect ui

   182           objects created after this, and in particular the ui that will be

   183           passed to runcommand

   184         - Command wraps (extensions.wrapcommand)

   185         - Changes that need to be visible to other extensions: because

   186           initialization occurs in phases (all extensions run uisetup, then all

   187           run extsetup), a change made here will be visible to other extensions

   188           during extsetup

   189         - Monkeypatch or wrap function (extensions.wrapfunction) of dispatch

   190           module members

   191         - Setup of pre-* and post-* hooks

   192         - pushkey setup

   193         """

   194         for cont, funcname, func in self._duckpunchers:

   195             setattr(cont, funcname, func)

   196         for command, wrapper, opts in self._commandwrappers:

   197             entry = extensions.wrapcommand(commands.table, command, wrapper)

   198             if opts:

   199                 for short, long, val, msg in opts:

   200                     entry[1].append((short, long, val, msg))

   201         for cont, funcname, wrapper in self._functionwrappers:

   202             extensions.wrapfunction(cont, funcname, wrapper)

   203         for c in self._uicallables:

   204             c(ui)

   205 

   206     def final_extsetup(self, ui):

   207         """Method to be used as a the extension extsetup

   208 

   209         The following operations belong here:

   210 

   211         - Changes depending on the status of other extensions. (if

   212           extensions.find('mq'))

   213         - Add a global option to all commands

   214         - Register revset functions

   215         """

   216         knownexts = {}

   217         for name, symbol in self._revsetsymbols:

   218             revset.symbols[name] = symbol

   219         for name, kw in self._templatekws:

   220             templatekw.keywords[name] = kw

   221         for ext, command, wrapper, opts in self._extcommandwrappers:

   222             if ext not in knownexts:

   223                 try:

   224                     e = extensions.find(ext)

   225                 except KeyError:

   226                     # Extension isn't enabled, so don't bother trying to wrap

   227                     # it.

   228                     continue

   229                 knownexts[ext] = e.cmdtable

   230             entry = extensions.wrapcommand(knownexts[ext], command, wrapper)

   231             if opts:

   232                 for short, long, val, msg in opts:

   233                     entry[1].append((short, long, val, msg))

   234 

   235         for c in self._extcallables:

   236             c(ui)

   237 

   238     def final_reposetup(self, ui, repo):

   239         """Method to be used as the extension reposetup

   240 

   241         The following operations belong here:

   242 

   243         - All hooks but pre-* and post-*

   244         - Modify configuration variables

   245         - Changes to repo.__class__, repo.dirstate.__class__

   246         """

   247         for c in self._repocallables:

   248             c(ui, repo)

   249 

   250     def uisetup(self, call):

   251         """Decorated function will be executed during uisetup

   252 

   253         example::

   254 

   255             @eh.uisetup

   256             def setupbabar(ui):

   257                 print 'this is uisetup!'

   258         """

   259         self._uicallables.append(call)

   260         return call

   261 

   262     def extsetup(self, call):

   263         """Decorated function will be executed during extsetup

   264 

   265         example::

   266 

   267             @eh.extsetup

   268             def setupcelestine(ui):

   269                 print 'this is extsetup!'

   270         """

   271         self._extcallables.append(call)

   272         return call

   273 

   274     def reposetup(self, call):

   275         """Decorated function will be executed during reposetup

   276 

   277         example::

   278 

   279             @eh.reposetup

   280             def setupzephir(ui, repo):

   281                 print 'this is reposetup!'

   282         """

   283         self._repocallables.append(call)

   284         return call

   285 

   286     def revset(self, symbolname):

   287         """Decorated function is a revset symbol

   288 

   289         The name of the symbol must be given as the decorator argument.

   290         The symbol is added during `extsetup`.

   291 

   292         example::

   293 

   294             @eh.revset('hidden')

   295             def revsetbabar(repo, subset, x):

   296                 args = revset.getargs(x, 0, 0, 'babar accept no argument')

   297                 return [r for r in subset if 'babar' in repo[r].description()]

   298         """

   299         def dec(symbol):

   300             self._revsetsymbols.append((symbolname, symbol))

   301             return symbol

   302         return dec

   303 

   304 

   305     def templatekw(self, keywordname):

   306         """Decorated function is a template keyword

   307 

   308         The name of the keyword must be given as the decorator argument.

   309         The symbol is added during `extsetup`.

   310 

   311         example::

   312 

   313             @eh.templatekw('babar')

   314             def kwbabar(ctx):

   315                 return 'babar'

   316         """

   317         def dec(keyword):

   318             self._templatekws.append((keywordname, keyword))

   319             return keyword

   320         return dec

   321 

   322     def wrapcommand(self, command, extension=None, opts=[]):

   323         """Decorated function is a command wrapper

   324 

   325         The name of the command must be given as the decorator argument.

   326         The wrapping is installed during `uisetup`.

   327 

   328         If the second option `extension` argument is provided, the wrapping

   329         will be applied in the extension commandtable. This argument must be a

   330         string that will be searched using `extension.find` if not found and

   331         Abort error is raised. If the wrapping applies to an extension, it is

   332         installed during `extsetup`.

   333 

   334         example::

   335 

   336             @eh.wrapcommand('summary')

   337             def wrapsummary(orig, ui, repo, *args, **kwargs):

   338                 ui.note('Barry!')

   339                 return orig(ui, repo, *args, **kwargs)

   340 

   341         The `opts` argument allows specifying additional arguments for the

   342         command.

   343 

   344         """

   345         def dec(wrapper):

   346             if extension is None:

   347                 self._commandwrappers.append((command, wrapper, opts))

   348             else:

   349                 self._extcommandwrappers.append((extension, command, wrapper,

   350                     opts))

   351             return wrapper

   352         return dec

   353 

   354     def wrapfunction(self, container, funcname):

   355         """Decorated function is a function wrapper

   356 

   357         This function takes two arguments, the container and the name of the

   358         function to wrap. The wrapping is performed during `uisetup`.

   359         (there is no extension support)

   360 

   361         example::

   362 

   363             @eh.function(discovery, 'checkheads')

   364             def wrapfunction(orig, *args, **kwargs):

   365                 ui.note('His head smashed in and his heart cut out')

   366                 return orig(*args, **kwargs)

   367         """

   368         def dec(wrapper):

   369             self._functionwrappers.append((container, funcname, wrapper))

   370             return wrapper

   371         return dec

   372 

   373     def addattr(self, container, funcname):

   374         """Decorated function is to be added to the container

   375 

   376         This function takes two arguments, the container and the name of the

   377         function to wrap. The wrapping is performed during `uisetup`.

   378 

   379         example::

   380 

   381             @eh.function(context.changectx, 'babar')

   382             def babar(ctx):

   383                 return 'babar' in ctx.description

   384         """

   385         def dec(func):

   386             self._duckpunchers.append((container, funcname, func))

   387             return func

   388         return dec

   389 

   390 eh = exthelper()

   391 uisetup = eh.final_uisetup

   392 extsetup = eh.final_extsetup

   393 reposetup = eh.final_reposetup

   394 

   395 #####################################################################

   396 ### Option configuration                                          ###

   397 #####################################################################

   398 

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

   400 def _configureoptions(ui, repo):

   401     # If no capabilities are specified, enable everything.

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

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

   404     if not evolveopts:

   405         evolveopts = ['all']

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

   407 

   408 @eh.uisetup

   409 def _configurecmdoptions(ui):

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

   411     #

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

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

   414     # extsetup functions.

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

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

   417     if evolveopts and (commandopt not in evolveopts and

   418                        'all' not in evolveopts):

   419         # We build whitelist containing the commands we want to enable

   420         whitelist = set()

   421         for cmd in evolvecommands:

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

   423             if not matchingevolvecommands:

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

   425             elif len(matchingevolvecommands) > 1:

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

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

   428             else:

   429                 whitelist.add(matchingevolvecommands[0])

   430         for disabledcmd in set(cmdtable) - whitelist:

   431             del cmdtable[disabledcmd]

   432 

   433 #####################################################################

   434 ### experimental behavior                                         ###

   435 #####################################################################

   436 

   437 commitopts3 = [

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

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

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

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

   442 ]

   443 

   444 def _resolveoptions(ui, opts):

   445     """modify commit options dict to handle related options

   446 

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

   448     -d was supplied.

   449     """

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

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

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

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

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

   455 

   456 getrevs = obsolete.getrevs

   457 

   458 #####################################################################

   459 ### Additional Utilities                                          ###

   460 #####################################################################

   461 

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

   463 

   464 # - Function to create markers

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

   466 # - "troubles" method on changectx

   467 # - function to travel through the obsolescence graph

   468 # - function to find useful changeset to stabilize

   469 

   470 

   471 ### Useful alias

   472 

   473 @eh.uisetup

   474 def _installalias(ui):

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

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

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

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

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

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

   481                      'evolve')

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

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

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

   485             'evolve')

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

   487         if os.name == 'nt':

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

   489                 "! " + util.hgexecutable() + " rebase --dest . --rev $@ && "

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

   491                          'evolve')

   492         else:

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

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

   495                          'evolve')

   496 

   497 

   498 ### Troubled revset symbol

   499 

   500 @eh.revset('troubled')

   501 def revsettroubled(repo, subset, x):

   502     """``troubled()``

   503     Changesets with troubles.

   504     """

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

   506     troubled = set()

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

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

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

   510     troubled = revset.baseset(troubled)

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

   512     return subset & troubled

   513 

   514 ### Obsolescence graph

   515 

   516 # XXX SOME MAJOR CLEAN UP TO DO HERE XXX

   517 

   518 def _precursors(repo, s):

   519     """Precursor of a changeset"""

   520     cs = set()

   521     nm = repo.changelog.nodemap

   522     markerbysubj = repo.obsstore.precursors

   523     node = repo.changelog.node

   524     for r in s:

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

   526             pr = nm.get(p[0])

   527             if pr is not None:

   528                 cs.add(pr)

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

   530     return cs

   531 

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

   533     """transitive precursors of a subset"""

   534     node = repo.changelog.node

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

   536     seen = set()

   537     allsubjects = repo.obsstore.precursors

   538     while toproceed:

   539         nc = toproceed.pop()

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

   541             np = mark[0]

   542             if np not in seen:

   543                 seen.add(np)

   544                 toproceed.append(np)

   545     nm = repo.changelog.nodemap

   546     cs = set()

   547     for p in seen:

   548         pr = nm.get(p)

   549         if pr is not None:

   550             cs.add(pr)

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

   552     return cs

   553 

   554 def _successors(repo, s):

   555     """Successors of a changeset"""

   556     cs = set()

   557     node = repo.changelog.node

   558     nm = repo.changelog.nodemap

   559     markerbyobj = repo.obsstore.successors

   560     for r in s:

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

   562             for sub in p[1]:

   563                 sr = nm.get(sub)

   564                 if sr is not None:

   565                     cs.add(sr)

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

   567     return cs

   568 

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

   570     """transitive successors of a subset

   571 

   572     haltonflags allows to provide flags which prevent the evaluation of a

   573     marker.  """

   574     node = repo.changelog.node

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

   576     seen = set()

   577     allobjects = repo.obsstore.successors

   578     while toproceed:

   579         nc = toproceed.pop()

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

   581             if mark[2] & haltonflags:

   582                 continue

   583             for sub in mark[1]:

   584                 if sub == nullid:

   585                     continue # should not be here!

   586                 if sub not in seen:

   587                     seen.add(sub)

   588                     toproceed.append(sub)

   589     nm = repo.changelog.nodemap

   590     cs = set()

   591     for s in seen:

   592         sr = nm.get(s)

   593         if sr is not None:

   594             cs.add(sr)

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

   596     return cs

   597 

   598 

   599 

   600 

   601 #####################################################################

   602 ### Extending revset and template                                 ###

   603 #####################################################################

   604 

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

   606 # they are subject to changes

   607 

   608 

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

   610 @eh.revset('suspended')

   611 def revsetsuspended(repo, subset, x):

   612     """``suspended()``

   613     Obsolete changesets with non-obsolete descendants.

   614     """

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

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

   617     suspended.sort()

   618     return subset & suspended

   619 

   620 

   621 @eh.revset('precursors')

   622 def revsetprecursors(repo, subset, x):

   623     """``precursors(set)``

   624     Immediate precursors of changesets in set.

   625     """

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

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

   628     s.sort()

   629     return subset & s

   630 

   631 

   632 @eh.revset('allprecursors')

   633 def revsetallprecursors(repo, subset, x):

   634     """``allprecursors(set)``

   635     Transitive precursors of changesets in set.

   636     """

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

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

   639     s.sort()

   640     return subset & s

   641 

   642 

   643 @eh.revset('successors')

   644 def revsetsuccessors(repo, subset, x):

   645     """``successors(set)``

   646     Immediate successors of changesets in set.

   647     """

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

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

   650     s.sort()

   651     return subset & s

   652 

   653 @eh.revset('allsuccessors')

   654 def revsetallsuccessors(repo, subset, x):

   655     """``allsuccessors(set)``

   656     Transitive successors of changesets in set.

   657     """

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

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

   660     s.sort()

   661     return subset & s

   662 

   663 ### template keywords

   664 # XXX it does not handle troubles well :-/

   665 

   666 @eh.templatekw('obsolete')

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

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

   669     """

   670     if ctx.obsolete():

   671         return 'obsolete'

   672     return ''

   673 

   674 @eh.templatekw('troubles')

   675 def showtroubles(repo, ctx, **args):

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

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

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

   679                                **args)

   680 

   681 #####################################################################

   682 ### Various trouble warning                                       ###

   683 #####################################################################

   684 

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

   686 

   687 

   688 def _warnobsoletewc(ui, repo):

   689     if repo['.'].obsolete():

   690         ui.warn(_('working directory parent is obsolete!\n'))

   691         if (not ui.quiet) and obsolete.isenabled(repo, commandopt):

   692             ui.warn(_("(use 'hg evolve' to update to its successor)\n"))

   693 

   694 @eh.wrapcommand("update")

   695 @eh.wrapcommand("pull")

   696 def wrapmayobsoletewc(origfn, ui, repo, *args, **opts):

   697     """Warn that the working directory parent is an obsolete changeset"""

   698     def warnobsolete():

   699         _warnobsoletewc(ui, repo)

   700     wlock = None

   701     try:

   702         wlock = repo.wlock()

   703         repo._afterlock(warnobsolete)

   704         res = origfn(ui, repo, *args, **opts)

   705     finally:

   706         lockmod.release(wlock)

   707     return res

   708 

   709 @eh.wrapcommand("parents")

   710 def wrapparents(origfn, ui, repo, *args, **opts):

   711     res = origfn(ui, repo, *args, **opts)

   712     _warnobsoletewc(ui, repo)

   713     return res

   714 

   715 # XXX this could wrap transaction code

   716 # XXX (but this is a bit a layer violation)

   717 @eh.wrapcommand("commit")

   718 @eh.wrapcommand("import")

   719 @eh.wrapcommand("push")

   720 @eh.wrapcommand("pull")

   721 @eh.wrapcommand("graft")

   722 @eh.wrapcommand("phase")

   723 @eh.wrapcommand("unbundle")

   724 def warnobserrors(orig, ui, repo, *args, **kwargs):

   725     """display warning is the command resulted in more instable changeset"""

   726     # part of the troubled stuff may be filtered (stash ?)

   727     # This needs a better implementation but will probably wait for core.

   728     filtered = repo.changelog.filteredrevs

   729     priorunstables = len(set(getrevs(repo, 'unstable')) - filtered)

   730     priorbumpeds = len(set(getrevs(repo, 'bumped')) - filtered)

   731     priordivergents = len(set(getrevs(repo, 'divergent')) - filtered)

   732     ret = orig(ui, repo, *args, **kwargs)

   733     # workaround phase stupidity

   734     #phases._filterunknown(ui, repo.changelog, repo._phasecache.phaseroots)

   735     filtered = repo.changelog.filteredrevs

   736     newunstables = \

   737         len(set(getrevs(repo, 'unstable')) - filtered) - priorunstables

   738     newbumpeds = \

   739         len(set(getrevs(repo, 'bumped')) - filtered) - priorbumpeds

   740     newdivergents = \

   741         len(set(getrevs(repo, 'divergent')) - filtered) - priordivergents

   742     if newunstables > 0:

   743         ui.warn(_('%i new unstable changesets\n') % newunstables)

   744     if newbumpeds > 0:

   745         ui.warn(_('%i new bumped changesets\n') % newbumpeds)

   746     if newdivergents > 0:

   747         ui.warn(_('%i new divergent changesets\n') % newdivergents)

   748     return ret

   749 

   750 @eh.wrapfunction(mercurial.exchange, 'push')

   751 def push(orig, repo, *args, **opts):

   752     """Add a hint for "hg evolve" when troubles make push fails

   753     """

   754     try:

   755         return orig(repo, *args, **opts)

   756     except error.Abort as ex:

   757         hint = _("use 'hg evolve' to get a stable history "

   758                  "or --force to ignore warnings")

   759         if (len(ex.args) >= 1

   760             and ex.args[0].startswith('push includes ')

   761             and ex.hint is None):

   762             ex.hint = hint

   763         raise

   764 

   765 def summaryhook(ui, repo):

   766     def write(fmt, count):

   767         s = fmt % count

   768         if count:

   769             ui.write(s)

   770         else:

   771             ui.note(s)

   772 

   773     # util.versiontuple was introduced in 3.6.2

   774     if not util.safehasattr(util, 'versiontuple'):

   775         nbunstable = len(getrevs(repo, 'unstable'))

   776         nbbumped = len(getrevs(repo, 'bumped'))

   777         nbdivergent = len(getrevs(repo, 'divergent'))

   778         write('unstable: %i changesets\n', nbunstable)

   779         write('bumped: %i changesets\n', nbbumped)

   780         write('divergent: %i changesets\n', nbdivergent)

   781     else:

   782         # In 3.6.2, summary in core gained this feature, no need to display it

   783         pass

   784     state = _evolvestateread(repo)

   785     if state is not None:

   786         # i18n: column positioning for "hg summary"

   787         ui.write(_('evolve: (evolve --continue)\n'))

   788 

   789 @eh.extsetup

   790 def obssummarysetup(ui):

   791     cmdutil.summaryhooks.add('evolve', summaryhook)

   792 

   793 

   794 #####################################################################

   795 ### Core Other extension compat                                   ###

   796 #####################################################################

   797 

   798 

   799 @eh.extsetup

   800 def _rebasewrapping(ui):

   801     # warning about more obsolete

   802     try:

   803         rebase = extensions.find('rebase')

   804         if rebase:

   805             extensions.wrapcommand(rebase.cmdtable, 'rebase', warnobserrors)

   806     except KeyError:

   807         pass # rebase not found

   808     try:

   809         histedit = extensions.find('histedit')

   810         if histedit:

   811             extensions.wrapcommand(histedit.cmdtable, 'histedit', warnobserrors)

   812     except KeyError:

   813         pass # histedit not found

   814 

   815 #####################################################################

   816 ### Old Evolve extension content                                  ###

   817 #####################################################################

   818 

   819 # XXX need clean up and proper sorting in other section

   820 

   821 ### util function

   822 #############################

   823 

   824 ### changeset rewriting logic

   825 #############################

   826 

   827 def rewrite(repo, old, updates, head, newbases, commitopts):

   828     """Return (nodeid, created) where nodeid is the identifier of the

   829     changeset generated by the rewrite process, and created is True if

   830     nodeid was actually created. If created is False, nodeid

   831     references a changeset existing before the rewrite call.

   832     """

   833     wlock = lock = tr = None

   834     try:

   835         wlock = repo.wlock()

   836         lock = repo.lock()

   837         tr = repo.transaction('rewrite')

   838         if len(old.parents()) > 1: #XXX remove this unnecessary limitation.

   839             raise error.Abort(_('cannot amend merge changesets'))

   840         base = old.p1()

   841         updatebookmarks = _bookmarksupdater(repo, old.node(), tr)

   842 

   843         # commit a new version of the old changeset, including the update

   844         # collect all files which might be affected

   845         files = set(old.files())

   846         for u in updates:

   847             files.update(u.files())

   848 

   849         # Recompute copies (avoid recording a -> b -> a)

   850         copied = copies.pathcopies(base, head)

   851 

   852 

   853         # prune files which were reverted by the updates

   854         def samefile(f):

   855             if f in head.manifest():

   856                 a = head.filectx(f)

   857                 if f in base.manifest():

   858                     b = base.filectx(f)

   859                     return (a.data() == b.data()

   860                             and a.flags() == b.flags())

   861                 else:

   862                     return False

   863             else:

   864                 return f not in base.manifest()

   865         files = [f for f in files if not samefile(f)]

   866         # commit version of these files as defined by head

   867         headmf = head.manifest()

   868         def filectxfn(repo, ctx, path):

   869             if path in headmf:

   870                 fctx = head[path]

   871                 flags = fctx.flags()

   872                 mctx = memfilectx(repo, fctx.path(), fctx.data(),

   873                                   islink='l' in flags,

   874                                   isexec='x' in flags,

   875                                   copied=copied.get(path))

   876                 return mctx

   877             return None

   878 

   879         message = cmdutil.logmessage(repo.ui, commitopts)

   880         if not message:

   881             message = old.description()

   882 

   883         user = commitopts.get('user') or old.user()

   884         date = commitopts.get('date') or None # old.date()

   885         extra = dict(commitopts.get('extra', old.extra()))

   886         extra['branch'] = head.branch()

   887 

   888         new = context.memctx(repo,

   889                              parents=newbases,

   890                              text=message,

   891                              files=files,

   892                              filectxfn=filectxfn,

   893                              user=user,

   894                              date=date,

   895                              extra=extra)

   896 

   897         if commitopts.get('edit'):

   898             new._text = cmdutil.commitforceeditor(repo, new, [])

   899         revcount = len(repo)

   900         newid = repo.commitctx(new)

   901         new = repo[newid]

   902         created = len(repo) != revcount

   903         updatebookmarks(newid)

   904 

   905         tr.close()

   906         return newid, created

   907     finally:

   908         lockmod.release(tr, lock, wlock)

   909 

   910 class MergeFailure(error.Abort):

   911     pass

   912 

   913 def relocate(repo, orig, dest, pctx=None, keepbranch=False):

   914     """rewrite <rev> on dest"""

   915     if orig.rev() == dest.rev():

   916         raise error.Abort(_('tried to relocate a node on top of itself'),

   917                          hint=_("This shouldn't happen. If you still "

   918                                 "need to move changesets, please do so "

   919                                 "manually with nothing to rebase - working "

   920                                 "directory parent is also destination"))

   921 

   922     if pctx is None:

   923         if len(orig.parents()) == 2:

   924             raise error.Abort(_("tried to relocate a merge commit without "

   925                                 "specifying which parent should be moved"),

   926                               hint=_("Specify the parent by passing in pctx"))

   927         pctx = orig.p1()

   928 

   929     destbookmarks = repo.nodebookmarks(dest.node())

   930     nodesrc = orig.node()

   931     destphase = repo[nodesrc].phase()

   932     commitmsg = orig.description()

   933 

   934     cache = {}

   935     sha1s = re.findall(sha1re, commitmsg)

   936     unfi = repo.unfiltered()

   937     for sha1 in sha1s:

   938         ctx = None

   939         try:

   940             ctx = unfi[sha1]

   941         except error.RepoLookupError:

   942             continue

   943 

   944         if not ctx.obsolete():

   945             continue

   946 

   947         successors = obsolete.successorssets(repo, ctx.node(), cache)

   948 

   949         # We can't make any assumptions about how to update the hash if the

   950         # cset in question was split or diverged.

   951         if len(successors) == 1 and len(successors[0]) == 1:

   952             newsha1 = node.hex(successors[0][0])

   953             commitmsg = commitmsg.replace(sha1, newsha1[:len(sha1)])

   954         else:

   955             repo.ui.note(_('The stale commit message reference to %s could '

   956                            'not be updated\n') % sha1)

   957 

   958     tr = repo.currenttransaction()

   959     assert tr is not None

   960     try:

   961         r = _evolvemerge(repo, orig, dest, pctx, keepbranch)

   962         if r[-1]:  #some conflict

   963             raise error.Abort(

   964                     'unresolved merge conflicts (see hg help resolve)')

   965         nodenew = _relocatecommit(repo, orig, commitmsg)

   966     except error.Abort as exc:

   967         repo.dirstate.beginparentchange()

   968         repo.setparents(repo['.'].node(), nullid)

   969         writedirstate(repo.dirstate, tr)

   970         # fix up dirstate for copies and renames

   971         copies.duplicatecopies(repo, dest.rev(), orig.p1().rev())

   972         repo.dirstate.endparentchange()

   973         class LocalMergeFailure(MergeFailure, exc.__class__):

   974             pass

   975         exc.__class__ = LocalMergeFailure

   976         tr.close() # to keep changes in this transaction (e.g. dirstate)

   977         raise

   978     oldbookmarks = repo.nodebookmarks(nodesrc)

   979     _finalizerelocate(repo, orig, dest, nodenew, tr)

   980     return nodenew

   981 

   982 def _bookmarksupdater(repo, oldid, tr):

   983     """Return a callable update(newid) updating the current bookmark

   984     and bookmarks bound to oldid to newid.

   985     """

   986     def updatebookmarks(newid):

   987         dirty = False

   988         oldbookmarks = repo.nodebookmarks(oldid)

   989         if oldbookmarks:

   990             for b in oldbookmarks:

   991                 repo._bookmarks[b] = newid

   992             dirty = True

   993         if dirty:

   994             repo._bookmarks.recordchange(tr)

   995     return updatebookmarks

   996 

   997 ### bookmarks api compatibility layer ###

   998 def bmdeactivate(repo):

   999     try:

  1000         return bookmarksmod.deactivate(repo)

  1001     except AttributeError:

  1002         return bookmarksmod.unsetcurrent(repo)

  1003 def bmactivate(repo, book):

  1004     try:

  1005         return bookmarksmod.activate(repo, book)

  1006     except AttributeError:

  1007         return bookmarksmod.setcurrent(repo, book)

  1008 

  1009 def bmactive(repo):

  1010     try:

  1011         return repo._activebookmark

  1012     except AttributeError:

  1013         return repo._bookmarkcurrent

  1014 

  1015 ### dirstate compatibility layer < hg 3.6

  1016 

  1017 def writedirstate(dirstate, tr):

  1018     if dirstate.write.func_code.co_argcount != 1: # mercurial 3.6 and above

  1019         return dirstate.write(tr)

  1020     return dirstate.write()

  1021 

  1022 

  1023 

  1024 ### new command

  1025 #############################

  1026 metadataopts = [

  1027     ('d', 'date', '',

  1028      _('record the specified date in metadata'), _('DATE')),

  1029     ('u', 'user', '',

  1030      _('record the specified user in metadata'), _('USER')),

  1031 ]

  1032 

  1033 @eh.uisetup

  1034 def _installimportobsolete(ui):

  1035     entry = cmdutil.findcmd('import', commands.table)[1]

  1036     entry[1].append(('', 'obsolete', False,

  1037                     _('mark the old node as obsoleted by '

  1038                       'the created commit')))

  1039 

  1040 @eh.wrapfunction(mercurial.cmdutil, 'tryimportone')

  1041 def tryimportone(orig, ui, repo, hunk, parents, opts, *args, **kwargs):

  1042     extracted = patch.extract(ui, hunk)

  1043     if util.safehasattr(extracted, 'get'):

  1044         # mercurial 3.6 return a dictionary there

  1045         expected = extracted.get('nodeid')

  1046     else:

  1047         expected = extracted[5]

  1048     if expected is not None:

  1049         expected = node.bin(expected)

  1050     oldextract = patch.extract

  1051     try:

  1052         patch.extract = lambda ui, hunk: extracted

  1053         ret = orig(ui, repo, hunk, parents, opts, *args, **kwargs)

  1054     finally:

  1055         patch.extract = oldextract

  1056     created = ret[1]

  1057     if (opts['obsolete'] and None not in (created, expected)

  1058         and created != expected):

  1059             tr = repo.transaction('import-obs')

  1060             try:

  1061                 metadata = {'user': ui.username()}

  1062                 repo.obsstore.create(tr, expected, (created,),

  1063                                      metadata=metadata)

  1064                 tr.close()

  1065             finally:

  1066                 tr.release()

  1067     return ret

  1068 

  1069 

  1070 def _deprecatealias(oldalias, newalias):

  1071     '''Deprecates an alias for a command in favour of another

  1072 

  1073     Creates a new entry in the command table for the old alias. It creates a

  1074     wrapper that has its synopsis set to show that is has been deprecated.

  1075     The documentation will be replace with a pointer to the new alias.

  1076     If a user invokes the command a deprecation warning will be printed and

  1077     the command of the *new* alias will be invoked.

  1078 

  1079     This function is loosely based on the extensions.wrapcommand function.

  1080     '''

  1081     try:

  1082         aliases, entry = cmdutil.findcmd(newalias, cmdtable)

  1083     except error.UnknownCommand:

  1084         # Commands may be disabled

  1085         return

  1086     for alias, e in cmdtable.items():

  1087         if e is entry:

  1088             break

  1089 

  1090     synopsis = '(DEPRECATED)'

  1091     if len(entry) > 2:

  1092         fn, opts, _syn = entry

  1093     else:

  1094         fn, opts, = entry

  1095     deprecationwarning = _('%s have been deprecated in favor of %s\n') % (

  1096         oldalias, newalias)

  1097     def newfn(*args, **kwargs):

  1098         ui = args[0]

  1099         ui.warn(deprecationwarning)

  1100         util.checksignature(fn)(*args, **kwargs)

  1101     newfn.__doc__  = deprecationwarning

  1102     cmdwrapper = command(oldalias, opts, synopsis)

  1103     cmdwrapper(newfn)

  1104 

  1105 @eh.extsetup

  1106 def deprecatealiases(ui):

  1107     _deprecatealias('gup', 'next')

  1108     _deprecatealias('gdown', 'previous')

  1109 

  1110 @command('debugrecordpruneparents', [], '')

  1111 def cmddebugrecordpruneparents(ui, repo):

  1112     """add parent data to prune markers when possible

  1113 

  1114     This command searches the repo for prune markers without parent information.

  1115     If the pruned node is locally known, it creates a new marker with parent

  1116     data.

  1117     """

  1118     pgop = 'reading markers'

  1119 

  1120     # lock from the beginning to prevent race

  1121     wlock = lock = tr = None

  1122     try:

  1123         wlock = repo.wlock()

  1124         lock = repo.lock()

  1125         tr = repo.transaction('recordpruneparents')

  1126         unfi = repo.unfiltered()

  1127         nm = unfi.changelog.nodemap

  1128         store = repo.obsstore

  1129         pgtotal = len(store._all)

  1130         for idx, mark in enumerate(list(store._all)):

  1131             if not mark[1]:

  1132                 rev = nm.get(mark[0])

  1133                 if rev is not None: