comparison mercurial/revset.py @ 20365:bc770ee6a351

revset: implemented set caching for revset evaluation

Added set caching to the baseset class. It lazily builds the set whenever it's
needed and keeps a reference which is returned when the set is requested
instead of being built again.

20364:a6cf48b2880d

    if m < n:
        r = range(m, n + 1)
    else:
        r = range(m, n - 1, -1)
    s = set(subset)
    return baseset([x for x in r if x in s])

def dagrange(repo, subset, x, y):
    r = baseset(repo)
    xs = _revsbetween(repo, getset(repo, r, x), getset(repo, r, y))
    s = set(subset)
    return baseset([r for r in xs if r in s])

def andset(repo, subset, x, y):
    return getset(repo, getset(repo, subset, x), y)

def orset(repo, subset, x, y):
    xl = getset(repo, subset, x)
    s = set(xl)
    yl = getset(repo, [r for r in subset if r not in s], y)
    return baseset(xl + yl)

def notset(repo, subset, x):
    s = set(getset(repo, subset, x))
    return baseset([r for r in subset if r not in s])

def listset(repo, subset, a, b):
    raise error.ParseError(_("can't use a list in this context"))

def _ancestors(repo, subset, x, followfirst=False):
    args = getset(repo, baseset(repo), x)
    if not args:
        return baseset([])
    s = set(_revancestors(repo, args, followfirst)) | set(args)
    return baseset([r for r in subset if r in s])

def ancestors(repo, subset, x):
    """``ancestors(set)``
    Changesets that are ancestors of a changeset in set.
    """

    cl = repo.changelog
    for r in getset(repo, cl, x):
        for i in range(n):
            r = cl.parentrevs(r)[0]
        ps.add(r)
    return baseset([r for r in subset if r in ps])

def author(repo, subset, x):
    """``author(string)``
    Alias for ``user(string)``.
    """

    - ``current``            : the cset currently being bisected
    """
    # i18n: "bisect" is a keyword
    status = getstring(x, _("bisect requires a string")).lower()
    state = set(hbisect.get(repo, status))
    return baseset([r for r in subset if r in state])

# Backward-compatibility
# - no help entry so that we do not advertise it any more
def bisected(repo, subset, x):
    return bisect(repo, subset, x)

                raise util.Abort(_("no bookmarks exist that match '%s'")
                                 % pattern)
            bmrevs = set()
            for bmrev in matchrevs:
                bmrevs.add(repo[bmrev].rev())
            return baseset([r for r in subset if r in bmrevs])

    bms = set([repo[r].rev()
               for r in repo._bookmarks.values()])
    return baseset([r for r in subset if r in bms])

def branch(repo, subset, x):
    """``branch(string or set)``
    All changesets belonging to the given branch or the branches of the given
    changesets.

    s = getset(repo, baseset(repo), x)
    b = set()
    for r in s:
        b.add(repo[r].branch())
    s = set(s)
    return baseset([r for r in subset if r in s or repo[r].branch() in b])

def bumped(repo, subset, x):
    """``bumped()``
    Mutable changesets marked as successors of public changesets.

def children(repo, subset, x):
    """``children(set)``
    Child changesets of changesets in set.
    """
    s = set(getset(repo, baseset(repo), x))
    cs = _children(repo, subset, s)
    return baseset([r for r in subset if r in cs])

def closed(repo, subset, x):
    """``closed()``

def _descendants(repo, subset, x, followfirst=False):
    args = getset(repo, baseset(repo), x)
    if not args:
        return baseset([])
    s = set(_revdescendants(repo, args, followfirst)) | set(args)
    return baseset([r for r in subset if r in s])

