# 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.
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.node import hex, bin
# 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()))
context.changectx.obsolete = obsolete
ohidden = context.changectx.hidden
def hidden(ctx):
# hack to fill hiddenrevs
# compute hidden (XXX should move elsewhere)
if not getattr(ctx._repo.changelog, 'hiddeninit', False):
basicquery = 'obsolete() - (ancestors(not obsolete() or . or bookmark()))'
for rev in scmutil.revrange(ctx._repo, [basicquery]):
ctx._repo.changelog.hiddenrevs.add(rev)
ctx._repo.changelog.hiddeninit = True
return ohidden(ctx)
context.changectx.hidden = hidden
# revset
#############################
def revsetobsolete(repo, subset, x):
args = revset.getargs(x, 0, 0, 'publicheads takes no arguments')
return [r for r in subset if repo[r].obsolete()] # XXX slow
def extsetup(ui):
revset.symbols["obsolete"] = revsetobsolete
try:
rebase = extensions.find('rebase')
if rebase:
extensions.wrapfunction(rebase, 'concludenode', concludenode)
except KeyError:
pass # rebase not found
# Pushkey mechanism for mutable
#########################################
def pushobsolete(repo, key, old, relations):
assert key == "relations"
w = repo.wlock()
try:
for sub, objs in relations.iteritems():
for obj in objs:
repo.addobsolete(sub, obj)
finally:
w.release()
def listobsolete(repo):
return {'relations': repo._obssubrels}
pushkey.register('obsolete', pushobsolete, listobsolete)
# 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"""
sub = repo[subject]
obj = repo[object]
repo.addobsolete(sub.node(), obj.node())
return 0
cmdtable = {'debugobsolete': (cmddebugobsolete, [], '<subject> <object>')}
def reposetup(ui, repo):
opull = repo.pull
opush = repo.push
class obsoletingrepo(repo.__class__):
### Hidden revision support
@util.propertycache
def hiddenrevs(self):
# It's a property because It simpler that to handle the __init__
revs = set()
return revs
### obsolete storage
@util.propertycache
def _obsobjrels(self):
"""{<old-node> -> set(<new-node>)}
also compute hidden revision"""
#reverse sub -> objs mapping
objrels = {}
for sub, objs in self._obssubrels.iteritems():
for obj in objs:
objrels.setdefault(obj, set()).add(sub)
return objrels
@util.propertycache
def _obssubrels(self):
"""{<new-node> -> set(<old-node>)}"""
return self._readobsrels()
### Disk IO
def _readobsrels(self):
"""Write obsolete relation on disk"""
# XXX handle lock
rels = {}
try:
f = self.opener('obsolete-relations')
try:
for line in f:
subhex, objhex = line.split()
rels.setdefault(bin(subhex), set()).add(bin(objhex))
finally:
f.close()
except IOError:
pass
return rels
def _writeobsrels(self):
"""Write obsolete relation on disk"""
# XXX handle lock
f = self.opener('obsolete-relations', 'w', atomictemp=True)
try:
for sub, objs in self._obssubrels.iteritems():
for obj in objs:
f.write('%s %s\n' % (hex(sub), hex(obj)))
f.rename()
finally:
f.close()
### pull // push support
def pull(self, remote, *args, **kwargs):
obskey = remote.listkeys('obsolete')
obsrels = obskey.get('relations', {})
result = opull(remote, *args, **kwargs)
for sub, objs in obsrels.iteritems():
for obj in objs:
self.addobsolete(sub, obj)
return result
def push(self, remote, *args, **opts):
obskey = remote.listkeys('obsolete')
obssupport = 'relations' in obskey
result = opush(remote, *args, **opts)
if obssupport:
remote.pushkey('obsolete', 'relations', {}, self._obssubrels)
return result
### Public method
def obsoletedby(self, node):
"""return the set of node that make <node> obsolete (obj)"""
return self._obsobjrels.get(node, set())
def obsolete(self, node):
"""return the set of node that <node> make obsolete (sub)"""
return self._obssubrels.get(node, set())
def addobsolete(self, sub, obj):
"""Add a relation marking that node <sub> is a new version of <obj>"""
self._obssubrels.setdefault(sub, set()).add(obj)
self._obsobjrels.setdefault(obj, set()).add(sub)
self.changelog.hiddenrevs.add(repo[obj].rev())
self._writeobsrels()
repo.__class__ = obsoletingrepo
### Other Extension compat
############################
def concludenode(orig, repo, rev, *args, **kwargs):
newrev = orig(repo, rev, *args, **kwargs)
oldnode = repo[rev].node()
newnode = repo[newrev].node()
repo.addobsolete(newnode, oldnode)
return newrev