hg-stable: comparison mercurial/revset.py

equal deleted inserted replaced

-:34bb07e70c68
+:6490f8385391
 def dagrange(repo, subset, x, y):
 r = spanset(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])
+return xs.filter(lambda r: r in s)
 def andset(repo, subset, x, y):
 return getset(repo, getset(repo, subset, x), y)
 def orset(repo, subset, x, y):
 def _ancestors(repo, subset, x, followfirst=False):
 args = getset(repo, spanset(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])
+return subset.filter(lambda r: 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, baseset(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])
+return subset.filter(lambda r: r in ps)
 def author(repo, subset, x):
 """``author(string)``
 Alias for ``user(string)``.
 """
 # i18n: "author" is a keyword
 n = encoding.lower(getstring(x, _("author requires a string")))
 kind, pattern, matcher = _substringmatcher(n)
-return lazyset(subset, lambda x: matcher(encoding.lower(repo[x].user())))
+return subset.filter(lambda x: matcher(encoding.lower(repo[x].user())))
 def bisect(repo, subset, x):
 """``bisect(string)``
 Changesets marked in the specified bisect status:
 - ``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])
+return subset.filter(lambda r: 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)
 if kind == 'literal':
 bmrev = repo._bookmarks.get(bm, None)
 if not bmrev:
 raise util.Abort(_("bookmark '%s' does not exist") % bm)
 bmrev = repo[bmrev].rev()
-return lazyset(subset, lambda r: r == bmrev)
+return subset.filter(lambda r: r == bmrev)
 else:
 matchrevs = set()
 for name, bmrev in repo._bookmarks.iteritems():
 if matcher(name):
 matchrevs.add(bmrev)
 bmrevs.add(repo[bmrev].rev())
 return subset & bmrevs
 bms = set([repo[r].rev()
 for r in repo._bookmarks.values()])
-return lazyset(subset, lambda r: r in bms)
+return subset.filter(lambda r: 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.
 kind, pattern, matcher = _stringmatcher(b)
 if kind == 'literal':
 # note: falls through to the revspec case if no branch with
 # this name exists
 if pattern in repo.branchmap():
-return lazyset(subset, lambda r: matcher(repo[r].branch()))
+return subset.filter(lambda r: matcher(repo[r].branch()))
 else:
-return lazyset(subset, lambda r: matcher(repo[r].branch()))
+return subset.filter(lambda r: matcher(repo[r].branch()))
 s = getset(repo, spanset(repo), x)
 b = set()
 for r in s:
 b.add(repo[r].branch())
 s = s.set()
-return lazyset(subset, lambda r: r in s or repo[r].branch() in b)
+return subset.filter(lambda r: r in s or repo[r].branch() in b)
 def bumped(repo, subset, x):
 """``bumped()``
 Mutable changesets marked as successors of public changesets.
 else:
 for f in files:
 if m(f):
 return True
-return lazyset(subset, matches)
+return subset.filter(matches)
 def _children(repo, narrow, parentset):
 cs = set()
 if not parentset:
 return baseset(cs)
 """``closed()``
 Changeset is closed.
 """
 # i18n: "closed" is a keyword
 getargs(x, 0, 0, _("closed takes no arguments"))
-return lazyset(subset, lambda r: repo[r].closesbranch())
+return subset.filter(lambda r: repo[r].closesbranch())
 def contains(repo, subset, x):
 """``contains(pattern)``
 Revision contains a file matching pattern. See :hg:`help patterns`
 for information about file patterns.
 for f in c.manifest():
 if m(f):
 return True
 return False
-return lazyset(subset, matches)
+return subset.filter(matches)
 def converted(repo, subset, x):
 """``converted([id])``
 Changesets converted from the given identifier in the old repository if
 present, or all converted changesets if no identifier is specified.
 def _matchvalue(r):
 source = repo[r].extra().get('convert_revision', None)
 return source is not None and (rev is None or source.startswith(rev))
-return lazyset(subset, lambda r: _matchvalue(r))
+return subset.filter(lambda r: _matchvalue(r))
 def date(repo, subset, x):
 """``date(interval)``
 Changesets within the interval, see :hg:`help dates`.
 """
 # i18n: "date" is a keyword
 ds = getstring(x, _("date requires a string"))
 dm = util.matchdate(ds)
-return lazyset(subset, lambda x: dm(repo[x].date()[0]))
+return subset.filter(lambda x: dm(repo[x].date()[0]))
 def desc(repo, subset, x):
 """``desc(string)``
 Search commit message for string. The match is case-insensitive.
 """
 def matches(x):
 c = repo[x]
 return ds in encoding.lower(c.description())
-return lazyset(subset, matches)
+return subset.filter(matches)
 def _descendants(repo, subset, x, followfirst=False):
 args = getset(repo, spanset(repo), x)
 if not args:
 return baseset([])
 break
 r = src
 src = _getrevsource(repo, r)
-return baseset([r for r in subset if r in dests])
+return subset.filter(lambda r: r in dests)
 def divergent(repo, subset, x):
 """``divergent()``
 Final successors of changesets with an alternative set of final successors.
 """
 # i18n: "divergent" is a keyword
 getargs(x, 0, 0, _("divergent takes no arguments"))
 divergent = obsmod.getrevs(repo, 'divergent')
-return baseset([r for r in subset if r in divergent])
+return subset.filter(lambda r: r in divergent)
 def draft(repo, subset, x):
 """``draft()``
 Changeset in draft phase."""
 # i18n: "draft" is a keyword
 getargs(x, 0, 0, _("draft takes no arguments"))
 pc = repo._phasecache
