view hgext3rd/topic/topicmap.py @ 1985:03d6b685c16a

topic: list the number of 'behind' changeset when --verbose is used

Displaying more information in the topic list is useful, we continue with the
number of 'behind' changesets. This 'behind' count the number of new changesets on
the default rebase destination. This will highlight topics that need rebasing.

import contextlib
import hashlib

from mercurial.node import hex, bin, nullid
from mercurial import (
    branchmap,
    changegroup,
    cmdutil,
    encoding,
    error,
    extensions,
    scmutil,
)

def _filename(repo):
    """name of a branchcache file for a given repo or repoview"""
    filename = "cache/topicmap"
    if repo.filtername:
        filename = '%s-%s' % (filename, repo.filtername)
    return filename

oldbranchcache = branchmap.branchcache

def _phaseshash(repo, maxrev):
    revs = set()
    cl = repo.changelog
    fr = cl.filteredrevs
    nm = cl.nodemap
    for roots in repo._phasecache.phaseroots[1:]:
        for n in roots:
            r = nm.get(n)
            if r not in fr and r < maxrev:
                revs.add(r)
    key = nullid
    revs = sorted(revs)
    if revs:
        s = hashlib.sha1()
        for rev in revs:
            s.update('%s;' % rev)
        key = s.digest()
    return key

@contextlib.contextmanager
def usetopicmap(repo):
    """use awful monkey patching to ensure topic map usage

    During the extend of the context block, The topicmap should be used and
    updated instead of the branchmap."""
    oldbranchcache = branchmap.branchcache
    oldfilename = branchmap._filename
    oldread = branchmap.read
    oldcaches = getattr(repo, '_branchcaches', {})
    try:
        branchmap.branchcache = topiccache
        branchmap._filename = _filename
        branchmap.read = readtopicmap
        repo._branchcaches = getattr(repo, '_topiccaches', {})
        yield
        repo._topiccaches = repo._branchcaches
    finally:
        repo._branchcaches = oldcaches
        branchmap.branchcache = oldbranchcache
        branchmap._filename = oldfilename
        branchmap.read = oldread

def cgapply(orig, repo, *args, **kwargs):
    """make sure a topicmap is used when applying a changegroup"""
    with usetopicmap(repo):
        return orig(repo, *args, **kwargs)

def commitstatus(orig, repo, node, branch, bheads=None, opts=None):
    # wrap commit status use the topic branch heads
    ctx = repo[node]
    if ctx.topic() and ctx.branch() == branch:
        bheads = repo.branchheads("%s:%s" % (branch, ctx.topic()))
    return orig(repo, node, branch, bheads=bheads, opts=opts)

