drop repo.addobsolete
We now use createmarkers directly.
No black magic with nullid is done anymore.
# obsolete.py - introduce the obsolete concept in mercurial.
#
# Copyright 2011 Pierre-Yves David <pierre-yves.david@ens-lyon.org>
# Logilab SA <contact@logilab.fr>
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.
"""Introduce the Obsolete concept to mercurial
General concept
===============
This extension introduces the *obsolete* concept. It adds a new *obsolete*
relation between two changesets. A relation ``<changeset B> obsolete <changeset
A>`` is set to denote that ``<changeset B>`` is new version of ``<changeset
A>``.
The *obsolete* relation act as a **perpendicular history** to the standard
changeset history. Standard changeset history versions files. The *obsolete*
relation versions changesets.
:obsolete: a changeset that has been replaced by another one.
:unstable: a changeset that is not obsolete but has an obsolete ancestor.
:suspended: an obsolete changeset with unstable descendant.
:extinct: an obsolete changeset without unstable descendant.
(subject to garbage collection)
Another name for unstable could be out of sync.
Usage and Feature
=================
New commands
------------
Note that rebased changesets are now marked obsolete instead of being stripped.
"""
from mercurial import util
try:
from mercurial import obsolete
obsolete._enabled = True
except ImportError:
raise util.Abort('Obsolete extension requires Mercurial 2.3 (or later)')
import sys
from mercurial.i18n import _
from mercurial import cmdutil
from mercurial import commands
from mercurial import context
from mercurial import discovery
from mercurial import error
from mercurial import extensions
from mercurial import phases
from mercurial import revset
from mercurial import scmutil
from mercurial import templatekw
from mercurial.node import bin, short, nullid
# This extension hold the following code
#
# - Extension Helper code
# - ...
# - Older format compat
#####################################################################
### Extension helper ###
#####################################################################
class exthelper(object):
"""Helper for modular extension setup
A single helper should be intanciated for each extension. Helper method are
then used as decorator for various purpose.
All decorator returns the original function and may be chained.
"""
def __init__(self):
self._uicallables = []
self._extcallables = []
self._repocallables = []
self._revsetsymbols = []
self._templatekws = []
self._commandwrappers = []
self._extcommandwrappers = []
self._functionwrappers = []
self._duckpunchers = []
def final_uisetup(self, ui):
"""Method to be used as a the extension uisetup
The following operations belong here:
- Changes to ui.__class__ . The ui object that will be used to run the
command has not yet been created. Changes made here will affect ui
objects created after this, and in particular the ui that will be
passed to runcommand
- Command wraps (extensions.wrapcommand)
- Changes that need to be visible by other extensions: because
initialization occurs in phases (all extensions run uisetup, then all
run extsetup), a change made here will be visible by other extensions
during extsetup
- Monkeypatches or function wraps (extensions.wrapfunction) of dispatch
module members
- Setup of pre-* and post-* hooks
- pushkey setup
"""
for cont, funcname, func in self._duckpunchers:
setattr(cont, funcname, func)
for command, wrapper in self._commandwrappers:
extensions.wrapcommand(commands.table, command, wrapper)
for cont, funcname, wrapper in self._functionwrappers:
extensions.wrapfunction(cont, funcname, wrapper)
for c in self._uicallables:
c(ui)
def final_extsetup(self, ui):
"""Method to be used as a the extension extsetup
The following operations belong here:
- Changes depending on the status of other extensions. (if extensions.find('mq'))
- Add a global option to all commands
- Extend revsets
"""
knownexts = {}
for name, symbol in self._revsetsymbols:
revset.symbols[name] = symbol
for name, kw in self._templatekws:
templatekw.keywords[name] = kw
for ext, command, wrapper in self._extcommandwrappers:
if ext not in knownexts:
e = extensions.find('rebase')
if e is None:
raise util.Abort('extension %s not found' %e)
knownexts[ext] = e.cmdtable
extensions.wrapcommand(knownexts[ext], commands, wrapper)
for c in self._extcallables:
c(ui)
def final_reposetup(self, ui, repo):
"""Method to be used as a the extension reposetup
The following operations belong here:
- All hooks but pre-* and post-*
- Modify configuration variables
- Changes to repo.__class__, repo.dirstate.__class__
"""
for c in self._repocallables:
c(ui, repo)
def uisetup(self, call):
"""Decorated function will be executed during uisetup
example::
@eh.uisetup
def setupbabar(ui):
print 'this is uisetup!'
"""
self._uicallables.append(call)
return call
def extsetup(self, call):
"""Decorated function will be executed during extsetup
example::
@eh.extsetup
def setupcelestine(ui):
print 'this is extsetup!'
"""
self._uicallables.append(call)
return call
def reposetup(self, call):
"""Decorated function will be executed during reposetup
example::
@eh.reposetup
def setupzephir(ui, repo):
print 'this is reposetup!'
"""
self._repocallables.append(call)
return call
def revset(self, symbolname):
"""Decorated function is a revset symbol
The name of the symbol must be given as the decorator argument.
The symbol is added during `extsetup`.
example::
@eh.revset('hidden')
def revsetbabar(repo, subset, x):
args = revset.getargs(x, 0, 0, 'babar accept no argument')
return [r for r in subset if 'babar' in repo[r].description()]
"""
def dec(symbol):
self._revsetsymbols.append((symbolname, symbol))
return symbol
return dec
def templatekw(self, keywordname):
"""Decorated function is a revset keyword
The name of the keyword must be given as the decorator argument.
The symbol is added during `extsetup`.
example::
@eh.templatekw('babar')
def kwbabar(ctx):
return 'babar'
"""
def dec(keyword):
self._templatekws.append((keywordname, keyword))
return keyword
return dec
def wrapcommand(self, command, extension=None):
"""Decorated function is a command wrapper
The name of the command must be given as the decorator argument.
The wrapping is installed during `uisetup`.
If the second option `extension` argument is provided, the wrapping
will be applied in the extension commandtable. This argument must be a
string that will be searched using `extension.find` if not found and
Abort error is raised. If the wrapping apply to an extension, it is
installed during `extsetup`
example::
@eh.wrapcommand('summary')
def wrapsummary(orig, ui, repo, *args, **kwargs):
ui.note('Barry!')
return orig(ui, repo, *args, **kwargs)
"""
def dec(wrapper):
if extension is None:
self._commandwrappers.append((command, wrapper))
else:
self._extcommandwrappers.append((extension, command, wrapper))
return wrapper
return dec
def wrapfunction(self, container, funcname):
"""Decorated function is a function wrapper
This function take two argument, the container and the name of the
function to wrap. The wrapping is performed during `uisetup`.
(there is don't support extension)
example::
@eh.function(discovery, 'checkheads')
def wrapfunction(orig, *args, **kwargs):
ui.note('His head smashed in and his heart cut out')
return orig(*args, **kwargs)
"""
def dec(wrapper):
self._functionwrappers.append((container, funcname, wrapper))
return wrapper
return dec
def addattr(self, container, funcname):
"""Decorated function is to be added to the container
This function take two argument, the container and the name of the
function to wrap. The wrapping is performed during `uisetup`.
example::
@eh.function(context.changectx, 'babar')
def babar(ctx):
return 'babar' in ctx.description
"""
def dec(func):
self._duckpunchers.append((container, funcname, func))
return func
return dec
eh = exthelper()
uisetup = eh.final_uisetup
extsetup = eh.final_extsetup
reposetup = eh.final_reposetup
#####################################################################
### Obsolescence Caching Logic ###
#####################################################################
@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 ctx._repo._unstableset
@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 ctx._repo._extinctset
@eh.revset('obsolete')
def revsetobsolete(repo, subset, x):
"""``obsolete()``
Changeset is obsolete.
"""
args = revset.getargs(x, 0, 0, 'obsolete takes no argument')
return [r for r in subset if r in repo._obsoleteset and repo._phasecache.phase(repo, r) > 0]
@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')
return [r for r in subset if r in repo._unstableset]
@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')
return [r for r in subset if r in repo._extinctset]
@eh.wrapfunction(phases, 'advanceboundary')
def wrapclearcache(orig, repo, *args, **kwargs):
try:
return orig(repo, *args, **kwargs)
finally:
repo._clearobsoletecache()
@eh.reposetup
def _repocachesetup(ui, repo):
if not repo.local():
return
o_updatebranchcache = repo.updatebranchcache
class cachedobsolescencegrepo(repo.__class__):
# XXX move me on obssotre
@util.propertycache
def _obsoleteset(self):
"""the set of obsolete revision"""
obs = set()
nm = self.changelog.nodemap
for prec in self.obsstore.precursors:
rev = nm.get(prec)
if rev is not None:
obs.add(rev)
return obs
# XXX move me on obssotre
@util.propertycache
def _unstableset(self):
"""the set of non obsolete revision with obsolete parent"""
return set(self.revs('(obsolete()::) - obsolete()'))
# XXX move me on obssotre
@util.propertycache
def _suspendedset(self):
"""the set of obsolete parent with non obsolete descendant"""
return set(self.revs('obsolete() and obsolete()::unstable()'))
# XXX move me on obssotre
@util.propertycache
def _extinctset(self):
"""the set of obsolete parent without non obsolete descendant"""
return set(self.revs('obsolete() - obsolete()::unstable()'))
# XXX move me on obssotre
@util.propertycache
def _latecomerset(self):
"""the set of rev trying to obsolete public revision"""
query = 'allsuccessors(public()) - obsolete() - public()'
return set(self.revs(query))
# XXX move me on obssotre
@util.propertycache
def _conflictingset(self):
"""the set of rev trying to obsolete public revision"""
conflicting = set()
obsstore = self.obsstore
newermap = {}
for ctx in self.set('(not public()) - obsolete()'):
prec = obsstore.successors.get(ctx.node(), ())
toprocess = set(prec)
while toprocess:
prec = toprocess.pop()[0]
if prec not in newermap:
newermap[prec] = newerversion(self, prec)
newer = [n for n in newermap[prec] if n] # filter kill
if len(newer) > 1:
conflicting.add(ctx.rev())
break
toprocess.update(obsstore.successors.get(prec, ()))
return conflicting
def _clearobsoletecache(self):
if '_obsoleteset' in vars(self):
del self._obsoleteset
self._clearunstablecache()
def updatebranchcache(self):
o_updatebranchcache()
self._clearunstablecache()
def _clearunstablecache(self):
if '_unstableset' in vars(self):
del self._unstableset
if '_suspendedset' in vars(self):
del self._suspendedset
if '_extinctset' in vars(self):
del self._extinctset
if '_latecomerset' in vars(self):
del self._latecomerset
if '_conflictingset' in vars(self):
del self._conflictingset
repo.__class__ = cachedobsolescencegrepo
#####################################################################
### Complete troubles computation logic ###
#####################################################################
@eh.addattr(context.changectx, 'latecomer')
def latecomer(ctx):
"""is the changeset latecomer (Try to succeed to public change)"""
if ctx.node() is None:
return False
return ctx.rev() in ctx._repo._latecomerset
@eh.addattr(context.changectx, 'conflicting')
def conflicting(ctx):
"""is the changeset conflicting (Try to succeed to public change)"""
if ctx.node() is None:
return False
return ctx.rev() in ctx._repo._conflictingset
#####################################################################
### Additional Utilities functions ###
#####################################################################
def _precursors(repo, s):
"""Precursor of a changeset"""
cs = set()
nm = repo.changelog.nodemap
markerbysubj = repo.obsstore.successors
for r in s:
for p in markerbysubj.get(repo[r].node(), ()):
pr = nm.get(p[0])
if pr is not None:
cs.add(pr)
return cs
def _allprecursors(repo, s): # XXX we need a better naming
"""transitive precursors of a subset"""
toproceed = [repo[r].node() for r in s]
seen = set()
allsubjects = repo.obsstore.successors
while toproceed:
nc = toproceed.pop()
for mark in allsubjects.get(nc, ()):
np = mark[0]
if np not in seen:
seen.add(np)
toproceed.append(np)
nm = repo.changelog.nodemap
cs = set()
for p in seen:
pr = nm.get(p)
if pr is not None:
cs.add(pr)
return cs
def _successors(repo, s):
"""Successors of a changeset"""
cs = set()
nm = repo.changelog.nodemap
markerbyobj = repo.obsstore.precursors
for r in s:
for p in markerbyobj.get(repo[r].node(), ()):
for sub in p[1]:
sr = nm.get(sub)
if sr is not None:
cs.add(sr)
return cs
def _allsuccessors(repo, s): # XXX we need a better naming
"""transitive successors of a subset"""
toproceed = [repo[r].node() for r in s]
seen = set()
allobjects = repo.obsstore.precursors
while toproceed:
nc = toproceed.pop()
for mark in allobjects.get(nc, ()):
for sub in mark[1]:
if sub not in seen:
seen.add(sub)
toproceed.append(sub)
nm = repo.changelog.nodemap
cs = set()
for s in seen:
sr = nm.get(s)
if sr is not None:
cs.add(sr)
return cs
### diagnostique tools
def unstables(repo):
"""Return all unstable changeset"""
return scmutil.revrange(repo, ['obsolete():: and (not obsolete())'])
def newerversion(repo, obs):
"""Return the newer version of an obsolete changeset"""
toproceed = set([(obs,)])
# XXX known optimization available
newer = set()
objectrels = repo.obsstore.precursors
while toproceed:
current = toproceed.pop()
assert len(current) <= 1, 'splitting not handled yet. %r' % current
current = [n for n in current if n != nullid]
if current:
n, = current
if n in objectrels:
markers = objectrels[n]
for mark in markers:
toproceed.add(tuple(mark[1]))
else:
newer.add(tuple(current))
else:
newer.add(())
return sorted(newer)
def createmarkers(repo, relations, metadata=None, flag=0):
"""Add obsolete markers between changeset in a repo
<relations> must be an iterable of (<old>, (<new>, ...)) tuple.
`old` and `news` are changectx.
Current user and date are used except if specified otherwise in the
metadata attribute.
/!\ assume the repo have been locked byt the user /!\
"""
# prepare metadata
if metadata is None:
metadata = {}
if 'date' not in metadata:
metadata['date'] = '%i %i' % util.makedate()
if 'user' not in metadata:
metadata['user'] = repo.ui.username()
# check future marker
tr = repo.transaction('add-obsolescence-marker')
try:
for prec, sucs in relations:
if not prec.mutable():
raise util.Abort("Cannot obsolete immutable changeset: %s" % prec)
nprec = prec.node()
nsucs = tuple(s.node() for s in sucs)
if nprec in nsucs:
raise util.Abort("Changeset %s cannot obsolete himself" % prec)
repo.obsstore.create(tr, nprec, nsucs, flag, metadata)
repo._clearobsoletecache()
tr.close()
finally:
tr.release()
#####################################################################
### Extending revset and template ###
#####################################################################
@eh.revset('hidden')
def revsethidden(repo, subset, x):
"""``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]
## troubles
@eh.revset('suspended')
def revsetsuspended(repo, subset, x):
"""``suspended()``
Obsolete changesets with non-obsolete descendants.
"""
args = revset.getargs(x, 0, 0, 'suspended takes no arguments')
return [r for r in subset if r in repo._suspendedset]
@eh.revset('latecomer')
def revsetlatecomer(repo, subset, x):
"""``latecomer()``
Changesets marked as successors of public changesets.
"""
args = revset.getargs(x, 0, 0, 'latecomer takes no arguments')
return [r for r in subset if r in repo._latecomerset]
@eh.revset('conflicting')
def revsetconflicting(repo, subset, x):
"""``conflicting()``
Changesets marked as successors of a same changeset.
"""
args = revset.getargs(x, 0, 0, 'conflicting takes no arguments')
return [r for r in subset if r in repo._conflictingset]
@eh.revset('obsparents') # XXX kill me
@eh.revset('precursors')
def revsetprecursors(repo, subset, x):
"""``precursors(set)``
Immediate precursors of changesets in set.
"""
s = revset.getset(repo, range(len(repo)), x)
cs = _precursors(repo, s)
return [r for r in subset if r in cs]
@eh.revset('obsancestors') # XXX kill me
@eh.revset('allprecursors')
def revsetallprecursors(repo, subset, x):
"""``allprecursors(set)``
Transitive precursors of changesets in set.
"""
s = revset.getset(repo, range(len(repo)), x)
cs = _allprecursors(repo, s)
return [r for r in subset if r in cs]
@eh.revset('obschildrend') # XXX kill me
@eh.revset('successors')
def revsetsuccessors(repo, subset, x):
"""``successors(set)``
Immediate successors of changesets in set.
"""
s = revset.getset(repo, range(len(repo)), x)
cs = _successors(repo, s)
return [r for r in subset if r in cs]
@eh.revset('obsdescendants') # XXX kill me
@eh.revset('allsuccessors')
def revsetallsuccessors(repo, subset, x):
"""``allsuccessors(set)``
Transitive successors of changesets in set.
"""
s = revset.getset(repo, range(len(repo)), x)
cs = _allsuccessors(repo, s)
return [r for r in subset if r in cs]
### template keywords
@eh.templatekw('obsolete')
def obsoletekw(repo, ctx, templ, **args):
""":obsolete: String. The obsolescence level of the node, could be
``stable``, ``unstable``, ``suspended`` or ``extinct``.
"""
rev = ctx.rev()
if rev in repo._extinctset:
return 'extinct'
if rev in repo._suspendedset:
return 'suspended'
if rev in repo._unstableset:
return 'unstable'
return 'stable'
#####################################################################
### Various trouble warning ###
#####################################################################
### Discovery wrapping
@eh.wrapfunction(discovery, 'checkheads')
def wrapcheckheads(orig, repo, remote, outgoing, *args, **kwargs):
"""wrap mercurial.discovery.checkheads
* prevent unstability to be pushed
* patch remote to ignore obsolete heads on remote
"""
# do not push instability
for h in outgoing.missingheads:
# Checking heads is enough, obsolete descendants are either
# obsolete or unstable.
ctx = repo[h]
if ctx.latecomer():
raise util.Abort(_("push includes a latecomer changeset: %s!")
% ctx)
if ctx.conflicting():
raise util.Abort(_("push includes a conflicting changeset: %s!")
% ctx)
return orig(repo, remote, outgoing, *args, **kwargs)
@eh.wrapcommand("update")
@eh.wrapcommand("pull")
def wrapmayobsoletewc(origfn, ui, repo, *args, **opts):
res = origfn(ui, repo, *args, **opts)
if repo['.'].obsolete():
ui.warn(_('Working directory parent is obsolete\n'))
return res
@eh.wrapcommand("commit")
@eh.wrapcommand("push")
@eh.wrapcommand("pull")
@eh.wrapcommand("graft")
@eh.wrapcommand("phase")
@eh.wrapcommand("unbundle")
def warnobserrors(orig, ui, repo, *args, **kwargs):
"""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()'))
#print orig, priorunstables
#print len(repo.revs('secret() - obsolete()'))
try:
return orig(ui, repo, *args, **kwargs)
finally:
newunstables = len(repo.revs('unstable()')) - priorunstables
newlatecomers = len(repo.revs('latecomer()')) - priorlatecomers
newconflictings = len(repo.revs('conflicting()')) - priorconflictings
#print orig, newunstables
#print len(repo.revs('secret() - obsolete()'))
if newunstables > 0:
ui.warn(_('%i new unstables changesets\n') % newunstables)
if newlatecomers > 0:
ui.warn(_('%i new latecomers changesets\n') % newlatecomers)
if newconflictings > 0:
ui.warn(_('%i new conflictings changesets\n') % newconflictings)
@eh.reposetup
def _repostabilizesetup(ui, repo):
if not repo.local():
return
opush = repo.push
class stabilizerrepo(repo.__class__):
def push(self, remote, *args, **opts):
"""wrapper around pull that pull obsolete relation"""
try:
result = opush(remote, *args, **opts)
except util.Abort, ex:
hint = _("use 'hg stabilize' to get a stable history "
"or --force to ignore warnings")
if (len(ex.args) >= 1
and ex.args[0].startswith('push includes ')
and ex.hint is None):
ex.hint = hint
raise
return result
repo.__class__ = stabilizerrepo
#####################################################################
### Other extension compat ###
#####################################################################
### commit --amend
@eh.wrapfunction(cmdutil, 'amend')
def wrapcmdutilamend(orig, ui, repo, commitfunc, old, *args, **kwargs):
oldnode = old.node()
new = orig(ui, repo, commitfunc, old, *args, **kwargs)
if new != oldnode:
lock = repo.lock()
try:
tr = repo.transaction('post-amend-obst')
try:
meta = {
'date': '%i %i' % util.makedate(),
'user': ui.username(),
}
repo.obsstore.create(tr, oldnode, [new], 0, meta)
tr.close()
repo._clearobsoletecache()
finally:
tr.release()
finally:
lock.release()
return new
### rebase
def buildstate(orig, repo, dest, rebaseset, *ags, **kws):
"""wrapper for rebase 's buildstate that exclude obsolete changeset"""
rebaseset = repo.revs('%ld - extinct()', rebaseset)
return orig(repo, dest, rebaseset, *ags, **kws)
def defineparents(orig, repo, rev, target, state, *args, **kwargs):
rebasestate = getattr(repo, '_rebasestate', None)
if rebasestate is not None:
repo._rebasestate = dict(state)
repo._rebasetarget = target
return orig(repo, rev, target, state, *args, **kwargs)
def concludenode(orig, repo, rev, p1, *args, **kwargs):
"""wrapper for rebase 's concludenode that set obsolete relation"""
newrev = orig(repo, rev, p1, *args, **kwargs)
rebasestate = getattr(repo, '_rebasestate', None)
if rebasestate is not None:
if newrev is not None:
nrev = repo[newrev].rev()
else:
nrev = p1
repo._rebasestate[rev] = nrev
return newrev
def cmdrebase(orig, ui, repo, *args, **kwargs):
reallykeep = kwargs.get('keep', False)
kwargs = dict(kwargs)
kwargs['keep'] = True
# We want to mark rebased revision as obsolete and set their
# replacements if any. Doing it in concludenode() prevents
# aborting the rebase, and is not called with all relevant
# revisions in --collapse case. Instead, we try to track the
# rebase state structure by sampling/updating it in
# defineparents() and concludenode(). The obsolete markers are
# added from this state after a successful call.
repo._rebasestate = {}
repo._rebasetarget = None
try:
l = repo.lock()
try:
res = orig(ui, repo, *args, **kwargs)
if not reallykeep:
# Filter nullmerge or unrebased entries
repo._rebasestate = dict(p for p in repo._rebasestate.iteritems()
if p[1] >= 0)
if not res and not kwargs.get('abort') and repo._rebasestate:
# Rebased revisions are assumed to be descendants of
# targetrev. If a source revision is mapped to targetrev
# or to another rebased revision, it must have been
# removed.
targetrev = repo[repo._rebasetarget].rev()
newrevs = set([targetrev])
replacements = {}
for rev, newrev in sorted(repo._rebasestate.items()):
oldnode = repo[rev].node()
if newrev not in newrevs:
newnode = repo[newrev].node()
newrevs.add(newrev)
else:
newnode = nullid
replacements[oldnode] = newnode
if kwargs.get('collapse'):
newnodes = set(n for n in replacements.values() if n != nullid)
if newnodes:
# Collapsing into more than one revision?
assert len(newnodes) == 1, newnodes
newnode = newnodes.pop()
markers = [(repo[r], (repo[newnode],))
for r in replacements]
else:
newnode = nullid
markers = [(repo[r], ())
for r in replacements]
createmarkers(repo, markers)
elif replacements:
markers = [(repo[o], (() if n == nullid else (repo[n],)))
for o, n in replacements.iteritems()]
createmarkers(repo, markers)
return res
finally:
l.release()
finally:
delattr(repo, '_rebasestate')
delattr(repo, '_rebasetarget')
@eh.extsetup
def _rebasewrapping(ui):
# warning about more obsolete
try:
rebase = extensions.find('rebase')
if rebase:
entry = extensions.wrapcommand(rebase.cmdtable, 'rebase', warnobserrors)
extensions.wrapfunction(rebase, 'buildstate', buildstate)
extensions.wrapfunction(rebase, 'defineparents', defineparents)
extensions.wrapfunction(rebase, 'concludenode', concludenode)
extensions.wrapcommand(rebase.cmdtable, "rebase", cmdrebase)
except KeyError:
pass # rebase not found
#####################################################################
### Older format management ###
#####################################################################
# Code related to detection and management of older legacy format never
# handled by core
import json
@eh.reposetup
def _checkoldobsolete(ui, repo):
"""Detect that a repo still carry some old obsolete format
"""
if not repo.local():
return
for arg in sys.argv:
if 'debugc' in arg:
break
else:
data = repo.opener.tryread('obsolete-relations')
if not data:
data = repo.sopener.tryread('obsoletemarkers')
if data:
raise util.Abort('old format of obsolete marker detected!\n'
'run `hg debugconvertobsolete` once.')
def _obsdeserialise(flike):
"""read a file like object serialised with _obsserialise
this desierialize into a {subject -> objects} mapping"""
rels = {}
for line in flike:
subhex, objhex = line.split()
subnode = bin(subhex)
if subnode == nullid:
subnode = None
rels.setdefault( subnode, set()).add(bin(objhex))
return rels
cmdtable = {}
command = cmdutil.command(cmdtable)
@command('debugconvertobsolete', [], '')
def cmddebugconvertobsolete(ui, repo):
"""import markers from an .hg/obsolete-relations file"""
cnt = 0
err = 0
l = repo.lock()
some = False
try:
unlink = []
tr = repo.transaction('convert-obsolete')
try:
repo._importoldobsolete = True
store = repo.obsstore
### very first format
try:
f = repo.opener('obsolete-relations')
try:
some = True
for line in f:
subhex, objhex = line.split()
suc = bin(subhex)
prec = bin(objhex)
sucs = (suc==nullid) and [] or [suc]
meta = {
'date': '%i %i' % util.makedate(),
'user': ui.username(),
}
try:
store.create(tr, prec, sucs, 0, meta)
cnt += 1
except ValueError:
repo.ui.write_err("invalid old marker line: %s"
% (line))
err += 1
finally:
f.close()
unlink.append(repo.join('obsolete-relations'))
except IOError:
pass
### second (json) format
data = repo.sopener.tryread('obsoletemarkers')
if data:
some = True
for oldmark in json.loads(data):
del oldmark['id'] # dropped for now
del oldmark['reason'] # unused until then
oldobject = str(oldmark.pop('object'))
oldsubjects = [str(s) for s in oldmark.pop('subjects', [])]
LOOKUP_ERRORS = (error.RepoLookupError, error.LookupError)
if len(oldobject) != 40:
try:
oldobject = repo[oldobject].node()
except LOOKUP_ERRORS:
pass
if any(len(s) != 40 for s in oldsubjects):
try:
oldsubjects = [repo[s].node() for s in oldsubjects]
except LOOKUP_ERRORS:
pass
oldmark['date'] = '%i %i' % tuple(oldmark['date'])
meta = dict((k.encode('utf-8'), v.encode('utf-8'))
for k, v in oldmark.iteritems())
try:
succs = [bin(n) for n in oldsubjects]
succs = [n for n in succs if n != nullid]
store.create(tr, bin(oldobject), succs,
0, meta)
cnt += 1
except ValueError:
repo.ui.write_err("invalid marker %s -> %s\n"
% (oldobject, oldsubjects))
err += 1
unlink.append(repo.sjoin('obsoletemarkers'))
tr.close()
for path in unlink:
util.unlink(path)
finally:
tr.release()
finally:
del repo._importoldobsolete
l.release()
if not some:
ui.warn('nothing to do\n')
ui.status('%i obsolete marker converted\n' % cnt)
if err:
ui.write_err('%i conversion failed. check you graph!\n' % err)