def descendants(repo, subset, x):
    """``descendants(set)``
    Changesets which are descendants of changesets in set.
    """

    Changesets that were created by a graft, transplant or rebase operation,
    with the given revisions specified as the source.  Omitting the optional set
    is the same as passing all().
    """
    if x is not None:
        args = set(getset(repo, baseset(repo), x))
    else:
        args = set(getall(repo, baseset(repo), x))

    dests = set()

    # subset contains all of the possible destinations that can be returned, so
    # iterate over them and see if their source(s) were provided in the args.

            if m(f):
                fl = repo.file(f)
                for fr in fl:
                    s.add(fl.linkrev(fr))

    return baseset([r for r in subset if r in s])

def first(repo, subset, x):
    """``first(set, [n])``
    An alias for limit().
    """

        else:
            return baseset([])
    else:
        s = set(_revancestors(repo, [c.rev()], followfirst)) | set([c.rev()])

    return baseset([r for r in subset if r in s])

def follow(repo, subset, x):
    """``follow([file])``
    An alias for ``::.`` (ancestors of the working copy's first parent).
    If a filename is specified, the history of the given file is followed,

    # i18n: "head" is a keyword
    getargs(x, 0, 0, _("head takes no arguments"))
    hs = set()
    for b, ls in repo.branchmap().iteritems():
        hs.update(repo[h].rev() for h in ls)
    return baseset([r for r in subset if r in hs])

def heads(repo, subset, x):
    """``heads(set)``
    Members of set with no children in set.
    """
    s = getset(repo, subset, x)
    ps = set(parents(repo, subset, x))
    return baseset([r for r in s if r not in ps])

def hidden(repo, subset, x):
    """``hidden()``
    Hidden changesets.

            # i18n: "limit" is a keyword
            lim = int(getstring(l[1], _("limit requires a number")))
    except (TypeError, ValueError):
        # i18n: "limit" is a keyword
        raise error.ParseError(_("limit expects a number"))
    ss = set(subset)
    os = getset(repo, baseset(repo), l[0])[:lim]
    return baseset([r for r in os if r in ss])

def last(repo, subset, x):
    """``last(set, [n])``

            # i18n: "last" is a keyword
            lim = int(getstring(l[1], _("last requires a number")))
    except (TypeError, ValueError):
        # i18n: "last" is a keyword
        raise error.ParseError(_("last expects a number"))
    ss = set(subset)
    os = getset(repo, baseset(repo), l[0])[-lim:]
    return baseset([r for r in os if r in ss])

def maxrev(repo, subset, x):
    """``max(set)``

    same as passing all().  If a changeset created by these operations is itself
    specified as a source for one of these operations, only the source changeset
    for the first operation is selected.
    """
    if x is not None:
        args = set(getset(repo, baseset(repo), x))
    else:
        args = set(getall(repo, baseset(repo), x))

    def _firstsrc(rev):
        src = _getrevsource(repo, rev)
        if src is None:
            return None

            if prev is None:
                return src
            src = prev

    o = set([_firstsrc(r) for r in args])
    return baseset([r for r in subset if r in o])

def outgoing(repo, subset, x):
    """``outgoing([path])``
    Changesets not found in the specified destination repository, or the
    default push location.

    repo.ui.pushbuffer()
    outgoing = discovery.findcommonoutgoing(repo, other, onlyheads=revs)
    repo.ui.popbuffer()
    cl = repo.changelog
    o = set([cl.rev(r) for r in outgoing.missing])
    return baseset([r for r in subset if r in o])

def p1(repo, subset, x):
    """``p1([set])``
    First parent of changesets in set, or the working directory.
    """

    ps = set()
    cl = repo.changelog
    for r in getset(repo, baseset(repo), x):
        ps.add(cl.parentrevs(r)[0])
    return baseset([r for r in subset if r in ps])

def p2(repo, subset, x):
    """``p2([set])``
    Second parent of changesets in set, or the working directory.
    """

    ps = set()
    cl = repo.changelog
    for r in getset(repo, baseset(repo), x):
        ps.add(cl.parentrevs(r)[1])
    return baseset([r for r in subset if r in ps])

def parents(repo, subset, x):
    """``parents([set])``
    The set of all parents for all changesets in set, or the working directory.
    """

    ps = set()
    cl = repo.changelog
    for r in getset(repo, baseset(repo), x):
        ps.update(cl.parentrevs(r))
    return baseset([r for r in subset if r in ps])

def parentspec(repo, subset, x, n):
    """``set^0``
    The set.
    ``set^1`` (or ``set^``), ``set^2``

            ps.add(cl.parentrevs(r)[0])
        elif n == 2:
            parents = cl.parentrevs(r)
            if len(parents) > 1:
                ps.add(parents[1])
    return baseset([r for r in subset if r in ps])

def present(repo, subset, x):
    """``present(set)``
    An empty set, if any revision in set isn't found; otherwise,
    all revisions in set.

def reverse(repo, subset, x):
    """``reverse(set)``
    Reverse order of set.
    """
    l = getset(repo, subset, x)
    if not isinstance(l, list):
        l = baseset(l)
    l.reverse()
    return l

def roots(repo, subset, x):
    """``roots(set)``
    Changesets in set with no parent changeset in set.
    """
    s = set(getset(repo, baseset(repo.changelog), x))
    subset = baseset([r for r in subset if r in s])
    cs = _children(repo, subset, s)
    return baseset([r for r in subset if r not in cs])

def secret(repo, subset, x):

# for internal use
def _list(repo, subset, x):
    s = getstring(x, "internal error")
    if not s:
        return baseset([])
    if not isinstance(subset, set):
        subset = set(subset)
    ls = [repo[r].rev() for r in s.split('\0')]
    return baseset([r for r in ls if r in subset])

symbols = {
    "adds": adds,
    "all": getall,
    "ancestor": ancestor,

        if tree[0] == 'func':
            funcs.add(tree[1][1])
        return funcs

class baseset(list):
    pass

# tell hggettext to extract docstrings from these functions:
i18nfunctions = symbols.values()

20365:bc770ee6a351

    if m < n:
        r = range(m, n + 1)
    else:
        r = range(m, n - 1, -1)
    s = subset.set()
    return baseset([x for x in r if x in s])

def dagrange(repo, subset, x, y):
    r = baseset(repo)
    xs = _revsbetween(repo, getset(repo, r, x), getset(repo, r, y))
    s = subset.set()
    return baseset([r for r in xs if r in s])

def andset(repo, subset, x, y):
    return getset(repo, getset(repo, subset, x), y)

def orset(repo, subset, x, y):
    xl = getset(repo, subset, x)
    s = xl.set()
    yl = getset(repo, baseset([r for r in subset if r not in s]), y)
    return baseset(xl + yl)

def notset(repo, subset, x):
    s = getset(repo, subset, x).set()
    return baseset([r for r in subset if r not in s])

def listset(repo, subset, a, b):
    raise error.ParseError(_("can't use a list in this context"))

def _ancestors(repo, subset, x, followfirst=False):
    args = getset(repo, baseset(repo), x)
    if not args:
        return baseset([])
    s = set(_revancestors(repo, args, followfirst)) | set(args)
    ss = subset.set()
    return baseset([r for r in ss if r in s])

def ancestors(repo, subset, x):
    """``ancestors(set)``
    Changesets that are ancestors of a changeset in set.
    """

    cl = repo.changelog
    for r in getset(repo, cl, x):
        for i in range(n):
            r = cl.parentrevs(r)[0]
        ps.add(r)
    s = subset.set()
    return baseset([r for r in s if r in ps])

def author(repo, subset, x):
    """``author(string)``
    Alias for ``user(string)``.
    """

    - ``current``            : the cset currently being bisected
    """
    # i18n: "bisect" is a keyword
    status = getstring(x, _("bisect requires a string")).lower()
    state = set(hbisect.get(repo, status))
    s = subset.set()
    return baseset([r for r in s if r in state])

# Backward-compatibility
# - no help entry so that we do not advertise it any more
def bisected(repo, subset, x):
    return bisect(repo, subset, x)

                raise util.Abort(_("no bookmarks exist that match '%s'")
                                 % pattern)
            bmrevs = set()
            for bmrev in matchrevs:
                bmrevs.add(repo[bmrev].rev())
            s = subset.set()
            return baseset([r for r in s if r in bmrevs])

    bms = set([repo[r].rev()
               for r in repo._bookmarks.values()])
    s = subset.set()
    return baseset([r for r in s if r in bms])

def branch(repo, subset, x):
    """``branch(string or set)``
    All changesets belonging to the given branch or the branches of the given
    changesets.

    s = getset(repo, baseset(repo), x)
    b = set()
    for r in s:
        b.add(repo[r].branch())
    s = s.set()
    return baseset([r for r in subset if r in s or repo[r].branch() in b])

def bumped(repo, subset, x):
    """``bumped()``
    Mutable changesets marked as successors of public changesets.

def children(repo, subset, x):
    """``children(set)``
    Child changesets of changesets in set.
    """
    s = getset(repo, baseset(repo), x).set()
    cs = _children(repo, subset, s)
    return baseset([r for r in subset if r in cs])

def closed(repo, subset, x):
    """``closed()``

def _descendants(repo, subset, x, followfirst=False):
    args = getset(repo, baseset(repo), x)
    if not args:
        return baseset([])
    s = set(_revdescendants(repo, args, followfirst)) | set(args)
    ss = subset.set()
    return baseset([r for r in ss if r in s])

def descendants(repo, subset, x):
    """``descendants(set)``
    Changesets which are descendants of changesets in set.
    """

    Changesets that were created by a graft, transplant or rebase operation,
    with the given revisions specified as the source.  Omitting the optional set
    is the same as passing all().
    """
    if x is not None:
        args = getset(repo, baseset(repo), x).set()
    else:
        args = getall(repo, baseset(repo), x).set()

    dests = set()

    # subset contains all of the possible destinations that can be returned, so
    # iterate over them and see if their source(s) were provided in the args.

            if m(f):
                fl = repo.file(f)
                for fr in fl:
                    s.add(fl.linkrev(fr))

    ss = subset.set()
    return baseset([r for r in ss if r in s])

def first(repo, subset, x):
    """``first(set, [n])``
    An alias for limit().
    """

        else:
            return baseset([])
    else:
        s = set(_revancestors(repo, [c.rev()], followfirst)) | set([c.rev()])

    ss = subset.set()
    return baseset([r for r in ss if r in s])

def follow(repo, subset, x):
    """``follow([file])``
    An alias for ``::.`` (ancestors of the working copy's first parent).
    If a filename is specified, the history of the given file is followed,

    # i18n: "head" is a keyword
    getargs(x, 0, 0, _("head takes no arguments"))
    hs = set()
    for b, ls in repo.branchmap().iteritems():
        hs.update(repo[h].rev() for h in ls)
    s = subset.set()
    return baseset([r for r in s if r in hs])

def heads(repo, subset, x):
    """``heads(set)``
    Members of set with no children in set.
    """
    s = getset(repo, subset, x).set()
    ps = parents(repo, subset, x).set()
    return baseset([r for r in s if r not in ps])

def hidden(repo, subset, x):
    """``hidden()``
    Hidden changesets.

            # i18n: "limit" is a keyword
            lim = int(getstring(l[1], _("limit requires a number")))
    except (TypeError, ValueError):
        # i18n: "limit" is a keyword
        raise error.ParseError(_("limit expects a number"))
    ss = subset.set()
    os = getset(repo, baseset(repo), l[0])[:lim]
    return baseset([r for r in os if r in ss])

def last(repo, subset, x):
    """``last(set, [n])``

            # i18n: "last" is a keyword
            lim = int(getstring(l[1], _("last requires a number")))
    except (TypeError, ValueError):
        # i18n: "last" is a keyword
        raise error.ParseError(_("last expects a number"))
    ss = subset.set()
    os = getset(repo, baseset(repo), l[0])[-lim:]
    return baseset([r for r in os if r in ss])

def maxrev(repo, subset, x):
    """``max(set)``

    same as passing all().  If a changeset created by these operations is itself
    specified as a source for one of these operations, only the source changeset
    for the first operation is selected.
    """
    if x is not None:
        args = getset(repo, baseset(repo), x).set()
    else:
        args = getall(repo, baseset(repo), x).set()

    def _firstsrc(rev):
        src = _getrevsource(repo, rev)
        if src is None:
            return None

            if prev is None:
                return src
            src = prev

    o = set([_firstsrc(r) for r in args])
    s = subset.set()
    return baseset([r for r in s if r in o])

def outgoing(repo, subset, x):
    """``outgoing([path])``
    Changesets not found in the specified destination repository, or the
    default push location.

    repo.ui.pushbuffer()
    outgoing = discovery.findcommonoutgoing(repo, other, onlyheads=revs)
    repo.ui.popbuffer()
    cl = repo.changelog
    o = set([cl.rev(r) for r in outgoing.missing])
    s = subset.set()
    return baseset([r for r in s if r in o])

def p1(repo, subset, x):
    """``p1([set])``
    First parent of changesets in set, or the working directory.
    """

    ps = set()
    cl = repo.changelog
    for r in getset(repo, baseset(repo), x):
        ps.add(cl.parentrevs(r)[0])
    s = subset.set()
    return baseset([r for r in s if r in ps])

def p2(repo, subset, x):
    """``p2([set])``
    Second parent of changesets in set, or the working directory.
    """

    ps = set()
    cl = repo.changelog
    for r in getset(repo, baseset(repo), x):
        ps.add(cl.parentrevs(r)[1])
    s = subset.set()
    return baseset([r for r in s if r in ps])

def parents(repo, subset, x):
    """``parents([set])``
    The set of all parents for all changesets in set, or the working directory.
    """

    ps = set()
    cl = repo.changelog
    for r in getset(repo, baseset(repo), x):
        ps.update(cl.parentrevs(r))
    s = subset.set()
    return baseset([r for r in s if r in ps])

def parentspec(repo, subset, x, n):
    """``set^0``
    The set.
    ``set^1`` (or ``set^``), ``set^2``

            ps.add(cl.parentrevs(r)[0])
        elif n == 2:
            parents = cl.parentrevs(r)
            if len(parents) > 1:
                ps.add(parents[1])
    s = subset.set()
    return baseset([r for r in s if r in ps])

def present(repo, subset, x):
    """``present(set)``
    An empty set, if any revision in set isn't found; otherwise,
    all revisions in set.

def reverse(repo, subset, x):
    """``reverse(set)``
    Reverse order of set.
    """
    l = getset(repo, subset, x)
    l.reverse()
    return l

def roots(repo, subset, x):
    """``roots(set)``
    Changesets in set with no parent changeset in set.
    """
    s = getset(repo, baseset(repo.changelog), x).set()
    subset = baseset([r for r in subset if r in s])
    cs = _children(repo, subset, s)
    return baseset([r for r in subset if r not in cs])

def secret(repo, subset, x):

# for internal use
def _list(repo, subset, x):
    s = getstring(x, "internal error")
    if not s:
        return baseset([])
    ls = [repo[r].rev() for r in s.split('\0')]
    s = subset.set()
    return baseset([r for r in ls if r in s])

symbols = {
    "adds": adds,
    "all": getall,
    "ancestor": ancestor,

        if tree[0] == 'func':
            funcs.add(tree[1][1])
        return funcs

class baseset(list):
    def __init__(self, data):
        super(baseset, self).__init__(data)
        self._set = None

    def set(self):
        if not self._set:
            self._set = set(self)
        return self._set

# tell hggettext to extract docstrings from these functions:
i18nfunctions = symbols.values()