evolve: comparison hgext/evolve.py

equal deleted inserted replaced

-:53d7e3413337
+:5a0a01c4c7c2
-# states.py - introduce the state concept for mercurial changeset
-#
 # 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 Provide several command tommutate history and deal with issue it may raise.
+This extension provides several commands to mutate history and deal with
+issues it may raise.
 It also:
-- enable the "Changeset Obsolescence" feature of mercurial,
+- enables the "Changeset Obsolescence" feature of mercurial,
-- alter core command and extension that rewrite history to use this feature,
+- alters core commands and extensions that rewrite history to use
-- improve some aspect of the early implementation in 2.3
+this feature,
+- improves some aspect of the early implementation in 2.3
 '''
 import random
 from mercurial import util
 from mercurial import discovery
 from mercurial import error
 from mercurial import extensions
 from mercurial import hg
 from mercurial import localrepo
+from mercurial import lock as lockmod
 from mercurial import merge
 from mercurial import node
 from mercurial import phases
 from mercurial import revset
 from mercurial import scmutil
 from mercurial import templatekw
 from mercurial.i18n import _
 from mercurial.commands import walkopts, commitopts, commitopts2
 from mercurial.node import nullid
+import mercurial.hgweb.hgweb_mod
 # This extension contains the following code
 #
 #####################################################################
 ### Obsolescence Caching Logic                                    ###
 #####################################################################
+# IN CORE fb72eec7efd8
 # Obsolescence related logic can be very slow if we don't have efficient cache.
 #
 # This section implements a cache mechanism that did not make it into core for
-# time reason. It store meaningful set of revision related to obsolescence
+# time reason. It stores meaningful set of revisions related to obsolescence
-# (obsolete, unstabletble ...
+# (obsolete, unstable, etc.)
 #
 # Here is:
 #
-# - Computation of meaningful set,
+# - Computation of meaningful sets
 # - Cache access logic,
 # - Cache invalidation logic,
 # - revset and ctx using this cache.
 #
 #: { set name -> function to compute this set } mapping
 #:   function take a single "repo" argument.
 #:
 #: Use the `cachefor` decorator to register new cache function
-cachefuncs = {}
+try:
-def cachefor(name):
+cachefuncs = obsolete.cachefuncs
-"""Decorator to register a function as computing the cache for a set"""
+cachefor = obsolete.cachefor
-def decorator(func):
+getobscache = obsolete.getobscache
-assert name not in cachefuncs
+clearobscaches = obsolete.clearobscaches
-cachefuncs[name] = func
+except AttributeError:
-return func
+cachefuncs = {}
-return decorator
+def cachefor(name):
-@cachefor('obsolete')
+"""Decorator to register a function as computing the cache for a set"""
-def _computeobsoleteset(repo):
+def decorator(func):
-"""the set of obsolete revisions"""
+assert name not in cachefuncs
-obs = set()
+cachefuncs[name] = func
-nm = repo.changelog.nodemap
+return func
-for prec in repo.obsstore.precursors:
+return decorator
-rev = nm.get(prec)
-if rev is not None:
+@cachefor('obsolete')
-obs.add(rev)
+def _computeobsoleteset(repo):
-return set(repo.revs('%ld - public()', obs))
+"""the set of obsolete revisions"""
+obs = set()
-@cachefor('unstable')
+nm = repo.changelog.nodemap
-def _computeunstableset(repo):
+for prec in repo.obsstore.precursors:
-"""the set of non obsolete revisions with obsolete parents"""
+rev = nm.get(prec)
-return set(repo.revs('(obsolete()::) - obsolete()'))
+if rev is not None:
+obs.add(rev)
-@cachefor('suspended')
+return set(repo.revs('%ld - public()', obs))
-def _computesuspendedset(repo):
-"""the set of obsolete parents with non obsolete descendants"""
+@cachefor('unstable')
-return set(repo.revs('obsolete() and obsolete()::unstable()'))
+def _computeunstableset(repo):
+"""the set of non obsolete revisions with obsolete parents"""
-@cachefor('extinct')
+return set(repo.revs('(obsolete()::) - obsolete()'))
-def _computeextinctset(repo):
-"""the set of obsolete parents without non obsolete descendants"""
+@cachefor('suspended')
-return set(repo.revs('obsolete() - obsolete()::unstable()'))
+def _computesuspendedset(repo):
+"""the set of obsolete parents with non obsolete descendants"""
-@eh.wrapfunction(obsolete.obsstore, '__init__')
+return set(repo.revs('obsolete() and obsolete()::unstable()'))
-def _initobsstorecache(orig, obsstore, *args, **kwargs):
-"""add a cache attribute to obsstore"""
+@cachefor('extinct')
-obsstore.caches = {}
+def _computeextinctset(repo):
-return orig(obsstore, *args, **kwargs)
+"""the set of obsolete parents without non obsolete descendants"""
+return set(repo.revs('obsolete() - obsolete()::unstable()'))
+@eh.wrapfunction(obsolete.obsstore, '__init__')
+def _initobsstorecache(orig, obsstore, *args, **kwargs):
+"""add a cache attribute to obsstore"""
+obsstore.caches = {}
+return orig(obsstore, *args, **kwargs)
 ### Cache access
 def getobscache(repo, name):
 """Return the set of revision that belong to the <name> set
 Such access may compute the set and cache it for future use"""
 if not repo.obsstore:
 return ()
 if name not in repo.obsstore.caches:
 repo.obsstore.caches[name] = cachefuncs[name](repo)
 return repo.obsstore.caches[name]
 ### Cache clean up
 #
 # To be simple we need to invalidate obsolescence cache when:
 #
 # - public phase is changed
 # - obsolescence marker are added
 # - strip is used a repo
 def clearobscaches(repo):
 """Remove all obsolescence related cache from a repo
 This remove all cache in obsstore is the obsstore already exist on the
 repo.
 (We could be smarter here)"""
 if 'obsstore' in repo._filecache:
 repo.obsstore.caches.clear()
 @eh.wrapfunction(localrepo.localrepository, 'addchangegroup')  # new changeset
 @eh.wrapfunction(phases, 'retractboundary')  # phase movement
 @eh.wrapfunction(phases, 'advanceboundary')  # phase movement
 @eh.wrapfunction(localrepo.localrepository, 'destroyed')  # strip
 def wrapclearcache(orig, repo, *args, **kwargs):
 try:
 return orig(repo, *args, **kwargs)
 finally:
 # we are a bit wide here
 # we could restrict to:
 # advanceboundary + phase==public
 # retractboundary + phase==draft
 clearobscaches(repo)
 @eh.wrapfunction(obsolete.obsstore, 'add')  # new marker
 def clearonadd(orig, obsstore, *args, **kwargs):
 try:
 return orig(obsstore, *args, **kwargs)
 finally:
 obsstore.caches.clear()
 ### Use the case
 # Function in core that could benefic from the cache are overwritten by cache using version
 # changectx method
 @eh.addattr(context.changectx, 'unstable')
 def unstable(ctx):
 """is the changeset unstable (have obsolete ancestor)"""
 if ctx.node() is None:
 return False
 return ctx.rev() in getobscache(ctx._repo, 'unstable')
 @eh.addattr(context.changectx, 'extinct')
 def extinct(ctx):
 """is the changeset extinct by other"""
 if ctx.node() is None:
 return False
 return ctx.rev() in getobscache(ctx._repo, 'extinct')
 # revset
 @eh.revset('obsolete')
 def revsetobsolete(repo, subset, x):
 """``obsolete()``
 Changeset is obsolete.
 """
 args = revset.getargs(x, 0, 0, 'obsolete takes no argument')
 obsoletes = getobscache(repo, 'obsolete')
 return [r for r in subset if r in obsoletes]
 @eh.revset('unstable')
 def revsetunstable(repo, subset, x):
 """``unstable()``
 Unstable changesets are non-obsolete with obsolete ancestors.
 """
 args = revset.getargs(x, 0, 0, 'unstable takes no arguments')
 unstables = getobscache(repo, 'unstable')
 return [r for r in subset if r in unstables]
 @eh.revset('extinct')
 def revsetextinct(repo, subset, x):
 """``extinct()``
 Obsolete changesets with obsolete descendants only.
 """
 args = revset.getargs(x, 0, 0, 'extinct takes no arguments')
 extincts = getobscache(repo, 'extinct')
 return [r for r in subset if r in extincts]
 #####################################################################
 ### Complete troubles computation logic                           ###
 #####################################################################
 raise util.Abort(_("push includes a conflicting changeset: %s!")
 % ctx)
 return orig(repo, remote, outgoing, *args, **kwargs)
 #####################################################################
-### Filter extinct changeset from common operation                ###
+### Filter extinct changesets from common operations              ###
 #####################################################################
 @eh.wrapfunction(merge, 'update')
 def wrapmergeupdate(orig, repo, node, *args, **kwargs):
 """ensure we don't automatically update on hidden changeset"""
 return orig(repo, node, *args, **kwargs)
 @eh.wrapfunction(localrepo.localrepository, 'branchtip')
 def obsbranchtip(orig, repo, branch):
 """ensure "stable" reference does not end on a hidden changeset"""
+if not getattr(repo, '_dofilterbranchtip', True):
+return orig(repo, branch)
 result = ()
 heads = repo.branchmap().get(branch, ())
 if heads:
 result = list(repo.set('last(heads(branch(%n) - hidden()))', heads[0]))
 if not result:
 raise error.RepoLookupError(_("unknown branch '%s'") % branch)
 return result[0].node()
+@eh.wrapfunction(mercurial.hgweb.hgweb_mod.hgweb, '__init__')
+@eh.wrapfunction(mercurial.hgweb.hgweb_mod.hgweb, 'refresh')
+def nofilter(orig, hgweb, *args, **kwargs):
+orig(hgweb, *args, **kwargs)
+hgweb.repo._dofilterbranchtip = False
 #####################################################################
 ### Additional Utilities                                          ###
 #####################################################################
 # This section contains a lot of small utility function and method
 # - "troubles" method on changectx
 # - function to travel throught the obsolescence graph
 # - function to find useful changeset to stabilize
 ### Marker Create
+# NOW IN CORE f85816af6294
-def createmarkers(repo, relations, metadata=None, flag=0):
+try:
-"""Add obsolete markers between changeset in a repo
+createmarkers = obsolete.createmarkers
+except AttributeError:
-<relations> must be an iterable of (<old>, (<new>, ...)) tuple.
+def createmarkers(repo, relations, metadata=None, flag=0):
-`old` and `news` are changectx.
+"""Add obsolete markers between changeset in a repo
-Current user and date are used except if specified otherwise in the
+<relations> must be an iterable of (<old>, (<new>, ...)) tuple.
-metadata attribute.
+`old` and `news` are changectx.
-/!\ assume the repo have been locked by the user /!\
+Current user and date are used except if specified otherwise in the
-"""
+metadata attribute.
-# prepare metadata
-if metadata is None:
+/!\ assume the repo have been locked by the user /!\
-metadata = {}
+"""
-if 'date' not in metadata:
+# prepare metadata
-metadata['date'] = '%i %i' % util.makedate()
+if metadata is None:
-if 'user' not in metadata:
+metadata = {}
-metadata['user'] = repo.ui.username()
+if 'date' not in metadata:
-# check future marker
+metadata['date'] = '%i %i' % util.makedate()
-tr = repo.transaction('add-obsolescence-marker')
+if 'user' not in metadata:
-try:
+metadata['user'] = repo.ui.username()
-for prec, sucs in relations:
+# check future marker
-if not prec.mutable():
+tr = repo.transaction('add-obsolescence-marker')
-raise util.Abort("Cannot obsolete immutable changeset: %s" % prec)
+try:
-nprec = prec.node()
+for prec, sucs in relations:
-nsucs = tuple(s.node() for s in sucs)
+if not prec.mutable():
-if nprec in nsucs:
+raise util.Abort("cannot obsolete immutable changeset: %s" % prec)
-raise util.Abort("Changeset %s cannot obsolete himself" % prec)
+nprec = prec.node()
-repo.obsstore.create(tr, nprec, nsucs, flag, metadata)
+nsucs = tuple(s.node() for s in sucs)
-clearobscaches(repo)
+if nprec in nsucs:
-tr.close()
+raise util.Abort("changeset %s cannot obsolete himself" % prec)
-finally:
+repo.obsstore.create(tr, nprec, nsucs, flag, metadata)
-tr.release()
+clearobscaches(repo)
+tr.close()
+finally:
+tr.release()
 ### Useful alias
 @eh.uisetup
 def revsetlatecomer(repo, subset, x):
 """``troubled()``
 Changesets with troubles.
 """
 _ = revset.getargs(x, 0, 0, 'troubled takes no arguments')
-return list(repo.revs('%ld and (unstable() + latecomer() + conflicting())',
+return repo.revs('%ld and (unstable() + latecomer() + conflicting())',
-subset))
+subset)
 ### Obsolescence graph
 # XXX SOME MAJOR CLEAN UP TO DO HERE XXX
 #####################################################################
 # this section add several useful revset symbol not yet in core.
 # they are subject to changes
-### hidden revset is not in core yet
+if 'hidden' not in revset.symbols:
-@eh.revset('hidden')
+# in 2.3+
-def revsethidden(repo, subset, x):
+@eh.revset('hidden')
-"""``hidden()``
+def revsethidden(repo, subset, x):
-Changeset is hidden.
+"""``hidden()``
-"""
+Changeset is hidden.
-args = revset.getargs(x, 0, 0, 'hidden takes no argument')
+"""
-return [r for r in subset if r in repo.hiddenrevs]
+args = revset.getargs(x, 0, 0, 'hidden takes no argument')
+return [r for r in subset if r in repo.hiddenrevs]
 ### XXX I'm not sure this revset is useful
 @eh.revset('suspended')
 def revsetsuspended(repo, subset, x):
 """``suspended()``
 """display warning is the command resulted in more instable changeset"""
 priorunstables = len(repo.revs('unstable()'))
 priorlatecomers = len(repo.revs('latecomer()'))
 priorconflictings = len(repo.revs('conflicting()'))
 ret = orig(ui, repo, *args, **kwargs)
+# workaround phase stupidity
+phases._filterunknown(ui, repo.changelog, repo._phasecache.phaseroots)
 newunstables = len(repo.revs('unstable()')) - priorunstables
 newlatecomers = len(repo.revs('latecomer()')) - priorlatecomers
 newconflictings = len(repo.revs('conflicting()')) - priorconflictings
 if newunstables > 0:
 ui.warn(_('%i new unstable changesets\n') % newunstables)
 return result
 repo.__class__ = evolvingrepo
 @eh.wrapcommand("summary")
 def obssummary(orig, ui, repo, *args, **kwargs):
+def write(fmt, count):
+s = fmt % count
+if count:
+ui.write(s)
+else:
+ui.note(s)
 ret = orig(ui, repo, *args, **kwargs)
 nbunstable = len(getobscache(repo, 'unstable'))
 nblatecomer = len(getobscache(repo, 'latecomer'))
 nbconflicting = len(getobscache(repo, 'unstable'))
-if nbunstable:
+write('unstable: %i changesets\n', nbunstable)
-ui.write('unstable: %i changesets\n' % nbunstable)
+write('latecomer: %i changesets\n', nblatecomer)
-else:
+write('conflicting: %i changesets\n', nbconflicting)
-ui.note('unstable: 0 changesets\n')
-if nblatecomer:
-ui.write('latecomer: %i changesets\n' % nblatecomer)
-else:
-ui.note('latecomer: 0 changesets\n')
-if nbconflicting:
-ui.write('conflicting: %i changesets\n' % nbconflicting)
-else:
-ui.note('conflicting: 0 changesets\n')
 return ret
 #####################################################################
 ### Core Other extension compat                                   ###
 ### commit --amend
 # make commit --amend create obsolete marker
 #
 # The precursor is still strip from the repository.
-@eh.wrapfunction(cmdutil, 'amend')
+# IN CORE 63e45aee46d4
-def wrapcmdutilamend(orig, ui, repo, commitfunc, old, *args, **kwargs):
-oldnode = old.node()
+if getattr(cmdutil, 'obsolete', None) is None:
-new = orig(ui, repo, commitfunc, old, *args, **kwargs)
+@eh.wrapfunction(cmdutil, 'amend')
-if new != oldnode:
+def wrapcmdutilamend(orig, ui, repo, commitfunc, old, *args, **kwargs):
-lock = repo.lock()
+oldnode = old.node()
-try:
+new = orig(ui, repo, commitfunc, old, *args, **kwargs)
-tr = repo.transaction('post-amend-obst')
+if new != oldnode:
+lock = repo.lock()
 try:
-meta = {
+tr = repo.transaction('post-amend-obst')
-'date':  '%i %i' % util.makedate(),
+try:
-'user': ui.username(),
+meta = {
-}
+'date':  '%i %i' % util.makedate(),
-repo.obsstore.create(tr, oldnode, [new], 0, meta)
+'user': ui.username(),
-tr.close()
+}
-clearobscaches(repo)
+repo.obsstore.create(tr, oldnode, [new], 0, meta)
+tr.close()
+clearobscaches(repo)
+finally:
+tr.release()
 finally:
-tr.release()
+lock.release()
-finally:
+return new
-lock.release()
-return new
 ### rebase
 #
 # - ignore obsolete changeset
 # - create obsolete marker *instead of* striping
 rebaseset = repo.revs('%ld - extinct()', rebaseset)
 if not rebaseset:
 repo.ui.warn(_('whole rebase set is extinct and ignored.\n'))
 return {}
 root = min(rebaseset)
-if not repo._rebasekeep and not repo[root].mutable():
+if (not getattr(repo, '_rebasekeep', False)
+and not repo[root].mutable()):
 raise util.Abort(_("can't rebase immutable changeset %s") % repo[root],
 hint=_('see hg help phases for details'))
 return orig(repo, dest, rebaseset, *ags, **kws)
 def defineparents(orig, repo, rev, target, state, *args, **kwargs):
 def _rebasewrapping(ui):
 # warning about more obsolete
 try:
 rebase = extensions.find('rebase')
 if rebase:
-entry = extensions.wrapcommand(rebase.cmdtable, 'rebase', warnobserrors)
+incore = getattr(rebase, 'obsolete', None) is not None
-extensions.wrapfunction(rebase, 'buildstate', buildstate)
+if not incore:
-extensions.wrapfunction(rebase, 'defineparents', defineparents)
+extensions.wrapcommand(rebase.cmdtable, "rebase", cmdrebase)
-extensions.wrapfunction(rebase, 'concludenode', concludenode)
+extensions.wrapcommand(rebase.cmdtable, 'rebase', warnobserrors)
-extensions.wrapcommand(rebase.cmdtable, "rebase", cmdrebase)
+if not incore:
+extensions.wrapfunction(rebase, 'buildstate', buildstate)
+extensions.wrapfunction(rebase, 'defineparents', defineparents)
+extensions.wrapfunction(rebase, 'concludenode', concludenode)
 except KeyError:
 pass  # rebase not found
 #####################################################################
 assert orig.p2().rev() == node.nullrev, 'no support yet'
 destbookmarks = repo.nodebookmarks(dest.node())
 cmdutil.duplicatecopies(repo, orig.node(), dest.node())
 nodesrc = orig.node()
 destphase = repo[nodesrc].phase()
-if rebase.rebasenode.func_code.co_argcount == 5:
-# rebasenode collapse argument was introduced by
-# d1afbf03e69a (2.3)
-rebase.rebasenode(repo, orig.node(), dest.node(),
-{node.nullrev: node.nullrev}, False)
-else:
-rebase.rebasenode(repo, orig.node(), dest.node(),
-{node.nullrev: node.nullrev})
 try:
+if rebase.rebasenode.func_code.co_argcount == 5:
+# rebasenode collapse argument was introduced by
+# d1afbf03e69a (2.3)
+r = rebase.rebasenode(repo, orig.node(), dest.node(),
+{node.nullrev: node.nullrev}, False)
+else:
+r = rebase.rebasenode(repo, orig.node(), dest.node(),
+{node.nullrev: node.nullrev})
+if r[-1]: #some conflict
+raise util.Abort(
+'unresolved merge conflicts (see hg help resolve)')
 nodenew = rebase.concludenode(repo, orig.node(), dest.node(),
 node.nullid)
 except util.Abort, exc:
 class LocalMergeFailure(MergeFailure, exc.__class__):
 pass
 except util.Abort:
 # Invalidate the previous setparents
 repo.dirstate.invalidate()
 raise
-def _stabilizableunstable(repo, pctx):
-"""Return a changectx for an unstable changeset which can be
-stabilized on top of pctx or one of its descendants. None if none
-can be found.
-"""
-def selfanddescendants(repo, pctx):
-yield pctx
-for ctx in pctx.descendants():
-yield ctx
-# Look for an unstable which can be stabilized as a child of
-# node. The unstable must be a child of one of node predecessors.
-for ctx in selfanddescendants(repo, pctx):
-unstables = list(repo.set('unstable() and children(allprecursors(%d))',
-ctx.rev()))
-if unstables:
-return unstables[0]
-return None
 def _bookmarksupdater(repo, oldid):
 """Return a callable update(newid) updating the current bookmark
 and bookmarks bound to oldid to newid.
 """
 bm = bookmarks.readcurrent(repo)
 if anyopt:
 raise util.Abort('can not specify both "--any" and "--continue"')
 graftcmd = commands.table['graft'][0]
 return graftcmd(ui, repo, old_obsolete=True, **{'continue': True})
-troubled = list(repo.revs('troubled()'))
 tr = _picknexttroubled(ui, repo, anyopt)
 if tr is None:
+troubled = repo.revs('troubled()')
 if troubled:
 ui.write_err(_('nothing to evolve here\n'))
 ui.status(_('(%i troubled changesets, do you want --any ?)\n')
 % len(troubled))
 return 2
 elif 'conflicting' in troubles:
 return _solveconflicting(ui, repo, tr, opts['dry_run'])
 else:
 assert False  # WHAT? unknown troubles
-def _picknexttroubled(ui, repo, any=False):
+def _picknexttroubled(ui, repo, pickany=False):
 """Pick a the next trouble changeset to solve"""
 tr = _stabilizableunstable(repo, repo['.'])
 if tr is None:
 wdp = repo['.']
 if 'conflicting' in wdp.troubles():
 tr = wdp
-if tr is None and any:
+if tr is None and pickany:
 troubled = list(repo.set('unstable()'))
 if not troubled:
 troubled = list(repo.set('latecomer()'))
 if not troubled:
 troubled = list(repo.set('conflicting()'))
 if troubled:
 tr = troubled[0]
 return tr
+def _stabilizableunstable(repo, pctx):
+"""Return a changectx for an unstable changeset which can be
+stabilized on top of pctx or one of its descendants. None if none
+can be found.
+"""
+def selfanddescendants(repo, pctx):
+yield pctx
+for ctx in pctx.descendants():
+yield ctx
+# Look for an unstable which can be stabilized as a child of
+# node. The unstable must be a child of one of node predecessors.
+for ctx in selfanddescendants(repo, pctx):
+unstables = list(repo.set('unstable() and children(allprecursors(%d))',
+ctx.rev()))
+if unstables:
+return unstables[0]
+return None
 def _solveunstable(ui, repo, orig, dryrun=False):
 """Stabilize a unstable changeset"""
 obs = orig.parents()[0]
 if not obs.obsolete():
 assert obs.obsolete()
 newer = newerversion(repo, obs.node())
 # search of a parent which is not killed
 while newer == [()]:
 ui.debug("stabilize target %s is plain dead,"
-" trying to stabilize on it's parent")
+" trying to stabilize on its parent")
 obs = obs.parents()[0]
 newer = newerversion(repo, obs.node())
 if len(newer) > 1:
 ui.write_err(_("conflict rewriting. can't choose destination\n"))
 return 2
 if not ui.quiet:
 displayer.show(orig)
 repo.ui.status(_('atop:'))
 if not ui.quiet:
 displayer.show(target)
-todo = 'hg rebase -Dr %s -d %s\n' % (orig, target)
+todo = 'hg rebase -r %s -d %s\n' % (orig, target)
 if dryrun:
 repo.ui.write(todo)
 else:
 repo.ui.note(todo)
 lock = repo.lock()
 displayer.show(latecomer)
 repo.ui.status(_('atop:'))
 if not ui.quiet:
 displayer.show(prec)
 if dryrun:
-todo = 'hg rebase --rev %s --detach %s;\n' % (latecomer, prec.p1())
+todo = 'hg rebase --rev %s --dest %s;\n' % (latecomer, prec.p1())
 repo.ui.write(todo)
 repo.ui.write('hg update %s;\n' % prec)
 repo.ui.write('hg revert --all --rev %s;\n' % latecomer)
 repo.ui.write('hg commit --msg "latecomer update to %s"')
 return 0
 if conflicting.phase() <= phases.public:
 raise util.Abort("We can't resolve this conflict from the public side")
 if len(other.parents()) > 1:
 raise util.Abort("conflicting changeset can't be a merge (yet)")
 if other.p1() not in conflicting.parents():
-raise util.Abort("parent are not common (not handled yet)")
+raise util.Abort("parents are not common (not handled yet)")
 displayer = cmdutil.show_changeset(ui, repo, {'template': shorttemplate})
 ui.status(_('merge:'))
 if not ui.quiet:
 displayer.show(conflicting)
 ui.status(_('base: '))
 if not ui.quiet:
 displayer.show(base)
 if dryrun:
 ui.write('hg update -c %s &&\n' % conflicting)
-ui.write('hg merge %s && \n' % other)
+ui.write('hg merge %s &&\n' % other)
-ui.write('hg commit -m "auto merge resolving conflict between %s and %s"&&\n'
+ui.write('hg commit -m "auto merge resolving conflict between '
-% (conflicting, other))
+'%s and %s"&&\n' % (conflicting, other))
 ui.write('hg up -C %s &&\n' % base)
 ui.write('hg revert --all --rev tip &&\n')
-ui.write('hg commit -m "`hg log -r %s --template={desc}`";\n' % conflicting)
+ui.write('hg commit -m "`hg log -r %s --template={desc}`";\n'
+% conflicting)
 return
-#oldphase = max(conflicting.phase(), other.phase())
+wlock = lock = None
-wlock = repo.wlock()
 try:
+wlock = repo.wlock()
 lock = repo.lock()
+if conflicting not in repo[None].parents():
+repo.ui.status(_('updating to "local" conflict\n'))
+hg.update(repo, conflicting.rev())
+repo.ui.note(_('merging conflicting changeset\n'))
+stats = merge.update(repo,
+other.node(),
+branchmerge=True,
+force=False,
+partial=None,
+ancestor=base.node(),
+mergeancestor=True)
+hg._showstats(repo, stats)
+if stats[3]:
+repo.ui.status(_("use 'hg resolve' to retry unresolved file merges "
+"or 'hg update -C .' to abandon\n"))
+if stats[3] > 0:
+raise util.Abort('Merge conflict between several amendments, and this is not yet automated',
+hint="""/!\ You can try:
+/!\ * manual merge + resolve => new cset X
+/!\ * hg up to the parent of the amended changeset (which are named W and Z)
+/!\ * hg revert --all -r X
+/!\ * hg ci -m "same message as the amended changeset" => new cset Y
+/!\ * hg kill -n Y W Z
+""")
+tr = repo.transaction('stabilize-conflicting')
 try:
-if conflicting not in repo[None].parents():
+repo.dirstate.setparents(conflicting.node(), node.nullid)
-repo.ui.status(_('updating to "local" conflict\n'))
+oldlen = len(repo)
-hg.update(repo, conflicting.rev())
+amend(ui, repo)
-repo.ui.note(_('merging conflicting changeset\n'))
+if oldlen == len(repo):
-stats = merge.update(repo,
+new = conflicting
-other.node(),
+# no changes
-branchmerge=True,
+else:
-force=False,
+new = repo['.']
-partial=None,
+createmarkers(repo, [(other, (new,))])
-ancestor=base.node(),
+phases.retractboundary(repo, other.phase(), [new.node()])
-mergeancestor=True)
+tr.close()
-hg._showstats(repo, stats)
-if stats[3]:
-repo.ui.status(_("use 'hg resolve' to retry unresolved file merges "
-"or 'hg update -C .' to abandon\n"))
-#repo.dirstate.write()
-if stats[3] > 0:
-raise util.Abort('GASP! Merge Conflict! You are on you own chap!',
-hint='/!\\ hg evolve --continue will NOT work /!\\')
-tr = repo.transaction('stabilize-conflicting')
-try:
-repo.dirstate.setparents(conflicting.node(), node.nullid)
-oldlen = len(repo)
-amend(ui, repo)
-if oldlen == len(repo):
-new = conflicting
-# no changes
-else:
-new = repo['.']
-createmarkers(repo, [(other, (new,))])
-phases.retractboundary(repo, other.phase(), [new.node()])
-tr.close()
-finally:
-tr.release()
 finally:
-lock.release()
+tr.release()
 finally:
-wlock.release()
+lockmod.release(lock, wlock)
 def conflictingdata(ctx):
 """return base, other part of a conflict
 try:
 lock = repo.lock()
 try:
 new = set(noderange(repo, opts['new']))
 targetnodes = set(noderange(repo, revs))
+if not targetnodes:
+raise util.Abort('nothing to prune')
 if new:
 sucs = tuple(repo[n] for n in new)
 else:
 sucs = ()
 markers = []
 [('r', 'rev', [], 'revision to update'),],
 # allow to choose the seed ?
 _('[-r] revs'))
 def touch(ui, repo, *revs, **opts):
 """Create successors with exact same property but hash
-This is used to "resurect" changeset"""
+This is used to "resurrect" changesets
+"""
 revs = list(revs)
 revs.extend(opts['rev'])
 if not revs:
 revs = ['.']
 revs = scmutil.revrange(repo, revs)
 if not revs:
 ui.write_err('no revision to touch\n')
 return 1
 if repo.revs('public() and %ld', revs):
 raise util.Abort("can't touch public revision")
-wlock = repo.wlock()
+wlock = lock = None
 try:
+wlock = repo.wlock()
 lock = repo.lock()
+tr = repo.transaction('touch')
 try:
-tr = repo.transaction('touch')
+for r in revs:
-try:
+ctx = repo[r]
-for r in revs:
+extra = ctx.extra().copy()
-ctx = repo[r]
+extra['__touch-noise__'] = random.randint(0, 0xffffffff)
-extra = ctx.extra().copy()
+new, _ = rewrite(repo, ctx, [], ctx,
-extra['__touch-noise__'] = random.randint(0, 0xffffffff)
+[ctx.p1().node(), ctx.p2().node()],
-new, _ = rewrite(repo, ctx, [], ctx,
+commitopts={'extra': extra})
-[ctx.p1().node(), ctx.p2().node()],
+createmarkers(repo, [(ctx, (repo[new],))])
-commitopts={'extra': extra})
+phases.retractboundary(repo, ctx.phase(), [new])
-createmarkers(repo, [(ctx, (repo[new],))])
+if ctx in repo[None].parents():
-phases.retractboundary(repo, ctx.phase(), [new])
+repo.dirstate.setparents(new, node.nullid)
-if ctx in repo[None].parents():
+tr.close()
-repo.dirstate.setparents(new, node.nullid)
-tr.close()
-finally:
-tr.release()
 finally:
-lock.release()
+tr.release()
 finally:
-wlock.release()
+lockmod.release(lock, wlock)
 @command('^fold',
-[('r', 'rev', [], 'revision to fold'),],
+[('r', 'rev', [], 'revisions to fold'),],
 # allow to choose the seed ?
 _('[-r] revs'))
 def fold(ui, repo, *revs, **opts):
-"""Fold multiple revision into a single one"""
+"""Fold multiple revisions into a single one"""
 revs = list(revs)
 revs.extend(opts['rev'])
-if not revs:
+if revs:
-revs = ['.']
+revs = scmutil.revrange(repo, revs)
-revs = scmutil.revrange(repo, revs)
 if not revs:
 ui.write_err('no revision to fold\n')
 return 1
 roots = repo.revs('roots(%ld)', revs)
 if len(roots) > 1:
-raise util.Abort("set have multiple roots")
+raise util.Abort("set has multiple roots")
 root = repo[roots[0]]
 if root.phase() <= phases.public:
-raise util.Abort("can't touch public revision")
+raise util.Abort("can't fold public revisions")
 heads = repo.revs('heads(%ld)', revs)
 if len(heads) > 1:
-raise util.Abort("set have multiple heads")
+raise util.Abort("set has multiple heads")
 head = repo[heads[0]]
-wlock = repo.wlock()
+wlock = lock = None
 try:
+wlock = repo.wlock()
 lock = repo.lock()
+tr = repo.transaction('touch')
 try:
-tr = repo.transaction('touch')
+allctx = [repo[r] for r in revs]
-try:
+targetphase = max(c.phase() for c in allctx)
-allctx = [repo[r] for r in revs]
+msg = '\n\n***\n\n'.join(c.description() for c in allctx)
-targetphase = max(c.phase() for c in allctx)
+newid, _ = rewrite(repo, root, allctx, head,
-msg = '\n\n***\n\n'.join(c.description() for c in allctx)
+[root.p1().node(), root.p2().node()],
-newid, _ = rewrite(repo, root, allctx, head,
+commitopts={'message': msg})
-[root.p1().node(), root.p2().node()],
+phases.retractboundary(repo, targetphase, [newid])
-commitopts={'message': msg})
+createmarkers(repo, [(ctx, (repo[newid],))
-phases.retractboundary(repo, targetphase, [newid])
+for ctx in allctx])
-createmarkers(repo, [(ctx, (repo[newid],))
+tr.close()
-for ctx in allctx])
-tr.close()
-finally:
-tr.release()
 finally:
-lock.release()
+tr.release()
 ui.status('%i changesets folded\n' % len(revs))
 if repo.revs('. and %ld', revs):
-repo.dirstate.setparents(newid, node.nullid)
+hg.update(repo, newid)
 finally:
-wlock.release()
+lockmod.release(lock, wlock)
 @eh.wrapcommand('graft')
 def graftwrapper(orig, ui, repo, *revs, **kwargs):
 kwargs = dict(kwargs)
 try:
 rebase = extensions.find('rebase')
 except KeyError:
 raise error.Abort(_('evolution extension requires rebase extension.'))
-for cmd in ['amend', 'kill', 'uncommit']:
+for cmd in ['amend', 'kill', 'uncommit', 'touch', 'fold']:
 entry = extensions.wrapcommand(cmdtable, cmd,
 warnobserrors)
 entry = cmdutil.findcmd('commit', commands.table)[1]
 entry[1].append(('o', 'obsolete', [],

changeset 573	5a0a01c4c7c2
parent 572	dc107acd0bd2
child 576	cf116ffc9cc5