# 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 have been replace by another one.

:unstable:     a non-obsolet changeset based on another one.

: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

=================

Display and Exchange

....................

obsolete changesets are hidden. (except if they have non obsolete changeset)

obsolete changesets are currently not exchange. This will probably change later

but it was the simpler solution for now.

New commands

............

a ``debugobsolete`` command has been added.

It add an obsolete relation between too relation.

Context object

..............

Context gain a ``obsolete`` method that return True if a changeset is obsolete

False otherwise.

revset

......

Add an ``obsolete()`` entry.

repo extension

..............

To Do

-----

* refuse to obsolete published changesets

* handle split

* handle conflict

* handle unstable // out of sync

"""

import os

try:

    from cStringIO import StringIO

except ImportError:

    from StringIO import StringIO

from mercurial.i18n import _

import base64

import json

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

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 obsolete(ctx):

    """is the changeset obsolete by other"""

    if ctx.node()is None:

        return False

    return bool(ctx._repo.obsoletedby(ctx.node())) and ctx.phase()

context.changectx.obsolete = obsolete

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

### revset

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

def revsetobsolete(repo, subset, x):

    """obsolete changesets"""

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

    """non obsolete changesets descendant of obsolete one"""

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

    """obsolete changesets with non obsolete descendants"""

    args = revset.getargs(x, 0, 0, 'unstable takes no arguments')

    return [r for r in subset if r in repo._suspendedset]

def revsetextinct(repo, subset, x):

    """obsolete changesets without obsolete descendants"""

    args = revset.getargs(x, 0, 0, 'unstable takes no arguments')

    return [r for r in subset if r in repo._extinctset]

def _obsparents(repo, s):

    """obsolete parents of a subset"""

    cs = set()

    nm = repo.changelog.nodemap

    markerbysubj = repo.obsoletestore.subjects

    for r in s:

        for p in markerbysubj.get(repo[r].node(), ()):

            pr = nm.get(p['object'])

            if pr is not None:

                cs.add(pr)

    return cs

def revsetobsparents(repo, subset, x):

    """obsolete parents"""

    s = revset.getset(repo, range(len(repo)), x)

    cs = _obsparents(repo, s)

    return [r for r in subset if r in cs]

def _obsancestors(repo, s):

    """obsolete ancestors of a subset"""

    toproceed = [repo[r].node() for r in s]

    seen = set()

    allsubjects = repo.obsoletestore.subjects

    while toproceed:

        nc = toproceed.pop()

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

            np = mark['object']

            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 revsetobsancestors(repo, subset, x):

    """obsolete parents"""

    s = revset.getset(repo, range(len(repo)), x)

    cs = _obsancestors(repo, s)

    return [r for r in subset if r in cs]

### Other Extension compat

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

def buildstate(orig, repo, dest, rebaseset, detach):

    """wrapper for rebase 's buildstate that exclude obsolete changeset"""

    rebaseset = repo.revs('%ld - extinct()', rebaseset)

    return orig(repo, dest, rebaseset, detach)

def concludenode(orig, repo, rev, *args, **kwargs):

    """wrapper for rebase 's concludenode that set obsolete relation"""

    newrev = orig(repo, rev, *args, **kwargs)

    oldnode = repo[rev].node()

    newnode = repo[newrev].node()

    repo.addobsolete(newnode, oldnode)

    return newrev

def cmdrebase(orig, repo, ui, *args, **kwargs):

    oldkeep = kwargs.pop('keep', False)

    if oldkeep:

        ui.warn('WARNING --keep option ignored by experimental obsolete extension')

    kwargs['keep'] = True

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

def extsetup(ui):

    revset.symbols["obsolete"] = revsetobsolete

    revset.symbols["unstable"] = revsetunstable

    revset.symbols["suspended"] = revsetsuspended

    revset.symbols["extinct"] = revsetextinct

    revset.symbols["obsparents"] = revsetobsparents

    revset.symbols["obsancestors"] = revsetobsancestors

    try:

        rebase = extensions.find('rebase')

        if rebase:

            extensions.wrapfunction(rebase, 'buildstate', buildstate)

            extensions.wrapfunction(rebase, 'concludenode', concludenode)

            extensions.wrapcommand(rebase.cmdtable, "rebase", cmdrebase)

    except KeyError:

        pass # rebase not found