class topiccache(oldbranchcache):

    def __init__(self, *args, **kwargs):
        otherbranchcache = branchmap.branchcache
        try:
            # super() call may fail otherwise
            branchmap.branchcache = oldbranchcache
            super(topiccache, self).__init__(*args, **kwargs)
            if self.filteredhash is None:
                self.filteredhash = nullid
            self.phaseshash = nullid
        finally:
            branchmap.branchcache = otherbranchcache

    def copy(self):
        """return an deep copy of the branchcache object"""
        new = topiccache(self, self.tipnode, self.tiprev, self.filteredhash,
                         self._closednodes)
        if self.filteredhash is None:
            self.filteredhash = nullid
        new.phaseshash = self.phaseshash
        return new

    def branchtip(self, branch, topic=''):
        '''Return the tipmost open head on branch head, otherwise return the
        tipmost closed head on branch.
        Raise KeyError for unknown branch.'''
        if topic:
            branch = '%s:%s' % (branch, topic)
        return super(topiccache, self).branchtip(branch)

    def branchheads(self, branch, closed=False, topic=''):
        if topic:
            branch = '%s:%s' % (branch, topic)
        return super(topiccache, self).branchheads(branch, closed=closed)

    def validfor(self, repo):
        """Is the cache content valid regarding a repo

        - False when cached tipnode is unknown or if we detect a strip.
        - True when cache is up to date or a subset of current repo."""
        # This is copy paste of mercurial.branchmap.branchcache.validfor in
        # 69077c65919d With a small changes to the cache key handling to
        # include phase information that impact the topic cache.
        #
        # All code changes should be flagged on site.
        try:
            if (self.tipnode == repo.changelog.node(self.tiprev)):
                fh = scmutil.filteredhash(repo, self.tiprev)
                if fh is None:
                    fh = nullid
                if ((self.filteredhash == fh)
                     and (self.phaseshash == _phaseshash(repo, self.tiprev))):
                    return True
            return False
        except IndexError:
            return False

    def write(self, repo):
        # This is copy paste of mercurial.branchmap.branchcache.write in
        # 69077c65919d With a small changes to the cache key handling to
        # include phase information that impact the topic cache.
        #
        # All code changes should be flagged on site.
        try:
            f = repo.vfs(_filename(repo), "w", atomictemp=True)
            cachekey = [hex(self.tipnode), str(self.tiprev)]
            # [CHANGE] we need a hash in all cases
            assert self.filteredhash is not None
            cachekey.append(hex(self.filteredhash))
            cachekey.append(hex(self.phaseshash))
            f.write(" ".join(cachekey) + '\n')
            nodecount = 0
            for label, nodes in sorted(self.iteritems()):
                for node in nodes:
                    nodecount += 1
                    if node in self._closednodes:
                        state = 'c'
                    else:
                        state = 'o'
                    f.write("%s %s %s\n" % (hex(node), state,
                                            encoding.fromlocal(label)))
            f.close()
            repo.ui.log('branchcache',
                        'wrote %s branch cache with %d labels and %d nodes\n',
                        repo.filtername, len(self), nodecount)
        except (IOError, OSError, error.Abort) as inst:
            repo.ui.debug("couldn't write branch cache: %s\n" % inst)
            # Abort may be raise by read only opener
            pass

    def update(self, repo, revgen):
        """Given a branchhead cache, self, that may have extra nodes or be
        missing heads, and a generator of nodes that are strictly a superset of
        heads missing, this function updates self to be correct.
        """
        oldgetbranchinfo = repo.revbranchcache().branchinfo
        try:
            def branchinfo(r):
                info = oldgetbranchinfo(r)
                topic = ''
                ctx = repo[r]
                if ctx.mutable():
                    topic = ctx.topic()
                branch = info[0]
                if topic:
                    branch = '%s:%s' % (branch, topic)
                return (branch, info[1])
            repo.revbranchcache().branchinfo = branchinfo
            super(topiccache, self).update(repo, revgen)
            if self.filteredhash is None:
                self.filteredhash = nullid
            self.phaseshash = _phaseshash(repo, self.tiprev)
        finally:
            repo.revbranchcache().branchinfo = oldgetbranchinfo

def readtopicmap(repo):
    # This is copy paste of mercurial.branchmap.read in 69077c65919d
    # With a small changes to the cache key handling to include phase
    # information that impact the topic cache.
    #
    # All code changes should be flagged on site.
    try:
        f = repo.vfs(_filename(repo))
        lines = f.read().split('\n')
        f.close()
    except (IOError, OSError):
        return None

    try:
        cachekey = lines.pop(0).split(" ", 2)
        last, lrev = cachekey[:2]
        last, lrev = bin(last), int(lrev)
        filteredhash = bin(cachekey[2]) # [CHANGE] unconditional filteredhash
        partial = topiccache(tipnode=last, tiprev=lrev,
                             filteredhash=filteredhash)
        partial.phaseshash = bin(cachekey[3]) # [CHANGE] read phaseshash
        if not partial.validfor(repo):
            # invalidate the cache
            raise ValueError('tip differs')
        cl = repo.changelog
        for l in lines:
            if not l:
                continue
            node, state, label = l.split(" ", 2)
            if state not in 'oc':
                raise ValueError('invalid branch state')
            label = encoding.tolocal(label.strip())
            node = bin(node)
            if not cl.hasnode(node):
                raise ValueError('node %s does not exist' % hex(node))
            partial.setdefault(label, []).append(node)
            if state == 'c':
                partial._closednodes.add(node)
    except KeyboardInterrupt:
        raise
    except Exception as inst:
        if repo.ui.debugflag:
            msg = 'invalid branchheads cache'
            if repo.filtername is not None:
                msg += ' (%s)' % repo.filtername
            msg += ': %s\n'
            repo.ui.debug(msg % inst)
        partial = None
    return partial

def modsetup(ui):
    """call at uisetup time to install various wrappings"""
    extensions.wrapfunction(changegroup.cg1unpacker, 'apply', cgapply)
    extensions.wrapfunction(cmdutil, 'commitstatus', commitstatus)