view hgext3rd/topic/revset.py @ 4369:75276f858444

revset: subscriptrelations functions now have two bounds

from __future__ import absolute_import

from mercurial import (
    error,
    registrar,
    revset,
    util,
)

from . import (
    destination,
    stack,
)

try:
    mkmatcher = revset._stringmatcher
except AttributeError:
    try:
        from mercurial.utils import stringutil
        mkmatcher = stringutil.stringmatcher
    except (ImportError, AttributeError):
        mkmatcher = util.stringmatcher

revsetpredicate = registrar.revsetpredicate()

def getstringstrict(x, err):
    if x and x[0] == 'string':
        return x[1]
    raise error.ParseError(err)

@revsetpredicate('topic([string or set])')
def topicset(repo, subset, x):
    """All changesets with the specified topic or the topics of the given
    changesets. Without the argument, all changesets with any topic specified.

    If `string` starts with `re:` the remainder of the name is treated
    as a regular expression.
    """
    args = revset.getargs(x, 0, 1, 'topic takes one or no arguments')

    mutable = revset._notpublic(repo, revset.fullreposet(repo), ())

    if not args:
        return (subset & mutable).filter(lambda r: bool(repo[r].topic()))

    try:
        topic = getstringstrict(args[0], '')
    except error.ParseError:
        # not a string, but another revset
        pass
    else:
        kind, pattern, matcher = mkmatcher(topic)

        if topic.startswith('literal:') and pattern not in repo.topics:
            raise error.RepoLookupError("topic '%s' does not exist" % pattern)

        def matches(r):
            topic = repo[r].topic()
            if not topic:
                return False
            return matcher(topic)

        return (subset & mutable).filter(matches)

    s = revset.getset(repo, revset.fullreposet(repo), x)
    topics = {repo[r].topic() for r in s}
    topics.discard('')

    def matches(r):
        if r in s:
            return True
        topic = repo[r].topic()
        if not topic:
            return False
        return topic in topics

    return (subset & mutable).filter(matches)

@revsetpredicate('ngtip([branch])')
def ngtipset(repo, subset, x):
    """The untopiced tip.

    Name is horrible so that people change it.
    """
    args = revset.getargs(x, 1, 1, 'ngtip takes one argument')
    # match a specific topic
    branch = revset.getstring(args[0], 'ngtip requires a string')
    if branch == '.':
        branch = repo['.'].branch()
    return subset & revset.baseset(destination.ngtip(repo, branch))

@revsetpredicate('stack()')
def stackset(repo, subset, x):
    """All relevant changes in the current topic,

    This is roughly equivalent to 'topic(.) - obsolete' with a sorting moving
    unstable changeset after there future parent (as if evolve where already
    run).
    """
    err = 'stack takes no arguments, it works on current topic'
    revset.getargs(x, 0, 0, err)
    topic = None
    branch = None
    if repo.currenttopic:
        topic = repo.currenttopic
    else:
        branch = repo[None].branch()
    return revset.baseset(stack.stack(repo, branch=branch, topic=topic)[1:]) & subset

if util.safehasattr(revset, 'subscriptrelations'):
    def stackrel(repo, subset, x, rel, n, *args):
        """This is a revset-flavored implementation of stack aliases.

        The syntax is: rev#stack[n] or rev#s[n]. Plenty of logic is borrowed
        from topic._namemap, but unlike that function, which prefers to abort
        (e.g. when stack index is too high), this returns empty set to be more
        revset-friendly.
        """
        # hg 5.0 provides two bounds, for now we support only one
        if len(args) == 2 and args[0] != n:
            raise NotImplementedError
        s = revset.getset(repo, revset.fullreposet(repo), x)
        if not s:
            return revset.baseset()
        revs = []
        for r in s:
            topic = repo[r].topic()
            if topic:
                st = stack.stack(repo, topic=topic)
            else:
                st = stack.stack(repo, branch=repo[r].branch())
            if n < 0:
                st = list(st)[1:]
            else:
                st = list(st)
            try:
                rev = st[n]
            except IndexError:
                continue
            if rev == -1 and n == 0:
                continue
            if rev not in revs:
                revs.append(rev)
        return subset & revset.baseset(revs)

    revset.subscriptrelations['stack'] = stackrel
    revset.subscriptrelations['s'] = stackrel

    def topicrel(repo, subset, x, rel, n, *args):
        # hg 5.0 provides two bounds, for now we support only one
        if len(args) == 2 and args[0] != n:
            raise NotImplementedError
        ancestors = revset._ancestors
        descendants = revset._descendants
        subset = topicset(repo, subset, x)
        if n <= 0:
            n = -n
            return ancestors(repo, subset, x, startdepth=n, stopdepth=n + 1)
        else:
            return descendants(repo, subset, x, startdepth=n, stopdepth=n + 1)

    revset.subscriptrelations['topic'] = topicrel
    revset.subscriptrelations['t'] = topicrel