# Pushkey mechanism for mutable

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

def pushobsolete(repo, key, old, raw):

    """push obsolete relation through pushkey"""

    assert key == "markers"

    l = repo.lock()

    try:

        tmp = StringIO()

        tmp.write(raw)

        tmp.seek(0)

        repo.obsoletestore.load(tmp)

        repo.obsoletestore._dirty = True # XXX meh

        return 1

    finally:

        l.release()

def listobsolete(repo):

    """dump all obsolete relation in

    XXX this have be improved"""

    tmp = StringIO()

    repo.obsoletestore.save(tmp)

    return {'markers': base64.b64encode(tmp.getvalue())}

pushkey.register('obsolete', pushobsolete, listobsolete)

### Discovery wrapping

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

class blist(list, object):

    """silly class to have non False but empty list"""

    def __nonzero__(self):

        return bool(len(self.orig))

def wrapfindcommonoutgoing(orig, repo, *args, **kwargs):

    """wrap mercurial.discovery.findcommonoutgoing to remove extinct changeset

    Such excluded changeset are removed from excluded  and will *not* appear

    are excluded secret changeset.

    """

    outgoing = orig(repo, *args, **kwargs)

    orig = outgoing.excluded

    outgoing.excluded = blist(n for n in orig if not repo[n].extinct())

    # when no revision is specified (push everything) a shortcut is taken when

    # nothign was exclude. taking this code path when extinct changeset have

    # been excluded leads to repository corruption.

    outgoing.excluded.orig = orig

    return outgoing

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 only is enought because any thing base on obsolete

        # changeset is either obsolete or unstable.

        ctx =  repo[h]

        hint = _("use 'hg stabilize' to get a stable history (or --force to proceed)")

        if ctx.unstable():

            raise util.Abort(_("Trying to push unstable changeset: %s!") % ctx,

                             hint=hint)

        if ctx.obsolete():

            raise util.Abort(_("Trying to push obsolete changeset: %s!") % ctx,

                             hint=hint)

    ### patch remote branch map

    # do not read it this burn eyes

    try:

        if 'oldbranchmap' not in vars(remote):

            remote.oldbranchmap = remote.branchmap

            def branchmap():

                newbm = {}

                oldbm = None

                if (util.safehasattr(phases, 'visiblebranchmap')

                    and not util.safehasattr(remote, 'ignorevisiblebranchmap')

                   ):

                    remote.ignorevisiblebranchmap = False

                    remote.branchmap = remote.oldbranchmap

                    oldbm = phases.visiblebranchmap(remote)

                    remote.branchmap = remote.newbranchmap

                    remote.ignorevisiblebranchmap = True

                if oldbm is None:

                    oldbm = remote.oldbranchmap()

                for branch, nodes in oldbm.iteritems():

                    nodes = list(nodes)

                    new = set()

                    while nodes:

                        n = nodes.pop()

                        if n in repo.obsoletestore.objects:

                            markers = repo.obsoletestore.objects[n]

                            for mark in markers:

                                for newernode in mark['subjects']:

                                    if newernode is not None:

                                        nodes.append(newernode)

                        else:

                            new.add(n)

                    if new:

                        newbm[branch] = list(new)

                return newbm

            remote.ignorevisiblebranchmap = True

            remote.branchmap = branchmap

            remote.newbranchmap = branchmap

        return orig(repo, remote, outgoing, *args, **kwargs)

    finally:

        remote.__dict__.pop('branchmap', None) # restore class one

        remote.__dict__.pop('oldbranchmap', None)

        remote.__dict__.pop('newbranchmap', None)

        remote.__dict__.pop('ignorevisiblebranchmap', None)

# eye are still burning

def wrapvisiblebranchmap(orig, repo):

    ignore = getattr(repo, 'ignorevisiblebranchmap', None)

    if ignore is None:

        return orig(repo)

    elif ignore:

        return repo.branchmap()

    else:

        return None # break recursion

### New commands

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

def cmddebugobsolete(ui, repo, subject, object):

    """Add an obsolete relation between a too node

    The subject is expected to be a newer version of the object"""

    lock = repo.lock()

    try:

        sub = repo[subject]