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

"""

import os, sys

try:

    from cStringIO import StringIO

except ImportError:

    from StringIO import StringIO

from mercurial.i18n import _

import json

import struct

from mercurial import util, base85

_pack = struct.pack

_unpack = struct.unpack

from mercurial import util

from mercurial import context

from mercurial import revset

from mercurial import scmutil

from mercurial import extensions

from mercurial import pushkey

from mercurial import discovery

from mercurial import error

from mercurial import commands

from mercurial import changelog

from mercurial import phases

from mercurial.node import hex, bin, short, nullid

from mercurial.lock import release

from mercurial import localrepo

from mercurial import cmdutil

from mercurial import templatekw

from mercurial import obsolete

obsolete._enabled = True

try:

    from mercurial.localrepo import storecache

    storecache('babar') # to trigger import

except (TypeError, ImportError):

    def storecache(*args):

        return scmutil.filecache(*args, instore=True)

### Patch changectx

#############################

def unstable(ctx):

    """is the changeset unstable (have obsolete ancestor)"""

    if ctx.node() is None:

        return False

    return ctx.rev() in ctx._repo._unstableset

context.changectx.unstable = unstable

def extinct(ctx):

    """is the changeset extinct by other"""

    if ctx.node() is None:

        return False

    return ctx.rev() in ctx._repo._extinctset

context.changectx.extinct = extinct

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

context.changectx.latecomer = latecomer

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

context.changectx.conflicting = conflicting

### revset

#############################

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]

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]

# XXX Backward compatibility, to be removed once stabilized

if '_phasecache' not in vars(localrepo.localrepository): # new api

    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._phaserev[r] > 0]

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]

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]

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]

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]

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]

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

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

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

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

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

#####################

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'

### Other Extension compat

############################

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:

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

                    else:

                        newnode = nullid

                    repo.addcollapsedobsolete(replacements, newnode)

                else:

                    for oldnode, newnode in replacements.iteritems():

                        repo.addobsolete(newnode, oldnode)

        return res

    finally:

        delattr(repo, '_rebasestate')