-return lazyset(subset, lambda r: pc.phase(repo, r) == phases.draft)
+return subset.filter(lambda r: pc.phase(repo, r) == phases.draft)
 def extinct(repo, subset, x):
 """``extinct()``
 Obsolete changesets with obsolete descendants only.
 """
 def _matchvalue(r):
 extra = repo[r].extra()
 return label in extra and (value is None or matcher(extra[label]))
-return lazyset(subset, lambda r: _matchvalue(r))
+return subset.filter(lambda r: _matchvalue(r))
 def filelog(repo, subset, x):
 """``filelog(pattern)``
 Changesets connected to the specified filelog.
 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])
+return subset.filter(lambda r: 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])
+return subset.filter(lambda r: 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,
 for e in c.files() + [c.user(), c.description()]:
 if gr.search(e):
 return True
 return False
-return lazyset(subset, matches)
+return subset.filter(matches)
 def _matchfiles(repo, subset, x):
 # _matchfiles takes a revset list of prefixed arguments:
 #
 #   [p:foo, i:bar, x:baz]
 for f in c.files():
 if m(f):
 return True
 return False
-return lazyset(subset, matches)
+return subset.filter(matches)
 def hasfile(repo, subset, x):
 """``file(pattern)``
 Changesets affecting files matched by pattern.
 # 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])
+return subset.filter(lambda r: r in hs)
 def heads(repo, subset, x):
 """``heads(set)``
 Members of set with no children in set.
 """
 def matches(r):
 c = repo[r]
 return util.any(kw in encoding.lower(t) for t in c.files() + [c.user(),
 c.description()])
-return lazyset(subset, matches)
+return subset.filter(matches)
 def limit(repo, subset, x):
 """``limit(set, [n])``
 First n members of set, defaulting to 1.
 """
 Changeset is a merge changeset.
 """
 # i18n: "merge" is a keyword
 getargs(x, 0, 0, _("merge takes no arguments"))
 cl = repo.changelog
-return lazyset(subset, lambda r: cl.parentrevs(r)[1] != -1)
+return subset.filter(lambda r: cl.parentrevs(r)[1] != -1)
 def branchpoint(repo, subset, x):
 """``branchpoint()``
 Changesets with more than one child.
 """
 parentscount = [0]*(len(repo) - baserev)
 for r in cl.revs(start=baserev + 1):
 for p in cl.parentrevs(r):
 if p >= baserev:
 parentscount[p - baserev] += 1
-return baseset([r for r in subset if (parentscount[r - baserev] > 1)])
+return subset.filter(lambda r: parentscount[r - baserev] > 1)
 def minrev(repo, subset, x):
 """``min(set)``
 Changeset with lowest revision number in set.
 """
 rn = None
 pm = repo.changelog._partialmatch(n)
 if pm is not None:
 rn = repo.changelog.rev(pm)
-return baseset([r for r in subset if r == rn])
+return subset.filter(lambda r: r == rn)
 def obsolete(repo, subset, x):
 """``obsolete()``
 Mutable changeset with a newer version."""
 # i18n: "obsolete" is a keyword
 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])
+return subset.filter(lambda r: 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])
+return subset.filter(lambda r: r in o)
 def p1(repo, subset, x):
 """``p1([set])``
 First parent of changesets in set, or the working directory.
 """
 if x is None:
 p = repo[x].p1().rev()
-return baseset([r for r in subset if r == p])
+return subset.filter(lambda r: r == p)
 ps = set()
 cl = repo.changelog
 for r in getset(repo, spanset(repo), x):
 ps.add(cl.parentrevs(r)[0])
 """
 if x is None:
 ps = repo[x].parents()
 try:
 p = ps[1].rev()
-return baseset([r for r in subset if r == p])
+return subset.filter(lambda r: r == p)
 except IndexError:
 return baseset([])
 ps = set()
 cl = repo.changelog
 """``public()``
 Changeset in public phase."""
 # i18n: "public" is a keyword
 getargs(x, 0, 0, _("public takes no arguments"))
 pc = repo._phasecache
-return lazyset(subset, lambda r: pc.phase(repo, r) == phases.public)
+return subset.filter(lambda r: pc.phase(repo, r) == phases.public)
 def remote(repo, subset, x):
 """``remote([id [,path]])``
 Local revision that corresponds to the given identifier in a
 remote repository, if present. Here, the '.' identifier is a
 # i18n: "rev" is a keyword
 l = int(getstring(l[0], _("rev requires a number")))
 except (TypeError, ValueError):
 # i18n: "rev" is a keyword
 raise error.ParseError(_("rev expects a number"))
-return baseset([r for r in subset if r == l])
+return subset.filter(lambda r: r == l)
 def matching(repo, subset, x):
 """``matching(revision [, field])``
 Changesets in which a given set of fields match the set of fields in the
 selected revision or set.
 match = False
 if match:
 return True
 return False
-return lazyset(subset, matches)
+return subset.filter(matches)
 def reverse(repo, subset, x):
 """``reverse(set)``
 Reverse order of set.
 """
 """``secret()``
 Changeset in secret phase."""
 # i18n: "secret" is a keyword
 getargs(x, 0, 0, _("secret takes no arguments"))
 pc = repo._phasecache
-return lazyset(subset, lambda x: pc.phase(repo, x) == phases.secret)
+return subset.filter(lambda x: pc.phase(repo, x) == phases.secret)
 def sort(repo, subset, x):
 """``sort(set[, [-]key...])``
 Sort set by keys. The default sort order is ascending, specify a key
 as ``-key`` to sort in descending order.

changeset 20611	6490f8385391
parent 20610	34bb07e70c68
child 20612	60c308b932eb