Mercurial > hg
annotate mercurial/revset.py @ 26311:60dd8e3977f0
util: avoid mutable default arguments
I almost introduced a bug around this code by accidentally mutating a default
argument. There's no reason for these to exist.
author | Siddharth Agarwal <sid0@fb.com> |
---|---|
date | Tue, 22 Sep 2015 16:55:18 -0700 |
parents | 428a8747f4ee |
children | 7d132557e44a |
rev | line source |
---|---|
11275 | 1 # revset.py - revision set queries for mercurial |
2 # | |
3 # Copyright 2010 Matt Mackall <mpm@selenic.com> | |
4 # | |
5 # This software may be used and distributed according to the terms of the | |
6 # GNU General Public License version 2 or any later version. | |
7 | |
25971
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
8 from __future__ import absolute_import |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
9 |
20690
13c0327eeb6f
revset: changed ancestors revset to return lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20659
diff
changeset
|
10 import heapq |
25971
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
11 import re |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
12 |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
13 from .i18n import _ |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
14 from . import ( |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
15 encoding, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
16 error, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
17 hbisect, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
18 match as matchmod, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
19 node, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
20 obsolete as obsmod, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
21 parser, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
22 pathutil, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
23 phases, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
24 repoview, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
25 util, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
26 ) |
11275 | 27 |
16409
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
28 def _revancestors(repo, revs, followfirst): |
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
29 """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
|
30 if followfirst: |
6ddc86eedc3b
style: kill ersatz if-else ternary operators
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
24219
diff
changeset
|
31 cut = 1 |
6ddc86eedc3b
style: kill ersatz if-else ternary operators
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
24219
diff
changeset
|
32 else: |
6ddc86eedc3b
style: kill ersatz if-else ternary operators
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
24219
diff
changeset
|
33 cut = None |
16409
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
34 cl = repo.changelog |
20690
13c0327eeb6f
revset: changed ancestors revset to return lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20659
diff
changeset
|
35 |
13c0327eeb6f
revset: changed ancestors revset to return lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20659
diff
changeset
|
36 def iterate(): |
22832
2f1d2a42f040
revancestors: replace `descending` with `sort(reverse=False)`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22831
diff
changeset
|
37 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
|
38 irevs = iter(revs) |
20691
c1f666e27345
revset: optimized _revancestors method based on order of revisions
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20690
diff
changeset
|
39 h = [] |
c1f666e27345
revset: optimized _revancestors method based on order of revisions
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20690
diff
changeset
|
40 |
25143
91c49621b2b8
_revancestors: use 'next' to remove the verbose try except clauses
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25131
diff
changeset
|
41 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
|
42 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
|
43 heapq.heappush(h, -inputrev) |
20691
c1f666e27345
revset: optimized _revancestors method based on order of revisions
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20690
diff
changeset
|
44 |
23956
b1e026c25552
revset: fix ancestors(null) to include null revision (issue4512)
Yuya Nishihara <yuya@tcha.org>
parents:
23954
diff
changeset
|
45 seen = set() |
20690
13c0327eeb6f
revset: changed ancestors revset to return lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20659
diff
changeset
|
46 while h: |
13c0327eeb6f
revset: changed ancestors revset to return lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20659
diff
changeset
|
47 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
|
48 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
|
49 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
|
50 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
|
51 heapq.heappush(h, -inputrev) |
20690
13c0327eeb6f
revset: changed ancestors revset to return lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20659
diff
changeset
|
52 if current not in seen: |
13c0327eeb6f
revset: changed ancestors revset to return lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20659
diff
changeset
|
53 seen.add(current) |
13c0327eeb6f
revset: changed ancestors revset to return lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20659
diff
changeset
|
54 yield current |
13c0327eeb6f
revset: changed ancestors revset to return lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20659
diff
changeset
|
55 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
|
56 if parent != node.nullrev: |
13c0327eeb6f
revset: changed ancestors revset to return lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20659
diff
changeset
|
57 heapq.heappush(h, -parent) |
13c0327eeb6f
revset: changed ancestors revset to return lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20659
diff
changeset
|
58 |
22795
c21342159fad
generatorset: drop the leading underscore in the class name
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22794
diff
changeset
|
59 return generatorset(iterate(), iterasc=False) |
16409
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
60 |
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
61 def _revdescendants(repo, revs, followfirst): |
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
62 """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
|
63 if followfirst: |
6ddc86eedc3b
style: kill ersatz if-else ternary operators
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
24219
diff
changeset
|
64 cut = 1 |
6ddc86eedc3b
style: kill ersatz if-else ternary operators
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
24219
diff
changeset
|
65 else: |
6ddc86eedc3b
style: kill ersatz if-else ternary operators
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
24219
diff
changeset
|
66 cut = None |
16409
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
67 |
20692
7af341082b76
revset: changed descendants revset to use lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20691
diff
changeset
|
68 def iterate(): |
7af341082b76
revset: changed descendants revset to use lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20691
diff
changeset
|
69 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
|
70 # 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
|
71 # 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
|
72 first = min(revs) |
7af341082b76
revset: changed descendants revset to use lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20691
diff
changeset
|
73 nullrev = node.nullrev |
7af341082b76
revset: changed descendants revset to use lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20691
diff
changeset
|
74 if first == nullrev: |
7af341082b76
revset: changed descendants revset to use lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20691
diff
changeset
|
75 # 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
|
76 # 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
|
77 for i in cl: |
16409
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
78 yield i |
20692
7af341082b76
revset: changed descendants revset to use lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20691
diff
changeset
|
79 else: |
7af341082b76
revset: changed descendants revset to use lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20691
diff
changeset
|
80 seen = set(revs) |
7af341082b76
revset: changed descendants revset to use lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20691
diff
changeset
|
81 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
|
82 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
|
83 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
|
84 seen.add(i) |
7af341082b76
revset: changed descendants revset to use lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20691
diff
changeset
|
85 yield i |
7af341082b76
revset: changed descendants revset to use lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20691
diff
changeset
|
86 break |
7af341082b76
revset: changed descendants revset to use lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20691
diff
changeset
|
87 |
22795
c21342159fad
generatorset: drop the leading underscore in the class name
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22794
diff
changeset
|
88 return generatorset(iterate(), iterasc=True) |
16409
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
89 |
26095
6eed95ca4c03
revset: mark reachablerootspure as private
Yuya Nishihara <yuya@tcha.org>
parents:
26094
diff
changeset
|
90 def _reachablerootspure(repo, minroot, roots, heads, includepath): |
26002
fd92bfbbe02d
revset: rename revsbetween to reachableroots and add an argument
Laurent Charignon <lcharignon@fb.com>
parents:
26001
diff
changeset
|
91 """return (heads(::<roots> and ::<heads>)) |
fd92bfbbe02d
revset: rename revsbetween to reachableroots and add an argument
Laurent Charignon <lcharignon@fb.com>
parents:
26001
diff
changeset
|
92 |
fd92bfbbe02d
revset: rename revsbetween to reachableroots and add an argument
Laurent Charignon <lcharignon@fb.com>
parents:
26001
diff
changeset
|
93 If includepath is True, return (<roots>::<heads>).""" |
16862
b6efeb27e733
revset: introduce and use _revsbetween
Bryan O'Sullivan <bryano@fb.com>
parents:
16861
diff
changeset
|
94 if not roots: |
26094
df41c7be16d6
reachableroots: construct and sort baseset in revset module
Yuya Nishihara <yuya@tcha.org>
parents:
26093
diff
changeset
|
95 return [] |
16862
b6efeb27e733
revset: introduce and use _revsbetween
Bryan O'Sullivan <bryano@fb.com>
parents:
16861
diff
changeset
|
96 parentrevs = repo.changelog.parentrevs |
26053
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26006
diff
changeset
|
97 roots = set(roots) |
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
|
98 visit = list(heads) |
16862
b6efeb27e733
revset: introduce and use _revsbetween
Bryan O'Sullivan <bryano@fb.com>
parents:
16861
diff
changeset
|
99 reachable = set() |
b6efeb27e733
revset: introduce and use _revsbetween
Bryan O'Sullivan <bryano@fb.com>
parents:
16861
diff
changeset
|
100 seen = {} |
25566
15412bba5a68
revset: prefetch all attributes before loop in _revsbetween
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25554
diff
changeset
|
101 # 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
|
102 reached = reachable.add |
15412bba5a68
revset: prefetch all attributes before loop in _revsbetween
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25554
diff
changeset
|
103 dovisit = visit.append |
15412bba5a68
revset: prefetch all attributes before loop in _revsbetween
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25554
diff
changeset
|
104 nextvisit = visit.pop |
16862
b6efeb27e733
revset: introduce and use _revsbetween
Bryan O'Sullivan <bryano@fb.com>
parents:
16861
diff
changeset
|
105 # 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
|
106 # sys.getrecursionlimit() |
b6efeb27e733
revset: introduce and use _revsbetween
Bryan O'Sullivan <bryano@fb.com>
parents:
16861
diff
changeset
|
107 while visit: |
25566
15412bba5a68
revset: prefetch all attributes before loop in _revsbetween
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25554
diff
changeset
|
108 rev = nextvisit() |
16862
b6efeb27e733
revset: introduce and use _revsbetween
Bryan O'Sullivan <bryano@fb.com>
parents:
16861
diff
changeset
|
109 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
|
110 reached(rev) |
26002
fd92bfbbe02d
revset: rename revsbetween to reachableroots and add an argument
Laurent Charignon <lcharignon@fb.com>
parents:
26001
diff
changeset
|
111 if not includepath: |
fd92bfbbe02d
revset: rename revsbetween to reachableroots and add an argument
Laurent Charignon <lcharignon@fb.com>
parents:
26001
diff
changeset
|
112 continue |
16862
b6efeb27e733
revset: introduce and use _revsbetween
Bryan O'Sullivan <bryano@fb.com>
parents:
16861
diff
changeset
|
113 parents = parentrevs(rev) |
b6efeb27e733
revset: introduce and use _revsbetween
Bryan O'Sullivan <bryano@fb.com>
parents:
16861
diff
changeset
|
114 seen[rev] = parents |
b6efeb27e733
revset: introduce and use _revsbetween
Bryan O'Sullivan <bryano@fb.com>
parents:
16861
diff
changeset
|
115 for parent in parents: |
b6efeb27e733
revset: introduce and use _revsbetween
Bryan O'Sullivan <bryano@fb.com>
parents:
16861
diff
changeset
|
116 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
|
117 dovisit(parent) |
16862
b6efeb27e733
revset: introduce and use _revsbetween
Bryan O'Sullivan <bryano@fb.com>
parents:
16861
diff
changeset
|
118 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
|
119 return baseset() |
26002
fd92bfbbe02d
revset: rename revsbetween to reachableroots and add an argument
Laurent Charignon <lcharignon@fb.com>
parents:
26001
diff
changeset
|
120 if not includepath: |
fd92bfbbe02d
revset: rename revsbetween to reachableroots and add an argument
Laurent Charignon <lcharignon@fb.com>
parents:
26001
diff
changeset
|
121 return reachable |
16862
b6efeb27e733
revset: introduce and use _revsbetween
Bryan O'Sullivan <bryano@fb.com>
parents:
16861
diff
changeset
|
122 for rev in sorted(seen): |
b6efeb27e733
revset: introduce and use _revsbetween
Bryan O'Sullivan <bryano@fb.com>
parents:
16861
diff
changeset
|
123 for parent in seen[rev]: |
b6efeb27e733
revset: introduce and use _revsbetween
Bryan O'Sullivan <bryano@fb.com>
parents:
16861
diff
changeset
|
124 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
|
125 reached(rev) |
26091
60bbd4f9abd1
reachableroots: sort the smartset in the pure version too
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26060
diff
changeset
|
126 return reachable |
16862
b6efeb27e733
revset: introduce and use _revsbetween
Bryan O'Sullivan <bryano@fb.com>
parents:
16861
diff
changeset
|
127 |
26006
1ffd97cbf9a2
reachableroots: default to the C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
26002
diff
changeset
|
128 def reachableroots(repo, roots, heads, includepath=False): |
1ffd97cbf9a2
reachableroots: default to the C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
26002
diff
changeset
|
129 """return (heads(::<roots> and ::<heads>)) |
1ffd97cbf9a2
reachableroots: default to the C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
26002
diff
changeset
|
130 |
1ffd97cbf9a2
reachableroots: default to the C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
26002
diff
changeset
|
131 If includepath is True, return (<roots>::<heads>).""" |
1ffd97cbf9a2
reachableroots: default to the C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
26002
diff
changeset
|
132 if not roots: |
1ffd97cbf9a2
reachableroots: default to the C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
26002
diff
changeset
|
133 return baseset() |
26093
204131131766
reachableroots: use smartset min
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26091
diff
changeset
|
134 minroot = roots.min() |
26053
b68c9d232db6
reachableroots: use internal "revstates" array to test if rev is a root
Yuya Nishihara <yuya@tcha.org>
parents:
26006
diff
changeset
|
135 roots = list(roots) |
26006
1ffd97cbf9a2
reachableroots: default to the C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
26002
diff
changeset
|
136 heads = list(heads) |
1ffd97cbf9a2
reachableroots: default to the C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
26002
diff
changeset
|
137 try: |
26094
df41c7be16d6
reachableroots: construct and sort baseset in revset module
Yuya Nishihara <yuya@tcha.org>
parents:
26093
diff
changeset
|
138 revs = repo.changelog.reachableroots(minroot, heads, roots, includepath) |
26006
1ffd97cbf9a2
reachableroots: default to the C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
26002
diff
changeset
|
139 except AttributeError: |
26095
6eed95ca4c03
revset: mark reachablerootspure as private
Yuya Nishihara <yuya@tcha.org>
parents:
26094
diff
changeset
|
140 revs = _reachablerootspure(repo, minroot, roots, heads, includepath) |
26094
df41c7be16d6
reachableroots: construct and sort baseset in revset module
Yuya Nishihara <yuya@tcha.org>
parents:
26093
diff
changeset
|
141 revs = baseset(revs) |
df41c7be16d6
reachableroots: construct and sort baseset in revset module
Yuya Nishihara <yuya@tcha.org>
parents:
26093
diff
changeset
|
142 revs.sort() |
df41c7be16d6
reachableroots: construct and sort baseset in revset module
Yuya Nishihara <yuya@tcha.org>
parents:
26093
diff
changeset
|
143 return revs |
26006
1ffd97cbf9a2
reachableroots: default to the C implementation
Laurent Charignon <lcharignon@fb.com>
parents:
26002
diff
changeset
|
144 |
11275 | 145 elements = { |
25815
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
146 # token-type: binding-strength, primary, prefix, infix, suffix |
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
147 "(": (21, None, ("group", 1, ")"), ("func", 1, ")"), None), |
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
148 "##": (20, None, None, ("_concat", 20), None), |
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
149 "~": (18, None, None, ("ancestor", 18), None), |
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
150 "^": (18, None, None, ("parent", 18), ("parentpost", 18)), |
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
151 "-": (5, None, ("negate", 19), ("minus", 5), None), |
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
152 "::": (17, None, ("dagrangepre", 17), ("dagrange", 17), |
11278
7df88cdf47fd
revset: add support for prefix and suffix versions of : and ::
Matt Mackall <mpm@selenic.com>
parents:
11275
diff
changeset
|
153 ("dagrangepost", 17)), |
25815
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
154 "..": (17, None, ("dagrangepre", 17), ("dagrange", 17), |
11278
7df88cdf47fd
revset: add support for prefix and suffix versions of : and ::
Matt Mackall <mpm@selenic.com>
parents:
11275
diff
changeset
|
155 ("dagrangepost", 17)), |
25819
be29d26e2949
revset: parse nullary ":" operator as "0:tip"
Yuya Nishihara <yuya@tcha.org>
parents:
25815
diff
changeset
|
156 ":": (15, "rangeall", ("rangepre", 15), ("range", 15), ("rangepost", 15)), |
25815
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
157 "not": (10, None, ("not", 10), None, None), |
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
158 "!": (10, None, ("not", 10), None, None), |
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
159 "and": (5, None, None, ("and", 5), None), |
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
160 "&": (5, None, None, ("and", 5), None), |
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
161 "%": (5, None, None, ("only", 5), ("onlypost", 5)), |
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
162 "or": (4, None, None, ("or", 4), None), |
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
163 "|": (4, None, None, ("or", 4), None), |
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
164 "+": (4, None, None, ("or", 4), None), |
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
165 "=": (3, None, None, ("keyvalue", 3), None), |
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
166 ",": (2, None, None, ("list", 2), None), |
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
167 ")": (0, None, None, None, None), |
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
168 "symbol": (0, "symbol", None, None, None), |
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
169 "string": (0, "string", None, None, None), |
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
170 "end": (0, None, None, None, None), |
11275 | 171 } |
172 | |
173 keywords = set(['and', 'or', 'not']) | |
174 | |
23842
91dbb98b3513
revset: make tokenize extensible to parse alias declarations and definitions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23836
diff
changeset
|
175 # 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
|
176 _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
|
177 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
|
178 |
91dbb98b3513
revset: make tokenize extensible to parse alias declarations and definitions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23836
diff
changeset
|
179 # 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
|
180 _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
|
181 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
|
182 |
91dbb98b3513
revset: make tokenize extensible to parse alias declarations and definitions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23836
diff
changeset
|
183 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
|
184 ''' |
d8905e2c1301
revset: accept @ in unquoted symbols (issue3686)
Matt Mackall <mpm@selenic.com>
parents:
17829
diff
changeset
|
185 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
|
186 |
23842
91dbb98b3513
revset: make tokenize extensible to parse alias declarations and definitions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23836
diff
changeset
|
187 ``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
|
188 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
|
189 |
91dbb98b3513
revset: make tokenize extensible to parse alias declarations and definitions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23836
diff
changeset
|
190 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
|
191 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
|
192 |
91dbb98b3513
revset: make tokenize extensible to parse alias declarations and definitions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23836
diff
changeset
|
193 ``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
|
194 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
|
195 |
91dbb98b3513
revset: make tokenize extensible to parse alias declarations and definitions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23836
diff
changeset
|
196 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
|
197 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
|
198 |
17886
d8905e2c1301
revset: accept @ in unquoted symbols (issue3686)
Matt Mackall <mpm@selenic.com>
parents:
17829
diff
changeset
|
199 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
|
200 >>> list(tokenize("@::")) |
d8905e2c1301
revset: accept @ in unquoted symbols (issue3686)
Matt Mackall <mpm@selenic.com>
parents:
17829
diff
changeset
|
201 [('symbol', '@', 0), ('::', None, 1), ('end', None, 3)] |
d8905e2c1301
revset: accept @ in unquoted symbols (issue3686)
Matt Mackall <mpm@selenic.com>
parents:
17829
diff
changeset
|
202 |
d8905e2c1301
revset: accept @ in unquoted symbols (issue3686)
Matt Mackall <mpm@selenic.com>
parents:
17829
diff
changeset
|
203 ''' |
23842
91dbb98b3513
revset: make tokenize extensible to parse alias declarations and definitions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23836
diff
changeset
|
204 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
|
205 syminitletters = _syminitletters |
91dbb98b3513
revset: make tokenize extensible to parse alias declarations and definitions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23836
diff
changeset
|
206 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
|
207 symletters = _symletters |
17886
d8905e2c1301
revset: accept @ in unquoted symbols (issue3686)
Matt Mackall <mpm@selenic.com>
parents:
17829
diff
changeset
|
208 |
25902
5214cbdc37e5
revset: port parsing rule of old-style ranges from scmutil.revrange()
Yuya Nishihara <yuya@tcha.org>
parents:
25819
diff
changeset
|
209 if program and lookup: |
5214cbdc37e5
revset: port parsing rule of old-style ranges from scmutil.revrange()
Yuya Nishihara <yuya@tcha.org>
parents:
25819
diff
changeset
|
210 # attempt to parse old-style ranges first to deal with |
5214cbdc37e5
revset: port parsing rule of old-style ranges from scmutil.revrange()
Yuya Nishihara <yuya@tcha.org>
parents:
25819
diff
changeset
|
211 # things like old-tag which contain query metacharacters |
5214cbdc37e5
revset: port parsing rule of old-style ranges from scmutil.revrange()
Yuya Nishihara <yuya@tcha.org>
parents:
25819
diff
changeset
|
212 parts = program.split(':', 1) |
5214cbdc37e5
revset: port parsing rule of old-style ranges from scmutil.revrange()
Yuya Nishihara <yuya@tcha.org>
parents:
25819
diff
changeset
|
213 if all(lookup(sym) for sym in parts if sym): |
5214cbdc37e5
revset: port parsing rule of old-style ranges from scmutil.revrange()
Yuya Nishihara <yuya@tcha.org>
parents:
25819
diff
changeset
|
214 if parts[0]: |
5214cbdc37e5
revset: port parsing rule of old-style ranges from scmutil.revrange()
Yuya Nishihara <yuya@tcha.org>
parents:
25819
diff
changeset
|
215 yield ('symbol', parts[0], 0) |
5214cbdc37e5
revset: port parsing rule of old-style ranges from scmutil.revrange()
Yuya Nishihara <yuya@tcha.org>
parents:
25819
diff
changeset
|
216 if len(parts) > 1: |
5214cbdc37e5
revset: port parsing rule of old-style ranges from scmutil.revrange()
Yuya Nishihara <yuya@tcha.org>
parents:
25819
diff
changeset
|
217 s = len(parts[0]) |
5214cbdc37e5
revset: port parsing rule of old-style ranges from scmutil.revrange()
Yuya Nishihara <yuya@tcha.org>
parents:
25819
diff
changeset
|
218 yield (':', None, s) |
5214cbdc37e5
revset: port parsing rule of old-style ranges from scmutil.revrange()
Yuya Nishihara <yuya@tcha.org>
parents:
25819
diff
changeset
|
219 if parts[1]: |
5214cbdc37e5
revset: port parsing rule of old-style ranges from scmutil.revrange()
Yuya Nishihara <yuya@tcha.org>
parents:
25819
diff
changeset
|
220 yield ('symbol', parts[1], s + 1) |
5214cbdc37e5
revset: port parsing rule of old-style ranges from scmutil.revrange()
Yuya Nishihara <yuya@tcha.org>
parents:
25819
diff
changeset
|
221 yield ('end', None, len(program)) |
5214cbdc37e5
revset: port parsing rule of old-style ranges from scmutil.revrange()
Yuya Nishihara <yuya@tcha.org>
parents:
25819
diff
changeset
|
222 return |
5214cbdc37e5
revset: port parsing rule of old-style ranges from scmutil.revrange()
Yuya Nishihara <yuya@tcha.org>
parents:
25819
diff
changeset
|
223 |
11275 | 224 pos, l = 0, len(program) |
225 while pos < l: | |
226 c = program[pos] | |
227 if c.isspace(): # skip inter-token whitespace | |
228 pass | |
11278
7df88cdf47fd
revset: add support for prefix and suffix versions of : and ::
Matt Mackall <mpm@selenic.com>
parents:
11275
diff
changeset
|
229 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
|
230 yield ('::', None, pos) |
11278
7df88cdf47fd
revset: add support for prefix and suffix versions of : and ::
Matt Mackall <mpm@selenic.com>
parents:
11275
diff
changeset
|
231 pos += 1 # skip ahead |
11275 | 232 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
|
233 yield ('..', None, pos) |
11275 | 234 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
|
235 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
|
236 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
|
237 pos += 1 # skip ahead |
25704
70a2082f855a
revset: add parsing rule for key=value pair
Yuya Nishihara <yuya@tcha.org>
parents:
25689
diff
changeset
|
238 elif c in "():=,-|&+!~^%": # handle simple operators |
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
239 yield (c, None, pos) |
12408
78a97859b90d
revset: support raw string literals
Brodie Rao <brodie@bitheap.org>
parents:
12401
diff
changeset
|
240 elif (c in '"\'' or c == 'r' and |
78a97859b90d
revset: support raw string literals
Brodie Rao <brodie@bitheap.org>
parents:
12401
diff
changeset
|
241 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
|
242 if c == 'r': |
78a97859b90d
revset: support raw string literals
Brodie Rao <brodie@bitheap.org>
parents:
12401
diff
changeset
|
243 pos += 1 |
78a97859b90d
revset: support raw string literals
Brodie Rao <brodie@bitheap.org>
parents:
12401
diff
changeset
|
244 c = program[pos] |
78a97859b90d
revset: support raw string literals
Brodie Rao <brodie@bitheap.org>
parents:
12401
diff
changeset
|
245 decode = lambda x: x |
78a97859b90d
revset: support raw string literals
Brodie Rao <brodie@bitheap.org>
parents:
12401
diff
changeset
|
246 else: |
26232
43f9976346e9
revset: handle error of string unescaping
Yuya Nishihara <yuya@tcha.org>
parents:
26212
diff
changeset
|
247 decode = parser.unescapestr |
11275 | 248 pos += 1 |
249 s = pos | |
250 while pos < l: # find closing quote | |
251 d = program[pos] | |
252 if d == '\\': # skip over escaped characters | |
253 pos += 2 | |
254 continue | |
255 if d == c: | |
12408
78a97859b90d
revset: support raw string literals
Brodie Rao <brodie@bitheap.org>
parents:
12401
diff
changeset
|
256 yield ('string', decode(program[s:pos]), s) |
11275 | 257 break |
258 pos += 1 | |
259 else: | |
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
260 raise error.ParseError(_("unterminated string"), s) |
16683 | 261 # 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
|
262 elif c in syminitletters: |
11275 | 263 s = pos |
264 pos += 1 | |
265 while pos < l: # find end of symbol | |
266 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
|
267 if d not in symletters: |
11275 | 268 break |
269 if d == '.' and program[pos - 1] == '.': # special case for .. | |
270 pos -= 1 | |
271 break | |
272 pos += 1 | |
273 sym = program[s:pos] | |
274 if sym in keywords: # operator keywords | |
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
275 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
|
276 elif '-' in sym: |
403f1f73d30f
revset: try to handle hyphenated symbols if lookup callback is available
Matt Mackall <mpm@selenic.com>
parents:
20779
diff
changeset
|
277 # 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
|
278 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
|
279 # 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
|
280 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
|
281 else: |
403f1f73d30f
revset: try to handle hyphenated symbols if lookup callback is available
Matt Mackall <mpm@selenic.com>
parents:
20779
diff
changeset
|
282 # 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
|
283 parts = sym.split('-') |
403f1f73d30f
revset: try to handle hyphenated symbols if lookup callback is available
Matt Mackall <mpm@selenic.com>
parents:
20779
diff
changeset
|
284 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
|
285 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
|
286 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
|
287 s += len(p) |
403f1f73d30f
revset: try to handle hyphenated symbols if lookup callback is available
Matt Mackall <mpm@selenic.com>
parents:
20779
diff
changeset
|
288 yield ('-', None, pos) |
403f1f73d30f
revset: try to handle hyphenated symbols if lookup callback is available
Matt Mackall <mpm@selenic.com>
parents:
20779
diff
changeset
|
289 s += 1 |
403f1f73d30f
revset: try to handle hyphenated symbols if lookup callback is available
Matt Mackall <mpm@selenic.com>
parents:
20779
diff
changeset
|
290 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
|
291 yield ('symbol', parts[-1], s) |
11275 | 292 else: |
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
293 yield ('symbol', sym, s) |
11275 | 294 pos -= 1 |
295 else: | |
24708
fb47816e1a9c
revsets: more informative syntax error message
Ryan McElroy <rmcelroy@fb.com>
parents:
24518
diff
changeset
|
296 raise error.ParseError(_("syntax error in revset '%s'") % |
fb47816e1a9c
revsets: more informative syntax error message
Ryan McElroy <rmcelroy@fb.com>
parents:
24518
diff
changeset
|
297 program, pos) |
11275 | 298 pos += 1 |
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
299 yield ('end', None, pos) |
11275 | 300 |
23843
c4d0c3d05721
revset: factor out composing error message for ParseError to reuse
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23842
diff
changeset
|
301 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
|
302 """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
|
303 """ |
c4d0c3d05721
revset: factor out composing error message for ParseError to reuse
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23842
diff
changeset
|
304 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
|
305 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
|
306 else: |
c4d0c3d05721
revset: factor out composing error message for ParseError to reuse
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23842
diff
changeset
|
307 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
|
308 |
11275 | 309 # helpers |
310 | |
311 def getstring(x, err): | |
11406
42408cd43f55
revset: fix up contains/getstring when no args passed
Matt Mackall <mpm@selenic.com>
parents:
11404
diff
changeset
|
312 if x and (x[0] == 'string' or x[0] == 'symbol'): |
11275 | 313 return x[1] |
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
314 raise error.ParseError(err) |
11275 | 315 |
316 def getlist(x): | |
317 if not x: | |
318 return [] | |
319 if x[0] == 'list': | |
320 return getlist(x[1]) + [x[2]] | |
321 return [x] | |
322 | |
11339
744d5b73f776
revset: improve filter argument handling
Matt Mackall <mpm@selenic.com>
parents:
11304
diff
changeset
|
323 def getargs(x, min, max, err): |
11275 | 324 l = getlist(x) |
16161
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
325 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
|
326 raise error.ParseError(err) |
11275 | 327 return l |
328 | |
25767
026105c442d7
revset: rename getkwargs() to getargsdict()
Yuya Nishihara <yuya@tcha.org>
parents:
25766
diff
changeset
|
329 def getargsdict(x, funcname, keys): |
25705
48919d246a47
revset: add function to build dict of positional and keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
25704
diff
changeset
|
330 return parser.buildargsdict(getlist(x), funcname, keys.split(), |
48919d246a47
revset: add function to build dict of positional and keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
25704
diff
changeset
|
331 keyvaluenode='keyvalue', keynode='symbol') |
48919d246a47
revset: add function to build dict of positional and keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
25704
diff
changeset
|
332 |
23845
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
333 def isvalidsymbol(tree): |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
334 """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
|
335 """ |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
336 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
|
337 |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
338 def getsymbol(tree): |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
339 """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
|
340 |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
341 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
|
342 """ |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
343 return tree[1] |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
344 |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
345 def isvalidfunc(tree): |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
346 """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
|
347 """ |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
348 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
|
349 |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
350 def getfuncname(tree): |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
351 """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
|
352 |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
353 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
|
354 """ |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
355 return getsymbol(tree[1]) |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
356 |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
357 def getfuncargs(tree): |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
358 """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
|
359 |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
360 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
|
361 """ |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
362 if len(tree) > 2: |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
363 return getlist(tree[2]) |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
364 else: |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
365 return [] |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
366 |
11275 | 367 def getset(repo, subset, x): |
368 if not x: | |
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
369 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
|
370 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
|
371 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
|
372 return s |
25630
c88082baf693
devel-warn: issue a warning for old style revsets
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25622
diff
changeset
|
373 if (repo.ui.configbool('devel', 'all-warnings') |
c88082baf693
devel-warn: issue a warning for old style revsets
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25622
diff
changeset
|
374 or repo.ui.configbool('devel', 'old-revset')): |
c88082baf693
devel-warn: issue a warning for old style revsets
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25622
diff
changeset
|
375 # else case should not happen, because all non-func are internal, |
c88082baf693
devel-warn: issue a warning for old style revsets
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25622
diff
changeset
|
376 # ignoring for now. |
c88082baf693
devel-warn: issue a warning for old style revsets
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25622
diff
changeset
|
377 if x[0] == 'func' and x[1][0] == 'symbol' and x[1][1] in symbols: |
c88082baf693
devel-warn: issue a warning for old style revsets
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25622
diff
changeset
|
378 repo.ui.develwarn('revset "%s" use list instead of smartset, ' |
c88082baf693
devel-warn: issue a warning for old style revsets
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25622
diff
changeset
|
379 '(upgrade your code)' % x[1][1]) |
20527
bde426f18e0a
revset: changed mfunc and getset to work with old style revset methods
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20526
diff
changeset
|
380 return baseset(s) |
11275 | 381 |
17003
42c472877825
revset: add a utility for obtaining the source of a given rev
Matt Harbison <matt_harbison@yahoo.com>
parents:
17002
diff
changeset
|
382 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
|
383 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
|
384 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
|
385 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
|
386 try: |
42c472877825
revset: add a utility for obtaining the source of a given rev
Matt Harbison <matt_harbison@yahoo.com>
parents:
17002
diff
changeset
|
387 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
|
388 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
|
389 pass |
42c472877825
revset: add a utility for obtaining the source of a given rev
Matt Harbison <matt_harbison@yahoo.com>
parents:
17002
diff
changeset
|
390 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
|
391 |
11275 | 392 # operator methods |
393 | |
394 def stringset(repo, subset, x): | |
395 x = repo[x].rev() | |
25265
e16456831516
revset: drop magic of fullreposet membership test (issue4682)
Yuya Nishihara <yuya@tcha.org>
parents:
25094
diff
changeset
|
396 if (x in subset |
e16456831516
revset: drop magic of fullreposet membership test (issue4682)
Yuya Nishihara <yuya@tcha.org>
parents:
25094
diff
changeset
|
397 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
|
398 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
|
399 return baseset() |
11275 | 400 |
401 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
|
402 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
|
403 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
|
404 |
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
405 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
|
406 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
|
407 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
|
408 |
25766
d51dac68ec98
revset: work around x:y range where x or y is wdir()
Yuya Nishihara <yuya@tcha.org>
parents:
25765
diff
changeset
|
409 if m == n: |
d51dac68ec98
revset: work around x:y range where x or y is wdir()
Yuya Nishihara <yuya@tcha.org>
parents:
25765
diff
changeset
|
410 r = baseset([m]) |
d51dac68ec98
revset: work around x:y range where x or y is wdir()
Yuya Nishihara <yuya@tcha.org>
parents:
25765
diff
changeset
|
411 elif n == node.wdirrev: |
d51dac68ec98
revset: work around x:y range where x or y is wdir()
Yuya Nishihara <yuya@tcha.org>
parents:
25765
diff
changeset
|
412 r = spanset(repo, m, len(repo)) + baseset([n]) |
d51dac68ec98
revset: work around x:y range where x or y is wdir()
Yuya Nishihara <yuya@tcha.org>
parents:
25765
diff
changeset
|
413 elif m == node.wdirrev: |
d51dac68ec98
revset: work around x:y range where x or y is wdir()
Yuya Nishihara <yuya@tcha.org>
parents:
25765
diff
changeset
|
414 r = baseset([m]) + spanset(repo, len(repo) - 1, n - 1) |
d51dac68ec98
revset: work around x:y range where x or y is wdir()
Yuya Nishihara <yuya@tcha.org>
parents:
25765
diff
changeset
|
415 elif m < n: |
20526
9ad6dae67845
revset: changed revsets to use spanset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20525
diff
changeset
|
416 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
|
417 else: |
20526
9ad6dae67845
revset: changed revsets to use spanset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20525
diff
changeset
|
418 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
|
419 # 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
|
420 # 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
|
421 # |
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
|
422 # 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
|
423 # would be more efficient. |
20526
9ad6dae67845
revset: changed revsets to use spanset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20525
diff
changeset
|
424 return r & subset |
11275 | 425 |
16860
e1aa1ed30030
revset: turn dagrange into a function
Bryan O'Sullivan <bryano@fb.com>
parents:
16859
diff
changeset
|
426 def dagrange(repo, subset, x, y): |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
427 r = fullreposet(repo) |
26002
fd92bfbbe02d
revset: rename revsbetween to reachableroots and add an argument
Laurent Charignon <lcharignon@fb.com>
parents:
26001
diff
changeset
|
428 xs = reachableroots(repo, getset(repo, r, x), getset(repo, r, y), |
fd92bfbbe02d
revset: rename revsbetween to reachableroots and add an argument
Laurent Charignon <lcharignon@fb.com>
parents:
26001
diff
changeset
|
429 includepath=True) |
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
|
430 # 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
|
431 # 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
|
432 return xs & subset |
16860
e1aa1ed30030
revset: turn dagrange into a function
Bryan O'Sullivan <bryano@fb.com>
parents:
16859
diff
changeset
|
433 |
11275 | 434 def andset(repo, subset, x, y): |
435 return getset(repo, getset(repo, subset, x), y) | |
436 | |
25309
b333ca94403d
revset: reduce nesting of chained 'or' operations (issue4624)
Yuya Nishihara <yuya@tcha.org>
parents:
25308
diff
changeset
|
437 def orset(repo, subset, *xs): |
25929
289149111d46
revset: make balanced addsets by orset() without using _combinesets()
Yuya Nishihara <yuya@tcha.org>
parents:
25927
diff
changeset
|
438 assert xs |
289149111d46
revset: make balanced addsets by orset() without using _combinesets()
Yuya Nishihara <yuya@tcha.org>
parents:
25927
diff
changeset
|
439 if len(xs) == 1: |
289149111d46
revset: make balanced addsets by orset() without using _combinesets()
Yuya Nishihara <yuya@tcha.org>
parents:
25927
diff
changeset
|
440 return getset(repo, subset, xs[0]) |
289149111d46
revset: make balanced addsets by orset() without using _combinesets()
Yuya Nishihara <yuya@tcha.org>
parents:
25927
diff
changeset
|
441 p = len(xs) // 2 |
289149111d46
revset: make balanced addsets by orset() without using _combinesets()
Yuya Nishihara <yuya@tcha.org>
parents:
25927
diff
changeset
|
442 a = orset(repo, subset, *xs[:p]) |
289149111d46
revset: make balanced addsets by orset() without using _combinesets()
Yuya Nishihara <yuya@tcha.org>
parents:
25927
diff
changeset
|
443 b = orset(repo, subset, *xs[p:]) |
289149111d46
revset: make balanced addsets by orset() without using _combinesets()
Yuya Nishihara <yuya@tcha.org>
parents:
25927
diff
changeset
|
444 return a + b |
11275 | 445 |
446 def notset(repo, subset, x): | |
20366
5ec6321f49a9
revset: added substraction to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20365
diff
changeset
|
447 return subset - getset(repo, subset, x) |
11275 | 448 |
449 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
|
450 raise error.ParseError(_("can't use a list in this context")) |
11275 | 451 |
25704
70a2082f855a
revset: add parsing rule for key=value pair
Yuya Nishihara <yuya@tcha.org>
parents:
25689
diff
changeset
|
452 def keyvaluepair(repo, subset, k, v): |
70a2082f855a
revset: add parsing rule for key=value pair
Yuya Nishihara <yuya@tcha.org>
parents:
25689
diff
changeset
|
453 raise error.ParseError(_("can't use a key-value pair in this context")) |
70a2082f855a
revset: add parsing rule for key=value pair
Yuya Nishihara <yuya@tcha.org>
parents:
25689
diff
changeset
|
454 |
11275 | 455 def func(repo, subset, a, b): |
456 if a[0] == 'symbol' and a[1] in symbols: | |
457 return symbols[a[1]](repo, subset, b) | |
25632
015c0d1087a3
revset: don't suggest private or undocumented queries
Matt Harbison <matt_harbison@yahoo.com>
parents:
25630
diff
changeset
|
458 |
015c0d1087a3
revset: don't suggest private or undocumented queries
Matt Harbison <matt_harbison@yahoo.com>
parents:
25630
diff
changeset
|
459 keep = lambda fn: getattr(fn, '__doc__', None) is not None |
015c0d1087a3
revset: don't suggest private or undocumented queries
Matt Harbison <matt_harbison@yahoo.com>
parents:
25630
diff
changeset
|
460 |
015c0d1087a3
revset: don't suggest private or undocumented queries
Matt Harbison <matt_harbison@yahoo.com>
parents:
25630
diff
changeset
|
461 syms = [s for (s, fn) in symbols.items() if keep(fn)] |
015c0d1087a3
revset: don't suggest private or undocumented queries
Matt Harbison <matt_harbison@yahoo.com>
parents:
25630
diff
changeset
|
462 raise error.UnknownIdentifier(a[1], syms) |
11275 | 463 |
464 # functions | |
465 | |
26303
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
466 def _mergedefaultdest(repo, subset, x): |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
467 # ``_mergedefaultdest()`` |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
468 |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
469 # default destination for merge. |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
470 # # XXX: Currently private because I expect the signature to change. |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
471 # # XXX: - taking rev as arguments, |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
472 # # XXX: - bailing out in case of ambiguity vs returning all data. |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
473 getargs(x, 0, 0, _("_mergedefaultdest takes no arguments")) |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
474 if repo._activebookmark: |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
475 bmheads = repo.bookmarkheads(repo._activebookmark) |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
476 curhead = repo[repo._activebookmark].node() |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
477 if len(bmheads) == 2: |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
478 if curhead == bmheads[0]: |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
479 node = bmheads[1] |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
480 else: |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
481 node = bmheads[0] |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
482 elif len(bmheads) > 2: |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
483 raise util.Abort(_("multiple matching bookmarks to merge - " |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
484 "please merge with an explicit rev or bookmark"), |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
485 hint=_("run 'hg heads' to see all heads")) |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
486 elif len(bmheads) <= 1: |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
487 raise util.Abort(_("no matching bookmark to merge - " |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
488 "please merge with an explicit rev or bookmark"), |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
489 hint=_("run 'hg heads' to see all heads")) |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
490 else: |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
491 branch = repo[None].branch() |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
492 bheads = repo.branchheads(branch) |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
493 nbhs = [bh for bh in bheads if not repo[bh].bookmarks()] |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
494 |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
495 if len(nbhs) > 2: |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
496 raise util.Abort(_("branch '%s' has %d heads - " |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
497 "please merge with an explicit rev") |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
498 % (branch, len(bheads)), |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
499 hint=_("run 'hg heads .' to see heads")) |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
500 |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
501 parent = repo.dirstate.p1() |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
502 if len(nbhs) <= 1: |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
503 if len(bheads) > 1: |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
504 raise util.Abort(_("heads are bookmarked - " |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
505 "please merge with an explicit rev"), |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
506 hint=_("run 'hg heads' to see all heads")) |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
507 if len(repo.heads()) > 1: |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
508 raise util.Abort(_("branch '%s' has one head - " |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
509 "please merge with an explicit rev") |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
510 % branch, |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
511 hint=_("run 'hg heads' to see all heads")) |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
512 msg, hint = _('nothing to merge'), None |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
513 if parent != repo.lookup(branch): |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
514 hint = _("use 'hg update' instead") |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
515 raise util.Abort(msg, hint=hint) |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
516 |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
517 if parent not in bheads: |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
518 raise util.Abort(_('working directory not at a head revision'), |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
519 hint=_("use 'hg update' or merge with an " |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
520 "explicit revision")) |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
521 if parent == nbhs[0]: |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
522 node = nbhs[-1] |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
523 else: |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
524 node = nbhs[0] |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
525 return subset & baseset([repo[node].rev()]) |
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
526 |
26304
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
527 def _updatedefaultdest(repo, subset, x): |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
528 # ``_updatedefaultdest()`` |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
529 |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
530 # default destination for update. |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
531 # # XXX: Currently private because I expect the signature to change. |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
532 # # XXX: - taking rev as arguments, |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
533 # # XXX: - bailing out in case of ambiguity vs returning all data. |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
534 getargs(x, 0, 0, _("_updatedefaultdest takes no arguments")) |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
535 # Here is where we should consider bookmarks, divergent bookmarks, |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
536 # foreground changesets (successors), and tip of current branch; |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
537 # but currently we are only checking the branch tips. |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
538 node = None |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
539 wc = repo[None] |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
540 p1 = wc.p1() |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
541 try: |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
542 node = repo.branchtip(wc.branch()) |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
543 except error.RepoLookupError: |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
544 if wc.branch() == 'default': # no default branch! |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
545 node = repo.lookup('tip') # update to tip |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
546 else: |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
547 raise util.Abort(_("branch %s not found") % wc.branch()) |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
548 |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
549 if p1.obsolete() and not p1.children(): |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
550 # allow updating to successors |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
551 successors = obsmod.successorssets(repo, p1.node()) |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
552 |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
553 # behavior of certain cases is as follows, |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
554 # |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
555 # divergent changesets: update to highest rev, similar to what |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
556 # is currently done when there are more than one head |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
557 # (i.e. 'tip') |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
558 # |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
559 # replaced changesets: same as divergent except we know there |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
560 # is no conflict |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
561 # |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
562 # pruned changeset: no update is done; though, we could |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
563 # consider updating to the first non-obsolete parent, |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
564 # similar to what is current done for 'hg prune' |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
565 |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
566 if successors: |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
567 # flatten the list here handles both divergent (len > 1) |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
568 # and the usual case (len = 1) |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
569 successors = [n for sub in successors for n in sub] |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
570 |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
571 # get the max revision for the given successors set, |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
572 # i.e. the 'tip' of a set |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
573 node = repo.revs('max(%ln)', successors).first() |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
574 return subset & baseset([repo[node].rev()]) |
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
575 |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
576 def adds(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
577 """``adds(pattern)`` |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
578 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
|
579 |
96be25f1da45
revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20288
diff
changeset
|
580 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
|
581 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
|
582 directory. |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
583 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
584 # i18n: "adds" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
585 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
|
586 return checkstatus(repo, subset, pat, 1) |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
587 |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
588 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
|
589 """``ancestor(*changeset)`` |
20991
a05d694599f9
revlog: use context ancestor instead of changelog ancestor
Mads Kiilerich <madski@unity3d.com>
parents:
20895
diff
changeset
|
590 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
|
591 |
ae645d4f084c
revset: change ancestor to accept 0 or more arguments (issue3750)
Paul Cavallaro <ptc@fb.com>
parents:
18495
diff
changeset
|
592 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
|
593 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
|
594 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
|
595 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
596 # 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
|
597 l = getlist(x) |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
598 rl = fullreposet(repo) |
18536
ae645d4f084c
revset: change ancestor to accept 0 or more arguments (issue3750)
Paul Cavallaro <ptc@fb.com>
parents:
18495
diff
changeset
|
599 anc = None |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
600 |
18536
ae645d4f084c
revset: change ancestor to accept 0 or more arguments (issue3750)
Paul Cavallaro <ptc@fb.com>
parents:
18495
diff
changeset
|
601 # (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
|
602 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
|
603 for r in revs: |
ae645d4f084c
revset: change ancestor to accept 0 or more arguments (issue3750)
Paul Cavallaro <ptc@fb.com>
parents:
18495
diff
changeset
|
604 if anc is None: |
20991
a05d694599f9
revlog: use context ancestor instead of changelog ancestor
Mads Kiilerich <madski@unity3d.com>
parents:
20895
diff
changeset
|
605 anc = repo[r] |
18536
ae645d4f084c
revset: change ancestor to accept 0 or more arguments (issue3750)
Paul Cavallaro <ptc@fb.com>
parents:
18495
diff
changeset
|
606 else: |
20991
a05d694599f9
revlog: use context ancestor instead of changelog ancestor
Mads Kiilerich <madski@unity3d.com>
parents:
20895
diff
changeset
|
607 anc = anc.ancestor(repo[r]) |
a05d694599f9
revlog: use context ancestor instead of changelog ancestor
Mads Kiilerich <madski@unity3d.com>
parents:
20895
diff
changeset
|
608 |
a05d694599f9
revlog: use context ancestor instead of changelog ancestor
Mads Kiilerich <madski@unity3d.com>
parents:
20895
diff
changeset
|
609 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
|
610 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
|
611 return baseset() |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
612 |
16409
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
613 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
|
614 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
|
615 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
|
616 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
|
617 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
|
618 return subset & s |
16409
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
619 |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
620 def ancestors(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
621 """``ancestors(set)`` |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
622 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
|
623 """ |
16409
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
624 return _ancestors(repo, subset, x) |
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
625 |
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
626 def _firstancestors(repo, subset, x): |
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
627 # ``_firstancestors(set)`` |
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
628 # 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
|
629 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
|
630 |
14070
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
631 def ancestorspec(repo, subset, x, n): |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
632 """``set~n`` |
16683 | 633 Changesets that are the Nth ancestor (first parents only) of a changeset |
634 in set. | |
14070
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
635 """ |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
636 try: |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
637 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
|
638 except (TypeError, ValueError): |
14070
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
639 raise error.ParseError(_("~ expects a number")) |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
640 ps = set() |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
641 cl = repo.changelog |
23163
6f1b8b3f12fd
revset-ancestorspec: call 'getset' on a 'fullreposet'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23162
diff
changeset
|
642 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
|
643 for i in range(n): |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
644 r = cl.parentrevs(r)[0] |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
645 ps.add(r) |
22531
22ba2c0825da
revset: use `subset &` in `ancestorspec`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22530
diff
changeset
|
646 return subset & ps |
14070
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
647 |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
648 def author(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
649 """``author(string)`` |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
650 Alias for ``user(string)``. |
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 # 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
|
653 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
|
654 kind, pattern, matcher = _substringmatcher(n) |
20611
6490f8385391
revset: changed revset code to use filter method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20610
diff
changeset
|
655 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
|
656 |
15134
81adf7777f8f
revset: rename bisected() to bisect()
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents:
15133
diff
changeset
|
657 def bisect(repo, subset, x): |
81adf7777f8f
revset: rename bisected() to bisect()
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents:
15133
diff
changeset
|
658 """``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
|
659 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
|
660 |
15153
fa0a464e4ca5
hbisect: add two new revset descriptions: 'goods' and 'bads'
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents:
15147
diff
changeset
|
661 - ``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
|
662 - ``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
|
663 - ``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
|
664 - ``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
|
665 - ``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
|
666 - ``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
|
667 - ``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
|
668 """ |
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
|
669 # 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
|
670 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
|
671 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
|
672 return subset & state |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
673 |
15134
81adf7777f8f
revset: rename bisected() to bisect()
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents:
15133
diff
changeset
|
674 # Backward-compatibility |
81adf7777f8f
revset: rename bisected() to bisect()
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents:
15133
diff
changeset
|
675 # - 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
|
676 def bisected(repo, subset, x): |
81adf7777f8f
revset: rename bisected() to bisect()
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents:
15133
diff
changeset
|
677 return bisect(repo, subset, x) |
81adf7777f8f
revset: rename bisected() to bisect()
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents:
15133
diff
changeset
|
678 |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
679 def bookmark(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
680 """``bookmark([name])`` |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
681 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
|
682 |
da55d8a77390
revset: add pattern matching to 'bookmarks' revset expression
Simon King <simon@simonking.org.uk>
parents:
16821
diff
changeset
|
683 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
|
684 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
|
685 use the prefix `literal:`. |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
686 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
687 # i18n: "bookmark" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
688 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
|
689 if args: |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
690 bm = getstring(args[0], |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
691 # i18n: "bookmark" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
692 _('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
|
693 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
|
694 bms = set() |
16822
da55d8a77390
revset: add pattern matching to 'bookmarks' revset expression
Simon King <simon@simonking.org.uk>
parents:
16821
diff
changeset
|
695 if kind == 'literal': |
22105
3efe3c2609e0
revset: bookmark revset interprets 'literal:' prefix correctly (issue4329)
Michael O'Connor <mkoconnor@gmail.com>
parents:
21939
diff
changeset
|
696 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
|
697 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
|
698 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
|
699 % bm) |
22499
8c9f9e346acc
revset: unify code flow in `bookmark`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22498
diff
changeset
|
700 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
|
701 else: |
da55d8a77390
revset: add pattern matching to 'bookmarks' revset expression
Simon King <simon@simonking.org.uk>
parents:
16821
diff
changeset
|
702 matchrevs = set() |
18495
8260fa9f30b9
bookmarks: don't use bookmarks.listbookmarks in local computations
Kevin Bullock <kbullock@ringworld.org>
parents:
18473
diff
changeset
|
703 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
|
704 if matcher(name): |
da55d8a77390
revset: add pattern matching to 'bookmarks' revset expression
Simon King <simon@simonking.org.uk>
parents:
16821
diff
changeset
|
705 matchrevs.add(bmrev) |
da55d8a77390
revset: add pattern matching to 'bookmarks' revset expression
Simon King <simon@simonking.org.uk>
parents:
16821
diff
changeset
|
706 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
|
707 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
|
708 " that match '%s'") % pattern) |
16822
da55d8a77390
revset: add pattern matching to 'bookmarks' revset expression
Simon King <simon@simonking.org.uk>
parents:
16821
diff
changeset
|
709 for bmrev in matchrevs: |
22499
8c9f9e346acc
revset: unify code flow in `bookmark`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22498
diff
changeset
|
710 bms.add(repo[bmrev].rev()) |
8c9f9e346acc
revset: unify code flow in `bookmark`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22498
diff
changeset
|
711 else: |
8c9f9e346acc
revset: unify code flow in `bookmark`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22498
diff
changeset
|
712 bms = set([repo[r].rev() |
8c9f9e346acc
revset: unify code flow in `bookmark`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22498
diff
changeset
|
713 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
|
714 bms -= set([node.nullrev]) |
22530
faf4f63533ff
revset: use `subset &` in `bookmark`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22529
diff
changeset
|
715 return subset & bms |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
716 |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
717 def branch(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
718 """``branch(string or set)`` |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
719 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
|
720 changesets. |
16821
0946502fd3d5
revset: add pattern matching to 'branch' revset expression
Simon King <simon@simonking.org.uk>
parents:
16820
diff
changeset
|
721 |
0946502fd3d5
revset: add pattern matching to 'branch' revset expression
Simon King <simon@simonking.org.uk>
parents:
16820
diff
changeset
|
722 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
|
723 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
|
724 use the prefix `literal:`. |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
725 """ |
24374
77fd1fb538cd
revbranchcache: store repo on the object
Durham Goode <durham@fb.com>
parents:
24366
diff
changeset
|
726 getbi = repo.revbranchcache().branchinfo |
23787
678f53865c68
revset: use localrepo revbranchcache for branch name filtering
Mads Kiilerich <madski@unity3d.com>
parents:
23765
diff
changeset
|
727 |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
728 try: |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
729 b = getstring(x, '') |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
730 except error.ParseError: |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
731 # 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
|
732 pass |
16821
0946502fd3d5
revset: add pattern matching to 'branch' revset expression
Simon King <simon@simonking.org.uk>
parents:
16820
diff
changeset
|
733 else: |
0946502fd3d5
revset: add pattern matching to 'branch' revset expression
Simon King <simon@simonking.org.uk>
parents:
16820
diff
changeset
|
734 kind, pattern, matcher = _stringmatcher(b) |
0946502fd3d5
revset: add pattern matching to 'branch' revset expression
Simon King <simon@simonking.org.uk>
parents:
16820
diff
changeset
|
735 if kind == 'literal': |
0946502fd3d5
revset: add pattern matching to 'branch' revset expression
Simon King <simon@simonking.org.uk>
parents:
16820
diff
changeset
|
736 # 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
|
737 # this name exists |
0946502fd3d5
revset: add pattern matching to 'branch' revset expression
Simon King <simon@simonking.org.uk>
parents:
16820
diff
changeset
|
738 if pattern in repo.branchmap(): |
24374
77fd1fb538cd
revbranchcache: store repo on the object
Durham Goode <durham@fb.com>
parents:
24366
diff
changeset
|
739 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
|
740 else: |
24374
77fd1fb538cd
revbranchcache: store repo on the object
Durham Goode <durham@fb.com>
parents:
24366
diff
changeset
|
741 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
|
742 |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
743 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
|
744 b = set() |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
745 for r in s: |
24374
77fd1fb538cd
revbranchcache: store repo on the object
Durham Goode <durham@fb.com>
parents:
24366
diff
changeset
|
746 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
|
747 c = s.__contains__ |
24374
77fd1fb538cd
revbranchcache: store repo on the object
Durham Goode <durham@fb.com>
parents:
24366
diff
changeset
|
748 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
|
749 |
17829
c73f7a28953c
revset: add a bumped revset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17825
diff
changeset
|
750 def bumped(repo, subset, x): |
c73f7a28953c
revset: add a bumped revset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17825
diff
changeset
|
751 """``bumped()`` |
c73f7a28953c
revset: add a bumped revset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17825
diff
changeset
|
752 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
|
753 |
c73f7a28953c
revset: add a bumped revset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17825
diff
changeset
|
754 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
|
755 """ |
c73f7a28953c
revset: add a bumped revset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17825
diff
changeset
|
756 # i18n: "bumped" is a keyword |
c73f7a28953c
revset: add a bumped revset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17825
diff
changeset
|
757 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
|
758 bumped = obsmod.getrevs(repo, 'bumped') |
20367
2ac278aab2b4
revset: added intersection to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20366
diff
changeset
|
759 return subset & bumped |
17829
c73f7a28953c
revset: add a bumped revset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17825
diff
changeset
|
760 |
17913
03e552aaae67
bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents:
17886
diff
changeset
|
761 def bundle(repo, subset, x): |
03e552aaae67
bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents:
17886
diff
changeset
|
762 """``bundle()`` |
03e552aaae67
bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents:
17886
diff
changeset
|
763 Changesets in the bundle. |
03e552aaae67
bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents:
17886
diff
changeset
|
764 |
03e552aaae67
bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents:
17886
diff
changeset
|
765 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
|
766 |
03e552aaae67
bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents:
17886
diff
changeset
|
767 try: |
18411
8b0f0dd56cec
bundlerepo: improve performance for bundle() revset expression
Mads Kiilerich <madski@unity3d.com>
parents:
18382
diff
changeset
|
768 bundlerevs = repo.changelog.bundlerevs |
17913
03e552aaae67
bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents:
17886
diff
changeset
|
769 except AttributeError: |
03e552aaae67
bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents:
17886
diff
changeset
|
770 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
|
771 return subset & bundlerevs |
17913
03e552aaae67
bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents:
17886
diff
changeset
|
772 |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
773 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
|
774 hasset = matchmod.patkind(pat) == 'set' |
20457
ed7b674824a3
revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20456
diff
changeset
|
775 |
23115
c23c03605c59
revset: don't recreate matcher for every revision
Martin von Zweigbergk <martinvonz@google.com>
parents:
23100
diff
changeset
|
776 mcache = [None] |
20457
ed7b674824a3
revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20456
diff
changeset
|
777 def matches(x): |
ed7b674824a3
revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20456
diff
changeset
|
778 c = repo[x] |
23115
c23c03605c59
revset: don't recreate matcher for every revision
Martin von Zweigbergk <martinvonz@google.com>
parents:
23100
diff
changeset
|
779 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
|
780 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
|
781 m = mcache[0] |
c23c03605c59
revset: don't recreate matcher for every revision
Martin von Zweigbergk <martinvonz@google.com>
parents:
23100
diff
changeset
|
782 fname = None |
c23c03605c59
revset: don't recreate matcher for every revision
Martin von Zweigbergk <martinvonz@google.com>
parents:
23100
diff
changeset
|
783 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
|
784 fname = m.files()[0] |
16521
592701c8eac6
revset: fix adds/modifies/removes and patterns (issue3403)
Patrick Mezard <patrick@mezard.eu>
parents:
16467
diff
changeset
|
785 if fname is not None: |
592701c8eac6
revset: fix adds/modifies/removes and patterns (issue3403)
Patrick Mezard <patrick@mezard.eu>
parents:
16467
diff
changeset
|
786 if fname not in c.files(): |
20457
ed7b674824a3
revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20456
diff
changeset
|
787 return False |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
788 else: |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
789 for f in c.files(): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
790 if m(f): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
791 break |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
792 else: |
20457
ed7b674824a3
revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20456
diff
changeset
|
793 return False |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
794 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
|
795 if fname is not None: |
592701c8eac6
revset: fix adds/modifies/removes and patterns (issue3403)
Patrick Mezard <patrick@mezard.eu>
parents:
16467
diff
changeset
|
796 if fname in files: |
20457
ed7b674824a3
revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20456
diff
changeset
|
797 return True |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
798 else: |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
799 for f in files: |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
800 if m(f): |
20457
ed7b674824a3
revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20456
diff
changeset
|
801 return True |
ed7b674824a3
revset: added lazyset implementation to checkstatus
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20456
diff
changeset
|
802 |
20611
6490f8385391
revset: changed revset code to use filter method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20610
diff
changeset
|
803 return subset.filter(matches) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
804 |
16396
03e408a122c4
revset: avoid set duplication in roots()
Patrick Mezard <patrick@mezard.eu>
parents:
16395
diff
changeset
|
805 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
|
806 if not parentset: |
3e9049876ace
revset: gratuitous code move in '_children'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25549
diff
changeset
|
807 return baseset() |
15899
476a981fdf34
revset: optimize roots and children
Matt Mackall <mpm@selenic.com>
parents:
15898
diff
changeset
|
808 cs = set() |
476a981fdf34
revset: optimize roots and children
Matt Mackall <mpm@selenic.com>
parents:
15898
diff
changeset
|
809 pr = repo.changelog.parentrevs |
25567
f140d6207cca
revset: use parentsets.min in _children
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25566
diff
changeset
|
810 minrev = parentset.min() |
16394
f3df7d34791e
revset: do not ignore input revisions in roots()
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
811 for r in narrow: |
18063
34a1a639d835
revset.children: ignore rev numbers that are too low
Siddharth Agarwal <sid0@fb.com>
parents:
17980
diff
changeset
|
812 if r <= minrev: |
34a1a639d835
revset.children: ignore rev numbers that are too low
Siddharth Agarwal <sid0@fb.com>
parents:
17980
diff
changeset
|
813 continue |
15899
476a981fdf34
revset: optimize roots and children
Matt Mackall <mpm@selenic.com>
parents:
15898
diff
changeset
|
814 for p in pr(r): |
16396
03e408a122c4
revset: avoid set duplication in roots()
Patrick Mezard <patrick@mezard.eu>
parents:
16395
diff
changeset
|
815 if p in parentset: |
15899
476a981fdf34
revset: optimize roots and children
Matt Mackall <mpm@selenic.com>
parents:
15898
diff
changeset
|
816 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
|
817 # 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
|
818 # 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
|
819 return baseset(cs) |
15899
476a981fdf34
revset: optimize roots and children
Matt Mackall <mpm@selenic.com>
parents:
15898
diff
changeset
|
820 |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
821 def children(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
822 """``children(set)`` |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
823 Child changesets of changesets in set. |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
824 """ |
23164
7a42e5d4c418
revset-children: call 'getset' on a 'fullreposet'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23163
diff
changeset
|
825 s = getset(repo, fullreposet(repo), x) |
15899
476a981fdf34
revset: optimize roots and children
Matt Mackall <mpm@selenic.com>
parents:
15898
diff
changeset
|
826 cs = _children(repo, subset, s) |
20367
2ac278aab2b4
revset: added intersection to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20366
diff
changeset
|
827 return subset & cs |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
828 |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
829 def closed(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
830 """``closed()`` |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
831 Changeset is closed. |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
832 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
833 # i18n: "closed" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
834 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
|
835 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
|
836 |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
837 def contains(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
838 """``contains(pattern)`` |
21199
e9c2f76be74b
help: clarify distinction among `contains`/`file`/`filelog`
Greg Hurrell <glh@fb.com>
parents:
21173
diff
changeset
|
839 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
|
840 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
|
841 |
96be25f1da45
revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20288
diff
changeset
|
842 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
|
843 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
|
844 for efficiency. |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
845 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
846 # i18n: "contains" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
847 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
|
848 |
abd8e56a1038
revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20460
diff
changeset
|
849 def matches(x): |
abd8e56a1038
revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20460
diff
changeset
|
850 if not matchmod.patkind(pat): |
abd8e56a1038
revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20460
diff
changeset
|
851 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
|
852 if pats in repo[x]: |
abd8e56a1038
revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20460
diff
changeset
|
853 return True |
abd8e56a1038
revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20460
diff
changeset
|
854 else: |
abd8e56a1038
revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20460
diff
changeset
|
855 c = repo[x] |
abd8e56a1038
revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20460
diff
changeset
|
856 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
|
857 for f in c.manifest(): |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
858 if m(f): |
20461
abd8e56a1038
revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20460
diff
changeset
|
859 return True |
abd8e56a1038
revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20460
diff
changeset
|
860 return False |
abd8e56a1038
revset: added lazyset implementation to contains revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20460
diff
changeset
|
861 |
20611
6490f8385391
revset: changed revset code to use filter method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20610
diff
changeset
|
862 return subset.filter(matches) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
863 |
17002
0eb522625eb2
revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents:
16862
diff
changeset
|
864 def converted(repo, subset, x): |
0eb522625eb2
revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents:
16862
diff
changeset
|
865 """``converted([id])`` |
0eb522625eb2
revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents:
16862
diff
changeset
|
866 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
|
867 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
|
868 """ |
0eb522625eb2
revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents:
16862
diff
changeset
|
869 |
0eb522625eb2
revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents:
16862
diff
changeset
|
870 # 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
|
871 # 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
|
872 |
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
|
873 rev = None |
17002
0eb522625eb2
revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents:
16862
diff
changeset
|
874 # i18n: "converted" is a keyword |
0eb522625eb2
revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents:
16862
diff
changeset
|
875 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
|
876 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
|
877 # 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
|
878 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
|
879 |
0eb522625eb2
revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents:
16862
diff
changeset
|
880 def _matchvalue(r): |
0eb522625eb2
revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents:
16862
diff
changeset
|
881 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
|
882 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
|
883 |
20611
6490f8385391
revset: changed revset code to use filter method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20610
diff
changeset
|
884 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
|
885 |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
886 def date(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
887 """``date(interval)`` |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
888 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
|
889 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
890 # i18n: "date" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
891 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
|
892 dm = util.matchdate(ds) |
20611
6490f8385391
revset: changed revset code to use filter method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20610
diff
changeset
|
893 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
|
894 |
14650
93731b3efd0d
revset: add desc(string) to search in commit messages
Thomas Arendsen Hein <thomas@intevation.de>
parents:
14649
diff
changeset
|
895 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
|
896 """``desc(string)`` |
93731b3efd0d
revset: add desc(string) to search in commit messages
Thomas Arendsen Hein <thomas@intevation.de>
parents:
14649
diff
changeset
|
897 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
|
898 """ |
93731b3efd0d
revset: add desc(string) to search in commit messages
Thomas Arendsen Hein <thomas@intevation.de>
parents:
14649
diff
changeset
|
899 # 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
|
900 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
|
901 |
a685d9870eb5
revset: added lazyset implementation to desc revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20451
diff
changeset
|
902 def matches(x): |
a685d9870eb5
revset: added lazyset implementation to desc revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20451
diff
changeset
|
903 c = repo[x] |
a685d9870eb5
revset: added lazyset implementation to desc revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20451
diff
changeset
|
904 return ds in encoding.lower(c.description()) |
a685d9870eb5
revset: added lazyset implementation to desc revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20451
diff
changeset
|
905 |
20611
6490f8385391
revset: changed revset code to use filter method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20610
diff
changeset
|
906 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
|
907 |
16409
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
908 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
|
909 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
|
910 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
|
911 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
|
912 s = _revdescendants(repo, roots, followfirst) |
20894
04e1596d5dbd
revset: improve _descendants performance
Durham Goode <durham@fb.com>
parents:
20863
diff
changeset
|
913 |
04e1596d5dbd
revset: improve _descendants performance
Durham Goode <durham@fb.com>
parents:
20863
diff
changeset
|
914 # 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
|
915 # 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
|
916 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
|
917 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
|
918 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
|
919 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
|
920 result.sort() |
1dd178277cf5
revset-_descendant: rework the whole sorting and combining logic
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22859
diff
changeset
|
921 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
|
922 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
|
923 else: |
1dd178277cf5
revset-_descendant: rework the whole sorting and combining logic
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22859
diff
changeset
|
924 result = subset & result |
22830
1d1da8abe130
_descendants: directly use smartset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22829
diff
changeset
|
925 return result |
16409
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
926 |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
927 def descendants(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
928 """``descendants(set)`` |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
929 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
|
930 """ |
16409
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
931 return _descendants(repo, subset, x) |
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
932 |
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
933 def _firstdescendants(repo, subset, x): |
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
934 # ``_firstdescendants(set)`` |
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
935 # 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
|
936 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
|
937 |
17186
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
938 def destination(repo, subset, x): |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
939 """``destination([set])`` |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
940 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
|
941 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
|
942 is the same as passing all(). |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
943 """ |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
944 if x is not None: |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
945 sources = getset(repo, fullreposet(repo), x) |
17186
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
946 else: |
24201
77ef059b3317
revset: drop unnecessary calls of getall() with empty argument
Yuya Nishihara <yuya@tcha.org>
parents:
24163
diff
changeset
|
947 sources = fullreposet(repo) |
17186
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
948 |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
949 dests = set() |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
950 |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
951 # 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
|
952 # 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
|
953 # 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
|
954 # 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
|
955 # 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
|
956 # grafts. |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
957 for r in subset: |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
958 src = _getrevsource(repo, r) |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
959 lineage = None |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
960 |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
961 while src is not None: |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
962 if lineage is None: |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
963 lineage = list() |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
964 |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
965 lineage.append(r) |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
966 |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
967 # 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
|
968 # set. Since every candidate dest is visited by way of iterating |
17494 | 969 # 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
|
970 # 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
|
971 # 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
|
972 # further. |
22944
5aae3dea8044
revset: better naming of variables containing the value of a single argument
Mads Kiilerich <madski@unity3d.com>
parents:
22891
diff
changeset
|
973 if src in sources or src in dests: |
17186
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
974 dests.update(lineage) |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
975 break |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
976 |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
977 r = src |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
978 src = _getrevsource(repo, r) |
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
979 |
21217
2195ac506c6a
revset: directly use __contains__ instead of a lambda
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21215
diff
changeset
|
980 return subset.filter(dests.__contains__) |
17186
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
981 |
18071
bea754715961
obsolete: add revset and test for divergent changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18063
diff
changeset
|
982 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
|
983 """``divergent()`` |
bea754715961
obsolete: add revset and test for divergent changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18063
diff
changeset
|
984 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
|
985 """ |
bea754715961
obsolete: add revset and test for divergent changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
18063
diff
changeset
|
986 # 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
|
987 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
|
988 divergent = obsmod.getrevs(repo, 'divergent') |
22533
5b65429721d5
revset: use `subset &` in `divergent`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22532
diff
changeset
|
989 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
|
990 |
17173
c621f84dbb35
obsolete: compute extinct changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17171
diff
changeset
|
991 def extinct(repo, subset, x): |
c621f84dbb35
obsolete: compute extinct changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17171
diff
changeset
|
992 """``extinct()`` |
17291
2d6bbf87f7b4
revset: minor doc fixes on obsolete related revsets
Patrick Mezard <patrick@mezard.eu>
parents:
17272
diff
changeset
|
993 Obsolete changesets with obsolete descendants only. |
2d6bbf87f7b4
revset: minor doc fixes on obsolete related revsets
Patrick Mezard <patrick@mezard.eu>
parents:
17272
diff
changeset
|
994 """ |
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
|
995 # 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
|
996 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
|
997 extincts = obsmod.getrevs(repo, 'extinct') |
20367
2ac278aab2b4
revset: added intersection to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20366
diff
changeset
|
998 return subset & extincts |
17173
c621f84dbb35
obsolete: compute extinct changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17171
diff
changeset
|
999 |
16661
de4b42daf396
revset: add function for matching extra data (issue2767)
Henrik Stuart <hg@hstuart.dk>
parents:
16657
diff
changeset
|
1000 def extra(repo, subset, x): |
de4b42daf396
revset: add function for matching extra data (issue2767)
Henrik Stuart <hg@hstuart.dk>
parents:
16657
diff
changeset
|
1001 """``extra(label, [value])`` |
de4b42daf396
revset: add function for matching extra data (issue2767)
Henrik Stuart <hg@hstuart.dk>
parents:
16657
diff
changeset
|
1002 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
|
1003 optional value. |
f3b8c82a559c
revset: add pattern matching to 'extra' revset expression
Simon King <simon@simonking.org.uk>
parents:
16823
diff
changeset
|
1004 |
f3b8c82a559c
revset: add pattern matching to 'extra' revset expression
Simon King <simon@simonking.org.uk>
parents:
16823
diff
changeset
|
1005 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
|
1006 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
|
1007 use the prefix `literal:`. |
f3b8c82a559c
revset: add pattern matching to 'extra' revset expression
Simon King <simon@simonking.org.uk>
parents:
16823
diff
changeset
|
1008 """ |
25767
026105c442d7
revset: rename getkwargs() to getargsdict()
Yuya Nishihara <yuya@tcha.org>
parents:
25766
diff
changeset
|
1009 args = getargsdict(x, 'extra', 'label value') |
25706
b7f53c474e2c
revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
25705
diff
changeset
|
1010 if 'label' not in args: |
b7f53c474e2c
revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
25705
diff
changeset
|
1011 # i18n: "extra" is a keyword |
b7f53c474e2c
revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
25705
diff
changeset
|
1012 raise error.ParseError(_('extra takes at least 1 argument')) |
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
|
1013 # i18n: "extra" is a keyword |
25706
b7f53c474e2c
revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
25705
diff
changeset
|
1014 label = getstring(args['label'], _('first argument to extra must be ' |
b7f53c474e2c
revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
25705
diff
changeset
|
1015 'a string')) |
16661
de4b42daf396
revset: add function for matching extra data (issue2767)
Henrik Stuart <hg@hstuart.dk>
parents:
16657
diff
changeset
|
1016 value = None |
de4b42daf396
revset: add function for matching extra data (issue2767)
Henrik Stuart <hg@hstuart.dk>
parents:
16657
diff
changeset
|
1017 |
25706
b7f53c474e2c
revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
25705
diff
changeset
|
1018 if 'value' in args: |
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
|
1019 # i18n: "extra" is a keyword |
25706
b7f53c474e2c
revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
25705
diff
changeset
|
1020 value = getstring(args['value'], _('second argument to extra must be ' |
b7f53c474e2c
revset: port extra() to support keyword arguments
Yuya Nishihara <yuya@tcha.org>
parents:
25705
diff
changeset
|
1021 'a string')) |
16824
f3b8c82a559c
revset: add pattern matching to 'extra' revset expression
Simon King <simon@simonking.org.uk>
parents:
16823
diff
changeset
|
1022 kind, value, matcher = _stringmatcher(value) |
16661
de4b42daf396
revset: add function for matching extra data (issue2767)
Henrik Stuart <hg@hstuart.dk>
parents:
16657
diff
changeset
|
1023 |
de4b42daf396
revset: add function for matching extra data (issue2767)
Henrik Stuart <hg@hstuart.dk>
parents:
16657
diff
changeset
|
1024 def _matchvalue(r): |
de4b42daf396
revset: add function for matching extra data (issue2767)
Henrik Stuart <hg@hstuart.dk>
parents:
16657
diff
changeset
|
1025 extra = repo[r].extra() |
16824
f3b8c82a559c
revset: add pattern matching to 'extra' revset expression
Simon King <simon@simonking.org.uk>
parents:
16823
diff
changeset
|
1026 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
|
1027 |
20611
6490f8385391
revset: changed revset code to use filter method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20610
diff
changeset
|
1028 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
|
1029 |
14342
c0b6a734b4f3
revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents:
14318
diff
changeset
|
1030 def filelog(repo, subset, x): |
c0b6a734b4f3
revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents:
14318
diff
changeset
|
1031 """``filelog(pattern)`` |
c0b6a734b4f3
revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents:
14318
diff
changeset
|
1032 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
|
1033 |
21199
e9c2f76be74b
help: clarify distinction among `contains`/`file`/`filelog`
Greg Hurrell <glh@fb.com>
parents:
21173
diff
changeset
|
1034 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
|
1035 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
|
1036 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
|
1037 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
|
1038 |
96be25f1da45
revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20288
diff
changeset
|
1039 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
|
1040 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
|
1041 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
|
1042 |
34364a4b25eb
linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23704
diff
changeset
|
1043 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
|
1044 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
|
1045 """ |
c0b6a734b4f3
revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents:
14318
diff
changeset
|
1046 |
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
|
1047 # 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
|
1048 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
|
1049 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
|
1050 cl = repo.changelog |
14342
c0b6a734b4f3
revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents:
14318
diff
changeset
|
1051 |
15964
6e37b8282aa2
revsets: provide contexts for filesets
Matt Mackall <mpm@selenic.com>
parents:
15949
diff
changeset
|
1052 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
|
1053 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
|
1054 files = [f] |
14342
c0b6a734b4f3
revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents:
14318
diff
changeset
|
1055 else: |
20288
b61ad01c4e73
revset: use "canonpath()" for "filelog()" pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20287
diff
changeset
|
1056 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
|
1057 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
|
1058 |
34364a4b25eb
linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23704
diff
changeset
|
1059 for f in files: |
23822
02f4560b69b7
filelog: fix backwards comment for 'backrevref'
Martin von Zweigbergk <martinvonz@google.com>
parents:
23821
diff
changeset
|
1060 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
|
1061 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
|
1062 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
|
1063 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
|
1064 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
|
1065 for fr in list(fl): |
23820
60178888be05
filelog: remove unused variable 'lkr'
Martin von Zweigbergk <martinvonz@google.com>
parents:
23787
diff
changeset
|
1066 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
|
1067 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
|
1068 # 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
|
1069 # 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
|
1070 delayed.append((fr, rev)) |
23821
7a7f437ab63d
filelog: remove trailing "form feed" character
Martin von Zweigbergk <martinvonz@google.com>
parents:
23820
diff
changeset
|
1071 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
|
1072 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
|
1073 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
|
1074 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
|
1075 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
|
1076 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
|
1077 |
34364a4b25eb
linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23704
diff
changeset
|
1078 # 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
|
1079 # 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
|
1080 # 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
|
1081 # 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
|
1082 # 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
|
1083 # have. |
34364a4b25eb
linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23704
diff
changeset
|
1084 # |
34364a4b25eb
linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23704
diff
changeset
|
1085 # 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
|
1086 # 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
|
1087 # 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
|
1088 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
|
1089 # 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
|
1090 # 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
|
1091 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
|
1092 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
|
1093 |
34364a4b25eb
linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23704
diff
changeset
|
1094 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
|
1095 |
34364a4b25eb
linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23704
diff
changeset
|
1096 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
|
1097 # 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
|
1098 # 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
|
1099 # - 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
|
1100 # 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
|
1101 # - 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
|
1102 # 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
|
1103 # 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
|
1104 # - 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
|
1105 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
|
1106 lowesthead = {} |
8ec03e0ef51a
linkrev-filelog: handle filtered linkrev with no visible children (issue4307)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23719
diff
changeset
|
1107 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
|
1108 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
|
1109 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
|
1110 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
|
1111 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
|
1112 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
|
1113 # 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
|
1114 continue |
8ec03e0ef51a
linkrev-filelog: handle filtered linkrev with no visible children (issue4307)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23719
diff
changeset
|
1115 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
|
1116 else: |
34364a4b25eb
linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23704
diff
changeset
|
1117 # 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
|
1118 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
|
1119 # 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
|
1120 # 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
|
1121 # 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
|
1122 # 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
|
1123 # 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
|
1124 # 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
|
1125 # 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
|
1126 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
|
1127 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
|
1128 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
|
1129 break |
34364a4b25eb
linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23704
diff
changeset
|
1130 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
|
1131 # 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
|
1132 # 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
|
1133 # 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
|
1134 continue |
34364a4b25eb
linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23704
diff
changeset
|
1135 |
34364a4b25eb
linkrev: work around linkrev to filtered entry in 'filelog' revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23704
diff
changeset
|
1136 # 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
|
1137 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
|
1138 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
|
1139 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
|
1140 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
|
1141 s.add(rev) |
14342
c0b6a734b4f3
revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents:
14318
diff
changeset
|
1142 |
22534
6261b9c549a2
revset: use `subset &` in `filelog`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22533
diff
changeset
|
1143 return subset & s |
14342
c0b6a734b4f3
revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents:
14318
diff
changeset
|
1144 |
15117
0ab1c3a1f3b2
revsets: add first alias for last
Matt Mackall <mpm@selenic.com>
parents:
15116
diff
changeset
|
1145 def first(repo, subset, x): |
0ab1c3a1f3b2
revsets: add first alias for last
Matt Mackall <mpm@selenic.com>
parents:
15116
diff
changeset
|
1146 """``first(set, [n])`` |
0ab1c3a1f3b2
revsets: add first alias for last
Matt Mackall <mpm@selenic.com>
parents:
15116
diff
changeset
|
1147 An alias for limit(). |
0ab1c3a1f3b2
revsets: add first alias for last
Matt Mackall <mpm@selenic.com>
parents:
15116
diff
changeset
|
1148 """ |
0ab1c3a1f3b2
revsets: add first alias for last
Matt Mackall <mpm@selenic.com>
parents:
15116
diff
changeset
|
1149 return limit(repo, subset, x) |
0ab1c3a1f3b2
revsets: add first alias for last
Matt Mackall <mpm@selenic.com>
parents:
15116
diff
changeset
|
1150 |
16185
352053e6cd8e
context: add followfirst arg to filectx and workingfilectx
Patrick Mezard <patrick@mezard.eu>
parents:
16181
diff
changeset
|
1151 def _follow(repo, subset, x, name, followfirst=False): |
26102
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
1152 l = getargs(x, 0, 1, _("%s takes no arguments or a pattern") % name) |
16185
352053e6cd8e
context: add followfirst arg to filectx and workingfilectx
Patrick Mezard <patrick@mezard.eu>
parents:
16181
diff
changeset
|
1153 c = repo['.'] |
352053e6cd8e
context: add followfirst arg to filectx and workingfilectx
Patrick Mezard <patrick@mezard.eu>
parents:
16181
diff
changeset
|
1154 if l: |
26102
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
1155 x = getstring(l[0], _("%s expected a pattern") % name) |
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
1156 matcher = matchmod.match(repo.root, repo.getcwd(), [x], |
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
1157 ctx=repo[None], default='path') |
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
1158 |
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
1159 s = set() |
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
1160 for fname in c: |
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
1161 if matcher(fname): |
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
1162 fctx = c[fname] |
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
1163 s = s.union(set(c.rev() for c in fctx.ancestors(followfirst))) |
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
1164 # include the revision responsible for the most recent version |
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
1165 s.add(fctx.introrev()) |
16185
352053e6cd8e
context: add followfirst arg to filectx and workingfilectx
Patrick Mezard <patrick@mezard.eu>
parents:
16181
diff
changeset
|
1166 else: |
20690
13c0327eeb6f
revset: changed ancestors revset to return lazy generators
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20659
diff
changeset
|
1167 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
|
1168 |
22535
44f471102f3a
revset: use `subset &` in `follow`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22534
diff
changeset
|
1169 return subset & s |
16185
352053e6cd8e
context: add followfirst arg to filectx and workingfilectx
Patrick Mezard <patrick@mezard.eu>
parents:
16181
diff
changeset
|
1170 |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1171 def follow(repo, subset, x): |
26102
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
1172 """``follow([pattern])`` |
24366
e8ea31131705
revset: replace "working copy" with "working directory" in function help
Yuya Nishihara <yuya@tcha.org>
parents:
24306
diff
changeset
|
1173 An alias for ``::.`` (ancestors of the working directory's first parent). |
26102
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
1174 If pattern is specified, the histories of files matching given |
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
1175 pattern is followed, including copies. |
14343
9ed227f79e47
revset: add follow(filename) to follow a filename's history across copies
Matt Mackall <mpm@selenic.com>
parents:
14342
diff
changeset
|
1176 """ |
16185
352053e6cd8e
context: add followfirst arg to filectx and workingfilectx
Patrick Mezard <patrick@mezard.eu>
parents:
16181
diff
changeset
|
1177 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
|
1178 |
16174
0a73c4bd9f47
graphlog: implement --follow-first
Patrick Mezard <patrick@mezard.eu>
parents:
16161
diff
changeset
|
1179 def _followfirst(repo, subset, x): |
26102
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
1180 # ``followfirst([pattern])`` |
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
1181 # Like ``follow([pattern])`` but follows only the first parent of |
5618858dce26
revsets: makes follow() supports file patterns (issue4757) (BC)
liscju <piotr.listkiewicz@gmail.com>
parents:
26099
diff
changeset
|
1182 # every revisions or files revisions. |
16185
352053e6cd8e
context: add followfirst arg to filectx and workingfilectx
Patrick Mezard <patrick@mezard.eu>
parents:
16181
diff
changeset
|
1183 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
|
1184 |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1185 def getall(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1186 """``all()`` |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1187 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
|
1188 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1189 # i18n: "all" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1190 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
|
1191 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
|
1192 |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1193 def grep(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1194 """``grep(regex)`` |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1195 Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')`` |
14357 | 1196 to ensure special escape characters are handled correctly. Unlike |
1197 ``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
|
1198 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1199 try: |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1200 # i18n: "grep" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1201 gr = re.compile(getstring(x, _("grep requires a string"))) |
25660
328739ea70c3
global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25654
diff
changeset
|
1202 except re.error as e: |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1203 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
|
1204 |
6aa7dcae6bd8
revset: added lazyset implementation to grep revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20452
diff
changeset
|
1205 def matches(x): |
6aa7dcae6bd8
revset: added lazyset implementation to grep revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20452
diff
changeset
|
1206 c = repo[x] |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1207 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
|
1208 if gr.search(e): |
20453
6aa7dcae6bd8
revset: added lazyset implementation to grep revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20452
diff
changeset
|
1209 return True |
6aa7dcae6bd8
revset: added lazyset implementation to grep revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20452
diff
changeset
|
1210 return False |
6aa7dcae6bd8
revset: added lazyset implementation to grep revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20452
diff
changeset
|
1211 |
20611
6490f8385391
revset: changed revset code to use filter method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20610
diff
changeset
|
1212 return subset.filter(matches) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1213 |
16161
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1214 def _matchfiles(repo, subset, x): |
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1215 # _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
|
1216 # |
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1217 # [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
|
1218 # |
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1219 # 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
|
1220 # 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
|
1221 # 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
|
1222 # 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
|
1223 # 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
|
1224 # 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
|
1225 # 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
|
1226 |
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1227 # i18n: "_matchfiles" is a keyword |
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1228 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
|
1229 pats, inc, exc = [], [], [] |
16411
4c2edcd84175
graphlog: correctly handle calls in subdirectories
Patrick Mezard <patrick@mezard.eu>
parents:
16409
diff
changeset
|
1230 rev, default = None, None |
16161
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1231 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
|
1232 # 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
|
1233 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
|
1234 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
|
1235 if prefix == 'p:': |
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1236 pats.append(value) |
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1237 elif prefix == 'i:': |
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1238 inc.append(value) |
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1239 elif prefix == 'x:': |
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1240 exc.append(value) |
16181
1fd352aa08fc
graphlog: evaluate FILE/-I/-X filesets on the working dir
Patrick Mezard <patrick@mezard.eu>
parents:
16174
diff
changeset
|
1241 elif prefix == 'r:': |
1fd352aa08fc
graphlog: evaluate FILE/-I/-X filesets on the working dir
Patrick Mezard <patrick@mezard.eu>
parents:
16174
diff
changeset
|
1242 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
|
1243 # 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
|
1244 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
|
1245 'revision')) |
23950
caff3675cba5
log: evaluate filesets on working copy, not its parent
Martin von Zweigbergk <martinvonz@google.com>
parents:
23847
diff
changeset
|
1246 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
|
1247 rev = value |
16411
4c2edcd84175
graphlog: correctly handle calls in subdirectories
Patrick Mezard <patrick@mezard.eu>
parents:
16409
diff
changeset
|
1248 elif prefix == 'd:': |
4c2edcd84175
graphlog: correctly handle calls in subdirectories
Patrick Mezard <patrick@mezard.eu>
parents:
16409
diff
changeset
|
1249 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
|
1250 # i18n: "_matchfiles" is a keyword |
16411
4c2edcd84175
graphlog: correctly handle calls in subdirectories
Patrick Mezard <patrick@mezard.eu>
parents:
16409
diff
changeset
|
1251 raise error.ParseError(_('_matchfiles expected at most one ' |
4c2edcd84175
graphlog: correctly handle calls in subdirectories
Patrick Mezard <patrick@mezard.eu>
parents:
16409
diff
changeset
|
1252 'default mode')) |
4c2edcd84175
graphlog: correctly handle calls in subdirectories
Patrick Mezard <patrick@mezard.eu>
parents:
16409
diff
changeset
|
1253 default = value |
16161
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1254 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
|
1255 # 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
|
1256 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
|
1257 if not default: |
4c2edcd84175
graphlog: correctly handle calls in subdirectories
Patrick Mezard <patrick@mezard.eu>
parents:
16409
diff
changeset
|
1258 default = 'glob' |
20458
8dabcc889e33
revset: added lazyset implementation to _matchfiles
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20457
diff
changeset
|
1259 |
23061
f2aeff8a87b6
revset: avoid recalculating filesets
Matt Mackall <mpm@selenic.com>
parents:
23019
diff
changeset
|
1260 m = matchmod.match(repo.root, repo.getcwd(), pats, include=inc, |
f2aeff8a87b6
revset: avoid recalculating filesets
Matt Mackall <mpm@selenic.com>
parents:
23019
diff
changeset
|
1261 exclude=exc, ctx=repo[rev], default=default) |
f2aeff8a87b6
revset: avoid recalculating filesets
Matt Mackall <mpm@selenic.com>
parents:
23019
diff
changeset
|
1262 |
20458
8dabcc889e33
revset: added lazyset implementation to _matchfiles
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20457
diff
changeset
|
1263 def matches(x): |
23061
f2aeff8a87b6
revset: avoid recalculating filesets
Matt Mackall <mpm@selenic.com>
parents:
23019
diff
changeset
|
1264 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
|
1265 if m(f): |
20458
8dabcc889e33
revset: added lazyset implementation to _matchfiles
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20457
diff
changeset
|
1266 return True |
8dabcc889e33
revset: added lazyset implementation to _matchfiles
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20457
diff
changeset
|
1267 return False |
8dabcc889e33
revset: added lazyset implementation to _matchfiles
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20457
diff
changeset
|
1268 |
20611
6490f8385391
revset: changed revset code to use filter method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20610
diff
changeset
|
1269 return subset.filter(matches) |
16161
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
1270 |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1271 def hasfile(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1272 """``file(pattern)`` |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1273 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
|
1274 |
17265
c30307eeec4b
revset: polish explanation of the difference between file() and filelog()
Greg Ward <greg@gerg.ca>
parents:
17259
diff
changeset
|
1275 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
|
1276 instead. |
20289
96be25f1da45
revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20288
diff
changeset
|
1277 |
96be25f1da45
revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20288
diff
changeset
|
1278 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
|
1279 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1280 # i18n: "file" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1281 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
|
1282 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
|
1283 |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1284 def head(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1285 """``head()`` |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1286 Changeset is a named branch head. |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1287 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1288 # i18n: "head" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1289 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
|
1290 hs = set() |
25620
5f87f2305ad0
revset: translate node directly with changelog in 'head'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25619
diff
changeset
|
1291 cl = repo.changelog |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1292 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
|
1293 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
|
1294 # 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
|
1295 # This does not break because of other fullreposet misbehavior. |
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
|
1296 # 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
|
1297 # necessary to ensure we preserve the order in subset. |
25634
1ddefcfcd3e6
revsets: use '&' instead of '.filter' in head
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25632
diff
changeset
|
1298 return baseset(hs) & subset |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1299 |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1300 def heads(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1301 """``heads(set)`` |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1302 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
|
1303 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1304 s = getset(repo, subset, x) |
20366
5ec6321f49a9
revset: added substraction to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20365
diff
changeset
|
1305 ps = parents(repo, subset, x) |
5ec6321f49a9
revset: added substraction to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20365
diff
changeset
|
1306 return s - ps |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1307 |
17390
74b44f25b4b1
revset: add hidden() revset
Patrick Mezard <patrick@mezard.eu>
parents:
17291
diff
changeset
|
1308 def hidden(repo, subset, x): |
74b44f25b4b1
revset: add hidden() revset
Patrick Mezard <patrick@mezard.eu>
parents:
17291
diff
changeset
|
1309 """``hidden()`` |
74b44f25b4b1
revset: add hidden() revset
Patrick Mezard <patrick@mezard.eu>
parents:
17291
diff
changeset
|
1310 Hidden changesets. |
74b44f25b4b1
revset: add hidden() revset
Patrick Mezard <patrick@mezard.eu>
parents:
17291
diff
changeset
|
1311 """ |
74b44f25b4b1
revset: add hidden() revset
Patrick Mezard <patrick@mezard.eu>
parents:
17291
diff
changeset
|
1312 # i18n: "hidden" is a keyword |
74b44f25b4b1
revset: add hidden() revset
Patrick Mezard <patrick@mezard.eu>
parents:
17291
diff
changeset
|
1313 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
|
1314 hiddenrevs = repoview.filterrevs(repo, 'visible') |
20367
2ac278aab2b4
revset: added intersection to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20366
diff
changeset
|
1315 return subset & hiddenrevs |
17390
74b44f25b4b1
revset: add hidden() revset
Patrick Mezard <patrick@mezard.eu>
parents:
17291
diff
changeset
|
1316 |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1317 def keyword(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1318 """``keyword(string)`` |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1319 Search commit message, user name, and names of changed files for |
14357 | 1320 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
|
1321 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1322 # 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
|
1323 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
|
1324 |
abb91b74f758
revset: added lazyset implementation to keyword revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20446
diff
changeset
|
1325 def matches(r): |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1326 c = repo[r] |
25551
c1d163ce7394
revset: gratuitous formating fix in keyword
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25550
diff
changeset
|
1327 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
|
1328 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
|
1329 |
20611
6490f8385391
revset: changed revset code to use filter method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20610
diff
changeset
|
1330 return subset.filter(matches) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1331 |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1332 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
|
1333 """``limit(set, [n])`` |
d8501bcbb221
revset: add default of 1 to limit and last functions
Matt Mackall <mpm@selenic.com>
parents:
14901
diff
changeset
|
1334 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
|
1335 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1336 # 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
|
1337 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
|
1338 try: |
15116
d8501bcbb221
revset: add default of 1 to limit and last functions
Matt Mackall <mpm@selenic.com>
parents:
14901
diff
changeset
|
1339 lim = 1 |
d8501bcbb221
revset: add default of 1 to limit and last functions
Matt Mackall <mpm@selenic.com>
parents:
14901
diff
changeset
|
1340 if len(l) == 2: |
d8501bcbb221
revset: add default of 1 to limit and last functions
Matt Mackall <mpm@selenic.com>
parents:
14901
diff
changeset
|
1341 # 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
|
1342 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
|
1343 except (TypeError, ValueError): |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1344 # i18n: "limit" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1345 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
|
1346 ss = subset |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
1347 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
|
1348 result = [] |
20446
d258486604f4
revset: changed limit revset implementation to work with lazy revsets
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20445
diff
changeset
|
1349 it = iter(os) |
d258486604f4
revset: changed limit revset implementation to work with lazy revsets
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20445
diff
changeset
|
1350 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
|
1351 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
|
1352 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
|
1353 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
|
1354 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
|
1355 result.append(y) |
22804
5385314e0b14
revset-limit: remove user of baseset.append
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22802
diff
changeset
|
1356 return baseset(result) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1357 |
14061
611d2f8a4ba2
revsets: add a last function
Matt Mackall <mpm@selenic.com>
parents:
14057
diff
changeset
|
1358 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
|
1359 """``last(set, [n])`` |
d8501bcbb221
revset: add default of 1 to limit and last functions
Matt Mackall <mpm@selenic.com>
parents:
14901
diff
changeset
|
1360 Last n members of set, defaulting to 1. |
14061
611d2f8a4ba2
revsets: add a last function
Matt Mackall <mpm@selenic.com>
parents:
14057
diff
changeset
|
1361 """ |
611d2f8a4ba2
revsets: add a last function
Matt Mackall <mpm@selenic.com>
parents:
14057
diff
changeset
|
1362 # 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
|
1363 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
|
1364 try: |
15116
d8501bcbb221
revset: add default of 1 to limit and last functions
Matt Mackall <mpm@selenic.com>
parents:
14901
diff
changeset
|
1365 lim = 1 |
d8501bcbb221
revset: add default of 1 to limit and last functions
Matt Mackall <mpm@selenic.com>
parents:
14901
diff
changeset
|
1366 if len(l) == 2: |
d8501bcbb221
revset: add default of 1 to limit and last functions
Matt Mackall <mpm@selenic.com>
parents:
14901
diff
changeset
|
1367 # 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
|
1368 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
|
1369 except (TypeError, ValueError): |
14061
611d2f8a4ba2
revsets: add a last function
Matt Mackall <mpm@selenic.com>
parents:
14057
diff
changeset
|
1370 # i18n: "last" is a keyword |
611d2f8a4ba2
revsets: add a last function
Matt Mackall <mpm@selenic.com>
parents:
14057
diff
changeset
|
1371 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
|
1372 ss = subset |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
1373 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
|
1374 os.reverse() |
22805
e74245b79901
revset-last: remove user of baseset.append
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22804
diff
changeset
|
1375 result = [] |
20534
4849f574aa24
revset: changed last implementation to use lazy classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20527
diff
changeset
|
1376 it = iter(os) |
4849f574aa24
revset: changed last implementation to use lazy classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20527
diff
changeset
|
1377 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
|
1378 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
|
1379 if y is None: |
20534
4849f574aa24
revset: changed last implementation to use lazy classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20527
diff
changeset
|
1380 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
|
1381 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
|
1382 result.append(y) |
22805
e74245b79901
revset-last: remove user of baseset.append
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22804
diff
changeset
|
1383 return baseset(result) |
14061
611d2f8a4ba2
revsets: add a last function
Matt Mackall <mpm@selenic.com>
parents:
14057
diff
changeset
|
1384 |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1385 def maxrev(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1386 """``max(set)`` |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1387 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
|
1388 """ |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
1389 os = getset(repo, fullreposet(repo), x) |
26305
ade5c488d622
revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents:
26304
diff
changeset
|
1390 try: |
20754
f15ff553b762
revset: changed minrev and maxrev implementations to use ordered sets
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20753
diff
changeset
|
1391 m = os.max() |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1392 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
|
1393 return baseset([m]) |
26305
ade5c488d622
revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents:
26304
diff
changeset
|
1394 except ValueError: |
ade5c488d622
revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents:
26304
diff
changeset
|
1395 # os.max() throws a ValueError when the collection is empty. |
ade5c488d622
revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents:
26304
diff
changeset
|
1396 # Same as python's max(). |
ade5c488d622
revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents:
26304
diff
changeset
|
1397 pass |
22802
1fcd361efaf4
baseset: use default value instead of [] when possible
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22801
diff
changeset
|
1398 return baseset() |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1399 |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1400 def merge(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1401 """``merge()`` |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1402 Changeset is a merge changeset. |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1403 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1404 # i18n: "merge" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1405 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
|
1406 cl = repo.changelog |
20611
6490f8385391
revset: changed revset code to use filter method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20610
diff
changeset
|
1407 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
|
1408 |
17753
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1409 def branchpoint(repo, subset, x): |
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1410 """``branchpoint()`` |
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1411 Changesets with more than one child. |
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1412 """ |
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1413 # i18n: "branchpoint" is a keyword |
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1414 getargs(x, 0, 0, _("branchpoint takes no arguments")) |
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1415 cl = repo.changelog |
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1416 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
|
1417 return baseset() |
25549
f93ff3ab8d14
revset: mark spots that should use 'smartset.min()'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25548
diff
changeset
|
1418 # 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
|
1419 # (and if it is not, it should.) |
17753
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1420 baserev = min(subset) |
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1421 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
|
1422 for r in cl.revs(start=baserev + 1): |
17753
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1423 for p in cl.parentrevs(r): |
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1424 if p >= baserev: |
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1425 parentscount[p - baserev] += 1 |
20611
6490f8385391
revset: changed revset code to use filter method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20610
diff
changeset
|
1426 return subset.filter(lambda r: parentscount[r - baserev] > 1) |
17753
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
1427 |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1428 def minrev(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1429 """``min(set)`` |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1430 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
|
1431 """ |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
1432 os = getset(repo, fullreposet(repo), x) |
26305
ade5c488d622
revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents:
26304
diff
changeset
|
1433 try: |
20754
f15ff553b762
revset: changed minrev and maxrev implementations to use ordered sets
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20753
diff
changeset
|
1434 m = os.min() |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1435 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
|
1436 return baseset([m]) |
26305
ade5c488d622
revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents:
26304
diff
changeset
|
1437 except ValueError: |
ade5c488d622
revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents:
26304
diff
changeset
|
1438 # os.min() throws a ValueError when the collection is empty. |
ade5c488d622
revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents:
26304
diff
changeset
|
1439 # Same as python's min(). |
ade5c488d622
revset: remove existence check from min() and max()
Durham Goode <durham@fb.com>
parents:
26304
diff
changeset
|
1440 pass |
22802
1fcd361efaf4
baseset: use default value instead of [] when possible
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22801
diff
changeset
|
1441 return baseset() |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1442 |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1443 def modifies(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1444 """``modifies(pattern)`` |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1445 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
|
1446 |
96be25f1da45
revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20288
diff
changeset
|
1447 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
|
1448 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
|
1449 directory. |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1450 """ |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1451 # i18n: "modifies" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1452 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
|
1453 return checkstatus(repo, subset, pat, 0) |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1454 |
23836
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1455 def named(repo, subset, x): |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1456 """``named(namespace)`` |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1457 The changesets in a given namespace. |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1458 |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1459 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
|
1460 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
|
1461 use the prefix `literal:`. |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1462 """ |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1463 # i18n: "named" is a keyword |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1464 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
|
1465 |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1466 ns = getstring(args[0], |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1467 # i18n: "named" is a keyword |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1468 _('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
|
1469 kind, pattern, matcher = _stringmatcher(ns) |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1470 namespaces = set() |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1471 if kind == 'literal': |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1472 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
|
1473 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
|
1474 % ns) |
23836
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1475 namespaces.add(repo.names[pattern]) |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1476 else: |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1477 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
|
1478 if matcher(name): |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1479 namespaces.add(ns) |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1480 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
|
1481 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
|
1482 " that match '%s'") % pattern) |
23836
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1483 |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1484 names = set() |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1485 for ns in namespaces: |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1486 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
|
1487 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
|
1488 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
|
1489 |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1490 names -= set([node.nullrev]) |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1491 return subset & names |
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
1492 |
16417
b4b0c6931e11
revset: avoid demandimport bug
Matt Mackall <mpm@selenic.com>
parents:
16415
diff
changeset
|
1493 def node_(repo, subset, x): |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1494 """``id(string)`` |
12859
76066903ae08
revset: fix missing dot in docstring
Wagner Bruna <wbruna@yahoo.com>
parents:
12855
diff
changeset
|
1495 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
|
1496 """ |
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
1497 # 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
|
1498 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
|
1499 # 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
|
1500 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
|
1501 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
|
1502 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
|
1503 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
|
1504 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
|
1505 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
|
1506 else: |
16735
47b8ec0eb7fb
revset: fix traceback for bogus revisions in id(rev)
Matt Harbison <matt_harbison@yahoo.com>
parents:
16640
diff
changeset
|
1507 rn = None |
47b8ec0eb7fb
revset: fix traceback for bogus revisions in id(rev)
Matt Harbison <matt_harbison@yahoo.com>
parents:
16640
diff
changeset
|
1508 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
|
1509 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
|
1510 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
|
1511 |
23005
9bfe68357c01
revset-node: speedup by a few hundred fold
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23004
diff
changeset
|
1512 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
|
1513 return baseset() |
9bfe68357c01
revset-node: speedup by a few hundred fold
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23004
diff
changeset
|
1514 result = baseset([rn]) |
9bfe68357c01
revset-node: speedup by a few hundred fold
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23004
diff
changeset
|
1515 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
|
1516 |
17170
63a4a3871607
revset: add an `obsolete` symbol
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17102
diff
changeset
|
1517 def obsolete(repo, subset, x): |
63a4a3871607
revset: add an `obsolete` symbol
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17102
diff
changeset
|
1518 """``obsolete()`` |
63a4a3871607
revset: add an `obsolete` symbol
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17102
diff
changeset
|
1519 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
|
1520 # i18n: "obsolete" is a keyword |
17170
63a4a3871607
revset: add an `obsolete` symbol
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17102
diff
changeset
|
1521 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
|
1522 obsoletes = obsmod.getrevs(repo, 'obsolete') |
20367
2ac278aab2b4
revset: added intersection to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20366
diff
changeset
|
1523 return subset & obsoletes |
17170
63a4a3871607
revset: add an `obsolete` symbol
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17102
diff
changeset
|
1524 |
23466
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1525 def only(repo, subset, x): |
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1526 """``only(set, [set])`` |
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1527 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
|
1528 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
|
1529 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
|
1530 (i.e. ::<set1> - ::<set2>). |
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1531 """ |
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1532 cl = repo.changelog |
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1533 # i18n: "only" is a keyword |
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1534 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
|
1535 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
|
1536 if len(args) == 1: |
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1537 if not include: |
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1538 return baseset() |
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1539 |
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1540 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
|
1541 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
|
1542 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
|
1543 else: |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
1544 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
|
1545 |
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1546 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
|
1547 # 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
|
1548 # 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
|
1549 return subset & results |
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
1550 |
17185
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1551 def origin(repo, subset, x): |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1552 """``origin([set])`` |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1553 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
|
1554 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
|
1555 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
|
1556 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
|
1557 for the first operation is selected. |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1558 """ |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1559 if x is not None: |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
1560 dests = getset(repo, fullreposet(repo), x) |
17185
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1561 else: |
24201
77ef059b3317
revset: drop unnecessary calls of getall() with empty argument
Yuya Nishihara <yuya@tcha.org>
parents:
24163
diff
changeset
|
1562 dests = fullreposet(repo) |
17185
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1563 |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1564 def _firstsrc(rev): |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1565 src = _getrevsource(repo, rev) |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1566 if src is None: |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1567 return None |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1568 |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1569 while True: |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1570 prev = _getrevsource(repo, src) |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1571 |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1572 if prev is None: |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1573 return src |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1574 src = prev |
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1575 |
22944
5aae3dea8044
revset: better naming of variables containing the value of a single argument
Mads Kiilerich <madski@unity3d.com>
parents:
22891
diff
changeset
|
1576 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
|
1577 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
|
1578 # 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
|
1579 # 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
|
1580 return subset & o |
17185
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
1581 |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1582 def outgoing(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1583 """``outgoing([path])`` |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1584 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
|
1585 default push location. |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1586 """ |
24722
02a5618e2fbf
revset: don't import discovery at module level
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24708
diff
changeset
|
1587 # Avoid cycles. |
25971
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
1588 from . import ( |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
1589 discovery, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
1590 hg, |
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
1591 ) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1592 # 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
|
1593 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
|
1594 # i18n: "outgoing" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1595 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
|
1596 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
|
1597 dest, branches = hg.parseurl(dest) |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1598 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
|
1599 if revs: |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1600 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
|
1601 other = hg.peer(repo, {}, dest) |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1602 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
|
1603 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
|
1604 repo.ui.popbuffer() |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1605 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
|
1606 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
|
1607 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
|
1608 |
11275 | 1609 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
|
1610 """``p1([set])`` |
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
1611 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
|
1612 """ |
12928
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
1613 if x is None: |
13878
a8d13ee0ce68
misc: replace .parents()[0] with p1()
Matt Mackall <mpm@selenic.com>
parents:
13873
diff
changeset
|
1614 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
|
1615 if p >= 0: |
a428db9ab61d
revset: use `subset &` in bare `p1()`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22537
diff
changeset
|
1616 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
|
1617 return baseset() |
12928
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
1618 |
11275 | 1619 ps = set() |
1620 cl = repo.changelog | |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
1621 for r in getset(repo, fullreposet(repo), x): |
11275 | 1622 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
|
1623 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
|
1624 # 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
|
1625 # 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
|
1626 return subset & ps |
11275 | 1627 |
1628 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
|
1629 """``p2([set])`` |
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
1630 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
|
1631 """ |
12928
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
1632 if x is None: |
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
1633 ps = repo[x].parents() |
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
1634 try: |
12935
98b79c892768
revset: fix p1, p2 and parents in dirstate case (a5f7f1e9340e)
Patrick Mezard <pmezard@gmail.com>
parents:
12929
diff
changeset
|
1635 p = ps[1].rev() |
22539
6f434ef54222
revset: use `subset &` in bare `p2()`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22538
diff
changeset
|
1636 if p >= 0: |
6f434ef54222
revset: use `subset &` in bare `p2()`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22538
diff
changeset
|
1637 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
|
1638 return baseset() |
12928
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
1639 except IndexError: |
22802
1fcd361efaf4
baseset: use default value instead of [] when possible
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22801
diff
changeset
|
1640 return baseset() |
12928
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
1641 |
11275 | 1642 ps = set() |
1643 cl = repo.changelog | |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
1644 for r in getset(repo, fullreposet(repo), x): |
11275 | 1645 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
|
1646 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
|
1647 # 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
|
1648 # 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
|
1649 return subset & ps |
11275 | 1650 |
1651 def parents(repo, subset, x): | |
12929
515c2786e1cf
revsets: let parents() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12928
diff
changeset
|
1652 """``parents([set])`` |
515c2786e1cf
revsets: let parents() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12928
diff
changeset
|
1653 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
|
1654 """ |
12929
515c2786e1cf
revsets: let parents() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12928
diff
changeset
|
1655 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
|
1656 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
|
1657 else: |
35af9361a049
revset: refactor parents() into a single return point
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22495
diff
changeset
|
1658 ps = set() |
35af9361a049
revset: refactor parents() into a single return point
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22495
diff
changeset
|
1659 cl = repo.changelog |
25716
d50677c3bf44
revset: prefetch method in "parents"
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25706
diff
changeset
|
1660 up = ps.update |
d50677c3bf44
revset: prefetch method in "parents"
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25706
diff
changeset
|
1661 parentrevs = cl.parentrevs |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
1662 for r in getset(repo, fullreposet(repo), x): |
25765
5e1b0739611c
revset: use integer representation of wdir() in revset
Yuya Nishihara <yuya@tcha.org>
parents:
25716
diff
changeset
|
1663 if r == node.wdirrev: |
25716
d50677c3bf44
revset: prefetch method in "parents"
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25706
diff
changeset
|
1664 up(p.rev() for p in repo[r].parents()) |
25689
1cce81121472
revset: fix a crash in parents() when 'wdir()' is in the set
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1665 else: |
25716
d50677c3bf44
revset: prefetch method in "parents"
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25706
diff
changeset
|
1666 up(parentrevs(r)) |
22497
8ea3f47bcaff
revset: remove nullrev from set computed in parents()
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22496
diff
changeset
|
1667 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
|
1668 return subset & ps |
11275 | 1669 |
25621
21a874693619
revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25620
diff
changeset
|
1670 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
|
1671 """helper to select all rev in phase <target>""" |
25622
85294076adce
revset: make use of natively-computed set for 'draft()' and 'secret()'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25621
diff
changeset
|
1672 repo._phasecache.loadphaserevs(repo) # ensure phase's sets are loaded |
85294076adce
revset: make use of natively-computed set for 'draft()' and 'secret()'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25621
diff
changeset
|
1673 if repo._phasecache._phasesets: |
85294076adce
revset: make use of natively-computed set for 'draft()' and 'secret()'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25621
diff
changeset
|
1674 s = repo._phasecache._phasesets[target] - repo.changelog.filteredrevs |
85294076adce
revset: make use of natively-computed set for 'draft()' and 'secret()'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25621
diff
changeset
|
1675 s = baseset(s) |
85294076adce
revset: make use of natively-computed set for 'draft()' and 'secret()'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25621
diff
changeset
|
1676 s.sort() # set are non ordered, so we enforce ascending |
85294076adce
revset: make use of natively-computed set for 'draft()' and 'secret()'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25621
diff
changeset
|
1677 return subset & s |
85294076adce
revset: make use of natively-computed set for 'draft()' and 'secret()'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25621
diff
changeset
|
1678 else: |
85294076adce
revset: make use of natively-computed set for 'draft()' and 'secret()'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25621
diff
changeset
|
1679 phase = repo._phasecache.phase |
85294076adce
revset: make use of natively-computed set for 'draft()' and 'secret()'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25621
diff
changeset
|
1680 condition = lambda r: phase(repo, r) == target |
85294076adce
revset: make use of natively-computed set for 'draft()' and 'secret()'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25621
diff
changeset
|
1681 return subset.filter(condition, cache=False) |
25621
21a874693619
revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25620
diff
changeset
|
1682 |
21a874693619
revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25620
diff
changeset
|
1683 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
|
1684 """``draft()`` |
21a874693619
revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25620
diff
changeset
|
1685 Changeset in draft phase.""" |
21a874693619
revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25620
diff
changeset
|
1686 # 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
|
1687 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
|
1688 target = phases.draft |
21a874693619
revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25620
diff
changeset
|
1689 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
|
1690 |
21a874693619
revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25620
diff
changeset
|
1691 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
|
1692 """``secret()`` |
21a874693619
revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25620
diff
changeset
|
1693 Changeset in secret phase.""" |
21a874693619
revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25620
diff
changeset
|
1694 # 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
|
1695 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
|
1696 target = phases.secret |
21a874693619
revset: refactor the non-public phase code
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25620
diff
changeset
|
1697 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
|
1698 |
14070
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
1699 def parentspec(repo, subset, x, n): |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
1700 """``set^0`` |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
1701 The set. |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
1702 ``set^1`` (or ``set^``), ``set^2`` |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
1703 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
|
1704 """ |
12320
40c40c6f20b8
revset: handle re.compile() errors in grep()
Brodie Rao <brodie@bitheap.org>
parents:
11882
diff
changeset
|
1705 try: |
14070
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
1706 n = int(n[1]) |
14072
2e4d79dcc0a0
revset: add missing whitespace
Kevin Gessner <kevin@kevingessner.com>
parents:
14070
diff
changeset
|
1707 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
|
1708 raise ValueError |
14851
f96c354493d7
revsets: actually catch type error on tip^p1(tip) (issue2884)
Matt Mackall <mpm@selenic.com>
parents:
14842
diff
changeset
|
1709 except (TypeError, ValueError): |
14070
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
1710 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
|
1711 ps = set() |
11275 | 1712 cl = repo.changelog |
23165
7e8737e6ab08
revset-parentspec: call 'getset' on a 'fullreposet'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23164
diff
changeset
|
1713 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
|
1714 if n == 0: |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
1715 ps.add(r) |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
1716 elif n == 1: |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
1717 ps.add(cl.parentrevs(r)[0]) |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
1718 elif n == 2: |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
1719 parents = cl.parentrevs(r) |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
1720 if len(parents) > 1: |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
1721 ps.add(parents[1]) |
20367
2ac278aab2b4
revset: added intersection to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20366
diff
changeset
|
1722 return subset & ps |
11275 | 1723 |
11944
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
1724 def present(repo, subset, x): |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1725 """``present(set)`` |
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1726 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
|
1727 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
|
1728 |
0a730d3c5aae
doc: add detail explanation for 'present()' predicate of revsets
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
16735
diff
changeset
|
1729 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
|
1730 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
|
1731 to continue even in such cases. |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1732 """ |
11944
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
1733 try: |
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
1734 return getset(repo, subset, x) |
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
1735 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
|
1736 return baseset() |
11944
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
1737 |
25224
d032f57936f5
revset: drop docstring from internal _notpublic() function
Yuya Nishihara <yuya@tcha.org>
parents:
25191
diff
changeset
|
1738 # for internal use |
25191
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
1739 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
|
1740 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
|
1741 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
|
1742 if repo._phasecache._phasesets: |
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
1743 s = set() |
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
1744 for u in repo._phasecache._phasesets[1:]: |
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
1745 s.update(u) |
25619
833fa28cd949
revset: use a baseset in _notpublic()
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25612
diff
changeset
|
1746 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
|
1747 s.sort() |
25191
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
1748 return subset & s |
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
1749 else: |
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
1750 phase = repo._phasecache.phase |
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
1751 target = phases.public |
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
1752 condition = lambda r: phase(repo, r) != target |
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
1753 return subset.filter(condition, cache=False) |
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
1754 |
15819
33ca11b010e2
phases: implements simple revset symbol
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15791
diff
changeset
|
1755 def public(repo, subset, x): |
33ca11b010e2
phases: implements simple revset symbol
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15791
diff
changeset
|
1756 """``public()`` |
33ca11b010e2
phases: implements simple revset symbol
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15791
diff
changeset
|
1757 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
|
1758 # 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
|
1759 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
|
1760 phase = repo._phasecache.phase |
c8f32accd00a
revset-phases: prefetch attributes in phasesrelated revsets
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23018
diff
changeset
|
1761 target = phases.public |
c8f32accd00a
revset-phases: prefetch attributes in phasesrelated revsets
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23018
diff
changeset
|
1762 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
|
1763 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
|
1764 |
15936
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1765 def remote(repo, subset, x): |
16007
f06c53ca59a9
revset: fix documentation for 'remote()' predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
16006
diff
changeset
|
1766 """``remote([id [,path]])`` |
15936
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1767 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
|
1768 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
|
1769 synonym for the current local branch. |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1770 """ |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1771 |
25971
e9cd028f2dff
revset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25929
diff
changeset
|
1772 from . import hg # avoid start-up nasties |
15936
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1773 # i18n: "remote" is a keyword |
16007
f06c53ca59a9
revset: fix documentation for 'remote()' predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
16006
diff
changeset
|
1774 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
|
1775 |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1776 q = '.' |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1777 if len(l) > 0: |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1778 # i18n: "remote" is a keyword |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1779 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
|
1780 if q == '.': |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1781 q = repo['.'].branch() |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1782 |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1783 dest = '' |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1784 if len(l) > 1: |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1785 # i18n: "remote" is a keyword |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1786 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
|
1787 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
|
1788 dest, branches = hg.parseurl(dest) |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1789 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
|
1790 if revs: |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1791 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
|
1792 other = hg.peer(repo, {}, dest) |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1793 n = other.lookup(q) |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1794 if n in repo: |
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1795 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
|
1796 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
|
1797 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
|
1798 return baseset() |
15936
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
1799 |
11275 | 1800 def removes(repo, subset, x): |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1801 """``removes(pattern)`` |
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1802 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
|
1803 |
96be25f1da45
revset: add explanation about the pattern without explicit kind
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20288
diff
changeset
|
1804 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
|
1805 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
|
1806 directory. |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1807 """ |
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
1808 # 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
|
1809 pat = getstring(x, _("removes requires a pattern")) |
11275 | 1810 return checkstatus(repo, subset, pat, 2) |
1811 | |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1812 def rev(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1813 """``rev(number)`` |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1814 Revision with the given numeric identifier. |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1815 """ |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1816 # i18n: "rev" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1817 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
|
1818 try: |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1819 # i18n: "rev" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1820 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
|
1821 except (TypeError, ValueError): |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1822 # i18n: "rev" is a keyword |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1823 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
|
1824 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
|
1825 return baseset() |
22537
bbf4f3dfd700
revset: use `subset &` in `rev`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22536
diff
changeset
|
1826 return subset & baseset([l]) |
11275 | 1827 |
16402
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1828 def matching(repo, subset, x): |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1829 """``matching(revision [, field])`` |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1830 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
|
1831 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
|
1832 |
16402
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1833 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
|
1834 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
|
1835 |
5d803620ca05
doc: flatten description of 'matching()' predicate to be formatted well
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
16521
diff
changeset
|
1836 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
|
1837 |
5d803620ca05
doc: flatten description of 'matching()' predicate to be formatted well
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
16521
diff
changeset
|
1838 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
|
1839 ``date``, ``files``, ``phase``, ``parents``, ``substate``, ``user`` |
d9a046ae4d8e
revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
17100
diff
changeset
|
1840 and ``diff``. |
d9a046ae4d8e
revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
17100
diff
changeset
|
1841 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
|
1842 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
|
1843 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
|
1844 |
5d803620ca05
doc: flatten description of 'matching()' predicate to be formatted well
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
16521
diff
changeset
|
1845 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
|
1846 ``summary`` matches the first line of the description. |
16639
00290bd359fe
revset: documentation typo "metatadata"
Jesse Glick <jesse.glick@oracle.com>
parents:
16528
diff
changeset
|
1847 ``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
|
1848 (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
|
1849 |
5d803620ca05
doc: flatten description of 'matching()' predicate to be formatted well
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
16521
diff
changeset
|
1850 ``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
|
1851 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
|
1852 """ |
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
|
1853 # i18n: "matching" is a keyword |
16402
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1854 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
|
1855 |
23166
30e0dcd7c5ff
revset-matching: call 'getset' on a 'fullreposet'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23165
diff
changeset
|
1856 revs = getset(repo, fullreposet(repo), l[0]) |
16402
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1857 |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1858 fieldlist = ['metadata'] |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1859 if len(l) > 1: |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1860 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
|
1861 # i18n: "matching" is a keyword |
16402
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1862 _("matching requires a string " |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1863 "as its second argument")).split() |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1864 |
17102
d9a046ae4d8e
revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
17100
diff
changeset
|
1865 # 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
|
1866 # expand the 'special' 'metadata' field type |
d9a046ae4d8e
revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
17100
diff
changeset
|
1867 # 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
|
1868 fields = [] |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1869 for field in fieldlist: |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1870 if field == 'metadata': |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1871 fields += ['user', 'description', 'date'] |
17102
d9a046ae4d8e
revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
17100
diff
changeset
|
1872 elif field == 'diff': |
d9a046ae4d8e
revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
17100
diff
changeset
|
1873 # 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
|
1874 # 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
|
1875 # also match the files first |
d9a046ae4d8e
revset: add "diff" field to "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
17100
diff
changeset
|
1876 fields += ['files', 'diff'] |
16402
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1877 else: |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1878 if field == 'author': |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1879 field = 'user' |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1880 fields.append(field) |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1881 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
|
1882 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
|
1883 # 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
|
1884 fields.discard('summary') |
16402
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1885 |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1886 # 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
|
1887 # 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
|
1888 # 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
|
1889 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
|
1890 '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
|
1891 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
|
1892 try: |
984e0412e82b
revset: speedup matching() by first matching fields that take less time to
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16445
diff
changeset
|
1893 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
|
1894 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
|
1895 # 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
|
1896 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
|
1897 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
|
1898 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
|
1899 |
16402
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1900 # 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
|
1901 # 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
|
1902 getfieldfuncs = [] |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1903 _funcs = { |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1904 'user': lambda r: repo[r].user(), |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1905 'branch': lambda r: repo[r].branch(), |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1906 'date': lambda r: repo[r].date(), |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1907 'description': lambda r: repo[r].description(), |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1908 'files': lambda r: repo[r].files(), |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1909 'parents': lambda r: repo[r].parents(), |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1910 'phase': lambda r: repo[r].phase(), |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1911 'substate': lambda r: repo[r].substate, |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1912 '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
|
1913 '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
|
1914 } |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1915 for info in fields: |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1916 getfield = _funcs.get(info, None) |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1917 if getfield is None: |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1918 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
|
1919 # i18n: "matching" is a keyword |
16402
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1920 _("unexpected field name passed to matching: %s") % info) |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1921 getfieldfuncs.append(getfield) |
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1922 # 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
|
1923 # 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
|
1924 # 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
|
1925 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
|
1926 |
20459
51890507c6b3
revset: added lazyset implementation to matching revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20458
diff
changeset
|
1927 def matches(x): |
51890507c6b3
revset: added lazyset implementation to matching revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20458
diff
changeset
|
1928 for rev in revs: |
51890507c6b3
revset: added lazyset implementation to matching revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20458
diff
changeset
|
1929 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
|
1930 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
|
1931 for n, f in enumerate(getfieldfuncs): |
20459
51890507c6b3
revset: added lazyset implementation to matching revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20458
diff
changeset
|
1932 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
|
1933 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
|
1934 if match: |
20459
51890507c6b3
revset: added lazyset implementation to matching revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20458
diff
changeset
|
1935 return True |
51890507c6b3
revset: added lazyset implementation to matching revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20458
diff
changeset
|
1936 return False |
51890507c6b3
revset: added lazyset implementation to matching revset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20458
diff
changeset
|
1937 |
20611
6490f8385391
revset: changed revset code to use filter method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20610
diff
changeset
|
1938 return subset.filter(matches) |
16402
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
1939 |
11275 | 1940 def reverse(repo, subset, x): |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1941 """``reverse(set)`` |
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1942 Reverse order of set. |
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1943 """ |
11275 | 1944 l = getset(repo, subset, x) |
1945 l.reverse() | |
1946 return l | |
1947 | |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1948 def roots(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
1949 """``roots(set)`` |
16394
f3df7d34791e
revset: do not ignore input revisions in roots()
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
1950 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
|
1951 """ |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
1952 s = getset(repo, fullreposet(repo), x) |
25647
46a96dd4d976
revset: improves time complexity of 'roots(xxx)'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25634
diff
changeset
|
1953 parents = repo.changelog.parentrevs |
46a96dd4d976
revset: improves time complexity of 'roots(xxx)'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25634
diff
changeset
|
1954 def filter(r): |
46a96dd4d976
revset: improves time complexity of 'roots(xxx)'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25634
diff
changeset
|
1955 for p in parents(r): |
46a96dd4d976
revset: improves time complexity of 'roots(xxx)'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25634
diff
changeset
|
1956 if 0 <= p and p in s: |
46a96dd4d976
revset: improves time complexity of 'roots(xxx)'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25634
diff
changeset
|
1957 return False |
46a96dd4d976
revset: improves time complexity of 'roots(xxx)'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25634
diff
changeset
|
1958 return True |
46a96dd4d976
revset: improves time complexity of 'roots(xxx)'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25634
diff
changeset
|
1959 return subset & s.filter(filter) |
11944
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
1960 |
11275 | 1961 def sort(repo, subset, x): |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1962 """``sort(set[, [-]key...])`` |
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1963 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
|
1964 as ``-key`` to sort in descending order. |
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1965 |
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1966 The keys can be: |
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1967 |
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1968 - ``rev`` for the revision number, |
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1969 - ``branch`` for the branch name, |
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1970 - ``desc`` for the commit message (description), |
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1971 - ``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
|
1972 - ``date`` for the commit date |
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
1973 """ |
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
1974 # 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
|
1975 l = getargs(x, 1, 2, _("sort requires one or two arguments")) |
11275 | 1976 keys = "rev" |
1977 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
|
1978 # i18n: "sort" is a keyword |
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
1979 keys = getstring(l[1], _("sort spec must be a string")) |
11275 | 1980 |
1981 s = l[0] | |
1982 keys = keys.split() | |
1983 l = [] | |
1984 def invert(s): | |
1985 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
|
1986 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
|
1987 if keys == ["rev"]: |
cce8fbedc82a
revset: changed sort method to use native sort implementation of smartsets
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20718
diff
changeset
|
1988 revs.sort() |
cce8fbedc82a
revset: changed sort method to use native sort implementation of smartsets
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20718
diff
changeset
|
1989 return revs |
cce8fbedc82a
revset: changed sort method to use native sort implementation of smartsets
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20718
diff
changeset
|
1990 elif keys == ["-rev"]: |
cce8fbedc82a
revset: changed sort method to use native sort implementation of smartsets
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20718
diff
changeset
|
1991 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
|
1992 return revs |
cce8fbedc82a
revset: changed sort method to use native sort implementation of smartsets
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20718
diff
changeset
|
1993 for r in revs: |
11275 | 1994 c = repo[r] |
1995 e = [] | |
1996 for k in keys: | |
1997 if k == 'rev': | |
1998 e.append(r) | |
1999 elif k == '-rev': | |
2000 e.append(-r) | |
2001 elif k == 'branch': | |
2002 e.append(c.branch()) | |
2003 elif k == '-branch': | |
2004 e.append(invert(c.branch())) | |
2005 elif k == 'desc': | |
2006 e.append(c.description()) | |
2007 elif k == '-desc': | |
2008 e.append(invert(c.description())) | |
2009 elif k in 'user author': | |
2010 e.append(c.user()) | |
2011 elif k in '-user -author': | |
2012 e.append(invert(c.user())) | |
2013 elif k == 'date': | |
2014 e.append(c.date()[0]) | |
2015 elif k == '-date': | |
2016 e.append(-c.date()[0]) | |
2017 else: | |
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
2018 raise error.ParseError(_("unknown sort key %r") % k) |
11275 | 2019 e.append(r) |
2020 l.append(e) | |
2021 l.sort() | |
20364
a6cf48b2880d
revset: added baseset class (still empty) to improve revset performance
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20289
diff
changeset
|
2022 return baseset([e[-1] for e in l]) |
11275 | 2023 |
24446
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2024 def subrepo(repo, subset, x): |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2025 """``subrepo([pattern])`` |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2026 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
|
2027 pattern is named, any subrepo changes are returned. |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2028 """ |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2029 # i18n: "subrepo" is a keyword |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2030 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
|
2031 if len(args) != 0: |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2032 pat = getstring(args[0], _("subrepo requires a pattern")) |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2033 |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2034 m = matchmod.exact(repo.root, repo.root, ['.hgsubstate']) |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2035 |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2036 def submatches(names): |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2037 k, p, m = _stringmatcher(pat) |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2038 for name in names: |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2039 if m(name): |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2040 yield name |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2041 |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2042 def matches(x): |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2043 c = repo[x] |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2044 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
|
2045 |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2046 if len(args) == 0: |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2047 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
|
2048 |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2049 if s.added: |
25149
3f0744eeaeaf
cleanup: use __builtins__.any instead of util.any
Augie Fackler <augie@google.com>
parents:
25146
diff
changeset
|
2050 return any(submatches(c.substate.keys())) |
24446
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2051 |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2052 if s.modified: |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2053 subs = set(c.p1().substate.keys()) |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2054 subs.update(c.substate.keys()) |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2055 |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2056 for path in submatches(subs): |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2057 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
|
2058 return True |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2059 |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2060 if s.removed: |
25149
3f0744eeaeaf
cleanup: use __builtins__.any instead of util.any
Augie Fackler <augie@google.com>
parents:
25146
diff
changeset
|
2061 return any(submatches(c.p1().substate.keys())) |
24446
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2062 |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2063 return False |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2064 |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2065 return subset.filter(matches) |
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2066 |
16819
5260a9e93113
revset: add helper function for matching strings to patterns
Simon King <simon@simonking.org.uk>
parents:
16803
diff
changeset
|
2067 def _stringmatcher(pattern): |
5260a9e93113
revset: add helper function for matching strings to patterns
Simon King <simon@simonking.org.uk>
parents:
16803
diff
changeset
|
2068 """ |
5260a9e93113
revset: add helper function for matching strings to patterns
Simon King <simon@simonking.org.uk>
parents:
16803
diff
changeset
|
2069 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
|
2070 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
|
2071 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
|
2072 |
5260a9e93113
revset: add helper function for matching strings to patterns
Simon King <simon@simonking.org.uk>
parents:
16803
diff
changeset
|
2073 helper for tests: |
5260a9e93113
revset: add helper function for matching strings to patterns
Simon King <simon@simonking.org.uk>
parents:
16803
diff
changeset
|
2074 >>> def test(pattern, *tests): |
5260a9e93113
revset: add helper function for matching strings to patterns
Simon King <simon@simonking.org.uk>
parents:
16803
diff
changeset
|
2075 ... 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
|
2076 ... 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
|
2077 |
5260a9e93113
revset: add helper function for matching strings to patterns
Simon King <simon@simonking.org.uk>
parents:
16803
diff
changeset
|
2078 exact matching (no prefix): |
5260a9e93113
revset: add helper function for matching strings to patterns
Simon King <simon@simonking.org.uk>
parents:
16803
diff
changeset
|
2079 >>> 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
|
2080 ('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
|
2081 |
5260a9e93113
revset: add helper function for matching strings to patterns
Simon King <simon@simonking.org.uk>
parents:
16803
diff
changeset
|
2082 regex matching ('re:' prefix) |
5260a9e93113
revset: add helper function for matching strings to patterns
Simon King <simon@simonking.org.uk>
parents:
16803
diff
changeset
|
2083 >>> 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
|
2084 ('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
|
2085 |
5260a9e93113
revset: add helper function for matching strings to patterns
Simon King <simon@simonking.org.uk>
parents:
16803
diff
changeset
|
2086 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
|
2087 >>> 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
|
2088 ('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
|
2089 |
5260a9e93113
revset: add helper function for matching strings to patterns
Simon King <simon@simonking.org.uk>
parents:
16803
diff
changeset
|
2090 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
|
2091 >>> 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
|
2092 ('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
|
2093 """ |
5260a9e93113
revset: add helper function for matching strings to patterns
Simon King <simon@simonking.org.uk>
parents:
16803
diff
changeset
|
2094 if pattern.startswith('re:'): |
5260a9e93113
revset: add helper function for matching strings to patterns
Simon King <simon@simonking.org.uk>
parents:
16803
diff
changeset
|
2095 pattern = pattern[3:] |
5260a9e93113
revset: add helper function for matching strings to patterns
Simon King <simon@simonking.org.uk>
parents:
16803
diff
changeset
|
2096 try: |
5260a9e93113
revset: add helper function for matching strings to patterns
Simon King <simon@simonking.org.uk>
parents:
16803
diff
changeset
|
2097 regex = re.compile(pattern) |
25660
328739ea70c3
global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25654
diff
changeset
|
2098 except re.error as e: |
16819
5260a9e93113
revset: add helper function for matching strings to patterns
Simon King <simon@simonking.org.uk>
parents:
16803
diff
changeset
|
2099 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
|
2100 % e) |
5260a9e93113
revset: add helper function for matching strings to patterns
Simon King <simon@simonking.org.uk>
parents:
16803
diff
changeset
|
2101 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
|
2102 elif pattern.startswith('literal:'): |
5260a9e93113
revset: add helper function for matching strings to patterns
Simon King <simon@simonking.org.uk>
parents:
16803
diff
changeset
|
2103 pattern = pattern[8:] |
5260a9e93113
revset: add helper function for matching strings to patterns
Simon King <simon@simonking.org.uk>
parents:
16803
diff
changeset
|
2104 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
|
2105 |
16823
b23bacb230c9
revset: add pattern matching to the 'user' revset expression
Simon King <simon@simonking.org.uk>
parents:
16822
diff
changeset
|
2106 def _substringmatcher(pattern): |
b23bacb230c9
revset: add pattern matching to the 'user' revset expression
Simon King <simon@simonking.org.uk>
parents:
16822
diff
changeset
|
2107 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
|
2108 if kind == 'literal': |
b23bacb230c9
revset: add pattern matching to the 'user' revset expression
Simon King <simon@simonking.org.uk>
parents:
16822
diff
changeset
|
2109 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
|
2110 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
|
2111 |
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
|
2112 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
|
2113 """``tag([name])`` |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
2114 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
|
2115 |
c57c9cece645
revset: document the regular expression support for tag(name)
Matt Harbison <matt_harbison@yahoo.com>
parents:
20289
diff
changeset
|
2116 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
|
2117 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
|
2118 use the prefix `literal:`. |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
2119 """ |
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
2120 # 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
|
2121 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
|
2122 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
|
2123 if args: |
16820
20f55613fb2a
revset: add pattern matching to 'tag' revset expression
Simon King <simon@simonking.org.uk>
parents:
16819
diff
changeset
|
2124 pattern = getstring(args[0], |
20f55613fb2a
revset: add pattern matching to 'tag' revset expression
Simon King <simon@simonking.org.uk>
parents:
16819
diff
changeset
|
2125 # i18n: "tag" is a keyword |
20f55613fb2a
revset: add pattern matching to 'tag' revset expression
Simon King <simon@simonking.org.uk>
parents:
16819
diff
changeset
|
2126 _('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
|
2127 kind, pattern, matcher = _stringmatcher(pattern) |
20f55613fb2a
revset: add pattern matching to 'tag' revset expression
Simon King <simon@simonking.org.uk>
parents:
16819
diff
changeset
|
2128 if kind == 'literal': |
16825
b6ef1395d77f
revset: avoid validating all tag nodes for tag(x)
Matt Mackall <mpm@selenic.com>
parents:
16824
diff
changeset
|
2129 # avoid resolving all tags |
b6ef1395d77f
revset: avoid validating all tag nodes for tag(x)
Matt Mackall <mpm@selenic.com>
parents:
16824
diff
changeset
|
2130 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
|
2131 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
|
2132 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
|
2133 % pattern) |
16825
b6ef1395d77f
revset: avoid validating all tag nodes for tag(x)
Matt Mackall <mpm@selenic.com>
parents:
16824
diff
changeset
|
2134 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
|
2135 else: |
20f55613fb2a
revset: add pattern matching to 'tag' revset expression
Simon King <simon@simonking.org.uk>
parents:
16819
diff
changeset
|
2136 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
|
2137 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
|
2138 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
|
2139 return subset & s |
11280
a5eb0bf7e158
revset: add tagged predicate
Matt Mackall <mpm@selenic.com>
parents:
11279
diff
changeset
|
2140 |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
2141 def tagged(repo, subset, x): |
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
2142 return tag(repo, subset, x) |
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
2143 |
17171
9c750c3e4fac
obsolete: compute unstable changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17170
diff
changeset
|
2144 def unstable(repo, subset, x): |
9c750c3e4fac
obsolete: compute unstable changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17170
diff
changeset
|
2145 """``unstable()`` |
17291
2d6bbf87f7b4
revset: minor doc fixes on obsolete related revsets
Patrick Mezard <patrick@mezard.eu>
parents:
17272
diff
changeset
|
2146 Non-obsolete changesets with obsolete ancestors. |
2d6bbf87f7b4
revset: minor doc fixes on obsolete related revsets
Patrick Mezard <patrick@mezard.eu>
parents:
17272
diff
changeset
|
2147 """ |
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
|
2148 # 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
|
2149 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
|
2150 unstables = obsmod.getrevs(repo, 'unstable') |
20367
2ac278aab2b4
revset: added intersection to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20366
diff
changeset
|
2151 return subset & unstables |
17171
9c750c3e4fac
obsolete: compute unstable changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17170
diff
changeset
|
2152 |
9c750c3e4fac
obsolete: compute unstable changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17170
diff
changeset
|
2153 |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
2154 def user(repo, subset, x): |
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
2155 """``user(string)`` |
14357 | 2156 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
|
2157 |
b23bacb230c9
revset: add pattern matching to the 'user' revset expression
Simon King <simon@simonking.org.uk>
parents:
16822
diff
changeset
|
2158 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
|
2159 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
|
2160 the prefix `literal:`. |
13359
87f248e78173
bookmarks: move revset support to core
Matt Mackall <mpm@selenic.com>
parents:
13031
diff
changeset
|
2161 """ |
13915
8f81d6f4047f
revset: rearrange code so functions are sorted alphabetically
Idan Kamara <idankk86@gmail.com>
parents:
13914
diff
changeset
|
2162 return author(repo, subset, x) |
13359
87f248e78173
bookmarks: move revset support to core
Matt Mackall <mpm@selenic.com>
parents:
13031
diff
changeset
|
2163 |
24777
077683371b7b
revset: undocument wdir() until its command outputs get stable
Yuya Nishihara <yuya@tcha.org>
parents:
24722
diff
changeset
|
2164 # experimental |
24419
0e41f110e69e
revset: add wdir() function to specify workingctx revision by command
Yuya Nishihara <yuya@tcha.org>
parents:
24374
diff
changeset
|
2165 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
|
2166 # 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
|
2167 getargs(x, 0, 0, _("wdir takes no arguments")) |
25765
5e1b0739611c
revset: use integer representation of wdir() in revset
Yuya Nishihara <yuya@tcha.org>
parents:
25716
diff
changeset
|
2168 if node.wdirrev in subset or isinstance(subset, fullreposet): |
5e1b0739611c
revset: use integer representation of wdir() in revset
Yuya Nishihara <yuya@tcha.org>
parents:
25716
diff
changeset
|
2169 return baseset([node.wdirrev]) |
24419
0e41f110e69e
revset: add wdir() function to specify workingctx revision by command
Yuya Nishihara <yuya@tcha.org>
parents:
24374
diff
changeset
|
2170 return baseset() |
0e41f110e69e
revset: add wdir() function to specify workingctx revision by command
Yuya Nishihara <yuya@tcha.org>
parents:
24374
diff
changeset
|
2171 |
15898
6902e13ddd03
revset: optimize building large lists in formatrevspec
Matt Mackall <mpm@selenic.com>
parents:
15837
diff
changeset
|
2172 # for internal use |
6902e13ddd03
revset: optimize building large lists in formatrevspec
Matt Mackall <mpm@selenic.com>
parents:
15837
diff
changeset
|
2173 def _list(repo, subset, x): |
6902e13ddd03
revset: optimize building large lists in formatrevspec
Matt Mackall <mpm@selenic.com>
parents:
15837
diff
changeset
|
2174 s = getstring(x, "internal error") |
6902e13ddd03
revset: optimize building large lists in formatrevspec
Matt Mackall <mpm@selenic.com>
parents:
15837
diff
changeset
|
2175 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
|
2176 return baseset() |
25341
9d6cc87bd507
revset: make internal _list() expression remove duplicated revisions
Yuya Nishihara <yuya@tcha.org>
parents:
25309
diff
changeset
|
2177 # 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
|
2178 # 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
|
2179 cl = repo.changelog |
25341
9d6cc87bd507
revset: make internal _list() expression remove duplicated revisions
Yuya Nishihara <yuya@tcha.org>
parents:
25309
diff
changeset
|
2180 ls = [] |
9d6cc87bd507
revset: make internal _list() expression remove duplicated revisions
Yuya Nishihara <yuya@tcha.org>
parents:
25309
diff
changeset
|
2181 seen = set() |
9d6cc87bd507
revset: make internal _list() expression remove duplicated revisions
Yuya Nishihara <yuya@tcha.org>
parents:
25309
diff
changeset
|
2182 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
|
2183 try: |
ceaf04bb14ff
revset: add fast path for _list() of integer revisions
Yuya Nishihara <yuya@tcha.org>
parents:
25343
diff
changeset
|
2184 # fast path for integer revision |
ceaf04bb14ff
revset: add fast path for _list() of integer revisions
Yuya Nishihara <yuya@tcha.org>
parents:
25343
diff
changeset
|
2185 r = int(t) |
ceaf04bb14ff
revset: add fast path for _list() of integer revisions
Yuya Nishihara <yuya@tcha.org>
parents:
25343
diff
changeset
|
2186 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
|
2187 raise ValueError |
26143
42bb1812686f
revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents:
26102
diff
changeset
|
2188 revs = [r] |
25344
ceaf04bb14ff
revset: add fast path for _list() of integer revisions
Yuya Nishihara <yuya@tcha.org>
parents:
25343
diff
changeset
|
2189 except ValueError: |
26143
42bb1812686f
revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents:
26102
diff
changeset
|
2190 revs = stringset(repo, subset, t) |
42bb1812686f
revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents:
26102
diff
changeset
|
2191 |
42bb1812686f
revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents:
26102
diff
changeset
|
2192 for r in revs: |
42bb1812686f
revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents:
26102
diff
changeset
|
2193 if r in seen: |
42bb1812686f
revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents:
26102
diff
changeset
|
2194 continue |
42bb1812686f
revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents:
26102
diff
changeset
|
2195 if (r in subset |
42bb1812686f
revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents:
26102
diff
changeset
|
2196 or r == node.nullrev and isinstance(subset, fullreposet)): |
42bb1812686f
revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents:
26102
diff
changeset
|
2197 ls.append(r) |
42bb1812686f
revset: fix resolving strings from a list
Durham Goode <durham@fb.com>
parents:
26102
diff
changeset
|
2198 seen.add(r) |
25341
9d6cc87bd507
revset: make internal _list() expression remove duplicated revisions
Yuya Nishihara <yuya@tcha.org>
parents:
25309
diff
changeset
|
2199 return baseset(ls) |
15898
6902e13ddd03
revset: optimize building large lists in formatrevspec
Matt Mackall <mpm@selenic.com>
parents:
15837
diff
changeset
|
2200 |
20566
98024950ade0
revset: added _intlist method to replace _list for %ld
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20552
diff
changeset
|
2201 # for internal use |
98024950ade0
revset: added _intlist method to replace _list for %ld
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20552
diff
changeset
|
2202 def _intlist(repo, subset, x): |
98024950ade0
revset: added _intlist method to replace _list for %ld
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20552
diff
changeset
|
2203 s = getstring(x, "internal error") |
98024950ade0
revset: added _intlist method to replace _list for %ld
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20552
diff
changeset
|
2204 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
|
2205 return baseset() |
20566
98024950ade0
revset: added _intlist method to replace _list for %ld
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20552
diff
changeset
|
2206 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
|
2207 s = subset |
20566
98024950ade0
revset: added _intlist method to replace _list for %ld
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20552
diff
changeset
|
2208 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
|
2209 |
20569
0d4be103c734
revset: added _hexlist method to replace _list for %ln
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20566
diff
changeset
|
2210 # for internal use |
0d4be103c734
revset: added _hexlist method to replace _list for %ln
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20566
diff
changeset
|
2211 def _hexlist(repo, subset, x): |
0d4be103c734
revset: added _hexlist method to replace _list for %ln
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20566
diff
changeset
|
2212 s = getstring(x, "internal error") |
0d4be103c734
revset: added _hexlist method to replace _list for %ln
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20566
diff
changeset
|
2213 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
|
2214 return baseset() |
20569
0d4be103c734
revset: added _hexlist method to replace _list for %ln
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20566
diff
changeset
|
2215 cl = repo.changelog |
0d4be103c734
revset: added _hexlist method to replace _list for %ln
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20566
diff
changeset
|
2216 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
|
2217 s = subset |
20569
0d4be103c734
revset: added _hexlist method to replace _list for %ln
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20566
diff
changeset
|
2218 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
|
2219 |
11275 | 2220 symbols = { |
26303
c99b4d6efdd8
merge: move default destination computation in a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26232
diff
changeset
|
2221 "_mergedefaultdest": _mergedefaultdest, |
26304
bca60842e22d
update: move default destination into a revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26303
diff
changeset
|
2222 "_updatedefaultdest": _updatedefaultdest, |
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
2223 "adds": adds, |
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
2224 "all": getall, |
11275 | 2225 "ancestor": ancestor, |
2226 "ancestors": ancestors, | |
16409
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
2227 "_firstancestors": _firstancestors, |
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
2228 "author": author, |
15134
81adf7777f8f
revset: rename bisected() to bisect()
"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
parents:
15133
diff
changeset
|
2229 "bisect": bisect, |
13602
54b198fe9768
revset: add a revset command to get bisect state.
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
13593
diff
changeset
|
2230 "bisected": bisected, |
13359
87f248e78173
bookmarks: move revset support to core
Matt Mackall <mpm@selenic.com>
parents:
13031
diff
changeset
|
2231 "bookmark": bookmark, |
11275 | 2232 "branch": branch, |
17753
69d5078d760d
revsets: add branchpoint() function
Ivan Andrus <darthandrus@gmail.com>
parents:
17675
diff
changeset
|
2233 "branchpoint": branchpoint, |
17829
c73f7a28953c
revset: add a bumped revset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17825
diff
changeset
|
2234 "bumped": bumped, |
17913
03e552aaae67
bundle: add revset expression to show bundle contents (issue3487)
Tomasz Kleczek <tkleczek@fb.com>
parents:
17886
diff
changeset
|
2235 "bundle": bundle, |
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
2236 "children": children, |
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
2237 "closed": closed, |
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
2238 "contains": contains, |
17002
0eb522625eb2
revset: add a predicate for finding converted changesets
Matt Harbison <matt_harbison@yahoo.com>
parents:
16862
diff
changeset
|
2239 "converted": converted, |
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
2240 "date": date, |
14650
93731b3efd0d
revset: add desc(string) to search in commit messages
Thomas Arendsen Hein <thomas@intevation.de>
parents:
14649
diff
changeset
|
2241 "desc": desc, |
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
2242 "descendants": descendants, |
16409
2cbd7dd0cc1f
graphlog: fix --follow-first --rev combinations
Patrick Mezard <patrick@mezard.eu>
parents:
16402
diff
changeset
|
2243 "_firstdescendants": _firstdescendants, |
17186
a3da6f298592
revset: add destination() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17185
diff
changeset
|
2244 "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
|
2245 "divergent": divergent, |
15819
33ca11b010e2
phases: implements simple revset symbol
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15791
diff
changeset
|
2246 "draft": draft, |
17173
c621f84dbb35
obsolete: compute extinct changesets
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17171
diff
changeset
|
2247 "extinct": extinct, |
16661
de4b42daf396
revset: add function for matching extra data (issue2767)
Henrik Stuart <hg@hstuart.dk>
parents:
16657
diff
changeset
|
2248 "extra": extra, |
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
2249 "file": hasfile, |
14342
c0b6a734b4f3
revset: introduce filelog() to emulate log's fast path
Matt Mackall <mpm@selenic.com>
parents:
14318
diff
changeset
|
2250 "filelog": filelog, |
15117
0ab1c3a1f3b2
revsets: add first alias for last
Matt Mackall <mpm@selenic.com>
parents:
15116
diff
changeset
|
2251 "first": first, |
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
2252 "follow": follow, |
16174
0a73c4bd9f47
graphlog: implement --follow-first
Patrick Mezard <patrick@mezard.eu>
parents:
16161
diff
changeset
|
2253 "_followfirst": _followfirst, |
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
2254 "grep": grep, |
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
2255 "head": head, |
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
2256 "heads": heads, |
17390
74b44f25b4b1
revset: add hidden() revset
Patrick Mezard <patrick@mezard.eu>
parents:
17291
diff
changeset
|
2257 "hidden": hidden, |
16417
b4b0c6931e11
revset: avoid demandimport bug
Matt Mackall <mpm@selenic.com>
parents:
16415
diff
changeset
|
2258 "id": node_, |
11275 | 2259 "keyword": keyword, |
14061
611d2f8a4ba2
revsets: add a last function
Matt Mackall <mpm@selenic.com>
parents:
14057
diff
changeset
|
2260 "last": last, |
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
2261 "limit": limit, |
16161
5a627b49b4d9
graphlog: paths/-I/-X handling requires a new revset
Patrick Mezard <patrick@mezard.eu>
parents:
16096
diff
changeset
|
2262 "_matchfiles": _matchfiles, |
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
2263 "max": maxrev, |
14649
a6a8809c6e33
revset: update sorting of symbols
Thomas Arendsen Hein <thomas@intevation.de>
parents:
14556
diff
changeset
|
2264 "merge": merge, |
11708
ba65d61f3158
revset: add min function
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11650
diff
changeset
|
2265 "min": minrev, |
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
2266 "modifies": modifies, |
23836
3fb61fcbc4e4
namespaces: add revset for 'named(namespace)'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23833
diff
changeset
|
2267 "named": named, |
17170
63a4a3871607
revset: add an `obsolete` symbol
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17102
diff
changeset
|
2268 "obsolete": obsolete, |
23466
d5b1a452cc32
revset: move 'only' so that functions are sorted alphabetically
Yuya Nishihara <yuya@tcha.org>
parents:
23426
diff
changeset
|
2269 "only": only, |
17185
2c7c4824969e
revset: add origin() predicate
Matt Harbison <matt_harbison@yahoo.com>
parents:
17173
diff
changeset
|
2270 "origin": origin, |
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
2271 "outgoing": outgoing, |
11275 | 2272 "p1": p1, |
2273 "p2": p2, | |
2274 "parents": parents, | |
11944
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
2275 "present": present, |
15819
33ca11b010e2
phases: implements simple revset symbol
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15791
diff
changeset
|
2276 "public": public, |
25191
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
2277 "_notpublic": _notpublic, |
15936
878bc4a62a73
revset: add remote() predicate to lookup remote revisions
Matt Mackall <mpm@selenic.com>
parents:
15903
diff
changeset
|
2278 "remote": remote, |
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
2279 "removes": removes, |
14649
a6a8809c6e33
revset: update sorting of symbols
Thomas Arendsen Hein <thomas@intevation.de>
parents:
14556
diff
changeset
|
2280 "rev": rev, |
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
2281 "reverse": reverse, |
11275 | 2282 "roots": roots, |
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
2283 "sort": sort, |
15819
33ca11b010e2
phases: implements simple revset symbol
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15791
diff
changeset
|
2284 "secret": secret, |
24446
582cfcc843c7
revset: add the 'subrepo' symbol
Matt Harbison <matt_harbison@yahoo.com>
parents:
24419
diff
changeset
|
2285 "subrepo": subrepo, |
16402
1fb2f1400ea8
revset: add "matching" keyword
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
16218
diff
changeset
|
2286 "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
|
2287 "tag": tag, |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
2288 "tagged": tagged, |
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
2289 "user": user, |
17171
9c750c3e4fac
obsolete: compute unstable changeset
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17170
diff
changeset
|
2290 "unstable": unstable, |
24419
0e41f110e69e
revset: add wdir() function to specify workingctx revision by command
Yuya Nishihara <yuya@tcha.org>
parents:
24374
diff
changeset
|
2291 "wdir": wdir, |
15898
6902e13ddd03
revset: optimize building large lists in formatrevspec
Matt Mackall <mpm@selenic.com>
parents:
15837
diff
changeset
|
2292 "_list": _list, |
20566
98024950ade0
revset: added _intlist method to replace _list for %ld
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20552
diff
changeset
|
2293 "_intlist": _intlist, |
20569
0d4be103c734
revset: added _hexlist method to replace _list for %ln
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20566
diff
changeset
|
2294 "_hexlist": _hexlist, |
11275 | 2295 } |
2296 | |
19721
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2297 # 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
|
2298 # (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
|
2299 # 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
|
2300 safesymbols = set([ |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2301 "adds", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2302 "all", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2303 "ancestor", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2304 "ancestors", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2305 "_firstancestors", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2306 "author", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2307 "bisect", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2308 "bisected", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2309 "bookmark", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2310 "branch", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2311 "branchpoint", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2312 "bumped", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2313 "bundle", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2314 "children", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2315 "closed", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2316 "converted", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2317 "date", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2318 "desc", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2319 "descendants", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2320 "_firstdescendants", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2321 "destination", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2322 "divergent", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2323 "draft", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2324 "extinct", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2325 "extra", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2326 "file", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2327 "filelog", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2328 "first", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2329 "follow", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2330 "_followfirst", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2331 "head", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2332 "heads", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2333 "hidden", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2334 "id", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2335 "keyword", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2336 "last", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2337 "limit", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2338 "_matchfiles", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2339 "max", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2340 "merge", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2341 "min", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2342 "modifies", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2343 "obsolete", |
23467
c237499a7fba
revset: add 'only' to DoS-safe symbols
Yuya Nishihara <yuya@tcha.org>
parents:
23466
diff
changeset
|
2344 "only", |
19721
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2345 "origin", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2346 "outgoing", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2347 "p1", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2348 "p2", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2349 "parents", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2350 "present", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2351 "public", |
25191
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
2352 "_notpublic", |
19721
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2353 "remote", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2354 "removes", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2355 "rev", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2356 "reverse", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2357 "roots", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2358 "sort", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2359 "secret", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2360 "matching", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2361 "tag", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2362 "tagged", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2363 "user", |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2364 "unstable", |
24419
0e41f110e69e
revset: add wdir() function to specify workingctx revision by command
Yuya Nishihara <yuya@tcha.org>
parents:
24374
diff
changeset
|
2365 "wdir", |
19721
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2366 "_list", |
20566
98024950ade0
revset: added _intlist method to replace _list for %ld
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20552
diff
changeset
|
2367 "_intlist", |
20569
0d4be103c734
revset: added _hexlist method to replace _list for %ln
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20566
diff
changeset
|
2368 "_hexlist", |
19721
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2369 ]) |
d8ca6d965230
revset: add a whitelist of DoS-safe symbols
Alexander Plavin <alexander@plav.in>
parents:
19720
diff
changeset
|
2370 |
11275 | 2371 methods = { |
2372 "range": rangeset, | |
16860
e1aa1ed30030
revset: turn dagrange into a function
Bryan O'Sullivan <bryano@fb.com>
parents:
16859
diff
changeset
|
2373 "dagrange": dagrange, |
11275 | 2374 "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
|
2375 "symbol": stringset, |
11275 | 2376 "and": andset, |
2377 "or": orset, | |
2378 "not": notset, | |
2379 "list": listset, | |
25704
70a2082f855a
revset: add parsing rule for key=value pair
Yuya Nishihara <yuya@tcha.org>
parents:
25689
diff
changeset
|
2380 "keyvalue": keyvaluepair, |
11275 | 2381 "func": func, |
14070
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
2382 "ancestor": ancestorspec, |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
2383 "parent": parentspec, |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
2384 "parentpost": p1, |
11275 | 2385 } |
2386 | |
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2387 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
|
2388 if x is None: |
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2389 return 0, x |
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2390 |
11275 | 2391 smallbonus = 1 |
2392 if small: | |
2393 smallbonus = .5 | |
2394 | |
2395 op = x[0] | |
11283
a6356b2695a3
revset: fix - handling in the optimizer
Matt Mackall <mpm@selenic.com>
parents:
11282
diff
changeset
|
2396 if op == 'minus': |
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2397 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
|
2398 elif op == 'only': |
537a2669a113
revset: use '%' as an operator for 'only'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23742
diff
changeset
|
2399 return optimize(('func', ('symbol', 'only'), |
537a2669a113
revset: use '%' as an operator for 'only'
Sean Farley <sean.michael.farley@gmail.com>
parents:
23742
diff
changeset
|
2400 ('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
|
2401 elif op == 'onlypost': |
8b99e9a8db05
revset: map postfix '%' to only() to optimize operand recursively (issue4670)
Yuya Nishihara <yuya@tcha.org>
parents:
24904
diff
changeset
|
2402 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
|
2403 elif op == 'dagrangepre': |
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2404 return optimize(('func', ('symbol', 'ancestors'), x[1]), small) |
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2405 elif op == 'dagrangepost': |
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2406 return optimize(('func', ('symbol', 'descendants'), x[1]), small) |
25819
be29d26e2949
revset: parse nullary ":" operator as "0:tip"
Yuya Nishihara <yuya@tcha.org>
parents:
25815
diff
changeset
|
2407 elif op == 'rangeall': |
be29d26e2949
revset: parse nullary ":" operator as "0:tip"
Yuya Nishihara <yuya@tcha.org>
parents:
25815
diff
changeset
|
2408 return optimize(('range', ('string', '0'), ('string', 'tip')), small) |
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2409 elif op == 'rangepre': |
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2410 return optimize(('range', ('string', '0'), x[1]), small) |
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2411 elif op == 'rangepost': |
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2412 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
|
2413 elif op == 'negate': |
6b836d5c8c9e
revset: make negate work for sort specs
Matt Mackall <mpm@selenic.com>
parents:
11456
diff
changeset
|
2414 return optimize(('string', |
6b836d5c8c9e
revset: make negate work for sort specs
Matt Mackall <mpm@selenic.com>
parents:
11456
diff
changeset
|
2415 '-' + 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
|
2416 elif op in 'string symbol negate': |
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2417 return smallbonus, x # single revisions are small |
16859
eeb464ed7275
revset: drop unreachable code
Bryan O'Sullivan <bryano@fb.com>
parents:
16838
diff
changeset
|
2418 elif op == 'and': |
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2419 wa, ta = optimize(x[1], True) |
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2420 wb, tb = optimize(x[2], True) |
20499
2efd608473fb
revset: optimize missing ancestor expressions
Siddharth Agarwal <sid0@fb.com>
parents:
20498
diff
changeset
|
2421 |
2efd608473fb
revset: optimize missing ancestor expressions
Siddharth Agarwal <sid0@fb.com>
parents:
20498
diff
changeset
|
2422 # (::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
|
2423 def isonly(revs, bases): |
20499
2efd608473fb
revset: optimize missing ancestor expressions
Siddharth Agarwal <sid0@fb.com>
parents:
20498
diff
changeset
|
2424 return ( |
25995
4f703dcc626f
revset: prevent crash caused by empty group expression while optimizing "and"
Yuya Nishihara <yuya@tcha.org>
parents:
25819
diff
changeset
|
2425 revs is not None |
4f703dcc626f
revset: prevent crash caused by empty group expression while optimizing "and"
Yuya Nishihara <yuya@tcha.org>
parents:
25819
diff
changeset
|
2426 and revs[0] == 'func' |
20499
2efd608473fb
revset: optimize missing ancestor expressions
Siddharth Agarwal <sid0@fb.com>
parents:
20498
diff
changeset
|
2427 and getstring(revs[1], _('not a symbol')) == 'ancestors' |
25995
4f703dcc626f
revset: prevent crash caused by empty group expression while optimizing "and"
Yuya Nishihara <yuya@tcha.org>
parents:
25819
diff
changeset
|
2428 and bases is not None |
20499
2efd608473fb
revset: optimize missing ancestor expressions
Siddharth Agarwal <sid0@fb.com>
parents:
20498
diff
changeset
|
2429 and bases[0] == 'not' |
2efd608473fb
revset: optimize missing ancestor expressions
Siddharth Agarwal <sid0@fb.com>
parents:
20498
diff
changeset
|
2430 and bases[1][0] == 'func' |
2efd608473fb
revset: optimize missing ancestor expressions
Siddharth Agarwal <sid0@fb.com>
parents:
20498
diff
changeset
|
2431 and getstring(bases[1][1], _('not a symbol')) == 'ancestors') |
2efd608473fb
revset: optimize missing ancestor expressions
Siddharth Agarwal <sid0@fb.com>
parents:
20498
diff
changeset
|
2432 |
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2433 w = min(wa, wb) |
21893
e967c3b08705
revset: replace _missingancestors optimization with only revset
Siddharth Agarwal <sid0@fb.com>
parents:
21870
diff
changeset
|
2434 if isonly(ta, tb): |
e967c3b08705
revset: replace _missingancestors optimization with only revset
Siddharth Agarwal <sid0@fb.com>
parents:
21870
diff
changeset
|
2435 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
|
2436 if isonly(tb, ta): |
e967c3b08705
revset: replace _missingancestors optimization with only revset
Siddharth Agarwal <sid0@fb.com>
parents:
21870
diff
changeset
|
2437 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
|
2438 |
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2439 if wa > wb: |
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2440 return w, (op, tb, ta) |
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2441 return w, (op, ta, tb) |
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2442 elif op == 'or': |
25343
7fbef7932af9
revset: optimize 'or' operation of trivial revisions to a list
Yuya Nishihara <yuya@tcha.org>
parents:
25342
diff
changeset
|
2443 # 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
|
2444 # 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
|
2445 ws, ts, ss = [], [], [] |
7fbef7932af9
revset: optimize 'or' operation of trivial revisions to a list
Yuya Nishihara <yuya@tcha.org>
parents:
25342
diff
changeset
|
2446 def flushss(): |
7fbef7932af9
revset: optimize 'or' operation of trivial revisions to a list
Yuya Nishihara <yuya@tcha.org>
parents:
25342
diff
changeset
|
2447 if not ss: |
7fbef7932af9
revset: optimize 'or' operation of trivial revisions to a list
Yuya Nishihara <yuya@tcha.org>
parents:
25342
diff
changeset
|
2448 return |
7fbef7932af9
revset: optimize 'or' operation of trivial revisions to a list
Yuya Nishihara <yuya@tcha.org>
parents:
25342
diff
changeset
|
2449 if len(ss) == 1: |
7fbef7932af9
revset: optimize 'or' operation of trivial revisions to a list
Yuya Nishihara <yuya@tcha.org>
parents:
25342
diff
changeset
|
2450 w, t = ss[0] |
7fbef7932af9
revset: optimize 'or' operation of trivial revisions to a list
Yuya Nishihara <yuya@tcha.org>
parents:
25342
diff
changeset
|
2451 else: |
7fbef7932af9
revset: optimize 'or' operation of trivial revisions to a list
Yuya Nishihara <yuya@tcha.org>
parents:
25342
diff
changeset
|
2452 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
|
2453 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
|
2454 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
|
2455 ws.append(w) |
7fbef7932af9
revset: optimize 'or' operation of trivial revisions to a list
Yuya Nishihara <yuya@tcha.org>
parents:
25342
diff
changeset
|
2456 ts.append(t) |
7fbef7932af9
revset: optimize 'or' operation of trivial revisions to a list
Yuya Nishihara <yuya@tcha.org>
parents:
25342
diff
changeset
|
2457 del ss[:] |
7fbef7932af9
revset: optimize 'or' operation of trivial revisions to a list
Yuya Nishihara <yuya@tcha.org>
parents:
25342
diff
changeset
|
2458 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
|
2459 w, t = optimize(y, False) |
25996
b12e00a05d57
revset: prevent crash caused by empty group expression while optimizing "or"
Yuya Nishihara <yuya@tcha.org>
parents:
25995
diff
changeset
|
2460 if t is not None and (t[0] == 'string' or t[0] == 'symbol'): |
25343
7fbef7932af9
revset: optimize 'or' operation of trivial revisions to a list
Yuya Nishihara <yuya@tcha.org>
parents:
25342
diff
changeset
|
2461 ss.append((w, t)) |
7fbef7932af9
revset: optimize 'or' operation of trivial revisions to a list
Yuya Nishihara <yuya@tcha.org>
parents:
25342
diff
changeset
|
2462 continue |
7fbef7932af9
revset: optimize 'or' operation of trivial revisions to a list
Yuya Nishihara <yuya@tcha.org>
parents:
25342
diff
changeset
|
2463 flushss() |
7fbef7932af9
revset: optimize 'or' operation of trivial revisions to a list
Yuya Nishihara <yuya@tcha.org>
parents:
25342
diff
changeset
|
2464 ws.append(w) |
7fbef7932af9
revset: optimize 'or' operation of trivial revisions to a list
Yuya Nishihara <yuya@tcha.org>
parents:
25342
diff
changeset
|
2465 ts.append(t) |
7fbef7932af9
revset: optimize 'or' operation of trivial revisions to a list
Yuya Nishihara <yuya@tcha.org>
parents:
25342
diff
changeset
|
2466 flushss() |
7fbef7932af9
revset: optimize 'or' operation of trivial revisions to a list
Yuya Nishihara <yuya@tcha.org>
parents:
25342
diff
changeset
|
2467 if len(ts) == 1: |
7fbef7932af9
revset: optimize 'or' operation of trivial revisions to a list
Yuya Nishihara <yuya@tcha.org>
parents:
25342
diff
changeset
|
2468 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
|
2469 # 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
|
2470 # ("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
|
2471 # 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
|
2472 return max(ws), (op,) + tuple(ts) |
11275 | 2473 elif op == 'not': |
25191
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
2474 # 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
|
2475 if x[1] == ('func', ('symbol', 'public'), None): |
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
2476 newsym = ('func', ('symbol', '_notpublic'), None) |
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
2477 o = optimize(newsym, not small) |
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
2478 return o[0], o[1] |
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
2479 else: |
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
2480 o = optimize(x[1], not small) |
08d1ef09ed37
revset: optimize not public revset
Laurent Charignon <lcharignon@fb.com>
parents:
25149
diff
changeset
|
2481 return o[0], (op, o[1]) |
14070
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
2482 elif op == 'parentpost': |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
2483 o = optimize(x[1], small) |
305c97670d7a
revset: add ^ and ~ operators from parentrevspec extension
Kevin Gessner <kevin@kevingessner.com>
parents:
14061
diff
changeset
|
2484 return o[0], (op, o[1]) |
11275 | 2485 elif op == 'group': |
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2486 return optimize(x[1], small) |
16860
e1aa1ed30030
revset: turn dagrange into a function
Bryan O'Sullivan <bryano@fb.com>
parents:
16859
diff
changeset
|
2487 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
|
2488 if op == 'parent': |
805651777188
revsets: do the right thing with x^:y (issue2884)
Matt Mackall <mpm@selenic.com>
parents:
14723
diff
changeset
|
2489 # 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
|
2490 post = ('parentpost', x[1]) |
805651777188
revsets: do the right thing with x^:y (issue2884)
Matt Mackall <mpm@selenic.com>
parents:
14723
diff
changeset
|
2491 if x[2][0] == 'dagrangepre': |
805651777188
revsets: do the right thing with x^:y (issue2884)
Matt Mackall <mpm@selenic.com>
parents:
14723
diff
changeset
|
2492 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
|
2493 elif x[2][0] == 'rangepre': |
805651777188
revsets: do the right thing with x^:y (issue2884)
Matt Mackall <mpm@selenic.com>
parents:
14723
diff
changeset
|
2494 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
|
2495 |
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2496 wa, ta = optimize(x[1], small) |
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2497 wb, tb = optimize(x[2], small) |
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2498 return wa + wb, (op, ta, tb) |
11275 | 2499 elif op == 'func': |
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
2500 f = getstring(x[1], _("not a symbol")) |
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2501 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
|
2502 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
|
2503 "outgoing user"): |
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2504 w = 10 # slow |
12351
b913232d13c1
revsets: reduce cost of outgoing in the optimizer
Matt Mackall <mpm@selenic.com>
parents:
12321
diff
changeset
|
2505 elif f in "modifies adds removes": |
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2506 w = 30 # slower |
11275 | 2507 elif f == "contains": |
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2508 w = 100 # very slow |
11275 | 2509 elif f == "ancestor": |
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2510 w = 1 * smallbonus |
22451
186fd06283b4
revset: lower weight for _intlist function
Durham Goode <durham@fb.com>
parents:
22450
diff
changeset
|
2511 elif f in "reverse limit first _intlist": |
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2512 w = 0 |
11275 | 2513 elif f in "sort": |
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2514 w = 10 # assume most sorts look at changelog |
11275 | 2515 else: |
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2516 w = 1 |
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2517 return w + wa, (op, x[1], ta) |
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2518 return 1, x |
11275 | 2519 |
16771
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2520 _aliasarg = ('func', ('symbol', '_aliasarg')) |
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2521 def _getaliasarg(tree): |
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2522 """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
|
2523 return X, None otherwise. |
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2524 """ |
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2525 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
|
2526 and tree[2][0] == 'string'): |
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2527 return tree[2][1] |
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2528 return None |
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2529 |
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2530 def _checkaliasarg(tree, known=None): |
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2531 """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
|
2532 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
|
2533 """ |
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2534 if isinstance(tree, tuple): |
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2535 arg = _getaliasarg(tree) |
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2536 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
|
2537 raise error.UnknownIdentifier('_aliasarg', []) |
16771
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2538 for t in tree: |
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2539 _checkaliasarg(t, known) |
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2540 |
23845
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2541 # 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
|
2542 # alias declarations and definitions |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2543 _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
|
2544 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
|
2545 |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2546 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
|
2547 """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
|
2548 |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2549 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
|
2550 (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
|
2551 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
|
2552 """ |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2553 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
|
2554 syminitletters=_aliassyminitletters) |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2555 |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2556 def _parsealiasdecl(decl): |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2557 """Parse alias declaration ``decl`` |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2558 |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2559 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
|
2560 |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2561 - ``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
|
2562 - ``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
|
2563 - ``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
|
2564 - ``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
|
2565 |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2566 >>> _parsealiasdecl('foo') |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2567 ('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
|
2568 >>> _parsealiasdecl('$foo') |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2569 ('$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
|
2570 >>> _parsealiasdecl('foo::bar') |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2571 ('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
|
2572 >>> _parsealiasdecl('foo bar') |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2573 ('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
|
2574 >>> _parsealiasdecl('foo()') |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2575 ('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
|
2576 >>> _parsealiasdecl('$foo()') |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2577 ('$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
|
2578 >>> _parsealiasdecl('foo($1, $2)') |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2579 ('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
|
2580 >>> _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
|
2581 ('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
|
2582 >>> _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
|
2583 ('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
|
2584 >>> _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
|
2585 ('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
|
2586 >>> _parsealiasdecl('foo("string")') |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2587 ('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
|
2588 >>> _parsealiasdecl('foo($1, $2') |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2589 ('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
|
2590 >>> _parsealiasdecl('foo("string') |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2591 ('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
|
2592 >>> _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
|
2593 ('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
|
2594 """ |
25654
af329a84310c
parser: accept iterator of tokens instead of tokenizer function and program
Yuya Nishihara <yuya@tcha.org>
parents:
25648
diff
changeset
|
2595 p = parser.parser(elements) |
23845
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2596 try: |
25654
af329a84310c
parser: accept iterator of tokens instead of tokenizer function and program
Yuya Nishihara <yuya@tcha.org>
parents:
25648
diff
changeset
|
2597 tree, pos = p.parse(_tokenizealias(decl)) |
23845
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2598 if (pos != len(decl)): |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2599 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
|
2600 |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2601 if isvalidsymbol(tree): |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2602 # "name = ...." style |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2603 name = getsymbol(tree) |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2604 if name.startswith('$'): |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2605 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
|
2606 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
|
2607 |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2608 if isvalidfunc(tree): |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2609 # "name(arg, ....) = ...." style |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2610 name = getfuncname(tree) |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2611 if name.startswith('$'): |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2612 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
|
2613 args = [] |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2614 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
|
2615 if not isvalidsymbol(arg): |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2616 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
|
2617 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
|
2618 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
|
2619 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
|
2620 _("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
|
2621 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
|
2622 |
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2623 return (decl, None, None, _("invalid format")) |
25660
328739ea70c3
global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25654
diff
changeset
|
2624 except error.ParseError as inst: |
23845
0a7fd54d4e60
revset: introduce "_parsealiasdecl" to parse alias declarations strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23844
diff
changeset
|
2625 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
|
2626 |
23993
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2627 def _parsealiasdefn(defn, args): |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2628 """Parse alias definition ``defn`` |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2629 |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2630 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
|
2631 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
|
2632 |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2633 ``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
|
2634 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
|
2635 |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2636 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
|
2637 |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2638 >>> args = ['$1', '$2', 'foo'] |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2639 >>> 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
|
2640 (or |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2641 (func |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2642 ('symbol', '_aliasarg') |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2643 ('string', '$1')) |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2644 (func |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2645 ('symbol', '_aliasarg') |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2646 ('string', 'foo'))) |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2647 >>> try: |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2648 ... _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
|
2649 ... except error.ParseError, inst: |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2650 ... print parseerrordetail(inst) |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2651 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
|
2652 >>> args = ['$1', '$10', 'foo'] |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2653 >>> 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
|
2654 (or |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2655 (func |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2656 ('symbol', '_aliasarg') |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2657 ('string', '$10')) |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2658 ('symbol', 'foobar')) |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2659 >>> 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
|
2660 (or |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2661 ('string', '$1') |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2662 ('string', 'foo')) |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2663 """ |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2664 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
|
2665 if args: |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2666 argset = set(args) |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2667 else: |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2668 argset = set() |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2669 |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2670 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
|
2671 if t == 'symbol': |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2672 if value in argset: |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2673 # 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
|
2674 # "_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
|
2675 # 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
|
2676 yield ('symbol', '_aliasarg', pos) |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2677 yield ('(', None, pos) |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2678 yield ('string', value, pos) |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2679 yield (')', None, pos) |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2680 continue |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2681 elif value.startswith('$'): |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2682 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
|
2683 pos) |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2684 yield (t, value, pos) |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2685 |
25654
af329a84310c
parser: accept iterator of tokens instead of tokenizer function and program
Yuya Nishihara <yuya@tcha.org>
parents:
25648
diff
changeset
|
2686 p = parser.parser(elements) |
af329a84310c
parser: accept iterator of tokens instead of tokenizer function and program
Yuya Nishihara <yuya@tcha.org>
parents:
25648
diff
changeset
|
2687 tree, pos = p.parse(tokenizedefn(defn)) |
23993
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2688 if pos != len(defn): |
eedade006458
revset: introduce _parsealiasdefn to parse alias definitions strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23978
diff
changeset
|
2689 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
|
2690 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
|
2691 |
14098
9f5a0acb0056
revset aliases
Alexander Solovyov <alexander@solovyov.net>
parents:
14073
diff
changeset
|
2692 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
|
2693 # 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
|
2694 # 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
|
2695 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
|
2696 |
14723
b9faf94ee196
revset: fix aliases with 0 or more than 2 parameters
Mads Kiilerich <mads@kiilerich.com>
parents:
14717
diff
changeset
|
2697 def __init__(self, name, value): |
14098
9f5a0acb0056
revset aliases
Alexander Solovyov <alexander@solovyov.net>
parents:
14073
diff
changeset
|
2698 '''Aliases like: |
9f5a0acb0056
revset aliases
Alexander Solovyov <alexander@solovyov.net>
parents:
14073
diff
changeset
|
2699 |
9f5a0acb0056
revset aliases
Alexander Solovyov <alexander@solovyov.net>
parents:
14073
diff
changeset
|
2700 h = heads(default) |
9f5a0acb0056
revset aliases
Alexander Solovyov <alexander@solovyov.net>
parents:
14073
diff
changeset
|
2701 b($1) = ancestors($1) - ancestors(default) |
9f5a0acb0056
revset aliases
Alexander Solovyov <alexander@solovyov.net>
parents:
14073
diff
changeset
|
2702 ''' |
23846
aac4a1a7920e
revset: parse alias declaration strictly by _parsealiasdecl
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23845
diff
changeset
|
2703 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
|
2704 if self.error: |
aac4a1a7920e
revset: parse alias declaration strictly by _parsealiasdecl
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23845
diff
changeset
|
2705 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
|
2706 ' "%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
|
2707 return |
aac4a1a7920e
revset: parse alias declaration strictly by _parsealiasdecl
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23845
diff
changeset
|
2708 |
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
|
2709 try: |
23994
8a2156780839
revset: replace parsing alias definition by _parsealiasdefn to parse strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23993
diff
changeset
|
2710 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
|
2711 # 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
|
2712 _checkaliasarg(self.replacement, self.args) |
25660
328739ea70c3
global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25654
diff
changeset
|
2713 except error.ParseError as 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
|
2714 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
|
2715 ' "%s": %s') % (self.name, parseerrordetail(inst)) |
14098
9f5a0acb0056
revset aliases
Alexander Solovyov <alexander@solovyov.net>
parents:
14073
diff
changeset
|
2716 |
16096
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2717 def _getalias(aliases, tree): |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2718 """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
|
2719 otherwise. |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2720 """ |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2721 if isinstance(tree, tuple) and tree: |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2722 if tree[0] == 'symbol' and len(tree) == 2: |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2723 name = tree[1] |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2724 alias = aliases.get(name) |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2725 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
|
2726 return alias |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2727 if tree[0] == 'func' and len(tree) > 1: |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2728 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
|
2729 name = tree[1][1] |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2730 alias = aliases.get(name) |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2731 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
|
2732 return alias |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2733 return None |
14098
9f5a0acb0056
revset aliases
Alexander Solovyov <alexander@solovyov.net>
parents:
14073
diff
changeset
|
2734 |
16096
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2735 def _expandargs(tree, args): |
16771
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2736 """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
|
2737 same name in args, recursively. |
16096
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2738 """ |
16771
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2739 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
|
2740 return tree |
16771
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2741 arg = _getaliasarg(tree) |
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2742 if arg is not None: |
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2743 return args[arg] |
16096
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2744 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
|
2745 |
16838
d37d221334be
revset: cache alias expansions
Patrick Mezard <patrick@mezard.eu>
parents:
16834
diff
changeset
|
2746 def _expandaliases(aliases, tree, expanding, cache): |
16096
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2747 """Expand aliases in tree, recursively. |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2748 |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2749 '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
|
2750 revsetalias objects. |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2751 """ |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2752 if not isinstance(tree, tuple): |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2753 # Do not expand raw strings |
14098
9f5a0acb0056
revset aliases
Alexander Solovyov <alexander@solovyov.net>
parents:
14073
diff
changeset
|
2754 return tree |
16096
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2755 alias = _getalias(aliases, tree) |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2756 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
|
2757 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
|
2758 raise util.Abort(alias.error) |
16096
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2759 if alias in expanding: |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2760 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
|
2761 'detected') % alias.name) |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2762 expanding.append(alias) |
16838
d37d221334be
revset: cache alias expansions
Patrick Mezard <patrick@mezard.eu>
parents:
16834
diff
changeset
|
2763 if alias.name not in cache: |
d37d221334be
revset: cache alias expansions
Patrick Mezard <patrick@mezard.eu>
parents:
16834
diff
changeset
|
2764 cache[alias.name] = _expandaliases(aliases, alias.replacement, |
d37d221334be
revset: cache alias expansions
Patrick Mezard <patrick@mezard.eu>
parents:
16834
diff
changeset
|
2765 expanding, cache) |
d37d221334be
revset: cache alias expansions
Patrick Mezard <patrick@mezard.eu>
parents:
16834
diff
changeset
|
2766 result = cache[alias.name] |
16772
30e46d7138de
revset: fix infinite alias expansion detection
Patrick Mezard <patrick@mezard.eu>
parents:
16771
diff
changeset
|
2767 expanding.pop() |
16096
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2768 if alias.args is not None: |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2769 l = getlist(tree[2]) |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2770 if len(l) != len(alias.args): |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2771 raise error.ParseError( |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2772 _('invalid number of arguments: %s') % len(l)) |
16838
d37d221334be
revset: cache alias expansions
Patrick Mezard <patrick@mezard.eu>
parents:
16834
diff
changeset
|
2773 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
|
2774 result = _expandargs(result, dict(zip(alias.args, l))) |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2775 else: |
16838
d37d221334be
revset: cache alias expansions
Patrick Mezard <patrick@mezard.eu>
parents:
16834
diff
changeset
|
2776 result = tuple(_expandaliases(aliases, t, expanding, cache) |
16096
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2777 for t in tree) |
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2778 return result |
14098
9f5a0acb0056
revset aliases
Alexander Solovyov <alexander@solovyov.net>
parents:
14073
diff
changeset
|
2779 |
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
|
2780 def findaliases(ui, tree, showwarning=None): |
16771
2f3317d53d51
revset: explicitely tag alias arguments for expansion
Patrick Mezard <patrick@mezard.eu>
parents:
16748
diff
changeset
|
2781 _checkaliasarg(tree) |
16096
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2782 aliases = {} |
14098
9f5a0acb0056
revset aliases
Alexander Solovyov <alexander@solovyov.net>
parents:
14073
diff
changeset
|
2783 for k, v in ui.configitems('revsetalias'): |
9f5a0acb0056
revset aliases
Alexander Solovyov <alexander@solovyov.net>
parents:
14073
diff
changeset
|
2784 alias = revsetalias(k, v) |
16096
b8be450638f6
revset: fix alias substitution recursion (issue3240)
Patrick Mezard <patrick@mezard.eu>
parents:
16007
diff
changeset
|
2785 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
|
2786 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
|
2787 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
|
2788 # 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
|
2789 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
|
2790 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
|
2791 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
|
2792 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
|
2793 return tree |
14098
9f5a0acb0056
revset aliases
Alexander Solovyov <alexander@solovyov.net>
parents:
14073
diff
changeset
|
2794 |
23742
3a4d8a6ce432
revset: introduce new operator "##" to concatenate strings/symbols at runtime
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23729
diff
changeset
|
2795 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
|
2796 """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
|
2797 """ |
3a4d8a6ce432
revset: introduce new operator "##" to concatenate strings/symbols at runtime
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23729
diff
changeset
|
2798 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
|
2799 return tree |
3a4d8a6ce432
revset: introduce new operator "##" to concatenate strings/symbols at runtime
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23729
diff
changeset
|
2800 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
|
2801 pending = [tree] |
3a4d8a6ce432
revset: introduce new operator "##" to concatenate strings/symbols at runtime
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23729
diff
changeset
|
2802 l = [] |
3a4d8a6ce432
revset: introduce new operator "##" to concatenate strings/symbols at runtime
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23729
diff
changeset
|
2803 while pending: |
3a4d8a6ce432
revset: introduce new operator "##" to concatenate strings/symbols at runtime
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23729
diff
changeset
|
2804 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
|
2805 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
|
2806 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
|
2807 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
|
2808 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
|
2809 else: |
3a4d8a6ce432
revset: introduce new operator "##" to concatenate strings/symbols at runtime
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23729
diff
changeset
|
2810 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
|
2811 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
|
2812 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
|
2813 else: |
3a4d8a6ce432
revset: introduce new operator "##" to concatenate strings/symbols at runtime
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23729
diff
changeset
|
2814 return tuple(foldconcat(t) for t in tree) |
14098
9f5a0acb0056
revset aliases
Alexander Solovyov <alexander@solovyov.net>
parents:
14073
diff
changeset
|
2815 |
20779
ffc2295c6b80
revset: pass a lookup function to the tokenizer
Matt Mackall <mpm@selenic.com>
parents:
20754
diff
changeset
|
2816 def parse(spec, lookup=None): |
25654
af329a84310c
parser: accept iterator of tokens instead of tokenizer function and program
Yuya Nishihara <yuya@tcha.org>
parents:
25648
diff
changeset
|
2817 p = parser.parser(elements) |
af329a84310c
parser: accept iterator of tokens instead of tokenizer function and program
Yuya Nishihara <yuya@tcha.org>
parents:
25648
diff
changeset
|
2818 tree, pos = p.parse(tokenize(spec, lookup=lookup)) |
25251
235f6490550c
revset: move validation of incomplete parsing to parse() function
Yuya Nishihara <yuya@tcha.org>
parents:
25225
diff
changeset
|
2819 if pos != len(spec): |
235f6490550c
revset: move validation of incomplete parsing to parse() function
Yuya Nishihara <yuya@tcha.org>
parents:
25225
diff
changeset
|
2820 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
|
2821 return parser.simplifyinfixops(tree, ('or',)) |
20779
ffc2295c6b80
revset: pass a lookup function to the tokenizer
Matt Mackall <mpm@selenic.com>
parents:
20754
diff
changeset
|
2822 |
24518
dd5e56f08d13
revset: add hook after tree parsing
Laurent Charignon <lcharignon@fb.com>
parents:
24459
diff
changeset
|
2823 def posttreebuilthook(tree, repo): |
dd5e56f08d13
revset: add hook after tree parsing
Laurent Charignon <lcharignon@fb.com>
parents:
24459
diff
changeset
|
2824 # 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
|
2825 pass |
dd5e56f08d13
revset: add hook after tree parsing
Laurent Charignon <lcharignon@fb.com>
parents:
24459
diff
changeset
|
2826 |
20779
ffc2295c6b80
revset: pass a lookup function to the tokenizer
Matt Mackall <mpm@selenic.com>
parents:
20754
diff
changeset
|
2827 def match(ui, spec, repo=None): |
11385
e5a2134c083b
revset: nicer exception for empty queries
Matt Mackall <mpm@selenic.com>
parents:
11383
diff
changeset
|
2828 if not spec: |
e5a2134c083b
revset: nicer exception for empty queries
Matt Mackall <mpm@selenic.com>
parents:
11383
diff
changeset
|
2829 raise error.ParseError(_("empty query")) |
20779
ffc2295c6b80
revset: pass a lookup function to the tokenizer
Matt Mackall <mpm@selenic.com>
parents:
20754
diff
changeset
|
2830 lookup = None |
ffc2295c6b80
revset: pass a lookup function to the tokenizer
Matt Mackall <mpm@selenic.com>
parents:
20754
diff
changeset
|
2831 if repo: |
ffc2295c6b80
revset: pass a lookup function to the tokenizer
Matt Mackall <mpm@selenic.com>
parents:
20754
diff
changeset
|
2832 lookup = repo.__contains__ |
25251
235f6490550c
revset: move validation of incomplete parsing to parse() function
Yuya Nishihara <yuya@tcha.org>
parents:
25225
diff
changeset
|
2833 tree = parse(spec, lookup) |
25926
996102be8b91
revset: split post-parsing stage from match()
Yuya Nishihara <yuya@tcha.org>
parents:
25902
diff
changeset
|
2834 return _makematcher(ui, tree, repo) |
996102be8b91
revset: split post-parsing stage from match()
Yuya Nishihara <yuya@tcha.org>
parents:
25902
diff
changeset
|
2835 |
25927
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2836 def matchany(ui, specs, repo=None): |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2837 """Create a matcher that will include any revisions matching one of the |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2838 given specs""" |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2839 if not specs: |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2840 def mfunc(repo, subset=None): |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2841 return baseset() |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2842 return mfunc |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2843 if not all(specs): |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2844 raise error.ParseError(_("empty query")) |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2845 lookup = None |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2846 if repo: |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2847 lookup = repo.__contains__ |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2848 if len(specs) == 1: |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2849 tree = parse(specs[0], lookup) |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2850 else: |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2851 tree = ('or',) + tuple(parse(s, lookup) for s in specs) |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2852 return _makematcher(ui, tree, repo) |
44da63623fca
revset: add matchany() to construct OR expression from a list of specs
Yuya Nishihara <yuya@tcha.org>
parents:
25926
diff
changeset
|
2853 |
25926
996102be8b91
revset: split post-parsing stage from match()
Yuya Nishihara <yuya@tcha.org>
parents:
25902
diff
changeset
|
2854 def _makematcher(ui, tree, repo): |
14900
fc3d6f300d7d
revset: allow bypassing alias expansion
Matt Mackall <mpm@selenic.com>
parents:
14851
diff
changeset
|
2855 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
|
2856 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
|
2857 tree = foldconcat(tree) |
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
2858 weight, tree = optimize(tree, True) |
24518
dd5e56f08d13
revset: add hook after tree parsing
Laurent Charignon <lcharignon@fb.com>
parents:
24459
diff
changeset
|
2859 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
|
2860 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
|
2861 if subset is None: |
24115
ff24af40728b
revset: specify fullreposet without using spanset factory
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
2862 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
|
2863 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
|
2864 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
|
2865 else: |
2717dcff7be1
revset: use a single return statement in matcher function
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22670
diff
changeset
|
2866 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
|
2867 return result |
11275 | 2868 return mfunc |
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
2869 |
14901
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2870 def formatspec(expr, *args): |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2871 ''' |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2872 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
|
2873 escapes arguments appropriately. Aliases are intentionally ignored |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2874 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
|
2875 |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2876 Supported arguments: |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2877 |
15266
8bea39ca9acb
revset: add %r for embedded revset support to formatspec
Matt Mackall <mpm@selenic.com>
parents:
15153
diff
changeset
|
2878 %r = revset expression, parenthesized |
14901
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2879 %d = int(arg), no quoting |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2880 %s = string(arg), escaped and single-quoted |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2881 %b = arg.branch(), escaped and single-quoted |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2882 %n = hex(arg), single-quoted |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2883 %% = a literal '%' |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2884 |
15266
8bea39ca9acb
revset: add %r for embedded revset support to formatspec
Matt Mackall <mpm@selenic.com>
parents:
15153
diff
changeset
|
2885 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
|
2886 |
15268
bd5103819c2e
revset: fix %r handling in formatspec
Matt Mackall <mpm@selenic.com>
parents:
15266
diff
changeset
|
2887 >>> 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
|
2888 '(10 or 11):: and ((this()) or (that()))' |
14901
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2889 >>> formatspec('%d:: and not %d::', 10, 20) |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2890 '10:: and not 20::' |
15325
cdf1daa3b83f
revset: deal with empty lists in formatspec
Matt Mackall <mpm@selenic.com>
parents:
15268
diff
changeset
|
2891 >>> formatspec('%ld or %ld', [], [1]) |
15898
6902e13ddd03
revset: optimize building large lists in formatrevspec
Matt Mackall <mpm@selenic.com>
parents:
15837
diff
changeset
|
2892 "_list('') or 1" |
14901
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2893 >>> formatspec('keyword(%s)', 'foo\\xe9') |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2894 "keyword('foo\\\\xe9')" |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2895 >>> b = lambda: 'default' |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2896 >>> b.branch = b |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2897 >>> formatspec('branch(%b)', b) |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2898 "branch('default')" |
15140
353a1ba928f6
revset: add 'l' flag to formatspec for args
Matt Mackall <mpm@selenic.com>
parents:
15138
diff
changeset
|
2899 >>> 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
|
2900 "root(_list('a\\x00b\\x00c\\x00d'))" |
14901
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2901 ''' |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2902 |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2903 def quote(s): |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2904 return repr(str(s)) |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2905 |
15140
353a1ba928f6
revset: add 'l' flag to formatspec for args
Matt Mackall <mpm@selenic.com>
parents:
15138
diff
changeset
|
2906 def argtype(c, arg): |
353a1ba928f6
revset: add 'l' flag to formatspec for args
Matt Mackall <mpm@selenic.com>
parents:
15138
diff
changeset
|
2907 if c == 'd': |
353a1ba928f6
revset: add 'l' flag to formatspec for args
Matt Mackall <mpm@selenic.com>
parents:
15138
diff
changeset
|
2908 return str(int(arg)) |
353a1ba928f6
revset: add 'l' flag to formatspec for args
Matt Mackall <mpm@selenic.com>
parents:
15138
diff
changeset
|
2909 elif c == 's': |
353a1ba928f6
revset: add 'l' flag to formatspec for args
Matt Mackall <mpm@selenic.com>
parents:
15138
diff
changeset
|
2910 return quote(arg) |
15266
8bea39ca9acb
revset: add %r for embedded revset support to formatspec
Matt Mackall <mpm@selenic.com>
parents:
15153
diff
changeset
|
2911 elif c == 'r': |
8bea39ca9acb
revset: add %r for embedded revset support to formatspec
Matt Mackall <mpm@selenic.com>
parents:
15153
diff
changeset
|
2912 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
|
2913 return '(%s)' % arg |
15140
353a1ba928f6
revset: add 'l' flag to formatspec for args
Matt Mackall <mpm@selenic.com>
parents:
15138
diff
changeset
|
2914 elif c == 'n': |
16417
b4b0c6931e11
revset: avoid demandimport bug
Matt Mackall <mpm@selenic.com>
parents:
16415
diff
changeset
|
2915 return quote(node.hex(arg)) |
15140
353a1ba928f6
revset: add 'l' flag to formatspec for args
Matt Mackall <mpm@selenic.com>
parents:
15138
diff
changeset
|
2916 elif c == 'b': |
353a1ba928f6
revset: add 'l' flag to formatspec for args
Matt Mackall <mpm@selenic.com>
parents:
15138
diff
changeset
|
2917 return quote(arg.branch()) |
353a1ba928f6
revset: add 'l' flag to formatspec for args
Matt Mackall <mpm@selenic.com>
parents:
15138
diff
changeset
|
2918 |
15595
a585d78e7b2f
revset: balance %l or-expressions (issue3129)
Matt Mackall <mpm@selenic.com>
parents:
15532
diff
changeset
|
2919 def listexp(s, t): |
a585d78e7b2f
revset: balance %l or-expressions (issue3129)
Matt Mackall <mpm@selenic.com>
parents:
15532
diff
changeset
|
2920 l = len(s) |
a585d78e7b2f
revset: balance %l or-expressions (issue3129)
Matt Mackall <mpm@selenic.com>
parents:
15532
diff
changeset
|
2921 if l == 0: |
15898
6902e13ddd03
revset: optimize building large lists in formatrevspec
Matt Mackall <mpm@selenic.com>
parents:
15837
diff
changeset
|
2922 return "_list('')" |
6902e13ddd03
revset: optimize building large lists in formatrevspec
Matt Mackall <mpm@selenic.com>
parents:
15837
diff
changeset
|
2923 elif l == 1: |
15595
a585d78e7b2f
revset: balance %l or-expressions (issue3129)
Matt Mackall <mpm@selenic.com>
parents:
15532
diff
changeset
|
2924 return argtype(t, s[0]) |
15898
6902e13ddd03
revset: optimize building large lists in formatrevspec
Matt Mackall <mpm@selenic.com>
parents:
15837
diff
changeset
|
2925 elif t == 'd': |
20566
98024950ade0
revset: added _intlist method to replace _list for %ld
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20552
diff
changeset
|
2926 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
|
2927 elif t == 's': |
6902e13ddd03
revset: optimize building large lists in formatrevspec
Matt Mackall <mpm@selenic.com>
parents:
15837
diff
changeset
|
2928 return "_list('%s')" % "\0".join(s) |
6902e13ddd03
revset: optimize building large lists in formatrevspec
Matt Mackall <mpm@selenic.com>
parents:
15837
diff
changeset
|
2929 elif t == 'n': |
20569
0d4be103c734
revset: added _hexlist method to replace _list for %ln
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20566
diff
changeset
|
2930 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
|
2931 elif t == 'b': |
6902e13ddd03
revset: optimize building large lists in formatrevspec
Matt Mackall <mpm@selenic.com>
parents:
15837
diff
changeset
|
2932 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
|
2933 |
15791
a814f8fcc65a
Use explicit integer division
Martin Geisler <mg@aragost.com>
parents:
15726
diff
changeset
|
2934 m = l // 2 |
15595
a585d78e7b2f
revset: balance %l or-expressions (issue3129)
Matt Mackall <mpm@selenic.com>
parents:
15532
diff
changeset
|
2935 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
|
2936 |
14901
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2937 ret = '' |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2938 pos = 0 |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2939 arg = 0 |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2940 while pos < len(expr): |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2941 c = expr[pos] |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2942 if c == '%': |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2943 pos += 1 |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2944 d = expr[pos] |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2945 if d == '%': |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2946 ret += d |
15268
bd5103819c2e
revset: fix %r handling in formatspec
Matt Mackall <mpm@selenic.com>
parents:
15266
diff
changeset
|
2947 elif d in 'dsnbr': |
15140
353a1ba928f6
revset: add 'l' flag to formatspec for args
Matt Mackall <mpm@selenic.com>
parents:
15138
diff
changeset
|
2948 ret += argtype(d, args[arg]) |
14901
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2949 arg += 1 |
15140
353a1ba928f6
revset: add 'l' flag to formatspec for args
Matt Mackall <mpm@selenic.com>
parents:
15138
diff
changeset
|
2950 elif d == 'l': |
353a1ba928f6
revset: add 'l' flag to formatspec for args
Matt Mackall <mpm@selenic.com>
parents:
15138
diff
changeset
|
2951 # a list of some type |
353a1ba928f6
revset: add 'l' flag to formatspec for args
Matt Mackall <mpm@selenic.com>
parents:
15138
diff
changeset
|
2952 pos += 1 |
353a1ba928f6
revset: add 'l' flag to formatspec for args
Matt Mackall <mpm@selenic.com>
parents:
15138
diff
changeset
|
2953 d = expr[pos] |
15596 | 2954 ret += listexp(list(args[arg]), d) |
14901
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2955 arg += 1 |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2956 else: |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2957 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
|
2958 else: |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2959 ret += c |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2960 pos += 1 |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2961 |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2962 return ret |
a773119f30ba
revset: add formatspec convenience query builder
Matt Mackall <mpm@selenic.com>
parents:
14900
diff
changeset
|
2963 |
16218
81a1a00f5738
debugrevspec: pretty print output
Patrick Mezard <patrick@mezard.eu>
parents:
16185
diff
changeset
|
2964 def prettyformat(tree): |
25253
3f1a9b44b8c2
parser: move prettyformat() function from revset module
Yuya Nishihara <yuya@tcha.org>
parents:
25251
diff
changeset
|
2965 return parser.prettyformat(tree, ('string', 'symbol')) |
16218
81a1a00f5738
debugrevspec: pretty print output
Patrick Mezard <patrick@mezard.eu>
parents:
16185
diff
changeset
|
2966 |
19719
2f9d5c5256ea
revset: add helper function to get revset parse tree depth
Alexander Plavin <alexander@plav.in>
parents:
19706
diff
changeset
|
2967 def depth(tree): |
2f9d5c5256ea
revset: add helper function to get revset parse tree depth
Alexander Plavin <alexander@plav.in>
parents:
19706
diff
changeset
|
2968 if isinstance(tree, tuple): |
2f9d5c5256ea
revset: add helper function to get revset parse tree depth
Alexander Plavin <alexander@plav.in>
parents:
19706
diff
changeset
|
2969 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
|
2970 else: |
2f9d5c5256ea
revset: add helper function to get revset parse tree depth
Alexander Plavin <alexander@plav.in>
parents:
19706
diff
changeset
|
2971 return 0 |
2f9d5c5256ea
revset: add helper function to get revset parse tree depth
Alexander Plavin <alexander@plav.in>
parents:
19706
diff
changeset
|
2972 |
19720
f0b992a9be9c
revset: add helper function to get functions used in a revset parse tree
Alexander Plavin <alexander@plav.in>
parents:
19719
diff
changeset
|
2973 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
|
2974 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
|
2975 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
|
2976 else: |
f0b992a9be9c
revset: add helper function to get functions used in a revset parse tree
Alexander Plavin <alexander@plav.in>
parents:
19719
diff
changeset
|
2977 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
|
2978 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
|
2979 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
|
2980 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
|
2981 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
|
2982 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
|
2983 |
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
2984 class abstractsmartset(object): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
2985 |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
2986 def __nonzero__(self): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
2987 """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
|
2988 raise NotImplementedError() |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
2989 |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
2990 def __contains__(self, rev): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
2991 """provide fast membership testing""" |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
2992 raise NotImplementedError() |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
2993 |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
2994 def __iter__(self): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
2995 """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
|
2996 raise NotImplementedError() |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
2997 |
22716
6877ba8d85ff
abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22715
diff
changeset
|
2998 # 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
|
2999 # 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
|
3000 # |
6877ba8d85ff
abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22715
diff
changeset
|
3001 # 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
|
3002 # 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
|
3003 fastasc = None |
6877ba8d85ff
abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22715
diff
changeset
|
3004 fastdesc = None |
6877ba8d85ff
abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22715
diff
changeset
|
3005 |
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3006 def isascending(self): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3007 """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
|
3008 raise NotImplementedError() |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3009 |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3010 def isdescending(self): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3011 """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
|
3012 raise NotImplementedError() |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3013 |
26099
ab66c1dee405
revset: cache smartset's min/max
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26095
diff
changeset
|
3014 @util.cachefunc |
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3015 def min(self): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3016 """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
|
3017 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
|
3018 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
|
3019 return r |
e8832cf1abf6
abstractsmartset: add a default implementation for min and max
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22721
diff
changeset
|
3020 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
|
3021 return min(self) |
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3022 |
26099
ab66c1dee405
revset: cache smartset's min/max
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26095
diff
changeset
|
3023 @util.cachefunc |
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3024 def max(self): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3025 """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
|
3026 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
|
3027 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
|
3028 return r |
e8832cf1abf6
abstractsmartset: add a default implementation for min and max
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22721
diff
changeset
|
3029 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
|
3030 return max(self) |
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3031 |
22808
228b0aafb1ce
smartset: add first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22805
diff
changeset
|
3032 def first(self): |
228b0aafb1ce
smartset: add first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22805
diff
changeset
|
3033 """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
|
3034 |
228b0aafb1ce
smartset: add first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22805
diff
changeset
|
3035 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
|
3036 raise NotImplementedError() |
228b0aafb1ce
smartset: add first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22805
diff
changeset
|
3037 |
228b0aafb1ce
smartset: add first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22805
diff
changeset
|
3038 def last(self): |
228b0aafb1ce
smartset: add first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22805
diff
changeset
|
3039 """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
|
3040 |
228b0aafb1ce
smartset: add first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22805
diff
changeset
|
3041 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
|
3042 raise NotImplementedError() |
228b0aafb1ce
smartset: add first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22805
diff
changeset
|
3043 |
22995
2587631c5f8a
revset: make __len__ part of the offical API
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22944
diff
changeset
|
3044 def __len__(self): |
2587631c5f8a
revset: make __len__ part of the offical API
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22944
diff
changeset
|
3045 """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
|
3046 |
2587631c5f8a
revset: make __len__ part of the offical API
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22944
diff
changeset
|
3047 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
|
3048 raise NotImplementedError() |
2587631c5f8a
revset: make __len__ part of the offical API
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22944
diff
changeset
|
3049 |
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3050 def reverse(self): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3051 """reverse the expected iteration order""" |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3052 raise NotImplementedError() |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3053 |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3054 def sort(self, reverse=True): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3055 """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
|
3056 raise NotImplementedError() |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3057 |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3058 def __and__(self, other): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3059 """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
|
3060 |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3061 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
|
3062 if isinstance(other, fullreposet): |
7d369fae098e
revset: optimize "x & fullreposet" case
Yuya Nishihara <yuya@tcha.org>
parents:
24458
diff
changeset
|
3063 return self |
22864
96b6b3d78697
revset: cache most conditions used in `filter`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22863
diff
changeset
|
3064 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
|
3065 |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3066 def __add__(self, other): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3067 """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
|
3068 |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3069 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
|
3070 return addset(self, other) |
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3071 |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3072 def __sub__(self, other): |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3073 """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
|
3074 |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3075 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
|
3076 c = other.__contains__ |
22864
96b6b3d78697
revset: cache most conditions used in `filter`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22863
diff
changeset
|
3077 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
|
3078 |
96b6b3d78697
revset: cache most conditions used in `filter`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22863
diff
changeset
|
3079 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
|
3080 """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
|
3081 |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3082 `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
|
3083 boolean. |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3084 |
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3085 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
|
3086 # 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
|
3087 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
|
3088 condition = util.cachefunc(condition) |
22862
9e5576f822cc
filteredset: drop explicit order management
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22861
diff
changeset
|
3089 return filteredset(self, condition) |
22692
78c916f24dd9
revset: introduce an abstractsmartset class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22691
diff
changeset
|
3090 |
22825
0e8bb81b58b9
baseset: stop inheriting from built-in list class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22817
diff
changeset
|
3091 class baseset(abstractsmartset): |
20416
e72bcc245ecb
revset: added docstring to baseset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20393
diff
changeset
|
3092 """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
|
3093 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
|
3094 |
1e59f760d850
revset: added comments to all methods needed to duck-type from baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20726
diff
changeset
|
3095 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
|
3096 """ |
20752
6744f4621434
revset: add a default argument for baseset.__init__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20751
diff
changeset
|
3097 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
|
3098 if not isinstance(data, list): |
26060
4ee2af2194d4
baseset: keep the input set around
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26053
diff
changeset
|
3099 if isinstance(data, set): |
4ee2af2194d4
baseset: keep the input set around
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26053
diff
changeset
|
3100 self._set = data |
22825
0e8bb81b58b9
baseset: stop inheriting from built-in list class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22817
diff
changeset
|
3101 data = list(data) |
0e8bb81b58b9
baseset: stop inheriting from built-in list class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22817
diff
changeset
|
3102 self._list = data |
22827
c1107cb21df2
baseset: prepare lazy ordering in __iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22826
diff
changeset
|
3103 self._ascending = None |
20365
bc770ee6a351
revset: implemented set caching for revset evaluation
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20364
diff
changeset
|
3104 |
22826
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
3105 @util.propertycache |
22879
efe5062145c1
baseset: make `_set` a property cache
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22877
diff
changeset
|
3106 def _set(self): |
efe5062145c1
baseset: make `_set` a property cache
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22877
diff
changeset
|
3107 return set(self._list) |
efe5062145c1
baseset: make `_set` a property cache
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22877
diff
changeset
|
3108 |
efe5062145c1
baseset: make `_set` a property cache
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22877
diff
changeset
|
3109 @util.propertycache |
22826
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
3110 def _asclist(self): |
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
3111 asclist = self._list[:] |
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
3112 asclist.sort() |
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
3113 return asclist |
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
3114 |
22827
c1107cb21df2
baseset: prepare lazy ordering in __iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22826
diff
changeset
|
3115 def __iter__(self): |
c1107cb21df2
baseset: prepare lazy ordering in __iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22826
diff
changeset
|
3116 if self._ascending is None: |
c1107cb21df2
baseset: prepare lazy ordering in __iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22826
diff
changeset
|
3117 return iter(self._list) |
c1107cb21df2
baseset: prepare lazy ordering in __iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22826
diff
changeset
|
3118 elif self._ascending: |
c1107cb21df2
baseset: prepare lazy ordering in __iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22826
diff
changeset
|
3119 return iter(self._asclist) |
c1107cb21df2
baseset: prepare lazy ordering in __iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22826
diff
changeset
|
3120 else: |
c1107cb21df2
baseset: prepare lazy ordering in __iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22826
diff
changeset
|
3121 return reversed(self._asclist) |
c1107cb21df2
baseset: prepare lazy ordering in __iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22826
diff
changeset
|
3122 |
22826
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
3123 def fastasc(self): |
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
3124 return iter(self._asclist) |
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
3125 |
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
3126 def fastdesc(self): |
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
3127 return reversed(self._asclist) |
4ffb327e4719
baseset: implement a fastasc and fastdesc
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22825
diff
changeset
|
3128 |
22503
300e07582e9b
revset: add an optimised baseset.__contains__ (issue4371)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22105
diff
changeset
|
3129 @util.propertycache |
300e07582e9b
revset: add an optimised baseset.__contains__ (issue4371)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22105
diff
changeset
|
3130 def __contains__(self): |
22880
5b635b44af14
baseset: access `_set` directly for containment check
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22879
diff
changeset
|
3131 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
|
3132 |
22691
d8a08b68f754
revset: add a `__nonzero__` to baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22690
diff
changeset
|
3133 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
|
3134 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
|
3135 |
0e8bb81b58b9
baseset: stop inheriting from built-in list class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22817
diff
changeset
|
3136 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
|
3137 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
|
3138 |
0e8bb81b58b9
baseset: stop inheriting from built-in list class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22817
diff
changeset
|
3139 def reverse(self): |
22829
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
3140 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
|
3141 self._list.reverse() |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
3142 else: |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
3143 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
|
3144 |
0e8bb81b58b9
baseset: stop inheriting from built-in list class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22817
diff
changeset
|
3145 def __len__(self): |
0e8bb81b58b9
baseset: stop inheriting from built-in list class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22817
diff
changeset
|
3146 return len(self._list) |
22691
d8a08b68f754
revset: add a `__nonzero__` to baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22690
diff
changeset
|
3147 |
20725
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
3148 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
|
3149 """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
|
3150 |
1e59f760d850
revset: added comments to all methods needed to duck-type from baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20726
diff
changeset
|
3151 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
|
3152 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
|
3153 return True |
22828
966860f7a1a8
baseset: fix isascending and isdescending
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22827
diff
changeset
|
3154 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
|
3155 |
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
3156 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
|
3157 """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
|
3158 |
1e59f760d850
revset: added comments to all methods needed to duck-type from baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20726
diff
changeset
|
3159 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
|
3160 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
|
3161 return True |
22828
966860f7a1a8
baseset: fix isascending and isdescending
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22827
diff
changeset
|
3162 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
|
3163 |
22812
fcd12b310148
baseset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22811
diff
changeset
|
3164 def first(self): |
fcd12b310148
baseset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22811
diff
changeset
|
3165 if self: |
22829
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
3166 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
|
3167 return self._list[0] |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
3168 elif self._ascending: |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
3169 return self._asclist[0] |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
3170 else: |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
3171 return self._asclist[-1] |
22812
fcd12b310148
baseset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22811
diff
changeset
|
3172 return None |
fcd12b310148
baseset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22811
diff
changeset
|
3173 |
fcd12b310148
baseset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22811
diff
changeset
|
3174 def last(self): |
fcd12b310148
baseset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22811
diff
changeset
|
3175 if self: |
22829
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
3176 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
|
3177 return self._list[-1] |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
3178 elif self._ascending: |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
3179 return self._asclist[-1] |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
3180 else: |
36e09c25f870
baseset: explicitly track order of the baseset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22828
diff
changeset
|
3181 return self._asclist[0] |
22812
fcd12b310148
baseset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22811
diff
changeset
|
3182 return None |
fcd12b310148
baseset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22811
diff
changeset
|
3183 |
24457
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
3184 def __repr__(self): |
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
3185 d = {None: '', False: '-', True: '+'}[self._ascending] |
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
3186 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
|
3187 |
22726
169aa5e74b52
lazyset: rename the class to filteredset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22725
diff
changeset
|
3188 class filteredset(abstractsmartset): |
20427
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
3189 """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
|
3190 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
|
3191 revset |
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
3192 """ |
22862
9e5576f822cc
filteredset: drop explicit order management
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22861
diff
changeset
|
3193 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
|
3194 """ |
33943add5d65
revset: add some documentation for lazyset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20737
diff
changeset
|
3195 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
|
3196 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
|
3197 """ |
20427
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
3198 self._subset = subset |
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
3199 self._condition = condition |
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
3200 |
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
3201 def __contains__(self, x): |
26212
0d8df1f510c6
revset: uncache filteredset.__contains__
Yuya Nishihara <yuya@tcha.org>
parents:
26143
diff
changeset
|
3202 return x in self._subset and self._condition(x) |
20427
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
3203 |
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
3204 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
|
3205 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
|
3206 |
21fda9dcd4e8
lazyset: split the iteration logic from the condition filtering logic
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22718
diff
changeset
|
3207 def _iterfilter(self, it): |
20427
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
3208 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
|
3209 for x in it: |
20427
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
3210 if cond(x): |
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
3211 yield x |
4a9191ca848e
revset: added lazyset class with basic operations
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20424
diff
changeset
|
3212 |
22720
4388f99c5512
lazyset: inherit the fastasc and fastdesc method from subset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22719
diff
changeset
|
3213 @property |
4388f99c5512
lazyset: inherit the fastasc and fastdesc method from subset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22719
diff
changeset
|
3214 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
|
3215 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
|
3216 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
|
3217 return None |
4388f99c5512
lazyset: inherit the fastasc and fastdesc method from subset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22719
diff
changeset
|
3218 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
|
3219 |
4388f99c5512
lazyset: inherit the fastasc and fastdesc method from subset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22719
diff
changeset
|
3220 @property |
4388f99c5512
lazyset: inherit the fastasc and fastdesc method from subset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22719
diff
changeset
|
3221 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
|
3222 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
|
3223 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
|
3224 return None |
4388f99c5512
lazyset: inherit the fastasc and fastdesc method from subset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22719
diff
changeset
|
3225 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
|
3226 |
20552
0e99a66eb7bc
revset: added __nonzero__ method to lazyset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20540
diff
changeset
|
3227 def __nonzero__(self): |
26307
428a8747f4ee
revset: avoid implicit None testing in revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26306
diff
changeset
|
3228 fast = self.fastasc |
428a8747f4ee
revset: avoid implicit None testing in revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26306
diff
changeset
|
3229 if fast is None: |
428a8747f4ee
revset: avoid implicit None testing in revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26306
diff
changeset
|
3230 fast = self.fastdesc |
428a8747f4ee
revset: avoid implicit None testing in revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26306
diff
changeset
|
3231 if fast is not None: |
26306
d157e1f18e3f
revset: speed up existence checks for ordered filtered sets
Durham Goode <durham@fb.com>
parents:
26305
diff
changeset
|
3232 it = fast() |
26307
428a8747f4ee
revset: avoid implicit None testing in revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26306
diff
changeset
|
3233 else: |
428a8747f4ee
revset: avoid implicit None testing in revset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26306
diff
changeset
|
3234 it = self |
26306
d157e1f18e3f
revset: speed up existence checks for ordered filtered sets
Durham Goode <durham@fb.com>
parents:
26305
diff
changeset
|
3235 |
d157e1f18e3f
revset: speed up existence checks for ordered filtered sets
Durham Goode <durham@fb.com>
parents:
26305
diff
changeset
|
3236 for r in it: |
20552
0e99a66eb7bc
revset: added __nonzero__ method to lazyset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20540
diff
changeset
|
3237 return True |
0e99a66eb7bc
revset: added __nonzero__ method to lazyset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20540
diff
changeset
|
3238 return False |
0e99a66eb7bc
revset: added __nonzero__ method to lazyset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20540
diff
changeset
|
3239 |
20429
f5b560c60bcd
revset: added operations to duck type baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20428
diff
changeset
|
3240 def __len__(self): |
f5b560c60bcd
revset: added operations to duck type baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20428
diff
changeset
|
3241 # 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
|
3242 l = baseset([r for r in self]) |
f5b560c60bcd
revset: added operations to duck type baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20428
diff
changeset
|
3243 return len(l) |
f5b560c60bcd
revset: added operations to duck type baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20428
diff
changeset
|
3244 |
f5b560c60bcd
revset: added operations to duck type baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20428
diff
changeset
|
3245 def sort(self, reverse=False): |
22862
9e5576f822cc
filteredset: drop explicit order management
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22861
diff
changeset
|
3246 self._subset.sort(reverse=reverse) |
20429
f5b560c60bcd
revset: added operations to duck type baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20428
diff
changeset
|
3247 |
f5b560c60bcd
revset: added operations to duck type baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20428
diff
changeset
|
3248 def reverse(self): |
f5b560c60bcd
revset: added operations to duck type baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20428
diff
changeset
|
3249 self._subset.reverse() |
f5b560c60bcd
revset: added operations to duck type baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20428
diff
changeset
|
3250 |
20725
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
3251 def isascending(self): |
22862
9e5576f822cc
filteredset: drop explicit order management
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22861
diff
changeset
|
3252 return self._subset.isascending() |
20725
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
3253 |
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
3254 def isdescending(self): |
22862
9e5576f822cc
filteredset: drop explicit order management
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22861
diff
changeset
|
3255 return self._subset.isdescending() |
20725
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
3256 |
22813
5a96df266b2b
filteredset: implement `first` and `last`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22812
diff
changeset
|
3257 def first(self): |
5a96df266b2b
filteredset: implement `first` and `last`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22812
diff
changeset
|
3258 for x in self: |
5a96df266b2b
filteredset: implement `first` and `last`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22812
diff
changeset
|
3259 return x |
5a96df266b2b
filteredset: implement `first` and `last`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22812
diff
changeset
|
3260 return None |
5a96df266b2b
filteredset: implement `first` and `last`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22812
diff
changeset
|
3261 |
5a96df266b2b
filteredset: implement `first` and `last`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22812
diff
changeset
|
3262 def last(self): |
5a96df266b2b
filteredset: implement `first` and `last`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22812
diff
changeset
|
3263 it = None |
25648
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
3264 if self.isascending(): |
22862
9e5576f822cc
filteredset: drop explicit order management
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22861
diff
changeset
|
3265 it = self.fastdesc |
25648
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
3266 elif self.isdescending(): |
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
3267 it = self.fastasc |
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
3268 if it is not None: |
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
3269 for x in it(): |
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
3270 return x |
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
3271 return None #empty case |
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
3272 else: |
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
3273 x = None |
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
3274 for x in self: |
9b9877d2b229
revset: rework 'filteredset.last'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25647
diff
changeset
|
3275 pass |
22813
5a96df266b2b
filteredset: implement `first` and `last`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22812
diff
changeset
|
3276 return x |
5a96df266b2b
filteredset: implement `first` and `last`
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22812
diff
changeset
|
3277 |
24457
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
3278 def __repr__(self): |
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
3279 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
|
3280 |
25131
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3281 def _iterordered(ascending, iter1, iter2): |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3282 """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
|
3283 |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3284 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
|
3285 """ |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3286 choice = max |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3287 if ascending: |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3288 choice = min |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3289 |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3290 val1 = None |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3291 val2 = None |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3292 try: |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3293 # 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
|
3294 while True: |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3295 if val1 is None: |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3296 val1 = iter1.next() |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3297 if val2 is None: |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3298 val2 = iter2.next() |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3299 next = choice(val1, val2) |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3300 yield next |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3301 if val1 == next: |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3302 val1 = None |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3303 if val2 == next: |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3304 val2 = None |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3305 except StopIteration: |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3306 # 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
|
3307 it = iter2 |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3308 if val1 is not None: |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3309 yield val1 |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3310 it = iter1 |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3311 elif val2 is not None: |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3312 # 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
|
3313 yield val2 |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3314 for val in it: |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3315 yield val |
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3316 |
22793
ff6689b47e48
addset: drop the leading underscore from the class name
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22792
diff
changeset
|
3317 class addset(abstractsmartset): |
20708
17c89e5a5627
revset: made addset a private class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20707
diff
changeset
|
3318 """Represent the addition of two sets |
17c89e5a5627
revset: made addset a private class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20707
diff
changeset
|
3319 |
17c89e5a5627
revset: made addset a private class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20707
diff
changeset
|
3320 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
|
3321 performance on the __contains__ method |
20708
17c89e5a5627
revset: made addset a private class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20707
diff
changeset
|
3322 |
20712
c152e538b85b
revset: added ascending attribute to addset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20711
diff
changeset
|
3323 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
|
3324 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
|
3325 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
|
3326 |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3327 >>> xs = baseset([0, 3, 2]) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3328 >>> ys = baseset([5, 2, 4]) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3329 |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3330 >>> rs = addset(xs, ys) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3331 >>> 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
|
3332 (True, True, False, True, 0, 4) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3333 >>> rs = addset(xs, baseset([])) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3334 >>> 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
|
3335 (True, True, False, 0, 2) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3336 >>> rs = addset(baseset([]), baseset([])) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3337 >>> 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
|
3338 (False, False, None, None) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3339 |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3340 iterate unsorted: |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3341 >>> rs = addset(xs, ys) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3342 >>> [x for x in rs] # without _genlist |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3343 [0, 3, 2, 5, 4] |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3344 >>> assert not rs._genlist |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3345 >>> len(rs) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3346 5 |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3347 >>> [x for x in rs] # with _genlist |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3348 [0, 3, 2, 5, 4] |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3349 >>> assert rs._genlist |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3350 |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3351 iterate ascending: |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3352 >>> rs = addset(xs, ys, ascending=True) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3353 >>> [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
|
3354 ([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
|
3355 >>> 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
|
3356 >>> 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
|
3357 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
|
3358 >>> [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
|
3359 ([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
|
3360 >>> assert rs._asclist |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3361 |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3362 iterate descending: |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3363 >>> rs = addset(xs, ys, ascending=False) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3364 >>> [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
|
3365 ([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
|
3366 >>> 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
|
3367 >>> 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
|
3368 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
|
3369 >>> [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
|
3370 ([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
|
3371 >>> assert rs._asclist |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3372 |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3373 iterate ascending without fastasc: |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3374 >>> rs = addset(xs, generatorset(ys), ascending=True) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3375 >>> 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
|
3376 >>> [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
|
3377 [0, 2, 3, 4, 5] |
25024
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3378 |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3379 iterate descending without fastdesc: |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3380 >>> rs = addset(generatorset(xs), ys, ascending=False) |
263bbed1833c
revset: test current behavior of addset class
Yuya Nishihara <yuya@tcha.org>
parents:
25023
diff
changeset
|
3381 >>> 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
|
3382 >>> [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
|
3383 [5, 4, 3, 2, 0] |
20694
621c94378d0d
revset: added addset class with its basic methods
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20693
diff
changeset
|
3384 """ |
20712
c152e538b85b
revset: added ascending attribute to addset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20711
diff
changeset
|
3385 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
|
3386 self._r1 = revs1 |
621c94378d0d
revset: added addset class with its basic methods
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20693
diff
changeset
|
3387 self._r2 = revs2 |
621c94378d0d
revset: added addset class with its basic methods
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20693
diff
changeset
|
3388 self._iter = None |
20712
c152e538b85b
revset: added ascending attribute to addset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20711
diff
changeset
|
3389 self._ascending = ascending |
20720
5f8400efca0b
revset: added cached generated list to addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20719
diff
changeset
|
3390 self._genlist = None |
22859
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
3391 self._asclist = None |
20720
5f8400efca0b
revset: added cached generated list to addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20719
diff
changeset
|
3392 |
20845
bc95143446e8
_addset: add a __len__ method
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20833
diff
changeset
|
3393 def __len__(self): |
bc95143446e8
_addset: add a __len__ method
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20833
diff
changeset
|
3394 return len(self._list) |
bc95143446e8
_addset: add a __len__ method
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20833
diff
changeset
|
3395 |
22743
eccf9907b844
addset: add a __nonzero__ method
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22742
diff
changeset
|
3396 def __nonzero__(self): |
23100
ac494b087feb
revset: fix O(2^n) perf regression in addset
Durham Goode <durham@fb.com>
parents:
23078
diff
changeset
|
3397 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
|
3398 |
20720
5f8400efca0b
revset: added cached generated list to addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20719
diff
changeset
|
3399 @util.propertycache |
5f8400efca0b
revset: added cached generated list to addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20719
diff
changeset
|
3400 def _list(self): |
5f8400efca0b
revset: added cached generated list to addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20719
diff
changeset
|
3401 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
|
3402 self._genlist = baseset(iter(self)) |
20720
5f8400efca0b
revset: added cached generated list to addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20719
diff
changeset
|
3403 return self._genlist |
20694
621c94378d0d
revset: added addset class with its basic methods
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20693
diff
changeset
|
3404 |
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
|
3405 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
|
3406 """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
|
3407 |
6894223ebc38
revset: changed _iterator() method on addset to work with a given order
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20721
diff
changeset
|
3408 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
|
3409 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
|
3410 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
|
3411 |
6894223ebc38
revset: changed _iterator() method on addset to work with a given order
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20721
diff
changeset
|
3412 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
|
3413 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
|
3414 """ |
22799
bafa371d7af3
addset: drop caching through generatorset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22798
diff
changeset
|
3415 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
|
3416 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
|
3417 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
|
3418 def arbitraryordergen(): |
22799
bafa371d7af3
addset: drop caching through generatorset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22798
diff
changeset
|
3419 for r in self._r1: |
bafa371d7af3
addset: drop caching through generatorset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22798
diff
changeset
|
3420 yield r |
22881
057ebf7714e1
addset: drop `.set()` usage during iteration
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22880
diff
changeset
|
3421 inr1 = self._r1.__contains__ |
22799
bafa371d7af3
addset: drop caching through generatorset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22798
diff
changeset
|
3422 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
|
3423 if not inr1(r): |
20694
621c94378d0d
revset: added addset class with its basic methods
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20693
diff
changeset
|
3424 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
|
3425 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
|
3426 # 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
|
3427 self._trysetasclist() |
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
3428 if self._ascending: |
25130
a94ef7f517e0
revset: use fastasc/fastdesc switch consistently in addset.__iter__
Yuya Nishihara <yuya@tcha.org>
parents:
25129
diff
changeset
|
3429 attr = 'fastasc' |
22859
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
3430 else: |
25130
a94ef7f517e0
revset: use fastasc/fastdesc switch consistently in addset.__iter__
Yuya Nishihara <yuya@tcha.org>
parents:
25129
diff
changeset
|
3431 attr = 'fastdesc' |
a94ef7f517e0
revset: use fastasc/fastdesc switch consistently in addset.__iter__
Yuya Nishihara <yuya@tcha.org>
parents:
25129
diff
changeset
|
3432 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
|
3433 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
|
3434 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
|
3435 # 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
|
3436 # 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
|
3437 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
|
3438 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
|
3439 # 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
|
3440 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
|
3441 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
|
3442 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
|
3443 # 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
|
3444 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
|
3445 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
|
3446 # 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
|
3447 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
|
3448 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
|
3449 iter2 = iter2() |
25131
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3450 return _iterordered(self._ascending, iter1, iter2) |
22859
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
3451 |
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
3452 def _trysetasclist(self): |
23139
e53f6b72a0e4
spelling: fixes from proofreading of spell checker issues
Mads Kiilerich <madski@unity3d.com>
parents:
23127
diff
changeset
|
3453 """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
|
3454 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
|
3455 self._asclist = sorted(self._genlist) |
20694
621c94378d0d
revset: added addset class with its basic methods
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20693
diff
changeset
|
3456 |
22742
6bbc26adcc6a
addset: offer a fastasc and fastdesc methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22741
diff
changeset
|
3457 @property |
6bbc26adcc6a
addset: offer a fastasc and fastdesc methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22741
diff
changeset
|
3458 def fastasc(self): |
22859
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
3459 self._trysetasclist() |
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
3460 if self._asclist is not None: |
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
3461 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
|
3462 iter1 = self._r1.fastasc |
6bbc26adcc6a
addset: offer a fastasc and fastdesc methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22741
diff
changeset
|
3463 iter2 = self._r2.fastasc |
6bbc26adcc6a
addset: offer a fastasc and fastdesc methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22741
diff
changeset
|
3464 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
|
3465 return None |
25131
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3466 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
|
3467 |
6bbc26adcc6a
addset: offer a fastasc and fastdesc methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22741
diff
changeset
|
3468 @property |
6bbc26adcc6a
addset: offer a fastasc and fastdesc methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22741
diff
changeset
|
3469 def fastdesc(self): |
22859
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
3470 self._trysetasclist() |
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
3471 if self._asclist is not None: |
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
3472 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
|
3473 iter1 = self._r1.fastdesc |
6bbc26adcc6a
addset: offer a fastasc and fastdesc methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22741
diff
changeset
|
3474 iter2 = self._r2.fastdesc |
6bbc26adcc6a
addset: offer a fastasc and fastdesc methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22741
diff
changeset
|
3475 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
|
3476 return None |
25131
adfe4d9680bf
revset: extract addset._iterordered to free function
Yuya Nishihara <yuya@tcha.org>
parents:
25130
diff
changeset
|
3477 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
|
3478 |
20694
621c94378d0d
revset: added addset class with its basic methods
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20693
diff
changeset
|
3479 def __contains__(self, x): |
621c94378d0d
revset: added addset class with its basic methods
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20693
diff
changeset
|
3480 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
|
3481 |
20724
e9a64b3f2925
revset: added sort method in addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20723
diff
changeset
|
3482 def sort(self, reverse=False): |
e9a64b3f2925
revset: added sort method in addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20723
diff
changeset
|
3483 """Sort the added set |
e9a64b3f2925
revset: added sort method in addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20723
diff
changeset
|
3484 |
e9a64b3f2925
revset: added sort method in addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20723
diff
changeset
|
3485 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
|
3486 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
|
3487 """ |
22859
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
3488 self._ascending = not reverse |
20724
e9a64b3f2925
revset: added sort method in addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20723
diff
changeset
|
3489 |
20733
adf4ec7e6f60
revset: added isascending and isdescending methods to _addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20732
diff
changeset
|
3490 def isascending(self): |
adf4ec7e6f60
revset: added isascending and isdescending methods to _addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20732
diff
changeset
|
3491 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
|
3492 |
adf4ec7e6f60
revset: added isascending and isdescending methods to _addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20732
diff
changeset
|
3493 def isdescending(self): |
adf4ec7e6f60
revset: added isascending and isdescending methods to _addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20732
diff
changeset
|
3494 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
|
3495 |
20723
fb9852c46a42
revset: added reverse method to addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20722
diff
changeset
|
3496 def reverse(self): |
22859
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
3497 if self._ascending is None: |
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
3498 self._list.reverse() |
513c0ba61db8
addset: do lazy sorting
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22857
diff
changeset
|
3499 else: |
20723
fb9852c46a42
revset: added reverse method to addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20722
diff
changeset
|
3500 self._ascending = not self._ascending |
fb9852c46a42
revset: added reverse method to addset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20722
diff
changeset
|
3501 |
22810
7f97cb12782f
addset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22809
diff
changeset
|
3502 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
|
3503 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
|
3504 return x |
22810
7f97cb12782f
addset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22809
diff
changeset
|
3505 return None |
7f97cb12782f
addset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22809
diff
changeset
|
3506 |
7f97cb12782f
addset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22809
diff
changeset
|
3507 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
|
3508 self.reverse() |
7361d8244efb
addset: fix `first` and `last` on sorted addset (issue4426)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23115
diff
changeset
|
3509 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
|
3510 self.reverse() |
7361d8244efb
addset: fix `first` and `last` on sorted addset (issue4426)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23115
diff
changeset
|
3511 return val |
22810
7f97cb12782f
addset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22809
diff
changeset
|
3512 |
24457
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
3513 def __repr__(self): |
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
3514 d = {None: '', False: '-', True: '+'}[self._ascending] |
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
3515 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
|
3516 |
22795
c21342159fad
generatorset: drop the leading underscore in the class name
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22794
diff
changeset
|
3517 class generatorset(abstractsmartset): |
20705
9cc2249a9461
revset: made generatorset a private class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20703
diff
changeset
|
3518 """Wrap a generator for lazy iteration |
9cc2249a9461
revset: made generatorset a private class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20703
diff
changeset
|
3519 |
9cc2249a9461
revset: made generatorset a private class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20703
diff
changeset
|
3520 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
|
3521 be iterated more than once. |
fa16c710a3d8
revset: added cached generated list on generatorset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20538
diff
changeset
|
3522 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
|
3523 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
|
3524 """ |
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
|
3525 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
|
3526 """ |
1b4f2399f3c4
revset: add documentation and comment for _generatorset
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
20738
diff
changeset
|
3527 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
|
3528 """ |
20536
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
3529 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
|
3530 self._asclist = None |
20536
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
3531 self._cache = {} |
22796
43f664bf2e1e
generatorset: stop using a base as the _genlist
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22795
diff
changeset
|
3532 self._genlist = [] |
20703
e07b1fd30805
revset: added sort methods to generatorsets
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20695
diff
changeset
|
3533 self._finished = False |
22800
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
3534 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
|
3535 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
|
3536 if iterasc: |
22797
61ecabeeadb3
generatorset: move iteration code into _iterator
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22796
diff
changeset
|
3537 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
|
3538 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
|
3539 else: |
22797
61ecabeeadb3
generatorset: move iteration code into _iterator
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22796
diff
changeset
|
3540 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
|
3541 self.__contains__ = self._desccontains |
20540
fa16c710a3d8
revset: added cached generated list on generatorset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20538
diff
changeset
|
3542 |
22739
4ed47a1b2d24
generatorset: implement __nonzero__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22738
diff
changeset
|
3543 def __nonzero__(self): |
24936
2aa94b6fe51c
revset: make generatorset.__nonzero__ lazy
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
24932
diff
changeset
|
3544 # 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
|
3545 # 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
|
3546 # iterator. |
2aa94b6fe51c
revset: make generatorset.__nonzero__ lazy
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
24932
diff
changeset
|
3547 if self._genlist: |
2aa94b6fe51c
revset: make generatorset.__nonzero__ lazy
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
24932
diff
changeset
|
3548 return True |
2aa94b6fe51c
revset: make generatorset.__nonzero__ lazy
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
24932
diff
changeset
|
3549 for r in self._consumegen(): |
22739
4ed47a1b2d24
generatorset: implement __nonzero__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22738
diff
changeset
|
3550 return True |
4ed47a1b2d24
generatorset: implement __nonzero__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22738
diff
changeset
|
3551 return False |
4ed47a1b2d24
generatorset: implement __nonzero__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22738
diff
changeset
|
3552 |
20536
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
3553 def __contains__(self, x): |
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
3554 if x in self._cache: |
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
3555 return self._cache[x] |
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
3556 |
20828
3210b7930899
revset: improve performance of _generatorset.__contains__ (issue 4201)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
20780
diff
changeset
|
3557 # 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
|
3558 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
|
3559 if l == x: |
f2bb7ba59456
revset: changed generatorset code to remove unnecesary function call
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20613
diff
changeset
|
3560 return True |
20536
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
3561 |
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
3562 self._cache[x] = False |
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
3563 return False |
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
3564 |
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
|
3565 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
|
3566 """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
|
3567 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
|
3568 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
|
3569 |
d34969a4b1a8
generatorset: move membership testing on ordered gen to the main class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22756
diff
changeset
|
3570 # 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
|
3571 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
|
3572 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
|
3573 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
|
3574 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
|
3575 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
|
3576 |
d34969a4b1a8
generatorset: move membership testing on ordered gen to the main class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22756
diff
changeset
|
3577 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
|
3578 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
|
3579 |
d34969a4b1a8
generatorset: move membership testing on ordered gen to the main class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22756
diff
changeset
|
3580 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
|
3581 """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
|
3582 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
|
3583 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
|
3584 |
d34969a4b1a8
generatorset: move membership testing on ordered gen to the main class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22756
diff
changeset
|
3585 # 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
|
3586 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
|
3587 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
|
3588 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
|
3589 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
|
3590 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
|
3591 |
d34969a4b1a8
generatorset: move membership testing on ordered gen to the main class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22756
diff
changeset
|
3592 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
|
3593 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
|
3594 |
20536
532b114a6e02
revset: added generatorset class with cached __contains__ method
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20534
diff
changeset
|
3595 def __iter__(self): |
22800
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
3596 if self._ascending: |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
3597 it = self.fastasc |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
3598 else: |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
3599 it = self.fastdesc |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
3600 if it is not None: |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
3601 return it() |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
3602 # we need to consume the iterator |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
3603 for x in self._consumegen(): |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
3604 pass |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
3605 # recall the same code |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
3606 return iter(self) |
22797
61ecabeeadb3
generatorset: move iteration code into _iterator
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22796
diff
changeset
|
3607 |
61ecabeeadb3
generatorset: move iteration code into _iterator
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22796
diff
changeset
|
3608 def _iterator(self): |
20833
47d43e2323c5
revset: fix generatorset race condition
Durham Goode <durham@fb.com>
parents:
20829
diff
changeset
|
3609 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
|
3610 return iter(self._genlist) |
20833
47d43e2323c5
revset: fix generatorset race condition
Durham Goode <durham@fb.com>
parents:
20829
diff
changeset
|
3611 |
22494
14f6cebfcb8a
revset: document the choice made in __generatorset.__iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22487
diff
changeset
|
3612 # 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
|
3613 # 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
|
3614 # 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
|
3615 # |
14f6cebfcb8a
revset: document the choice made in __generatorset.__iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22487
diff
changeset
|
3616 # 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
|
3617 # iteration. |
20833
47d43e2323c5
revset: fix generatorset race condition
Durham Goode <durham@fb.com>
parents:
20829
diff
changeset
|
3618 genlist = self._genlist |
22669
00c8abe64cf3
revset: prefetch an attribute in _generatorset.__iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22539
diff
changeset
|
3619 nextrev = self._consumegen().next |
00c8abe64cf3
revset: prefetch an attribute in _generatorset.__iter__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22539
diff
changeset
|
3620 _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
|
3621 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
|
3622 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
|
3623 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
|
3624 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
|
3625 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
|
3626 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
|
3627 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
|
3628 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
|
3629 return gen() |
20828
3210b7930899
revset: improve performance of _generatorset.__contains__ (issue 4201)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
20780
diff
changeset
|
3630 |
3210b7930899
revset: improve performance of _generatorset.__contains__ (issue 4201)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
20780
diff
changeset
|
3631 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
|
3632 cache = self._cache |
b6dc3b79bb25
revset: avoid in loop lookup in _generatorset._consumegen
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22527
diff
changeset
|
3633 genlist = self._genlist.append |
20634
f2bb7ba59456
revset: changed generatorset code to remove unnecesary function call
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20613
diff
changeset
|
3634 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
|
3635 cache[item] = True |
b6dc3b79bb25
revset: avoid in loop lookup in _generatorset._consumegen
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22527
diff
changeset
|
3636 genlist(item) |
20634
f2bb7ba59456
revset: changed generatorset code to remove unnecesary function call
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20613
diff
changeset
|
3637 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
|
3638 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
|
3639 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
|
3640 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
|
3641 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
|
3642 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
|
3643 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
|
3644 self.fastdesc = asc.__reversed__ |
20703
e07b1fd30805
revset: added sort methods to generatorsets
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20695
diff
changeset
|
3645 |
22996
a43d929d1fa1
generatorset: implement __len__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22995
diff
changeset
|
3646 def __len__(self): |
a43d929d1fa1
generatorset: implement __len__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22995
diff
changeset
|
3647 for x in self._consumegen(): |
a43d929d1fa1
generatorset: implement __len__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22995
diff
changeset
|
3648 pass |
a43d929d1fa1
generatorset: implement __len__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22995
diff
changeset
|
3649 return len(self._genlist) |
a43d929d1fa1
generatorset: implement __len__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22995
diff
changeset
|
3650 |
20703
e07b1fd30805
revset: added sort methods to generatorsets
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20695
diff
changeset
|
3651 def sort(self, reverse=False): |
22800
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
3652 self._ascending = not reverse |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
3653 |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
3654 def reverse(self): |
29a8c20e14a8
generatorset: explicitly track iteration order
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22799
diff
changeset
|
3655 self._ascending = not self._ascending |
20703
e07b1fd30805
revset: added sort methods to generatorsets
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20695
diff
changeset
|
3656 |
22801
6af9e9b6af39
generatorset: implement isascending and isdescending
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22800
diff
changeset
|
3657 def isascending(self): |
6af9e9b6af39
generatorset: implement isascending and isdescending
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22800
diff
changeset
|
3658 return self._ascending |
6af9e9b6af39
generatorset: implement isascending and isdescending
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22800
diff
changeset
|
3659 |
6af9e9b6af39
generatorset: implement isascending and isdescending
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22800
diff
changeset
|
3660 def isdescending(self): |
6af9e9b6af39
generatorset: implement isascending and isdescending
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22800
diff
changeset
|
3661 return not self._ascending |
6af9e9b6af39
generatorset: implement isascending and isdescending
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22800
diff
changeset
|
3662 |
22811
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
3663 def first(self): |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
3664 if self._ascending: |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
3665 it = self.fastasc |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
3666 else: |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
3667 it = self.fastdesc |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
3668 if it is None: |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
3669 # 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
|
3670 for x in self._consumegen(): |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
3671 pass |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
3672 return self.first() |
25146
f542a2c89b60
generatorset: use 'next()' to simplify the code
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25145
diff
changeset
|
3673 return next(it(), None) |
22811
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
3674 |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
3675 def last(self): |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
3676 if self._ascending: |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
3677 it = self.fastdesc |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
3678 else: |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
3679 it = self.fastasc |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
3680 if it is None: |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
3681 # 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
|
3682 for x in self._consumegen(): |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
3683 pass |
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
3684 return self.first() |
25146
f542a2c89b60
generatorset: use 'next()' to simplify the code
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25145
diff
changeset
|
3685 return next(it(), None) |
22811
c1fd827e1ae0
generatorset: implement first and last methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22810
diff
changeset
|
3686 |
24457
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
3687 def __repr__(self): |
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
3688 d = {False: '-', True: '+'}[self._ascending] |
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
3689 return '<%s%s>' % (type(self).__name__, d) |
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
3690 |
24116
8b90a60181d1
revset: drop factory that promotes spanset to fullreposet
Yuya Nishihara <yuya@tcha.org>
parents:
24115
diff
changeset
|
3691 class spanset(abstractsmartset): |
20482
a979078bd788
revset: added spanset class to represent revision ranges
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20481
diff
changeset
|
3692 """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
|
3693 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
|
3694 |
b141080e70c5
revset: added documentation and comment for spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20734
diff
changeset
|
3695 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
|
3696 notable points: |
b141080e70c5
revset: added documentation and comment for spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20734
diff
changeset
|
3697 - 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
|
3698 - 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
|
3699 |
20482
a979078bd788
revset: added spanset class to represent revision ranges
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20481
diff
changeset
|
3700 """ |
20525
aa73a6327df4
revset: changed spanset to take a repo argument
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20521
diff
changeset
|
3701 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
|
3702 """ |
b141080e70c5
revset: added documentation and comment for spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20734
diff
changeset
|
3703 start: first revision included the set |
b141080e70c5
revset: added documentation and comment for spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20734
diff
changeset
|
3704 (default to 0) |
b141080e70c5
revset: added documentation and comment for spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20734
diff
changeset
|
3705 end: first revision excluded (last+1) |
b141080e70c5
revset: added documentation and comment for spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20734
diff
changeset
|
3706 (default to len(repo) |
b141080e70c5
revset: added documentation and comment for spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20734
diff
changeset
|
3707 |
b141080e70c5
revset: added documentation and comment for spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20734
diff
changeset
|
3708 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
|
3709 """ |
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
|
3710 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
|
3711 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
|
3712 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
|
3713 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
|
3714 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
|
3715 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
|
3716 self._end = end |
20525
aa73a6327df4
revset: changed spanset to take a repo argument
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20521
diff
changeset
|
3717 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
|
3718 |
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
|
3719 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
|
3720 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
|
3721 |
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
3722 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
|
3723 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
|
3724 |
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
3725 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
|
3726 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
|
3727 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
|
3728 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
|
3729 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
|
3730 |
20482
a979078bd788
revset: added spanset class to represent revision ranges
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20481
diff
changeset
|
3731 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
|
3732 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
|
3733 return self.fastasc() |
20482
a979078bd788
revset: added spanset class to represent revision ranges
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20481
diff
changeset
|
3734 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
|
3735 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
|
3736 |
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
3737 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
|
3738 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
|
3739 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
|
3740 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
|
3741 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
|
3742 |
b89f7e3a414d
spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22716
diff
changeset
|
3743 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
|
3744 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
|
3745 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
|
3746 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
|
3747 return iter(iterrange) |
20482
a979078bd788
revset: added spanset class to represent revision ranges
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20481
diff
changeset
|
3748 |
21201
c8b9c6147108
revset: fix revision filtering in spanset.contains (regression)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21199
diff
changeset
|
3749 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
|
3750 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
|
3751 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
|
3752 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
|
3753 |
20716
fa1ac5faa7c4
revset: added __nonzero__ method to spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20714
diff
changeset
|
3754 def __nonzero__(self): |
fa1ac5faa7c4
revset: added __nonzero__ method to spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20714
diff
changeset
|
3755 for r in self: |
fa1ac5faa7c4
revset: added __nonzero__ method to spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20714
diff
changeset
|
3756 return True |
fa1ac5faa7c4
revset: added __nonzero__ method to spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20714
diff
changeset
|
3757 return False |
fa1ac5faa7c4
revset: added __nonzero__ method to spanset class
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20714
diff
changeset
|
3758 |
20484
0f1ef9e9e904
revset: added operations to spanset to duck type baseset
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20483
diff
changeset
|
3759 def __len__(self): |
20521
1850a7f5fb66
revset: changed spanset implementation to take hidden revisions into account
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20512
diff
changeset
|
3760 if not self._hiddenrevs: |
1850a7f5fb66
revset: changed spanset implementation to take hidden revisions into account
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20512
diff
changeset
|
3761 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
|
3762 else: |
1850a7f5fb66
revset: changed spanset implementation to take hidden revisions into account
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20512
diff
changeset
|
3763 count = 0 |
21205
e2031c8ca4f8
revset: also inline spanset._contained in __len__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21204
diff
changeset
|
3764 start = self._start |
e2031c8ca4f8
revset: also inline spanset._contained in __len__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
21204
diff
changeset
|
3765 end = self._end |
20521
1850a7f5fb66
revset: changed spanset implementation to take hidden revisions into account
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20512
diff
changeset
|
3766 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
|
3767 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
|
3768 count += 1 |
1850a7f5fb66
revset: changed spanset implementation to take hidden revisions into account
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20512
diff
changeset
|
3769 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
|
3770 |
20725
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
3771 def isascending(self): |
23826
c90d195320c5
revset: fix spanset.isascending() to honor sort() or reverse() request
Yuya Nishihara <yuya@tcha.org>
parents:
23724
diff
changeset
|
3772 return self._ascending |
20725
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
3773 |
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
3774 def isdescending(self): |
23826
c90d195320c5
revset: fix spanset.isascending() to honor sort() or reverse() request
Yuya Nishihara <yuya@tcha.org>
parents:
23724
diff
changeset
|
3775 return not self._ascending |
20725
cf628b50afbb
revset: added isascending and isdescending methods to smartset classes
Lucas Moscovicz <lmoscovicz@fb.com>
parents:
20724
diff
changeset
|
3776 |
22809
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
3777 def first(self): |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
3778 if self._ascending: |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
3779 it = self.fastasc |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
3780 else: |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
3781 it = self.fastdesc |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
3782 for x in it(): |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
3783 return x |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
3784 return None |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
3785 |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
3786 def last(self): |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
3787 if self._ascending: |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
3788 it = self.fastdesc |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
3789 else: |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
3790 it = self.fastasc |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
3791 for x in it(): |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
3792 return x |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
3793 return None |
88dad916c008
spanset: implement `first` and `last` methods
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22808
diff
changeset
|
3794 |
24457
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
3795 def __repr__(self): |
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
3796 d = {False: '-', True: '+'}[self._ascending] |
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
3797 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
|
3798 self._start, self._end - 1) |
c5022f3579b9
revset: add __repr__ to all smartset classes
Yuya Nishihara <yuya@tcha.org>
parents:
24446
diff
changeset
|
3799 |
24116
8b90a60181d1
revset: drop factory that promotes spanset to fullreposet
Yuya Nishihara <yuya@tcha.org>
parents:
24115
diff
changeset
|
3800 class fullreposet(spanset): |
22508
2434c68d82a8
revert: add a fullreposet class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22504
diff
changeset
|
3801 """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
|
3802 |
24204
d2de20e1451f
revset: extend fullreposet to make "null" revision magically appears in set
Yuya Nishihara <yuya@tcha.org>
parents:
24203
diff
changeset
|
3803 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
|
3804 revisions such as "null". |
22508
2434c68d82a8
revert: add a fullreposet class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22504
diff
changeset
|
3805 """ |
2434c68d82a8
revert: add a fullreposet class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22504
diff
changeset
|
3806 |
2434c68d82a8
revert: add a fullreposet class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22504
diff
changeset
|
3807 def __init__(self, repo): |
2434c68d82a8
revert: add a fullreposet class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22504
diff
changeset
|
3808 super(fullreposet, self).__init__(repo) |
2434c68d82a8
revert: add a fullreposet class
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22504
diff
changeset
|
3809 |
22510
911f5a6579d1
revset: fast implementation for fullreposet.__and__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22509
diff
changeset
|
3810 def __and__(self, other): |
23139
e53f6b72a0e4
spelling: fixes from proofreading of spell checker issues
Mads Kiilerich <madski@unity3d.com>
parents:
23127
diff
changeset
|
3811 """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
|
3812 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
|
3813 |
911f5a6579d1
revset: fast implementation for fullreposet.__and__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22509
diff
changeset
|
3814 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
|
3815 """ |
911f5a6579d1
revset: fast implementation for fullreposet.__and__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22509
diff
changeset
|
3816 # 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
|
3817 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
|
3818 # filter out hidden revision |
911f5a6579d1
revset: fast implementation for fullreposet.__and__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22509
diff
changeset
|
3819 # (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
|
3820 # |
911f5a6579d1
revset: fast implementation for fullreposet.__and__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22509
diff
changeset
|
3821 # `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
|
3822 # object. |
911f5a6579d1
revset: fast implementation for fullreposet.__and__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22509
diff
changeset
|
3823 other = baseset(other - self._hiddenrevs) |
911f5a6579d1
revset: fast implementation for fullreposet.__and__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22509
diff
changeset
|
3824 |
25547
99a1f73af85b
revset: point out wrong behavior in fullreposet
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25344
diff
changeset
|
3825 # 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
|
3826 # |
99a1f73af85b
revset: point out wrong behavior in fullreposet
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25344
diff
changeset
|
3827 # 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
|
3828 # '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
|
3829 # 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
|
3830 # '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
|
3831 # |
99a1f73af85b
revset: point out wrong behavior in fullreposet
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25344
diff
changeset
|
3832 # 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
|
3833 # (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
|
3834 # |
99a1f73af85b
revset: point out wrong behavior in fullreposet
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25344
diff
changeset
|
3835 # 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
|
3836 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
|
3837 return other |
911f5a6579d1
revset: fast implementation for fullreposet.__and__
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22509
diff
changeset
|
3838 |
24458
7d87f672d069
debugrevspec: show nesting structure of smartsets if verbose
Yuya Nishihara <yuya@tcha.org>
parents:
24457
diff
changeset
|
3839 def prettyformatset(revs): |
7d87f672d069
debugrevspec: show nesting structure of smartsets if verbose
Yuya Nishihara <yuya@tcha.org>
parents:
24457
diff
changeset
|
3840 lines = [] |
7d87f672d069
debugrevspec: show nesting structure of smartsets if verbose
Yuya Nishihara <yuya@tcha.org>
parents:
24457
diff
changeset
|
3841 rs = repr(revs) |
7d87f672d069
debugrevspec: show nesting structure of smartsets if verbose
Yuya Nishihara <yuya@tcha.org>
parents:
24457
diff
changeset
|
3842 p = 0 |
7d87f672d069
debugrevspec: show nesting structure of smartsets if verbose
Yuya Nishihara <yuya@tcha.org>
parents:
24457
diff
changeset
|
3843 while p < len(rs): |
7d87f672d069
debugrevspec: show nesting structure of smartsets if verbose
Yuya Nishihara <yuya@tcha.org>
parents:
24457
diff
changeset
|
3844 q = rs.find('<', p + 1) |
7d87f672d069
debugrevspec: show nesting structure of smartsets if verbose
Yuya Nishihara <yuya@tcha.org>
parents:
24457
diff
changeset
|
3845 if q < 0: |
7d87f672d069
debugrevspec: show nesting structure of smartsets if verbose
Yuya Nishihara <yuya@tcha.org>
parents:
24457
diff
changeset
|
3846 q = len(rs) |
7d87f672d069
debugrevspec: show nesting structure of smartsets if verbose
Yuya Nishihara <yuya@tcha.org>
parents:
24457
diff
changeset
|
3847 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
|
3848 assert l >= 0 |
7d87f672d069
debugrevspec: show nesting structure of smartsets if verbose
Yuya Nishihara <yuya@tcha.org>
parents:
24457
diff
changeset
|
3849 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
|
3850 p = q |
7d87f672d069
debugrevspec: show nesting structure of smartsets if verbose
Yuya Nishihara <yuya@tcha.org>
parents:
24457
diff
changeset
|
3851 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
|
3852 |
12823
80deae3bc5ea
hggettext: handle i18nfunctions declaration for docstrings translations
Patrick Mezard <pmezard@gmail.com>
parents:
12821
diff
changeset
|
3853 # 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
|
3854 i18nfunctions = symbols.values() |