mercurial-scm/hg-stable: mercurial/revset.py annotate

annotate mercurial/revset.py @ 25621:21a874693619

revset: refactor the non-public phase code Code for draft and secret are the same. We'll make it more complex to take advantages of the set recomputed in C, so we first refactor the code to only have one place to update (and make sure all behave properly). We do not refactor the 'public()' code because it does not have a natively computed set.

author	Pierre-Yves David <pierre-yves.david@fb.com>
date	Wed, 17 Jun 2015 19:19:57 -0700
parents	5f87f2305ad0
children	85294076adce

rev	line source
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1 # revset.py - revision set queries for mercurial
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2 #
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	3 # Copyright 2010 Matt Mackall <mpm@selenic.com>
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	4 #
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	5 # This software may be used and distributed according to the terms of the
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	6 # GNU General Public License version 2 or any later version.
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	7
16834 cafd8a8fb713 util: subclass deque for Python 2.4 backwards compatibility Bryan O'Sullivan <bryano@fb.com> parents: 16825 diff changeset	8 import re
24722 02a5618e2fbf revset: don't import discovery at module level Gregory Szorc <gregory.szorc@gmail.com> parents: 24708 diff changeset	9 import parser, util, error, hbisect, phases
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	10 import node
20690 13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	11 import heapq
12085 6f833fc3ccab Consistently import foo as foomod when foo to avoid shadowing Martin Geisler <mg@aragost.com> parents: 11944 diff changeset	12 import match as matchmod
13593 cc4721ed7a2a help: extract items doc generation function Patrick Mezard <pmezard@gmail.com> parents: 13506 diff changeset	13 from i18n import _
15726 9b822edecb4c i18n: use "encoding.lower()" to normalize specified string for revset FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15596 diff changeset	14 import encoding
17469 fb72eec7efd8 obsolete: introduce caches for all meaningful sets Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17424 diff changeset	15 import obsolete as obsmod
20286 760151697a4f revset: make default kind of pattern for "contains()" rooted at cwd FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20285 diff changeset	16 import pathutil
18251 a6483f827512 revset: retrieve hidden from filteredrevs Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 18071 diff changeset	17 import repoview
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	18
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	19 def _revancestors(repo, revs, followfirst):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	20 """Like revlog.ancestors(), but supports followfirst."""
24306 6ddc86eedc3b style: kill ersatz if-else ternary operators Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24219 diff changeset	21 if followfirst:
6ddc86eedc3b style: kill ersatz if-else ternary operators Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24219 diff changeset	22 cut = 1
6ddc86eedc3b style: kill ersatz if-else ternary operators Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24219 diff changeset	23 else:
6ddc86eedc3b style: kill ersatz if-else ternary operators Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24219 diff changeset	24 cut = None
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	25 cl = repo.changelog
20690 13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	26
13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	27 def iterate():
22832 2f1d2a42f040 revancestors: replace `descending` with `sort(reverse=False)` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22831 diff changeset	28 revs.sort(reverse=True)
24939 85544a52ee84 revset: use an iterator instead of a dequeue in ancestors() Pierre-Yves David <pierre-yves.david@fb.com> parents: 24938 diff changeset	29 irevs = iter(revs)
20691 c1f666e27345 revset: optimized _revancestors method based on order of revisions Lucas Moscovicz <lmoscovicz@fb.com> parents: 20690 diff changeset	30 h = []
c1f666e27345 revset: optimized _revancestors method based on order of revisions Lucas Moscovicz <lmoscovicz@fb.com> parents: 20690 diff changeset	31
25143 91c49621b2b8 _revancestors: use 'next' to remove the verbose try except clauses Pierre-Yves David <pierre-yves.david@fb.com> parents: 25131 diff changeset	32 inputrev = next(irevs, None)
91c49621b2b8 _revancestors: use 'next' to remove the verbose try except clauses Pierre-Yves David <pierre-yves.david@fb.com> parents: 25131 diff changeset	33 if inputrev is not None:
24939 85544a52ee84 revset: use an iterator instead of a dequeue in ancestors() Pierre-Yves David <pierre-yves.david@fb.com> parents: 24938 diff changeset	34 heapq.heappush(h, -inputrev)
20691 c1f666e27345 revset: optimized _revancestors method based on order of revisions Lucas Moscovicz <lmoscovicz@fb.com> parents: 20690 diff changeset	35
23956 b1e026c25552 revset: fix ancestors(null) to include null revision (issue4512) Yuya Nishihara <yuya@tcha.org> parents: 23954 diff changeset	36 seen = set()
20690 13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	37 while h:
13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	38 current = -heapq.heappop(h)
24940 6b54f749659b revset: avoid returning duplicates when returning ancestors Pierre-Yves David <pierre-yves.david@fb.com> parents: 24939 diff changeset	39 if current == inputrev:
25143 91c49621b2b8 _revancestors: use 'next' to remove the verbose try except clauses Pierre-Yves David <pierre-yves.david@fb.com> parents: 25131 diff changeset	40 inputrev = next(irevs, None)
91c49621b2b8 _revancestors: use 'next' to remove the verbose try except clauses Pierre-Yves David <pierre-yves.david@fb.com> parents: 25131 diff changeset	41 if inputrev is not None:
24940 6b54f749659b revset: avoid returning duplicates when returning ancestors Pierre-Yves David <pierre-yves.david@fb.com> parents: 24939 diff changeset	42 heapq.heappush(h, -inputrev)
20690 13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	43 if current not in seen:
13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	44 seen.add(current)
13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	45 yield current
13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	46 for parent in cl.parentrevs(current)[:cut]:
13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	47 if parent != node.nullrev:
13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	48 heapq.heappush(h, -parent)
13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	49
22795 c21342159fad generatorset: drop the leading underscore in the class name Pierre-Yves David <pierre-yves.david@fb.com> parents: 22794 diff changeset	50 return generatorset(iterate(), iterasc=False)
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	51
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	52 def _revdescendants(repo, revs, followfirst):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	53 """Like revlog.descendants() but supports followfirst."""
24306 6ddc86eedc3b style: kill ersatz if-else ternary operators Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24219 diff changeset	54 if followfirst:
6ddc86eedc3b style: kill ersatz if-else ternary operators Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24219 diff changeset	55 cut = 1
6ddc86eedc3b style: kill ersatz if-else ternary operators Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24219 diff changeset	56 else:
6ddc86eedc3b style: kill ersatz if-else ternary operators Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24219 diff changeset	57 cut = None
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	58
20692 7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	59 def iterate():
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	60 cl = repo.changelog
25549 f93ff3ab8d14 revset: mark spots that should use 'smartset.min()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25548 diff changeset	61 # XXX this should be 'parentset.min()' assuming 'parentset' is a
f93ff3ab8d14 revset: mark spots that should use 'smartset.min()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25548 diff changeset	62 # smartset (and if it is not, it should.)
20692 7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	63 first = min(revs)
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	64 nullrev = node.nullrev
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	65 if first == nullrev:
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	66 # Are there nodes with a null first parent and a non-null
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	67 # second one? Maybe. Do we care? Probably not.
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	68 for i in cl:
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	69 yield i
20692 7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	70 else:
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	71 seen = set(revs)
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	72 for i in cl.revs(first + 1):
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	73 for x in cl.parentrevs(i)[:cut]:
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	74 if x != nullrev and x in seen:
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	75 seen.add(i)
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	76 yield i
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	77 break
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	78
22795 c21342159fad generatorset: drop the leading underscore in the class name Pierre-Yves David <pierre-yves.david@fb.com> parents: 22794 diff changeset	79 return generatorset(iterate(), iterasc=True)
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	80
16862 b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	81 def _revsbetween(repo, roots, heads):
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	82 """Return all paths between roots and heads, inclusive of both endpoint
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	83 sets."""
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	84 if not roots:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	85 return baseset()
16862 b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	86 parentrevs = repo.changelog.parentrevs
22487 e40bb83d0989 revset: stop using a baseset instead of a plain list in _revsbetween Pierre-Yves David <pierre-yves.david@fb.com> parents: 22483 diff changeset	87 visit = list(heads)
16862 b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	88 reachable = set()
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	89 seen = {}
25549 f93ff3ab8d14 revset: mark spots that should use 'smartset.min()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25548 diff changeset	90 # XXX this should be 'parentset.min()' assuming 'parentset' is a smartset
f93ff3ab8d14 revset: mark spots that should use 'smartset.min()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25548 diff changeset	91 # (and if it is not, it should.)
16862 b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	92 minroot = min(roots)
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	93 roots = set(roots)
25566 15412bba5a68 revset: prefetch all attributes before loop in _revsbetween Pierre-Yves David <pierre-yves.david@fb.com> parents: 25554 diff changeset	94 # prefetch all the things! (because python is slow)
15412bba5a68 revset: prefetch all attributes before loop in _revsbetween Pierre-Yves David <pierre-yves.david@fb.com> parents: 25554 diff changeset	95 reached = reachable.add
15412bba5a68 revset: prefetch all attributes before loop in _revsbetween Pierre-Yves David <pierre-yves.david@fb.com> parents: 25554 diff changeset	96 dovisit = visit.append
15412bba5a68 revset: prefetch all attributes before loop in _revsbetween Pierre-Yves David <pierre-yves.david@fb.com> parents: 25554 diff changeset	97 nextvisit = visit.pop
16862 b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	98 # open-code the post-order traversal due to the tiny size of
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	99 # sys.getrecursionlimit()
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	100 while visit:
25566 15412bba5a68 revset: prefetch all attributes before loop in _revsbetween Pierre-Yves David <pierre-yves.david@fb.com> parents: 25554 diff changeset	101 rev = nextvisit()
16862 b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	102 if rev in roots:
25566 15412bba5a68 revset: prefetch all attributes before loop in _revsbetween Pierre-Yves David <pierre-yves.david@fb.com> parents: 25554 diff changeset	103 reached(rev)
16862 b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	104 parents = parentrevs(rev)
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	105 seen[rev] = parents
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	106 for parent in parents:
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	107 if parent >= minroot and parent not in seen:
25566 15412bba5a68 revset: prefetch all attributes before loop in _revsbetween Pierre-Yves David <pierre-yves.david@fb.com> parents: 25554 diff changeset	108 dovisit(parent)
16862 b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	109 if not reachable:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	110 return baseset()
16862 b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	111 for rev in sorted(seen):
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	112 for parent in seen[rev]:
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	113 if parent in reachable:
25566 15412bba5a68 revset: prefetch all attributes before loop in _revsbetween Pierre-Yves David <pierre-yves.david@fb.com> parents: 25554 diff changeset	114 reached(rev)
20364 a6cf48b2880d revset: added baseset class (still empty) to improve revset performance Lucas Moscovicz <lmoscovicz@fb.com> parents: 20289 diff changeset	115 return baseset(sorted(reachable))
16862 b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	116
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	117 elements = {
23742 3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	118 "(": (21, ("group", 1, ")"), ("func", 1, ")")),
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	119 "##": (20, None, ("_concat", 20)),
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	120 "~": (18, None, ("ancestor", 18)),
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	121 "^": (18, None, ("parent", 18), ("parentpost", 18)),
12616 e797fdf91df4 revset: lower precedence of minus infix (issue2361) Matt Mackall <mpm@selenic.com> parents: 12615 diff changeset	122 "-": (5, ("negate", 19), ("minus", 5)),
11278 7df88cdf47fd revset: add support for prefix and suffix versions of : and :: Matt Mackall <mpm@selenic.com> parents: 11275 diff changeset	123 "::": (17, ("dagrangepre", 17), ("dagrange", 17),
7df88cdf47fd revset: add support for prefix and suffix versions of : and :: Matt Mackall <mpm@selenic.com> parents: 11275 diff changeset	124 ("dagrangepost", 17)),
7df88cdf47fd revset: add support for prefix and suffix versions of : and :: Matt Mackall <mpm@selenic.com> parents: 11275 diff changeset	125 "..": (17, ("dagrangepre", 17), ("dagrange", 17),
7df88cdf47fd revset: add support for prefix and suffix versions of : and :: Matt Mackall <mpm@selenic.com> parents: 11275 diff changeset	126 ("dagrangepost", 17)),
7df88cdf47fd revset: add support for prefix and suffix versions of : and :: Matt Mackall <mpm@selenic.com> parents: 11275 diff changeset	127 ":": (15, ("rangepre", 15), ("range", 15), ("rangepost", 15)),
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	128 "not": (10, ("not", 10)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	129 "!": (10, ("not", 10)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	130 "and": (5, None, ("and", 5)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	131 "&": (5, None, ("and", 5)),
23765 537a2669a113 revset: use '%' as an operator for 'only' Sean Farley <sean.michael.farley@gmail.com> parents: 23742 diff changeset	132 "%": (5, None, ("only", 5), ("onlypost", 5)),
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	133 "or": (4, None, ("or", 4)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	134 "\|": (4, None, ("or", 4)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	135 "+": (4, None, ("or", 4)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	136 ",": (2, None, ("list", 2)),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	137 ")": (0, None, None),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	138 "symbol": (0, ("symbol",), None),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	139 "string": (0, ("string",), None),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	140 "end": (0, None, None),
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	141 }
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	142
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	143 keywords = set(['and', 'or', 'not'])
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	144
23842 91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	145 # default set of valid characters for the initial letter of symbols
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	146 _syminitletters = set(c for c in [chr(i) for i in xrange(256)]
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	147 if c.isalnum() or c in '._@' or ord(c) > 127)
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	148
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	149 # default set of valid characters for non-initial letters of symbols
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	150 _symletters = set(c for c in [chr(i) for i in xrange(256)]
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	151 if c.isalnum() or c in '-._/@' or ord(c) > 127)
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	152
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	153 def tokenize(program, lookup=None, syminitletters=None, symletters=None):
17886 d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	154 '''
d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	155 Parse a revset statement into a stream of tokens
d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	156
23842 91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	157 ``syminitletters`` is the set of valid characters for the initial
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	158 letter of symbols.
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	159
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	160 By default, character ``c`` is recognized as valid for initial
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	161 letter of symbols, if ``c.isalnum() or c in '._@' or ord(c) > 127``.
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	162
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	163 ``symletters`` is the set of valid characters for non-initial
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	164 letters of symbols.
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	165
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	166 By default, character ``c`` is recognized as valid for non-initial
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	167 letters of symbols, if ``c.isalnum() or c in '-._/@' or ord(c) > 127``.
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	168
17886 d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	169 Check that @ is a valid unquoted token character (issue3686):
d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	170 >>> list(tokenize("@::"))
d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	171 [('symbol', '@', 0), ('::', None, 1), ('end', None, 3)]
d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	172
d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	173 '''
23842 91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	174 if syminitletters is None:
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	175 syminitletters = _syminitletters
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	176 if symletters is None:
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	177 symletters = _symletters
17886 d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	178
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	179 pos, l = 0, len(program)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	180 while pos < l:
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	181 c = program[pos]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	182 if c.isspace(): # skip inter-token whitespace
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	183 pass
11278 7df88cdf47fd revset: add support for prefix and suffix versions of : and :: Matt Mackall <mpm@selenic.com> parents: 11275 diff changeset	184 elif c == ':' and program[pos:pos + 2] == '::': # look ahead carefully
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	185 yield ('::', None, pos)
11278 7df88cdf47fd revset: add support for prefix and suffix versions of : and :: Matt Mackall <mpm@selenic.com> parents: 11275 diff changeset	186 pos += 1 # skip ahead
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	187 elif c == '.' and program[pos:pos + 2] == '..': # look ahead carefully
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	188 yield ('..', None, pos)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	189 pos += 1 # skip ahead
23742 3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	190 elif c == '#' and program[pos:pos + 2] == '##': # look ahead carefully
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	191 yield ('##', None, pos)
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	192 pos += 1 # skip ahead
23765 537a2669a113 revset: use '%' as an operator for 'only' Sean Farley <sean.michael.farley@gmail.com> parents: 23742 diff changeset	193 elif c in "():,-\|&+!~^%": # handle simple operators
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	194 yield (c, None, pos)
12408 78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	195 elif (c in '"\'' or c == 'r' and
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	196 program[pos:pos + 2] in ("r'", 'r"')): # handle quoted strings
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	197 if c == 'r':
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	198 pos += 1
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	199 c = program[pos]
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	200 decode = lambda x: x
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	201 else:
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	202 decode = lambda x: x.decode('string-escape')
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	203 pos += 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	204 s = pos
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	205 while pos < l: # find closing quote
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	206 d = program[pos]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	207 if d == '\\': # skip over escaped characters
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	208 pos += 2
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	209 continue
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	210 if d == c:
12408 78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	211 yield ('string', decode(program[s:pos]), s)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	212 break
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	213 pos += 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	214 else:
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	215 raise error.ParseError(_("unterminated string"), s)
16683 525fdb738975 cleanup: eradicate long lines Brodie Rao <brodie@sf.io> parents: 16661 diff changeset	216 # gather up a symbol/keyword
23842 91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	217 elif c in syminitletters:
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	218 s = pos
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	219 pos += 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	220 while pos < l: # find end of symbol
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	221 d = program[pos]
23842 91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	222 if d not in symletters:
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	223 break
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	224 if d == '.' and program[pos - 1] == '.': # special case for ..
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	225 pos -= 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	226 break
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	227 pos += 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	228 sym = program[s:pos]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	229 if sym in keywords: # operator keywords
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	230 yield (sym, None, s)
20780 403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	231 elif '-' in sym:
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	232 # some jerk gave us foo-bar-baz, try to check if it's a symbol
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	233 if lookup and lookup(sym):
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	234 # looks like a real symbol
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	235 yield ('symbol', sym, s)
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	236 else:
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	237 # looks like an expression
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	238 parts = sym.split('-')
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	239 for p in parts[:-1]:
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	240 if p: # possible consecutive -
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	241 yield ('symbol', p, s)
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	242 s += len(p)
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	243 yield ('-', None, pos)
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	244 s += 1
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	245 if parts[-1]: # possible trailing -
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	246 yield ('symbol', parts[-1], s)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	247 else:
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	248 yield ('symbol', sym, s)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	249 pos -= 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	250 else:
24708 fb47816e1a9c revsets: more informative syntax error message Ryan McElroy <rmcelroy@fb.com> parents: 24518 diff changeset	251 raise error.ParseError(_("syntax error in revset '%s'") %
fb47816e1a9c revsets: more informative syntax error message Ryan McElroy <rmcelroy@fb.com> parents: 24518 diff changeset	252 program, pos)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	253 pos += 1
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	254 yield ('end', None, pos)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	255
23843 c4d0c3d05721 revset: factor out composing error message for ParseError to reuse FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23842 diff changeset	256 def parseerrordetail(inst):
c4d0c3d05721 revset: factor out composing error message for ParseError to reuse FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23842 diff changeset	257 """Compose error message from specified ParseError object
c4d0c3d05721 revset: factor out composing error message for ParseError to reuse FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23842 diff changeset	258 """
c4d0c3d05721 revset: factor out composing error message for ParseError to reuse FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23842 diff changeset	259 if len(inst.args) > 1:
c4d0c3d05721 revset: factor out composing error message for ParseError to reuse FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23842 diff changeset	260 return _('at %s: %s') % (inst.args[1], inst.args[0])
c4d0c3d05721 revset: factor out composing error message for ParseError to reuse FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23842 diff changeset	261 else:
c4d0c3d05721 revset: factor out composing error message for ParseError to reuse FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23842 diff changeset	262 return inst.args[0]
c4d0c3d05721 revset: factor out composing error message for ParseError to reuse FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23842 diff changeset	263
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	264 # helpers
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	265
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	266 def getstring(x, err):
11406 42408cd43f55 revset: fix up contains/getstring when no args passed Matt Mackall <mpm@selenic.com> parents: 11404 diff changeset	267 if x and (x[0] == 'string' or x[0] == 'symbol'):
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	268 return x[1]
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	269 raise error.ParseError(err)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	270
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	271 def getlist(x):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	272 if not x:
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	273 return []
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	274 if x[0] == 'list':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	275 return getlist(x[1]) + [x[2]]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	276 return [x]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	277
11339 744d5b73f776 revset: improve filter argument handling Matt Mackall <mpm@selenic.com> parents: 11304 diff changeset	278 def getargs(x, min, max, err):
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	279 l = getlist(x)
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	280 if len(l) < min or (max >= 0 and len(l) > max):
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	281 raise error.ParseError(err)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	282 return l
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	283
23845 0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	284 def isvalidsymbol(tree):
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	285 """Examine whether specified ``tree`` is valid ``symbol`` or not
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	286 """
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	287 return tree[0] == 'symbol' and len(tree) > 1
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	288
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	289 def getsymbol(tree):
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	290 """Get symbol name from valid ``symbol`` in ``tree``
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	291
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	292 This assumes that ``tree`` is already examined by ``isvalidsymbol``.
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	293 """
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	294 return tree[1]
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	295
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	296 def isvalidfunc(tree):
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	297 """Examine whether specified ``tree`` is valid ``func`` or not
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	298 """
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	299 return tree[0] == 'func' and len(tree) > 1 and isvalidsymbol(tree[1])
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	300
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	301 def getfuncname(tree):
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	302 """Get function name from valid ``func`` in ``tree``
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	303
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	304 This assumes that ``tree`` is already examined by ``isvalidfunc``.
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	305 """
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	306 return getsymbol(tree[1])
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	307
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	308 def getfuncargs(tree):
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	309 """Get list of function arguments from valid ``func`` in ``tree``
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	310
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	311 This assumes that ``tree`` is already examined by ``isvalidfunc``.
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	312 """
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	313 if len(tree) > 2:
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	314 return getlist(tree[2])
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	315 else:
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	316 return []
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	317
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	318 def getset(repo, subset, x):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	319 if not x:
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	320 raise error.ParseError(_("missing argument"))
20527 bde426f18e0a revset: changed mfunc and getset to work with old style revset methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20526 diff changeset	321 s = methods[x[0]](repo, subset, *x[1:])
22884 4584eec9aead getset: check if an object is a baseset using `isascending` instead of `set` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22883 diff changeset	322 if util.safehasattr(s, 'isascending'):
20527 bde426f18e0a revset: changed mfunc and getset to work with old style revset methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20526 diff changeset	323 return s
bde426f18e0a revset: changed mfunc and getset to work with old style revset methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20526 diff changeset	324 return baseset(s)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	325
17003 42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	326 def _getrevsource(repo, r):
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	327 extra = repo[r].extra()
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	328 for label in ('source', 'transplant_source', 'rebase_source'):
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	329 if label in extra:
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	330 try:
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	331 return repo[extra[label]].rev()
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	332 except error.RepoLookupError:
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	333 pass
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	334 return None
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	335
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	336 # operator methods
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	337
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	338 def stringset(repo, subset, x):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	339 x = repo[x].rev()
25265 e16456831516 revset: drop magic of fullreposet membership test (issue4682) Yuya Nishihara <yuya@tcha.org> parents: 25094 diff changeset	340 if (x in subset
e16456831516 revset: drop magic of fullreposet membership test (issue4682) Yuya Nishihara <yuya@tcha.org> parents: 25094 diff changeset	341 or x == node.nullrev and isinstance(subset, fullreposet)):
20364 a6cf48b2880d revset: added baseset class (still empty) to improve revset performance Lucas Moscovicz <lmoscovicz@fb.com> parents: 20289 diff changeset	342 return baseset([x])
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	343 return baseset()
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	344
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	345 def rangeset(repo, subset, x, y):
23162 69524a05a7fa revset-rangeset: call 'getset' on a 'fullreposet' Pierre-Yves David <pierre-yves.david@fb.com> parents: 23139 diff changeset	346 m = getset(repo, fullreposet(repo), x)
69524a05a7fa revset-rangeset: call 'getset' on a 'fullreposet' Pierre-Yves David <pierre-yves.david@fb.com> parents: 23139 diff changeset	347 n = getset(repo, fullreposet(repo), y)
11456 88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	348
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	349 if not m or not n:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	350 return baseset()
22817 e4eb4bfc3616 rangeset: use `first` and `last` instead of direct indexing Pierre-Yves David <pierre-yves.david@fb.com> parents: 22813 diff changeset	351 m, n = m.first(), n.last()
11456 88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	352
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	353 if m < n:
20526 9ad6dae67845 revset: changed revsets to use spanset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20525 diff changeset	354 r = spanset(repo, m, n + 1)
11456 88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	355 else:
20526 9ad6dae67845 revset: changed revsets to use spanset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20525 diff changeset	356 r = spanset(repo, m, n - 1)
25548 9584bcf27637 revset: mark the place where we are combining sets in the wrong direction Pierre-Yves David <pierre-yves.david@fb.com> parents: 25547 diff changeset	357 # XXX We should combine with subset first: 'subset & baseset(...)'. This is
9584bcf27637 revset: mark the place where we are combining sets in the wrong direction Pierre-Yves David <pierre-yves.david@fb.com> parents: 25547 diff changeset	358 # necessary to ensure we preserve the order in subset.
9584bcf27637 revset: mark the place where we are combining sets in the wrong direction Pierre-Yves David <pierre-yves.david@fb.com> parents: 25547 diff changeset	359 #
9584bcf27637 revset: mark the place where we are combining sets in the wrong direction Pierre-Yves David <pierre-yves.david@fb.com> parents: 25547 diff changeset	360 # This has performance implication, carrying the sorting over when possible
9584bcf27637 revset: mark the place where we are combining sets in the wrong direction Pierre-Yves David <pierre-yves.david@fb.com> parents: 25547 diff changeset	361 # would be more efficient.
20526 9ad6dae67845 revset: changed revsets to use spanset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20525 diff changeset	362 return r & subset
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	363
16860 e1aa1ed30030 revset: turn dagrange into a function Bryan O'Sullivan <bryano@fb.com> parents: 16859 diff changeset	364 def dagrange(repo, subset, x, y):
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	365 r = fullreposet(repo)
18991 c1af1fb314bc log: fix behavior with empty repositories (issue3497) Alexander Plavin <me@aplavin.ru> parents: 18779 diff changeset	366 xs = _revsbetween(repo, getset(repo, r, x), getset(repo, r, y))
25548 9584bcf27637 revset: mark the place where we are combining sets in the wrong direction Pierre-Yves David <pierre-yves.david@fb.com> parents: 25547 diff changeset	367 # XXX We should combine with subset first: 'subset & baseset(...)'. This is
9584bcf27637 revset: mark the place where we are combining sets in the wrong direction Pierre-Yves David <pierre-yves.david@fb.com> parents: 25547 diff changeset	368 # necessary to ensure we preserve the order in subset.
22866 6e739356f9bf revset-rangeset: remove usage of `set()` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22865 diff changeset	369 return xs & subset
16860 e1aa1ed30030 revset: turn dagrange into a function Bryan O'Sullivan <bryano@fb.com> parents: 16859 diff changeset	370
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	371 def andset(repo, subset, x, y):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	372 return getset(repo, getset(repo, subset, x), y)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	373
25309 b333ca94403d revset: reduce nesting of chained 'or' operations (issue4624) Yuya Nishihara <yuya@tcha.org> parents: 25308 diff changeset	374 def orset(repo, subset, *xs):
b333ca94403d revset: reduce nesting of chained 'or' operations (issue4624) Yuya Nishihara <yuya@tcha.org> parents: 25308 diff changeset	375 rs = [getset(repo, subset, x) for x in xs]
b333ca94403d revset: reduce nesting of chained 'or' operations (issue4624) Yuya Nishihara <yuya@tcha.org> parents: 25308 diff changeset	376 return _combinesets(rs)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	377
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	378 def notset(repo, subset, x):
20366 5ec6321f49a9 revset: added substraction to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20365 diff changeset	379 return subset - getset(repo, subset, x)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	380
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	381 def listset(repo, subset, a, b):
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	382 raise error.ParseError(_("can't use a list in this context"))
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	383
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	384 def func(repo, subset, a, b):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	385 if a[0] == 'symbol' and a[1] in symbols:
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	386 return symbols[a[1]](repo, subset, b)
24219 282c0d8c1880 revset: use UnknownIdentifier where appropriate Augie Fackler <augie@google.com> parents: 24204 diff changeset	387 raise error.UnknownIdentifier(a[1], symbols.keys())
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	388
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	389 # functions
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	390
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	391 def adds(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	392 """``adds(pattern)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	393 Changesets that add a file matching pattern.
20289 96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	394
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	395 The pattern without explicit kind like ``glob:`` is expected to be
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	396 relative to the current directory and match against a file or a
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	397 directory.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	398 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	399 # i18n: "adds" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	400 pat = getstring(x, _("adds requires a pattern"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	401 return checkstatus(repo, subset, pat, 1)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	402
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	403 def ancestor(repo, subset, x):
18536 ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	404 """``ancestor(*changeset)``
20991 a05d694599f9 revlog: use context ancestor instead of changelog ancestor Mads Kiilerich <madski@unity3d.com> parents: 20895 diff changeset	405 A greatest common ancestor of the changesets.
18536 ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	406
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	407 Accepts 0 or more changesets.
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	408 Will return empty list when passed no args.
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	409 Greatest common ancestor of a single changeset is that changeset.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	410 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	411 # i18n: "ancestor" is a keyword
18536 ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	412 l = getlist(x)
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	413 rl = fullreposet(repo)
18536 ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	414 anc = None
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	415
18536 ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	416 # (getset(repo, rl, i) for i in l) generates a list of lists
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	417 for revs in (getset(repo, rl, i) for i in l):
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	418 for r in revs:
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	419 if anc is None:
20991 a05d694599f9 revlog: use context ancestor instead of changelog ancestor Mads Kiilerich <madski@unity3d.com> parents: 20895 diff changeset	420 anc = repo[r]
18536 ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	421 else:
20991 a05d694599f9 revlog: use context ancestor instead of changelog ancestor Mads Kiilerich <madski@unity3d.com> parents: 20895 diff changeset	422 anc = anc.ancestor(repo[r])
a05d694599f9 revlog: use context ancestor instead of changelog ancestor Mads Kiilerich <madski@unity3d.com> parents: 20895 diff changeset	423
a05d694599f9 revlog: use context ancestor instead of changelog ancestor Mads Kiilerich <madski@unity3d.com> parents: 20895 diff changeset	424 if anc is not None and anc.rev() in subset:
a05d694599f9 revlog: use context ancestor instead of changelog ancestor Mads Kiilerich <madski@unity3d.com> parents: 20895 diff changeset	425 return baseset([anc.rev()])
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	426 return baseset()
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	427
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	428 def _ancestors(repo, subset, x, followfirst=False):
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	429 heads = getset(repo, fullreposet(repo), x)
22944 5aae3dea8044 revset: better naming of variables containing the value of a single argument Mads Kiilerich <madski@unity3d.com> parents: 22891 diff changeset	430 if not heads:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	431 return baseset()
22944 5aae3dea8044 revset: better naming of variables containing the value of a single argument Mads Kiilerich <madski@unity3d.com> parents: 22891 diff changeset	432 s = _revancestors(repo, heads, followfirst)
23003 62d19ce9d7b6 revset-_ancestor: use & instead of filter Pierre-Yves David <pierre-yves.david@fb.com> parents: 22999 diff changeset	433 return subset & s
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	434
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	435 def ancestors(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	436 """``ancestors(set)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	437 Changesets that are ancestors of a changeset in set.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	438 """
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	439 return _ancestors(repo, subset, x)
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	440
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	441 def _firstancestors(repo, subset, x):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	442 # ``_firstancestors(set)``
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	443 # Like ``ancestors(set)`` but follows only the first parents.
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	444 return _ancestors(repo, subset, x, followfirst=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	445
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	446 def ancestorspec(repo, subset, x, n):
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	447 """``set~n``
16683 525fdb738975 cleanup: eradicate long lines Brodie Rao <brodie@sf.io> parents: 16661 diff changeset	448 Changesets that are the Nth ancestor (first parents only) of a changeset
525fdb738975 cleanup: eradicate long lines Brodie Rao <brodie@sf.io> parents: 16661 diff changeset	449 in set.
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	450 """
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	451 try:
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	452 n = int(n[1])
14851 f96c354493d7 revsets: actually catch type error on tip^p1(tip) (issue2884) Matt Mackall <mpm@selenic.com> parents: 14842 diff changeset	453 except (TypeError, ValueError):
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	454 raise error.ParseError(_("~ expects a number"))
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	455 ps = set()
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	456 cl = repo.changelog
23163 6f1b8b3f12fd revset-ancestorspec: call 'getset' on a 'fullreposet' Pierre-Yves David <pierre-yves.david@fb.com> parents: 23162 diff changeset	457 for r in getset(repo, fullreposet(repo), x):
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	458 for i in range(n):
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	459 r = cl.parentrevs(r)[0]
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	460 ps.add(r)
22531 22ba2c0825da revset: use `subset &` in `ancestorspec` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22530 diff changeset	461 return subset & ps
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	462
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	463 def author(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	464 """``author(string)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	465 Alias for ``user(string)``.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	466 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	467 # i18n: "author" is a keyword
15726 9b822edecb4c i18n: use "encoding.lower()" to normalize specified string for revset FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15596 diff changeset	468 n = encoding.lower(getstring(x, _("author requires a string")))
16823 b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	469 kind, pattern, matcher = _substringmatcher(n)
20611 6490f8385391 revset: changed revset code to use filter method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20610 diff changeset	470 return subset.filter(lambda x: matcher(encoding.lower(repo[x].user())))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	471
15134 81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	472 def bisect(repo, subset, x):
81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	473 """``bisect(string)``
15153 fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads' "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15147 diff changeset	474 Changesets marked in the specified bisect status:
15136 18219c0789ae revset.bisect: add new 'range' set to the bisect keyword "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15135 diff changeset	475
15153 fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads' "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15147 diff changeset	476 - ``good``, ``bad``, ``skip``: csets explicitly marked as good/bad/skip
17424 e7cfe3587ea4 fix trivial spelling errors Mads Kiilerich <mads@kiilerich.com> parents: 17390 diff changeset	477 - ``goods``, ``bads`` : csets topologically good/bad
15153 fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads' "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15147 diff changeset	478 - ``range`` : csets taking part in the bisection
fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads' "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15147 diff changeset	479 - ``pruned`` : csets that are goods, bads or skipped
fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads' "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15147 diff changeset	480 - ``untested`` : csets whose fate is yet unknown
fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads' "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15147 diff changeset	481 - ``ignored`` : csets ignored due to DAG topology
16647 14913fcb30c6 bisect: track the current changeset (issue3382) Bryan O'Sullivan <bryano@fb.com> parents: 16640 diff changeset	482 - ``current`` : the cset currently being bisected
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	483 """
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	484 # i18n: "bisect" is a keyword
15135 f19de58af225 revset.bisect: move bisect() code to hbisect.py "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15134 diff changeset	485 status = getstring(x, _("bisect requires a string")).lower()
16467 7f59900e3f8b revset: fix O(n*2) behaviour of bisect() (issue3381) Bryan O'Sullivan <bryano@fb.com>* parents: 16453 diff changeset	486 state = set(hbisect.get(repo, status))
22532 0cf46b8298fe revset: use `subset &` in `bisect` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22531 diff changeset	487 return subset & state
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	488
15134 81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	489 # Backward-compatibility
81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	490 # - no help entry so that we do not advertise it any more
81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	491 def bisected(repo, subset, x):
81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	492 return bisect(repo, subset, x)
81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	493
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	494 def bookmark(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	495 """``bookmark([name])``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	496 The named bookmark or all bookmarks.
16822 da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	497
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	498 If `name` starts with `re:`, the remainder of the name is treated as
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	499 a regular expression. To match a bookmark that actually starts with `re:`,
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	500 use the prefix `literal:`.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	501 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	502 # i18n: "bookmark" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	503 args = getargs(x, 0, 1, _('bookmark takes one or no arguments'))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	504 if args:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	505 bm = getstring(args[0],
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	506 # i18n: "bookmark" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	507 _('the argument to bookmark must be a string'))
16822 da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	508 kind, pattern, matcher = _stringmatcher(bm)
22499 8c9f9e346acc revset: unify code flow in `bookmark` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22498 diff changeset	509 bms = set()
16822 da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	510 if kind == 'literal':
22105 3efe3c2609e0 revset: bookmark revset interprets 'literal:' prefix correctly (issue4329) Michael O'Connor <mkoconnor@gmail.com> parents: 21939 diff changeset	511 bmrev = repo._bookmarks.get(pattern, None)
16822 da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	512 if not bmrev:
23978 eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23956 diff changeset	513 raise error.RepoLookupError(_("bookmark '%s' does not exist")
eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23956 diff changeset	514 % bm)
22499 8c9f9e346acc revset: unify code flow in `bookmark` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22498 diff changeset	515 bms.add(repo[bmrev].rev())
16822 da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	516 else:
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	517 matchrevs = set()
18495 8260fa9f30b9 bookmarks: don't use bookmarks.listbookmarks in local computations Kevin Bullock <kbullock@ringworld.org> parents: 18473 diff changeset	518 for name, bmrev in repo._bookmarks.iteritems():
16822 da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	519 if matcher(name):
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	520 matchrevs.add(bmrev)
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	521 if not matchrevs:
23978 eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23956 diff changeset	522 raise error.RepoLookupError(_("no bookmarks exist"
eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23956 diff changeset	523 " that match '%s'") % pattern)
16822 da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	524 for bmrev in matchrevs:
22499 8c9f9e346acc revset: unify code flow in `bookmark` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22498 diff changeset	525 bms.add(repo[bmrev].rev())
8c9f9e346acc revset: unify code flow in `bookmark` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22498 diff changeset	526 else:
8c9f9e346acc revset: unify code flow in `bookmark` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22498 diff changeset	527 bms = set([repo[r].rev()
8c9f9e346acc revset: unify code flow in `bookmark` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22498 diff changeset	528 for r in repo._bookmarks.values()])
22500 171015d3b30c revset: remove nullrev from the bookmark computation Pierre-Yves David <pierre-yves.david@fb.com> parents: 22499 diff changeset	529 bms -= set([node.nullrev])
22530 faf4f63533ff revset: use `subset &` in `bookmark` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22529 diff changeset	530 return subset & bms
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	531
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	532 def branch(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	533 """``branch(string or set)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	534 All changesets belonging to the given branch or the branches of the given
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	535 changesets.
16821 0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	536
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	537 If `string` starts with `re:`, the remainder of the name is treated as
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	538 a regular expression. To match a branch that actually starts with `re:`,
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	539 use the prefix `literal:`.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	540 """
24374 77fd1fb538cd revbranchcache: store repo on the object Durham Goode <durham@fb.com> parents: 24366 diff changeset	541 getbi = repo.revbranchcache().branchinfo
23787 678f53865c68 revset: use localrepo revbranchcache for branch name filtering Mads Kiilerich <madski@unity3d.com> parents: 23765 diff changeset	542
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	543 try:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	544 b = getstring(x, '')
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	545 except error.ParseError:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	546 # not a string, but another revspec, e.g. tip()
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	547 pass
16821 0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	548 else:
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	549 kind, pattern, matcher = _stringmatcher(b)
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	550 if kind == 'literal':
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	551 # note: falls through to the revspec case if no branch with
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	552 # this name exists
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	553 if pattern in repo.branchmap():
24374 77fd1fb538cd revbranchcache: store repo on the object Durham Goode <durham@fb.com> parents: 24366 diff changeset	554 return subset.filter(lambda r: matcher(getbi(r)[0]))
16821 0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	555 else:
24374 77fd1fb538cd revbranchcache: store repo on the object Durham Goode <durham@fb.com> parents: 24366 diff changeset	556 return subset.filter(lambda r: matcher(getbi(r)[0]))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	557
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	558 s = getset(repo, fullreposet(repo), x)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	559 b = set()
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	560 for r in s:
24374 77fd1fb538cd revbranchcache: store repo on the object Durham Goode <durham@fb.com> parents: 24366 diff changeset	561 b.add(getbi(r)[0])
22867 5ee9b78ce805 revset-branch: remove usage of `set()` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22866 diff changeset	562 c = s.__contains__
24374 77fd1fb538cd revbranchcache: store repo on the object Durham Goode <durham@fb.com> parents: 24366 diff changeset	563 return subset.filter(lambda r: c(r) or getbi(r)[0] in b)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	564
17829 c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	565 def bumped(repo, subset, x):
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	566 """``bumped()``
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	567 Mutable changesets marked as successors of public changesets.
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	568
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	569 Only non-public and non-obsolete changesets can be `bumped`.
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	570 """
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	571 # i18n: "bumped" is a keyword
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	572 getargs(x, 0, 0, _("bumped takes no arguments"))
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	573 bumped = obsmod.getrevs(repo, 'bumped')
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	574 return subset & bumped
17829 c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	575
17913 03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	576 def bundle(repo, subset, x):
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	577 """``bundle()``
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	578 Changesets in the bundle.
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	579
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	580 Bundle must be specified by the -R option."""
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	581
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	582 try:
18411 8b0f0dd56cec bundlerepo: improve performance for bundle() revset expression Mads Kiilerich <madski@unity3d.com> parents: 18382 diff changeset	583 bundlerevs = repo.changelog.bundlerevs
17913 03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	584 except AttributeError:
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	585 raise util.Abort(_("no bundle provided - specify with -R"))
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	586 return subset & bundlerevs
17913 03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	587
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	588 def checkstatus(repo, subset, pat, field):
16521 592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	589 hasset = matchmod.patkind(pat) == 'set'
20457 ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	590
23115 c23c03605c59 revset: don't recreate matcher for every revision Martin von Zweigbergk <martinvonz@google.com> parents: 23100 diff changeset	591 mcache = [None]
20457 ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	592 def matches(x):
ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	593 c = repo[x]
23115 c23c03605c59 revset: don't recreate matcher for every revision Martin von Zweigbergk <martinvonz@google.com> parents: 23100 diff changeset	594 if not mcache[0] or hasset:
c23c03605c59 revset: don't recreate matcher for every revision Martin von Zweigbergk <martinvonz@google.com> parents: 23100 diff changeset	595 mcache[0] = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c)
c23c03605c59 revset: don't recreate matcher for every revision Martin von Zweigbergk <martinvonz@google.com> parents: 23100 diff changeset	596 m = mcache[0]
c23c03605c59 revset: don't recreate matcher for every revision Martin von Zweigbergk <martinvonz@google.com> parents: 23100 diff changeset	597 fname = None
c23c03605c59 revset: don't recreate matcher for every revision Martin von Zweigbergk <martinvonz@google.com> parents: 23100 diff changeset	598 if not m.anypats() and len(m.files()) == 1:
c23c03605c59 revset: don't recreate matcher for every revision Martin von Zweigbergk <martinvonz@google.com> parents: 23100 diff changeset	599 fname = m.files()[0]
16521 592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	600 if fname is not None:
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	601 if fname not in c.files():
20457 ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	602 return False
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	603 else:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	604 for f in c.files():
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	605 if m(f):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	606 break
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	607 else:
20457 ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	608 return False
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	609 files = repo.status(c.p1().node(), c.node())[field]
16521 592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	610 if fname is not None:
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	611 if fname in files:
20457 ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	612 return True
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	613 else:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	614 for f in files:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	615 if m(f):
20457 ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	616 return True
ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	617
20611 6490f8385391 revset: changed revset code to use filter method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20610 diff changeset	618 return subset.filter(matches)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	619
16396 03e408a122c4 revset: avoid set duplication in roots() Patrick Mezard <patrick@mezard.eu> parents: 16395 diff changeset	620 def _children(repo, narrow, parentset):
25550 3e9049876ace revset: gratuitous code move in '_children' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25549 diff changeset	621 if not parentset:
3e9049876ace revset: gratuitous code move in '_children' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25549 diff changeset	622 return baseset()
15899 476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	623 cs = set()
476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	624 pr = repo.changelog.parentrevs
25567 f140d6207cca revset: use parentsets.min in _children Pierre-Yves David <pierre-yves.david@fb.com> parents: 25566 diff changeset	625 minrev = parentset.min()
16394 f3df7d34791e revset: do not ignore input revisions in roots() Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	626 for r in narrow:
18063 34a1a639d835 revset.children: ignore rev numbers that are too low Siddharth Agarwal <sid0@fb.com> parents: 17980 diff changeset	627 if r <= minrev:
34a1a639d835 revset.children: ignore rev numbers that are too low Siddharth Agarwal <sid0@fb.com> parents: 17980 diff changeset	628 continue
15899 476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	629 for p in pr(r):
16396 03e408a122c4 revset: avoid set duplication in roots() Patrick Mezard <patrick@mezard.eu> parents: 16395 diff changeset	630 if p in parentset:
15899 476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	631 cs.add(r)
25553 fa2e91d00e4c revset: mark spot that feeds a set to a baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 25552 diff changeset	632 # XXX using a set to feed the baseset is wrong. Sets are not ordered.
fa2e91d00e4c revset: mark spot that feeds a set to a baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 25552 diff changeset	633 # This does not break because of other fullreposet misbehavior.
20709 71df845d86cf revsets: backout d04aac468bf4 due to performance regressions Matt Mackall <mpm@selenic.com> parents: 20708 diff changeset	634 return baseset(cs)
15899 476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	635
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	636 def children(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	637 """``children(set)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	638 Child changesets of changesets in set.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	639 """
23164 7a42e5d4c418 revset-children: call 'getset' on a 'fullreposet' Pierre-Yves David <pierre-yves.david@fb.com> parents: 23163 diff changeset	640 s = getset(repo, fullreposet(repo), x)
15899 476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	641 cs = _children(repo, subset, s)
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	642 return subset & cs
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	643
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	644 def closed(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	645 """``closed()``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	646 Changeset is closed.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	647 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	648 # i18n: "closed" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	649 getargs(x, 0, 0, _("closed takes no arguments"))
20611 6490f8385391 revset: changed revset code to use filter method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20610 diff changeset	650 return subset.filter(lambda r: repo[r].closesbranch())
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	651
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	652 def contains(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	653 """``contains(pattern)``
21199 e9c2f76be74b help: clarify distinction among `contains`/`file`/`filelog` Greg Hurrell <glh@fb.com> parents: 21173 diff changeset	654 The revision's manifest contains a file matching pattern (but might not
e9c2f76be74b help: clarify distinction among `contains`/`file`/`filelog` Greg Hurrell <glh@fb.com> parents: 21173 diff changeset	655 modify it). See :hg:`help patterns` for information about file patterns.
20289 96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	656
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	657 The pattern without explicit kind like ``glob:`` is expected to be
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	658 relative to the current directory and match against a file exactly
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	659 for efficiency.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	660 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	661 # i18n: "contains" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	662 pat = getstring(x, _("contains requires a pattern"))
20461 abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	663
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	664 def matches(x):
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	665 if not matchmod.patkind(pat):
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	666 pats = pathutil.canonpath(repo.root, repo.getcwd(), pat)
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	667 if pats in repo[x]:
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	668 return True
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	669 else:
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	670 c = repo[x]
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	671 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c)
15964 6e37b8282aa2 revsets: provide contexts for filesets Matt Mackall <mpm@selenic.com> parents: 15949 diff changeset	672 for f in c.manifest():
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	673 if m(f):
20461 abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	674 return True
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	675 return False
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	676
20611 6490f8385391 revset: changed revset code to use filter method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20610 diff changeset	677 return subset.filter(matches)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	678
17002 0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	679 def converted(repo, subset, x):
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	680 """``converted([id])``
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	681 Changesets converted from the given identifier in the old repository if
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	682 present, or all converted changesets if no identifier is specified.
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	683 """
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	684
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	685 # There is exactly no chance of resolving the revision, so do a simple
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	686 # string compare and hope for the best
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	687
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	688 rev = None
17002 0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	689 # i18n: "converted" is a keyword
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	690 l = getargs(x, 0, 1, _('converted takes one or no arguments'))
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	691 if l:
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	692 # i18n: "converted" is a keyword
17002 0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	693 rev = getstring(l[0], _('converted requires a revision'))
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	694
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	695 def _matchvalue(r):
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	696 source = repo[r].extra().get('convert_revision', None)
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	697 return source is not None and (rev is None or source.startswith(rev))
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	698
20611 6490f8385391 revset: changed revset code to use filter method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20610 diff changeset	699 return subset.filter(lambda r: _matchvalue(r))
17002 0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	700
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	701 def date(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	702 """``date(interval)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	703 Changesets within the interval, see :hg:`help dates`.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	704 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	705 # i18n: "date" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	706 ds = getstring(x, _("date requires a string"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	707 dm = util.matchdate(ds)
20611 6490f8385391 revset: changed revset code to use filter method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20610 diff changeset	708 return subset.filter(lambda x: dm(repo[x].date()[0]))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	709
14650 93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	710 def desc(repo, subset, x):
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	711 """``desc(string)``
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	712 Search commit message for string. The match is case-insensitive.
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	713 """
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	714 # i18n: "desc" is a keyword
15726 9b822edecb4c i18n: use "encoding.lower()" to normalize specified string for revset FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15596 diff changeset	715 ds = encoding.lower(getstring(x, _("desc requires a string")))
20452 a685d9870eb5 revset: added lazyset implementation to desc revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20451 diff changeset	716
a685d9870eb5 revset: added lazyset implementation to desc revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20451 diff changeset	717 def matches(x):
a685d9870eb5 revset: added lazyset implementation to desc revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20451 diff changeset	718 c = repo[x]
a685d9870eb5 revset: added lazyset implementation to desc revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20451 diff changeset	719 return ds in encoding.lower(c.description())
a685d9870eb5 revset: added lazyset implementation to desc revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20451 diff changeset	720
20611 6490f8385391 revset: changed revset code to use filter method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20610 diff changeset	721 return subset.filter(matches)
14650 93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	722
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	723 def _descendants(repo, subset, x, followfirst=False):
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	724 roots = getset(repo, fullreposet(repo), x)
22944 5aae3dea8044 revset: better naming of variables containing the value of a single argument Mads Kiilerich <madski@unity3d.com> parents: 22891 diff changeset	725 if not roots:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	726 return baseset()
22944 5aae3dea8044 revset: better naming of variables containing the value of a single argument Mads Kiilerich <madski@unity3d.com> parents: 22891 diff changeset	727 s = _revdescendants(repo, roots, followfirst)
20894 04e1596d5dbd revset: improve _descendants performance Durham Goode <durham@fb.com> parents: 20863 diff changeset	728
04e1596d5dbd revset: improve _descendants performance Durham Goode <durham@fb.com> parents: 20863 diff changeset	729 # Both sets need to be ascending in order to lazily return the union
04e1596d5dbd revset: improve _descendants performance Durham Goode <durham@fb.com> parents: 20863 diff changeset	730 # in the correct order.
22944 5aae3dea8044 revset: better naming of variables containing the value of a single argument Mads Kiilerich <madski@unity3d.com> parents: 22891 diff changeset	731 base = subset & roots
22860 1dd178277cf5 revset-_descendant: rework the whole sorting and combining logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22859 diff changeset	732 desc = subset & s
1dd178277cf5 revset-_descendant: rework the whole sorting and combining logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22859 diff changeset	733 result = base + desc
1dd178277cf5 revset-_descendant: rework the whole sorting and combining logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22859 diff changeset	734 if subset.isascending():
1dd178277cf5 revset-_descendant: rework the whole sorting and combining logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22859 diff changeset	735 result.sort()
1dd178277cf5 revset-_descendant: rework the whole sorting and combining logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22859 diff changeset	736 elif subset.isdescending():
1dd178277cf5 revset-_descendant: rework the whole sorting and combining logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22859 diff changeset	737 result.sort(reverse=True)
1dd178277cf5 revset-_descendant: rework the whole sorting and combining logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22859 diff changeset	738 else:
1dd178277cf5 revset-_descendant: rework the whole sorting and combining logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22859 diff changeset	739 result = subset & result
22830 1d1da8abe130 _descendants: directly use smartset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22829 diff changeset	740 return result
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	741
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	742 def descendants(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	743 """``descendants(set)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	744 Changesets which are descendants of changesets in set.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	745 """
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	746 return _descendants(repo, subset, x)
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	747
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	748 def _firstdescendants(repo, subset, x):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	749 # ``_firstdescendants(set)``
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	750 # Like ``descendants(set)`` but follows only the first parents.
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	751 return _descendants(repo, subset, x, followfirst=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	752
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	753 def destination(repo, subset, x):
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	754 """``destination([set])``
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	755 Changesets that were created by a graft, transplant or rebase operation,
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	756 with the given revisions specified as the source. Omitting the optional set
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	757 is the same as passing all().
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	758 """
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	759 if x is not None:
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	760 sources = getset(repo, fullreposet(repo), x)
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	761 else:
24201 77ef059b3317 revset: drop unnecessary calls of getall() with empty argument Yuya Nishihara <yuya@tcha.org> parents: 24163 diff changeset	762 sources = fullreposet(repo)
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	763
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	764 dests = set()
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	765
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	766 # subset contains all of the possible destinations that can be returned, so
22944 5aae3dea8044 revset: better naming of variables containing the value of a single argument Mads Kiilerich <madski@unity3d.com> parents: 22891 diff changeset	767 # iterate over them and see if their source(s) were provided in the arg set.
5aae3dea8044 revset: better naming of variables containing the value of a single argument Mads Kiilerich <madski@unity3d.com> parents: 22891 diff changeset	768 # Even if the immediate src of r is not in the arg set, src's source (or
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	769 # further back) may be. Scanning back further than the immediate src allows
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	770 # transitive transplants and rebases to yield the same results as transitive
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	771 # grafts.
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	772 for r in subset:
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	773 src = _getrevsource(repo, r)
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	774 lineage = None
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	775
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	776 while src is not None:
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	777 if lineage is None:
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	778 lineage = list()
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	779
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	780 lineage.append(r)
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	781
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	782 # The visited lineage is a match if the current source is in the arg
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	783 # set. Since every candidate dest is visited by way of iterating
17494 74801685aaa2 spelling: further timeless@mozdev.org parents: 17291 diff changeset	784 # subset, any dests further back in the lineage will be tested by a
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	785 # different iteration over subset. Likewise, if the src was already
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	786 # selected, the current lineage can be selected without going back
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	787 # further.
22944 5aae3dea8044 revset: better naming of variables containing the value of a single argument Mads Kiilerich <madski@unity3d.com> parents: 22891 diff changeset	788 if src in sources or src in dests:
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	789 dests.update(lineage)
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	790 break
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	791
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	792 r = src
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	793 src = _getrevsource(repo, r)
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	794
21217 2195ac506c6a revset: directly use __contains__ instead of a lambda Pierre-Yves David <pierre-yves.david@fb.com> parents: 21215 diff changeset	795 return subset.filter(dests.__contains__)
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	796
18071 bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	797 def divergent(repo, subset, x):
bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	798 """``divergent()``
bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	799 Final successors of changesets with an alternative set of final successors.
bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	800 """
bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	801 # i18n: "divergent" is a keyword
bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	802 getargs(x, 0, 0, _("divergent takes no arguments"))
bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	803 divergent = obsmod.getrevs(repo, 'divergent')
22533 5b65429721d5 revset: use `subset &` in `divergent` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22532 diff changeset	804 return subset & divergent
18071 bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	805
17173 c621f84dbb35 obsolete: compute extinct changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17171 diff changeset	806 def extinct(repo, subset, x):
c621f84dbb35 obsolete: compute extinct changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17171 diff changeset	807 """``extinct()``
17291 2d6bbf87f7b4 revset: minor doc fixes on obsolete related revsets Patrick Mezard <patrick@mezard.eu> parents: 17272 diff changeset	808 Obsolete changesets with obsolete descendants only.
2d6bbf87f7b4 revset: minor doc fixes on obsolete related revsets Patrick Mezard <patrick@mezard.eu> parents: 17272 diff changeset	809 """
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	810 # i18n: "extinct" is a keyword
17258 5822345e9e46 revset: use appropriate predicate name in error messages FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17244 diff changeset	811 getargs(x, 0, 0, _("extinct takes no arguments"))
17825 3cc06457f15e obsolete: rename `getobscache` into `getrevs` Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17804 diff changeset	812 extincts = obsmod.getrevs(repo, 'extinct')
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	813 return subset & extincts
17173 c621f84dbb35 obsolete: compute extinct changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17171 diff changeset	814
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	815 def extra(repo, subset, x):
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	816 """``extra(label, [value])``
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	817 Changesets with the given label in the extra metadata, with the given
16824 f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	818 optional value.
f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	819
f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	820 If `value` starts with `re:`, the remainder of the value is treated as
f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	821 a regular expression. To match a value that actually starts with `re:`,
f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	822 use the prefix `literal:`.
f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	823 """
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	824
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	825 # i18n: "extra" is a keyword
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	826 l = getargs(x, 1, 2, _('extra takes at least 1 and at most 2 arguments'))
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	827 # i18n: "extra" is a keyword
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	828 label = getstring(l[0], _('first argument to extra must be a string'))
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	829 value = None
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	830
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	831 if len(l) > 1:
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	832 # i18n: "extra" is a keyword
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	833 value = getstring(l[1], _('second argument to extra must be a string'))
16824 f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	834 kind, value, matcher = _stringmatcher(value)
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	835
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	836 def _matchvalue(r):
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	837 extra = repo[r].extra()
16824 f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	838 return label in extra and (value is None or matcher(extra[label]))
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	839
20611 6490f8385391 revset: changed revset code to use filter method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20610 diff changeset	840 return subset.filter(lambda r: _matchvalue(r))
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	841
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	842 def filelog(repo, subset, x):
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	843 """``filelog(pattern)``
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	844 Changesets connected to the specified filelog.
17244 483aa765f6c4 revset: add explanation about difference between 'filelog()' and 'file()' FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17186 diff changeset	845
21199 e9c2f76be74b help: clarify distinction among `contains`/`file`/`filelog` Greg Hurrell <glh@fb.com> parents: 21173 diff changeset	846 For performance reasons, visits only revisions mentioned in the file-level
e9c2f76be74b help: clarify distinction among `contains`/`file`/`filelog` Greg Hurrell <glh@fb.com> parents: 21173 diff changeset	847 filelog, rather than filtering through all changesets (much faster, but
e9c2f76be74b help: clarify distinction among `contains`/`file`/`filelog` Greg Hurrell <glh@fb.com> parents: 21173 diff changeset	848 doesn't include deletes or duplicate changes). For a slower, more accurate
e9c2f76be74b help: clarify distinction among `contains`/`file`/`filelog` Greg Hurrell <glh@fb.com> parents: 21173 diff changeset	849 result, use ``file()``.
20289 96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	850
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	851 The pattern without explicit kind like ``glob:`` is expected to be
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	852 relative to the current directory and match against a file exactly
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	853 for efficiency.
23719 34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	854
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	855 If some linkrev points to revisions filtered by the current repoview, we'll
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	856 work around it to return a non-filtered value.
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	857 """
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	858
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	859 # i18n: "filelog" is a keyword
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	860 pat = getstring(x, _("filelog requires a pattern"))
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	861 s = set()
23719 34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	862 cl = repo.changelog
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	863
15964 6e37b8282aa2 revsets: provide contexts for filesets Matt Mackall <mpm@selenic.com> parents: 15949 diff changeset	864 if not matchmod.patkind(pat):
20288 b61ad01c4e73 revset: use "canonpath()" for "filelog()" pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20287 diff changeset	865 f = pathutil.canonpath(repo.root, repo.getcwd(), pat)
23719 34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	866 files = [f]
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	867 else:
20288 b61ad01c4e73 revset: use "canonpath()" for "filelog()" pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20287 diff changeset	868 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=repo[None])
23719 34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	869 files = (f for f in repo[None] if m(f))
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	870
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	871 for f in files:
23822 02f4560b69b7 filelog: fix backwards comment for 'backrevref' Martin von Zweigbergk <martinvonz@google.com> parents: 23821 diff changeset	872 backrevref = {} # final value for: filerev -> changerev
23719 34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	873 lowestchild = {} # lowest known filerev child of a filerev
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	874 delayed = [] # filerev with filtered linkrev, for post-processing
23720 8ec03e0ef51a linkrev-filelog: handle filtered linkrev with no visible children (issue4307) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23719 diff changeset	875 lowesthead = None # cache for manifest content of all head revisions
23719 34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	876 fl = repo.file(f)
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	877 for fr in list(fl):
23820 60178888be05 filelog: remove unused variable 'lkr' Martin von Zweigbergk <martinvonz@google.com> parents: 23787 diff changeset	878 rev = fl.linkrev(fr)
23719 34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	879 if rev not in cl:
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	880 # changerev pointed in linkrev is filtered
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	881 # record it for post processing.
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	882 delayed.append((fr, rev))
23821 7a7f437ab63d filelog: remove trailing "form feed" character Martin von Zweigbergk <martinvonz@google.com> parents: 23820 diff changeset	883 continue
23719 34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	884 for p in fl.parentrevs(fr):
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	885 if 0 <= p and p not in lowestchild:
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	886 lowestchild[p] = fr
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	887 backrevref[fr] = rev
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	888 s.add(rev)
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	889
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	890 # Post-processing of all filerevs we skipped because they were
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	891 # filtered. If such filerevs have known and unfiltered children, this
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	892 # means they have an unfiltered appearance out there. We'll use linkrev
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	893 # adjustment to find one of these appearances. The lowest known child
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	894 # will be used as a starting point because it is the best upper-bound we
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	895 # have.
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	896 #
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	897 # This approach will fail when an unfiltered but linkrev-shadowed
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	898 # appearance exists in a head changeset without unfiltered filerev
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	899 # children anywhere.
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	900 while delayed:
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	901 # must be a descending iteration. To slowly fill lowest child
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	902 # information that is of potential use by the next item.
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	903 fr, rev = delayed.pop()
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	904 lkr = rev
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	905
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	906 child = lowestchild.get(fr)
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	907
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	908 if child is None:
23720 8ec03e0ef51a linkrev-filelog: handle filtered linkrev with no visible children (issue4307) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23719 diff changeset	909 # search for existence of this file revision in a head revision.
8ec03e0ef51a linkrev-filelog: handle filtered linkrev with no visible children (issue4307) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23719 diff changeset	910 # There are three possibilities:
8ec03e0ef51a linkrev-filelog: handle filtered linkrev with no visible children (issue4307) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23719 diff changeset	911 # - the revision exists in a head and we can find an
8ec03e0ef51a linkrev-filelog: handle filtered linkrev with no visible children (issue4307) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23719 diff changeset	912 # introduction from there,
8ec03e0ef51a linkrev-filelog: handle filtered linkrev with no visible children (issue4307) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23719 diff changeset	913 # - the revision does not exist in a head because it has been
8ec03e0ef51a linkrev-filelog: handle filtered linkrev with no visible children (issue4307) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23719 diff changeset	914 # changed since its introduction: we would have found a child
8ec03e0ef51a linkrev-filelog: handle filtered linkrev with no visible children (issue4307) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23719 diff changeset	915 # and be in the other 'else' clause,
8ec03e0ef51a linkrev-filelog: handle filtered linkrev with no visible children (issue4307) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23719 diff changeset	916 # - all versions of the revision are hidden.
8ec03e0ef51a linkrev-filelog: handle filtered linkrev with no visible children (issue4307) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23719 diff changeset	917 if lowesthead is None:
8ec03e0ef51a linkrev-filelog: handle filtered linkrev with no visible children (issue4307) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23719 diff changeset	918 lowesthead = {}
8ec03e0ef51a linkrev-filelog: handle filtered linkrev with no visible children (issue4307) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23719 diff changeset	919 for h in repo.heads():
23729 07a6faf939dc revset-filelog: handle hidden linkrev for file missing for head (issue4490) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23726 diff changeset	920 fnode = repo[h].manifest().get(f)
07a6faf939dc revset-filelog: handle hidden linkrev for file missing for head (issue4490) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23726 diff changeset	921 if fnode is not None:
07a6faf939dc revset-filelog: handle hidden linkrev for file missing for head (issue4490) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23726 diff changeset	922 lowesthead[fl.rev(fnode)] = h
23720 8ec03e0ef51a linkrev-filelog: handle filtered linkrev with no visible children (issue4307) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23719 diff changeset	923 headrev = lowesthead.get(fr)
8ec03e0ef51a linkrev-filelog: handle filtered linkrev with no visible children (issue4307) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23719 diff changeset	924 if headrev is None:
8ec03e0ef51a linkrev-filelog: handle filtered linkrev with no visible children (issue4307) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23719 diff changeset	925 # content is nowhere unfiltered
8ec03e0ef51a linkrev-filelog: handle filtered linkrev with no visible children (issue4307) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23719 diff changeset	926 continue
8ec03e0ef51a linkrev-filelog: handle filtered linkrev with no visible children (issue4307) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23719 diff changeset	927 rev = repo[headrev][f].introrev()
23719 34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	928 else:
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	929 # the lowest known child is a good upper bound
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	930 childcrev = backrevref[child]
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	931 # XXX this does not guarantee returning the lowest
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	932 # introduction of this revision, but this gives a
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	933 # result which is a good start and will fit in most
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	934 # cases. We probably need to fix the multiple
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	935 # introductions case properly (report each
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	936 # introduction, even for identical file revisions)
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	937 # once and for all at some point anyway.
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	938 for p in repo[childcrev][f].parents():
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	939 if p.filerev() == fr:
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	940 rev = p.rev()
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	941 break
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	942 if rev == lkr: # no shadowed entry found
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	943 # XXX This should never happen unless some manifest points
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	944 # to biggish file revisions (like a revision that uses a
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	945 # parent that never appears in the manifest ancestors)
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	946 continue
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	947
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	948 # Fill the data for the next iteration.
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	949 for p in fl.parentrevs(fr):
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	950 if 0 <= p and p not in lowestchild:
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	951 lowestchild[p] = fr
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	952 backrevref[fr] = rev
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	953 s.add(rev)
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	954
22534 6261b9c549a2 revset: use `subset &` in `filelog` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22533 diff changeset	955 return subset & s
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	956
15117 0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	957 def first(repo, subset, x):
0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	958 """``first(set, [n])``
0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	959 An alias for limit().
0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	960 """
0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	961 return limit(repo, subset, x)
0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	962
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	963 def _follow(repo, subset, x, name, followfirst=False):
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	964 l = getargs(x, 0, 1, _("%s takes no arguments or a filename") % name)
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	965 c = repo['.']
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	966 if l:
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	967 x = getstring(l[0], _("%s expected a filename") % name)
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	968 if x in c:
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	969 cx = c[x]
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	970 s = set(ctx.rev() for ctx in cx.ancestors(followfirst=followfirst))
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	971 # include the revision responsible for the most recent version
23704 c624fb2c4239 linkrev: also adjust linkrev when bootstrapping 'follow' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23467 diff changeset	972 s.add(cx.introrev())
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	973 else:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	974 return baseset()
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	975 else:
20690 13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	976 s = _revancestors(repo, baseset([c.rev()]), followfirst)
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	977
22535 44f471102f3a revset: use `subset &` in `follow` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22534 diff changeset	978 return subset & s
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	979
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	980 def follow(repo, subset, x):
14343 9ed227f79e47 revset: add follow(filename) to follow a filename's history across copies Matt Mackall <mpm@selenic.com> parents: 14342 diff changeset	981 """``follow([file])``
24366 e8ea31131705 revset: replace "working copy" with "working directory" in function help Yuya Nishihara <yuya@tcha.org> parents: 24306 diff changeset	982 An alias for ``::.`` (ancestors of the working directory's first parent).
14343 9ed227f79e47 revset: add follow(filename) to follow a filename's history across copies Matt Mackall <mpm@selenic.com> parents: 14342 diff changeset	983 If a filename is specified, the history of the given file is followed,
9ed227f79e47 revset: add follow(filename) to follow a filename's history across copies Matt Mackall <mpm@selenic.com> parents: 14342 diff changeset	984 including copies.
9ed227f79e47 revset: add follow(filename) to follow a filename's history across copies Matt Mackall <mpm@selenic.com> parents: 14342 diff changeset	985 """
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	986 return _follow(repo, subset, x, 'follow')
14343 9ed227f79e47 revset: add follow(filename) to follow a filename's history across copies Matt Mackall <mpm@selenic.com> parents: 14342 diff changeset	987
16174 0a73c4bd9f47 graphlog: implement --follow-first Patrick Mezard <patrick@mezard.eu> parents: 16161 diff changeset	988 def _followfirst(repo, subset, x):
0a73c4bd9f47 graphlog: implement --follow-first Patrick Mezard <patrick@mezard.eu> parents: 16161 diff changeset	989 # ``followfirst([file])``
0a73c4bd9f47 graphlog: implement --follow-first Patrick Mezard <patrick@mezard.eu> parents: 16161 diff changeset	990 # Like ``follow([file])`` but follows only the first parent of
0a73c4bd9f47 graphlog: implement --follow-first Patrick Mezard <patrick@mezard.eu> parents: 16161 diff changeset	991 # every revision or file revision.
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	992 return _follow(repo, subset, x, '_followfirst', followfirst=True)
14343 9ed227f79e47 revset: add follow(filename) to follow a filename's history across copies Matt Mackall <mpm@selenic.com> parents: 14342 diff changeset	993
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	994 def getall(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	995 """``all()``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	996 All changesets, the same as ``0:tip``.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	997 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	998 # i18n: "all" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	999 getargs(x, 0, 0, _("all takes no arguments"))
24202 2de9ee016425 revset: have all() filter out null revision Yuya Nishihara <yuya@tcha.org> parents: 24201 diff changeset	1000 return subset & spanset(repo) # drop "null" if any
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1001
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1002 def grep(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1003 """``grep(regex)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1004 Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')``
14357 cb4ff8ef466b merge with stable Martin Geisler <mg@aragost.com> parents: 14343 14356 diff changeset	1005 to ensure special escape characters are handled correctly. Unlike
cb4ff8ef466b merge with stable Martin Geisler <mg@aragost.com> parents: 14343 14356 diff changeset	1006 ``keyword(string)``, the match is case-sensitive.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1007 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1008 try:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1009 # i18n: "grep" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1010 gr = re.compile(getstring(x, _("grep requires a string")))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1011 except re.error, e:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1012 raise error.ParseError(_('invalid match pattern: %s') % e)
20453 6aa7dcae6bd8 revset: added lazyset implementation to grep revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20452 diff changeset	1013
6aa7dcae6bd8 revset: added lazyset implementation to grep revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20452 diff changeset	1014 def matches(x):
6aa7dcae6bd8 revset: added lazyset implementation to grep revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20452 diff changeset	1015 c = repo[x]
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1016 for e in c.files() + [c.user(), c.description()]:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1017 if gr.search(e):
20453 6aa7dcae6bd8 revset: added lazyset implementation to grep revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20452 diff changeset	1018 return True
6aa7dcae6bd8 revset: added lazyset implementation to grep revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20452 diff changeset	1019 return False
6aa7dcae6bd8 revset: added lazyset implementation to grep revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20452 diff changeset	1020
20611 6490f8385391 revset: changed revset code to use filter method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20610 diff changeset	1021 return subset.filter(matches)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1022
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1023 def _matchfiles(repo, subset, x):
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1024 # _matchfiles takes a revset list of prefixed arguments:
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1025 #
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1026 # [p:foo, i:bar, x:baz]
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1027 #
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1028 # builds a match object from them and filters subset. Allowed
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1029 # prefixes are 'p:' for regular patterns, 'i:' for include
16181 1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	1030 # patterns and 'x:' for exclude patterns. Use 'r:' prefix to pass
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	1031 # a revision identifier, or the empty string to reference the
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	1032 # working directory, from which the match object is
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	1033 # initialized. Use 'd:' to set the default matching mode, default
4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	1034 # to 'glob'. At most one 'r:' and 'd:' argument can be passed.
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1035
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1036 # i18n: "_matchfiles" is a keyword
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1037 l = getargs(x, 1, -1, _("_matchfiles requires at least one argument"))
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1038 pats, inc, exc = [], [], []
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	1039 rev, default = None, None
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1040 for arg in l:
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1041 # i18n: "_matchfiles" is a keyword
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1042 s = getstring(arg, _("_matchfiles requires string arguments"))
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1043 prefix, value = s[:2], s[2:]
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1044 if prefix == 'p:':
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1045 pats.append(value)
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1046 elif prefix == 'i:':
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1047 inc.append(value)
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1048 elif prefix == 'x:':
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1049 exc.append(value)
16181 1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	1050 elif prefix == 'r:':
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	1051 if rev is not None:
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1052 # i18n: "_matchfiles" is a keyword
16181 1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	1053 raise error.ParseError(_('_matchfiles expected at most one '
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	1054 'revision'))
23950 caff3675cba5 log: evaluate filesets on working copy, not its parent Martin von Zweigbergk <martinvonz@google.com> parents: 23847 diff changeset	1055 if value != '': # empty means working directory; leave rev as None
caff3675cba5 log: evaluate filesets on working copy, not its parent Martin von Zweigbergk <martinvonz@google.com> parents: 23847 diff changeset	1056 rev = value
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	1057 elif prefix == 'd:':
4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	1058 if default is not None:
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1059 # i18n: "_matchfiles" is a keyword
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	1060 raise error.ParseError(_('_matchfiles expected at most one '
4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	1061 'default mode'))
4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	1062 default = value
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1063 else:
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1064 # i18n: "_matchfiles" is a keyword
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1065 raise error.ParseError(_('invalid _matchfiles prefix: %s') % prefix)
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	1066 if not default:
4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	1067 default = 'glob'
20458 8dabcc889e33 revset: added lazyset implementation to _matchfiles Lucas Moscovicz <lmoscovicz@fb.com> parents: 20457 diff changeset	1068
23061 f2aeff8a87b6 revset: avoid recalculating filesets Matt Mackall <mpm@selenic.com> parents: 23019 diff changeset	1069 m = matchmod.match(repo.root, repo.getcwd(), pats, include=inc,
f2aeff8a87b6 revset: avoid recalculating filesets Matt Mackall <mpm@selenic.com> parents: 23019 diff changeset	1070 exclude=exc, ctx=repo[rev], default=default)
f2aeff8a87b6 revset: avoid recalculating filesets Matt Mackall <mpm@selenic.com> parents: 23019 diff changeset	1071
20458 8dabcc889e33 revset: added lazyset implementation to _matchfiles Lucas Moscovicz <lmoscovicz@fb.com> parents: 20457 diff changeset	1072 def matches(x):
23061 f2aeff8a87b6 revset: avoid recalculating filesets Matt Mackall <mpm@selenic.com> parents: 23019 diff changeset	1073 for f in repo[x].files():
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1074 if m(f):
20458 8dabcc889e33 revset: added lazyset implementation to _matchfiles Lucas Moscovicz <lmoscovicz@fb.com> parents: 20457 diff changeset	1075 return True
8dabcc889e33 revset: added lazyset implementation to _matchfiles Lucas Moscovicz <lmoscovicz@fb.com> parents: 20457 diff changeset	1076 return False
8dabcc889e33 revset: added lazyset implementation to _matchfiles Lucas Moscovicz <lmoscovicz@fb.com> parents: 20457 diff changeset	1077
20611 6490f8385391 revset: changed revset code to use filter method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20610 diff changeset	1078 return subset.filter(matches)
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1079
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1080 def hasfile(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1081 """``file(pattern)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1082 Changesets affecting files matched by pattern.
17244 483aa765f6c4 revset: add explanation about difference between 'filelog()' and 'file()' FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17186 diff changeset	1083
17265 c30307eeec4b revset: polish explanation of the difference between file() and filelog() Greg Ward <greg@gerg.ca> parents: 17259 diff changeset	1084 For a faster but less accurate result, consider using ``filelog()``
c30307eeec4b revset: polish explanation of the difference between file() and filelog() Greg Ward <greg@gerg.ca> parents: 17259 diff changeset	1085 instead.
20289 96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1086
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1087 This predicate uses ``glob:`` as the default kind of pattern.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1088 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1089 # i18n: "file" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1090 pat = getstring(x, _("file requires a pattern"))
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1091 return _matchfiles(repo, subset, ('string', 'p:' + pat))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1092
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1093 def head(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1094 """``head()``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1095 Changeset is a named branch head.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1096 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1097 # i18n: "head" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1098 getargs(x, 0, 0, _("head takes no arguments"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1099 hs = set()
25620 5f87f2305ad0 revset: translate node directly with changelog in 'head' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25619 diff changeset	1100 cl = repo.changelog
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1101 for b, ls in repo.branchmap().iteritems():
25620 5f87f2305ad0 revset: translate node directly with changelog in 'head' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25619 diff changeset	1102 hs.update(cl.rev(h) for h in ls)
25553 fa2e91d00e4c revset: mark spot that feeds a set to a baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 25552 diff changeset	1103 # XXX using a set to feed the baseset is wrong. Sets are not ordered.
fa2e91d00e4c revset: mark spot that feeds a set to a baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 25552 diff changeset	1104 # This does not break because of other fullreposet misbehavior.
25552 4644e991a12a revset: mark the fact we should use '&' instead of 'filter' in 'head' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25551 diff changeset	1105 # XXX We should not be using '.filter' here, but combines subset with '&'
25548 9584bcf27637 revset: mark the place where we are combining sets in the wrong direction Pierre-Yves David <pierre-yves.david@fb.com> parents: 25547 diff changeset	1106 # XXX We should combine with subset first: 'subset & baseset(...)'. This is
9584bcf27637 revset: mark the place where we are combining sets in the wrong direction Pierre-Yves David <pierre-yves.david@fb.com> parents: 25547 diff changeset	1107 # necessary to ensure we preserve the order in subset.
20713 6a1a4c212d50 revset: improve head revset performance Durham Goode <durham@fb.com> parents: 20712 diff changeset	1108 return baseset(hs).filter(subset.__contains__)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1109
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1110 def heads(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1111 """``heads(set)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1112 Members of set with no children in set.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1113 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1114 s = getset(repo, subset, x)
20366 5ec6321f49a9 revset: added substraction to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20365 diff changeset	1115 ps = parents(repo, subset, x)
5ec6321f49a9 revset: added substraction to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20365 diff changeset	1116 return s - ps
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1117
17390 74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	1118 def hidden(repo, subset, x):
74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	1119 """``hidden()``
74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	1120 Hidden changesets.
74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	1121 """
74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	1122 # i18n: "hidden" is a keyword
74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	1123 getargs(x, 0, 0, _("hidden takes no arguments"))
18382 f3b21beb9802 filtering: rename filters to their antonyms Kevin Bullock <kbullock@ringworld.org> parents: 18251 diff changeset	1124 hiddenrevs = repoview.filterrevs(repo, 'visible')
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	1125 return subset & hiddenrevs
17390 74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	1126
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1127 def keyword(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1128 """``keyword(string)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1129 Search commit message, user name, and names of changed files for
14357 cb4ff8ef466b merge with stable Martin Geisler <mg@aragost.com> parents: 14343 14356 diff changeset	1130 string. The match is case-insensitive.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1131 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1132 # i18n: "keyword" is a keyword
15726 9b822edecb4c i18n: use "encoding.lower()" to normalize specified string for revset FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15596 diff changeset	1133 kw = encoding.lower(getstring(x, _("keyword requires a string")))
20447 abb91b74f758 revset: added lazyset implementation to keyword revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20446 diff changeset	1134
abb91b74f758 revset: added lazyset implementation to keyword revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20446 diff changeset	1135 def matches(r):
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1136 c = repo[r]
25551 c1d163ce7394 revset: gratuitous formating fix in keyword Pierre-Yves David <pierre-yves.david@fb.com> parents: 25550 diff changeset	1137 return any(kw in encoding.lower(t)
c1d163ce7394 revset: gratuitous formating fix in keyword Pierre-Yves David <pierre-yves.david@fb.com> parents: 25550 diff changeset	1138 for t in c.files() + [c.user(), c.description()])
20447 abb91b74f758 revset: added lazyset implementation to keyword revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20446 diff changeset	1139
20611 6490f8385391 revset: changed revset code to use filter method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20610 diff changeset	1140 return subset.filter(matches)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1141
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1142 def limit(repo, subset, x):
15116 d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	1143 """``limit(set, [n])``
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	1144 First n members of set, defaulting to 1.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1145 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1146 # i18n: "limit" is a keyword
15116 d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	1147 l = getargs(x, 1, 2, _("limit requires one or two arguments"))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1148 try:
15116 d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	1149 lim = 1
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	1150 if len(l) == 2:
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	1151 # i18n: "limit" is a keyword
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	1152 lim = int(getstring(l[1], _("limit requires a number")))
14851 f96c354493d7 revsets: actually catch type error on tip^p1(tip) (issue2884) Matt Mackall <mpm@selenic.com> parents: 14842 diff changeset	1153 except (TypeError, ValueError):
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1154 # i18n: "limit" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1155 raise error.ParseError(_("limit expects a number"))
22870 970d78f3f47c revset-limit: remove usage of `set()` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22869 diff changeset	1156 ss = subset
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1157 os = getset(repo, fullreposet(repo), l[0])
22804 5385314e0b14 revset-limit: remove user of baseset.append Pierre-Yves David <pierre-yves.david@fb.com> parents: 22802 diff changeset	1158 result = []
20446 d258486604f4 revset: changed limit revset implementation to work with lazy revsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20445 diff changeset	1159 it = iter(os)
d258486604f4 revset: changed limit revset implementation to work with lazy revsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20445 diff changeset	1160 for x in xrange(lim):
25144 81a395447b34 revset: use 'next()' to detect end of iteration in 'limit' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25143 diff changeset	1161 y = next(it, None)
81a395447b34 revset: use 'next()' to detect end of iteration in 'limit' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25143 diff changeset	1162 if y is None:
20446 d258486604f4 revset: changed limit revset implementation to work with lazy revsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20445 diff changeset	1163 break
25144 81a395447b34 revset: use 'next()' to detect end of iteration in 'limit' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25143 diff changeset	1164 elif y in ss:
81a395447b34 revset: use 'next()' to detect end of iteration in 'limit' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25143 diff changeset	1165 result.append(y)
22804 5385314e0b14 revset-limit: remove user of baseset.append Pierre-Yves David <pierre-yves.david@fb.com> parents: 22802 diff changeset	1166 return baseset(result)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1167
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	1168 def last(repo, subset, x):
15116 d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	1169 """``last(set, [n])``
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	1170 Last n members of set, defaulting to 1.
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	1171 """
611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	1172 # i18n: "last" is a keyword
15116 d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	1173 l = getargs(x, 1, 2, _("last requires one or two arguments"))
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	1174 try:
15116 d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	1175 lim = 1
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	1176 if len(l) == 2:
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	1177 # i18n: "last" is a keyword
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	1178 lim = int(getstring(l[1], _("last requires a number")))
14851 f96c354493d7 revsets: actually catch type error on tip^p1(tip) (issue2884) Matt Mackall <mpm@selenic.com> parents: 14842 diff changeset	1179 except (TypeError, ValueError):
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	1180 # i18n: "last" is a keyword
611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	1181 raise error.ParseError(_("last expects a number"))
22871 9b73ab9bcbfb revset-last: remove usage of `set()` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22870 diff changeset	1182 ss = subset
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1183 os = getset(repo, fullreposet(repo), l[0])
20534 4849f574aa24 revset: changed last implementation to use lazy classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20527 diff changeset	1184 os.reverse()
22805 e74245b79901 revset-last: remove user of baseset.append Pierre-Yves David <pierre-yves.david@fb.com> parents: 22804 diff changeset	1185 result = []
20534 4849f574aa24 revset: changed last implementation to use lazy classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20527 diff changeset	1186 it = iter(os)
4849f574aa24 revset: changed last implementation to use lazy classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20527 diff changeset	1187 for x in xrange(lim):
25145 3553163bb736 revset: use 'next()' to detect end of iteration in 'last' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25144 diff changeset	1188 y = next(it, None)
3553163bb736 revset: use 'next()' to detect end of iteration in 'last' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25144 diff changeset	1189 if y is None:
20534 4849f574aa24 revset: changed last implementation to use lazy classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20527 diff changeset	1190 break
25145 3553163bb736 revset: use 'next()' to detect end of iteration in 'last' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25144 diff changeset	1191 elif y in ss:
3553163bb736 revset: use 'next()' to detect end of iteration in 'last' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25144 diff changeset	1192 result.append(y)
22805 e74245b79901 revset-last: remove user of baseset.append Pierre-Yves David <pierre-yves.david@fb.com> parents: 22804 diff changeset	1193 return baseset(result)
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	1194
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1195 def maxrev(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1196 """``max(set)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1197 Changeset with highest revision number in set.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1198 """
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1199 os = getset(repo, fullreposet(repo), x)
14153 f8047a059ca0 revset: avoid over-aggresive optimizations of non-filtering functions (issue2549) Mads Kiilerich <mads@kiilerich.com> parents: 14098 diff changeset	1200 if os:
20754 f15ff553b762 revset: changed minrev and maxrev implementations to use ordered sets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20753 diff changeset	1201 m = os.max()
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1202 if m in subset:
20364 a6cf48b2880d revset: added baseset class (still empty) to improve revset performance Lucas Moscovicz <lmoscovicz@fb.com> parents: 20289 diff changeset	1203 return baseset([m])
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	1204 return baseset()
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1205
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1206 def merge(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1207 """``merge()``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1208 Changeset is a merge changeset.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1209 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1210 # i18n: "merge" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1211 getargs(x, 0, 0, _("merge takes no arguments"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1212 cl = repo.changelog
20611 6490f8385391 revset: changed revset code to use filter method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20610 diff changeset	1213 return subset.filter(lambda r: cl.parentrevs(r)[1] != -1)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1214
17753 69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1215 def branchpoint(repo, subset, x):
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1216 """``branchpoint()``
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1217 Changesets with more than one child.
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1218 """
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1219 # i18n: "branchpoint" is a keyword
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1220 getargs(x, 0, 0, _("branchpoint takes no arguments"))
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1221 cl = repo.changelog
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1222 if not subset:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	1223 return baseset()
25549 f93ff3ab8d14 revset: mark spots that should use 'smartset.min()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25548 diff changeset	1224 # XXX this should be 'parentset.min()' assuming 'parentset' is a smartset
f93ff3ab8d14 revset: mark spots that should use 'smartset.min()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25548 diff changeset	1225 # (and if it is not, it should.)
17753 69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1226 baserev = min(subset)
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1227 parentscount = [0]*(len(repo) - baserev)
17785 ac5c9c8046f7 clfilter: use changelog to iterate over the repo in branchpoint Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17753 diff changeset	1228 for r in cl.revs(start=baserev + 1):
17753 69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1229 for p in cl.parentrevs(r):
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1230 if p >= baserev:
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1231 parentscount[p - baserev] += 1
20611 6490f8385391 revset: changed revset code to use filter method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20610 diff changeset	1232 return subset.filter(lambda r: parentscount[r - baserev] > 1)
17753 69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1233
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1234 def minrev(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1235 """``min(set)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1236 Changeset with lowest revision number in set.
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1237 """
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1238 os = getset(repo, fullreposet(repo), x)
14153 f8047a059ca0 revset: avoid over-aggresive optimizations of non-filtering functions (issue2549) Mads Kiilerich <mads@kiilerich.com> parents: 14098 diff changeset	1239 if os:
20754 f15ff553b762 revset: changed minrev and maxrev implementations to use ordered sets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20753 diff changeset	1240 m = os.min()
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1241 if m in subset:
20364 a6cf48b2880d revset: added baseset class (still empty) to improve revset performance Lucas Moscovicz <lmoscovicz@fb.com> parents: 20289 diff changeset	1242 return baseset([m])
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	1243 return baseset()
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1244
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1245 def modifies(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1246 """``modifies(pattern)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1247 Changesets modifying files matched by pattern.
20289 96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1248
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1249 The pattern without explicit kind like ``glob:`` is expected to be
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1250 relative to the current directory and match against a file or a
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1251 directory.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1252 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1253 # i18n: "modifies" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1254 pat = getstring(x, _("modifies requires a pattern"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1255 return checkstatus(repo, subset, pat, 0)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1256
23836 3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1257 def named(repo, subset, x):
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1258 """``named(namespace)``
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1259 The changesets in a given namespace.
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1260
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1261 If `namespace` starts with `re:`, the remainder of the string is treated as
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1262 a regular expression. To match a namespace that actually starts with `re:`,
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1263 use the prefix `literal:`.
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1264 """
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1265 # i18n: "named" is a keyword
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1266 args = getargs(x, 1, 1, _('named requires a namespace argument'))
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1267
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1268 ns = getstring(args[0],
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1269 # i18n: "named" is a keyword
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1270 _('the argument to named must be a string'))
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1271 kind, pattern, matcher = _stringmatcher(ns)
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1272 namespaces = set()
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1273 if kind == 'literal':
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1274 if pattern not in repo.names:
23978 eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23956 diff changeset	1275 raise error.RepoLookupError(_("namespace '%s' does not exist")
eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23956 diff changeset	1276 % ns)
23836 3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1277 namespaces.add(repo.names[pattern])
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1278 else:
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1279 for name, ns in repo.names.iteritems():
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1280 if matcher(name):
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1281 namespaces.add(ns)
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1282 if not namespaces:
23978 eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23956 diff changeset	1283 raise error.RepoLookupError(_("no namespace exists"
eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23956 diff changeset	1284 " that match '%s'") % pattern)
23836 3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1285
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1286 names = set()
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1287 for ns in namespaces:
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1288 for name in ns.listnames(repo):
24151 38824c53c2f1 revset: mask specific names for named() predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24008 diff changeset	1289 if name not in ns.deprecated:
38824c53c2f1 revset: mask specific names for named() predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24008 diff changeset	1290 names.update(repo[n].rev() for n in ns.nodes(repo, name))
23836 3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1291
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1292 names -= set([node.nullrev])
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1293 return subset & names
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1294
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	1295 def node_(repo, subset, x):
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1296 """``id(string)``
12859 76066903ae08 revset: fix missing dot in docstring Wagner Bruna <wbruna@yahoo.com> parents: 12855 diff changeset	1297 Revision non-ambiguously specified by the given hex string prefix.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1298 """
12815 079a618ea89d revset: add translator comments to i18n strings Martin Geisler <mg@lazybytes.net> parents: 12786 diff changeset	1299 # i18n: "id" is a keyword
12736 7e14e67e6622 revset: use 'requires' instead of 'wants' in error message Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 12733 diff changeset	1300 l = getargs(x, 1, 1, _("id requires one argument"))
12815 079a618ea89d revset: add translator comments to i18n strings Martin Geisler <mg@lazybytes.net> parents: 12786 diff changeset	1301 # i18n: "id" is a keyword
12736 7e14e67e6622 revset: use 'requires' instead of 'wants' in error message Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 12733 diff changeset	1302 n = getstring(l[0], _("id requires a string"))
12716 c7e619e30ba3 revset: add id() and rev() to allow explicitly referring to changes by hash or rev Augie Fackler <durin42@gmail.com> parents: 12715 diff changeset	1303 if len(n) == 40:
24904 b5c227f3e461 revset: id() called with 40-byte strings should give the same results as for short strings Alexander Drozdov <al.drozdov@gmail.com> parents: 24777 diff changeset	1304 try:
b5c227f3e461 revset: id() called with 40-byte strings should give the same results as for short strings Alexander Drozdov <al.drozdov@gmail.com> parents: 24777 diff changeset	1305 rn = repo.changelog.rev(node.bin(n))
b5c227f3e461 revset: id() called with 40-byte strings should give the same results as for short strings Alexander Drozdov <al.drozdov@gmail.com> parents: 24777 diff changeset	1306 except (LookupError, TypeError):
b5c227f3e461 revset: id() called with 40-byte strings should give the same results as for short strings Alexander Drozdov <al.drozdov@gmail.com> parents: 24777 diff changeset	1307 rn = None
12716 c7e619e30ba3 revset: add id() and rev() to allow explicitly referring to changes by hash or rev Augie Fackler <durin42@gmail.com> parents: 12715 diff changeset	1308 else:
16735 47b8ec0eb7fb revset: fix traceback for bogus revisions in id(rev) Matt Harbison <matt_harbison@yahoo.com> parents: 16640 diff changeset	1309 rn = None
47b8ec0eb7fb revset: fix traceback for bogus revisions in id(rev) Matt Harbison <matt_harbison@yahoo.com> parents: 16640 diff changeset	1310 pm = repo.changelog._partialmatch(n)
47b8ec0eb7fb revset: fix traceback for bogus revisions in id(rev) Matt Harbison <matt_harbison@yahoo.com> parents: 16640 diff changeset	1311 if pm is not None:
47b8ec0eb7fb revset: fix traceback for bogus revisions in id(rev) Matt Harbison <matt_harbison@yahoo.com> parents: 16640 diff changeset	1312 rn = repo.changelog.rev(pm)
47b8ec0eb7fb revset: fix traceback for bogus revisions in id(rev) Matt Harbison <matt_harbison@yahoo.com> parents: 16640 diff changeset	1313
23005 9bfe68357c01 revset-node: speedup by a few hundred fold Pierre-Yves David <pierre-yves.david@fb.com> parents: 23004 diff changeset	1314 if rn is None:
9bfe68357c01 revset-node: speedup by a few hundred fold Pierre-Yves David <pierre-yves.david@fb.com> parents: 23004 diff changeset	1315 return baseset()
9bfe68357c01 revset-node: speedup by a few hundred fold Pierre-Yves David <pierre-yves.david@fb.com> parents: 23004 diff changeset	1316 result = baseset([rn])
9bfe68357c01 revset-node: speedup by a few hundred fold Pierre-Yves David <pierre-yves.david@fb.com> parents: 23004 diff changeset	1317 return result & subset
12716 c7e619e30ba3 revset: add id() and rev() to allow explicitly referring to changes by hash or rev Augie Fackler <durin42@gmail.com> parents: 12715 diff changeset	1318
17170 63a4a3871607 revset: add an `obsolete` symbol Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17102 diff changeset	1319 def obsolete(repo, subset, x):
63a4a3871607 revset: add an `obsolete` symbol Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17102 diff changeset	1320 """``obsolete()``
63a4a3871607 revset: add an `obsolete` symbol Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17102 diff changeset	1321 Mutable changeset with a newer version."""
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1322 # i18n: "obsolete" is a keyword
17170 63a4a3871607 revset: add an `obsolete` symbol Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17102 diff changeset	1323 getargs(x, 0, 0, _("obsolete takes no arguments"))
17825 3cc06457f15e obsolete: rename `getobscache` into `getrevs` Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17804 diff changeset	1324 obsoletes = obsmod.getrevs(repo, 'obsolete')
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	1325 return subset & obsoletes
17170 63a4a3871607 revset: add an `obsolete` symbol Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17102 diff changeset	1326
23466 d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1327 def only(repo, subset, x):
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1328 """``only(set, [set])``
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1329 Changesets that are ancestors of the first set that are not ancestors
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1330 of any other head in the repo. If a second set is specified, the result
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1331 is ancestors of the first set that are not ancestors of the second set
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1332 (i.e. ::<set1> - ::<set2>).
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1333 """
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1334 cl = repo.changelog
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1335 # i18n: "only" is a keyword
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1336 args = getargs(x, 1, 2, _('only takes one or two arguments'))
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1337 include = getset(repo, fullreposet(repo), args[0])
23466 d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1338 if len(args) == 1:
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1339 if not include:
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1340 return baseset()
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1341
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1342 descendants = set(_revdescendants(repo, include, False))
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1343 exclude = [rev for rev in cl.headrevs()
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1344 if not rev in descendants and not rev in include]
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1345 else:
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1346 exclude = getset(repo, fullreposet(repo), args[1])
23466 d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1347
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1348 results = set(cl.findmissingrevs(common=exclude, heads=include))
25554 94441df6206c revset: mark spots that use 'set' instead of 'smartset' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25553 diff changeset	1349 # XXX we should turn this into a baseset instead of a set, smartset may do
94441df6206c revset: mark spots that use 'set' instead of 'smartset' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25553 diff changeset	1350 # some optimisations from the fact this is a baseset.
23466 d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1351 return subset & results
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1352
17185 2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1353 def origin(repo, subset, x):
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1354 """``origin([set])``
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1355 Changesets that were specified as a source for the grafts, transplants or
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1356 rebases that created the given revisions. Omitting the optional set is the
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1357 same as passing all(). If a changeset created by these operations is itself
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1358 specified as a source for one of these operations, only the source changeset
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1359 for the first operation is selected.
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1360 """
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1361 if x is not None:
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1362 dests = getset(repo, fullreposet(repo), x)
17185 2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1363 else:
24201 77ef059b3317 revset: drop unnecessary calls of getall() with empty argument Yuya Nishihara <yuya@tcha.org> parents: 24163 diff changeset	1364 dests = fullreposet(repo)
17185 2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1365
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1366 def _firstsrc(rev):
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1367 src = _getrevsource(repo, rev)
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1368 if src is None:
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1369 return None
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1370
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1371 while True:
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1372 prev = _getrevsource(repo, src)
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1373
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1374 if prev is None:
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1375 return src
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1376 src = prev
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1377
22944 5aae3dea8044 revset: better naming of variables containing the value of a single argument Mads Kiilerich <madski@unity3d.com> parents: 22891 diff changeset	1378 o = set([_firstsrc(r) for r in dests])
22498 64673dc48931 revset: remove invalid value in the origin set Pierre-Yves David <pierre-yves.david@fb.com> parents: 22497 diff changeset	1379 o -= set([None])
25554 94441df6206c revset: mark spots that use 'set' instead of 'smartset' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25553 diff changeset	1380 # XXX we should turn this into a baseset instead of a set, smartset may do
94441df6206c revset: mark spots that use 'set' instead of 'smartset' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25553 diff changeset	1381 # some optimisations from the fact this is a baseset.
22536 8040a44aab1c revset: use `subset &` in `origin` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22535 diff changeset	1382 return subset & o
17185 2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1383
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1384 def outgoing(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1385 """``outgoing([path])``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1386 Changesets not found in the specified destination repository, or the
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1387 default push location.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1388 """
24722 02a5618e2fbf revset: don't import discovery at module level Gregory Szorc <gregory.szorc@gmail.com> parents: 24708 diff changeset	1389 # Avoid cycles.
02a5618e2fbf revset: don't import discovery at module level Gregory Szorc <gregory.szorc@gmail.com> parents: 24708 diff changeset	1390 import discovery
02a5618e2fbf revset: don't import discovery at module level Gregory Szorc <gregory.szorc@gmail.com> parents: 24708 diff changeset	1391 import hg
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1392 # i18n: "outgoing" is a keyword
14717 c8ee2729e89f revset and fileset: fix typos in parser error messages Mads Kiilerich <mads@kiilerich.com> parents: 14715 diff changeset	1393 l = getargs(x, 0, 1, _("outgoing takes one or no arguments"))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1394 # i18n: "outgoing" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1395 dest = l and getstring(l[0], _("outgoing requires a repository path")) or ''
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1396 dest = repo.ui.expandpath(dest or 'default-push', dest or 'default')
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1397 dest, branches = hg.parseurl(dest)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1398 revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1399 if revs:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1400 revs = [repo.lookup(rev) for rev in revs]
14556 517e1d88bf7e hg: change various repository() users to use peer() where appropriate Matt Mackall <mpm@selenic.com> parents: 14509 diff changeset	1401 other = hg.peer(repo, {}, dest)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1402 repo.ui.pushbuffer()
15837 cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15819 diff changeset	1403 outgoing = discovery.findcommonoutgoing(repo, other, onlyheads=revs)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1404 repo.ui.popbuffer()
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1405 cl = repo.changelog
15837 cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15819 diff changeset	1406 o = set([cl.rev(r) for r in outgoing.missing])
22529 5c53d7888aef revset: use `subset &` in `outgoing` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22528 diff changeset	1407 return subset & o
12716 c7e619e30ba3 revset: add id() and rev() to allow explicitly referring to changes by hash or rev Augie Fackler <durin42@gmail.com> parents: 12715 diff changeset	1408
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1409 def p1(repo, subset, x):
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1410 """``p1([set])``
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1411 First parent of changesets in set, or the working directory.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1412 """
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1413 if x is None:
13878 a8d13ee0ce68 misc: replace .parents()[0] with p1() Matt Mackall <mpm@selenic.com> parents: 13873 diff changeset	1414 p = repo[x].p1().rev()
22538 a428db9ab61d revset: use `subset &` in bare `p1()` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22537 diff changeset	1415 if p >= 0:
a428db9ab61d revset: use `subset &` in bare `p1()` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22537 diff changeset	1416 return subset & baseset([p])
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	1417 return baseset()
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1418
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1419 ps = set()
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1420 cl = repo.changelog
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1421 for r in getset(repo, fullreposet(repo), x):
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1422 ps.add(cl.parentrevs(r)[0])
22495 668b26d32bf6 revset: remove nullrev from set computed in p1() and p2() Pierre-Yves David <pierre-yves.david@fb.com> parents: 22494 diff changeset	1423 ps -= set([node.nullrev])
25554 94441df6206c revset: mark spots that use 'set' instead of 'smartset' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25553 diff changeset	1424 # XXX we should turn this into a baseset instead of a set, smartset may do
94441df6206c revset: mark spots that use 'set' instead of 'smartset' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25553 diff changeset	1425 # some optimisations from the fact this is a baseset.
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	1426 return subset & ps
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1427
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1428 def p2(repo, subset, x):
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1429 """``p2([set])``
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1430 Second parent of changesets in set, or the working directory.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1431 """
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1432 if x is None:
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1433 ps = repo[x].parents()
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1434 try:
12935 98b79c892768 revset: fix p1, p2 and parents in dirstate case (a5f7f1e9340e) Patrick Mezard <pmezard@gmail.com> parents: 12929 diff changeset	1435 p = ps[1].rev()
22539 6f434ef54222 revset: use `subset &` in bare `p2()` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22538 diff changeset	1436 if p >= 0:
6f434ef54222 revset: use `subset &` in bare `p2()` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22538 diff changeset	1437 return subset & baseset([p])
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	1438 return baseset()
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1439 except IndexError:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	1440 return baseset()
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1441
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1442 ps = set()
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1443 cl = repo.changelog
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1444 for r in getset(repo, fullreposet(repo), x):
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1445 ps.add(cl.parentrevs(r)[1])
22495 668b26d32bf6 revset: remove nullrev from set computed in p1() and p2() Pierre-Yves David <pierre-yves.david@fb.com> parents: 22494 diff changeset	1446 ps -= set([node.nullrev])
25554 94441df6206c revset: mark spots that use 'set' instead of 'smartset' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25553 diff changeset	1447 # XXX we should turn this into a baseset instead of a set, smartset may do
94441df6206c revset: mark spots that use 'set' instead of 'smartset' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25553 diff changeset	1448 # some optimisations from the fact this is a baseset.
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	1449 return subset & ps
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1450
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1451 def parents(repo, subset, x):
12929 515c2786e1cf revsets: let parents() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12928 diff changeset	1452 """``parents([set])``
515c2786e1cf revsets: let parents() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12928 diff changeset	1453 The set of all parents for all changesets in set, or the working directory.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1454 """
12929 515c2786e1cf revsets: let parents() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12928 diff changeset	1455 if x is None:
22496 35af9361a049 revset: refactor parents() into a single return point Pierre-Yves David <pierre-yves.david@fb.com> parents: 22495 diff changeset	1456 ps = set(p.rev() for p in repo[x].parents())
35af9361a049 revset: refactor parents() into a single return point Pierre-Yves David <pierre-yves.david@fb.com> parents: 22495 diff changeset	1457 else:
35af9361a049 revset: refactor parents() into a single return point Pierre-Yves David <pierre-yves.david@fb.com> parents: 22495 diff changeset	1458 ps = set()
35af9361a049 revset: refactor parents() into a single return point Pierre-Yves David <pierre-yves.david@fb.com> parents: 22495 diff changeset	1459 cl = repo.changelog
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1460 for r in getset(repo, fullreposet(repo), x):
22496 35af9361a049 revset: refactor parents() into a single return point Pierre-Yves David <pierre-yves.david@fb.com> parents: 22495 diff changeset	1461 ps.update(cl.parentrevs(r))
22497 8ea3f47bcaff revset: remove nullrev from set computed in parents() Pierre-Yves David <pierre-yves.david@fb.com> parents: 22496 diff changeset	1462 ps -= set([node.nullrev])
22712 093df3b77f27 revert: bring back usage of `subset & ps` in `parents` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22692 diff changeset	1463 return subset & ps
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1464
25621 21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1465 def _phase(repo, subset, target):
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1466 """helper to select all rev in phase <target>"""
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1467 phase = repo._phasecache.phase
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1468 condition = lambda r: phase(repo, r) == target
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1469 return subset.filter(condition, cache=False)
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1470
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1471 def draft(repo, subset, x):
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1472 """``draft()``
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1473 Changeset in draft phase."""
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1474 # i18n: "draft" is a keyword
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1475 getargs(x, 0, 0, _("draft takes no arguments"))
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1476 target = phases.draft
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1477 return _phase(repo, subset, target)
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1478
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1479 def secret(repo, subset, x):
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1480 """``secret()``
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1481 Changeset in secret phase."""
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1482 # i18n: "secret" is a keyword
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1483 getargs(x, 0, 0, _("secret takes no arguments"))
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1484 target = phases.secret
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1485 return _phase(repo, subset, target)
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1486
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1487 def parentspec(repo, subset, x, n):
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1488 """``set^0``
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1489 The set.
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1490 ``set^1`` (or ``set^``), ``set^2``
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1491 First or second parent, respectively, of all changesets in set.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1492 """
12320 40c40c6f20b8 revset: handle re.compile() errors in grep() Brodie Rao <brodie@bitheap.org> parents: 11882 diff changeset	1493 try:
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1494 n = int(n[1])
14072 2e4d79dcc0a0 revset: add missing whitespace Kevin Gessner <kevin@kevingessner.com> parents: 14070 diff changeset	1495 if n not in (0, 1, 2):
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1496 raise ValueError
14851 f96c354493d7 revsets: actually catch type error on tip^p1(tip) (issue2884) Matt Mackall <mpm@selenic.com> parents: 14842 diff changeset	1497 except (TypeError, ValueError):
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1498 raise error.ParseError(_("^ expects a number 0, 1, or 2"))
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1499 ps = set()
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1500 cl = repo.changelog
23165 7e8737e6ab08 revset-parentspec: call 'getset' on a 'fullreposet' Pierre-Yves David <pierre-yves.david@fb.com> parents: 23164 diff changeset	1501 for r in getset(repo, fullreposet(repo), x):
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1502 if n == 0:
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1503 ps.add(r)
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1504 elif n == 1:
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1505 ps.add(cl.parentrevs(r)[0])
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1506 elif n == 2:
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1507 parents = cl.parentrevs(r)
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1508 if len(parents) > 1:
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1509 ps.add(parents[1])
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	1510 return subset & ps
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1511
11944 df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1512 def present(repo, subset, x):
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1513 """``present(set)``
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1514 An empty set, if any revision in set isn't found; otherwise,
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1515 all revisions in set.
16748 0a730d3c5aae doc: add detail explanation for 'present()' predicate of revsets FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16735 diff changeset	1516
0a730d3c5aae doc: add detail explanation for 'present()' predicate of revsets FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16735 diff changeset	1517 If any of specified revisions is not present in the local repository,
0a730d3c5aae doc: add detail explanation for 'present()' predicate of revsets FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16735 diff changeset	1518 the query is normally aborted. But this predicate allows the query
0a730d3c5aae doc: add detail explanation for 'present()' predicate of revsets FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16735 diff changeset	1519 to continue even in such cases.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1520 """
11944 df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1521 try:
df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1522 return getset(repo, subset, x)
df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1523 except error.RepoLookupError:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	1524 return baseset()
11944 df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1525
25224 d032f57936f5 revset: drop docstring from internal _notpublic() function Yuya Nishihara <yuya@tcha.org> parents: 25191 diff changeset	1526 # for internal use
25191 08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1527 def _notpublic(repo, subset, x):
25225 57fae767c52b revset: drop translation marker from error message of _notpublic() Yuya Nishihara <yuya@tcha.org> parents: 25224 diff changeset	1528 getargs(x, 0, 0, "_notpublic takes no arguments")
25612 97528adbf74b revset: ensure we have loaded phases data in '_notpublic()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25567 diff changeset	1529 repo._phasecache.loadphaserevs(repo) # ensure phase's sets are loaded
25191 08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1530 if repo._phasecache._phasesets:
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1531 s = set()
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1532 for u in repo._phasecache._phasesets[1:]:
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1533 s.update(u)
25619 833fa28cd949 revset: use a baseset in _notpublic() Pierre-Yves David <pierre-yves.david@fb.com> parents: 25612 diff changeset	1534 s = baseset(s - repo.changelog.filteredrevs)
833fa28cd949 revset: use a baseset in _notpublic() Pierre-Yves David <pierre-yves.david@fb.com> parents: 25612 diff changeset	1535 s.sort()
25191 08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1536 return subset & s
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1537 else:
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1538 phase = repo._phasecache.phase
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1539 target = phases.public
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1540 condition = lambda r: phase(repo, r) != target
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1541 return subset.filter(condition, cache=False)
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1542
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1543 def public(repo, subset, x):
33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1544 """``public()``
33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1545 Changeset in public phase."""
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1546 # i18n: "public" is a keyword
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1547 getargs(x, 0, 0, _("public takes no arguments"))
23019 c8f32accd00a revset-phases: prefetch attributes in phasesrelated revsets Pierre-Yves David <pierre-yves.david@fb.com> parents: 23018 diff changeset	1548 phase = repo._phasecache.phase
c8f32accd00a revset-phases: prefetch attributes in phasesrelated revsets Pierre-Yves David <pierre-yves.david@fb.com> parents: 23018 diff changeset	1549 target = phases.public
c8f32accd00a revset-phases: prefetch attributes in phasesrelated revsets Pierre-Yves David <pierre-yves.david@fb.com> parents: 23018 diff changeset	1550 condition = lambda r: phase(repo, r) == target
23018 73d9d5548dfe revset-phases: do not cache phase-related filters Pierre-Yves David <pierre-yves.david@fb.com> parents: 23005 diff changeset	1551 return subset.filter(condition, cache=False)
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1552
15936 878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1553 def remote(repo, subset, x):
16007 f06c53ca59a9 revset: fix documentation for 'remote()' predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16006 diff changeset	1554 """``remote([id [,path]])``
15936 878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1555 Local revision that corresponds to the given identifier in a
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1556 remote repository, if present. Here, the '.' identifier is a
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1557 synonym for the current local branch.
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1558 """
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1559
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1560 import hg # avoid start-up nasties
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1561 # i18n: "remote" is a keyword
16007 f06c53ca59a9 revset: fix documentation for 'remote()' predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16006 diff changeset	1562 l = getargs(x, 0, 2, _("remote takes one, two or no arguments"))
15936 878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1563
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1564 q = '.'
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1565 if len(l) > 0:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1566 # i18n: "remote" is a keyword
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1567 q = getstring(l[0], _("remote requires a string id"))
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1568 if q == '.':
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1569 q = repo['.'].branch()
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1570
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1571 dest = ''
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1572 if len(l) > 1:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1573 # i18n: "remote" is a keyword
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1574 dest = getstring(l[1], _("remote requires a repository path"))
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1575 dest = repo.ui.expandpath(dest or 'default')
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1576 dest, branches = hg.parseurl(dest)
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1577 revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1578 if revs:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1579 revs = [repo.lookup(rev) for rev in revs]
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1580 other = hg.peer(repo, {}, dest)
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1581 n = other.lookup(q)
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1582 if n in repo:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1583 r = repo[n].rev()
16006 39e60576ac98 revset: fix 'remote()' failure when remote repo has more revs than local FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15966 diff changeset	1584 if r in subset:
20364 a6cf48b2880d revset: added baseset class (still empty) to improve revset performance Lucas Moscovicz <lmoscovicz@fb.com> parents: 20289 diff changeset	1585 return baseset([r])
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	1586 return baseset()
15936 878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1587
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1588 def removes(repo, subset, x):
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1589 """``removes(pattern)``
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1590 Changesets which remove files matching pattern.
20289 96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1591
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1592 The pattern without explicit kind like ``glob:`` is expected to be
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1593 relative to the current directory and match against a file or a
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1594 directory.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1595 """
12815 079a618ea89d revset: add translator comments to i18n strings Martin Geisler <mg@lazybytes.net> parents: 12786 diff changeset	1596 # i18n: "removes" is a keyword
12736 7e14e67e6622 revset: use 'requires' instead of 'wants' in error message Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 12733 diff changeset	1597 pat = getstring(x, _("removes requires a pattern"))
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1598 return checkstatus(repo, subset, pat, 2)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1599
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1600 def rev(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1601 """``rev(number)``
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1602 Revision with the given numeric identifier.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1603 """
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1604 # i18n: "rev" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1605 l = getargs(x, 1, 1, _("rev requires one argument"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1606 try:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1607 # i18n: "rev" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1608 l = int(getstring(l[0], _("rev requires a number")))
14851 f96c354493d7 revsets: actually catch type error on tip^p1(tip) (issue2884) Matt Mackall <mpm@selenic.com> parents: 14842 diff changeset	1609 except (TypeError, ValueError):
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1610 # i18n: "rev" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1611 raise error.ParseError(_("rev expects a number"))
24031 fe1abb5d92f6 revset: have rev() validate input by repo.changelog.__contains__() Yuya Nishihara <yuya@tcha.org> parents: 24012 diff changeset	1612 if l not in repo.changelog and l != node.nullrev:
23062 ba89f7b542c9 revset: have rev() drop out-of-range or filtered rev explicitly (issue4396) Yuya Nishihara <yuya@tcha.org> parents: 23061 diff changeset	1613 return baseset()
22537 bbf4f3dfd700 revset: use `subset &` in `rev` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22536 diff changeset	1614 return subset & baseset([l])
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1615
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1616 def matching(repo, subset, x):
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1617 """``matching(revision [, field])``
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1618 Changesets in which a given set of fields match the set of fields in the
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1619 selected revision or set.
16528 5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1620
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1621 To match more than one field pass the list of fields to match separated
16528 5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1622 by spaces (e.g. ``author description``).
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1623
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1624 Valid fields are most regular revision fields and some special fields.
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1625
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1626 Regular revision fields are ``description``, ``author``, ``branch``,
17102 d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1627 ``date``, ``files``, ``phase``, ``parents``, ``substate``, ``user``
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1628 and ``diff``.
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1629 Note that ``author`` and ``user`` are synonyms. ``diff`` refers to the
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1630 contents of the revision. Two revisions matching their ``diff`` will
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1631 also match their ``files``.
16528 5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1632
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1633 Special fields are ``summary`` and ``metadata``:
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1634 ``summary`` matches the first line of the description.
16639 00290bd359fe revset: documentation typo "metatadata" Jesse Glick <jesse.glick@oracle.com> parents: 16528 diff changeset	1635 ``metadata`` is equivalent to matching ``description user date``
16528 5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1636 (i.e. it matches the main metadata fields).
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1637
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1638 ``metadata`` is the default field which is used when no fields are
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1639 specified. You can match more than one field at a time.
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1640 """
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1641 # i18n: "matching" is a keyword
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1642 l = getargs(x, 1, 2, _("matching takes 1 or 2 arguments"))
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1643
23166 30e0dcd7c5ff revset-matching: call 'getset' on a 'fullreposet' Pierre-Yves David <pierre-yves.david@fb.com> parents: 23165 diff changeset	1644 revs = getset(repo, fullreposet(repo), l[0])
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1645
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1646 fieldlist = ['metadata']
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1647 if len(l) > 1:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1648 fieldlist = getstring(l[1],
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1649 # i18n: "matching" is a keyword
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1650 _("matching requires a string "
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1651 "as its second argument")).split()
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1652
17102 d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1653 # Make sure that there are no repeated fields,
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1654 # expand the 'special' 'metadata' field type
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1655 # and check the 'files' whenever we check the 'diff'
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1656 fields = []
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1657 for field in fieldlist:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1658 if field == 'metadata':
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1659 fields += ['user', 'description', 'date']
17102 d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1660 elif field == 'diff':
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1661 # a revision matching the diff must also match the files
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1662 # since matching the diff is very costly, make sure to
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1663 # also match the files first
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1664 fields += ['files', 'diff']
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1665 else:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1666 if field == 'author':
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1667 field = 'user'
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1668 fields.append(field)
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1669 fields = set(fields)
16444 432f198600c6 revset: make matching keyword not match summary when matching for description Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16417 diff changeset	1670 if 'summary' in fields and 'description' in fields:
432f198600c6 revset: make matching keyword not match summary when matching for description Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16417 diff changeset	1671 # If a revision matches its description it also matches its summary
432f198600c6 revset: make matching keyword not match summary when matching for description Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16417 diff changeset	1672 fields.discard('summary')
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1673
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1674 # We may want to match more than one field
16446 984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1675 # Not all fields take the same amount of time to be matched
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1676 # Sort the selected fields in order of increasing matching cost
16453 d2a865d4b963 revset: make matching() work on python 2.4 Patrick Mezard <patrick@mezard.eu> parents: 16452 diff changeset	1677 fieldorder = ['phase', 'parents', 'user', 'date', 'branch', 'summary',
17102 d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1678 'files', 'description', 'substate', 'diff']
16446 984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1679 def fieldkeyfunc(f):
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1680 try:
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1681 return fieldorder.index(f)
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1682 except ValueError:
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1683 # assume an unknown field is very costly
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1684 return len(fieldorder)
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1685 fields = list(fields)
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1686 fields.sort(key=fieldkeyfunc)
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1687
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1688 # Each field will be matched with its own "getfield" function
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1689 # which will be added to the getfieldfuncs array of functions
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1690 getfieldfuncs = []
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1691 _funcs = {
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1692 'user': lambda r: repo[r].user(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1693 'branch': lambda r: repo[r].branch(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1694 'date': lambda r: repo[r].date(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1695 'description': lambda r: repo[r].description(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1696 'files': lambda r: repo[r].files(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1697 'parents': lambda r: repo[r].parents(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1698 'phase': lambda r: repo[r].phase(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1699 'substate': lambda r: repo[r].substate,
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1700 'summary': lambda r: repo[r].description().splitlines()[0],
17102 d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1701 'diff': lambda r: list(repo[r].diff(git=True),)
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1702 }
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1703 for info in fields:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1704 getfield = _funcs.get(info, None)
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1705 if getfield is None:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1706 raise error.ParseError(
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1707 # i18n: "matching" is a keyword
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1708 _("unexpected field name passed to matching: %s") % info)
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1709 getfieldfuncs.append(getfield)
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1710 # convert the getfield array of functions into a "getinfo" function
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1711 # which returns an array of field values (or a single value if there
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1712 # is only one field to match)
16445 453c8670566c revset: speedup matching() by stopping the match early if a field does not match Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16444 diff changeset	1713 getinfo = lambda r: [f(r) for f in getfieldfuncs]
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1714
20459 51890507c6b3 revset: added lazyset implementation to matching revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20458 diff changeset	1715 def matches(x):
51890507c6b3 revset: added lazyset implementation to matching revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20458 diff changeset	1716 for rev in revs:
51890507c6b3 revset: added lazyset implementation to matching revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20458 diff changeset	1717 target = getinfo(rev)
16445 453c8670566c revset: speedup matching() by stopping the match early if a field does not match Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16444 diff changeset	1718 match = True
453c8670566c revset: speedup matching() by stopping the match early if a field does not match Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16444 diff changeset	1719 for n, f in enumerate(getfieldfuncs):
20459 51890507c6b3 revset: added lazyset implementation to matching revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20458 diff changeset	1720 if target[n] != f(x):
16445 453c8670566c revset: speedup matching() by stopping the match early if a field does not match Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16444 diff changeset	1721 match = False
453c8670566c revset: speedup matching() by stopping the match early if a field does not match Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16444 diff changeset	1722 if match:
20459 51890507c6b3 revset: added lazyset implementation to matching revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20458 diff changeset	1723 return True
51890507c6b3 revset: added lazyset implementation to matching revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20458 diff changeset	1724 return False
51890507c6b3 revset: added lazyset implementation to matching revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20458 diff changeset	1725
20611 6490f8385391 revset: changed revset code to use filter method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20610 diff changeset	1726 return subset.filter(matches)
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1727
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1728 def reverse(repo, subset, x):
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1729 """``reverse(set)``
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1730 Reverse order of set.
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1731 """
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1732 l = getset(repo, subset, x)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1733 l.reverse()
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1734 return l
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1735
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1736 def roots(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1737 """``roots(set)``
16394 f3df7d34791e revset: do not ignore input revisions in roots() Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1738 Changesets in set with no parent changeset in set.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1739 """
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1740 s = getset(repo, fullreposet(repo), x)
24923 e5f166961123 revset: narrow the subset using smartset operation in roots() Pierre-Yves David <pierre-yves.david@fb.com> parents: 24904 diff changeset	1741 subset = subset & s# baseset([r for r in s if r in subset])
16394 f3df7d34791e revset: do not ignore input revisions in roots() Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	1742 cs = _children(repo, subset, s)
20366 5ec6321f49a9 revset: added substraction to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20365 diff changeset	1743 return subset - cs
11944 df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1744
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1745 def sort(repo, subset, x):
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1746 """``sort(set[, [-]key...])``
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1747 Sort set by keys. The default sort order is ascending, specify a key
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1748 as ``-key`` to sort in descending order.
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1749
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1750 The keys can be:
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1751
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1752 - ``rev`` for the revision number,
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1753 - ``branch`` for the branch name,
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1754 - ``desc`` for the commit message (description),
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1755 - ``user`` for user name (``author`` can be used as an alias),
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1756 - ``date`` for the commit date
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1757 """
12815 079a618ea89d revset: add translator comments to i18n strings Martin Geisler <mg@lazybytes.net> parents: 12786 diff changeset	1758 # i18n: "sort" is a keyword
12736 7e14e67e6622 revset: use 'requires' instead of 'wants' in error message Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 12733 diff changeset	1759 l = getargs(x, 1, 2, _("sort requires one or two arguments"))
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1760 keys = "rev"
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1761 if len(l) == 2:
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1762 # i18n: "sort" is a keyword
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	1763 keys = getstring(l[1], _("sort spec must be a string"))
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1764
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1765 s = l[0]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1766 keys = keys.split()
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1767 l = []
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1768 def invert(s):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1769 return "".join(chr(255 - ord(c)) for c in s)
20719 cce8fbedc82a revset: changed sort method to use native sort implementation of smartsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20718 diff changeset	1770 revs = getset(repo, subset, s)
cce8fbedc82a revset: changed sort method to use native sort implementation of smartsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20718 diff changeset	1771 if keys == ["rev"]:
cce8fbedc82a revset: changed sort method to use native sort implementation of smartsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20718 diff changeset	1772 revs.sort()
cce8fbedc82a revset: changed sort method to use native sort implementation of smartsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20718 diff changeset	1773 return revs
cce8fbedc82a revset: changed sort method to use native sort implementation of smartsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20718 diff changeset	1774 elif keys == ["-rev"]:
cce8fbedc82a revset: changed sort method to use native sort implementation of smartsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20718 diff changeset	1775 revs.sort(reverse=True)
cce8fbedc82a revset: changed sort method to use native sort implementation of smartsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20718 diff changeset	1776 return revs
cce8fbedc82a revset: changed sort method to use native sort implementation of smartsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20718 diff changeset	1777 for r in revs:
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1778 c = repo[r]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1779 e = []
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1780 for k in keys:
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1781 if k == 'rev':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1782 e.append(r)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1783 elif k == '-rev':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1784 e.append(-r)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1785 elif k == 'branch':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1786 e.append(c.branch())
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1787 elif k == '-branch':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1788 e.append(invert(c.branch()))
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1789 elif k == 'desc':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1790 e.append(c.description())
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1791 elif k == '-desc':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1792 e.append(invert(c.description()))
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1793 elif k in 'user author':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1794 e.append(c.user())
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1795 elif k in '-user -author':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1796 e.append(invert(c.user()))
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1797 elif k == 'date':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1798 e.append(c.date()[0])
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1799 elif k == '-date':
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1800 e.append(-c.date()[0])
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1801 else:
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	1802 raise error.ParseError(_("unknown sort key %r") % k)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1803 e.append(r)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1804 l.append(e)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1805 l.sort()
20364 a6cf48b2880d revset: added baseset class (still empty) to improve revset performance Lucas Moscovicz <lmoscovicz@fb.com> parents: 20289 diff changeset	1806 return baseset([e[-1] for e in l])
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1807
24446 582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1808 def subrepo(repo, subset, x):
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1809 """``subrepo([pattern])``
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1810 Changesets that add, modify or remove the given subrepo. If no subrepo
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1811 pattern is named, any subrepo changes are returned.
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1812 """
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1813 # i18n: "subrepo" is a keyword
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1814 args = getargs(x, 0, 1, _('subrepo takes at most one argument'))
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1815 if len(args) != 0:
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1816 pat = getstring(args[0], _("subrepo requires a pattern"))
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1817
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1818 m = matchmod.exact(repo.root, repo.root, ['.hgsubstate'])
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1819
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1820 def submatches(names):
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1821 k, p, m = _stringmatcher(pat)
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1822 for name in names:
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1823 if m(name):
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1824 yield name
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1825
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1826 def matches(x):
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1827 c = repo[x]
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1828 s = repo.status(c.p1().node(), c.node(), match=m)
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1829
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1830 if len(args) == 0:
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1831 return s.added or s.modified or s.removed
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1832
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1833 if s.added:
25149 3f0744eeaeaf cleanup: use __builtins__.any instead of util.any Augie Fackler <augie@google.com> parents: 25146 diff changeset	1834 return any(submatches(c.substate.keys()))
24446 582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1835
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1836 if s.modified:
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1837 subs = set(c.p1().substate.keys())
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1838 subs.update(c.substate.keys())
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1839
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1840 for path in submatches(subs):
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1841 if c.p1().substate.get(path) != c.substate.get(path):
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1842 return True
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1843
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1844 if s.removed:
25149 3f0744eeaeaf cleanup: use __builtins__.any instead of util.any Augie Fackler <augie@google.com> parents: 25146 diff changeset	1845 return any(submatches(c.p1().substate.keys()))
24446 582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1846
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1847 return False
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1848
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1849 return subset.filter(matches)
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1850
16819 5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1851 def _stringmatcher(pattern):
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1852 """
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1853 accepts a string, possibly starting with 're:' or 'literal:' prefix.
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1854 returns the matcher name, pattern, and matcher function.
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1855 missing or unknown prefixes are treated as literal matches.
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1856
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1857 helper for tests:
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1858 >>> def test(pattern, *tests):
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1859 ... kind, pattern, matcher = _stringmatcher(pattern)
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1860 ... return (kind, pattern, [bool(matcher(t)) for t in tests])
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1861
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1862 exact matching (no prefix):
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1863 >>> test('abcdefg', 'abc', 'def', 'abcdefg')
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1864 ('literal', 'abcdefg', [False, False, True])
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1865
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1866 regex matching ('re:' prefix)
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1867 >>> test('re:a.+b', 'nomatch', 'fooadef', 'fooadefbar')
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1868 ('re', 'a.+b', [False, False, True])
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1869
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1870 force exact matches ('literal:' prefix)
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1871 >>> test('literal:re:foobar', 'foobar', 're:foobar')
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1872 ('literal', 're:foobar', [False, True])
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1873
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1874 unknown prefixes are ignored and treated as literals
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1875 >>> test('foo:bar', 'foo', 'bar', 'foo:bar')
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1876 ('literal', 'foo:bar', [False, False, True])
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1877 """
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1878 if pattern.startswith('re:'):
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1879 pattern = pattern[3:]
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1880 try:
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1881 regex = re.compile(pattern)
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1882 except re.error, e:
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1883 raise error.ParseError(_('invalid regular expression: %s')
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1884 % e)
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1885 return 're', pattern, regex.search
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1886 elif pattern.startswith('literal:'):
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1887 pattern = pattern[8:]
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1888 return 'literal', pattern, pattern.__eq__
5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1889
16823 b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	1890 def _substringmatcher(pattern):
b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	1891 kind, pattern, matcher = _stringmatcher(pattern)
b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	1892 if kind == 'literal':
b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	1893 matcher = lambda s: pattern in s
b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	1894 return kind, pattern, matcher
16819 5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	1895
12715 33820dccbea4 revset: rename tagged() to tag() and allow it to take an optional tag name Augie Fackler <durin42@gmail.com> parents: 12616 diff changeset	1896 def tag(repo, subset, x):
14356 02a5bebd0dc4 revset: the name is optional for the tag predicate Martin Geisler <mg@aragost.com> parents: 14355 diff changeset	1897 """``tag([name])``
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1898 The specified tag by name, or all tagged revisions if no name is given.
20824 c57c9cece645 revset: document the regular expression support for tag(name) Matt Harbison <matt_harbison@yahoo.com> parents: 20289 diff changeset	1899
c57c9cece645 revset: document the regular expression support for tag(name) Matt Harbison <matt_harbison@yahoo.com> parents: 20289 diff changeset	1900 If `name` starts with `re:`, the remainder of the name is treated as
c57c9cece645 revset: document the regular expression support for tag(name) Matt Harbison <matt_harbison@yahoo.com> parents: 20289 diff changeset	1901 a regular expression. To match a tag that actually starts with `re:`,
c57c9cece645 revset: document the regular expression support for tag(name) Matt Harbison <matt_harbison@yahoo.com> parents: 20289 diff changeset	1902 use the prefix `literal:`.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1903 """
12815 079a618ea89d revset: add translator comments to i18n strings Martin Geisler <mg@lazybytes.net> parents: 12786 diff changeset	1904 # i18n: "tag" is a keyword
12715 33820dccbea4 revset: rename tagged() to tag() and allow it to take an optional tag name Augie Fackler <durin42@gmail.com> parents: 12616 diff changeset	1905 args = getargs(x, 0, 1, _("tag takes one or no arguments"))
11280 a5eb0bf7e158 revset: add tagged predicate Matt Mackall <mpm@selenic.com> parents: 11279 diff changeset	1906 cl = repo.changelog
12715 33820dccbea4 revset: rename tagged() to tag() and allow it to take an optional tag name Augie Fackler <durin42@gmail.com> parents: 12616 diff changeset	1907 if args:
16820 20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1908 pattern = getstring(args[0],
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1909 # i18n: "tag" is a keyword
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1910 _('the argument to tag must be a string'))
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1911 kind, pattern, matcher = _stringmatcher(pattern)
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1912 if kind == 'literal':
16825 b6ef1395d77f revset: avoid validating all tag nodes for tag(x) Matt Mackall <mpm@selenic.com> parents: 16824 diff changeset	1913 # avoid resolving all tags
b6ef1395d77f revset: avoid validating all tag nodes for tag(x) Matt Mackall <mpm@selenic.com> parents: 16824 diff changeset	1914 tn = repo._tagscache.tags.get(pattern, None)
b6ef1395d77f revset: avoid validating all tag nodes for tag(x) Matt Mackall <mpm@selenic.com> parents: 16824 diff changeset	1915 if tn is None:
23978 eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23956 diff changeset	1916 raise error.RepoLookupError(_("tag '%s' does not exist")
eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23956 diff changeset	1917 % pattern)
16825 b6ef1395d77f revset: avoid validating all tag nodes for tag(x) Matt Mackall <mpm@selenic.com> parents: 16824 diff changeset	1918 s = set([repo[tn].rev()])
16820 20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1919 else:
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1920 s = set([cl.rev(n) for t, n in repo.tagslist() if matcher(t)])
12715 33820dccbea4 revset: rename tagged() to tag() and allow it to take an optional tag name Augie Fackler <durin42@gmail.com> parents: 12616 diff changeset	1921 else:
33820dccbea4 revset: rename tagged() to tag() and allow it to take an optional tag name Augie Fackler <durin42@gmail.com> parents: 12616 diff changeset	1922 s = set([cl.rev(n) for t, n in repo.tagslist() if t != 'tip'])
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	1923 return subset & s
11280 a5eb0bf7e158 revset: add tagged predicate Matt Mackall <mpm@selenic.com> parents: 11279 diff changeset	1924
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1925 def tagged(repo, subset, x):
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1926 return tag(repo, subset, x)
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1927
17171 9c750c3e4fac obsolete: compute unstable changeset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17170 diff changeset	1928 def unstable(repo, subset, x):
9c750c3e4fac obsolete: compute unstable changeset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17170 diff changeset	1929 """``unstable()``
17291 2d6bbf87f7b4 revset: minor doc fixes on obsolete related revsets Patrick Mezard <patrick@mezard.eu> parents: 17272 diff changeset	1930 Non-obsolete changesets with obsolete ancestors.
2d6bbf87f7b4 revset: minor doc fixes on obsolete related revsets Patrick Mezard <patrick@mezard.eu> parents: 17272 diff changeset	1931 """
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1932 # i18n: "unstable" is a keyword
17258 5822345e9e46 revset: use appropriate predicate name in error messages FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17244 diff changeset	1933 getargs(x, 0, 0, _("unstable takes no arguments"))
17825 3cc06457f15e obsolete: rename `getobscache` into `getrevs` Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17804 diff changeset	1934 unstables = obsmod.getrevs(repo, 'unstable')
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	1935 return subset & unstables
17171 9c750c3e4fac obsolete: compute unstable changeset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17170 diff changeset	1936
9c750c3e4fac obsolete: compute unstable changeset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17170 diff changeset	1937
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1938 def user(repo, subset, x):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1939 """``user(string)``
14357 cb4ff8ef466b merge with stable Martin Geisler <mg@aragost.com> parents: 14343 14356 diff changeset	1940 User name contains string. The match is case-insensitive.
16823 b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	1941
b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	1942 If `string` starts with `re:`, the remainder of the string is treated as
b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	1943 a regular expression. To match a user that actually contains `re:`, use
b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	1944 the prefix `literal:`.
13359 87f248e78173 bookmarks: move revset support to core Matt Mackall <mpm@selenic.com> parents: 13031 diff changeset	1945 """
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1946 return author(repo, subset, x)
13359 87f248e78173 bookmarks: move revset support to core Matt Mackall <mpm@selenic.com> parents: 13031 diff changeset	1947
24777 077683371b7b revset: undocument wdir() until its command outputs get stable Yuya Nishihara <yuya@tcha.org> parents: 24722 diff changeset	1948 # experimental
24419 0e41f110e69e revset: add wdir() function to specify workingctx revision by command Yuya Nishihara <yuya@tcha.org> parents: 24374 diff changeset	1949 def wdir(repo, subset, x):
0e41f110e69e revset: add wdir() function to specify workingctx revision by command Yuya Nishihara <yuya@tcha.org> parents: 24374 diff changeset	1950 # i18n: "wdir" is a keyword
0e41f110e69e revset: add wdir() function to specify workingctx revision by command Yuya Nishihara <yuya@tcha.org> parents: 24374 diff changeset	1951 getargs(x, 0, 0, _("wdir takes no arguments"))
25265 e16456831516 revset: drop magic of fullreposet membership test (issue4682) Yuya Nishihara <yuya@tcha.org> parents: 25094 diff changeset	1952 if None in subset or isinstance(subset, fullreposet):
24419 0e41f110e69e revset: add wdir() function to specify workingctx revision by command Yuya Nishihara <yuya@tcha.org> parents: 24374 diff changeset	1953 return baseset([None])
0e41f110e69e revset: add wdir() function to specify workingctx revision by command Yuya Nishihara <yuya@tcha.org> parents: 24374 diff changeset	1954 return baseset()
0e41f110e69e revset: add wdir() function to specify workingctx revision by command Yuya Nishihara <yuya@tcha.org> parents: 24374 diff changeset	1955
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1956 # for internal use
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1957 def _list(repo, subset, x):
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1958 s = getstring(x, "internal error")
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1959 if not s:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	1960 return baseset()
25341 9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions Yuya Nishihara <yuya@tcha.org> parents: 25309 diff changeset	1961 # remove duplicates here. it's difficult for caller to deduplicate sets
9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions Yuya Nishihara <yuya@tcha.org> parents: 25309 diff changeset	1962 # because different symbols can point to the same rev.
25344 ceaf04bb14ff revset: add fast path for _list() of integer revisions Yuya Nishihara <yuya@tcha.org> parents: 25343 diff changeset	1963 cl = repo.changelog
25341 9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions Yuya Nishihara <yuya@tcha.org> parents: 25309 diff changeset	1964 ls = []
9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions Yuya Nishihara <yuya@tcha.org> parents: 25309 diff changeset	1965 seen = set()
9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions Yuya Nishihara <yuya@tcha.org> parents: 25309 diff changeset	1966 for t in s.split('\0'):
25344 ceaf04bb14ff revset: add fast path for _list() of integer revisions Yuya Nishihara <yuya@tcha.org> parents: 25343 diff changeset	1967 try:
ceaf04bb14ff revset: add fast path for _list() of integer revisions Yuya Nishihara <yuya@tcha.org> parents: 25343 diff changeset	1968 # fast path for integer revision
ceaf04bb14ff revset: add fast path for _list() of integer revisions Yuya Nishihara <yuya@tcha.org> parents: 25343 diff changeset	1969 r = int(t)
ceaf04bb14ff revset: add fast path for _list() of integer revisions Yuya Nishihara <yuya@tcha.org> parents: 25343 diff changeset	1970 if str(r) != t or r not in cl:
ceaf04bb14ff revset: add fast path for _list() of integer revisions Yuya Nishihara <yuya@tcha.org> parents: 25343 diff changeset	1971 raise ValueError
ceaf04bb14ff revset: add fast path for _list() of integer revisions Yuya Nishihara <yuya@tcha.org> parents: 25343 diff changeset	1972 except ValueError:
ceaf04bb14ff revset: add fast path for _list() of integer revisions Yuya Nishihara <yuya@tcha.org> parents: 25343 diff changeset	1973 r = repo[t].rev()
25341 9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions Yuya Nishihara <yuya@tcha.org> parents: 25309 diff changeset	1974 if r in seen:
9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions Yuya Nishihara <yuya@tcha.org> parents: 25309 diff changeset	1975 continue
25342 5dde117269b6 revset: make "null" able to appear in internal _list() expression Yuya Nishihara <yuya@tcha.org> parents: 25341 diff changeset	1976 if (r in subset
5dde117269b6 revset: make "null" able to appear in internal _list() expression Yuya Nishihara <yuya@tcha.org> parents: 25341 diff changeset	1977 or r == node.nullrev and isinstance(subset, fullreposet)):
25341 9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions Yuya Nishihara <yuya@tcha.org> parents: 25309 diff changeset	1978 ls.append(r)
9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions Yuya Nishihara <yuya@tcha.org> parents: 25309 diff changeset	1979 seen.add(r)
9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions Yuya Nishihara <yuya@tcha.org> parents: 25309 diff changeset	1980 return baseset(ls)
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1981
20566 98024950ade0 revset: added _intlist method to replace _list for %ld Lucas Moscovicz <lmoscovicz@fb.com> parents: 20552 diff changeset	1982 # for internal use
98024950ade0 revset: added _intlist method to replace _list for %ld Lucas Moscovicz <lmoscovicz@fb.com> parents: 20552 diff changeset	1983 def _intlist(repo, subset, x):
98024950ade0 revset: added _intlist method to replace _list for %ld Lucas Moscovicz <lmoscovicz@fb.com> parents: 20552 diff changeset	1984 s = getstring(x, "internal error")
98024950ade0 revset: added _intlist method to replace _list for %ld Lucas Moscovicz <lmoscovicz@fb.com> parents: 20552 diff changeset	1985 if not s:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	1986 return baseset()
20566 98024950ade0 revset: added _intlist method to replace _list for %ld Lucas Moscovicz <lmoscovicz@fb.com> parents: 20552 diff changeset	1987 ls = [int(r) for r in s.split('\0')]
22876 d52ca940c665 revset-_intlist: remove usage of `set()` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22875 diff changeset	1988 s = subset
20566 98024950ade0 revset: added _intlist method to replace _list for %ld Lucas Moscovicz <lmoscovicz@fb.com> parents: 20552 diff changeset	1989 return baseset([r for r in ls if r in s])
98024950ade0 revset: added _intlist method to replace _list for %ld Lucas Moscovicz <lmoscovicz@fb.com> parents: 20552 diff changeset	1990
20569 0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	1991 # for internal use
0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	1992 def _hexlist(repo, subset, x):
0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	1993 s = getstring(x, "internal error")
0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	1994 if not s:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	1995 return baseset()
20569 0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	1996 cl = repo.changelog
0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	1997 ls = [cl.rev(node.bin(r)) for r in s.split('\0')]
22877 489d2f3688c9 revset-_hexlist: remove usage of `set()` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22876 diff changeset	1998 s = subset
20569 0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	1999 return baseset([r for r in ls if r in s])
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2000
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2001 symbols = {
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	2002 "adds": adds,
0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	2003 "all": getall,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2004 "ancestor": ancestor,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2005 "ancestors": ancestors,
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	2006 "_firstancestors": _firstancestors,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	2007 "author": author,
15134 81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	2008 "bisect": bisect,
13602 54b198fe9768 revset: add a revset command to get bisect state. Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 13593 diff changeset	2009 "bisected": bisected,
13359 87f248e78173 bookmarks: move revset support to core Matt Mackall <mpm@selenic.com> parents: 13031 diff changeset	2010 "bookmark": bookmark,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2011 "branch": branch,
17753 69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	2012 "branchpoint": branchpoint,
17829 c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	2013 "bumped": bumped,
17913 03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	2014 "bundle": bundle,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	2015 "children": children,
0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	2016 "closed": closed,
0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	2017 "contains": contains,
17002 0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	2018 "converted": converted,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	2019 "date": date,
14650 93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	2020 "desc": desc,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	2021 "descendants": descendants,
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	2022 "_firstdescendants": _firstdescendants,
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	2023 "destination": destination,
18071 bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	2024 "divergent": divergent,
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	2025 "draft": draft,
17173 c621f84dbb35 obsolete: compute extinct changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17171 diff changeset	2026 "extinct": extinct,
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	2027 "extra": extra,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	2028 "file": hasfile,
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	2029 "filelog": filelog,
15117 0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	2030 "first": first,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	2031 "follow": follow,
16174 0a73c4bd9f47 graphlog: implement --follow-first Patrick Mezard <patrick@mezard.eu> parents: 16161 diff changeset	2032 "_followfirst": _followfirst,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	2033 "grep": grep,
0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	2034 "head": head,
0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	2035 "heads": heads,
17390 74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	2036 "hidden": hidden,
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	2037 "id": node_,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2038 "keyword": keyword,
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	2039 "last": last,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	2040 "limit": limit,
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	2041 "_matchfiles": _matchfiles,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	2042 "max": maxrev,
14649 a6a8809c6e33 revset: update sorting of symbols Thomas Arendsen Hein <thomas@intevation.de> parents: 14556 diff changeset	2043 "merge": merge,
11708 ba65d61f3158 revset: add min function Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 11650 diff changeset	2044 "min": minrev,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	2045 "modifies": modifies,
23836 3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	2046 "named": named,
17170 63a4a3871607 revset: add an `obsolete` symbol Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17102 diff changeset	2047 "obsolete": obsolete,
23466 d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	2048 "only": only,
17185 2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	2049 "origin": origin,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	2050 "outgoing": outgoing,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2051 "p1": p1,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2052 "p2": p2,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2053 "parents": parents,
11944 df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	2054 "present": present,
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	2055 "public": public,
25191 08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	2056 "_notpublic": _notpublic,
15936 878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	2057 "remote": remote,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	2058 "removes": removes,
14649 a6a8809c6e33 revset: update sorting of symbols Thomas Arendsen Hein <thomas@intevation.de> parents: 14556 diff changeset	2059 "rev": rev,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	2060 "reverse": reverse,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2061 "roots": roots,
11284 0b5c2e82aeb5 revset: sort the predicate list Matt Mackall <mpm@selenic.com> parents: 11283 diff changeset	2062 "sort": sort,
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	2063 "secret": secret,
24446 582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2064 "subrepo": subrepo,
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	2065 "matching": matching,
12715 33820dccbea4 revset: rename tagged() to tag() and allow it to take an optional tag name Augie Fackler <durin42@gmail.com> parents: 12616 diff changeset	2066 "tag": tag,
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	2067 "tagged": tagged,
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	2068 "user": user,
17171 9c750c3e4fac obsolete: compute unstable changeset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17170 diff changeset	2069 "unstable": unstable,
24419 0e41f110e69e revset: add wdir() function to specify workingctx revision by command Yuya Nishihara <yuya@tcha.org> parents: 24374 diff changeset	2070 "wdir": wdir,
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2071 "_list": _list,
20566 98024950ade0 revset: added _intlist method to replace _list for %ld Lucas Moscovicz <lmoscovicz@fb.com> parents: 20552 diff changeset	2072 "_intlist": _intlist,
20569 0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	2073 "_hexlist": _hexlist,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2074 }
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2075
19721 d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2076 # symbols which can't be used for a DoS attack for any given input
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2077 # (e.g. those which accept regexes as plain strings shouldn't be included)
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2078 # functions that just return a lot of changesets (like all) don't count here
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2079 safesymbols = set([
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2080 "adds",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2081 "all",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2082 "ancestor",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2083 "ancestors",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2084 "_firstancestors",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2085 "author",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2086 "bisect",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2087 "bisected",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2088 "bookmark",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2089 "branch",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2090 "branchpoint",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2091 "bumped",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2092 "bundle",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2093 "children",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2094 "closed",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2095 "converted",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2096 "date",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2097 "desc",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2098 "descendants",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2099 "_firstdescendants",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2100 "destination",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2101 "divergent",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2102 "draft",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2103 "extinct",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2104 "extra",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2105 "file",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2106 "filelog",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2107 "first",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2108 "follow",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2109 "_followfirst",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2110 "head",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2111 "heads",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2112 "hidden",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2113 "id",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2114 "keyword",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2115 "last",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2116 "limit",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2117 "_matchfiles",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2118 "max",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2119 "merge",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2120 "min",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2121 "modifies",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2122 "obsolete",
23467 c237499a7fba revset: add 'only' to DoS-safe symbols Yuya Nishihara <yuya@tcha.org> parents: 23466 diff changeset	2123 "only",
19721 d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2124 "origin",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2125 "outgoing",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2126 "p1",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2127 "p2",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2128 "parents",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2129 "present",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2130 "public",
25191 08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	2131 "_notpublic",
19721 d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2132 "remote",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2133 "removes",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2134 "rev",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2135 "reverse",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2136 "roots",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2137 "sort",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2138 "secret",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2139 "matching",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2140 "tag",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2141 "tagged",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2142 "user",
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2143 "unstable",
24419 0e41f110e69e revset: add wdir() function to specify workingctx revision by command Yuya Nishihara <yuya@tcha.org> parents: 24374 diff changeset	2144 "wdir",
19721 d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2145 "_list",
20566 98024950ade0 revset: added _intlist method to replace _list for %ld Lucas Moscovicz <lmoscovicz@fb.com> parents: 20552 diff changeset	2146 "_intlist",
20569 0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	2147 "_hexlist",
19721 d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2148 ])
d8ca6d965230 revset: add a whitelist of DoS-safe symbols Alexander Plavin <alexander@plav.in> parents: 19720 diff changeset	2149
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2150 methods = {
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2151 "range": rangeset,
16860 e1aa1ed30030 revset: turn dagrange into a function Bryan O'Sullivan <bryano@fb.com> parents: 16859 diff changeset	2152 "dagrange": dagrange,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2153 "string": stringset,
24932 022282152632 revset: don't error out if tokens parse as existing symbols Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24923 diff changeset	2154 "symbol": stringset,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2155 "and": andset,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2156 "or": orset,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2157 "not": notset,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2158 "list": listset,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2159 "func": func,
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	2160 "ancestor": ancestorspec,
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	2161 "parent": parentspec,
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	2162 "parentpost": p1,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2163 }
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2164
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2165 def optimize(x, small):
13031 3da456d0c885 code style: prefer 'is' and 'is not' tests with singletons Martin Geisler <mg@aragost.com> parents: 12936 diff changeset	2166 if x is None:
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2167 return 0, x
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2168
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2169 smallbonus = 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2170 if small:
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2171 smallbonus = .5
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2172
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2173 op = x[0]
11283 a6356b2695a3 revset: fix - handling in the optimizer Matt Mackall <mpm@selenic.com> parents: 11282 diff changeset	2174 if op == 'minus':
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2175 return optimize(('and', x[1], ('not', x[2])), small)
23765 537a2669a113 revset: use '%' as an operator for 'only' Sean Farley <sean.michael.farley@gmail.com> parents: 23742 diff changeset	2176 elif op == 'only':
537a2669a113 revset: use '%' as an operator for 'only' Sean Farley <sean.michael.farley@gmail.com> parents: 23742 diff changeset	2177 return optimize(('func', ('symbol', 'only'),
537a2669a113 revset: use '%' as an operator for 'only' Sean Farley <sean.michael.farley@gmail.com> parents: 23742 diff changeset	2178 ('list', x[1], x[2])), small)
25094 8b99e9a8db05 revset: map postfix '%' to only() to optimize operand recursively (issue4670) Yuya Nishihara <yuya@tcha.org> parents: 24904 diff changeset	2179 elif op == 'onlypost':
8b99e9a8db05 revset: map postfix '%' to only() to optimize operand recursively (issue4670) Yuya Nishihara <yuya@tcha.org> parents: 24904 diff changeset	2180 return optimize(('func', ('symbol', 'only'), x[1]), small)
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2181 elif op == 'dagrangepre':
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2182 return optimize(('func', ('symbol', 'ancestors'), x[1]), small)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2183 elif op == 'dagrangepost':
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2184 return optimize(('func', ('symbol', 'descendants'), x[1]), small)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2185 elif op == 'rangepre':
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2186 return optimize(('range', ('string', '0'), x[1]), small)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2187 elif op == 'rangepost':
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2188 return optimize(('range', x[1], ('string', 'tip')), small)
11467 6b836d5c8c9e revset: make negate work for sort specs Matt Mackall <mpm@selenic.com> parents: 11456 diff changeset	2189 elif op == 'negate':
6b836d5c8c9e revset: make negate work for sort specs Matt Mackall <mpm@selenic.com> parents: 11456 diff changeset	2190 return optimize(('string',
6b836d5c8c9e revset: make negate work for sort specs Matt Mackall <mpm@selenic.com> parents: 11456 diff changeset	2191 '-' + getstring(x[1], _("can't negate that"))), small)
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2192 elif op in 'string symbol negate':
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2193 return smallbonus, x # single revisions are small
16859 eeb464ed7275 revset: drop unreachable code Bryan O'Sullivan <bryano@fb.com> parents: 16838 diff changeset	2194 elif op == 'and':
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2195 wa, ta = optimize(x[1], True)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2196 wb, tb = optimize(x[2], True)
20499 2efd608473fb revset: optimize missing ancestor expressions Siddharth Agarwal <sid0@fb.com> parents: 20498 diff changeset	2197
2efd608473fb revset: optimize missing ancestor expressions Siddharth Agarwal <sid0@fb.com> parents: 20498 diff changeset	2198 # (::x and not ::y)/(not ::y and ::x) have a fast path
21893 e967c3b08705 revset: replace _missingancestors optimization with only revset Siddharth Agarwal <sid0@fb.com> parents: 21870 diff changeset	2199 def isonly(revs, bases):
20499 2efd608473fb revset: optimize missing ancestor expressions Siddharth Agarwal <sid0@fb.com> parents: 20498 diff changeset	2200 return (
2efd608473fb revset: optimize missing ancestor expressions Siddharth Agarwal <sid0@fb.com> parents: 20498 diff changeset	2201 revs[0] == 'func'
2efd608473fb revset: optimize missing ancestor expressions Siddharth Agarwal <sid0@fb.com> parents: 20498 diff changeset	2202 and getstring(revs[1], _('not a symbol')) == 'ancestors'
2efd608473fb revset: optimize missing ancestor expressions Siddharth Agarwal <sid0@fb.com> parents: 20498 diff changeset	2203 and bases[0] == 'not'
2efd608473fb revset: optimize missing ancestor expressions Siddharth Agarwal <sid0@fb.com> parents: 20498 diff changeset	2204 and bases[1][0] == 'func'
2efd608473fb revset: optimize missing ancestor expressions Siddharth Agarwal <sid0@fb.com> parents: 20498 diff changeset	2205 and getstring(bases[1][1], _('not a symbol')) == 'ancestors')
2efd608473fb revset: optimize missing ancestor expressions Siddharth Agarwal <sid0@fb.com> parents: 20498 diff changeset	2206
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2207 w = min(wa, wb)
21893 e967c3b08705 revset: replace _missingancestors optimization with only revset Siddharth Agarwal <sid0@fb.com> parents: 21870 diff changeset	2208 if isonly(ta, tb):
e967c3b08705 revset: replace _missingancestors optimization with only revset Siddharth Agarwal <sid0@fb.com> parents: 21870 diff changeset	2209 return w, ('func', ('symbol', 'only'), ('list', ta[2], tb[1][2]))
e967c3b08705 revset: replace _missingancestors optimization with only revset Siddharth Agarwal <sid0@fb.com> parents: 21870 diff changeset	2210 if isonly(tb, ta):
e967c3b08705 revset: replace _missingancestors optimization with only revset Siddharth Agarwal <sid0@fb.com> parents: 21870 diff changeset	2211 return w, ('func', ('symbol', 'only'), ('list', tb[2], ta[1][2]))
20499 2efd608473fb revset: optimize missing ancestor expressions Siddharth Agarwal <sid0@fb.com> parents: 20498 diff changeset	2212
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2213 if wa > wb:
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2214 return w, (op, tb, ta)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2215 return w, (op, ta, tb)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2216 elif op == 'or':
25343 7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2217 # fast path for machine-generated expression, that is likely to have
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2218 # lots of trivial revisions: 'a + b + c()' to '_list(a b) + c()'
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2219 ws, ts, ss = [], [], []
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2220 def flushss():
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2221 if not ss:
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2222 return
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2223 if len(ss) == 1:
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2224 w, t = ss[0]
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2225 else:
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2226 s = '\0'.join(t[1] for w, t in ss)
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2227 y = ('func', ('symbol', '_list'), ('string', s))
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2228 w, t = optimize(y, False)
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2229 ws.append(w)
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2230 ts.append(t)
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2231 del ss[:]
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2232 for y in x[1:]:
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2233 w, t = optimize(y, False)
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2234 if t[0] == 'string' or t[0] == 'symbol':
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2235 ss.append((w, t))
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2236 continue
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2237 flushss()
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2238 ws.append(w)
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2239 ts.append(t)
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2240 flushss()
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2241 if len(ts) == 1:
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2242 return ws[0], ts[0] # 'or' operation is fully optimized out
25307 4d1e56b29a91 revset: comment that we can't swap 'or' operands by weight Yuya Nishihara <yuya@tcha.org> parents: 25270 diff changeset	2243 # we can't reorder trees by weight because it would change the order.
4d1e56b29a91 revset: comment that we can't swap 'or' operands by weight Yuya Nishihara <yuya@tcha.org> parents: 25270 diff changeset	2244 # ("sort(a + b)" == "sort(b + a)", but "a + b" != "b + a")
25309 b333ca94403d revset: reduce nesting of chained 'or' operations (issue4624) Yuya Nishihara <yuya@tcha.org> parents: 25308 diff changeset	2245 # ts = tuple(t for w, t in sorted(zip(ws, ts), key=lambda wt: wt[0]))
25343 7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2246 return max(ws), (op,) + tuple(ts)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2247 elif op == 'not':
25191 08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	2248 # Optimize not public() to _notpublic() because we have a fast version
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	2249 if x[1] == ('func', ('symbol', 'public'), None):
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	2250 newsym = ('func', ('symbol', '_notpublic'), None)
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	2251 o = optimize(newsym, not small)
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	2252 return o[0], o[1]
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	2253 else:
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	2254 o = optimize(x[1], not small)
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	2255 return o[0], (op, o[1])
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	2256 elif op == 'parentpost':
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	2257 o = optimize(x[1], small)
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	2258 return o[0], (op, o[1])
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2259 elif op == 'group':
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2260 return optimize(x[1], small)
16860 e1aa1ed30030 revset: turn dagrange into a function Bryan O'Sullivan <bryano@fb.com> parents: 16859 diff changeset	2261 elif op in 'dagrange range list parent ancestorspec':
14842 805651777188 revsets: do the right thing with x^:y (issue2884) Matt Mackall <mpm@selenic.com> parents: 14723 diff changeset	2262 if op == 'parent':
805651777188 revsets: do the right thing with x^:y (issue2884) Matt Mackall <mpm@selenic.com> parents: 14723 diff changeset	2263 # x^:y means (x^) : y, not x ^ (:y)
805651777188 revsets: do the right thing with x^:y (issue2884) Matt Mackall <mpm@selenic.com> parents: 14723 diff changeset	2264 post = ('parentpost', x[1])
805651777188 revsets: do the right thing with x^:y (issue2884) Matt Mackall <mpm@selenic.com> parents: 14723 diff changeset	2265 if x[2][0] == 'dagrangepre':
805651777188 revsets: do the right thing with x^:y (issue2884) Matt Mackall <mpm@selenic.com> parents: 14723 diff changeset	2266 return optimize(('dagrange', post, x[2][1]), small)
805651777188 revsets: do the right thing with x^:y (issue2884) Matt Mackall <mpm@selenic.com> parents: 14723 diff changeset	2267 elif x[2][0] == 'rangepre':
805651777188 revsets: do the right thing with x^:y (issue2884) Matt Mackall <mpm@selenic.com> parents: 14723 diff changeset	2268 return optimize(('range', post, x[2][1]), small)
805651777188 revsets: do the right thing with x^:y (issue2884) Matt Mackall <mpm@selenic.com> parents: 14723 diff changeset	2269
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2270 wa, ta = optimize(x[1], small)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2271 wb, tb = optimize(x[2], small)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2272 return wa + wb, (op, ta, tb)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2273 elif op == 'func':
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	2274 f = getstring(x[1], _("not a symbol"))
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2275 wa, ta = optimize(x[2], small)
14650 93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	2276 if f in ("author branch closed date desc file grep keyword "
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	2277 "outgoing user"):
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2278 w = 10 # slow
12351 b913232d13c1 revsets: reduce cost of outgoing in the optimizer Matt Mackall <mpm@selenic.com> parents: 12321 diff changeset	2279 elif f in "modifies adds removes":
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2280 w = 30 # slower
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2281 elif f == "contains":
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2282 w = 100 # very slow
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2283 elif f == "ancestor":
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2284 w = 1 * smallbonus
22451 186fd06283b4 revset: lower weight for _intlist function Durham Goode <durham@fb.com> parents: 22450 diff changeset	2285 elif f in "reverse limit first _intlist":
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2286 w = 0
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2287 elif f in "sort":
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2288 w = 10 # assume most sorts look at changelog
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2289 else:
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2290 w = 1
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2291 return w + wa, (op, x[1], ta)
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2292 return 1, x
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2293
16771 2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2294 _aliasarg = ('func', ('symbol', '_aliasarg'))
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2295 def _getaliasarg(tree):
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2296 """If tree matches ('func', ('symbol', '_aliasarg'), ('string', X))
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2297 return X, None otherwise.
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2298 """
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2299 if (len(tree) == 3 and tree[:2] == _aliasarg
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2300 and tree[2][0] == 'string'):
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2301 return tree[2][1]
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2302 return None
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2303
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2304 def _checkaliasarg(tree, known=None):
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2305 """Check tree contains no _aliasarg construct or only ones which
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2306 value is in known. Used to avoid alias placeholders injection.
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2307 """
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2308 if isinstance(tree, tuple):
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2309 arg = _getaliasarg(tree)
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2310 if arg is not None and (not known or arg not in known):
24219 282c0d8c1880 revset: use UnknownIdentifier where appropriate Augie Fackler <augie@google.com> parents: 24204 diff changeset	2311 raise error.UnknownIdentifier('_aliasarg', [])
16771 2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2312 for t in tree:
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2313 _checkaliasarg(t, known)
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2314
23845 0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2315 # the set of valid characters for the initial letter of symbols in
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2316 # alias declarations and definitions
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2317 _aliassyminitletters = set(c for c in [chr(i) for i in xrange(256)]
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2318 if c.isalnum() or c in '._@$' or ord(c) > 127)
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2319
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2320 def _tokenizealias(program, lookup=None):
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2321 """Parse alias declaration/definition into a stream of tokens
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2322
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2323 This allows symbol names to use also ``$`` as an initial letter
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2324 (for backward compatibility), and callers of this function should
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2325 examine whether ``$`` is used also for unexpected symbols or not.
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2326 """
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2327 return tokenize(program, lookup=lookup,
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2328 syminitletters=_aliassyminitletters)
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2329
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2330 def _parsealiasdecl(decl):
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2331 """Parse alias declaration ``decl``
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2332
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2333 This returns ``(name, tree, args, errorstr)`` tuple:
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2334
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2335 - ``name``: of declared alias (may be ``decl`` itself at error)
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2336 - ``tree``: parse result (or ``None`` at error)
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2337 - ``args``: list of alias argument names (or None for symbol declaration)
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2338 - ``errorstr``: detail about detected error (or None)
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2339
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2340 >>> _parsealiasdecl('foo')
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2341 ('foo', ('symbol', 'foo'), None, None)
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2342 >>> _parsealiasdecl('$foo')
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2343 ('$foo', None, None, "'$' not for alias arguments")
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2344 >>> _parsealiasdecl('foo::bar')
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2345 ('foo::bar', None, None, 'invalid format')
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2346 >>> _parsealiasdecl('foo bar')
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2347 ('foo bar', None, None, 'at 4: invalid token')
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2348 >>> _parsealiasdecl('foo()')
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2349 ('foo', ('func', ('symbol', 'foo')), [], None)
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2350 >>> _parsealiasdecl('$foo()')
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2351 ('$foo()', None, None, "'$' not for alias arguments")
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2352 >>> _parsealiasdecl('foo($1, $2)')
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2353 ('foo', ('func', ('symbol', 'foo')), ['$1', '$2'], None)
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2354 >>> _parsealiasdecl('foo(bar_bar, baz.baz)')
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2355 ('foo', ('func', ('symbol', 'foo')), ['bar_bar', 'baz.baz'], None)
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2356 >>> _parsealiasdecl('foo($1, $2, nested($1, $2))')
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2357 ('foo($1, $2, nested($1, $2))', None, None, 'invalid argument list')
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2358 >>> _parsealiasdecl('foo(bar($1, $2))')
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2359 ('foo(bar($1, $2))', None, None, 'invalid argument list')
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2360 >>> _parsealiasdecl('foo("string")')
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2361 ('foo("string")', None, None, 'invalid argument list')
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2362 >>> _parsealiasdecl('foo($1, $2')
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2363 ('foo($1, $2', None, None, 'at 10: unexpected token: end')
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2364 >>> _parsealiasdecl('foo("string')
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2365 ('foo("string', None, None, 'at 5: unterminated string')
23847 71402bb8d8b2 revset: check for collisions between alias argument names in the declaration FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23846 diff changeset	2366 >>> _parsealiasdecl('foo($1, $2, $1)')
71402bb8d8b2 revset: check for collisions between alias argument names in the declaration FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23846 diff changeset	2367 ('foo', None, None, 'argument names collide with each other')
23845 0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2368 """
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2369 p = parser.parser(_tokenizealias, elements)
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2370 try:
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2371 tree, pos = p.parse(decl)
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2372 if (pos != len(decl)):
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2373 raise error.ParseError(_('invalid token'), pos)
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2374
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2375 if isvalidsymbol(tree):
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2376 # "name = ...." style
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2377 name = getsymbol(tree)
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2378 if name.startswith('$'):
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2379 return (decl, None, None, _("'$' not for alias arguments"))
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2380 return (name, ('symbol', name), None, None)
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2381
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2382 if isvalidfunc(tree):
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2383 # "name(arg, ....) = ...." style
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2384 name = getfuncname(tree)
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2385 if name.startswith('$'):
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2386 return (decl, None, None, _("'$' not for alias arguments"))
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2387 args = []
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2388 for arg in getfuncargs(tree):
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2389 if not isvalidsymbol(arg):
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2390 return (decl, None, None, _("invalid argument list"))
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2391 args.append(getsymbol(arg))
23847 71402bb8d8b2 revset: check for collisions between alias argument names in the declaration FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23846 diff changeset	2392 if len(args) != len(set(args)):
71402bb8d8b2 revset: check for collisions between alias argument names in the declaration FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23846 diff changeset	2393 return (name, None, None,
71402bb8d8b2 revset: check for collisions between alias argument names in the declaration FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23846 diff changeset	2394 _("argument names collide with each other"))
23845 0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2395 return (name, ('func', ('symbol', name)), args, None)
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2396
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2397 return (decl, None, None, _("invalid format"))
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2398 except error.ParseError, inst:
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2399 return (decl, None, None, parseerrordetail(inst))
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2400
23993 eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2401 def _parsealiasdefn(defn, args):
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2402 """Parse alias definition ``defn``
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2403
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2404 This function also replaces alias argument references in the
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2405 specified definition by ``_aliasarg(ARGNAME)``.
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2406
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2407 ``args`` is a list of alias argument names, or None if the alias
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2408 is declared as a symbol.
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2409
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2410 This returns "tree" as parsing result.
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2411
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2412 >>> args = ['$1', '$2', 'foo']
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2413 >>> print prettyformat(_parsealiasdefn('$1 or foo', args))
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2414 (or
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2415 (func
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2416 ('symbol', '_aliasarg')
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2417 ('string', '$1'))
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2418 (func
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2419 ('symbol', '_aliasarg')
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2420 ('string', 'foo')))
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2421 >>> try:
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2422 ... _parsealiasdefn('$1 or $bar', args)
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2423 ... except error.ParseError, inst:
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2424 ... print parseerrordetail(inst)
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2425 at 6: '$' not for alias arguments
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2426 >>> args = ['$1', '$10', 'foo']
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2427 >>> print prettyformat(_parsealiasdefn('$10 or foobar', args))
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2428 (or
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2429 (func
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2430 ('symbol', '_aliasarg')
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2431 ('string', '$10'))
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2432 ('symbol', 'foobar'))
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2433 >>> print prettyformat(_parsealiasdefn('"$1" or "foo"', args))
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2434 (or
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2435 ('string', '$1')
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2436 ('string', 'foo'))
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2437 """
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2438 def tokenizedefn(program, lookup=None):
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2439 if args:
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2440 argset = set(args)
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2441 else:
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2442 argset = set()
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2443
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2444 for t, value, pos in _tokenizealias(program, lookup=lookup):
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2445 if t == 'symbol':
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2446 if value in argset:
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2447 # emulate tokenization of "_aliasarg('ARGNAME')":
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2448 # "_aliasarg()" is an unknown symbol only used separate
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2449 # alias argument placeholders from regular strings.
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2450 yield ('symbol', '_aliasarg', pos)
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2451 yield ('(', None, pos)
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2452 yield ('string', value, pos)
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2453 yield (')', None, pos)
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2454 continue
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2455 elif value.startswith('$'):
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2456 raise error.ParseError(_("'$' not for alias arguments"),
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2457 pos)
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2458 yield (t, value, pos)
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2459
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2460 p = parser.parser(tokenizedefn, elements)
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2461 tree, pos = p.parse(defn)
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2462 if pos != len(defn):
eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2463 raise error.ParseError(_('invalid token'), pos)
25309 b333ca94403d revset: reduce nesting of chained 'or' operations (issue4624) Yuya Nishihara <yuya@tcha.org> parents: 25308 diff changeset	2464 return parser.simplifyinfixops(tree, ('or',))
23993 eedade006458 revset: introduce _parsealiasdefn to parse alias definitions strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23978 diff changeset	2465
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	2466 class revsetalias(object):
23725 6a81f88758aa revset: delay showing parse error for the revset alias until it is referred FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23720 diff changeset	2467 # whether own `error` information is already shown or not.
6a81f88758aa revset: delay showing parse error for the revset alias until it is referred FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23720 diff changeset	2468 # this avoids showing same warning multiple times at each `findaliases`.
6a81f88758aa revset: delay showing parse error for the revset alias until it is referred FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23720 diff changeset	2469 warned = False
6a81f88758aa revset: delay showing parse error for the revset alias until it is referred FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23720 diff changeset	2470
14723 b9faf94ee196 revset: fix aliases with 0 or more than 2 parameters Mads Kiilerich <mads@kiilerich.com> parents: 14717 diff changeset	2471 def __init__(self, name, value):
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	2472 '''Aliases like:
9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	2473
9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	2474 h = heads(default)
9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	2475 b($1) = ancestors($1) - ancestors(default)
9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	2476 '''
23846 aac4a1a7920e revset: parse alias declaration strictly by _parsealiasdecl FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23845 diff changeset	2477 self.name, self.tree, self.args, self.error = _parsealiasdecl(name)
aac4a1a7920e revset: parse alias declaration strictly by _parsealiasdecl FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23845 diff changeset	2478 if self.error:
aac4a1a7920e revset: parse alias declaration strictly by _parsealiasdecl FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23845 diff changeset	2479 self.error = _('failed to parse the declaration of revset alias'
aac4a1a7920e revset: parse alias declaration strictly by _parsealiasdecl FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23845 diff changeset	2480 ' "%s": %s') % (self.name, self.error)
aac4a1a7920e revset: parse alias declaration strictly by _parsealiasdecl FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23845 diff changeset	2481 return
aac4a1a7920e revset: parse alias declaration strictly by _parsealiasdecl FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23845 diff changeset	2482
23725 6a81f88758aa revset: delay showing parse error for the revset alias until it is referred FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23720 diff changeset	2483 try:
23994 8a2156780839 revset: replace parsing alias definition by _parsealiasdefn to parse strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23993 diff changeset	2484 self.replacement = _parsealiasdefn(value, self.args)
23725 6a81f88758aa revset: delay showing parse error for the revset alias until it is referred FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23720 diff changeset	2485 # Check for placeholder injection
6a81f88758aa revset: delay showing parse error for the revset alias until it is referred FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23720 diff changeset	2486 _checkaliasarg(self.replacement, self.args)
6a81f88758aa revset: delay showing parse error for the revset alias until it is referred FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23720 diff changeset	2487 except error.ParseError, inst:
23844 ddf2172e901d revset: store full detail into revsetalias.error for error source distinction FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23843 diff changeset	2488 self.error = _('failed to parse the definition of revset alias'
ddf2172e901d revset: store full detail into revsetalias.error for error source distinction FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23843 diff changeset	2489 ' "%s": %s') % (self.name, parseerrordetail(inst))
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	2490
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2491 def _getalias(aliases, tree):
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2492 """If tree looks like an unexpanded alias, return it. Return None
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2493 otherwise.
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2494 """
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2495 if isinstance(tree, tuple) and tree:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2496 if tree[0] == 'symbol' and len(tree) == 2:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2497 name = tree[1]
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2498 alias = aliases.get(name)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2499 if alias and alias.args is None and alias.tree == tree:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2500 return alias
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2501 if tree[0] == 'func' and len(tree) > 1:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2502 if tree[1][0] == 'symbol' and len(tree[1]) == 2:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2503 name = tree[1][1]
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2504 alias = aliases.get(name)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2505 if alias and alias.args is not None and alias.tree == tree[:2]:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2506 return alias
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2507 return None
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	2508
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2509 def _expandargs(tree, args):
16771 2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2510 """Replace _aliasarg instances with the substitution value of the
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2511 same name in args, recursively.
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2512 """
16771 2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2513 if not tree or not isinstance(tree, tuple):
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2514 return tree
16771 2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2515 arg = _getaliasarg(tree)
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2516 if arg is not None:
2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2517 return args[arg]
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2518 return tuple(_expandargs(t, args) for t in tree)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2519
16838 d37d221334be revset: cache alias expansions Patrick Mezard <patrick@mezard.eu> parents: 16834 diff changeset	2520 def _expandaliases(aliases, tree, expanding, cache):
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2521 """Expand aliases in tree, recursively.
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2522
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2523 'aliases' is a dictionary mapping user defined aliases to
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2524 revsetalias objects.
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2525 """
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2526 if not isinstance(tree, tuple):
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2527 # Do not expand raw strings
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	2528 return tree
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2529 alias = _getalias(aliases, tree)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2530 if alias is not None:
23725 6a81f88758aa revset: delay showing parse error for the revset alias until it is referred FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23720 diff changeset	2531 if alias.error:
23844 ddf2172e901d revset: store full detail into revsetalias.error for error source distinction FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23843 diff changeset	2532 raise util.Abort(alias.error)
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2533 if alias in expanding:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2534 raise error.ParseError(_('infinite expansion of revset alias "%s" '
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2535 'detected') % alias.name)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2536 expanding.append(alias)
16838 d37d221334be revset: cache alias expansions Patrick Mezard <patrick@mezard.eu> parents: 16834 diff changeset	2537 if alias.name not in cache:
d37d221334be revset: cache alias expansions Patrick Mezard <patrick@mezard.eu> parents: 16834 diff changeset	2538 cache[alias.name] = _expandaliases(aliases, alias.replacement,
d37d221334be revset: cache alias expansions Patrick Mezard <patrick@mezard.eu> parents: 16834 diff changeset	2539 expanding, cache)
d37d221334be revset: cache alias expansions Patrick Mezard <patrick@mezard.eu> parents: 16834 diff changeset	2540 result = cache[alias.name]
16772 30e46d7138de revset: fix infinite alias expansion detection Patrick Mezard <patrick@mezard.eu> parents: 16771 diff changeset	2541 expanding.pop()
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2542 if alias.args is not None:
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2543 l = getlist(tree[2])
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2544 if len(l) != len(alias.args):
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2545 raise error.ParseError(
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2546 _('invalid number of arguments: %s') % len(l))
16838 d37d221334be revset: cache alias expansions Patrick Mezard <patrick@mezard.eu> parents: 16834 diff changeset	2547 l = [_expandaliases(aliases, a, [], cache) for a in l]
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2548 result = _expandargs(result, dict(zip(alias.args, l)))
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2549 else:
16838 d37d221334be revset: cache alias expansions Patrick Mezard <patrick@mezard.eu> parents: 16834 diff changeset	2550 result = tuple(_expandaliases(aliases, t, expanding, cache)
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2551 for t in tree)
b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2552 return result
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	2553
23725 6a81f88758aa revset: delay showing parse error for the revset alias until it is referred FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23720 diff changeset	2554 def findaliases(ui, tree, showwarning=None):
16771 2f3317d53d51 revset: explicitely tag alias arguments for expansion Patrick Mezard <patrick@mezard.eu> parents: 16748 diff changeset	2555 _checkaliasarg(tree)
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2556 aliases = {}
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	2557 for k, v in ui.configitems('revsetalias'):
9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	2558 alias = revsetalias(k, v)
16096 b8be450638f6 revset: fix alias substitution recursion (issue3240) Patrick Mezard <patrick@mezard.eu> parents: 16007 diff changeset	2559 aliases[alias.name] = alias
23725 6a81f88758aa revset: delay showing parse error for the revset alias until it is referred FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23720 diff changeset	2560 tree = _expandaliases(aliases, tree, [], {})
6a81f88758aa revset: delay showing parse error for the revset alias until it is referred FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23720 diff changeset	2561 if showwarning:
6a81f88758aa revset: delay showing parse error for the revset alias until it is referred FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23720 diff changeset	2562 # warn about problematic (but not referred) aliases
6a81f88758aa revset: delay showing parse error for the revset alias until it is referred FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23720 diff changeset	2563 for name, alias in sorted(aliases.iteritems()):
6a81f88758aa revset: delay showing parse error for the revset alias until it is referred FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23720 diff changeset	2564 if alias.error and not alias.warned:
23844 ddf2172e901d revset: store full detail into revsetalias.error for error source distinction FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23843 diff changeset	2565 showwarning(_('warning: %s\n') % (alias.error))
23725 6a81f88758aa revset: delay showing parse error for the revset alias until it is referred FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23720 diff changeset	2566 alias.warned = True
6a81f88758aa revset: delay showing parse error for the revset alias until it is referred FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23720 diff changeset	2567 return tree
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	2568
23742 3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2569 def foldconcat(tree):
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2570 """Fold elements to be concatenated by `##`
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2571 """
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2572 if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'):
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2573 return tree
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2574 if tree[0] == '_concat':
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2575 pending = [tree]
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2576 l = []
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2577 while pending:
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2578 e = pending.pop()
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2579 if e[0] == '_concat':
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2580 pending.extend(reversed(e[1:]))
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2581 elif e[0] in ('string', 'symbol'):
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2582 l.append(e[1])
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2583 else:
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2584 msg = _("\"##\" can't concatenate \"%s\" element") % (e[0])
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2585 raise error.ParseError(msg)
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2586 return ('string', ''.join(l))
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2587 else:
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2588 return tuple(foldconcat(t) for t in tree)
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	2589
20779 ffc2295c6b80 revset: pass a lookup function to the tokenizer Matt Mackall <mpm@selenic.com> parents: 20754 diff changeset	2590 def parse(spec, lookup=None):
20208 61a47fd64f30 fileset, revset: do not use global parser object for thread safety Yuya Nishihara <yuya@tcha.org> parents: 19721 diff changeset	2591 p = parser.parser(tokenize, elements)
25251 235f6490550c revset: move validation of incomplete parsing to parse() function Yuya Nishihara <yuya@tcha.org> parents: 25225 diff changeset	2592 tree, pos = p.parse(spec, lookup=lookup)
235f6490550c revset: move validation of incomplete parsing to parse() function Yuya Nishihara <yuya@tcha.org> parents: 25225 diff changeset	2593 if pos != len(spec):
235f6490550c revset: move validation of incomplete parsing to parse() function Yuya Nishihara <yuya@tcha.org> parents: 25225 diff changeset	2594 raise error.ParseError(_("invalid token"), pos)
25309 b333ca94403d revset: reduce nesting of chained 'or' operations (issue4624) Yuya Nishihara <yuya@tcha.org> parents: 25308 diff changeset	2595 return parser.simplifyinfixops(tree, ('or',))
20779 ffc2295c6b80 revset: pass a lookup function to the tokenizer Matt Mackall <mpm@selenic.com> parents: 20754 diff changeset	2596
24518 dd5e56f08d13 revset: add hook after tree parsing Laurent Charignon <lcharignon@fb.com> parents: 24459 diff changeset	2597 def posttreebuilthook(tree, repo):
dd5e56f08d13 revset: add hook after tree parsing Laurent Charignon <lcharignon@fb.com> parents: 24459 diff changeset	2598 # hook for extensions to execute code on the optimized tree
dd5e56f08d13 revset: add hook after tree parsing Laurent Charignon <lcharignon@fb.com> parents: 24459 diff changeset	2599 pass
dd5e56f08d13 revset: add hook after tree parsing Laurent Charignon <lcharignon@fb.com> parents: 24459 diff changeset	2600
20779 ffc2295c6b80 revset: pass a lookup function to the tokenizer Matt Mackall <mpm@selenic.com> parents: 20754 diff changeset	2601 def match(ui, spec, repo=None):
11385 e5a2134c083b revset: nicer exception for empty queries Matt Mackall <mpm@selenic.com> parents: 11383 diff changeset	2602 if not spec:
e5a2134c083b revset: nicer exception for empty queries Matt Mackall <mpm@selenic.com> parents: 11383 diff changeset	2603 raise error.ParseError(_("empty query"))
20779 ffc2295c6b80 revset: pass a lookup function to the tokenizer Matt Mackall <mpm@selenic.com> parents: 20754 diff changeset	2604 lookup = None
ffc2295c6b80 revset: pass a lookup function to the tokenizer Matt Mackall <mpm@selenic.com> parents: 20754 diff changeset	2605 if repo:
ffc2295c6b80 revset: pass a lookup function to the tokenizer Matt Mackall <mpm@selenic.com> parents: 20754 diff changeset	2606 lookup = repo.__contains__
25251 235f6490550c revset: move validation of incomplete parsing to parse() function Yuya Nishihara <yuya@tcha.org> parents: 25225 diff changeset	2607 tree = parse(spec, lookup)
14900 fc3d6f300d7d revset: allow bypassing alias expansion Matt Mackall <mpm@selenic.com> parents: 14851 diff changeset	2608 if ui:
23725 6a81f88758aa revset: delay showing parse error for the revset alias until it is referred FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23720 diff changeset	2609 tree = findaliases(ui, tree, showwarning=ui.warn)
23742 3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2610 tree = foldconcat(tree)
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2611 weight, tree = optimize(tree, True)
24518 dd5e56f08d13 revset: add hook after tree parsing Laurent Charignon <lcharignon@fb.com> parents: 24459 diff changeset	2612 posttreebuilthook(tree, repo)
24114 fafd9a1284cf revset: make match function initiate query from full set by default Yuya Nishihara <yuya@tcha.org> parents: 24031 diff changeset	2613 def mfunc(repo, subset=None):
fafd9a1284cf revset: make match function initiate query from full set by default Yuya Nishihara <yuya@tcha.org> parents: 24031 diff changeset	2614 if subset is None:
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	2615 subset = fullreposet(repo)
22885 e02b16f496f2 match: check if an object is a baseset using `isascending` instead of `set` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22884 diff changeset	2616 if util.safehasattr(subset, 'isascending'):
22686 2717dcff7be1 revset: use a single return statement in matcher function Pierre-Yves David <pierre-yves.david@fb.com> parents: 22670 diff changeset	2617 result = getset(repo, subset, tree)
2717dcff7be1 revset: use a single return statement in matcher function Pierre-Yves David <pierre-yves.david@fb.com> parents: 22670 diff changeset	2618 else:
2717dcff7be1 revset: use a single return statement in matcher function Pierre-Yves David <pierre-yves.david@fb.com> parents: 22670 diff changeset	2619 result = getset(repo, baseset(subset), tree)
2717dcff7be1 revset: use a single return statement in matcher function Pierre-Yves David <pierre-yves.david@fb.com> parents: 22670 diff changeset	2620 return result
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2621 return mfunc
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	2622
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2623 def formatspec(expr, *args):
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2624 '''
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2625 This is a convenience function for using revsets internally, and
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2626 escapes arguments appropriately. Aliases are intentionally ignored
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2627 so that intended expression behavior isn't accidentally subverted.
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2628
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2629 Supported arguments:
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2630
15266 8bea39ca9acb revset: add %r for embedded revset support to formatspec Matt Mackall <mpm@selenic.com> parents: 15153 diff changeset	2631 %r = revset expression, parenthesized
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2632 %d = int(arg), no quoting
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2633 %s = string(arg), escaped and single-quoted
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2634 %b = arg.branch(), escaped and single-quoted
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2635 %n = hex(arg), single-quoted
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2636 %% = a literal '%'
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2637
15266 8bea39ca9acb revset: add %r for embedded revset support to formatspec Matt Mackall <mpm@selenic.com> parents: 15153 diff changeset	2638 Prefixing the type with 'l' specifies a parenthesized list of that type.
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2639
15268 bd5103819c2e revset: fix %r handling in formatspec Matt Mackall <mpm@selenic.com> parents: 15266 diff changeset	2640 >>> formatspec('%r:: and %lr', '10 or 11', ("this()", "that()"))
bd5103819c2e revset: fix %r handling in formatspec Matt Mackall <mpm@selenic.com> parents: 15266 diff changeset	2641 '(10 or 11):: and ((this()) or (that()))'
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2642 >>> formatspec('%d:: and not %d::', 10, 20)
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2643 '10:: and not 20::'
15325 cdf1daa3b83f revset: deal with empty lists in formatspec Matt Mackall <mpm@selenic.com> parents: 15268 diff changeset	2644 >>> formatspec('%ld or %ld', [], [1])
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2645 "_list('') or 1"
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2646 >>> formatspec('keyword(%s)', 'foo\\xe9')
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2647 "keyword('foo\\\\xe9')"
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2648 >>> b = lambda: 'default'
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2649 >>> b.branch = b
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2650 >>> formatspec('branch(%b)', b)
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2651 "branch('default')"
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2652 >>> formatspec('root(%ls)', ['a', 'b', 'c', 'd'])
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2653 "root(_list('a\\x00b\\x00c\\x00d'))"
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2654 '''
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2655
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2656 def quote(s):
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2657 return repr(str(s))
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2658
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2659 def argtype(c, arg):
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2660 if c == 'd':
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2661 return str(int(arg))
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2662 elif c == 's':
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2663 return quote(arg)
15266 8bea39ca9acb revset: add %r for embedded revset support to formatspec Matt Mackall <mpm@selenic.com> parents: 15153 diff changeset	2664 elif c == 'r':
8bea39ca9acb revset: add %r for embedded revset support to formatspec Matt Mackall <mpm@selenic.com> parents: 15153 diff changeset	2665 parse(arg) # make sure syntax errors are confined
8bea39ca9acb revset: add %r for embedded revset support to formatspec Matt Mackall <mpm@selenic.com> parents: 15153 diff changeset	2666 return '(%s)' % arg
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2667 elif c == 'n':
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	2668 return quote(node.hex(arg))
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2669 elif c == 'b':
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2670 return quote(arg.branch())
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2671
15595 a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	2672 def listexp(s, t):
a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	2673 l = len(s)
a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	2674 if l == 0:
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2675 return "_list('')"
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2676 elif l == 1:
15595 a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	2677 return argtype(t, s[0])
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2678 elif t == 'd':
20566 98024950ade0 revset: added _intlist method to replace _list for %ld Lucas Moscovicz <lmoscovicz@fb.com> parents: 20552 diff changeset	2679 return "_intlist('%s')" % "\0".join(str(int(a)) for a in s)
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2680 elif t == 's':
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2681 return "_list('%s')" % "\0".join(s)
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2682 elif t == 'n':
20569 0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	2683 return "_hexlist('%s')" % "\0".join(node.hex(a) for a in s)
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2684 elif t == 'b':
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2685 return "_list('%s')" % "\0".join(a.branch() for a in s)
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2686
15791 a814f8fcc65a Use explicit integer division Martin Geisler <mg@aragost.com> parents: 15726 diff changeset	2687 m = l // 2
15595 a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	2688 return '(%s or %s)' % (listexp(s[:m], t), listexp(s[m:], t))
a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	2689
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2690 ret = ''
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2691 pos = 0
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2692 arg = 0
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2693 while pos < len(expr):
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2694 c = expr[pos]
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2695 if c == '%':
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2696 pos += 1
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2697 d = expr[pos]
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2698 if d == '%':
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2699 ret += d
15268 bd5103819c2e revset: fix %r handling in formatspec Matt Mackall <mpm@selenic.com> parents: 15266 diff changeset	2700 elif d in 'dsnbr':
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2701 ret += argtype(d, args[arg])
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2702 arg += 1
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2703 elif d == 'l':
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2704 # a list of some type
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2705 pos += 1
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2706 d = expr[pos]
15596 2555f441a32f merge with stable Matt Mackall <mpm@selenic.com> parents: 15595 diff changeset	2707 ret += listexp(list(args[arg]), d)
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2708 arg += 1
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2709 else:
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2710 raise util.Abort('unexpected revspec format character %s' % d)
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2711 else:
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2712 ret += c
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2713 pos += 1
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2714
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2715 return ret
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2716
16218 81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	2717 def prettyformat(tree):
25253 3f1a9b44b8c2 parser: move prettyformat() function from revset module Yuya Nishihara <yuya@tcha.org> parents: 25251 diff changeset	2718 return parser.prettyformat(tree, ('string', 'symbol'))
16218 81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	2719
19719 2f9d5c5256ea revset: add helper function to get revset parse tree depth Alexander Plavin <alexander@plav.in> parents: 19706 diff changeset	2720 def depth(tree):
2f9d5c5256ea revset: add helper function to get revset parse tree depth Alexander Plavin <alexander@plav.in> parents: 19706 diff changeset	2721 if isinstance(tree, tuple):
2f9d5c5256ea revset: add helper function to get revset parse tree depth Alexander Plavin <alexander@plav.in> parents: 19706 diff changeset	2722 return max(map(depth, tree)) + 1
2f9d5c5256ea revset: add helper function to get revset parse tree depth Alexander Plavin <alexander@plav.in> parents: 19706 diff changeset	2723 else:
2f9d5c5256ea revset: add helper function to get revset parse tree depth Alexander Plavin <alexander@plav.in> parents: 19706 diff changeset	2724 return 0
2f9d5c5256ea revset: add helper function to get revset parse tree depth Alexander Plavin <alexander@plav.in> parents: 19706 diff changeset	2725
19720 f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2726 def funcsused(tree):
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2727 if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'):
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2728 return set()
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2729 else:
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2730 funcs = set()
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2731 for s in tree[1:]:
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2732 funcs \|= funcsused(s)
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2733 if tree[0] == 'func':
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2734 funcs.add(tree[1][1])
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2735 return funcs
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2736
22692 78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2737 class abstractsmartset(object):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2738
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2739 def __nonzero__(self):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2740 """True if the smartset is not empty"""
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2741 raise NotImplementedError()
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2742
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2743 def __contains__(self, rev):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2744 """provide fast membership testing"""
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2745 raise NotImplementedError()
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2746
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2747 def __iter__(self):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2748 """iterate the set in the order it is supposed to be iterated"""
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2749 raise NotImplementedError()
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2750
22716 6877ba8d85ff abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22715 diff changeset	2751 # Attributes containing a function to perform a fast iteration in a given
6877ba8d85ff abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22715 diff changeset	2752 # direction. A smartset can have none, one, or both defined.
6877ba8d85ff abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22715 diff changeset	2753 #
6877ba8d85ff abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22715 diff changeset	2754 # Default value is None instead of a function returning None to avoid
6877ba8d85ff abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22715 diff changeset	2755 # initializing an iterator just for testing if a fast method exists.
6877ba8d85ff abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22715 diff changeset	2756 fastasc = None
6877ba8d85ff abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22715 diff changeset	2757 fastdesc = None
6877ba8d85ff abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22715 diff changeset	2758
22692 78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2759 def isascending(self):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2760 """True if the set will iterate in ascending order"""
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2761 raise NotImplementedError()
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2762
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2763 def isdescending(self):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2764 """True if the set will iterate in descending order"""
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2765 raise NotImplementedError()
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2766
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2767 def min(self):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2768 """return the minimum element in the set"""
22722 e8832cf1abf6 abstractsmartset: add a default implementation for min and max Pierre-Yves David <pierre-yves.david@fb.com> parents: 22721 diff changeset	2769 if self.fastasc is not None:
e8832cf1abf6 abstractsmartset: add a default implementation for min and max Pierre-Yves David <pierre-yves.david@fb.com> parents: 22721 diff changeset	2770 for r in self.fastasc():
e8832cf1abf6 abstractsmartset: add a default implementation for min and max Pierre-Yves David <pierre-yves.david@fb.com> parents: 22721 diff changeset	2771 return r
e8832cf1abf6 abstractsmartset: add a default implementation for min and max Pierre-Yves David <pierre-yves.david@fb.com> parents: 22721 diff changeset	2772 raise ValueError('arg is an empty sequence')
e8832cf1abf6 abstractsmartset: add a default implementation for min and max Pierre-Yves David <pierre-yves.david@fb.com> parents: 22721 diff changeset	2773 return min(self)
22692 78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2774
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2775 def max(self):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2776 """return the maximum element in the set"""
22722 e8832cf1abf6 abstractsmartset: add a default implementation for min and max Pierre-Yves David <pierre-yves.david@fb.com> parents: 22721 diff changeset	2777 if self.fastdesc is not None:
e8832cf1abf6 abstractsmartset: add a default implementation for min and max Pierre-Yves David <pierre-yves.david@fb.com> parents: 22721 diff changeset	2778 for r in self.fastdesc():
e8832cf1abf6 abstractsmartset: add a default implementation for min and max Pierre-Yves David <pierre-yves.david@fb.com> parents: 22721 diff changeset	2779 return r
e8832cf1abf6 abstractsmartset: add a default implementation for min and max Pierre-Yves David <pierre-yves.david@fb.com> parents: 22721 diff changeset	2780 raise ValueError('arg is an empty sequence')
e8832cf1abf6 abstractsmartset: add a default implementation for min and max Pierre-Yves David <pierre-yves.david@fb.com> parents: 22721 diff changeset	2781 return max(self)
22692 78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2782
22808 228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	2783 def first(self):
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	2784 """return the first element in the set (user iteration perspective)
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	2785
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	2786 Return None if the set is empty"""
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	2787 raise NotImplementedError()
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	2788
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	2789 def last(self):
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	2790 """return the last element in the set (user iteration perspective)
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	2791
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	2792 Return None if the set is empty"""
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	2793 raise NotImplementedError()
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	2794
22995 2587631c5f8a revset: make __len__ part of the offical API Pierre-Yves David <pierre-yves.david@fb.com> parents: 22944 diff changeset	2795 def __len__(self):
2587631c5f8a revset: make __len__ part of the offical API Pierre-Yves David <pierre-yves.david@fb.com> parents: 22944 diff changeset	2796 """return the length of the smartsets
2587631c5f8a revset: make __len__ part of the offical API Pierre-Yves David <pierre-yves.david@fb.com> parents: 22944 diff changeset	2797
2587631c5f8a revset: make __len__ part of the offical API Pierre-Yves David <pierre-yves.david@fb.com> parents: 22944 diff changeset	2798 This can be expensive on smartset that could be lazy otherwise."""
2587631c5f8a revset: make __len__ part of the offical API Pierre-Yves David <pierre-yves.david@fb.com> parents: 22944 diff changeset	2799 raise NotImplementedError()
2587631c5f8a revset: make __len__ part of the offical API Pierre-Yves David <pierre-yves.david@fb.com> parents: 22944 diff changeset	2800
22692 78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2801 def reverse(self):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2802 """reverse the expected iteration order"""
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2803 raise NotImplementedError()
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2804
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2805 def sort(self, reverse=True):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2806 """get the set to iterate in an ascending or descending order"""
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2807 raise NotImplementedError()
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2808
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2809 def __and__(self, other):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2810 """Returns a new object with the intersection of the two collections.
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2811
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2812 This is part of the mandatory API for smartset."""
24459 7d369fae098e revset: optimize "x & fullreposet" case Yuya Nishihara <yuya@tcha.org> parents: 24458 diff changeset	2813 if isinstance(other, fullreposet):
7d369fae098e revset: optimize "x & fullreposet" case Yuya Nishihara <yuya@tcha.org> parents: 24458 diff changeset	2814 return self
22864 96b6b3d78697 revset: cache most conditions used in `filter` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22863 diff changeset	2815 return self.filter(other.__contains__, cache=False)
22692 78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2816
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2817 def __add__(self, other):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2818 """Returns a new object with the union of the two collections.
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2819
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2820 This is part of the mandatory API for smartset."""
22861 546fa6576815 revset: restore order of `or` operation as in Mercurial 2.9 Pierre-Yves David <pierre-yves.david@fb.com> parents: 22860 diff changeset	2821 return addset(self, other)
22692 78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2822
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2823 def __sub__(self, other):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2824 """Returns a new object with the substraction of the two collections.
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2825
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2826 This is part of the mandatory API for smartset."""
22730 aeacc2055f0d abstractsmartset: add default implementation for __sub__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22729 diff changeset	2827 c = other.__contains__
22864 96b6b3d78697 revset: cache most conditions used in `filter` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22863 diff changeset	2828 return self.filter(lambda r: not c(r), cache=False)
96b6b3d78697 revset: cache most conditions used in `filter` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22863 diff changeset	2829
96b6b3d78697 revset: cache most conditions used in `filter` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22863 diff changeset	2830 def filter(self, condition, cache=True):
22692 78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2831 """Returns this smartset filtered by condition as a new smartset.
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2832
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2833 `condition` is a callable which takes a revision number and returns a
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2834 boolean.
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2835
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2836 This is part of the mandatory API for smartset."""
22864 96b6b3d78697 revset: cache most conditions used in `filter` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22863 diff changeset	2837 # builtin cannot be cached. but do not needs to
96b6b3d78697 revset: cache most conditions used in `filter` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22863 diff changeset	2838 if cache and util.safehasattr(condition, 'func_code'):
96b6b3d78697 revset: cache most conditions used in `filter` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22863 diff changeset	2839 condition = util.cachefunc(condition)
22862 9e5576f822cc filteredset: drop explicit order management Pierre-Yves David <pierre-yves.david@fb.com> parents: 22861 diff changeset	2840 return filteredset(self, condition)
22692 78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2841
22825 0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	2842 class baseset(abstractsmartset):
20416 e72bcc245ecb revset: added docstring to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20393 diff changeset	2843 """Basic data structure that represents a revset and contains the basic
e72bcc245ecb revset: added docstring to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20393 diff changeset	2844 operation that it should be able to perform.
20727 1e59f760d850 revset: added comments to all methods needed to duck-type from baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20726 diff changeset	2845
1e59f760d850 revset: added comments to all methods needed to duck-type from baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20726 diff changeset	2846 Every method in this class should be implemented by any smartset class.
20416 e72bcc245ecb revset: added docstring to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20393 diff changeset	2847 """
20752 6744f4621434 revset: add a default argument for baseset.__init__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 20751 diff changeset	2848 def __init__(self, data=()):
22825 0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	2849 if not isinstance(data, list):
0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	2850 data = list(data)
0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	2851 self._list = data
22827 c1107cb21df2 baseset: prepare lazy ordering in __iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22826 diff changeset	2852 self._ascending = None
20365 bc770ee6a351 revset: implemented set caching for revset evaluation Lucas Moscovicz <lmoscovicz@fb.com> parents: 20364 diff changeset	2853
22826 4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	2854 @util.propertycache
22879 efe5062145c1 baseset: make `_set` a property cache Pierre-Yves David <pierre-yves.david@fb.com> parents: 22877 diff changeset	2855 def _set(self):
efe5062145c1 baseset: make `_set` a property cache Pierre-Yves David <pierre-yves.david@fb.com> parents: 22877 diff changeset	2856 return set(self._list)
efe5062145c1 baseset: make `_set` a property cache Pierre-Yves David <pierre-yves.david@fb.com> parents: 22877 diff changeset	2857
efe5062145c1 baseset: make `_set` a property cache Pierre-Yves David <pierre-yves.david@fb.com> parents: 22877 diff changeset	2858 @util.propertycache
22826 4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	2859 def _asclist(self):
4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	2860 asclist = self._list[:]
4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	2861 asclist.sort()
4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	2862 return asclist
4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	2863
22827 c1107cb21df2 baseset: prepare lazy ordering in __iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22826 diff changeset	2864 def __iter__(self):
c1107cb21df2 baseset: prepare lazy ordering in __iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22826 diff changeset	2865 if self._ascending is None:
c1107cb21df2 baseset: prepare lazy ordering in __iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22826 diff changeset	2866 return iter(self._list)
c1107cb21df2 baseset: prepare lazy ordering in __iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22826 diff changeset	2867 elif self._ascending:
c1107cb21df2 baseset: prepare lazy ordering in __iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22826 diff changeset	2868 return iter(self._asclist)
c1107cb21df2 baseset: prepare lazy ordering in __iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22826 diff changeset	2869 else:
c1107cb21df2 baseset: prepare lazy ordering in __iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22826 diff changeset	2870 return reversed(self._asclist)
c1107cb21df2 baseset: prepare lazy ordering in __iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22826 diff changeset	2871
22826 4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	2872 def fastasc(self):
4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	2873 return iter(self._asclist)
4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	2874
4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	2875 def fastdesc(self):
4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	2876 return reversed(self._asclist)
4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	2877
22503 300e07582e9b revset: add an optimised baseset.__contains__ (issue4371) Pierre-Yves David <pierre-yves.david@fb.com> parents: 22105 diff changeset	2878 @util.propertycache
300e07582e9b revset: add an optimised baseset.__contains__ (issue4371) Pierre-Yves David <pierre-yves.david@fb.com> parents: 22105 diff changeset	2879 def __contains__(self):
22880 5b635b44af14 baseset: access `_set` directly for containment check Pierre-Yves David <pierre-yves.david@fb.com> parents: 22879 diff changeset	2880 return self._set.__contains__
22503 300e07582e9b revset: add an optimised baseset.__contains__ (issue4371) Pierre-Yves David <pierre-yves.david@fb.com> parents: 22105 diff changeset	2881
22691 d8a08b68f754 revset: add a `__nonzero__` to baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22690 diff changeset	2882 def __nonzero__(self):
22825 0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	2883 return bool(self._list)
0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	2884
0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	2885 def sort(self, reverse=False):
22829 36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	2886 self._ascending = not bool(reverse)
22825 0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	2887
0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	2888 def reverse(self):
22829 36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	2889 if self._ascending is None:
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	2890 self._list.reverse()
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	2891 else:
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	2892 self._ascending = not self._ascending
22825 0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	2893
0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	2894 def __len__(self):
0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	2895 return len(self._list)
22691 d8a08b68f754 revset: add a `__nonzero__` to baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22690 diff changeset	2896
20725 cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	2897 def isascending(self):
20727 1e59f760d850 revset: added comments to all methods needed to duck-type from baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20726 diff changeset	2898 """Returns True if the collection is ascending order, False if not.
1e59f760d850 revset: added comments to all methods needed to duck-type from baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20726 diff changeset	2899
1e59f760d850 revset: added comments to all methods needed to duck-type from baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20726 diff changeset	2900 This is part of the mandatory API for smartset."""
22863 a1a02b516cca baseset: empty or one-element sets are ascending and descending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22862 diff changeset	2901 if len(self) <= 1:
a1a02b516cca baseset: empty or one-element sets are ascending and descending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22862 diff changeset	2902 return True
22828 966860f7a1a8 baseset: fix isascending and isdescending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22827 diff changeset	2903 return self._ascending is not None and self._ascending
20725 cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	2904
cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	2905 def isdescending(self):
20727 1e59f760d850 revset: added comments to all methods needed to duck-type from baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20726 diff changeset	2906 """Returns True if the collection is descending order, False if not.
1e59f760d850 revset: added comments to all methods needed to duck-type from baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20726 diff changeset	2907
1e59f760d850 revset: added comments to all methods needed to duck-type from baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20726 diff changeset	2908 This is part of the mandatory API for smartset."""
22863 a1a02b516cca baseset: empty or one-element sets are ascending and descending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22862 diff changeset	2909 if len(self) <= 1:
a1a02b516cca baseset: empty or one-element sets are ascending and descending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22862 diff changeset	2910 return True
22828 966860f7a1a8 baseset: fix isascending and isdescending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22827 diff changeset	2911 return self._ascending is not None and not self._ascending
20725 cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	2912
22812 fcd12b310148 baseset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22811 diff changeset	2913 def first(self):
fcd12b310148 baseset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22811 diff changeset	2914 if self:
22829 36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	2915 if self._ascending is None:
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	2916 return self._list[0]
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	2917 elif self._ascending:
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	2918 return self._asclist[0]
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	2919 else:
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	2920 return self._asclist[-1]
22812 fcd12b310148 baseset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22811 diff changeset	2921 return None
fcd12b310148 baseset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22811 diff changeset	2922
fcd12b310148 baseset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22811 diff changeset	2923 def last(self):
fcd12b310148 baseset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22811 diff changeset	2924 if self:
22829 36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	2925 if self._ascending is None:
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	2926 return self._list[-1]
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	2927 elif self._ascending:
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	2928 return self._asclist[-1]
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	2929 else:
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	2930 return self._asclist[0]
22812 fcd12b310148 baseset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22811 diff changeset	2931 return None
fcd12b310148 baseset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22811 diff changeset	2932
24457 c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	2933 def __repr__(self):
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	2934 d = {None: '', False: '-', True: '+'}[self._ascending]
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	2935 return '<%s%s %r>' % (type(self).__name__, d, self._list)
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	2936
22726 169aa5e74b52 lazyset: rename the class to filteredset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22725 diff changeset	2937 class filteredset(abstractsmartset):
20427 4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	2938 """Duck type for baseset class which iterates lazily over the revisions in
4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	2939 the subset and contains a function which tests for membership in the
4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	2940 revset
4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	2941 """
22862 9e5576f822cc filteredset: drop explicit order management Pierre-Yves David <pierre-yves.david@fb.com> parents: 22861 diff changeset	2942 def __init__(self, subset, condition=lambda x: True):
20738 33943add5d65 revset: add some documentation for lazyset Pierre-Yves David <pierre-yves.david@fb.com> parents: 20737 diff changeset	2943 """
33943add5d65 revset: add some documentation for lazyset Pierre-Yves David <pierre-yves.david@fb.com> parents: 20737 diff changeset	2944 condition: a function that decide whether a revision in the subset
33943add5d65 revset: add some documentation for lazyset Pierre-Yves David <pierre-yves.david@fb.com> parents: 20737 diff changeset	2945 belongs to the revset or not.
33943add5d65 revset: add some documentation for lazyset Pierre-Yves David <pierre-yves.david@fb.com> parents: 20737 diff changeset	2946 """
20427 4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	2947 self._subset = subset
4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	2948 self._condition = condition
20512 659b8d8ddf19 revset: added cache to lazysets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20499 diff changeset	2949 self._cache = {}
20427 4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	2950
4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	2951 def __contains__(self, x):
20512 659b8d8ddf19 revset: added cache to lazysets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20499 diff changeset	2952 c = self._cache
659b8d8ddf19 revset: added cache to lazysets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20499 diff changeset	2953 if x not in c:
22527 6e38b5d49977 revset: reduce dict lookup in lazyset.__contains__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22526 diff changeset	2954 v = c[x] = x in self._subset and self._condition(x)
6e38b5d49977 revset: reduce dict lookup in lazyset.__contains__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22526 diff changeset	2955 return v
20512 659b8d8ddf19 revset: added cache to lazysets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20499 diff changeset	2956 return c[x]
20427 4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	2957
4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	2958 def __iter__(self):
22719 21fda9dcd4e8 lazyset: split the iteration logic from the condition filtering logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22718 diff changeset	2959 return self._iterfilter(self._subset)
21fda9dcd4e8 lazyset: split the iteration logic from the condition filtering logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22718 diff changeset	2960
21fda9dcd4e8 lazyset: split the iteration logic from the condition filtering logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22718 diff changeset	2961 def _iterfilter(self, it):
20427 4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	2962 cond = self._condition
22719 21fda9dcd4e8 lazyset: split the iteration logic from the condition filtering logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22718 diff changeset	2963 for x in it:
20427 4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	2964 if cond(x):
4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	2965 yield x
4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	2966
22720 4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	2967 @property
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	2968 def fastasc(self):
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	2969 it = self._subset.fastasc
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	2970 if it is None:
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	2971 return None
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	2972 return lambda: self._iterfilter(it())
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	2973
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	2974 @property
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	2975 def fastdesc(self):
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	2976 it = self._subset.fastdesc
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	2977 if it is None:
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	2978 return None
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	2979 return lambda: self._iterfilter(it())
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	2980
20552 0e99a66eb7bc revset: added __nonzero__ method to lazyset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20540 diff changeset	2981 def __nonzero__(self):
0e99a66eb7bc revset: added __nonzero__ method to lazyset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20540 diff changeset	2982 for r in self:
0e99a66eb7bc revset: added __nonzero__ method to lazyset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20540 diff changeset	2983 return True
0e99a66eb7bc revset: added __nonzero__ method to lazyset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20540 diff changeset	2984 return False
0e99a66eb7bc revset: added __nonzero__ method to lazyset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20540 diff changeset	2985
20429 f5b560c60bcd revset: added operations to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20428 diff changeset	2986 def __len__(self):
f5b560c60bcd revset: added operations to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20428 diff changeset	2987 # Basic implementation to be changed in future patches.
f5b560c60bcd revset: added operations to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20428 diff changeset	2988 l = baseset([r for r in self])
f5b560c60bcd revset: added operations to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20428 diff changeset	2989 return len(l)
f5b560c60bcd revset: added operations to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20428 diff changeset	2990
f5b560c60bcd revset: added operations to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20428 diff changeset	2991 def sort(self, reverse=False):
22862 9e5576f822cc filteredset: drop explicit order management Pierre-Yves David <pierre-yves.david@fb.com> parents: 22861 diff changeset	2992 self._subset.sort(reverse=reverse)
20429 f5b560c60bcd revset: added operations to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20428 diff changeset	2993
f5b560c60bcd revset: added operations to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20428 diff changeset	2994 def reverse(self):
f5b560c60bcd revset: added operations to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20428 diff changeset	2995 self._subset.reverse()
f5b560c60bcd revset: added operations to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20428 diff changeset	2996
20725 cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	2997 def isascending(self):
22862 9e5576f822cc filteredset: drop explicit order management Pierre-Yves David <pierre-yves.david@fb.com> parents: 22861 diff changeset	2998 return self._subset.isascending()
20725 cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	2999
cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	3000 def isdescending(self):
22862 9e5576f822cc filteredset: drop explicit order management Pierre-Yves David <pierre-yves.david@fb.com> parents: 22861 diff changeset	3001 return self._subset.isdescending()
20725 cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	3002
22813 5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3003 def first(self):
5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3004 for x in self:
5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3005 return x
5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3006 return None
5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3007
5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3008 def last(self):
5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3009 it = None
22862 9e5576f822cc filteredset: drop explicit order management Pierre-Yves David <pierre-yves.david@fb.com> parents: 22861 diff changeset	3010 if self._subset.isascending:
9e5576f822cc filteredset: drop explicit order management Pierre-Yves David <pierre-yves.david@fb.com> parents: 22861 diff changeset	3011 it = self.fastdesc
9e5576f822cc filteredset: drop explicit order management Pierre-Yves David <pierre-yves.david@fb.com> parents: 22861 diff changeset	3012 elif self._subset.isdescending:
9e5576f822cc filteredset: drop explicit order management Pierre-Yves David <pierre-yves.david@fb.com> parents: 22861 diff changeset	3013 it = self.fastdesc
22813 5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3014 if it is None:
5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3015 # slowly consume everything. This needs improvement
5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3016 it = lambda: reversed(list(self))
5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3017 for x in it():
5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3018 return x
5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3019 return None
5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3020
24457 c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3021 def __repr__(self):
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3022 return '<%s %r>' % (type(self).__name__, self._subset)
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3023
25308 036c26b08b71 revset: add helper to build balanced addsets from chained 'or' operations Yuya Nishihara <yuya@tcha.org> parents: 25307 diff changeset	3024 # this function will be removed, or merged to addset or orset, when
036c26b08b71 revset: add helper to build balanced addsets from chained 'or' operations Yuya Nishihara <yuya@tcha.org> parents: 25307 diff changeset	3025 # - scmutil.revrange() can be rewritten to not combine calculated smartsets
036c26b08b71 revset: add helper to build balanced addsets from chained 'or' operations Yuya Nishihara <yuya@tcha.org> parents: 25307 diff changeset	3026 # - or addset can handle more than two sets without balanced tree
036c26b08b71 revset: add helper to build balanced addsets from chained 'or' operations Yuya Nishihara <yuya@tcha.org> parents: 25307 diff changeset	3027 def _combinesets(subsets):
036c26b08b71 revset: add helper to build balanced addsets from chained 'or' operations Yuya Nishihara <yuya@tcha.org> parents: 25307 diff changeset	3028 """Create balanced tree of addsets representing union of given sets"""
036c26b08b71 revset: add helper to build balanced addsets from chained 'or' operations Yuya Nishihara <yuya@tcha.org> parents: 25307 diff changeset	3029 if not subsets:
036c26b08b71 revset: add helper to build balanced addsets from chained 'or' operations Yuya Nishihara <yuya@tcha.org> parents: 25307 diff changeset	3030 return baseset()
036c26b08b71 revset: add helper to build balanced addsets from chained 'or' operations Yuya Nishihara <yuya@tcha.org> parents: 25307 diff changeset	3031 if len(subsets) == 1:
036c26b08b71 revset: add helper to build balanced addsets from chained 'or' operations Yuya Nishihara <yuya@tcha.org> parents: 25307 diff changeset	3032 return subsets[0]
036c26b08b71 revset: add helper to build balanced addsets from chained 'or' operations Yuya Nishihara <yuya@tcha.org> parents: 25307 diff changeset	3033 p = len(subsets) // 2
036c26b08b71 revset: add helper to build balanced addsets from chained 'or' operations Yuya Nishihara <yuya@tcha.org> parents: 25307 diff changeset	3034 xs = _combinesets(subsets[:p])
036c26b08b71 revset: add helper to build balanced addsets from chained 'or' operations Yuya Nishihara <yuya@tcha.org> parents: 25307 diff changeset	3035 ys = _combinesets(subsets[p:])
036c26b08b71 revset: add helper to build balanced addsets from chained 'or' operations Yuya Nishihara <yuya@tcha.org> parents: 25307 diff changeset	3036 return addset(xs, ys)
036c26b08b71 revset: add helper to build balanced addsets from chained 'or' operations Yuya Nishihara <yuya@tcha.org> parents: 25307 diff changeset	3037
25131 adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3038 def _iterordered(ascending, iter1, iter2):
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3039 """produce an ordered iteration from two iterators with the same order
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3040
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3041 The ascending is used to indicated the iteration direction.
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3042 """
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3043 choice = max
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3044 if ascending:
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3045 choice = min
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3046
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3047 val1 = None
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3048 val2 = None
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3049 try:
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3050 # Consume both iterators in an ordered way until one is empty
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3051 while True:
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3052 if val1 is None:
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3053 val1 = iter1.next()
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3054 if val2 is None:
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3055 val2 = iter2.next()
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3056 next = choice(val1, val2)
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3057 yield next
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3058 if val1 == next:
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3059 val1 = None
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3060 if val2 == next:
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3061 val2 = None
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3062 except StopIteration:
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3063 # Flush any remaining values and consume the other one
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3064 it = iter2
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3065 if val1 is not None:
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3066 yield val1
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3067 it = iter1
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3068 elif val2 is not None:
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3069 # might have been equality and both are empty
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3070 yield val2
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3071 for val in it:
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3072 yield val
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3073
22793 ff6689b47e48 addset: drop the leading underscore from the class name Pierre-Yves David <pierre-yves.david@fb.com> parents: 22792 diff changeset	3074 class addset(abstractsmartset):
20708 17c89e5a5627 revset: made addset a private class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20707 diff changeset	3075 """Represent the addition of two sets
17c89e5a5627 revset: made addset a private class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20707 diff changeset	3076
17c89e5a5627 revset: made addset a private class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20707 diff changeset	3077 Wrapper structure for lazily adding two structures without losing much
20694 621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3078 performance on the __contains__ method
20708 17c89e5a5627 revset: made addset a private class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20707 diff changeset	3079
20712 c152e538b85b revset: added ascending attribute to addset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20711 diff changeset	3080 If the ascending attribute is set, that means the two structures are
c152e538b85b revset: added ascending attribute to addset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20711 diff changeset	3081 ordered in either an ascending or descending way. Therefore, we can add
21024 7731a2281cf0 spelling: fixes from spell checker Mads Kiilerich <madski@unity3d.com> parents: 20991 diff changeset	3082 them maintaining the order by iterating over both at the same time
25024 263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3083
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3084 >>> xs = baseset([0, 3, 2])
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3085 >>> ys = baseset([5, 2, 4])
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3086
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3087 >>> rs = addset(xs, ys)
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3088 >>> bool(rs), 0 in rs, 1 in rs, 5 in rs, rs.first(), rs.last()
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3089 (True, True, False, True, 0, 4)
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3090 >>> rs = addset(xs, baseset([]))
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3091 >>> bool(rs), 0 in rs, 1 in rs, rs.first(), rs.last()
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3092 (True, True, False, 0, 2)
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3093 >>> rs = addset(baseset([]), baseset([]))
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3094 >>> bool(rs), 0 in rs, rs.first(), rs.last()
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3095 (False, False, None, None)
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3096
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3097 iterate unsorted:
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3098 >>> rs = addset(xs, ys)
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3099 >>> [x for x in rs] # without _genlist
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3100 [0, 3, 2, 5, 4]
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3101 >>> assert not rs._genlist
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3102 >>> len(rs)
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3103 5
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3104 >>> [x for x in rs] # with _genlist
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3105 [0, 3, 2, 5, 4]
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3106 >>> assert rs._genlist
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3107
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3108 iterate ascending:
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3109 >>> rs = addset(xs, ys, ascending=True)
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3110 >>> [x for x in rs], [x for x in rs.fastasc()] # without _asclist
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3111 ([0, 2, 3, 4, 5], [0, 2, 3, 4, 5])
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3112 >>> assert not rs._asclist
25115 5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3113 >>> len(rs)
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3114 5
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3115 >>> [x for x in rs], [x for x in rs.fastasc()]
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3116 ([0, 2, 3, 4, 5], [0, 2, 3, 4, 5])
25024 263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3117 >>> assert rs._asclist
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3118
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3119 iterate descending:
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3120 >>> rs = addset(xs, ys, ascending=False)
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3121 >>> [x for x in rs], [x for x in rs.fastdesc()] # without _asclist
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3122 ([5, 4, 3, 2, 0], [5, 4, 3, 2, 0])
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3123 >>> assert not rs._asclist
25115 5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3124 >>> len(rs)
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3125 5
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3126 >>> [x for x in rs], [x for x in rs.fastdesc()]
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3127 ([5, 4, 3, 2, 0], [5, 4, 3, 2, 0])
25024 263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3128 >>> assert rs._asclist
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3129
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3130 iterate ascending without fastasc:
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3131 >>> rs = addset(xs, generatorset(ys), ascending=True)
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3132 >>> assert rs.fastasc is None
25115 5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3133 >>> [x for x in rs]
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3134 [0, 2, 3, 4, 5]
25024 263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3135
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3136 iterate descending without fastdesc:
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3137 >>> rs = addset(generatorset(xs), ys, ascending=False)
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3138 >>> assert rs.fastdesc is None
25115 5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3139 >>> [x for x in rs]
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3140 [5, 4, 3, 2, 0]
20694 621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3141 """
20712 c152e538b85b revset: added ascending attribute to addset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20711 diff changeset	3142 def __init__(self, revs1, revs2, ascending=None):
20694 621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3143 self._r1 = revs1
621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3144 self._r2 = revs2
621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3145 self._iter = None
20712 c152e538b85b revset: added ascending attribute to addset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20711 diff changeset	3146 self._ascending = ascending
20720 5f8400efca0b revset: added cached generated list to addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20719 diff changeset	3147 self._genlist = None
22859 513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3148 self._asclist = None
20720 5f8400efca0b revset: added cached generated list to addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20719 diff changeset	3149
20845 bc95143446e8 _addset: add a __len__ method Pierre-Yves David <pierre-yves.david@fb.com> parents: 20833 diff changeset	3150 def __len__(self):
bc95143446e8 _addset: add a __len__ method Pierre-Yves David <pierre-yves.david@fb.com> parents: 20833 diff changeset	3151 return len(self._list)
bc95143446e8 _addset: add a __len__ method Pierre-Yves David <pierre-yves.david@fb.com> parents: 20833 diff changeset	3152
22743 eccf9907b844 addset: add a __nonzero__ method Pierre-Yves David <pierre-yves.david@fb.com> parents: 22742 diff changeset	3153 def __nonzero__(self):
23100 ac494b087feb revset: fix O(2^n) perf regression in addset Durham Goode <durham@fb.com> parents: 23078 diff changeset	3154 return bool(self._r1) or bool(self._r2)
22743 eccf9907b844 addset: add a __nonzero__ method Pierre-Yves David <pierre-yves.david@fb.com> parents: 22742 diff changeset	3155
20720 5f8400efca0b revset: added cached generated list to addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20719 diff changeset	3156 @util.propertycache
5f8400efca0b revset: added cached generated list to addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20719 diff changeset	3157 def _list(self):
5f8400efca0b revset: added cached generated list to addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20719 diff changeset	3158 if not self._genlist:
25115 5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3159 self._genlist = baseset(iter(self))
20720 5f8400efca0b revset: added cached generated list to addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20719 diff changeset	3160 return self._genlist
20694 621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3161
25115 5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3162 def __iter__(self):
20722 6894223ebc38 revset: changed _iterator() method on addset to work with a given order Lucas Moscovicz <lmoscovicz@fb.com> parents: 20721 diff changeset	3163 """Iterate over both collections without repeating elements
6894223ebc38 revset: changed _iterator() method on addset to work with a given order Lucas Moscovicz <lmoscovicz@fb.com> parents: 20721 diff changeset	3164
6894223ebc38 revset: changed _iterator() method on addset to work with a given order Lucas Moscovicz <lmoscovicz@fb.com> parents: 20721 diff changeset	3165 If the ascending attribute is not set, iterate over the first one and
6894223ebc38 revset: changed _iterator() method on addset to work with a given order Lucas Moscovicz <lmoscovicz@fb.com> parents: 20721 diff changeset	3166 then over the second one checking for membership on the first one so we
6894223ebc38 revset: changed _iterator() method on addset to work with a given order Lucas Moscovicz <lmoscovicz@fb.com> parents: 20721 diff changeset	3167 dont yield any duplicates.
6894223ebc38 revset: changed _iterator() method on addset to work with a given order Lucas Moscovicz <lmoscovicz@fb.com> parents: 20721 diff changeset	3168
6894223ebc38 revset: changed _iterator() method on addset to work with a given order Lucas Moscovicz <lmoscovicz@fb.com> parents: 20721 diff changeset	3169 If the ascending attribute is set, iterate over both collections at the
6894223ebc38 revset: changed _iterator() method on addset to work with a given order Lucas Moscovicz <lmoscovicz@fb.com> parents: 20721 diff changeset	3170 same time, yielding only one value at a time in the given order.
6894223ebc38 revset: changed _iterator() method on addset to work with a given order Lucas Moscovicz <lmoscovicz@fb.com> parents: 20721 diff changeset	3171 """
22799 bafa371d7af3 addset: drop caching through generatorset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22798 diff changeset	3172 if self._ascending is None:
25115 5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3173 if self._genlist:
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3174 return iter(self._genlist)
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3175 def arbitraryordergen():
22799 bafa371d7af3 addset: drop caching through generatorset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22798 diff changeset	3176 for r in self._r1:
bafa371d7af3 addset: drop caching through generatorset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22798 diff changeset	3177 yield r
22881 057ebf7714e1 addset: drop `.set()` usage during iteration Pierre-Yves David <pierre-yves.david@fb.com> parents: 22880 diff changeset	3178 inr1 = self._r1.__contains__
22799 bafa371d7af3 addset: drop caching through generatorset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22798 diff changeset	3179 for r in self._r2:
22881 057ebf7714e1 addset: drop `.set()` usage during iteration Pierre-Yves David <pierre-yves.david@fb.com> parents: 22880 diff changeset	3180 if not inr1(r):
20694 621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3181 yield r
25115 5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3182 return arbitraryordergen()
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3183 # try to use our own fast iterator if it exists
22859 513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3184 self._trysetasclist()
513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3185 if self._ascending:
25130 a94ef7f517e0 revset: use fastasc/fastdesc switch consistently in addset.__iter__ Yuya Nishihara <yuya@tcha.org> parents: 25129 diff changeset	3186 attr = 'fastasc'
22859 513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3187 else:
25130 a94ef7f517e0 revset: use fastasc/fastdesc switch consistently in addset.__iter__ Yuya Nishihara <yuya@tcha.org> parents: 25129 diff changeset	3188 attr = 'fastdesc'
a94ef7f517e0 revset: use fastasc/fastdesc switch consistently in addset.__iter__ Yuya Nishihara <yuya@tcha.org> parents: 25129 diff changeset	3189 it = getattr(self, attr)
25115 5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3190 if it is not None:
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3191 return it()
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3192 # maybe half of the component supports fast
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3193 # get iterator for _r1
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3194 iter1 = getattr(self._r1, attr)
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3195 if iter1 is None:
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3196 # let's avoid side effect (not sure it matters)
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3197 iter1 = iter(sorted(self._r1, reverse=not self._ascending))
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3198 else:
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3199 iter1 = iter1()
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3200 # get iterator for _r2
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3201 iter2 = getattr(self._r2, attr)
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3202 if iter2 is None:
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3203 # let's avoid side effect (not sure it matters)
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3204 iter2 = iter(sorted(self._r2, reverse=not self._ascending))
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3205 else:
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3206 iter2 = iter2()
25131 adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3207 return _iterordered(self._ascending, iter1, iter2)
22859 513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3208
513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3209 def _trysetasclist(self):
23139 e53f6b72a0e4 spelling: fixes from proofreading of spell checker issues Mads Kiilerich <madski@unity3d.com> parents: 23127 diff changeset	3210 """populate the _asclist attribute if possible and necessary"""
22859 513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3211 if self._genlist is not None and self._asclist is None:
513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3212 self._asclist = sorted(self._genlist)
20694 621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3213
22742 6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3214 @property
6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3215 def fastasc(self):
22859 513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3216 self._trysetasclist()
513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3217 if self._asclist is not None:
513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3218 return self._asclist.__iter__
22742 6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3219 iter1 = self._r1.fastasc
6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3220 iter2 = self._r2.fastasc
6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3221 if None in (iter1, iter2):
6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3222 return None
25131 adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3223 return lambda: _iterordered(True, iter1(), iter2())
22742 6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3224
6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3225 @property
6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3226 def fastdesc(self):
22859 513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3227 self._trysetasclist()
513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3228 if self._asclist is not None:
513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3229 return self._asclist.__reversed__
22742 6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3230 iter1 = self._r1.fastdesc
6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3231 iter2 = self._r2.fastdesc
6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3232 if None in (iter1, iter2):
6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3233 return None
25131 adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3234 return lambda: _iterordered(False, iter1(), iter2())
22741 ef2c1ea8fb2c addset: split simple and ordered iteration Pierre-Yves David <pierre-yves.david@fb.com> parents: 22740 diff changeset	3235
20694 621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3236 def __contains__(self, x):
621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3237 return x in self._r1 or x in self._r2
621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3238
20724 e9a64b3f2925 revset: added sort method in addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20723 diff changeset	3239 def sort(self, reverse=False):
e9a64b3f2925 revset: added sort method in addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20723 diff changeset	3240 """Sort the added set
e9a64b3f2925 revset: added sort method in addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20723 diff changeset	3241
e9a64b3f2925 revset: added sort method in addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20723 diff changeset	3242 For this we use the cached list with all the generated values and if we
e9a64b3f2925 revset: added sort method in addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20723 diff changeset	3243 know they are ascending or descending we can sort them in a smart way.
e9a64b3f2925 revset: added sort method in addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20723 diff changeset	3244 """
22859 513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3245 self._ascending = not reverse
20724 e9a64b3f2925 revset: added sort method in addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20723 diff changeset	3246
20733 adf4ec7e6f60 revset: added isascending and isdescending methods to _addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20732 diff changeset	3247 def isascending(self):
adf4ec7e6f60 revset: added isascending and isdescending methods to _addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20732 diff changeset	3248 return self._ascending is not None and self._ascending
adf4ec7e6f60 revset: added isascending and isdescending methods to _addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20732 diff changeset	3249
adf4ec7e6f60 revset: added isascending and isdescending methods to _addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20732 diff changeset	3250 def isdescending(self):
adf4ec7e6f60 revset: added isascending and isdescending methods to _addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20732 diff changeset	3251 return self._ascending is not None and not self._ascending
adf4ec7e6f60 revset: added isascending and isdescending methods to _addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20732 diff changeset	3252
20723 fb9852c46a42 revset: added reverse method to addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20722 diff changeset	3253 def reverse(self):
22859 513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3254 if self._ascending is None:
513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3255 self._list.reverse()
513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3256 else:
20723 fb9852c46a42 revset: added reverse method to addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20722 diff changeset	3257 self._ascending = not self._ascending
fb9852c46a42 revset: added reverse method to addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20722 diff changeset	3258
22810 7f97cb12782f addset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22809 diff changeset	3259 def first(self):
23127 7361d8244efb addset: fix `first` and `last` on sorted addset (issue4426) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23115 diff changeset	3260 for x in self:
7361d8244efb addset: fix `first` and `last` on sorted addset (issue4426) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23115 diff changeset	3261 return x
22810 7f97cb12782f addset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22809 diff changeset	3262 return None
7f97cb12782f addset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22809 diff changeset	3263
7f97cb12782f addset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22809 diff changeset	3264 def last(self):
23127 7361d8244efb addset: fix `first` and `last` on sorted addset (issue4426) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23115 diff changeset	3265 self.reverse()
7361d8244efb addset: fix `first` and `last` on sorted addset (issue4426) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23115 diff changeset	3266 val = self.first()
7361d8244efb addset: fix `first` and `last` on sorted addset (issue4426) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23115 diff changeset	3267 self.reverse()
7361d8244efb addset: fix `first` and `last` on sorted addset (issue4426) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23115 diff changeset	3268 return val
22810 7f97cb12782f addset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22809 diff changeset	3269
24457 c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3270 def __repr__(self):
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3271 d = {None: '', False: '-', True: '+'}[self._ascending]
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3272 return '<%s%s %r, %r>' % (type(self).__name__, d, self._r1, self._r2)
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3273
22795 c21342159fad generatorset: drop the leading underscore in the class name Pierre-Yves David <pierre-yves.david@fb.com> parents: 22794 diff changeset	3274 class generatorset(abstractsmartset):
20705 9cc2249a9461 revset: made generatorset a private class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20703 diff changeset	3275 """Wrap a generator for lazy iteration
9cc2249a9461 revset: made generatorset a private class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20703 diff changeset	3276
9cc2249a9461 revset: made generatorset a private class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20703 diff changeset	3277 Wrapper structure for generators that provides lazy membership and can
20540 fa16c710a3d8 revset: added cached generated list on generatorset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20538 diff changeset	3278 be iterated more than once.
fa16c710a3d8 revset: added cached generated list on generatorset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20538 diff changeset	3279 When asked for membership it generates values until either it finds the
fa16c710a3d8 revset: added cached generated list on generatorset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20538 diff changeset	3280 requested one or has gone through all the elements in the generator
fa16c710a3d8 revset: added cached generated list on generatorset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20538 diff changeset	3281 """
22755 f9a825b593be generatorset: make it possible to use gen as fastasc or fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22754 diff changeset	3282 def __init__(self, gen, iterasc=None):
20739 1b4f2399f3c4 revset: add documentation and comment for _generatorset Pierre-Yves David <pierre-yves.david@fb.com> parents: 20738 diff changeset	3283 """
1b4f2399f3c4 revset: add documentation and comment for _generatorset Pierre-Yves David <pierre-yves.david@fb.com> parents: 20738 diff changeset	3284 gen: a generator producing the values for the generatorset.
1b4f2399f3c4 revset: add documentation and comment for _generatorset Pierre-Yves David <pierre-yves.david@fb.com> parents: 20738 diff changeset	3285 """
20536 532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3286 self._gen = gen
22798 586d7058ea48 generatorset: get list-based fast iterations after the generator is consumed Pierre-Yves David <pierre-yves.david@fb.com> parents: 22797 diff changeset	3287 self._asclist = None
20536 532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3288 self._cache = {}
22796 43f664bf2e1e generatorset: stop using a base as the _genlist Pierre-Yves David <pierre-yves.david@fb.com> parents: 22795 diff changeset	3289 self._genlist = []
20703 e07b1fd30805 revset: added sort methods to generatorsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20695 diff changeset	3290 self._finished = False
22800 29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3291 self._ascending = True
22755 f9a825b593be generatorset: make it possible to use gen as fastasc or fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22754 diff changeset	3292 if iterasc is not None:
f9a825b593be generatorset: make it possible to use gen as fastasc or fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22754 diff changeset	3293 if iterasc:
22797 61ecabeeadb3 generatorset: move iteration code into _iterator Pierre-Yves David <pierre-yves.david@fb.com> parents: 22796 diff changeset	3294 self.fastasc = self._iterator
22757 d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3295 self.__contains__ = self._asccontains
22755 f9a825b593be generatorset: make it possible to use gen as fastasc or fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22754 diff changeset	3296 else:
22797 61ecabeeadb3 generatorset: move iteration code into _iterator Pierre-Yves David <pierre-yves.david@fb.com> parents: 22796 diff changeset	3297 self.fastdesc = self._iterator
22757 d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3298 self.__contains__ = self._desccontains
20540 fa16c710a3d8 revset: added cached generated list on generatorset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20538 diff changeset	3299
22739 4ed47a1b2d24 generatorset: implement __nonzero__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22738 diff changeset	3300 def __nonzero__(self):
24936 2aa94b6fe51c revset: make generatorset.__nonzero__ lazy Pierre-Yves David <pierre-yves.david@fb.com> parents: 24932 diff changeset	3301 # Do not use 'for r in self' because it will enforce the iteration
2aa94b6fe51c revset: make generatorset.__nonzero__ lazy Pierre-Yves David <pierre-yves.david@fb.com> parents: 24932 diff changeset	3302 # order (default ascending), possibly unrolling a whole descending
2aa94b6fe51c revset: make generatorset.__nonzero__ lazy Pierre-Yves David <pierre-yves.david@fb.com> parents: 24932 diff changeset	3303 # iterator.
2aa94b6fe51c revset: make generatorset.__nonzero__ lazy Pierre-Yves David <pierre-yves.david@fb.com> parents: 24932 diff changeset	3304 if self._genlist:
2aa94b6fe51c revset: make generatorset.__nonzero__ lazy Pierre-Yves David <pierre-yves.david@fb.com> parents: 24932 diff changeset	3305 return True
2aa94b6fe51c revset: make generatorset.__nonzero__ lazy Pierre-Yves David <pierre-yves.david@fb.com> parents: 24932 diff changeset	3306 for r in self._consumegen():
22739 4ed47a1b2d24 generatorset: implement __nonzero__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22738 diff changeset	3307 return True
4ed47a1b2d24 generatorset: implement __nonzero__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22738 diff changeset	3308 return False
4ed47a1b2d24 generatorset: implement __nonzero__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22738 diff changeset	3309
20536 532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3310 def __contains__(self, x):
532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3311 if x in self._cache:
532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3312 return self._cache[x]
532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3313
20828 3210b7930899 revset: improve performance of _generatorset.__contains__ (issue 4201) Gregory Szorc <gregory.szorc@gmail.com> parents: 20780 diff changeset	3314 # Use new values only, as existing values would be cached.
3210b7930899 revset: improve performance of _generatorset.__contains__ (issue 4201) Gregory Szorc <gregory.szorc@gmail.com> parents: 20780 diff changeset	3315 for l in self._consumegen():
20634 f2bb7ba59456 revset: changed generatorset code to remove unnecesary function call Lucas Moscovicz <lmoscovicz@fb.com> parents: 20613 diff changeset	3316 if l == x:
f2bb7ba59456 revset: changed generatorset code to remove unnecesary function call Lucas Moscovicz <lmoscovicz@fb.com> parents: 20613 diff changeset	3317 return True
20536 532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3318
532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3319 self._cache[x] = False
532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3320 return False
532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3321
22757 d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3322 def _asccontains(self, x):
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3323 """version of contains optimised for ascending generator"""
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3324 if x in self._cache:
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3325 return self._cache[x]
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3326
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3327 # Use new values only, as existing values would be cached.
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3328 for l in self._consumegen():
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3329 if l == x:
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3330 return True
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3331 if l > x:
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3332 break
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3333
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3334 self._cache[x] = False
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3335 return False
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3336
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3337 def _desccontains(self, x):
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3338 """version of contains optimised for descending generator"""
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3339 if x in self._cache:
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3340 return self._cache[x]
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3341
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3342 # Use new values only, as existing values would be cached.
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3343 for l in self._consumegen():
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3344 if l == x:
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3345 return True
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3346 if l < x:
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3347 break
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3348
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3349 self._cache[x] = False
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3350 return False
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3351
20536 532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3352 def __iter__(self):
22800 29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3353 if self._ascending:
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3354 it = self.fastasc
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3355 else:
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3356 it = self.fastdesc
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3357 if it is not None:
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3358 return it()
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3359 # we need to consume the iterator
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3360 for x in self._consumegen():
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3361 pass
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3362 # recall the same code
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3363 return iter(self)
22797 61ecabeeadb3 generatorset: move iteration code into _iterator Pierre-Yves David <pierre-yves.david@fb.com> parents: 22796 diff changeset	3364
61ecabeeadb3 generatorset: move iteration code into _iterator Pierre-Yves David <pierre-yves.david@fb.com> parents: 22796 diff changeset	3365 def _iterator(self):
20833 47d43e2323c5 revset: fix generatorset race condition Durham Goode <durham@fb.com> parents: 20829 diff changeset	3366 if self._finished:
22670 44dce874de97 revset: rely on built in iterator when possible in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22669 diff changeset	3367 return iter(self._genlist)
20833 47d43e2323c5 revset: fix generatorset race condition Durham Goode <durham@fb.com> parents: 20829 diff changeset	3368
22494 14f6cebfcb8a revset: document the choice made in __generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22487 diff changeset	3369 # We have to use this complex iteration strategy to allow multiple
14f6cebfcb8a revset: document the choice made in __generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22487 diff changeset	3370 # iterations at the same time. We need to be able to catch revision
23139 e53f6b72a0e4 spelling: fixes from proofreading of spell checker issues Mads Kiilerich <madski@unity3d.com> parents: 23127 diff changeset	3371 # removed from _consumegen and added to genlist in another instance.
22494 14f6cebfcb8a revset: document the choice made in __generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22487 diff changeset	3372 #
14f6cebfcb8a revset: document the choice made in __generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22487 diff changeset	3373 # Getting rid of it would provide an about 15% speed up on this
14f6cebfcb8a revset: document the choice made in __generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22487 diff changeset	3374 # iteration.
20833 47d43e2323c5 revset: fix generatorset race condition Durham Goode <durham@fb.com> parents: 20829 diff changeset	3375 genlist = self._genlist
22669 00c8abe64cf3 revset: prefetch an attribute in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22539 diff changeset	3376 nextrev = self._consumegen().next
00c8abe64cf3 revset: prefetch an attribute in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22539 diff changeset	3377 _len = len # cache global lookup
22670 44dce874de97 revset: rely on built in iterator when possible in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22669 diff changeset	3378 def gen():
44dce874de97 revset: rely on built in iterator when possible in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22669 diff changeset	3379 i = 0
44dce874de97 revset: rely on built in iterator when possible in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22669 diff changeset	3380 while True:
44dce874de97 revset: rely on built in iterator when possible in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22669 diff changeset	3381 if i < _len(genlist):
44dce874de97 revset: rely on built in iterator when possible in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22669 diff changeset	3382 yield genlist[i]
44dce874de97 revset: rely on built in iterator when possible in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22669 diff changeset	3383 else:
44dce874de97 revset: rely on built in iterator when possible in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22669 diff changeset	3384 yield nextrev()
44dce874de97 revset: rely on built in iterator when possible in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22669 diff changeset	3385 i += 1
44dce874de97 revset: rely on built in iterator when possible in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22669 diff changeset	3386 return gen()
20828 3210b7930899 revset: improve performance of _generatorset.__contains__ (issue 4201) Gregory Szorc <gregory.szorc@gmail.com> parents: 20780 diff changeset	3387
3210b7930899 revset: improve performance of _generatorset.__contains__ (issue 4201) Gregory Szorc <gregory.szorc@gmail.com> parents: 20780 diff changeset	3388 def _consumegen(self):
22528 b6dc3b79bb25 revset: avoid in loop lookup in _generatorset._consumegen Pierre-Yves David <pierre-yves.david@fb.com> parents: 22527 diff changeset	3389 cache = self._cache
b6dc3b79bb25 revset: avoid in loop lookup in _generatorset._consumegen Pierre-Yves David <pierre-yves.david@fb.com> parents: 22527 diff changeset	3390 genlist = self._genlist.append
20634 f2bb7ba59456 revset: changed generatorset code to remove unnecesary function call Lucas Moscovicz <lmoscovicz@fb.com> parents: 20613 diff changeset	3391 for item in self._gen:
22528 b6dc3b79bb25 revset: avoid in loop lookup in _generatorset._consumegen Pierre-Yves David <pierre-yves.david@fb.com> parents: 22527 diff changeset	3392 cache[item] = True
b6dc3b79bb25 revset: avoid in loop lookup in _generatorset._consumegen Pierre-Yves David <pierre-yves.david@fb.com> parents: 22527 diff changeset	3393 genlist(item)
20634 f2bb7ba59456 revset: changed generatorset code to remove unnecesary function call Lucas Moscovicz <lmoscovicz@fb.com> parents: 20613 diff changeset	3394 yield item
22798 586d7058ea48 generatorset: get list-based fast iterations after the generator is consumed Pierre-Yves David <pierre-yves.david@fb.com> parents: 22797 diff changeset	3395 if not self._finished:
586d7058ea48 generatorset: get list-based fast iterations after the generator is consumed Pierre-Yves David <pierre-yves.david@fb.com> parents: 22797 diff changeset	3396 self._finished = True
586d7058ea48 generatorset: get list-based fast iterations after the generator is consumed Pierre-Yves David <pierre-yves.david@fb.com> parents: 22797 diff changeset	3397 asc = self._genlist[:]
586d7058ea48 generatorset: get list-based fast iterations after the generator is consumed Pierre-Yves David <pierre-yves.david@fb.com> parents: 22797 diff changeset	3398 asc.sort()
586d7058ea48 generatorset: get list-based fast iterations after the generator is consumed Pierre-Yves David <pierre-yves.david@fb.com> parents: 22797 diff changeset	3399 self._asclist = asc
586d7058ea48 generatorset: get list-based fast iterations after the generator is consumed Pierre-Yves David <pierre-yves.david@fb.com> parents: 22797 diff changeset	3400 self.fastasc = asc.__iter__
586d7058ea48 generatorset: get list-based fast iterations after the generator is consumed Pierre-Yves David <pierre-yves.david@fb.com> parents: 22797 diff changeset	3401 self.fastdesc = asc.__reversed__
20703 e07b1fd30805 revset: added sort methods to generatorsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20695 diff changeset	3402
22996 a43d929d1fa1 generatorset: implement __len__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22995 diff changeset	3403 def __len__(self):
a43d929d1fa1 generatorset: implement __len__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22995 diff changeset	3404 for x in self._consumegen():
a43d929d1fa1 generatorset: implement __len__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22995 diff changeset	3405 pass
a43d929d1fa1 generatorset: implement __len__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22995 diff changeset	3406 return len(self._genlist)
a43d929d1fa1 generatorset: implement __len__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22995 diff changeset	3407
20703 e07b1fd30805 revset: added sort methods to generatorsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20695 diff changeset	3408 def sort(self, reverse=False):
22800 29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3409 self._ascending = not reverse
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3410
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3411 def reverse(self):
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3412 self._ascending = not self._ascending
20703 e07b1fd30805 revset: added sort methods to generatorsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20695 diff changeset	3413
22801 6af9e9b6af39 generatorset: implement isascending and isdescending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22800 diff changeset	3414 def isascending(self):
6af9e9b6af39 generatorset: implement isascending and isdescending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22800 diff changeset	3415 return self._ascending
6af9e9b6af39 generatorset: implement isascending and isdescending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22800 diff changeset	3416
6af9e9b6af39 generatorset: implement isascending and isdescending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22800 diff changeset	3417 def isdescending(self):
6af9e9b6af39 generatorset: implement isascending and isdescending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22800 diff changeset	3418 return not self._ascending
6af9e9b6af39 generatorset: implement isascending and isdescending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22800 diff changeset	3419
22811 c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3420 def first(self):
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3421 if self._ascending:
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3422 it = self.fastasc
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3423 else:
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3424 it = self.fastdesc
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3425 if it is None:
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3426 # we need to consume all and try again
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3427 for x in self._consumegen():
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3428 pass
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3429 return self.first()
25146 f542a2c89b60 generatorset: use 'next()' to simplify the code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25145 diff changeset	3430 return next(it(), None)
22811 c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3431
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3432 def last(self):
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3433 if self._ascending:
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3434 it = self.fastdesc
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3435 else:
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3436 it = self.fastasc
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3437 if it is None:
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3438 # we need to consume all and try again
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3439 for x in self._consumegen():
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3440 pass
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3441 return self.first()
25146 f542a2c89b60 generatorset: use 'next()' to simplify the code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25145 diff changeset	3442 return next(it(), None)
22811 c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3443
24457 c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3444 def __repr__(self):
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3445 d = {False: '-', True: '+'}[self._ascending]
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3446 return '<%s%s>' % (type(self).__name__, d)
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3447
24116 8b90a60181d1 revset: drop factory that promotes spanset to fullreposet Yuya Nishihara <yuya@tcha.org> parents: 24115 diff changeset	3448 class spanset(abstractsmartset):
20482 a979078bd788 revset: added spanset class to represent revision ranges Lucas Moscovicz <lmoscovicz@fb.com> parents: 20481 diff changeset	3449 """Duck type for baseset class which represents a range of revisions and
a979078bd788 revset: added spanset class to represent revision ranges Lucas Moscovicz <lmoscovicz@fb.com> parents: 20481 diff changeset	3450 can work lazily and without having all the range in memory
20737 b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3451
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3452 Note that spanset(x, y) behave almost like xrange(x, y) except for two
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3453 notable points:
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3454 - when x < y it will be automatically descending,
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3455 - revision filtered with this repoview will be skipped.
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3456
20482 a979078bd788 revset: added spanset class to represent revision ranges Lucas Moscovicz <lmoscovicz@fb.com> parents: 20481 diff changeset	3457 """
20525 aa73a6327df4 revset: changed spanset to take a repo argument Lucas Moscovicz <lmoscovicz@fb.com> parents: 20521 diff changeset	3458 def __init__(self, repo, start=0, end=None):
20737 b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3459 """
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3460 start: first revision included the set
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3461 (default to 0)
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3462 end: first revision excluded (last+1)
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3463 (default to len(repo)
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3464
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3465 Spanset will be descending if `end` < `start`.
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3466 """
22717 b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3467 if end is None:
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3468 end = len(repo)
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3469 self._ascending = start <= end
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3470 if not self._ascending:
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3471 start, end = end + 1, start +1
20482 a979078bd788 revset: added spanset class to represent revision ranges Lucas Moscovicz <lmoscovicz@fb.com> parents: 20481 diff changeset	3472 self._start = start
22717 b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3473 self._end = end
20525 aa73a6327df4 revset: changed spanset to take a repo argument Lucas Moscovicz <lmoscovicz@fb.com> parents: 20521 diff changeset	3474 self._hiddenrevs = repo.changelog.filteredrevs
20521 1850a7f5fb66 revset: changed spanset implementation to take hidden revisions into account Lucas Moscovicz <lmoscovicz@fb.com> parents: 20512 diff changeset	3475
22717 b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3476 def sort(self, reverse=False):
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3477 self._ascending = not reverse
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3478
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3479 def reverse(self):
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3480 self._ascending = not self._ascending
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3481
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3482 def _iterfilter(self, iterrange):
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3483 s = self._hiddenrevs
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3484 for r in iterrange:
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3485 if r not in s:
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3486 yield r
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3487
20482 a979078bd788 revset: added spanset class to represent revision ranges Lucas Moscovicz <lmoscovicz@fb.com> parents: 20481 diff changeset	3488 def __iter__(self):
22717 b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3489 if self._ascending:
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3490 return self.fastasc()
20482 a979078bd788 revset: added spanset class to represent revision ranges Lucas Moscovicz <lmoscovicz@fb.com> parents: 20481 diff changeset	3491 else:
22717 b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3492 return self.fastdesc()
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3493
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3494 def fastasc(self):
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3495 iterrange = xrange(self._start, self._end)
20521 1850a7f5fb66 revset: changed spanset implementation to take hidden revisions into account Lucas Moscovicz <lmoscovicz@fb.com> parents: 20512 diff changeset	3496 if self._hiddenrevs:
22717 b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3497 return self._iterfilter(iterrange)
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3498 return iter(iterrange)
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3499
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3500 def fastdesc(self):
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3501 iterrange = xrange(self._end - 1, self._start - 1, -1)
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3502 if self._hiddenrevs:
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3503 return self._iterfilter(iterrange)
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3504 return iter(iterrange)
20482 a979078bd788 revset: added spanset class to represent revision ranges Lucas Moscovicz <lmoscovicz@fb.com> parents: 20481 diff changeset	3505
21201 c8b9c6147108 revset: fix revision filtering in spanset.contains (regression) Pierre-Yves David <pierre-yves.david@fb.com> parents: 21199 diff changeset	3506 def __contains__(self, rev):
22526 1e6d2b6b37ea revset: do less lookup during spanset.__contains__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22510 diff changeset	3507 hidden = self._hiddenrevs
22718 7b123e5639f4 spanset: do a single range check in __contains__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22717 diff changeset	3508 return ((self._start <= rev < self._end)
22526 1e6d2b6b37ea revset: do less lookup during spanset.__contains__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22510 diff changeset	3509 and not (hidden and rev in hidden))
20482 a979078bd788 revset: added spanset class to represent revision ranges Lucas Moscovicz <lmoscovicz@fb.com> parents: 20481 diff changeset	3510
20716 fa1ac5faa7c4 revset: added __nonzero__ method to spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20714 diff changeset	3511 def __nonzero__(self):
fa1ac5faa7c4 revset: added __nonzero__ method to spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20714 diff changeset	3512 for r in self:
fa1ac5faa7c4 revset: added __nonzero__ method to spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20714 diff changeset	3513 return True
fa1ac5faa7c4 revset: added __nonzero__ method to spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20714 diff changeset	3514 return False
fa1ac5faa7c4 revset: added __nonzero__ method to spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20714 diff changeset	3515
20484 0f1ef9e9e904 revset: added operations to spanset to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20483 diff changeset	3516 def __len__(self):
20521 1850a7f5fb66 revset: changed spanset implementation to take hidden revisions into account Lucas Moscovicz <lmoscovicz@fb.com> parents: 20512 diff changeset	3517 if not self._hiddenrevs:
1850a7f5fb66 revset: changed spanset implementation to take hidden revisions into account Lucas Moscovicz <lmoscovicz@fb.com> parents: 20512 diff changeset	3518 return abs(self._end - self._start)
1850a7f5fb66 revset: changed spanset implementation to take hidden revisions into account Lucas Moscovicz <lmoscovicz@fb.com> parents: 20512 diff changeset	3519 else:
1850a7f5fb66 revset: changed spanset implementation to take hidden revisions into account Lucas Moscovicz <lmoscovicz@fb.com> parents: 20512 diff changeset	3520 count = 0
21205 e2031c8ca4f8 revset: also inline spanset._contained in __len__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 21204 diff changeset	3521 start = self._start
e2031c8ca4f8 revset: also inline spanset._contained in __len__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 21204 diff changeset	3522 end = self._end
20521 1850a7f5fb66 revset: changed spanset implementation to take hidden revisions into account Lucas Moscovicz <lmoscovicz@fb.com> parents: 20512 diff changeset	3523 for rev in self._hiddenrevs:
21284 3e53a64345c1 revset: cosmetic changes in spanset range comparison Pierre-Yves David <pierre-yves.david@fb.com> parents: 21283 diff changeset	3524 if (end < rev <= start) or (start <= rev < end):
20521 1850a7f5fb66 revset: changed spanset implementation to take hidden revisions into account Lucas Moscovicz <lmoscovicz@fb.com> parents: 20512 diff changeset	3525 count += 1
1850a7f5fb66 revset: changed spanset implementation to take hidden revisions into account Lucas Moscovicz <lmoscovicz@fb.com> parents: 20512 diff changeset	3526 return abs(self._end - self._start) - count
20484 0f1ef9e9e904 revset: added operations to spanset to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20483 diff changeset	3527
20725 cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	3528 def isascending(self):
23826 c90d195320c5 revset: fix spanset.isascending() to honor sort() or reverse() request Yuya Nishihara <yuya@tcha.org> parents: 23724 diff changeset	3529 return self._ascending
20725 cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	3530
cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	3531 def isdescending(self):
23826 c90d195320c5 revset: fix spanset.isascending() to honor sort() or reverse() request Yuya Nishihara <yuya@tcha.org> parents: 23724 diff changeset	3532 return not self._ascending
20725 cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	3533
22809 88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3534 def first(self):
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3535 if self._ascending:
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3536 it = self.fastasc
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3537 else:
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3538 it = self.fastdesc
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3539 for x in it():
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3540 return x
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3541 return None
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3542
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3543 def last(self):
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3544 if self._ascending:
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3545 it = self.fastdesc
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3546 else:
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3547 it = self.fastasc
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3548 for x in it():
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3549 return x
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3550 return None
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3551
24457 c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3552 def __repr__(self):
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3553 d = {False: '-', True: '+'}[self._ascending]
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3554 return '<%s%s %d:%d>' % (type(self).__name__, d,
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3555 self._start, self._end - 1)
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3556
24116 8b90a60181d1 revset: drop factory that promotes spanset to fullreposet Yuya Nishihara <yuya@tcha.org> parents: 24115 diff changeset	3557 class fullreposet(spanset):
22508 2434c68d82a8 revert: add a fullreposet class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22504 diff changeset	3558 """a set containing all revisions in the repo
2434c68d82a8 revert: add a fullreposet class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22504 diff changeset	3559
24204 d2de20e1451f revset: extend fullreposet to make "null" revision magically appears in set Yuya Nishihara <yuya@tcha.org> parents: 24203 diff changeset	3560 This class exists to host special optimization and magic to handle virtual
d2de20e1451f revset: extend fullreposet to make "null" revision magically appears in set Yuya Nishihara <yuya@tcha.org> parents: 24203 diff changeset	3561 revisions such as "null".
22508 2434c68d82a8 revert: add a fullreposet class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22504 diff changeset	3562 """
2434c68d82a8 revert: add a fullreposet class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22504 diff changeset	3563
2434c68d82a8 revert: add a fullreposet class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22504 diff changeset	3564 def __init__(self, repo):
2434c68d82a8 revert: add a fullreposet class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22504 diff changeset	3565 super(fullreposet, self).__init__(repo)
2434c68d82a8 revert: add a fullreposet class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22504 diff changeset	3566
22510 911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3567 def __and__(self, other):
23139 e53f6b72a0e4 spelling: fixes from proofreading of spell checker issues Mads Kiilerich <madski@unity3d.com> parents: 23127 diff changeset	3568 """As self contains the whole repo, all of the other set should also be
e53f6b72a0e4 spelling: fixes from proofreading of spell checker issues Mads Kiilerich <madski@unity3d.com> parents: 23127 diff changeset	3569 in self. Therefore `self & other = other`.
22510 911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3570
911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3571 This boldly assumes the other contains valid revs only.
911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3572 """
911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3573 # other not a smartset, make is so
22883 e7b8cf352614 fullreposet: detect smartset using "isascending" instead of "set" Pierre-Yves David <pierre-yves.david@fb.com> parents: 22882 diff changeset	3574 if not util.safehasattr(other, 'isascending'):
22510 911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3575 # filter out hidden revision
911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3576 # (this boldly assumes all smartset are pure)
911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3577 #
911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3578 # `other` was used with "&", let's assume this is a set like
911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3579 # object.
911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3580 other = baseset(other - self._hiddenrevs)
911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3581
25547 99a1f73af85b revset: point out wrong behavior in fullreposet Pierre-Yves David <pierre-yves.david@fb.com> parents: 25344 diff changeset	3582 # XXX As fullreposet is also used as bootstrap, this is wrong.
99a1f73af85b revset: point out wrong behavior in fullreposet Pierre-Yves David <pierre-yves.david@fb.com> parents: 25344 diff changeset	3583 #
99a1f73af85b revset: point out wrong behavior in fullreposet Pierre-Yves David <pierre-yves.david@fb.com> parents: 25344 diff changeset	3584 # With a giveme312() revset returning [3,1,2], this makes
99a1f73af85b revset: point out wrong behavior in fullreposet Pierre-Yves David <pierre-yves.david@fb.com> parents: 25344 diff changeset	3585 # 'hg log -r "giveme312()"' -> 1, 2, 3 (wrong)
99a1f73af85b revset: point out wrong behavior in fullreposet Pierre-Yves David <pierre-yves.david@fb.com> parents: 25344 diff changeset	3586 # We cannot just drop it because other usage still need to sort it:
99a1f73af85b revset: point out wrong behavior in fullreposet Pierre-Yves David <pierre-yves.david@fb.com> parents: 25344 diff changeset	3587 # 'hg log -r "all() and giveme312()"' -> 1, 2, 3 (right)
99a1f73af85b revset: point out wrong behavior in fullreposet Pierre-Yves David <pierre-yves.david@fb.com> parents: 25344 diff changeset	3588 #
99a1f73af85b revset: point out wrong behavior in fullreposet Pierre-Yves David <pierre-yves.david@fb.com> parents: 25344 diff changeset	3589 # There is also some faulty revset implementations that rely on it
99a1f73af85b revset: point out wrong behavior in fullreposet Pierre-Yves David <pierre-yves.david@fb.com> parents: 25344 diff changeset	3590 # (eg: children as of its state in e8075329c5fb)
99a1f73af85b revset: point out wrong behavior in fullreposet Pierre-Yves David <pierre-yves.david@fb.com> parents: 25344 diff changeset	3591 #
99a1f73af85b revset: point out wrong behavior in fullreposet Pierre-Yves David <pierre-yves.david@fb.com> parents: 25344 diff changeset	3592 # When we fix the two points above we can move this into the if clause
23827 4982fade9733 revset: simplify fullreposet.__and__ to call sort() with boolean flag Yuya Nishihara <yuya@tcha.org> parents: 23822 diff changeset	3593 other.sort(reverse=self.isdescending())
22510 911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3594 return other
911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3595
24458 7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3596 def prettyformatset(revs):
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3597 lines = []
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3598 rs = repr(revs)
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3599 p = 0
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3600 while p < len(rs):
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3601 q = rs.find('<', p + 1)
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3602 if q < 0:
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3603 q = len(rs)
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3604 l = rs.count('<', 0, p) - rs.count('>', 0, p)
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3605 assert l >= 0
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3606 lines.append((l, rs[p:q].rstrip()))
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3607 p = q
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3608 return '\n'.join(' ' * l + s for l, s in lines)
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3609
12823 80deae3bc5ea hggettext: handle i18nfunctions declaration for docstrings translations Patrick Mezard <pmezard@gmail.com> parents: 12821 diff changeset	3610 # tell hggettext to extract docstrings from these functions:
80deae3bc5ea hggettext: handle i18nfunctions declaration for docstrings translations Patrick Mezard <pmezard@gmail.com> parents: 12821 diff changeset	3611 i18nfunctions = symbols.values()

Mercurial > public > mercurial-scm > hg-stable

annotate mercurial/revset.py @ 25621:21a874693619