annotate hgext/obsolete.py @ 447:fa85e7205e0b

obsolete: move caches on obsstore

No need to clutter local repo

# obsolete.py - introduce the obsolete concept in mercurial.
#
# Copyright 2011 Pierre-Yves David <[e-mail]>
#                Logilab SA        <[e-mail]>
#
# 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 localrepo
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                                    ###
#####################################################################

### compute cache functions

computecache = {}
def cachefor(name):
    """Decorator to register a function as computing the cache for a set"""
    def decorator(func):
        assert name not in computecache
        computecache[name] = func
        return func
    return decorator

@cachefor('obsolete')
def _computeobsoleteset(repo):
    """the set of obsolete revision"""
    obs = set()
    nm = repo.changelog.nodemap
    for prec in repo.obsstore.precursors:
        rev = nm.get(prec)
        if rev is not None:
            obs.add(rev)
    return set(repo.revs('%ld - public()', obs))

@cachefor('unstable')
def _computeunstableset(repo):
    """the set of non obsolete revision with obsolete parent"""
    return set(repo.revs('(obsolete()::) - obsolete()'))

@cachefor('suspended')
def _computesuspendedset(repo):
    """the set of obsolete parent with non obsolete descendant"""
    return set(repo.revs('obsolete() and obsolete()::unstable()'))

@cachefor('extinct')
def _computeextinctset(repo):
    """the set of obsolete parent without non obsolete descendant"""
    return set(repo.revs('obsolete() - obsolete()::unstable()'))

@cachefor('latecomer')
def _computelatecomerset(repo):
    """the set of rev trying to obsolete public revision"""
    query = 'allsuccessors(public()) - obsolete() - public()'
    return set(repo.revs(query))

@cachefor('conflicting')
def _computeconflictingset(repo):
    """the set of rev trying to obsolete public revision"""
    conflicting = set()
    obsstore = repo.obsstore
    newermap = {}
    for ctx in repo.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(repo, 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

@eh.wrapfunction(obsolete.obsstore, '__init__')
def _initobsstorecache(orig, obsstore, *args, **kwargs):
    """add a caches attributes to obsstore"""
    obsstore.caches = {}
    return orig(obsstore, *args, **kwargs)

def getobscache(repo, name):
    if not repo.obsstore:
        return ()
    if name not in repo.obsstore.caches:
        repo.obsstore.caches[name] = computecache[name](repo)
    return repo.obsstore.caches[name]


### cache clean up
def clearobscaches(repo):
    #if 'obsstore' in vars(repo):
    # should work great but cache invalidation act strange
    repo.obsstore.caches.clear()

@eh.wrapfunction(localrepo.localrepository, 'updatebranchcache')
@eh.wrapfunction(phases, 'advanceboundary')
def wrapclearcache(orig, repo, *args, **kwargs):
    try:
        return orig(repo, *args, **kwargs)
    finally:
        clearobscaches(repo)

@eh.wrapfunction(obsolete.obsstore, 'add')
def clearonadd(orig, obsstore, *args, **kwargs):
    try:
        return orig(obsstore, *args, **kwargs)
    finally:
        obsstore.caches.clear()

### cache user

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

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

@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 getobscache(ctx._repo, 'latecomer')

@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 getobscache(ctx._repo, 'conflicting')


#####################################################################
### Additional Utilities                                          ###
#####################################################################

@eh.uisetup
def _installalias(ui):
    if ui.config('alias', 'pstatus', None) is None:
        ui.setconfig('alias', 'pstatus', 'status --rev .^')
    if ui.config('alias', 'pdiff', None) is None:
        ui.setconfig('alias', 'pdiff', 'diff --rev .^')

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)
            clearobscaches(repo)
        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')
    suspended = getobscache(repo, 'suspended')
    return [r for r in subset if r in suspended]

@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')
    lates = getobscache(repo, 'latecomer')
    return [r for r in subset if r in lates]

@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')
    conf = getobscache(repo, 'conflicting')
    return [r for r in subset if r in conf]


@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('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('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('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 ctx.obsolete():
        if ctx.extinct():
            return 'extinct'
        else:
            return 'suspended'
    elif ctx.unstable():
        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()
                clearobscaches(repo)
            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)