##// END OF EJS Templates
revset: use `subset &` in `filelog`...
Pierre-Yves David -
r22534:6261b9c5 default
parent child Browse files
Show More
@@ -1,2911 +1,2911 b''
1 # revset.py - revision set queries for mercurial
1 # revset.py - revision set queries for mercurial
2 #
2 #
3 # Copyright 2010 Matt Mackall <mpm@selenic.com>
3 # Copyright 2010 Matt Mackall <mpm@selenic.com>
4 #
4 #
5 # This software may be used and distributed according to the terms of the
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.
6 # GNU General Public License version 2 or any later version.
7
7
8 import re
8 import re
9 import parser, util, error, discovery, hbisect, phases
9 import parser, util, error, discovery, hbisect, phases
10 import node
10 import node
11 import heapq
11 import heapq
12 import match as matchmod
12 import match as matchmod
13 import ancestor as ancestormod
13 import ancestor as ancestormod
14 from i18n import _
14 from i18n import _
15 import encoding
15 import encoding
16 import obsolete as obsmod
16 import obsolete as obsmod
17 import pathutil
17 import pathutil
18 import repoview
18 import repoview
19
19
20 def _revancestors(repo, revs, followfirst):
20 def _revancestors(repo, revs, followfirst):
21 """Like revlog.ancestors(), but supports followfirst."""
21 """Like revlog.ancestors(), but supports followfirst."""
22 cut = followfirst and 1 or None
22 cut = followfirst and 1 or None
23 cl = repo.changelog
23 cl = repo.changelog
24
24
25 def iterate():
25 def iterate():
26 revqueue, revsnode = None, None
26 revqueue, revsnode = None, None
27 h = []
27 h = []
28
28
29 revs.descending()
29 revs.descending()
30 revqueue = util.deque(revs)
30 revqueue = util.deque(revs)
31 if revqueue:
31 if revqueue:
32 revsnode = revqueue.popleft()
32 revsnode = revqueue.popleft()
33 heapq.heappush(h, -revsnode)
33 heapq.heappush(h, -revsnode)
34
34
35 seen = set([node.nullrev])
35 seen = set([node.nullrev])
36 while h:
36 while h:
37 current = -heapq.heappop(h)
37 current = -heapq.heappop(h)
38 if current not in seen:
38 if current not in seen:
39 if revsnode and current == revsnode:
39 if revsnode and current == revsnode:
40 if revqueue:
40 if revqueue:
41 revsnode = revqueue.popleft()
41 revsnode = revqueue.popleft()
42 heapq.heappush(h, -revsnode)
42 heapq.heappush(h, -revsnode)
43 seen.add(current)
43 seen.add(current)
44 yield current
44 yield current
45 for parent in cl.parentrevs(current)[:cut]:
45 for parent in cl.parentrevs(current)[:cut]:
46 if parent != node.nullrev:
46 if parent != node.nullrev:
47 heapq.heappush(h, -parent)
47 heapq.heappush(h, -parent)
48
48
49 return _descgeneratorset(iterate())
49 return _descgeneratorset(iterate())
50
50
51 def _revdescendants(repo, revs, followfirst):
51 def _revdescendants(repo, revs, followfirst):
52 """Like revlog.descendants() but supports followfirst."""
52 """Like revlog.descendants() but supports followfirst."""
53 cut = followfirst and 1 or None
53 cut = followfirst and 1 or None
54
54
55 def iterate():
55 def iterate():
56 cl = repo.changelog
56 cl = repo.changelog
57 first = min(revs)
57 first = min(revs)
58 nullrev = node.nullrev
58 nullrev = node.nullrev
59 if first == nullrev:
59 if first == nullrev:
60 # Are there nodes with a null first parent and a non-null
60 # Are there nodes with a null first parent and a non-null
61 # second one? Maybe. Do we care? Probably not.
61 # second one? Maybe. Do we care? Probably not.
62 for i in cl:
62 for i in cl:
63 yield i
63 yield i
64 else:
64 else:
65 seen = set(revs)
65 seen = set(revs)
66 for i in cl.revs(first + 1):
66 for i in cl.revs(first + 1):
67 for x in cl.parentrevs(i)[:cut]:
67 for x in cl.parentrevs(i)[:cut]:
68 if x != nullrev and x in seen:
68 if x != nullrev and x in seen:
69 seen.add(i)
69 seen.add(i)
70 yield i
70 yield i
71 break
71 break
72
72
73 return _ascgeneratorset(iterate())
73 return _ascgeneratorset(iterate())
74
74
75 def _revsbetween(repo, roots, heads):
75 def _revsbetween(repo, roots, heads):
76 """Return all paths between roots and heads, inclusive of both endpoint
76 """Return all paths between roots and heads, inclusive of both endpoint
77 sets."""
77 sets."""
78 if not roots:
78 if not roots:
79 return baseset([])
79 return baseset([])
80 parentrevs = repo.changelog.parentrevs
80 parentrevs = repo.changelog.parentrevs
81 visit = list(heads)
81 visit = list(heads)
82 reachable = set()
82 reachable = set()
83 seen = {}
83 seen = {}
84 minroot = min(roots)
84 minroot = min(roots)
85 roots = set(roots)
85 roots = set(roots)
86 # open-code the post-order traversal due to the tiny size of
86 # open-code the post-order traversal due to the tiny size of
87 # sys.getrecursionlimit()
87 # sys.getrecursionlimit()
88 while visit:
88 while visit:
89 rev = visit.pop()
89 rev = visit.pop()
90 if rev in roots:
90 if rev in roots:
91 reachable.add(rev)
91 reachable.add(rev)
92 parents = parentrevs(rev)
92 parents = parentrevs(rev)
93 seen[rev] = parents
93 seen[rev] = parents
94 for parent in parents:
94 for parent in parents:
95 if parent >= minroot and parent not in seen:
95 if parent >= minroot and parent not in seen:
96 visit.append(parent)
96 visit.append(parent)
97 if not reachable:
97 if not reachable:
98 return baseset([])
98 return baseset([])
99 for rev in sorted(seen):
99 for rev in sorted(seen):
100 for parent in seen[rev]:
100 for parent in seen[rev]:
101 if parent in reachable:
101 if parent in reachable:
102 reachable.add(rev)
102 reachable.add(rev)
103 return baseset(sorted(reachable))
103 return baseset(sorted(reachable))
104
104
105 elements = {
105 elements = {
106 "(": (20, ("group", 1, ")"), ("func", 1, ")")),
106 "(": (20, ("group", 1, ")"), ("func", 1, ")")),
107 "~": (18, None, ("ancestor", 18)),
107 "~": (18, None, ("ancestor", 18)),
108 "^": (18, None, ("parent", 18), ("parentpost", 18)),
108 "^": (18, None, ("parent", 18), ("parentpost", 18)),
109 "-": (5, ("negate", 19), ("minus", 5)),
109 "-": (5, ("negate", 19), ("minus", 5)),
110 "::": (17, ("dagrangepre", 17), ("dagrange", 17),
110 "::": (17, ("dagrangepre", 17), ("dagrange", 17),
111 ("dagrangepost", 17)),
111 ("dagrangepost", 17)),
112 "..": (17, ("dagrangepre", 17), ("dagrange", 17),
112 "..": (17, ("dagrangepre", 17), ("dagrange", 17),
113 ("dagrangepost", 17)),
113 ("dagrangepost", 17)),
114 ":": (15, ("rangepre", 15), ("range", 15), ("rangepost", 15)),
114 ":": (15, ("rangepre", 15), ("range", 15), ("rangepost", 15)),
115 "not": (10, ("not", 10)),
115 "not": (10, ("not", 10)),
116 "!": (10, ("not", 10)),
116 "!": (10, ("not", 10)),
117 "and": (5, None, ("and", 5)),
117 "and": (5, None, ("and", 5)),
118 "&": (5, None, ("and", 5)),
118 "&": (5, None, ("and", 5)),
119 "or": (4, None, ("or", 4)),
119 "or": (4, None, ("or", 4)),
120 "|": (4, None, ("or", 4)),
120 "|": (4, None, ("or", 4)),
121 "+": (4, None, ("or", 4)),
121 "+": (4, None, ("or", 4)),
122 ",": (2, None, ("list", 2)),
122 ",": (2, None, ("list", 2)),
123 ")": (0, None, None),
123 ")": (0, None, None),
124 "symbol": (0, ("symbol",), None),
124 "symbol": (0, ("symbol",), None),
125 "string": (0, ("string",), None),
125 "string": (0, ("string",), None),
126 "end": (0, None, None),
126 "end": (0, None, None),
127 }
127 }
128
128
129 keywords = set(['and', 'or', 'not'])
129 keywords = set(['and', 'or', 'not'])
130
130
131 def tokenize(program, lookup=None):
131 def tokenize(program, lookup=None):
132 '''
132 '''
133 Parse a revset statement into a stream of tokens
133 Parse a revset statement into a stream of tokens
134
134
135 Check that @ is a valid unquoted token character (issue3686):
135 Check that @ is a valid unquoted token character (issue3686):
136 >>> list(tokenize("@::"))
136 >>> list(tokenize("@::"))
137 [('symbol', '@', 0), ('::', None, 1), ('end', None, 3)]
137 [('symbol', '@', 0), ('::', None, 1), ('end', None, 3)]
138
138
139 '''
139 '''
140
140
141 pos, l = 0, len(program)
141 pos, l = 0, len(program)
142 while pos < l:
142 while pos < l:
143 c = program[pos]
143 c = program[pos]
144 if c.isspace(): # skip inter-token whitespace
144 if c.isspace(): # skip inter-token whitespace
145 pass
145 pass
146 elif c == ':' and program[pos:pos + 2] == '::': # look ahead carefully
146 elif c == ':' and program[pos:pos + 2] == '::': # look ahead carefully
147 yield ('::', None, pos)
147 yield ('::', None, pos)
148 pos += 1 # skip ahead
148 pos += 1 # skip ahead
149 elif c == '.' and program[pos:pos + 2] == '..': # look ahead carefully
149 elif c == '.' and program[pos:pos + 2] == '..': # look ahead carefully
150 yield ('..', None, pos)
150 yield ('..', None, pos)
151 pos += 1 # skip ahead
151 pos += 1 # skip ahead
152 elif c in "():,-|&+!~^": # handle simple operators
152 elif c in "():,-|&+!~^": # handle simple operators
153 yield (c, None, pos)
153 yield (c, None, pos)
154 elif (c in '"\'' or c == 'r' and
154 elif (c in '"\'' or c == 'r' and
155 program[pos:pos + 2] in ("r'", 'r"')): # handle quoted strings
155 program[pos:pos + 2] in ("r'", 'r"')): # handle quoted strings
156 if c == 'r':
156 if c == 'r':
157 pos += 1
157 pos += 1
158 c = program[pos]
158 c = program[pos]
159 decode = lambda x: x
159 decode = lambda x: x
160 else:
160 else:
161 decode = lambda x: x.decode('string-escape')
161 decode = lambda x: x.decode('string-escape')
162 pos += 1
162 pos += 1
163 s = pos
163 s = pos
164 while pos < l: # find closing quote
164 while pos < l: # find closing quote
165 d = program[pos]
165 d = program[pos]
166 if d == '\\': # skip over escaped characters
166 if d == '\\': # skip over escaped characters
167 pos += 2
167 pos += 2
168 continue
168 continue
169 if d == c:
169 if d == c:
170 yield ('string', decode(program[s:pos]), s)
170 yield ('string', decode(program[s:pos]), s)
171 break
171 break
172 pos += 1
172 pos += 1
173 else:
173 else:
174 raise error.ParseError(_("unterminated string"), s)
174 raise error.ParseError(_("unterminated string"), s)
175 # gather up a symbol/keyword
175 # gather up a symbol/keyword
176 elif c.isalnum() or c in '._@' or ord(c) > 127:
176 elif c.isalnum() or c in '._@' or ord(c) > 127:
177 s = pos
177 s = pos
178 pos += 1
178 pos += 1
179 while pos < l: # find end of symbol
179 while pos < l: # find end of symbol
180 d = program[pos]
180 d = program[pos]
181 if not (d.isalnum() or d in "-._/@" or ord(d) > 127):
181 if not (d.isalnum() or d in "-._/@" or ord(d) > 127):
182 break
182 break
183 if d == '.' and program[pos - 1] == '.': # special case for ..
183 if d == '.' and program[pos - 1] == '.': # special case for ..
184 pos -= 1
184 pos -= 1
185 break
185 break
186 pos += 1
186 pos += 1
187 sym = program[s:pos]
187 sym = program[s:pos]
188 if sym in keywords: # operator keywords
188 if sym in keywords: # operator keywords
189 yield (sym, None, s)
189 yield (sym, None, s)
190 elif '-' in sym:
190 elif '-' in sym:
191 # some jerk gave us foo-bar-baz, try to check if it's a symbol
191 # some jerk gave us foo-bar-baz, try to check if it's a symbol
192 if lookup and lookup(sym):
192 if lookup and lookup(sym):
193 # looks like a real symbol
193 # looks like a real symbol
194 yield ('symbol', sym, s)
194 yield ('symbol', sym, s)
195 else:
195 else:
196 # looks like an expression
196 # looks like an expression
197 parts = sym.split('-')
197 parts = sym.split('-')
198 for p in parts[:-1]:
198 for p in parts[:-1]:
199 if p: # possible consecutive -
199 if p: # possible consecutive -
200 yield ('symbol', p, s)
200 yield ('symbol', p, s)
201 s += len(p)
201 s += len(p)
202 yield ('-', None, pos)
202 yield ('-', None, pos)
203 s += 1
203 s += 1
204 if parts[-1]: # possible trailing -
204 if parts[-1]: # possible trailing -
205 yield ('symbol', parts[-1], s)
205 yield ('symbol', parts[-1], s)
206 else:
206 else:
207 yield ('symbol', sym, s)
207 yield ('symbol', sym, s)
208 pos -= 1
208 pos -= 1
209 else:
209 else:
210 raise error.ParseError(_("syntax error"), pos)
210 raise error.ParseError(_("syntax error"), pos)
211 pos += 1
211 pos += 1
212 yield ('end', None, pos)
212 yield ('end', None, pos)
213
213
214 # helpers
214 # helpers
215
215
216 def getstring(x, err):
216 def getstring(x, err):
217 if x and (x[0] == 'string' or x[0] == 'symbol'):
217 if x and (x[0] == 'string' or x[0] == 'symbol'):
218 return x[1]
218 return x[1]
219 raise error.ParseError(err)
219 raise error.ParseError(err)
220
220
221 def getlist(x):
221 def getlist(x):
222 if not x:
222 if not x:
223 return []
223 return []
224 if x[0] == 'list':
224 if x[0] == 'list':
225 return getlist(x[1]) + [x[2]]
225 return getlist(x[1]) + [x[2]]
226 return [x]
226 return [x]
227
227
228 def getargs(x, min, max, err):
228 def getargs(x, min, max, err):
229 l = getlist(x)
229 l = getlist(x)
230 if len(l) < min or (max >= 0 and len(l) > max):
230 if len(l) < min or (max >= 0 and len(l) > max):
231 raise error.ParseError(err)
231 raise error.ParseError(err)
232 return l
232 return l
233
233
234 def getset(repo, subset, x):
234 def getset(repo, subset, x):
235 if not x:
235 if not x:
236 raise error.ParseError(_("missing argument"))
236 raise error.ParseError(_("missing argument"))
237 s = methods[x[0]](repo, subset, *x[1:])
237 s = methods[x[0]](repo, subset, *x[1:])
238 if util.safehasattr(s, 'set'):
238 if util.safehasattr(s, 'set'):
239 return s
239 return s
240 return baseset(s)
240 return baseset(s)
241
241
242 def _getrevsource(repo, r):
242 def _getrevsource(repo, r):
243 extra = repo[r].extra()
243 extra = repo[r].extra()
244 for label in ('source', 'transplant_source', 'rebase_source'):
244 for label in ('source', 'transplant_source', 'rebase_source'):
245 if label in extra:
245 if label in extra:
246 try:
246 try:
247 return repo[extra[label]].rev()
247 return repo[extra[label]].rev()
248 except error.RepoLookupError:
248 except error.RepoLookupError:
249 pass
249 pass
250 return None
250 return None
251
251
252 # operator methods
252 # operator methods
253
253
254 def stringset(repo, subset, x):
254 def stringset(repo, subset, x):
255 x = repo[x].rev()
255 x = repo[x].rev()
256 if x == -1 and len(subset) == len(repo):
256 if x == -1 and len(subset) == len(repo):
257 return baseset([-1])
257 return baseset([-1])
258 if len(subset) == len(repo) or x in subset:
258 if len(subset) == len(repo) or x in subset:
259 return baseset([x])
259 return baseset([x])
260 return baseset([])
260 return baseset([])
261
261
262 def symbolset(repo, subset, x):
262 def symbolset(repo, subset, x):
263 if x in symbols:
263 if x in symbols:
264 raise error.ParseError(_("can't use %s here") % x)
264 raise error.ParseError(_("can't use %s here") % x)
265 return stringset(repo, subset, x)
265 return stringset(repo, subset, x)
266
266
267 def rangeset(repo, subset, x, y):
267 def rangeset(repo, subset, x, y):
268 cl = baseset(repo.changelog)
268 cl = baseset(repo.changelog)
269 m = getset(repo, cl, x)
269 m = getset(repo, cl, x)
270 n = getset(repo, cl, y)
270 n = getset(repo, cl, y)
271
271
272 if not m or not n:
272 if not m or not n:
273 return baseset([])
273 return baseset([])
274 m, n = m[0], n[-1]
274 m, n = m[0], n[-1]
275
275
276 if m < n:
276 if m < n:
277 r = spanset(repo, m, n + 1)
277 r = spanset(repo, m, n + 1)
278 else:
278 else:
279 r = spanset(repo, m, n - 1)
279 r = spanset(repo, m, n - 1)
280 return r & subset
280 return r & subset
281
281
282 def dagrange(repo, subset, x, y):
282 def dagrange(repo, subset, x, y):
283 r = spanset(repo)
283 r = spanset(repo)
284 xs = _revsbetween(repo, getset(repo, r, x), getset(repo, r, y))
284 xs = _revsbetween(repo, getset(repo, r, x), getset(repo, r, y))
285 s = subset.set()
285 s = subset.set()
286 return xs.filter(s.__contains__)
286 return xs.filter(s.__contains__)
287
287
288 def andset(repo, subset, x, y):
288 def andset(repo, subset, x, y):
289 return getset(repo, getset(repo, subset, x), y)
289 return getset(repo, getset(repo, subset, x), y)
290
290
291 def orset(repo, subset, x, y):
291 def orset(repo, subset, x, y):
292 xl = getset(repo, subset, x)
292 xl = getset(repo, subset, x)
293 yl = getset(repo, subset - xl, y)
293 yl = getset(repo, subset - xl, y)
294 return xl + yl
294 return xl + yl
295
295
296 def notset(repo, subset, x):
296 def notset(repo, subset, x):
297 return subset - getset(repo, subset, x)
297 return subset - getset(repo, subset, x)
298
298
299 def listset(repo, subset, a, b):
299 def listset(repo, subset, a, b):
300 raise error.ParseError(_("can't use a list in this context"))
300 raise error.ParseError(_("can't use a list in this context"))
301
301
302 def func(repo, subset, a, b):
302 def func(repo, subset, a, b):
303 if a[0] == 'symbol' and a[1] in symbols:
303 if a[0] == 'symbol' and a[1] in symbols:
304 return symbols[a[1]](repo, subset, b)
304 return symbols[a[1]](repo, subset, b)
305 raise error.ParseError(_("not a function: %s") % a[1])
305 raise error.ParseError(_("not a function: %s") % a[1])
306
306
307 # functions
307 # functions
308
308
309 def adds(repo, subset, x):
309 def adds(repo, subset, x):
310 """``adds(pattern)``
310 """``adds(pattern)``
311 Changesets that add a file matching pattern.
311 Changesets that add a file matching pattern.
312
312
313 The pattern without explicit kind like ``glob:`` is expected to be
313 The pattern without explicit kind like ``glob:`` is expected to be
314 relative to the current directory and match against a file or a
314 relative to the current directory and match against a file or a
315 directory.
315 directory.
316 """
316 """
317 # i18n: "adds" is a keyword
317 # i18n: "adds" is a keyword
318 pat = getstring(x, _("adds requires a pattern"))
318 pat = getstring(x, _("adds requires a pattern"))
319 return checkstatus(repo, subset, pat, 1)
319 return checkstatus(repo, subset, pat, 1)
320
320
321 def ancestor(repo, subset, x):
321 def ancestor(repo, subset, x):
322 """``ancestor(*changeset)``
322 """``ancestor(*changeset)``
323 A greatest common ancestor of the changesets.
323 A greatest common ancestor of the changesets.
324
324
325 Accepts 0 or more changesets.
325 Accepts 0 or more changesets.
326 Will return empty list when passed no args.
326 Will return empty list when passed no args.
327 Greatest common ancestor of a single changeset is that changeset.
327 Greatest common ancestor of a single changeset is that changeset.
328 """
328 """
329 # i18n: "ancestor" is a keyword
329 # i18n: "ancestor" is a keyword
330 l = getlist(x)
330 l = getlist(x)
331 rl = spanset(repo)
331 rl = spanset(repo)
332 anc = None
332 anc = None
333
333
334 # (getset(repo, rl, i) for i in l) generates a list of lists
334 # (getset(repo, rl, i) for i in l) generates a list of lists
335 for revs in (getset(repo, rl, i) for i in l):
335 for revs in (getset(repo, rl, i) for i in l):
336 for r in revs:
336 for r in revs:
337 if anc is None:
337 if anc is None:
338 anc = repo[r]
338 anc = repo[r]
339 else:
339 else:
340 anc = anc.ancestor(repo[r])
340 anc = anc.ancestor(repo[r])
341
341
342 if anc is not None and anc.rev() in subset:
342 if anc is not None and anc.rev() in subset:
343 return baseset([anc.rev()])
343 return baseset([anc.rev()])
344 return baseset([])
344 return baseset([])
345
345
346 def _ancestors(repo, subset, x, followfirst=False):
346 def _ancestors(repo, subset, x, followfirst=False):
347 args = getset(repo, spanset(repo), x)
347 args = getset(repo, spanset(repo), x)
348 if not args:
348 if not args:
349 return baseset([])
349 return baseset([])
350 s = _revancestors(repo, args, followfirst)
350 s = _revancestors(repo, args, followfirst)
351 return subset.filter(s.__contains__)
351 return subset.filter(s.__contains__)
352
352
353 def ancestors(repo, subset, x):
353 def ancestors(repo, subset, x):
354 """``ancestors(set)``
354 """``ancestors(set)``
355 Changesets that are ancestors of a changeset in set.
355 Changesets that are ancestors of a changeset in set.
356 """
356 """
357 return _ancestors(repo, subset, x)
357 return _ancestors(repo, subset, x)
358
358
359 def _firstancestors(repo, subset, x):
359 def _firstancestors(repo, subset, x):
360 # ``_firstancestors(set)``
360 # ``_firstancestors(set)``
361 # Like ``ancestors(set)`` but follows only the first parents.
361 # Like ``ancestors(set)`` but follows only the first parents.
362 return _ancestors(repo, subset, x, followfirst=True)
362 return _ancestors(repo, subset, x, followfirst=True)
363
363
364 def ancestorspec(repo, subset, x, n):
364 def ancestorspec(repo, subset, x, n):
365 """``set~n``
365 """``set~n``
366 Changesets that are the Nth ancestor (first parents only) of a changeset
366 Changesets that are the Nth ancestor (first parents only) of a changeset
367 in set.
367 in set.
368 """
368 """
369 try:
369 try:
370 n = int(n[1])
370 n = int(n[1])
371 except (TypeError, ValueError):
371 except (TypeError, ValueError):
372 raise error.ParseError(_("~ expects a number"))
372 raise error.ParseError(_("~ expects a number"))
373 ps = set()
373 ps = set()
374 cl = repo.changelog
374 cl = repo.changelog
375 for r in getset(repo, baseset(cl), x):
375 for r in getset(repo, baseset(cl), x):
376 for i in range(n):
376 for i in range(n):
377 r = cl.parentrevs(r)[0]
377 r = cl.parentrevs(r)[0]
378 ps.add(r)
378 ps.add(r)
379 return subset & ps
379 return subset & ps
380
380
381 def author(repo, subset, x):
381 def author(repo, subset, x):
382 """``author(string)``
382 """``author(string)``
383 Alias for ``user(string)``.
383 Alias for ``user(string)``.
384 """
384 """
385 # i18n: "author" is a keyword
385 # i18n: "author" is a keyword
386 n = encoding.lower(getstring(x, _("author requires a string")))
386 n = encoding.lower(getstring(x, _("author requires a string")))
387 kind, pattern, matcher = _substringmatcher(n)
387 kind, pattern, matcher = _substringmatcher(n)
388 return subset.filter(lambda x: matcher(encoding.lower(repo[x].user())))
388 return subset.filter(lambda x: matcher(encoding.lower(repo[x].user())))
389
389
390 def only(repo, subset, x):
390 def only(repo, subset, x):
391 """``only(set, [set])``
391 """``only(set, [set])``
392 Changesets that are ancestors of the first set that are not ancestors
392 Changesets that are ancestors of the first set that are not ancestors
393 of any other head in the repo. If a second set is specified, the result
393 of any other head in the repo. If a second set is specified, the result
394 is ancestors of the first set that are not ancestors of the second set
394 is ancestors of the first set that are not ancestors of the second set
395 (i.e. ::<set1> - ::<set2>).
395 (i.e. ::<set1> - ::<set2>).
396 """
396 """
397 cl = repo.changelog
397 cl = repo.changelog
398 # i18n: "only" is a keyword
398 # i18n: "only" is a keyword
399 args = getargs(x, 1, 2, _('only takes one or two arguments'))
399 args = getargs(x, 1, 2, _('only takes one or two arguments'))
400 include = getset(repo, spanset(repo), args[0]).set()
400 include = getset(repo, spanset(repo), args[0]).set()
401 if len(args) == 1:
401 if len(args) == 1:
402 if len(include) == 0:
402 if len(include) == 0:
403 return baseset([])
403 return baseset([])
404
404
405 descendants = set(_revdescendants(repo, include, False))
405 descendants = set(_revdescendants(repo, include, False))
406 exclude = [rev for rev in cl.headrevs()
406 exclude = [rev for rev in cl.headrevs()
407 if not rev in descendants and not rev in include]
407 if not rev in descendants and not rev in include]
408 else:
408 else:
409 exclude = getset(repo, spanset(repo), args[1])
409 exclude = getset(repo, spanset(repo), args[1])
410
410
411 results = set(ancestormod.missingancestors(include, exclude, cl.parentrevs))
411 results = set(ancestormod.missingancestors(include, exclude, cl.parentrevs))
412 return lazyset(subset, results.__contains__)
412 return lazyset(subset, results.__contains__)
413
413
414 def bisect(repo, subset, x):
414 def bisect(repo, subset, x):
415 """``bisect(string)``
415 """``bisect(string)``
416 Changesets marked in the specified bisect status:
416 Changesets marked in the specified bisect status:
417
417
418 - ``good``, ``bad``, ``skip``: csets explicitly marked as good/bad/skip
418 - ``good``, ``bad``, ``skip``: csets explicitly marked as good/bad/skip
419 - ``goods``, ``bads`` : csets topologically good/bad
419 - ``goods``, ``bads`` : csets topologically good/bad
420 - ``range`` : csets taking part in the bisection
420 - ``range`` : csets taking part in the bisection
421 - ``pruned`` : csets that are goods, bads or skipped
421 - ``pruned`` : csets that are goods, bads or skipped
422 - ``untested`` : csets whose fate is yet unknown
422 - ``untested`` : csets whose fate is yet unknown
423 - ``ignored`` : csets ignored due to DAG topology
423 - ``ignored`` : csets ignored due to DAG topology
424 - ``current`` : the cset currently being bisected
424 - ``current`` : the cset currently being bisected
425 """
425 """
426 # i18n: "bisect" is a keyword
426 # i18n: "bisect" is a keyword
427 status = getstring(x, _("bisect requires a string")).lower()
427 status = getstring(x, _("bisect requires a string")).lower()
428 state = set(hbisect.get(repo, status))
428 state = set(hbisect.get(repo, status))
429 return subset & state
429 return subset & state
430
430
431 # Backward-compatibility
431 # Backward-compatibility
432 # - no help entry so that we do not advertise it any more
432 # - no help entry so that we do not advertise it any more
433 def bisected(repo, subset, x):
433 def bisected(repo, subset, x):
434 return bisect(repo, subset, x)
434 return bisect(repo, subset, x)
435
435
436 def bookmark(repo, subset, x):
436 def bookmark(repo, subset, x):
437 """``bookmark([name])``
437 """``bookmark([name])``
438 The named bookmark or all bookmarks.
438 The named bookmark or all bookmarks.
439
439
440 If `name` starts with `re:`, the remainder of the name is treated as
440 If `name` starts with `re:`, the remainder of the name is treated as
441 a regular expression. To match a bookmark that actually starts with `re:`,
441 a regular expression. To match a bookmark that actually starts with `re:`,
442 use the prefix `literal:`.
442 use the prefix `literal:`.
443 """
443 """
444 # i18n: "bookmark" is a keyword
444 # i18n: "bookmark" is a keyword
445 args = getargs(x, 0, 1, _('bookmark takes one or no arguments'))
445 args = getargs(x, 0, 1, _('bookmark takes one or no arguments'))
446 if args:
446 if args:
447 bm = getstring(args[0],
447 bm = getstring(args[0],
448 # i18n: "bookmark" is a keyword
448 # i18n: "bookmark" is a keyword
449 _('the argument to bookmark must be a string'))
449 _('the argument to bookmark must be a string'))
450 kind, pattern, matcher = _stringmatcher(bm)
450 kind, pattern, matcher = _stringmatcher(bm)
451 bms = set()
451 bms = set()
452 if kind == 'literal':
452 if kind == 'literal':
453 bmrev = repo._bookmarks.get(pattern, None)
453 bmrev = repo._bookmarks.get(pattern, None)
454 if not bmrev:
454 if not bmrev:
455 raise util.Abort(_("bookmark '%s' does not exist") % bm)
455 raise util.Abort(_("bookmark '%s' does not exist") % bm)
456 bms.add(repo[bmrev].rev())
456 bms.add(repo[bmrev].rev())
457 else:
457 else:
458 matchrevs = set()
458 matchrevs = set()
459 for name, bmrev in repo._bookmarks.iteritems():
459 for name, bmrev in repo._bookmarks.iteritems():
460 if matcher(name):
460 if matcher(name):
461 matchrevs.add(bmrev)
461 matchrevs.add(bmrev)
462 if not matchrevs:
462 if not matchrevs:
463 raise util.Abort(_("no bookmarks exist that match '%s'")
463 raise util.Abort(_("no bookmarks exist that match '%s'")
464 % pattern)
464 % pattern)
465 for bmrev in matchrevs:
465 for bmrev in matchrevs:
466 bms.add(repo[bmrev].rev())
466 bms.add(repo[bmrev].rev())
467 else:
467 else:
468 bms = set([repo[r].rev()
468 bms = set([repo[r].rev()
469 for r in repo._bookmarks.values()])
469 for r in repo._bookmarks.values()])
470 bms -= set([node.nullrev])
470 bms -= set([node.nullrev])
471 return subset & bms
471 return subset & bms
472
472
473 def branch(repo, subset, x):
473 def branch(repo, subset, x):
474 """``branch(string or set)``
474 """``branch(string or set)``
475 All changesets belonging to the given branch or the branches of the given
475 All changesets belonging to the given branch or the branches of the given
476 changesets.
476 changesets.
477
477
478 If `string` starts with `re:`, the remainder of the name is treated as
478 If `string` starts with `re:`, the remainder of the name is treated as
479 a regular expression. To match a branch that actually starts with `re:`,
479 a regular expression. To match a branch that actually starts with `re:`,
480 use the prefix `literal:`.
480 use the prefix `literal:`.
481 """
481 """
482 try:
482 try:
483 b = getstring(x, '')
483 b = getstring(x, '')
484 except error.ParseError:
484 except error.ParseError:
485 # not a string, but another revspec, e.g. tip()
485 # not a string, but another revspec, e.g. tip()
486 pass
486 pass
487 else:
487 else:
488 kind, pattern, matcher = _stringmatcher(b)
488 kind, pattern, matcher = _stringmatcher(b)
489 if kind == 'literal':
489 if kind == 'literal':
490 # note: falls through to the revspec case if no branch with
490 # note: falls through to the revspec case if no branch with
491 # this name exists
491 # this name exists
492 if pattern in repo.branchmap():
492 if pattern in repo.branchmap():
493 return subset.filter(lambda r: matcher(repo[r].branch()))
493 return subset.filter(lambda r: matcher(repo[r].branch()))
494 else:
494 else:
495 return subset.filter(lambda r: matcher(repo[r].branch()))
495 return subset.filter(lambda r: matcher(repo[r].branch()))
496
496
497 s = getset(repo, spanset(repo), x)
497 s = getset(repo, spanset(repo), x)
498 b = set()
498 b = set()
499 for r in s:
499 for r in s:
500 b.add(repo[r].branch())
500 b.add(repo[r].branch())
501 s = s.set()
501 s = s.set()
502 return subset.filter(lambda r: r in s or repo[r].branch() in b)
502 return subset.filter(lambda r: r in s or repo[r].branch() in b)
503
503
504 def bumped(repo, subset, x):
504 def bumped(repo, subset, x):
505 """``bumped()``
505 """``bumped()``
506 Mutable changesets marked as successors of public changesets.
506 Mutable changesets marked as successors of public changesets.
507
507
508 Only non-public and non-obsolete changesets can be `bumped`.
508 Only non-public and non-obsolete changesets can be `bumped`.
509 """
509 """
510 # i18n: "bumped" is a keyword
510 # i18n: "bumped" is a keyword
511 getargs(x, 0, 0, _("bumped takes no arguments"))
511 getargs(x, 0, 0, _("bumped takes no arguments"))
512 bumped = obsmod.getrevs(repo, 'bumped')
512 bumped = obsmod.getrevs(repo, 'bumped')
513 return subset & bumped
513 return subset & bumped
514
514
515 def bundle(repo, subset, x):
515 def bundle(repo, subset, x):
516 """``bundle()``
516 """``bundle()``
517 Changesets in the bundle.
517 Changesets in the bundle.
518
518
519 Bundle must be specified by the -R option."""
519 Bundle must be specified by the -R option."""
520
520
521 try:
521 try:
522 bundlerevs = repo.changelog.bundlerevs
522 bundlerevs = repo.changelog.bundlerevs
523 except AttributeError:
523 except AttributeError:
524 raise util.Abort(_("no bundle provided - specify with -R"))
524 raise util.Abort(_("no bundle provided - specify with -R"))
525 return subset & bundlerevs
525 return subset & bundlerevs
526
526
527 def checkstatus(repo, subset, pat, field):
527 def checkstatus(repo, subset, pat, field):
528 hasset = matchmod.patkind(pat) == 'set'
528 hasset = matchmod.patkind(pat) == 'set'
529
529
530 def matches(x):
530 def matches(x):
531 m = None
531 m = None
532 fname = None
532 fname = None
533 c = repo[x]
533 c = repo[x]
534 if not m or hasset:
534 if not m or hasset:
535 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c)
535 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c)
536 if not m.anypats() and len(m.files()) == 1:
536 if not m.anypats() and len(m.files()) == 1:
537 fname = m.files()[0]
537 fname = m.files()[0]
538 if fname is not None:
538 if fname is not None:
539 if fname not in c.files():
539 if fname not in c.files():
540 return False
540 return False
541 else:
541 else:
542 for f in c.files():
542 for f in c.files():
543 if m(f):
543 if m(f):
544 break
544 break
545 else:
545 else:
546 return False
546 return False
547 files = repo.status(c.p1().node(), c.node())[field]
547 files = repo.status(c.p1().node(), c.node())[field]
548 if fname is not None:
548 if fname is not None:
549 if fname in files:
549 if fname in files:
550 return True
550 return True
551 else:
551 else:
552 for f in files:
552 for f in files:
553 if m(f):
553 if m(f):
554 return True
554 return True
555
555
556 return subset.filter(matches)
556 return subset.filter(matches)
557
557
558 def _children(repo, narrow, parentset):
558 def _children(repo, narrow, parentset):
559 cs = set()
559 cs = set()
560 if not parentset:
560 if not parentset:
561 return baseset(cs)
561 return baseset(cs)
562 pr = repo.changelog.parentrevs
562 pr = repo.changelog.parentrevs
563 minrev = min(parentset)
563 minrev = min(parentset)
564 for r in narrow:
564 for r in narrow:
565 if r <= minrev:
565 if r <= minrev:
566 continue
566 continue
567 for p in pr(r):
567 for p in pr(r):
568 if p in parentset:
568 if p in parentset:
569 cs.add(r)
569 cs.add(r)
570 return baseset(cs)
570 return baseset(cs)
571
571
572 def children(repo, subset, x):
572 def children(repo, subset, x):
573 """``children(set)``
573 """``children(set)``
574 Child changesets of changesets in set.
574 Child changesets of changesets in set.
575 """
575 """
576 s = getset(repo, baseset(repo), x).set()
576 s = getset(repo, baseset(repo), x).set()
577 cs = _children(repo, subset, s)
577 cs = _children(repo, subset, s)
578 return subset & cs
578 return subset & cs
579
579
580 def closed(repo, subset, x):
580 def closed(repo, subset, x):
581 """``closed()``
581 """``closed()``
582 Changeset is closed.
582 Changeset is closed.
583 """
583 """
584 # i18n: "closed" is a keyword
584 # i18n: "closed" is a keyword
585 getargs(x, 0, 0, _("closed takes no arguments"))
585 getargs(x, 0, 0, _("closed takes no arguments"))
586 return subset.filter(lambda r: repo[r].closesbranch())
586 return subset.filter(lambda r: repo[r].closesbranch())
587
587
588 def contains(repo, subset, x):
588 def contains(repo, subset, x):
589 """``contains(pattern)``
589 """``contains(pattern)``
590 The revision's manifest contains a file matching pattern (but might not
590 The revision's manifest contains a file matching pattern (but might not
591 modify it). See :hg:`help patterns` for information about file patterns.
591 modify it). See :hg:`help patterns` for information about file patterns.
592
592
593 The pattern without explicit kind like ``glob:`` is expected to be
593 The pattern without explicit kind like ``glob:`` is expected to be
594 relative to the current directory and match against a file exactly
594 relative to the current directory and match against a file exactly
595 for efficiency.
595 for efficiency.
596 """
596 """
597 # i18n: "contains" is a keyword
597 # i18n: "contains" is a keyword
598 pat = getstring(x, _("contains requires a pattern"))
598 pat = getstring(x, _("contains requires a pattern"))
599
599
600 def matches(x):
600 def matches(x):
601 if not matchmod.patkind(pat):
601 if not matchmod.patkind(pat):
602 pats = pathutil.canonpath(repo.root, repo.getcwd(), pat)
602 pats = pathutil.canonpath(repo.root, repo.getcwd(), pat)
603 if pats in repo[x]:
603 if pats in repo[x]:
604 return True
604 return True
605 else:
605 else:
606 c = repo[x]
606 c = repo[x]
607 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c)
607 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c)
608 for f in c.manifest():
608 for f in c.manifest():
609 if m(f):
609 if m(f):
610 return True
610 return True
611 return False
611 return False
612
612
613 return subset.filter(matches)
613 return subset.filter(matches)
614
614
615 def converted(repo, subset, x):
615 def converted(repo, subset, x):
616 """``converted([id])``
616 """``converted([id])``
617 Changesets converted from the given identifier in the old repository if
617 Changesets converted from the given identifier in the old repository if
618 present, or all converted changesets if no identifier is specified.
618 present, or all converted changesets if no identifier is specified.
619 """
619 """
620
620
621 # There is exactly no chance of resolving the revision, so do a simple
621 # There is exactly no chance of resolving the revision, so do a simple
622 # string compare and hope for the best
622 # string compare and hope for the best
623
623
624 rev = None
624 rev = None
625 # i18n: "converted" is a keyword
625 # i18n: "converted" is a keyword
626 l = getargs(x, 0, 1, _('converted takes one or no arguments'))
626 l = getargs(x, 0, 1, _('converted takes one or no arguments'))
627 if l:
627 if l:
628 # i18n: "converted" is a keyword
628 # i18n: "converted" is a keyword
629 rev = getstring(l[0], _('converted requires a revision'))
629 rev = getstring(l[0], _('converted requires a revision'))
630
630
631 def _matchvalue(r):
631 def _matchvalue(r):
632 source = repo[r].extra().get('convert_revision', None)
632 source = repo[r].extra().get('convert_revision', None)
633 return source is not None and (rev is None or source.startswith(rev))
633 return source is not None and (rev is None or source.startswith(rev))
634
634
635 return subset.filter(lambda r: _matchvalue(r))
635 return subset.filter(lambda r: _matchvalue(r))
636
636
637 def date(repo, subset, x):
637 def date(repo, subset, x):
638 """``date(interval)``
638 """``date(interval)``
639 Changesets within the interval, see :hg:`help dates`.
639 Changesets within the interval, see :hg:`help dates`.
640 """
640 """
641 # i18n: "date" is a keyword
641 # i18n: "date" is a keyword
642 ds = getstring(x, _("date requires a string"))
642 ds = getstring(x, _("date requires a string"))
643 dm = util.matchdate(ds)
643 dm = util.matchdate(ds)
644 return subset.filter(lambda x: dm(repo[x].date()[0]))
644 return subset.filter(lambda x: dm(repo[x].date()[0]))
645
645
646 def desc(repo, subset, x):
646 def desc(repo, subset, x):
647 """``desc(string)``
647 """``desc(string)``
648 Search commit message for string. The match is case-insensitive.
648 Search commit message for string. The match is case-insensitive.
649 """
649 """
650 # i18n: "desc" is a keyword
650 # i18n: "desc" is a keyword
651 ds = encoding.lower(getstring(x, _("desc requires a string")))
651 ds = encoding.lower(getstring(x, _("desc requires a string")))
652
652
653 def matches(x):
653 def matches(x):
654 c = repo[x]
654 c = repo[x]
655 return ds in encoding.lower(c.description())
655 return ds in encoding.lower(c.description())
656
656
657 return subset.filter(matches)
657 return subset.filter(matches)
658
658
659 def _descendants(repo, subset, x, followfirst=False):
659 def _descendants(repo, subset, x, followfirst=False):
660 args = getset(repo, spanset(repo), x)
660 args = getset(repo, spanset(repo), x)
661 if not args:
661 if not args:
662 return baseset([])
662 return baseset([])
663 s = _revdescendants(repo, args, followfirst)
663 s = _revdescendants(repo, args, followfirst)
664
664
665 # Both sets need to be ascending in order to lazily return the union
665 # Both sets need to be ascending in order to lazily return the union
666 # in the correct order.
666 # in the correct order.
667 args.ascending()
667 args.ascending()
668 result = (orderedlazyset(s, subset.__contains__, ascending=True) +
668 result = (orderedlazyset(s, subset.__contains__, ascending=True) +
669 orderedlazyset(args, subset.__contains__, ascending=True))
669 orderedlazyset(args, subset.__contains__, ascending=True))
670
670
671 # Wrap result in a lazyset since it's an _addset, which doesn't implement
671 # Wrap result in a lazyset since it's an _addset, which doesn't implement
672 # all the necessary functions to be consumed by callers.
672 # all the necessary functions to be consumed by callers.
673 return orderedlazyset(result, lambda r: True, ascending=True)
673 return orderedlazyset(result, lambda r: True, ascending=True)
674
674
675 def descendants(repo, subset, x):
675 def descendants(repo, subset, x):
676 """``descendants(set)``
676 """``descendants(set)``
677 Changesets which are descendants of changesets in set.
677 Changesets which are descendants of changesets in set.
678 """
678 """
679 return _descendants(repo, subset, x)
679 return _descendants(repo, subset, x)
680
680
681 def _firstdescendants(repo, subset, x):
681 def _firstdescendants(repo, subset, x):
682 # ``_firstdescendants(set)``
682 # ``_firstdescendants(set)``
683 # Like ``descendants(set)`` but follows only the first parents.
683 # Like ``descendants(set)`` but follows only the first parents.
684 return _descendants(repo, subset, x, followfirst=True)
684 return _descendants(repo, subset, x, followfirst=True)
685
685
686 def destination(repo, subset, x):
686 def destination(repo, subset, x):
687 """``destination([set])``
687 """``destination([set])``
688 Changesets that were created by a graft, transplant or rebase operation,
688 Changesets that were created by a graft, transplant or rebase operation,
689 with the given revisions specified as the source. Omitting the optional set
689 with the given revisions specified as the source. Omitting the optional set
690 is the same as passing all().
690 is the same as passing all().
691 """
691 """
692 if x is not None:
692 if x is not None:
693 args = getset(repo, spanset(repo), x).set()
693 args = getset(repo, spanset(repo), x).set()
694 else:
694 else:
695 args = getall(repo, spanset(repo), x).set()
695 args = getall(repo, spanset(repo), x).set()
696
696
697 dests = set()
697 dests = set()
698
698
699 # subset contains all of the possible destinations that can be returned, so
699 # subset contains all of the possible destinations that can be returned, so
700 # iterate over them and see if their source(s) were provided in the args.
700 # iterate over them and see if their source(s) were provided in the args.
701 # Even if the immediate src of r is not in the args, src's source (or
701 # Even if the immediate src of r is not in the args, src's source (or
702 # further back) may be. Scanning back further than the immediate src allows
702 # further back) may be. Scanning back further than the immediate src allows
703 # transitive transplants and rebases to yield the same results as transitive
703 # transitive transplants and rebases to yield the same results as transitive
704 # grafts.
704 # grafts.
705 for r in subset:
705 for r in subset:
706 src = _getrevsource(repo, r)
706 src = _getrevsource(repo, r)
707 lineage = None
707 lineage = None
708
708
709 while src is not None:
709 while src is not None:
710 if lineage is None:
710 if lineage is None:
711 lineage = list()
711 lineage = list()
712
712
713 lineage.append(r)
713 lineage.append(r)
714
714
715 # The visited lineage is a match if the current source is in the arg
715 # The visited lineage is a match if the current source is in the arg
716 # set. Since every candidate dest is visited by way of iterating
716 # set. Since every candidate dest is visited by way of iterating
717 # subset, any dests further back in the lineage will be tested by a
717 # subset, any dests further back in the lineage will be tested by a
718 # different iteration over subset. Likewise, if the src was already
718 # different iteration over subset. Likewise, if the src was already
719 # selected, the current lineage can be selected without going back
719 # selected, the current lineage can be selected without going back
720 # further.
720 # further.
721 if src in args or src in dests:
721 if src in args or src in dests:
722 dests.update(lineage)
722 dests.update(lineage)
723 break
723 break
724
724
725 r = src
725 r = src
726 src = _getrevsource(repo, r)
726 src = _getrevsource(repo, r)
727
727
728 return subset.filter(dests.__contains__)
728 return subset.filter(dests.__contains__)
729
729
730 def divergent(repo, subset, x):
730 def divergent(repo, subset, x):
731 """``divergent()``
731 """``divergent()``
732 Final successors of changesets with an alternative set of final successors.
732 Final successors of changesets with an alternative set of final successors.
733 """
733 """
734 # i18n: "divergent" is a keyword
734 # i18n: "divergent" is a keyword
735 getargs(x, 0, 0, _("divergent takes no arguments"))
735 getargs(x, 0, 0, _("divergent takes no arguments"))
736 divergent = obsmod.getrevs(repo, 'divergent')
736 divergent = obsmod.getrevs(repo, 'divergent')
737 return subset & divergent
737 return subset & divergent
738
738
739 def draft(repo, subset, x):
739 def draft(repo, subset, x):
740 """``draft()``
740 """``draft()``
741 Changeset in draft phase."""
741 Changeset in draft phase."""
742 # i18n: "draft" is a keyword
742 # i18n: "draft" is a keyword
743 getargs(x, 0, 0, _("draft takes no arguments"))
743 getargs(x, 0, 0, _("draft takes no arguments"))
744 pc = repo._phasecache
744 pc = repo._phasecache
745 return subset.filter(lambda r: pc.phase(repo, r) == phases.draft)
745 return subset.filter(lambda r: pc.phase(repo, r) == phases.draft)
746
746
747 def extinct(repo, subset, x):
747 def extinct(repo, subset, x):
748 """``extinct()``
748 """``extinct()``
749 Obsolete changesets with obsolete descendants only.
749 Obsolete changesets with obsolete descendants only.
750 """
750 """
751 # i18n: "extinct" is a keyword
751 # i18n: "extinct" is a keyword
752 getargs(x, 0, 0, _("extinct takes no arguments"))
752 getargs(x, 0, 0, _("extinct takes no arguments"))
753 extincts = obsmod.getrevs(repo, 'extinct')
753 extincts = obsmod.getrevs(repo, 'extinct')
754 return subset & extincts
754 return subset & extincts
755
755
756 def extra(repo, subset, x):
756 def extra(repo, subset, x):
757 """``extra(label, [value])``
757 """``extra(label, [value])``
758 Changesets with the given label in the extra metadata, with the given
758 Changesets with the given label in the extra metadata, with the given
759 optional value.
759 optional value.
760
760
761 If `value` starts with `re:`, the remainder of the value is treated as
761 If `value` starts with `re:`, the remainder of the value is treated as
762 a regular expression. To match a value that actually starts with `re:`,
762 a regular expression. To match a value that actually starts with `re:`,
763 use the prefix `literal:`.
763 use the prefix `literal:`.
764 """
764 """
765
765
766 # i18n: "extra" is a keyword
766 # i18n: "extra" is a keyword
767 l = getargs(x, 1, 2, _('extra takes at least 1 and at most 2 arguments'))
767 l = getargs(x, 1, 2, _('extra takes at least 1 and at most 2 arguments'))
768 # i18n: "extra" is a keyword
768 # i18n: "extra" is a keyword
769 label = getstring(l[0], _('first argument to extra must be a string'))
769 label = getstring(l[0], _('first argument to extra must be a string'))
770 value = None
770 value = None
771
771
772 if len(l) > 1:
772 if len(l) > 1:
773 # i18n: "extra" is a keyword
773 # i18n: "extra" is a keyword
774 value = getstring(l[1], _('second argument to extra must be a string'))
774 value = getstring(l[1], _('second argument to extra must be a string'))
775 kind, value, matcher = _stringmatcher(value)
775 kind, value, matcher = _stringmatcher(value)
776
776
777 def _matchvalue(r):
777 def _matchvalue(r):
778 extra = repo[r].extra()
778 extra = repo[r].extra()
779 return label in extra and (value is None or matcher(extra[label]))
779 return label in extra and (value is None or matcher(extra[label]))
780
780
781 return subset.filter(lambda r: _matchvalue(r))
781 return subset.filter(lambda r: _matchvalue(r))
782
782
783 def filelog(repo, subset, x):
783 def filelog(repo, subset, x):
784 """``filelog(pattern)``
784 """``filelog(pattern)``
785 Changesets connected to the specified filelog.
785 Changesets connected to the specified filelog.
786
786
787 For performance reasons, visits only revisions mentioned in the file-level
787 For performance reasons, visits only revisions mentioned in the file-level
788 filelog, rather than filtering through all changesets (much faster, but
788 filelog, rather than filtering through all changesets (much faster, but
789 doesn't include deletes or duplicate changes). For a slower, more accurate
789 doesn't include deletes or duplicate changes). For a slower, more accurate
790 result, use ``file()``.
790 result, use ``file()``.
791
791
792 The pattern without explicit kind like ``glob:`` is expected to be
792 The pattern without explicit kind like ``glob:`` is expected to be
793 relative to the current directory and match against a file exactly
793 relative to the current directory and match against a file exactly
794 for efficiency.
794 for efficiency.
795 """
795 """
796
796
797 # i18n: "filelog" is a keyword
797 # i18n: "filelog" is a keyword
798 pat = getstring(x, _("filelog requires a pattern"))
798 pat = getstring(x, _("filelog requires a pattern"))
799 s = set()
799 s = set()
800
800
801 if not matchmod.patkind(pat):
801 if not matchmod.patkind(pat):
802 f = pathutil.canonpath(repo.root, repo.getcwd(), pat)
802 f = pathutil.canonpath(repo.root, repo.getcwd(), pat)
803 fl = repo.file(f)
803 fl = repo.file(f)
804 for fr in fl:
804 for fr in fl:
805 s.add(fl.linkrev(fr))
805 s.add(fl.linkrev(fr))
806 else:
806 else:
807 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=repo[None])
807 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=repo[None])
808 for f in repo[None]:
808 for f in repo[None]:
809 if m(f):
809 if m(f):
810 fl = repo.file(f)
810 fl = repo.file(f)
811 for fr in fl:
811 for fr in fl:
812 s.add(fl.linkrev(fr))
812 s.add(fl.linkrev(fr))
813
813
814 return subset.filter(s.__contains__)
814 return subset & s
815
815
816 def first(repo, subset, x):
816 def first(repo, subset, x):
817 """``first(set, [n])``
817 """``first(set, [n])``
818 An alias for limit().
818 An alias for limit().
819 """
819 """
820 return limit(repo, subset, x)
820 return limit(repo, subset, x)
821
821
822 def _follow(repo, subset, x, name, followfirst=False):
822 def _follow(repo, subset, x, name, followfirst=False):
823 l = getargs(x, 0, 1, _("%s takes no arguments or a filename") % name)
823 l = getargs(x, 0, 1, _("%s takes no arguments or a filename") % name)
824 c = repo['.']
824 c = repo['.']
825 if l:
825 if l:
826 x = getstring(l[0], _("%s expected a filename") % name)
826 x = getstring(l[0], _("%s expected a filename") % name)
827 if x in c:
827 if x in c:
828 cx = c[x]
828 cx = c[x]
829 s = set(ctx.rev() for ctx in cx.ancestors(followfirst=followfirst))
829 s = set(ctx.rev() for ctx in cx.ancestors(followfirst=followfirst))
830 # include the revision responsible for the most recent version
830 # include the revision responsible for the most recent version
831 s.add(cx.linkrev())
831 s.add(cx.linkrev())
832 else:
832 else:
833 return baseset([])
833 return baseset([])
834 else:
834 else:
835 s = _revancestors(repo, baseset([c.rev()]), followfirst)
835 s = _revancestors(repo, baseset([c.rev()]), followfirst)
836
836
837 return subset.filter(s.__contains__)
837 return subset.filter(s.__contains__)
838
838
839 def follow(repo, subset, x):
839 def follow(repo, subset, x):
840 """``follow([file])``
840 """``follow([file])``
841 An alias for ``::.`` (ancestors of the working copy's first parent).
841 An alias for ``::.`` (ancestors of the working copy's first parent).
842 If a filename is specified, the history of the given file is followed,
842 If a filename is specified, the history of the given file is followed,
843 including copies.
843 including copies.
844 """
844 """
845 return _follow(repo, subset, x, 'follow')
845 return _follow(repo, subset, x, 'follow')
846
846
847 def _followfirst(repo, subset, x):
847 def _followfirst(repo, subset, x):
848 # ``followfirst([file])``
848 # ``followfirst([file])``
849 # Like ``follow([file])`` but follows only the first parent of
849 # Like ``follow([file])`` but follows only the first parent of
850 # every revision or file revision.
850 # every revision or file revision.
851 return _follow(repo, subset, x, '_followfirst', followfirst=True)
851 return _follow(repo, subset, x, '_followfirst', followfirst=True)
852
852
853 def getall(repo, subset, x):
853 def getall(repo, subset, x):
854 """``all()``
854 """``all()``
855 All changesets, the same as ``0:tip``.
855 All changesets, the same as ``0:tip``.
856 """
856 """
857 # i18n: "all" is a keyword
857 # i18n: "all" is a keyword
858 getargs(x, 0, 0, _("all takes no arguments"))
858 getargs(x, 0, 0, _("all takes no arguments"))
859 return subset
859 return subset
860
860
861 def grep(repo, subset, x):
861 def grep(repo, subset, x):
862 """``grep(regex)``
862 """``grep(regex)``
863 Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')``
863 Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')``
864 to ensure special escape characters are handled correctly. Unlike
864 to ensure special escape characters are handled correctly. Unlike
865 ``keyword(string)``, the match is case-sensitive.
865 ``keyword(string)``, the match is case-sensitive.
866 """
866 """
867 try:
867 try:
868 # i18n: "grep" is a keyword
868 # i18n: "grep" is a keyword
869 gr = re.compile(getstring(x, _("grep requires a string")))
869 gr = re.compile(getstring(x, _("grep requires a string")))
870 except re.error, e:
870 except re.error, e:
871 raise error.ParseError(_('invalid match pattern: %s') % e)
871 raise error.ParseError(_('invalid match pattern: %s') % e)
872
872
873 def matches(x):
873 def matches(x):
874 c = repo[x]
874 c = repo[x]
875 for e in c.files() + [c.user(), c.description()]:
875 for e in c.files() + [c.user(), c.description()]:
876 if gr.search(e):
876 if gr.search(e):
877 return True
877 return True
878 return False
878 return False
879
879
880 return subset.filter(matches)
880 return subset.filter(matches)
881
881
882 def _matchfiles(repo, subset, x):
882 def _matchfiles(repo, subset, x):
883 # _matchfiles takes a revset list of prefixed arguments:
883 # _matchfiles takes a revset list of prefixed arguments:
884 #
884 #
885 # [p:foo, i:bar, x:baz]
885 # [p:foo, i:bar, x:baz]
886 #
886 #
887 # builds a match object from them and filters subset. Allowed
887 # builds a match object from them and filters subset. Allowed
888 # prefixes are 'p:' for regular patterns, 'i:' for include
888 # prefixes are 'p:' for regular patterns, 'i:' for include
889 # patterns and 'x:' for exclude patterns. Use 'r:' prefix to pass
889 # patterns and 'x:' for exclude patterns. Use 'r:' prefix to pass
890 # a revision identifier, or the empty string to reference the
890 # a revision identifier, or the empty string to reference the
891 # working directory, from which the match object is
891 # working directory, from which the match object is
892 # initialized. Use 'd:' to set the default matching mode, default
892 # initialized. Use 'd:' to set the default matching mode, default
893 # to 'glob'. At most one 'r:' and 'd:' argument can be passed.
893 # to 'glob'. At most one 'r:' and 'd:' argument can be passed.
894
894
895 # i18n: "_matchfiles" is a keyword
895 # i18n: "_matchfiles" is a keyword
896 l = getargs(x, 1, -1, _("_matchfiles requires at least one argument"))
896 l = getargs(x, 1, -1, _("_matchfiles requires at least one argument"))
897 pats, inc, exc = [], [], []
897 pats, inc, exc = [], [], []
898 hasset = False
898 hasset = False
899 rev, default = None, None
899 rev, default = None, None
900 for arg in l:
900 for arg in l:
901 # i18n: "_matchfiles" is a keyword
901 # i18n: "_matchfiles" is a keyword
902 s = getstring(arg, _("_matchfiles requires string arguments"))
902 s = getstring(arg, _("_matchfiles requires string arguments"))
903 prefix, value = s[:2], s[2:]
903 prefix, value = s[:2], s[2:]
904 if prefix == 'p:':
904 if prefix == 'p:':
905 pats.append(value)
905 pats.append(value)
906 elif prefix == 'i:':
906 elif prefix == 'i:':
907 inc.append(value)
907 inc.append(value)
908 elif prefix == 'x:':
908 elif prefix == 'x:':
909 exc.append(value)
909 exc.append(value)
910 elif prefix == 'r:':
910 elif prefix == 'r:':
911 if rev is not None:
911 if rev is not None:
912 # i18n: "_matchfiles" is a keyword
912 # i18n: "_matchfiles" is a keyword
913 raise error.ParseError(_('_matchfiles expected at most one '
913 raise error.ParseError(_('_matchfiles expected at most one '
914 'revision'))
914 'revision'))
915 rev = value
915 rev = value
916 elif prefix == 'd:':
916 elif prefix == 'd:':
917 if default is not None:
917 if default is not None:
918 # i18n: "_matchfiles" is a keyword
918 # i18n: "_matchfiles" is a keyword
919 raise error.ParseError(_('_matchfiles expected at most one '
919 raise error.ParseError(_('_matchfiles expected at most one '
920 'default mode'))
920 'default mode'))
921 default = value
921 default = value
922 else:
922 else:
923 # i18n: "_matchfiles" is a keyword
923 # i18n: "_matchfiles" is a keyword
924 raise error.ParseError(_('invalid _matchfiles prefix: %s') % prefix)
924 raise error.ParseError(_('invalid _matchfiles prefix: %s') % prefix)
925 if not hasset and matchmod.patkind(value) == 'set':
925 if not hasset and matchmod.patkind(value) == 'set':
926 hasset = True
926 hasset = True
927 if not default:
927 if not default:
928 default = 'glob'
928 default = 'glob'
929
929
930 def matches(x):
930 def matches(x):
931 m = None
931 m = None
932 c = repo[x]
932 c = repo[x]
933 if not m or (hasset and rev is None):
933 if not m or (hasset and rev is None):
934 ctx = c
934 ctx = c
935 if rev is not None:
935 if rev is not None:
936 ctx = repo[rev or None]
936 ctx = repo[rev or None]
937 m = matchmod.match(repo.root, repo.getcwd(), pats, include=inc,
937 m = matchmod.match(repo.root, repo.getcwd(), pats, include=inc,
938 exclude=exc, ctx=ctx, default=default)
938 exclude=exc, ctx=ctx, default=default)
939 for f in c.files():
939 for f in c.files():
940 if m(f):
940 if m(f):
941 return True
941 return True
942 return False
942 return False
943
943
944 return subset.filter(matches)
944 return subset.filter(matches)
945
945
946 def hasfile(repo, subset, x):
946 def hasfile(repo, subset, x):
947 """``file(pattern)``
947 """``file(pattern)``
948 Changesets affecting files matched by pattern.
948 Changesets affecting files matched by pattern.
949
949
950 For a faster but less accurate result, consider using ``filelog()``
950 For a faster but less accurate result, consider using ``filelog()``
951 instead.
951 instead.
952
952
953 This predicate uses ``glob:`` as the default kind of pattern.
953 This predicate uses ``glob:`` as the default kind of pattern.
954 """
954 """
955 # i18n: "file" is a keyword
955 # i18n: "file" is a keyword
956 pat = getstring(x, _("file requires a pattern"))
956 pat = getstring(x, _("file requires a pattern"))
957 return _matchfiles(repo, subset, ('string', 'p:' + pat))
957 return _matchfiles(repo, subset, ('string', 'p:' + pat))
958
958
959 def head(repo, subset, x):
959 def head(repo, subset, x):
960 """``head()``
960 """``head()``
961 Changeset is a named branch head.
961 Changeset is a named branch head.
962 """
962 """
963 # i18n: "head" is a keyword
963 # i18n: "head" is a keyword
964 getargs(x, 0, 0, _("head takes no arguments"))
964 getargs(x, 0, 0, _("head takes no arguments"))
965 hs = set()
965 hs = set()
966 for b, ls in repo.branchmap().iteritems():
966 for b, ls in repo.branchmap().iteritems():
967 hs.update(repo[h].rev() for h in ls)
967 hs.update(repo[h].rev() for h in ls)
968 return baseset(hs).filter(subset.__contains__)
968 return baseset(hs).filter(subset.__contains__)
969
969
970 def heads(repo, subset, x):
970 def heads(repo, subset, x):
971 """``heads(set)``
971 """``heads(set)``
972 Members of set with no children in set.
972 Members of set with no children in set.
973 """
973 """
974 s = getset(repo, subset, x)
974 s = getset(repo, subset, x)
975 ps = parents(repo, subset, x)
975 ps = parents(repo, subset, x)
976 return s - ps
976 return s - ps
977
977
978 def hidden(repo, subset, x):
978 def hidden(repo, subset, x):
979 """``hidden()``
979 """``hidden()``
980 Hidden changesets.
980 Hidden changesets.
981 """
981 """
982 # i18n: "hidden" is a keyword
982 # i18n: "hidden" is a keyword
983 getargs(x, 0, 0, _("hidden takes no arguments"))
983 getargs(x, 0, 0, _("hidden takes no arguments"))
984 hiddenrevs = repoview.filterrevs(repo, 'visible')
984 hiddenrevs = repoview.filterrevs(repo, 'visible')
985 return subset & hiddenrevs
985 return subset & hiddenrevs
986
986
987 def keyword(repo, subset, x):
987 def keyword(repo, subset, x):
988 """``keyword(string)``
988 """``keyword(string)``
989 Search commit message, user name, and names of changed files for
989 Search commit message, user name, and names of changed files for
990 string. The match is case-insensitive.
990 string. The match is case-insensitive.
991 """
991 """
992 # i18n: "keyword" is a keyword
992 # i18n: "keyword" is a keyword
993 kw = encoding.lower(getstring(x, _("keyword requires a string")))
993 kw = encoding.lower(getstring(x, _("keyword requires a string")))
994
994
995 def matches(r):
995 def matches(r):
996 c = repo[r]
996 c = repo[r]
997 return util.any(kw in encoding.lower(t) for t in c.files() + [c.user(),
997 return util.any(kw in encoding.lower(t) for t in c.files() + [c.user(),
998 c.description()])
998 c.description()])
999
999
1000 return subset.filter(matches)
1000 return subset.filter(matches)
1001
1001
1002 def limit(repo, subset, x):
1002 def limit(repo, subset, x):
1003 """``limit(set, [n])``
1003 """``limit(set, [n])``
1004 First n members of set, defaulting to 1.
1004 First n members of set, defaulting to 1.
1005 """
1005 """
1006 # i18n: "limit" is a keyword
1006 # i18n: "limit" is a keyword
1007 l = getargs(x, 1, 2, _("limit requires one or two arguments"))
1007 l = getargs(x, 1, 2, _("limit requires one or two arguments"))
1008 try:
1008 try:
1009 lim = 1
1009 lim = 1
1010 if len(l) == 2:
1010 if len(l) == 2:
1011 # i18n: "limit" is a keyword
1011 # i18n: "limit" is a keyword
1012 lim = int(getstring(l[1], _("limit requires a number")))
1012 lim = int(getstring(l[1], _("limit requires a number")))
1013 except (TypeError, ValueError):
1013 except (TypeError, ValueError):
1014 # i18n: "limit" is a keyword
1014 # i18n: "limit" is a keyword
1015 raise error.ParseError(_("limit expects a number"))
1015 raise error.ParseError(_("limit expects a number"))
1016 ss = subset.set()
1016 ss = subset.set()
1017 os = getset(repo, spanset(repo), l[0])
1017 os = getset(repo, spanset(repo), l[0])
1018 bs = baseset([])
1018 bs = baseset([])
1019 it = iter(os)
1019 it = iter(os)
1020 for x in xrange(lim):
1020 for x in xrange(lim):
1021 try:
1021 try:
1022 y = it.next()
1022 y = it.next()
1023 if y in ss:
1023 if y in ss:
1024 bs.append(y)
1024 bs.append(y)
1025 except (StopIteration):
1025 except (StopIteration):
1026 break
1026 break
1027 return bs
1027 return bs
1028
1028
1029 def last(repo, subset, x):
1029 def last(repo, subset, x):
1030 """``last(set, [n])``
1030 """``last(set, [n])``
1031 Last n members of set, defaulting to 1.
1031 Last n members of set, defaulting to 1.
1032 """
1032 """
1033 # i18n: "last" is a keyword
1033 # i18n: "last" is a keyword
1034 l = getargs(x, 1, 2, _("last requires one or two arguments"))
1034 l = getargs(x, 1, 2, _("last requires one or two arguments"))
1035 try:
1035 try:
1036 lim = 1
1036 lim = 1
1037 if len(l) == 2:
1037 if len(l) == 2:
1038 # i18n: "last" is a keyword
1038 # i18n: "last" is a keyword
1039 lim = int(getstring(l[1], _("last requires a number")))
1039 lim = int(getstring(l[1], _("last requires a number")))
1040 except (TypeError, ValueError):
1040 except (TypeError, ValueError):
1041 # i18n: "last" is a keyword
1041 # i18n: "last" is a keyword
1042 raise error.ParseError(_("last expects a number"))
1042 raise error.ParseError(_("last expects a number"))
1043 ss = subset.set()
1043 ss = subset.set()
1044 os = getset(repo, spanset(repo), l[0])
1044 os = getset(repo, spanset(repo), l[0])
1045 os.reverse()
1045 os.reverse()
1046 bs = baseset([])
1046 bs = baseset([])
1047 it = iter(os)
1047 it = iter(os)
1048 for x in xrange(lim):
1048 for x in xrange(lim):
1049 try:
1049 try:
1050 y = it.next()
1050 y = it.next()
1051 if y in ss:
1051 if y in ss:
1052 bs.append(y)
1052 bs.append(y)
1053 except (StopIteration):
1053 except (StopIteration):
1054 break
1054 break
1055 return bs
1055 return bs
1056
1056
1057 def maxrev(repo, subset, x):
1057 def maxrev(repo, subset, x):
1058 """``max(set)``
1058 """``max(set)``
1059 Changeset with highest revision number in set.
1059 Changeset with highest revision number in set.
1060 """
1060 """
1061 os = getset(repo, spanset(repo), x)
1061 os = getset(repo, spanset(repo), x)
1062 if os:
1062 if os:
1063 m = os.max()
1063 m = os.max()
1064 if m in subset:
1064 if m in subset:
1065 return baseset([m])
1065 return baseset([m])
1066 return baseset([])
1066 return baseset([])
1067
1067
1068 def merge(repo, subset, x):
1068 def merge(repo, subset, x):
1069 """``merge()``
1069 """``merge()``
1070 Changeset is a merge changeset.
1070 Changeset is a merge changeset.
1071 """
1071 """
1072 # i18n: "merge" is a keyword
1072 # i18n: "merge" is a keyword
1073 getargs(x, 0, 0, _("merge takes no arguments"))
1073 getargs(x, 0, 0, _("merge takes no arguments"))
1074 cl = repo.changelog
1074 cl = repo.changelog
1075 return subset.filter(lambda r: cl.parentrevs(r)[1] != -1)
1075 return subset.filter(lambda r: cl.parentrevs(r)[1] != -1)
1076
1076
1077 def branchpoint(repo, subset, x):
1077 def branchpoint(repo, subset, x):
1078 """``branchpoint()``
1078 """``branchpoint()``
1079 Changesets with more than one child.
1079 Changesets with more than one child.
1080 """
1080 """
1081 # i18n: "branchpoint" is a keyword
1081 # i18n: "branchpoint" is a keyword
1082 getargs(x, 0, 0, _("branchpoint takes no arguments"))
1082 getargs(x, 0, 0, _("branchpoint takes no arguments"))
1083 cl = repo.changelog
1083 cl = repo.changelog
1084 if not subset:
1084 if not subset:
1085 return baseset([])
1085 return baseset([])
1086 baserev = min(subset)
1086 baserev = min(subset)
1087 parentscount = [0]*(len(repo) - baserev)
1087 parentscount = [0]*(len(repo) - baserev)
1088 for r in cl.revs(start=baserev + 1):
1088 for r in cl.revs(start=baserev + 1):
1089 for p in cl.parentrevs(r):
1089 for p in cl.parentrevs(r):
1090 if p >= baserev:
1090 if p >= baserev:
1091 parentscount[p - baserev] += 1
1091 parentscount[p - baserev] += 1
1092 return subset.filter(lambda r: parentscount[r - baserev] > 1)
1092 return subset.filter(lambda r: parentscount[r - baserev] > 1)
1093
1093
1094 def minrev(repo, subset, x):
1094 def minrev(repo, subset, x):
1095 """``min(set)``
1095 """``min(set)``
1096 Changeset with lowest revision number in set.
1096 Changeset with lowest revision number in set.
1097 """
1097 """
1098 os = getset(repo, spanset(repo), x)
1098 os = getset(repo, spanset(repo), x)
1099 if os:
1099 if os:
1100 m = os.min()
1100 m = os.min()
1101 if m in subset:
1101 if m in subset:
1102 return baseset([m])
1102 return baseset([m])
1103 return baseset([])
1103 return baseset([])
1104
1104
1105 def modifies(repo, subset, x):
1105 def modifies(repo, subset, x):
1106 """``modifies(pattern)``
1106 """``modifies(pattern)``
1107 Changesets modifying files matched by pattern.
1107 Changesets modifying files matched by pattern.
1108
1108
1109 The pattern without explicit kind like ``glob:`` is expected to be
1109 The pattern without explicit kind like ``glob:`` is expected to be
1110 relative to the current directory and match against a file or a
1110 relative to the current directory and match against a file or a
1111 directory.
1111 directory.
1112 """
1112 """
1113 # i18n: "modifies" is a keyword
1113 # i18n: "modifies" is a keyword
1114 pat = getstring(x, _("modifies requires a pattern"))
1114 pat = getstring(x, _("modifies requires a pattern"))
1115 return checkstatus(repo, subset, pat, 0)
1115 return checkstatus(repo, subset, pat, 0)
1116
1116
1117 def node_(repo, subset, x):
1117 def node_(repo, subset, x):
1118 """``id(string)``
1118 """``id(string)``
1119 Revision non-ambiguously specified by the given hex string prefix.
1119 Revision non-ambiguously specified by the given hex string prefix.
1120 """
1120 """
1121 # i18n: "id" is a keyword
1121 # i18n: "id" is a keyword
1122 l = getargs(x, 1, 1, _("id requires one argument"))
1122 l = getargs(x, 1, 1, _("id requires one argument"))
1123 # i18n: "id" is a keyword
1123 # i18n: "id" is a keyword
1124 n = getstring(l[0], _("id requires a string"))
1124 n = getstring(l[0], _("id requires a string"))
1125 if len(n) == 40:
1125 if len(n) == 40:
1126 rn = repo[n].rev()
1126 rn = repo[n].rev()
1127 else:
1127 else:
1128 rn = None
1128 rn = None
1129 pm = repo.changelog._partialmatch(n)
1129 pm = repo.changelog._partialmatch(n)
1130 if pm is not None:
1130 if pm is not None:
1131 rn = repo.changelog.rev(pm)
1131 rn = repo.changelog.rev(pm)
1132
1132
1133 return subset.filter(lambda r: r == rn)
1133 return subset.filter(lambda r: r == rn)
1134
1134
1135 def obsolete(repo, subset, x):
1135 def obsolete(repo, subset, x):
1136 """``obsolete()``
1136 """``obsolete()``
1137 Mutable changeset with a newer version."""
1137 Mutable changeset with a newer version."""
1138 # i18n: "obsolete" is a keyword
1138 # i18n: "obsolete" is a keyword
1139 getargs(x, 0, 0, _("obsolete takes no arguments"))
1139 getargs(x, 0, 0, _("obsolete takes no arguments"))
1140 obsoletes = obsmod.getrevs(repo, 'obsolete')
1140 obsoletes = obsmod.getrevs(repo, 'obsolete')
1141 return subset & obsoletes
1141 return subset & obsoletes
1142
1142
1143 def origin(repo, subset, x):
1143 def origin(repo, subset, x):
1144 """``origin([set])``
1144 """``origin([set])``
1145 Changesets that were specified as a source for the grafts, transplants or
1145 Changesets that were specified as a source for the grafts, transplants or
1146 rebases that created the given revisions. Omitting the optional set is the
1146 rebases that created the given revisions. Omitting the optional set is the
1147 same as passing all(). If a changeset created by these operations is itself
1147 same as passing all(). If a changeset created by these operations is itself
1148 specified as a source for one of these operations, only the source changeset
1148 specified as a source for one of these operations, only the source changeset
1149 for the first operation is selected.
1149 for the first operation is selected.
1150 """
1150 """
1151 if x is not None:
1151 if x is not None:
1152 args = getset(repo, spanset(repo), x).set()
1152 args = getset(repo, spanset(repo), x).set()
1153 else:
1153 else:
1154 args = getall(repo, spanset(repo), x).set()
1154 args = getall(repo, spanset(repo), x).set()
1155
1155
1156 def _firstsrc(rev):
1156 def _firstsrc(rev):
1157 src = _getrevsource(repo, rev)
1157 src = _getrevsource(repo, rev)
1158 if src is None:
1158 if src is None:
1159 return None
1159 return None
1160
1160
1161 while True:
1161 while True:
1162 prev = _getrevsource(repo, src)
1162 prev = _getrevsource(repo, src)
1163
1163
1164 if prev is None:
1164 if prev is None:
1165 return src
1165 return src
1166 src = prev
1166 src = prev
1167
1167
1168 o = set([_firstsrc(r) for r in args])
1168 o = set([_firstsrc(r) for r in args])
1169 o -= set([None])
1169 o -= set([None])
1170 return subset.filter(o.__contains__)
1170 return subset.filter(o.__contains__)
1171
1171
1172 def outgoing(repo, subset, x):
1172 def outgoing(repo, subset, x):
1173 """``outgoing([path])``
1173 """``outgoing([path])``
1174 Changesets not found in the specified destination repository, or the
1174 Changesets not found in the specified destination repository, or the
1175 default push location.
1175 default push location.
1176 """
1176 """
1177 import hg # avoid start-up nasties
1177 import hg # avoid start-up nasties
1178 # i18n: "outgoing" is a keyword
1178 # i18n: "outgoing" is a keyword
1179 l = getargs(x, 0, 1, _("outgoing takes one or no arguments"))
1179 l = getargs(x, 0, 1, _("outgoing takes one or no arguments"))
1180 # i18n: "outgoing" is a keyword
1180 # i18n: "outgoing" is a keyword
1181 dest = l and getstring(l[0], _("outgoing requires a repository path")) or ''
1181 dest = l and getstring(l[0], _("outgoing requires a repository path")) or ''
1182 dest = repo.ui.expandpath(dest or 'default-push', dest or 'default')
1182 dest = repo.ui.expandpath(dest or 'default-push', dest or 'default')
1183 dest, branches = hg.parseurl(dest)
1183 dest, branches = hg.parseurl(dest)
1184 revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
1184 revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
1185 if revs:
1185 if revs:
1186 revs = [repo.lookup(rev) for rev in revs]
1186 revs = [repo.lookup(rev) for rev in revs]
1187 other = hg.peer(repo, {}, dest)
1187 other = hg.peer(repo, {}, dest)
1188 repo.ui.pushbuffer()
1188 repo.ui.pushbuffer()
1189 outgoing = discovery.findcommonoutgoing(repo, other, onlyheads=revs)
1189 outgoing = discovery.findcommonoutgoing(repo, other, onlyheads=revs)
1190 repo.ui.popbuffer()
1190 repo.ui.popbuffer()
1191 cl = repo.changelog
1191 cl = repo.changelog
1192 o = set([cl.rev(r) for r in outgoing.missing])
1192 o = set([cl.rev(r) for r in outgoing.missing])
1193 return subset & o
1193 return subset & o
1194
1194
1195 def p1(repo, subset, x):
1195 def p1(repo, subset, x):
1196 """``p1([set])``
1196 """``p1([set])``
1197 First parent of changesets in set, or the working directory.
1197 First parent of changesets in set, or the working directory.
1198 """
1198 """
1199 if x is None:
1199 if x is None:
1200 p = repo[x].p1().rev()
1200 p = repo[x].p1().rev()
1201 return subset.filter(lambda r: r == p)
1201 return subset.filter(lambda r: r == p)
1202
1202
1203 ps = set()
1203 ps = set()
1204 cl = repo.changelog
1204 cl = repo.changelog
1205 for r in getset(repo, spanset(repo), x):
1205 for r in getset(repo, spanset(repo), x):
1206 ps.add(cl.parentrevs(r)[0])
1206 ps.add(cl.parentrevs(r)[0])
1207 ps -= set([node.nullrev])
1207 ps -= set([node.nullrev])
1208 return subset & ps
1208 return subset & ps
1209
1209
1210 def p2(repo, subset, x):
1210 def p2(repo, subset, x):
1211 """``p2([set])``
1211 """``p2([set])``
1212 Second parent of changesets in set, or the working directory.
1212 Second parent of changesets in set, or the working directory.
1213 """
1213 """
1214 if x is None:
1214 if x is None:
1215 ps = repo[x].parents()
1215 ps = repo[x].parents()
1216 try:
1216 try:
1217 p = ps[1].rev()
1217 p = ps[1].rev()
1218 return subset.filter(lambda r: r == p)
1218 return subset.filter(lambda r: r == p)
1219 except IndexError:
1219 except IndexError:
1220 return baseset([])
1220 return baseset([])
1221
1221
1222 ps = set()
1222 ps = set()
1223 cl = repo.changelog
1223 cl = repo.changelog
1224 for r in getset(repo, spanset(repo), x):
1224 for r in getset(repo, spanset(repo), x):
1225 ps.add(cl.parentrevs(r)[1])
1225 ps.add(cl.parentrevs(r)[1])
1226 ps -= set([node.nullrev])
1226 ps -= set([node.nullrev])
1227 return subset & ps
1227 return subset & ps
1228
1228
1229 def parents(repo, subset, x):
1229 def parents(repo, subset, x):
1230 """``parents([set])``
1230 """``parents([set])``
1231 The set of all parents for all changesets in set, or the working directory.
1231 The set of all parents for all changesets in set, or the working directory.
1232 """
1232 """
1233 if x is None:
1233 if x is None:
1234 ps = set(p.rev() for p in repo[x].parents())
1234 ps = set(p.rev() for p in repo[x].parents())
1235 else:
1235 else:
1236 ps = set()
1236 ps = set()
1237 cl = repo.changelog
1237 cl = repo.changelog
1238 for r in getset(repo, spanset(repo), x):
1238 for r in getset(repo, spanset(repo), x):
1239 ps.update(cl.parentrevs(r))
1239 ps.update(cl.parentrevs(r))
1240 ps -= set([node.nullrev])
1240 ps -= set([node.nullrev])
1241 return baseset(ps) & subset
1241 return baseset(ps) & subset
1242
1242
1243 def parentspec(repo, subset, x, n):
1243 def parentspec(repo, subset, x, n):
1244 """``set^0``
1244 """``set^0``
1245 The set.
1245 The set.
1246 ``set^1`` (or ``set^``), ``set^2``
1246 ``set^1`` (or ``set^``), ``set^2``
1247 First or second parent, respectively, of all changesets in set.
1247 First or second parent, respectively, of all changesets in set.
1248 """
1248 """
1249 try:
1249 try:
1250 n = int(n[1])
1250 n = int(n[1])
1251 if n not in (0, 1, 2):
1251 if n not in (0, 1, 2):
1252 raise ValueError
1252 raise ValueError
1253 except (TypeError, ValueError):
1253 except (TypeError, ValueError):
1254 raise error.ParseError(_("^ expects a number 0, 1, or 2"))
1254 raise error.ParseError(_("^ expects a number 0, 1, or 2"))
1255 ps = set()
1255 ps = set()
1256 cl = repo.changelog
1256 cl = repo.changelog
1257 for r in getset(repo, baseset(cl), x):
1257 for r in getset(repo, baseset(cl), x):
1258 if n == 0:
1258 if n == 0:
1259 ps.add(r)
1259 ps.add(r)
1260 elif n == 1:
1260 elif n == 1:
1261 ps.add(cl.parentrevs(r)[0])
1261 ps.add(cl.parentrevs(r)[0])
1262 elif n == 2:
1262 elif n == 2:
1263 parents = cl.parentrevs(r)
1263 parents = cl.parentrevs(r)
1264 if len(parents) > 1:
1264 if len(parents) > 1:
1265 ps.add(parents[1])
1265 ps.add(parents[1])
1266 return subset & ps
1266 return subset & ps
1267
1267
1268 def present(repo, subset, x):
1268 def present(repo, subset, x):
1269 """``present(set)``
1269 """``present(set)``
1270 An empty set, if any revision in set isn't found; otherwise,
1270 An empty set, if any revision in set isn't found; otherwise,
1271 all revisions in set.
1271 all revisions in set.
1272
1272
1273 If any of specified revisions is not present in the local repository,
1273 If any of specified revisions is not present in the local repository,
1274 the query is normally aborted. But this predicate allows the query
1274 the query is normally aborted. But this predicate allows the query
1275 to continue even in such cases.
1275 to continue even in such cases.
1276 """
1276 """
1277 try:
1277 try:
1278 return getset(repo, subset, x)
1278 return getset(repo, subset, x)
1279 except error.RepoLookupError:
1279 except error.RepoLookupError:
1280 return baseset([])
1280 return baseset([])
1281
1281
1282 def public(repo, subset, x):
1282 def public(repo, subset, x):
1283 """``public()``
1283 """``public()``
1284 Changeset in public phase."""
1284 Changeset in public phase."""
1285 # i18n: "public" is a keyword
1285 # i18n: "public" is a keyword
1286 getargs(x, 0, 0, _("public takes no arguments"))
1286 getargs(x, 0, 0, _("public takes no arguments"))
1287 pc = repo._phasecache
1287 pc = repo._phasecache
1288 return subset.filter(lambda r: pc.phase(repo, r) == phases.public)
1288 return subset.filter(lambda r: pc.phase(repo, r) == phases.public)
1289
1289
1290 def remote(repo, subset, x):
1290 def remote(repo, subset, x):
1291 """``remote([id [,path]])``
1291 """``remote([id [,path]])``
1292 Local revision that corresponds to the given identifier in a
1292 Local revision that corresponds to the given identifier in a
1293 remote repository, if present. Here, the '.' identifier is a
1293 remote repository, if present. Here, the '.' identifier is a
1294 synonym for the current local branch.
1294 synonym for the current local branch.
1295 """
1295 """
1296
1296
1297 import hg # avoid start-up nasties
1297 import hg # avoid start-up nasties
1298 # i18n: "remote" is a keyword
1298 # i18n: "remote" is a keyword
1299 l = getargs(x, 0, 2, _("remote takes one, two or no arguments"))
1299 l = getargs(x, 0, 2, _("remote takes one, two or no arguments"))
1300
1300
1301 q = '.'
1301 q = '.'
1302 if len(l) > 0:
1302 if len(l) > 0:
1303 # i18n: "remote" is a keyword
1303 # i18n: "remote" is a keyword
1304 q = getstring(l[0], _("remote requires a string id"))
1304 q = getstring(l[0], _("remote requires a string id"))
1305 if q == '.':
1305 if q == '.':
1306 q = repo['.'].branch()
1306 q = repo['.'].branch()
1307
1307
1308 dest = ''
1308 dest = ''
1309 if len(l) > 1:
1309 if len(l) > 1:
1310 # i18n: "remote" is a keyword
1310 # i18n: "remote" is a keyword
1311 dest = getstring(l[1], _("remote requires a repository path"))
1311 dest = getstring(l[1], _("remote requires a repository path"))
1312 dest = repo.ui.expandpath(dest or 'default')
1312 dest = repo.ui.expandpath(dest or 'default')
1313 dest, branches = hg.parseurl(dest)
1313 dest, branches = hg.parseurl(dest)
1314 revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
1314 revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
1315 if revs:
1315 if revs:
1316 revs = [repo.lookup(rev) for rev in revs]
1316 revs = [repo.lookup(rev) for rev in revs]
1317 other = hg.peer(repo, {}, dest)
1317 other = hg.peer(repo, {}, dest)
1318 n = other.lookup(q)
1318 n = other.lookup(q)
1319 if n in repo:
1319 if n in repo:
1320 r = repo[n].rev()
1320 r = repo[n].rev()
1321 if r in subset:
1321 if r in subset:
1322 return baseset([r])
1322 return baseset([r])
1323 return baseset([])
1323 return baseset([])
1324
1324
1325 def removes(repo, subset, x):
1325 def removes(repo, subset, x):
1326 """``removes(pattern)``
1326 """``removes(pattern)``
1327 Changesets which remove files matching pattern.
1327 Changesets which remove files matching pattern.
1328
1328
1329 The pattern without explicit kind like ``glob:`` is expected to be
1329 The pattern without explicit kind like ``glob:`` is expected to be
1330 relative to the current directory and match against a file or a
1330 relative to the current directory and match against a file or a
1331 directory.
1331 directory.
1332 """
1332 """
1333 # i18n: "removes" is a keyword
1333 # i18n: "removes" is a keyword
1334 pat = getstring(x, _("removes requires a pattern"))
1334 pat = getstring(x, _("removes requires a pattern"))
1335 return checkstatus(repo, subset, pat, 2)
1335 return checkstatus(repo, subset, pat, 2)
1336
1336
1337 def rev(repo, subset, x):
1337 def rev(repo, subset, x):
1338 """``rev(number)``
1338 """``rev(number)``
1339 Revision with the given numeric identifier.
1339 Revision with the given numeric identifier.
1340 """
1340 """
1341 # i18n: "rev" is a keyword
1341 # i18n: "rev" is a keyword
1342 l = getargs(x, 1, 1, _("rev requires one argument"))
1342 l = getargs(x, 1, 1, _("rev requires one argument"))
1343 try:
1343 try:
1344 # i18n: "rev" is a keyword
1344 # i18n: "rev" is a keyword
1345 l = int(getstring(l[0], _("rev requires a number")))
1345 l = int(getstring(l[0], _("rev requires a number")))
1346 except (TypeError, ValueError):
1346 except (TypeError, ValueError):
1347 # i18n: "rev" is a keyword
1347 # i18n: "rev" is a keyword
1348 raise error.ParseError(_("rev expects a number"))
1348 raise error.ParseError(_("rev expects a number"))
1349 return subset.filter(lambda r: r == l)
1349 return subset.filter(lambda r: r == l)
1350
1350
1351 def matching(repo, subset, x):
1351 def matching(repo, subset, x):
1352 """``matching(revision [, field])``
1352 """``matching(revision [, field])``
1353 Changesets in which a given set of fields match the set of fields in the
1353 Changesets in which a given set of fields match the set of fields in the
1354 selected revision or set.
1354 selected revision or set.
1355
1355
1356 To match more than one field pass the list of fields to match separated
1356 To match more than one field pass the list of fields to match separated
1357 by spaces (e.g. ``author description``).
1357 by spaces (e.g. ``author description``).
1358
1358
1359 Valid fields are most regular revision fields and some special fields.
1359 Valid fields are most regular revision fields and some special fields.
1360
1360
1361 Regular revision fields are ``description``, ``author``, ``branch``,
1361 Regular revision fields are ``description``, ``author``, ``branch``,
1362 ``date``, ``files``, ``phase``, ``parents``, ``substate``, ``user``
1362 ``date``, ``files``, ``phase``, ``parents``, ``substate``, ``user``
1363 and ``diff``.
1363 and ``diff``.
1364 Note that ``author`` and ``user`` are synonyms. ``diff`` refers to the
1364 Note that ``author`` and ``user`` are synonyms. ``diff`` refers to the
1365 contents of the revision. Two revisions matching their ``diff`` will
1365 contents of the revision. Two revisions matching their ``diff`` will
1366 also match their ``files``.
1366 also match their ``files``.
1367
1367
1368 Special fields are ``summary`` and ``metadata``:
1368 Special fields are ``summary`` and ``metadata``:
1369 ``summary`` matches the first line of the description.
1369 ``summary`` matches the first line of the description.
1370 ``metadata`` is equivalent to matching ``description user date``
1370 ``metadata`` is equivalent to matching ``description user date``
1371 (i.e. it matches the main metadata fields).
1371 (i.e. it matches the main metadata fields).
1372
1372
1373 ``metadata`` is the default field which is used when no fields are
1373 ``metadata`` is the default field which is used when no fields are
1374 specified. You can match more than one field at a time.
1374 specified. You can match more than one field at a time.
1375 """
1375 """
1376 # i18n: "matching" is a keyword
1376 # i18n: "matching" is a keyword
1377 l = getargs(x, 1, 2, _("matching takes 1 or 2 arguments"))
1377 l = getargs(x, 1, 2, _("matching takes 1 or 2 arguments"))
1378
1378
1379 revs = getset(repo, baseset(repo.changelog), l[0])
1379 revs = getset(repo, baseset(repo.changelog), l[0])
1380
1380
1381 fieldlist = ['metadata']
1381 fieldlist = ['metadata']
1382 if len(l) > 1:
1382 if len(l) > 1:
1383 fieldlist = getstring(l[1],
1383 fieldlist = getstring(l[1],
1384 # i18n: "matching" is a keyword
1384 # i18n: "matching" is a keyword
1385 _("matching requires a string "
1385 _("matching requires a string "
1386 "as its second argument")).split()
1386 "as its second argument")).split()
1387
1387
1388 # Make sure that there are no repeated fields,
1388 # Make sure that there are no repeated fields,
1389 # expand the 'special' 'metadata' field type
1389 # expand the 'special' 'metadata' field type
1390 # and check the 'files' whenever we check the 'diff'
1390 # and check the 'files' whenever we check the 'diff'
1391 fields = []
1391 fields = []
1392 for field in fieldlist:
1392 for field in fieldlist:
1393 if field == 'metadata':
1393 if field == 'metadata':
1394 fields += ['user', 'description', 'date']
1394 fields += ['user', 'description', 'date']
1395 elif field == 'diff':
1395 elif field == 'diff':
1396 # a revision matching the diff must also match the files
1396 # a revision matching the diff must also match the files
1397 # since matching the diff is very costly, make sure to
1397 # since matching the diff is very costly, make sure to
1398 # also match the files first
1398 # also match the files first
1399 fields += ['files', 'diff']
1399 fields += ['files', 'diff']
1400 else:
1400 else:
1401 if field == 'author':
1401 if field == 'author':
1402 field = 'user'
1402 field = 'user'
1403 fields.append(field)
1403 fields.append(field)
1404 fields = set(fields)
1404 fields = set(fields)
1405 if 'summary' in fields and 'description' in fields:
1405 if 'summary' in fields and 'description' in fields:
1406 # If a revision matches its description it also matches its summary
1406 # If a revision matches its description it also matches its summary
1407 fields.discard('summary')
1407 fields.discard('summary')
1408
1408
1409 # We may want to match more than one field
1409 # We may want to match more than one field
1410 # Not all fields take the same amount of time to be matched
1410 # Not all fields take the same amount of time to be matched
1411 # Sort the selected fields in order of increasing matching cost
1411 # Sort the selected fields in order of increasing matching cost
1412 fieldorder = ['phase', 'parents', 'user', 'date', 'branch', 'summary',
1412 fieldorder = ['phase', 'parents', 'user', 'date', 'branch', 'summary',
1413 'files', 'description', 'substate', 'diff']
1413 'files', 'description', 'substate', 'diff']
1414 def fieldkeyfunc(f):
1414 def fieldkeyfunc(f):
1415 try:
1415 try:
1416 return fieldorder.index(f)
1416 return fieldorder.index(f)
1417 except ValueError:
1417 except ValueError:
1418 # assume an unknown field is very costly
1418 # assume an unknown field is very costly
1419 return len(fieldorder)
1419 return len(fieldorder)
1420 fields = list(fields)
1420 fields = list(fields)
1421 fields.sort(key=fieldkeyfunc)
1421 fields.sort(key=fieldkeyfunc)
1422
1422
1423 # Each field will be matched with its own "getfield" function
1423 # Each field will be matched with its own "getfield" function
1424 # which will be added to the getfieldfuncs array of functions
1424 # which will be added to the getfieldfuncs array of functions
1425 getfieldfuncs = []
1425 getfieldfuncs = []
1426 _funcs = {
1426 _funcs = {
1427 'user': lambda r: repo[r].user(),
1427 'user': lambda r: repo[r].user(),
1428 'branch': lambda r: repo[r].branch(),
1428 'branch': lambda r: repo[r].branch(),
1429 'date': lambda r: repo[r].date(),
1429 'date': lambda r: repo[r].date(),
1430 'description': lambda r: repo[r].description(),
1430 'description': lambda r: repo[r].description(),
1431 'files': lambda r: repo[r].files(),
1431 'files': lambda r: repo[r].files(),
1432 'parents': lambda r: repo[r].parents(),
1432 'parents': lambda r: repo[r].parents(),
1433 'phase': lambda r: repo[r].phase(),
1433 'phase': lambda r: repo[r].phase(),
1434 'substate': lambda r: repo[r].substate,
1434 'substate': lambda r: repo[r].substate,
1435 'summary': lambda r: repo[r].description().splitlines()[0],
1435 'summary': lambda r: repo[r].description().splitlines()[0],
1436 'diff': lambda r: list(repo[r].diff(git=True),)
1436 'diff': lambda r: list(repo[r].diff(git=True),)
1437 }
1437 }
1438 for info in fields:
1438 for info in fields:
1439 getfield = _funcs.get(info, None)
1439 getfield = _funcs.get(info, None)
1440 if getfield is None:
1440 if getfield is None:
1441 raise error.ParseError(
1441 raise error.ParseError(
1442 # i18n: "matching" is a keyword
1442 # i18n: "matching" is a keyword
1443 _("unexpected field name passed to matching: %s") % info)
1443 _("unexpected field name passed to matching: %s") % info)
1444 getfieldfuncs.append(getfield)
1444 getfieldfuncs.append(getfield)
1445 # convert the getfield array of functions into a "getinfo" function
1445 # convert the getfield array of functions into a "getinfo" function
1446 # which returns an array of field values (or a single value if there
1446 # which returns an array of field values (or a single value if there
1447 # is only one field to match)
1447 # is only one field to match)
1448 getinfo = lambda r: [f(r) for f in getfieldfuncs]
1448 getinfo = lambda r: [f(r) for f in getfieldfuncs]
1449
1449
1450 def matches(x):
1450 def matches(x):
1451 for rev in revs:
1451 for rev in revs:
1452 target = getinfo(rev)
1452 target = getinfo(rev)
1453 match = True
1453 match = True
1454 for n, f in enumerate(getfieldfuncs):
1454 for n, f in enumerate(getfieldfuncs):
1455 if target[n] != f(x):
1455 if target[n] != f(x):
1456 match = False
1456 match = False
1457 if match:
1457 if match:
1458 return True
1458 return True
1459 return False
1459 return False
1460
1460
1461 return subset.filter(matches)
1461 return subset.filter(matches)
1462
1462
1463 def reverse(repo, subset, x):
1463 def reverse(repo, subset, x):
1464 """``reverse(set)``
1464 """``reverse(set)``
1465 Reverse order of set.
1465 Reverse order of set.
1466 """
1466 """
1467 l = getset(repo, subset, x)
1467 l = getset(repo, subset, x)
1468 l.reverse()
1468 l.reverse()
1469 return l
1469 return l
1470
1470
1471 def roots(repo, subset, x):
1471 def roots(repo, subset, x):
1472 """``roots(set)``
1472 """``roots(set)``
1473 Changesets in set with no parent changeset in set.
1473 Changesets in set with no parent changeset in set.
1474 """
1474 """
1475 s = getset(repo, spanset(repo), x).set()
1475 s = getset(repo, spanset(repo), x).set()
1476 subset = baseset([r for r in s if r in subset.set()])
1476 subset = baseset([r for r in s if r in subset.set()])
1477 cs = _children(repo, subset, s)
1477 cs = _children(repo, subset, s)
1478 return subset - cs
1478 return subset - cs
1479
1479
1480 def secret(repo, subset, x):
1480 def secret(repo, subset, x):
1481 """``secret()``
1481 """``secret()``
1482 Changeset in secret phase."""
1482 Changeset in secret phase."""
1483 # i18n: "secret" is a keyword
1483 # i18n: "secret" is a keyword
1484 getargs(x, 0, 0, _("secret takes no arguments"))
1484 getargs(x, 0, 0, _("secret takes no arguments"))
1485 pc = repo._phasecache
1485 pc = repo._phasecache
1486 return subset.filter(lambda x: pc.phase(repo, x) == phases.secret)
1486 return subset.filter(lambda x: pc.phase(repo, x) == phases.secret)
1487
1487
1488 def sort(repo, subset, x):
1488 def sort(repo, subset, x):
1489 """``sort(set[, [-]key...])``
1489 """``sort(set[, [-]key...])``
1490 Sort set by keys. The default sort order is ascending, specify a key
1490 Sort set by keys. The default sort order is ascending, specify a key
1491 as ``-key`` to sort in descending order.
1491 as ``-key`` to sort in descending order.
1492
1492
1493 The keys can be:
1493 The keys can be:
1494
1494
1495 - ``rev`` for the revision number,
1495 - ``rev`` for the revision number,
1496 - ``branch`` for the branch name,
1496 - ``branch`` for the branch name,
1497 - ``desc`` for the commit message (description),
1497 - ``desc`` for the commit message (description),
1498 - ``user`` for user name (``author`` can be used as an alias),
1498 - ``user`` for user name (``author`` can be used as an alias),
1499 - ``date`` for the commit date
1499 - ``date`` for the commit date
1500 """
1500 """
1501 # i18n: "sort" is a keyword
1501 # i18n: "sort" is a keyword
1502 l = getargs(x, 1, 2, _("sort requires one or two arguments"))
1502 l = getargs(x, 1, 2, _("sort requires one or two arguments"))
1503 keys = "rev"
1503 keys = "rev"
1504 if len(l) == 2:
1504 if len(l) == 2:
1505 # i18n: "sort" is a keyword
1505 # i18n: "sort" is a keyword
1506 keys = getstring(l[1], _("sort spec must be a string"))
1506 keys = getstring(l[1], _("sort spec must be a string"))
1507
1507
1508 s = l[0]
1508 s = l[0]
1509 keys = keys.split()
1509 keys = keys.split()
1510 l = []
1510 l = []
1511 def invert(s):
1511 def invert(s):
1512 return "".join(chr(255 - ord(c)) for c in s)
1512 return "".join(chr(255 - ord(c)) for c in s)
1513 revs = getset(repo, subset, s)
1513 revs = getset(repo, subset, s)
1514 if keys == ["rev"]:
1514 if keys == ["rev"]:
1515 revs.sort()
1515 revs.sort()
1516 return revs
1516 return revs
1517 elif keys == ["-rev"]:
1517 elif keys == ["-rev"]:
1518 revs.sort(reverse=True)
1518 revs.sort(reverse=True)
1519 return revs
1519 return revs
1520 for r in revs:
1520 for r in revs:
1521 c = repo[r]
1521 c = repo[r]
1522 e = []
1522 e = []
1523 for k in keys:
1523 for k in keys:
1524 if k == 'rev':
1524 if k == 'rev':
1525 e.append(r)
1525 e.append(r)
1526 elif k == '-rev':
1526 elif k == '-rev':
1527 e.append(-r)
1527 e.append(-r)
1528 elif k == 'branch':
1528 elif k == 'branch':
1529 e.append(c.branch())
1529 e.append(c.branch())
1530 elif k == '-branch':
1530 elif k == '-branch':
1531 e.append(invert(c.branch()))
1531 e.append(invert(c.branch()))
1532 elif k == 'desc':
1532 elif k == 'desc':
1533 e.append(c.description())
1533 e.append(c.description())
1534 elif k == '-desc':
1534 elif k == '-desc':
1535 e.append(invert(c.description()))
1535 e.append(invert(c.description()))
1536 elif k in 'user author':
1536 elif k in 'user author':
1537 e.append(c.user())
1537 e.append(c.user())
1538 elif k in '-user -author':
1538 elif k in '-user -author':
1539 e.append(invert(c.user()))
1539 e.append(invert(c.user()))
1540 elif k == 'date':
1540 elif k == 'date':
1541 e.append(c.date()[0])
1541 e.append(c.date()[0])
1542 elif k == '-date':
1542 elif k == '-date':
1543 e.append(-c.date()[0])
1543 e.append(-c.date()[0])
1544 else:
1544 else:
1545 raise error.ParseError(_("unknown sort key %r") % k)
1545 raise error.ParseError(_("unknown sort key %r") % k)
1546 e.append(r)
1546 e.append(r)
1547 l.append(e)
1547 l.append(e)
1548 l.sort()
1548 l.sort()
1549 return baseset([e[-1] for e in l])
1549 return baseset([e[-1] for e in l])
1550
1550
1551 def _stringmatcher(pattern):
1551 def _stringmatcher(pattern):
1552 """
1552 """
1553 accepts a string, possibly starting with 're:' or 'literal:' prefix.
1553 accepts a string, possibly starting with 're:' or 'literal:' prefix.
1554 returns the matcher name, pattern, and matcher function.
1554 returns the matcher name, pattern, and matcher function.
1555 missing or unknown prefixes are treated as literal matches.
1555 missing or unknown prefixes are treated as literal matches.
1556
1556
1557 helper for tests:
1557 helper for tests:
1558 >>> def test(pattern, *tests):
1558 >>> def test(pattern, *tests):
1559 ... kind, pattern, matcher = _stringmatcher(pattern)
1559 ... kind, pattern, matcher = _stringmatcher(pattern)
1560 ... return (kind, pattern, [bool(matcher(t)) for t in tests])
1560 ... return (kind, pattern, [bool(matcher(t)) for t in tests])
1561
1561
1562 exact matching (no prefix):
1562 exact matching (no prefix):
1563 >>> test('abcdefg', 'abc', 'def', 'abcdefg')
1563 >>> test('abcdefg', 'abc', 'def', 'abcdefg')
1564 ('literal', 'abcdefg', [False, False, True])
1564 ('literal', 'abcdefg', [False, False, True])
1565
1565
1566 regex matching ('re:' prefix)
1566 regex matching ('re:' prefix)
1567 >>> test('re:a.+b', 'nomatch', 'fooadef', 'fooadefbar')
1567 >>> test('re:a.+b', 'nomatch', 'fooadef', 'fooadefbar')
1568 ('re', 'a.+b', [False, False, True])
1568 ('re', 'a.+b', [False, False, True])
1569
1569
1570 force exact matches ('literal:' prefix)
1570 force exact matches ('literal:' prefix)
1571 >>> test('literal:re:foobar', 'foobar', 're:foobar')
1571 >>> test('literal:re:foobar', 'foobar', 're:foobar')
1572 ('literal', 're:foobar', [False, True])
1572 ('literal', 're:foobar', [False, True])
1573
1573
1574 unknown prefixes are ignored and treated as literals
1574 unknown prefixes are ignored and treated as literals
1575 >>> test('foo:bar', 'foo', 'bar', 'foo:bar')
1575 >>> test('foo:bar', 'foo', 'bar', 'foo:bar')
1576 ('literal', 'foo:bar', [False, False, True])
1576 ('literal', 'foo:bar', [False, False, True])
1577 """
1577 """
1578 if pattern.startswith('re:'):
1578 if pattern.startswith('re:'):
1579 pattern = pattern[3:]
1579 pattern = pattern[3:]
1580 try:
1580 try:
1581 regex = re.compile(pattern)
1581 regex = re.compile(pattern)
1582 except re.error, e:
1582 except re.error, e:
1583 raise error.ParseError(_('invalid regular expression: %s')
1583 raise error.ParseError(_('invalid regular expression: %s')
1584 % e)
1584 % e)
1585 return 're', pattern, regex.search
1585 return 're', pattern, regex.search
1586 elif pattern.startswith('literal:'):
1586 elif pattern.startswith('literal:'):
1587 pattern = pattern[8:]
1587 pattern = pattern[8:]
1588 return 'literal', pattern, pattern.__eq__
1588 return 'literal', pattern, pattern.__eq__
1589
1589
1590 def _substringmatcher(pattern):
1590 def _substringmatcher(pattern):
1591 kind, pattern, matcher = _stringmatcher(pattern)
1591 kind, pattern, matcher = _stringmatcher(pattern)
1592 if kind == 'literal':
1592 if kind == 'literal':
1593 matcher = lambda s: pattern in s
1593 matcher = lambda s: pattern in s
1594 return kind, pattern, matcher
1594 return kind, pattern, matcher
1595
1595
1596 def tag(repo, subset, x):
1596 def tag(repo, subset, x):
1597 """``tag([name])``
1597 """``tag([name])``
1598 The specified tag by name, or all tagged revisions if no name is given.
1598 The specified tag by name, or all tagged revisions if no name is given.
1599
1599
1600 If `name` starts with `re:`, the remainder of the name is treated as
1600 If `name` starts with `re:`, the remainder of the name is treated as
1601 a regular expression. To match a tag that actually starts with `re:`,
1601 a regular expression. To match a tag that actually starts with `re:`,
1602 use the prefix `literal:`.
1602 use the prefix `literal:`.
1603 """
1603 """
1604 # i18n: "tag" is a keyword
1604 # i18n: "tag" is a keyword
1605 args = getargs(x, 0, 1, _("tag takes one or no arguments"))
1605 args = getargs(x, 0, 1, _("tag takes one or no arguments"))
1606 cl = repo.changelog
1606 cl = repo.changelog
1607 if args:
1607 if args:
1608 pattern = getstring(args[0],
1608 pattern = getstring(args[0],
1609 # i18n: "tag" is a keyword
1609 # i18n: "tag" is a keyword
1610 _('the argument to tag must be a string'))
1610 _('the argument to tag must be a string'))
1611 kind, pattern, matcher = _stringmatcher(pattern)
1611 kind, pattern, matcher = _stringmatcher(pattern)
1612 if kind == 'literal':
1612 if kind == 'literal':
1613 # avoid resolving all tags
1613 # avoid resolving all tags
1614 tn = repo._tagscache.tags.get(pattern, None)
1614 tn = repo._tagscache.tags.get(pattern, None)
1615 if tn is None:
1615 if tn is None:
1616 raise util.Abort(_("tag '%s' does not exist") % pattern)
1616 raise util.Abort(_("tag '%s' does not exist") % pattern)
1617 s = set([repo[tn].rev()])
1617 s = set([repo[tn].rev()])
1618 else:
1618 else:
1619 s = set([cl.rev(n) for t, n in repo.tagslist() if matcher(t)])
1619 s = set([cl.rev(n) for t, n in repo.tagslist() if matcher(t)])
1620 else:
1620 else:
1621 s = set([cl.rev(n) for t, n in repo.tagslist() if t != 'tip'])
1621 s = set([cl.rev(n) for t, n in repo.tagslist() if t != 'tip'])
1622 return subset & s
1622 return subset & s
1623
1623
1624 def tagged(repo, subset, x):
1624 def tagged(repo, subset, x):
1625 return tag(repo, subset, x)
1625 return tag(repo, subset, x)
1626
1626
1627 def unstable(repo, subset, x):
1627 def unstable(repo, subset, x):
1628 """``unstable()``
1628 """``unstable()``
1629 Non-obsolete changesets with obsolete ancestors.
1629 Non-obsolete changesets with obsolete ancestors.
1630 """
1630 """
1631 # i18n: "unstable" is a keyword
1631 # i18n: "unstable" is a keyword
1632 getargs(x, 0, 0, _("unstable takes no arguments"))
1632 getargs(x, 0, 0, _("unstable takes no arguments"))
1633 unstables = obsmod.getrevs(repo, 'unstable')
1633 unstables = obsmod.getrevs(repo, 'unstable')
1634 return subset & unstables
1634 return subset & unstables
1635
1635
1636
1636
1637 def user(repo, subset, x):
1637 def user(repo, subset, x):
1638 """``user(string)``
1638 """``user(string)``
1639 User name contains string. The match is case-insensitive.
1639 User name contains string. The match is case-insensitive.
1640
1640
1641 If `string` starts with `re:`, the remainder of the string is treated as
1641 If `string` starts with `re:`, the remainder of the string is treated as
1642 a regular expression. To match a user that actually contains `re:`, use
1642 a regular expression. To match a user that actually contains `re:`, use
1643 the prefix `literal:`.
1643 the prefix `literal:`.
1644 """
1644 """
1645 return author(repo, subset, x)
1645 return author(repo, subset, x)
1646
1646
1647 # for internal use
1647 # for internal use
1648 def _list(repo, subset, x):
1648 def _list(repo, subset, x):
1649 s = getstring(x, "internal error")
1649 s = getstring(x, "internal error")
1650 if not s:
1650 if not s:
1651 return baseset([])
1651 return baseset([])
1652 ls = [repo[r].rev() for r in s.split('\0')]
1652 ls = [repo[r].rev() for r in s.split('\0')]
1653 s = subset.set()
1653 s = subset.set()
1654 return baseset([r for r in ls if r in s])
1654 return baseset([r for r in ls if r in s])
1655
1655
1656 # for internal use
1656 # for internal use
1657 def _intlist(repo, subset, x):
1657 def _intlist(repo, subset, x):
1658 s = getstring(x, "internal error")
1658 s = getstring(x, "internal error")
1659 if not s:
1659 if not s:
1660 return baseset([])
1660 return baseset([])
1661 ls = [int(r) for r in s.split('\0')]
1661 ls = [int(r) for r in s.split('\0')]
1662 s = subset.set()
1662 s = subset.set()
1663 return baseset([r for r in ls if r in s])
1663 return baseset([r for r in ls if r in s])
1664
1664
1665 # for internal use
1665 # for internal use
1666 def _hexlist(repo, subset, x):
1666 def _hexlist(repo, subset, x):
1667 s = getstring(x, "internal error")
1667 s = getstring(x, "internal error")
1668 if not s:
1668 if not s:
1669 return baseset([])
1669 return baseset([])
1670 cl = repo.changelog
1670 cl = repo.changelog
1671 ls = [cl.rev(node.bin(r)) for r in s.split('\0')]
1671 ls = [cl.rev(node.bin(r)) for r in s.split('\0')]
1672 s = subset.set()
1672 s = subset.set()
1673 return baseset([r for r in ls if r in s])
1673 return baseset([r for r in ls if r in s])
1674
1674
1675 symbols = {
1675 symbols = {
1676 "adds": adds,
1676 "adds": adds,
1677 "all": getall,
1677 "all": getall,
1678 "ancestor": ancestor,
1678 "ancestor": ancestor,
1679 "ancestors": ancestors,
1679 "ancestors": ancestors,
1680 "_firstancestors": _firstancestors,
1680 "_firstancestors": _firstancestors,
1681 "author": author,
1681 "author": author,
1682 "only": only,
1682 "only": only,
1683 "bisect": bisect,
1683 "bisect": bisect,
1684 "bisected": bisected,
1684 "bisected": bisected,
1685 "bookmark": bookmark,
1685 "bookmark": bookmark,
1686 "branch": branch,
1686 "branch": branch,
1687 "branchpoint": branchpoint,
1687 "branchpoint": branchpoint,
1688 "bumped": bumped,
1688 "bumped": bumped,
1689 "bundle": bundle,
1689 "bundle": bundle,
1690 "children": children,
1690 "children": children,
1691 "closed": closed,
1691 "closed": closed,
1692 "contains": contains,
1692 "contains": contains,
1693 "converted": converted,
1693 "converted": converted,
1694 "date": date,
1694 "date": date,
1695 "desc": desc,
1695 "desc": desc,
1696 "descendants": descendants,
1696 "descendants": descendants,
1697 "_firstdescendants": _firstdescendants,
1697 "_firstdescendants": _firstdescendants,
1698 "destination": destination,
1698 "destination": destination,
1699 "divergent": divergent,
1699 "divergent": divergent,
1700 "draft": draft,
1700 "draft": draft,
1701 "extinct": extinct,
1701 "extinct": extinct,
1702 "extra": extra,
1702 "extra": extra,
1703 "file": hasfile,
1703 "file": hasfile,
1704 "filelog": filelog,
1704 "filelog": filelog,
1705 "first": first,
1705 "first": first,
1706 "follow": follow,
1706 "follow": follow,
1707 "_followfirst": _followfirst,
1707 "_followfirst": _followfirst,
1708 "grep": grep,
1708 "grep": grep,
1709 "head": head,
1709 "head": head,
1710 "heads": heads,
1710 "heads": heads,
1711 "hidden": hidden,
1711 "hidden": hidden,
1712 "id": node_,
1712 "id": node_,
1713 "keyword": keyword,
1713 "keyword": keyword,
1714 "last": last,
1714 "last": last,
1715 "limit": limit,
1715 "limit": limit,
1716 "_matchfiles": _matchfiles,
1716 "_matchfiles": _matchfiles,
1717 "max": maxrev,
1717 "max": maxrev,
1718 "merge": merge,
1718 "merge": merge,
1719 "min": minrev,
1719 "min": minrev,
1720 "modifies": modifies,
1720 "modifies": modifies,
1721 "obsolete": obsolete,
1721 "obsolete": obsolete,
1722 "origin": origin,
1722 "origin": origin,
1723 "outgoing": outgoing,
1723 "outgoing": outgoing,
1724 "p1": p1,
1724 "p1": p1,
1725 "p2": p2,
1725 "p2": p2,
1726 "parents": parents,
1726 "parents": parents,
1727 "present": present,
1727 "present": present,
1728 "public": public,
1728 "public": public,
1729 "remote": remote,
1729 "remote": remote,
1730 "removes": removes,
1730 "removes": removes,
1731 "rev": rev,
1731 "rev": rev,
1732 "reverse": reverse,
1732 "reverse": reverse,
1733 "roots": roots,
1733 "roots": roots,
1734 "sort": sort,
1734 "sort": sort,
1735 "secret": secret,
1735 "secret": secret,
1736 "matching": matching,
1736 "matching": matching,
1737 "tag": tag,
1737 "tag": tag,
1738 "tagged": tagged,
1738 "tagged": tagged,
1739 "user": user,
1739 "user": user,
1740 "unstable": unstable,
1740 "unstable": unstable,
1741 "_list": _list,
1741 "_list": _list,
1742 "_intlist": _intlist,
1742 "_intlist": _intlist,
1743 "_hexlist": _hexlist,
1743 "_hexlist": _hexlist,
1744 }
1744 }
1745
1745
1746 # symbols which can't be used for a DoS attack for any given input
1746 # symbols which can't be used for a DoS attack for any given input
1747 # (e.g. those which accept regexes as plain strings shouldn't be included)
1747 # (e.g. those which accept regexes as plain strings shouldn't be included)
1748 # functions that just return a lot of changesets (like all) don't count here
1748 # functions that just return a lot of changesets (like all) don't count here
1749 safesymbols = set([
1749 safesymbols = set([
1750 "adds",
1750 "adds",
1751 "all",
1751 "all",
1752 "ancestor",
1752 "ancestor",
1753 "ancestors",
1753 "ancestors",
1754 "_firstancestors",
1754 "_firstancestors",
1755 "author",
1755 "author",
1756 "bisect",
1756 "bisect",
1757 "bisected",
1757 "bisected",
1758 "bookmark",
1758 "bookmark",
1759 "branch",
1759 "branch",
1760 "branchpoint",
1760 "branchpoint",
1761 "bumped",
1761 "bumped",
1762 "bundle",
1762 "bundle",
1763 "children",
1763 "children",
1764 "closed",
1764 "closed",
1765 "converted",
1765 "converted",
1766 "date",
1766 "date",
1767 "desc",
1767 "desc",
1768 "descendants",
1768 "descendants",
1769 "_firstdescendants",
1769 "_firstdescendants",
1770 "destination",
1770 "destination",
1771 "divergent",
1771 "divergent",
1772 "draft",
1772 "draft",
1773 "extinct",
1773 "extinct",
1774 "extra",
1774 "extra",
1775 "file",
1775 "file",
1776 "filelog",
1776 "filelog",
1777 "first",
1777 "first",
1778 "follow",
1778 "follow",
1779 "_followfirst",
1779 "_followfirst",
1780 "head",
1780 "head",
1781 "heads",
1781 "heads",
1782 "hidden",
1782 "hidden",
1783 "id",
1783 "id",
1784 "keyword",
1784 "keyword",
1785 "last",
1785 "last",
1786 "limit",
1786 "limit",
1787 "_matchfiles",
1787 "_matchfiles",
1788 "max",
1788 "max",
1789 "merge",
1789 "merge",
1790 "min",
1790 "min",
1791 "modifies",
1791 "modifies",
1792 "obsolete",
1792 "obsolete",
1793 "origin",
1793 "origin",
1794 "outgoing",
1794 "outgoing",
1795 "p1",
1795 "p1",
1796 "p2",
1796 "p2",
1797 "parents",
1797 "parents",
1798 "present",
1798 "present",
1799 "public",
1799 "public",
1800 "remote",
1800 "remote",
1801 "removes",
1801 "removes",
1802 "rev",
1802 "rev",
1803 "reverse",
1803 "reverse",
1804 "roots",
1804 "roots",
1805 "sort",
1805 "sort",
1806 "secret",
1806 "secret",
1807 "matching",
1807 "matching",
1808 "tag",
1808 "tag",
1809 "tagged",
1809 "tagged",
1810 "user",
1810 "user",
1811 "unstable",
1811 "unstable",
1812 "_list",
1812 "_list",
1813 "_intlist",
1813 "_intlist",
1814 "_hexlist",
1814 "_hexlist",
1815 ])
1815 ])
1816
1816
1817 methods = {
1817 methods = {
1818 "range": rangeset,
1818 "range": rangeset,
1819 "dagrange": dagrange,
1819 "dagrange": dagrange,
1820 "string": stringset,
1820 "string": stringset,
1821 "symbol": symbolset,
1821 "symbol": symbolset,
1822 "and": andset,
1822 "and": andset,
1823 "or": orset,
1823 "or": orset,
1824 "not": notset,
1824 "not": notset,
1825 "list": listset,
1825 "list": listset,
1826 "func": func,
1826 "func": func,
1827 "ancestor": ancestorspec,
1827 "ancestor": ancestorspec,
1828 "parent": parentspec,
1828 "parent": parentspec,
1829 "parentpost": p1,
1829 "parentpost": p1,
1830 }
1830 }
1831
1831
1832 def optimize(x, small):
1832 def optimize(x, small):
1833 if x is None:
1833 if x is None:
1834 return 0, x
1834 return 0, x
1835
1835
1836 smallbonus = 1
1836 smallbonus = 1
1837 if small:
1837 if small:
1838 smallbonus = .5
1838 smallbonus = .5
1839
1839
1840 op = x[0]
1840 op = x[0]
1841 if op == 'minus':
1841 if op == 'minus':
1842 return optimize(('and', x[1], ('not', x[2])), small)
1842 return optimize(('and', x[1], ('not', x[2])), small)
1843 elif op == 'dagrangepre':
1843 elif op == 'dagrangepre':
1844 return optimize(('func', ('symbol', 'ancestors'), x[1]), small)
1844 return optimize(('func', ('symbol', 'ancestors'), x[1]), small)
1845 elif op == 'dagrangepost':
1845 elif op == 'dagrangepost':
1846 return optimize(('func', ('symbol', 'descendants'), x[1]), small)
1846 return optimize(('func', ('symbol', 'descendants'), x[1]), small)
1847 elif op == 'rangepre':
1847 elif op == 'rangepre':
1848 return optimize(('range', ('string', '0'), x[1]), small)
1848 return optimize(('range', ('string', '0'), x[1]), small)
1849 elif op == 'rangepost':
1849 elif op == 'rangepost':
1850 return optimize(('range', x[1], ('string', 'tip')), small)
1850 return optimize(('range', x[1], ('string', 'tip')), small)
1851 elif op == 'negate':
1851 elif op == 'negate':
1852 return optimize(('string',
1852 return optimize(('string',
1853 '-' + getstring(x[1], _("can't negate that"))), small)
1853 '-' + getstring(x[1], _("can't negate that"))), small)
1854 elif op in 'string symbol negate':
1854 elif op in 'string symbol negate':
1855 return smallbonus, x # single revisions are small
1855 return smallbonus, x # single revisions are small
1856 elif op == 'and':
1856 elif op == 'and':
1857 wa, ta = optimize(x[1], True)
1857 wa, ta = optimize(x[1], True)
1858 wb, tb = optimize(x[2], True)
1858 wb, tb = optimize(x[2], True)
1859
1859
1860 # (::x and not ::y)/(not ::y and ::x) have a fast path
1860 # (::x and not ::y)/(not ::y and ::x) have a fast path
1861 def isonly(revs, bases):
1861 def isonly(revs, bases):
1862 return (
1862 return (
1863 revs[0] == 'func'
1863 revs[0] == 'func'
1864 and getstring(revs[1], _('not a symbol')) == 'ancestors'
1864 and getstring(revs[1], _('not a symbol')) == 'ancestors'
1865 and bases[0] == 'not'
1865 and bases[0] == 'not'
1866 and bases[1][0] == 'func'
1866 and bases[1][0] == 'func'
1867 and getstring(bases[1][1], _('not a symbol')) == 'ancestors')
1867 and getstring(bases[1][1], _('not a symbol')) == 'ancestors')
1868
1868
1869 w = min(wa, wb)
1869 w = min(wa, wb)
1870 if isonly(ta, tb):
1870 if isonly(ta, tb):
1871 return w, ('func', ('symbol', 'only'), ('list', ta[2], tb[1][2]))
1871 return w, ('func', ('symbol', 'only'), ('list', ta[2], tb[1][2]))
1872 if isonly(tb, ta):
1872 if isonly(tb, ta):
1873 return w, ('func', ('symbol', 'only'), ('list', tb[2], ta[1][2]))
1873 return w, ('func', ('symbol', 'only'), ('list', tb[2], ta[1][2]))
1874
1874
1875 if wa > wb:
1875 if wa > wb:
1876 return w, (op, tb, ta)
1876 return w, (op, tb, ta)
1877 return w, (op, ta, tb)
1877 return w, (op, ta, tb)
1878 elif op == 'or':
1878 elif op == 'or':
1879 wa, ta = optimize(x[1], False)
1879 wa, ta = optimize(x[1], False)
1880 wb, tb = optimize(x[2], False)
1880 wb, tb = optimize(x[2], False)
1881 if wb < wa:
1881 if wb < wa:
1882 wb, wa = wa, wb
1882 wb, wa = wa, wb
1883 return max(wa, wb), (op, ta, tb)
1883 return max(wa, wb), (op, ta, tb)
1884 elif op == 'not':
1884 elif op == 'not':
1885 o = optimize(x[1], not small)
1885 o = optimize(x[1], not small)
1886 return o[0], (op, o[1])
1886 return o[0], (op, o[1])
1887 elif op == 'parentpost':
1887 elif op == 'parentpost':
1888 o = optimize(x[1], small)
1888 o = optimize(x[1], small)
1889 return o[0], (op, o[1])
1889 return o[0], (op, o[1])
1890 elif op == 'group':
1890 elif op == 'group':
1891 return optimize(x[1], small)
1891 return optimize(x[1], small)
1892 elif op in 'dagrange range list parent ancestorspec':
1892 elif op in 'dagrange range list parent ancestorspec':
1893 if op == 'parent':
1893 if op == 'parent':
1894 # x^:y means (x^) : y, not x ^ (:y)
1894 # x^:y means (x^) : y, not x ^ (:y)
1895 post = ('parentpost', x[1])
1895 post = ('parentpost', x[1])
1896 if x[2][0] == 'dagrangepre':
1896 if x[2][0] == 'dagrangepre':
1897 return optimize(('dagrange', post, x[2][1]), small)
1897 return optimize(('dagrange', post, x[2][1]), small)
1898 elif x[2][0] == 'rangepre':
1898 elif x[2][0] == 'rangepre':
1899 return optimize(('range', post, x[2][1]), small)
1899 return optimize(('range', post, x[2][1]), small)
1900
1900
1901 wa, ta = optimize(x[1], small)
1901 wa, ta = optimize(x[1], small)
1902 wb, tb = optimize(x[2], small)
1902 wb, tb = optimize(x[2], small)
1903 return wa + wb, (op, ta, tb)
1903 return wa + wb, (op, ta, tb)
1904 elif op == 'func':
1904 elif op == 'func':
1905 f = getstring(x[1], _("not a symbol"))
1905 f = getstring(x[1], _("not a symbol"))
1906 wa, ta = optimize(x[2], small)
1906 wa, ta = optimize(x[2], small)
1907 if f in ("author branch closed date desc file grep keyword "
1907 if f in ("author branch closed date desc file grep keyword "
1908 "outgoing user"):
1908 "outgoing user"):
1909 w = 10 # slow
1909 w = 10 # slow
1910 elif f in "modifies adds removes":
1910 elif f in "modifies adds removes":
1911 w = 30 # slower
1911 w = 30 # slower
1912 elif f == "contains":
1912 elif f == "contains":
1913 w = 100 # very slow
1913 w = 100 # very slow
1914 elif f == "ancestor":
1914 elif f == "ancestor":
1915 w = 1 * smallbonus
1915 w = 1 * smallbonus
1916 elif f in "reverse limit first _intlist":
1916 elif f in "reverse limit first _intlist":
1917 w = 0
1917 w = 0
1918 elif f in "sort":
1918 elif f in "sort":
1919 w = 10 # assume most sorts look at changelog
1919 w = 10 # assume most sorts look at changelog
1920 else:
1920 else:
1921 w = 1
1921 w = 1
1922 return w + wa, (op, x[1], ta)
1922 return w + wa, (op, x[1], ta)
1923 return 1, x
1923 return 1, x
1924
1924
1925 _aliasarg = ('func', ('symbol', '_aliasarg'))
1925 _aliasarg = ('func', ('symbol', '_aliasarg'))
1926 def _getaliasarg(tree):
1926 def _getaliasarg(tree):
1927 """If tree matches ('func', ('symbol', '_aliasarg'), ('string', X))
1927 """If tree matches ('func', ('symbol', '_aliasarg'), ('string', X))
1928 return X, None otherwise.
1928 return X, None otherwise.
1929 """
1929 """
1930 if (len(tree) == 3 and tree[:2] == _aliasarg
1930 if (len(tree) == 3 and tree[:2] == _aliasarg
1931 and tree[2][0] == 'string'):
1931 and tree[2][0] == 'string'):
1932 return tree[2][1]
1932 return tree[2][1]
1933 return None
1933 return None
1934
1934
1935 def _checkaliasarg(tree, known=None):
1935 def _checkaliasarg(tree, known=None):
1936 """Check tree contains no _aliasarg construct or only ones which
1936 """Check tree contains no _aliasarg construct or only ones which
1937 value is in known. Used to avoid alias placeholders injection.
1937 value is in known. Used to avoid alias placeholders injection.
1938 """
1938 """
1939 if isinstance(tree, tuple):
1939 if isinstance(tree, tuple):
1940 arg = _getaliasarg(tree)
1940 arg = _getaliasarg(tree)
1941 if arg is not None and (not known or arg not in known):
1941 if arg is not None and (not known or arg not in known):
1942 raise error.ParseError(_("not a function: %s") % '_aliasarg')
1942 raise error.ParseError(_("not a function: %s") % '_aliasarg')
1943 for t in tree:
1943 for t in tree:
1944 _checkaliasarg(t, known)
1944 _checkaliasarg(t, known)
1945
1945
1946 class revsetalias(object):
1946 class revsetalias(object):
1947 funcre = re.compile('^([^(]+)\(([^)]+)\)$')
1947 funcre = re.compile('^([^(]+)\(([^)]+)\)$')
1948 args = None
1948 args = None
1949
1949
1950 def __init__(self, name, value):
1950 def __init__(self, name, value):
1951 '''Aliases like:
1951 '''Aliases like:
1952
1952
1953 h = heads(default)
1953 h = heads(default)
1954 b($1) = ancestors($1) - ancestors(default)
1954 b($1) = ancestors($1) - ancestors(default)
1955 '''
1955 '''
1956 m = self.funcre.search(name)
1956 m = self.funcre.search(name)
1957 if m:
1957 if m:
1958 self.name = m.group(1)
1958 self.name = m.group(1)
1959 self.tree = ('func', ('symbol', m.group(1)))
1959 self.tree = ('func', ('symbol', m.group(1)))
1960 self.args = [x.strip() for x in m.group(2).split(',')]
1960 self.args = [x.strip() for x in m.group(2).split(',')]
1961 for arg in self.args:
1961 for arg in self.args:
1962 # _aliasarg() is an unknown symbol only used separate
1962 # _aliasarg() is an unknown symbol only used separate
1963 # alias argument placeholders from regular strings.
1963 # alias argument placeholders from regular strings.
1964 value = value.replace(arg, '_aliasarg(%r)' % (arg,))
1964 value = value.replace(arg, '_aliasarg(%r)' % (arg,))
1965 else:
1965 else:
1966 self.name = name
1966 self.name = name
1967 self.tree = ('symbol', name)
1967 self.tree = ('symbol', name)
1968
1968
1969 self.replacement, pos = parse(value)
1969 self.replacement, pos = parse(value)
1970 if pos != len(value):
1970 if pos != len(value):
1971 raise error.ParseError(_('invalid token'), pos)
1971 raise error.ParseError(_('invalid token'), pos)
1972 # Check for placeholder injection
1972 # Check for placeholder injection
1973 _checkaliasarg(self.replacement, self.args)
1973 _checkaliasarg(self.replacement, self.args)
1974
1974
1975 def _getalias(aliases, tree):
1975 def _getalias(aliases, tree):
1976 """If tree looks like an unexpanded alias, return it. Return None
1976 """If tree looks like an unexpanded alias, return it. Return None
1977 otherwise.
1977 otherwise.
1978 """
1978 """
1979 if isinstance(tree, tuple) and tree:
1979 if isinstance(tree, tuple) and tree:
1980 if tree[0] == 'symbol' and len(tree) == 2:
1980 if tree[0] == 'symbol' and len(tree) == 2:
1981 name = tree[1]
1981 name = tree[1]
1982 alias = aliases.get(name)
1982 alias = aliases.get(name)
1983 if alias and alias.args is None and alias.tree == tree:
1983 if alias and alias.args is None and alias.tree == tree:
1984 return alias
1984 return alias
1985 if tree[0] == 'func' and len(tree) > 1:
1985 if tree[0] == 'func' and len(tree) > 1:
1986 if tree[1][0] == 'symbol' and len(tree[1]) == 2:
1986 if tree[1][0] == 'symbol' and len(tree[1]) == 2:
1987 name = tree[1][1]
1987 name = tree[1][1]
1988 alias = aliases.get(name)
1988 alias = aliases.get(name)
1989 if alias and alias.args is not None and alias.tree == tree[:2]:
1989 if alias and alias.args is not None and alias.tree == tree[:2]:
1990 return alias
1990 return alias
1991 return None
1991 return None
1992
1992
1993 def _expandargs(tree, args):
1993 def _expandargs(tree, args):
1994 """Replace _aliasarg instances with the substitution value of the
1994 """Replace _aliasarg instances with the substitution value of the
1995 same name in args, recursively.
1995 same name in args, recursively.
1996 """
1996 """
1997 if not tree or not isinstance(tree, tuple):
1997 if not tree or not isinstance(tree, tuple):
1998 return tree
1998 return tree
1999 arg = _getaliasarg(tree)
1999 arg = _getaliasarg(tree)
2000 if arg is not None:
2000 if arg is not None:
2001 return args[arg]
2001 return args[arg]
2002 return tuple(_expandargs(t, args) for t in tree)
2002 return tuple(_expandargs(t, args) for t in tree)
2003
2003
2004 def _expandaliases(aliases, tree, expanding, cache):
2004 def _expandaliases(aliases, tree, expanding, cache):
2005 """Expand aliases in tree, recursively.
2005 """Expand aliases in tree, recursively.
2006
2006
2007 'aliases' is a dictionary mapping user defined aliases to
2007 'aliases' is a dictionary mapping user defined aliases to
2008 revsetalias objects.
2008 revsetalias objects.
2009 """
2009 """
2010 if not isinstance(tree, tuple):
2010 if not isinstance(tree, tuple):
2011 # Do not expand raw strings
2011 # Do not expand raw strings
2012 return tree
2012 return tree
2013 alias = _getalias(aliases, tree)
2013 alias = _getalias(aliases, tree)
2014 if alias is not None:
2014 if alias is not None:
2015 if alias in expanding:
2015 if alias in expanding:
2016 raise error.ParseError(_('infinite expansion of revset alias "%s" '
2016 raise error.ParseError(_('infinite expansion of revset alias "%s" '
2017 'detected') % alias.name)
2017 'detected') % alias.name)
2018 expanding.append(alias)
2018 expanding.append(alias)
2019 if alias.name not in cache:
2019 if alias.name not in cache:
2020 cache[alias.name] = _expandaliases(aliases, alias.replacement,
2020 cache[alias.name] = _expandaliases(aliases, alias.replacement,
2021 expanding, cache)
2021 expanding, cache)
2022 result = cache[alias.name]
2022 result = cache[alias.name]
2023 expanding.pop()
2023 expanding.pop()
2024 if alias.args is not None:
2024 if alias.args is not None:
2025 l = getlist(tree[2])
2025 l = getlist(tree[2])
2026 if len(l) != len(alias.args):
2026 if len(l) != len(alias.args):
2027 raise error.ParseError(
2027 raise error.ParseError(
2028 _('invalid number of arguments: %s') % len(l))
2028 _('invalid number of arguments: %s') % len(l))
2029 l = [_expandaliases(aliases, a, [], cache) for a in l]
2029 l = [_expandaliases(aliases, a, [], cache) for a in l]
2030 result = _expandargs(result, dict(zip(alias.args, l)))
2030 result = _expandargs(result, dict(zip(alias.args, l)))
2031 else:
2031 else:
2032 result = tuple(_expandaliases(aliases, t, expanding, cache)
2032 result = tuple(_expandaliases(aliases, t, expanding, cache)
2033 for t in tree)
2033 for t in tree)
2034 return result
2034 return result
2035
2035
2036 def findaliases(ui, tree):
2036 def findaliases(ui, tree):
2037 _checkaliasarg(tree)
2037 _checkaliasarg(tree)
2038 aliases = {}
2038 aliases = {}
2039 for k, v in ui.configitems('revsetalias'):
2039 for k, v in ui.configitems('revsetalias'):
2040 alias = revsetalias(k, v)
2040 alias = revsetalias(k, v)
2041 aliases[alias.name] = alias
2041 aliases[alias.name] = alias
2042 return _expandaliases(aliases, tree, [], {})
2042 return _expandaliases(aliases, tree, [], {})
2043
2043
2044 def parse(spec, lookup=None):
2044 def parse(spec, lookup=None):
2045 p = parser.parser(tokenize, elements)
2045 p = parser.parser(tokenize, elements)
2046 return p.parse(spec, lookup=lookup)
2046 return p.parse(spec, lookup=lookup)
2047
2047
2048 def match(ui, spec, repo=None):
2048 def match(ui, spec, repo=None):
2049 if not spec:
2049 if not spec:
2050 raise error.ParseError(_("empty query"))
2050 raise error.ParseError(_("empty query"))
2051 lookup = None
2051 lookup = None
2052 if repo:
2052 if repo:
2053 lookup = repo.__contains__
2053 lookup = repo.__contains__
2054 tree, pos = parse(spec, lookup)
2054 tree, pos = parse(spec, lookup)
2055 if (pos != len(spec)):
2055 if (pos != len(spec)):
2056 raise error.ParseError(_("invalid token"), pos)
2056 raise error.ParseError(_("invalid token"), pos)
2057 if ui:
2057 if ui:
2058 tree = findaliases(ui, tree)
2058 tree = findaliases(ui, tree)
2059 weight, tree = optimize(tree, True)
2059 weight, tree = optimize(tree, True)
2060 def mfunc(repo, subset):
2060 def mfunc(repo, subset):
2061 if util.safehasattr(subset, 'set'):
2061 if util.safehasattr(subset, 'set'):
2062 return getset(repo, subset, tree)
2062 return getset(repo, subset, tree)
2063 return getset(repo, baseset(subset), tree)
2063 return getset(repo, baseset(subset), tree)
2064 return mfunc
2064 return mfunc
2065
2065
2066 def formatspec(expr, *args):
2066 def formatspec(expr, *args):
2067 '''
2067 '''
2068 This is a convenience function for using revsets internally, and
2068 This is a convenience function for using revsets internally, and
2069 escapes arguments appropriately. Aliases are intentionally ignored
2069 escapes arguments appropriately. Aliases are intentionally ignored
2070 so that intended expression behavior isn't accidentally subverted.
2070 so that intended expression behavior isn't accidentally subverted.
2071
2071
2072 Supported arguments:
2072 Supported arguments:
2073
2073
2074 %r = revset expression, parenthesized
2074 %r = revset expression, parenthesized
2075 %d = int(arg), no quoting
2075 %d = int(arg), no quoting
2076 %s = string(arg), escaped and single-quoted
2076 %s = string(arg), escaped and single-quoted
2077 %b = arg.branch(), escaped and single-quoted
2077 %b = arg.branch(), escaped and single-quoted
2078 %n = hex(arg), single-quoted
2078 %n = hex(arg), single-quoted
2079 %% = a literal '%'
2079 %% = a literal '%'
2080
2080
2081 Prefixing the type with 'l' specifies a parenthesized list of that type.
2081 Prefixing the type with 'l' specifies a parenthesized list of that type.
2082
2082
2083 >>> formatspec('%r:: and %lr', '10 or 11', ("this()", "that()"))
2083 >>> formatspec('%r:: and %lr', '10 or 11', ("this()", "that()"))
2084 '(10 or 11):: and ((this()) or (that()))'
2084 '(10 or 11):: and ((this()) or (that()))'
2085 >>> formatspec('%d:: and not %d::', 10, 20)
2085 >>> formatspec('%d:: and not %d::', 10, 20)
2086 '10:: and not 20::'
2086 '10:: and not 20::'
2087 >>> formatspec('%ld or %ld', [], [1])
2087 >>> formatspec('%ld or %ld', [], [1])
2088 "_list('') or 1"
2088 "_list('') or 1"
2089 >>> formatspec('keyword(%s)', 'foo\\xe9')
2089 >>> formatspec('keyword(%s)', 'foo\\xe9')
2090 "keyword('foo\\\\xe9')"
2090 "keyword('foo\\\\xe9')"
2091 >>> b = lambda: 'default'
2091 >>> b = lambda: 'default'
2092 >>> b.branch = b
2092 >>> b.branch = b
2093 >>> formatspec('branch(%b)', b)
2093 >>> formatspec('branch(%b)', b)
2094 "branch('default')"
2094 "branch('default')"
2095 >>> formatspec('root(%ls)', ['a', 'b', 'c', 'd'])
2095 >>> formatspec('root(%ls)', ['a', 'b', 'c', 'd'])
2096 "root(_list('a\\x00b\\x00c\\x00d'))"
2096 "root(_list('a\\x00b\\x00c\\x00d'))"
2097 '''
2097 '''
2098
2098
2099 def quote(s):
2099 def quote(s):
2100 return repr(str(s))
2100 return repr(str(s))
2101
2101
2102 def argtype(c, arg):
2102 def argtype(c, arg):
2103 if c == 'd':
2103 if c == 'd':
2104 return str(int(arg))
2104 return str(int(arg))
2105 elif c == 's':
2105 elif c == 's':
2106 return quote(arg)
2106 return quote(arg)
2107 elif c == 'r':
2107 elif c == 'r':
2108 parse(arg) # make sure syntax errors are confined
2108 parse(arg) # make sure syntax errors are confined
2109 return '(%s)' % arg
2109 return '(%s)' % arg
2110 elif c == 'n':
2110 elif c == 'n':
2111 return quote(node.hex(arg))
2111 return quote(node.hex(arg))
2112 elif c == 'b':
2112 elif c == 'b':
2113 return quote(arg.branch())
2113 return quote(arg.branch())
2114
2114
2115 def listexp(s, t):
2115 def listexp(s, t):
2116 l = len(s)
2116 l = len(s)
2117 if l == 0:
2117 if l == 0:
2118 return "_list('')"
2118 return "_list('')"
2119 elif l == 1:
2119 elif l == 1:
2120 return argtype(t, s[0])
2120 return argtype(t, s[0])
2121 elif t == 'd':
2121 elif t == 'd':
2122 return "_intlist('%s')" % "\0".join(str(int(a)) for a in s)
2122 return "_intlist('%s')" % "\0".join(str(int(a)) for a in s)
2123 elif t == 's':
2123 elif t == 's':
2124 return "_list('%s')" % "\0".join(s)
2124 return "_list('%s')" % "\0".join(s)
2125 elif t == 'n':
2125 elif t == 'n':
2126 return "_hexlist('%s')" % "\0".join(node.hex(a) for a in s)
2126 return "_hexlist('%s')" % "\0".join(node.hex(a) for a in s)
2127 elif t == 'b':
2127 elif t == 'b':
2128 return "_list('%s')" % "\0".join(a.branch() for a in s)
2128 return "_list('%s')" % "\0".join(a.branch() for a in s)
2129
2129
2130 m = l // 2
2130 m = l // 2
2131 return '(%s or %s)' % (listexp(s[:m], t), listexp(s[m:], t))
2131 return '(%s or %s)' % (listexp(s[:m], t), listexp(s[m:], t))
2132
2132
2133 ret = ''
2133 ret = ''
2134 pos = 0
2134 pos = 0
2135 arg = 0
2135 arg = 0
2136 while pos < len(expr):
2136 while pos < len(expr):
2137 c = expr[pos]
2137 c = expr[pos]
2138 if c == '%':
2138 if c == '%':
2139 pos += 1
2139 pos += 1
2140 d = expr[pos]
2140 d = expr[pos]
2141 if d == '%':
2141 if d == '%':
2142 ret += d
2142 ret += d
2143 elif d in 'dsnbr':
2143 elif d in 'dsnbr':
2144 ret += argtype(d, args[arg])
2144 ret += argtype(d, args[arg])
2145 arg += 1
2145 arg += 1
2146 elif d == 'l':
2146 elif d == 'l':
2147 # a list of some type
2147 # a list of some type
2148 pos += 1
2148 pos += 1
2149 d = expr[pos]
2149 d = expr[pos]
2150 ret += listexp(list(args[arg]), d)
2150 ret += listexp(list(args[arg]), d)
2151 arg += 1
2151 arg += 1
2152 else:
2152 else:
2153 raise util.Abort('unexpected revspec format character %s' % d)
2153 raise util.Abort('unexpected revspec format character %s' % d)
2154 else:
2154 else:
2155 ret += c
2155 ret += c
2156 pos += 1
2156 pos += 1
2157
2157
2158 return ret
2158 return ret
2159
2159
2160 def prettyformat(tree):
2160 def prettyformat(tree):
2161 def _prettyformat(tree, level, lines):
2161 def _prettyformat(tree, level, lines):
2162 if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'):
2162 if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'):
2163 lines.append((level, str(tree)))
2163 lines.append((level, str(tree)))
2164 else:
2164 else:
2165 lines.append((level, '(%s' % tree[0]))
2165 lines.append((level, '(%s' % tree[0]))
2166 for s in tree[1:]:
2166 for s in tree[1:]:
2167 _prettyformat(s, level + 1, lines)
2167 _prettyformat(s, level + 1, lines)
2168 lines[-1:] = [(lines[-1][0], lines[-1][1] + ')')]
2168 lines[-1:] = [(lines[-1][0], lines[-1][1] + ')')]
2169
2169
2170 lines = []
2170 lines = []
2171 _prettyformat(tree, 0, lines)
2171 _prettyformat(tree, 0, lines)
2172 output = '\n'.join((' '*l + s) for l, s in lines)
2172 output = '\n'.join((' '*l + s) for l, s in lines)
2173 return output
2173 return output
2174
2174
2175 def depth(tree):
2175 def depth(tree):
2176 if isinstance(tree, tuple):
2176 if isinstance(tree, tuple):
2177 return max(map(depth, tree)) + 1
2177 return max(map(depth, tree)) + 1
2178 else:
2178 else:
2179 return 0
2179 return 0
2180
2180
2181 def funcsused(tree):
2181 def funcsused(tree):
2182 if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'):
2182 if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'):
2183 return set()
2183 return set()
2184 else:
2184 else:
2185 funcs = set()
2185 funcs = set()
2186 for s in tree[1:]:
2186 for s in tree[1:]:
2187 funcs |= funcsused(s)
2187 funcs |= funcsused(s)
2188 if tree[0] == 'func':
2188 if tree[0] == 'func':
2189 funcs.add(tree[1][1])
2189 funcs.add(tree[1][1])
2190 return funcs
2190 return funcs
2191
2191
2192 class baseset(list):
2192 class baseset(list):
2193 """Basic data structure that represents a revset and contains the basic
2193 """Basic data structure that represents a revset and contains the basic
2194 operation that it should be able to perform.
2194 operation that it should be able to perform.
2195
2195
2196 Every method in this class should be implemented by any smartset class.
2196 Every method in this class should be implemented by any smartset class.
2197 """
2197 """
2198 def __init__(self, data=()):
2198 def __init__(self, data=()):
2199 super(baseset, self).__init__(data)
2199 super(baseset, self).__init__(data)
2200 self._set = None
2200 self._set = None
2201
2201
2202 def ascending(self):
2202 def ascending(self):
2203 """Sorts the set in ascending order (in place).
2203 """Sorts the set in ascending order (in place).
2204
2204
2205 This is part of the mandatory API for smartset."""
2205 This is part of the mandatory API for smartset."""
2206 self.sort()
2206 self.sort()
2207
2207
2208 def descending(self):
2208 def descending(self):
2209 """Sorts the set in descending order (in place).
2209 """Sorts the set in descending order (in place).
2210
2210
2211 This is part of the mandatory API for smartset."""
2211 This is part of the mandatory API for smartset."""
2212 self.sort(reverse=True)
2212 self.sort(reverse=True)
2213
2213
2214 def min(self):
2214 def min(self):
2215 return min(self)
2215 return min(self)
2216
2216
2217 def max(self):
2217 def max(self):
2218 return max(self)
2218 return max(self)
2219
2219
2220 def set(self):
2220 def set(self):
2221 """Returns a set or a smartset containing all the elements.
2221 """Returns a set or a smartset containing all the elements.
2222
2222
2223 The returned structure should be the fastest option for membership
2223 The returned structure should be the fastest option for membership
2224 testing.
2224 testing.
2225
2225
2226 This is part of the mandatory API for smartset."""
2226 This is part of the mandatory API for smartset."""
2227 if not self._set:
2227 if not self._set:
2228 self._set = set(self)
2228 self._set = set(self)
2229 return self._set
2229 return self._set
2230
2230
2231 @util.propertycache
2231 @util.propertycache
2232 def __contains__(self):
2232 def __contains__(self):
2233 return self.set().__contains__
2233 return self.set().__contains__
2234
2234
2235 def __sub__(self, other):
2235 def __sub__(self, other):
2236 """Returns a new object with the substraction of the two collections.
2236 """Returns a new object with the substraction of the two collections.
2237
2237
2238 This is part of the mandatory API for smartset."""
2238 This is part of the mandatory API for smartset."""
2239 # If we are operating on 2 baseset, do the computation now since all
2239 # If we are operating on 2 baseset, do the computation now since all
2240 # data is available. The alternative is to involve a lazyset, which
2240 # data is available. The alternative is to involve a lazyset, which
2241 # may be slow.
2241 # may be slow.
2242 if isinstance(other, baseset):
2242 if isinstance(other, baseset):
2243 other = other.set()
2243 other = other.set()
2244 return baseset([x for x in self if x not in other])
2244 return baseset([x for x in self if x not in other])
2245
2245
2246 return self.filter(lambda x: x not in other)
2246 return self.filter(lambda x: x not in other)
2247
2247
2248 def __and__(self, other):
2248 def __and__(self, other):
2249 """Returns a new object with the intersection of the two collections.
2249 """Returns a new object with the intersection of the two collections.
2250
2250
2251 This is part of the mandatory API for smartset."""
2251 This is part of the mandatory API for smartset."""
2252 if isinstance(other, baseset):
2252 if isinstance(other, baseset):
2253 other = other.set()
2253 other = other.set()
2254 return baseset([y for y in self if y in other])
2254 return baseset([y for y in self if y in other])
2255
2255
2256 def __add__(self, other):
2256 def __add__(self, other):
2257 """Returns a new object with the union of the two collections.
2257 """Returns a new object with the union of the two collections.
2258
2258
2259 This is part of the mandatory API for smartset."""
2259 This is part of the mandatory API for smartset."""
2260 s = self.set()
2260 s = self.set()
2261 l = [r for r in other if r not in s]
2261 l = [r for r in other if r not in s]
2262 return baseset(list(self) + l)
2262 return baseset(list(self) + l)
2263
2263
2264 def isascending(self):
2264 def isascending(self):
2265 """Returns True if the collection is ascending order, False if not.
2265 """Returns True if the collection is ascending order, False if not.
2266
2266
2267 This is part of the mandatory API for smartset."""
2267 This is part of the mandatory API for smartset."""
2268 return False
2268 return False
2269
2269
2270 def isdescending(self):
2270 def isdescending(self):
2271 """Returns True if the collection is descending order, False if not.
2271 """Returns True if the collection is descending order, False if not.
2272
2272
2273 This is part of the mandatory API for smartset."""
2273 This is part of the mandatory API for smartset."""
2274 return False
2274 return False
2275
2275
2276 def filter(self, condition):
2276 def filter(self, condition):
2277 """Returns this smartset filtered by condition as a new smartset.
2277 """Returns this smartset filtered by condition as a new smartset.
2278
2278
2279 `condition` is a callable which takes a revision number and returns a
2279 `condition` is a callable which takes a revision number and returns a
2280 boolean.
2280 boolean.
2281
2281
2282 This is part of the mandatory API for smartset."""
2282 This is part of the mandatory API for smartset."""
2283 return lazyset(self, condition)
2283 return lazyset(self, condition)
2284
2284
2285 class _orderedsetmixin(object):
2285 class _orderedsetmixin(object):
2286 """Mixin class with utility methods for smartsets
2286 """Mixin class with utility methods for smartsets
2287
2287
2288 This should be extended by smartsets which have the isascending(),
2288 This should be extended by smartsets which have the isascending(),
2289 isdescending() and reverse() methods"""
2289 isdescending() and reverse() methods"""
2290
2290
2291 def _first(self):
2291 def _first(self):
2292 """return the first revision in the set"""
2292 """return the first revision in the set"""
2293 for r in self:
2293 for r in self:
2294 return r
2294 return r
2295 raise ValueError('arg is an empty sequence')
2295 raise ValueError('arg is an empty sequence')
2296
2296
2297 def _last(self):
2297 def _last(self):
2298 """return the last revision in the set"""
2298 """return the last revision in the set"""
2299 self.reverse()
2299 self.reverse()
2300 m = self._first()
2300 m = self._first()
2301 self.reverse()
2301 self.reverse()
2302 return m
2302 return m
2303
2303
2304 def min(self):
2304 def min(self):
2305 """return the smallest element in the set"""
2305 """return the smallest element in the set"""
2306 if self.isascending():
2306 if self.isascending():
2307 return self._first()
2307 return self._first()
2308 return self._last()
2308 return self._last()
2309
2309
2310 def max(self):
2310 def max(self):
2311 """return the largest element in the set"""
2311 """return the largest element in the set"""
2312 if self.isascending():
2312 if self.isascending():
2313 return self._last()
2313 return self._last()
2314 return self._first()
2314 return self._first()
2315
2315
2316 class lazyset(object):
2316 class lazyset(object):
2317 """Duck type for baseset class which iterates lazily over the revisions in
2317 """Duck type for baseset class which iterates lazily over the revisions in
2318 the subset and contains a function which tests for membership in the
2318 the subset and contains a function which tests for membership in the
2319 revset
2319 revset
2320 """
2320 """
2321 def __init__(self, subset, condition=lambda x: True):
2321 def __init__(self, subset, condition=lambda x: True):
2322 """
2322 """
2323 condition: a function that decide whether a revision in the subset
2323 condition: a function that decide whether a revision in the subset
2324 belongs to the revset or not.
2324 belongs to the revset or not.
2325 """
2325 """
2326 self._subset = subset
2326 self._subset = subset
2327 self._condition = condition
2327 self._condition = condition
2328 self._cache = {}
2328 self._cache = {}
2329
2329
2330 def ascending(self):
2330 def ascending(self):
2331 self._subset.sort()
2331 self._subset.sort()
2332
2332
2333 def descending(self):
2333 def descending(self):
2334 self._subset.sort(reverse=True)
2334 self._subset.sort(reverse=True)
2335
2335
2336 def min(self):
2336 def min(self):
2337 return min(self)
2337 return min(self)
2338
2338
2339 def max(self):
2339 def max(self):
2340 return max(self)
2340 return max(self)
2341
2341
2342 def __contains__(self, x):
2342 def __contains__(self, x):
2343 c = self._cache
2343 c = self._cache
2344 if x not in c:
2344 if x not in c:
2345 v = c[x] = x in self._subset and self._condition(x)
2345 v = c[x] = x in self._subset and self._condition(x)
2346 return v
2346 return v
2347 return c[x]
2347 return c[x]
2348
2348
2349 def __iter__(self):
2349 def __iter__(self):
2350 cond = self._condition
2350 cond = self._condition
2351 for x in self._subset:
2351 for x in self._subset:
2352 if cond(x):
2352 if cond(x):
2353 yield x
2353 yield x
2354
2354
2355 def __and__(self, x):
2355 def __and__(self, x):
2356 return lazyset(self, x.__contains__)
2356 return lazyset(self, x.__contains__)
2357
2357
2358 def __sub__(self, x):
2358 def __sub__(self, x):
2359 return lazyset(self, lambda r: r not in x)
2359 return lazyset(self, lambda r: r not in x)
2360
2360
2361 def __add__(self, x):
2361 def __add__(self, x):
2362 return _addset(self, x)
2362 return _addset(self, x)
2363
2363
2364 def __nonzero__(self):
2364 def __nonzero__(self):
2365 for r in self:
2365 for r in self:
2366 return True
2366 return True
2367 return False
2367 return False
2368
2368
2369 def __len__(self):
2369 def __len__(self):
2370 # Basic implementation to be changed in future patches.
2370 # Basic implementation to be changed in future patches.
2371 l = baseset([r for r in self])
2371 l = baseset([r for r in self])
2372 return len(l)
2372 return len(l)
2373
2373
2374 def __getitem__(self, x):
2374 def __getitem__(self, x):
2375 # Basic implementation to be changed in future patches.
2375 # Basic implementation to be changed in future patches.
2376 l = baseset([r for r in self])
2376 l = baseset([r for r in self])
2377 return l[x]
2377 return l[x]
2378
2378
2379 def sort(self, reverse=False):
2379 def sort(self, reverse=False):
2380 if not util.safehasattr(self._subset, 'sort'):
2380 if not util.safehasattr(self._subset, 'sort'):
2381 self._subset = baseset(self._subset)
2381 self._subset = baseset(self._subset)
2382 self._subset.sort(reverse=reverse)
2382 self._subset.sort(reverse=reverse)
2383
2383
2384 def reverse(self):
2384 def reverse(self):
2385 self._subset.reverse()
2385 self._subset.reverse()
2386
2386
2387 def set(self):
2387 def set(self):
2388 return set([r for r in self])
2388 return set([r for r in self])
2389
2389
2390 def isascending(self):
2390 def isascending(self):
2391 return False
2391 return False
2392
2392
2393 def isdescending(self):
2393 def isdescending(self):
2394 return False
2394 return False
2395
2395
2396 def filter(self, l):
2396 def filter(self, l):
2397 return lazyset(self, l)
2397 return lazyset(self, l)
2398
2398
2399 class orderedlazyset(_orderedsetmixin, lazyset):
2399 class orderedlazyset(_orderedsetmixin, lazyset):
2400 """Subclass of lazyset which subset can be ordered either ascending or
2400 """Subclass of lazyset which subset can be ordered either ascending or
2401 descendingly
2401 descendingly
2402 """
2402 """
2403 def __init__(self, subset, condition, ascending=True):
2403 def __init__(self, subset, condition, ascending=True):
2404 super(orderedlazyset, self).__init__(subset, condition)
2404 super(orderedlazyset, self).__init__(subset, condition)
2405 self._ascending = ascending
2405 self._ascending = ascending
2406
2406
2407 def filter(self, l):
2407 def filter(self, l):
2408 return orderedlazyset(self, l, ascending=self._ascending)
2408 return orderedlazyset(self, l, ascending=self._ascending)
2409
2409
2410 def ascending(self):
2410 def ascending(self):
2411 if not self._ascending:
2411 if not self._ascending:
2412 self.reverse()
2412 self.reverse()
2413
2413
2414 def descending(self):
2414 def descending(self):
2415 if self._ascending:
2415 if self._ascending:
2416 self.reverse()
2416 self.reverse()
2417
2417
2418 def __and__(self, x):
2418 def __and__(self, x):
2419 return orderedlazyset(self, x.__contains__,
2419 return orderedlazyset(self, x.__contains__,
2420 ascending=self._ascending)
2420 ascending=self._ascending)
2421
2421
2422 def __sub__(self, x):
2422 def __sub__(self, x):
2423 return orderedlazyset(self, lambda r: r not in x,
2423 return orderedlazyset(self, lambda r: r not in x,
2424 ascending=self._ascending)
2424 ascending=self._ascending)
2425
2425
2426 def __add__(self, x):
2426 def __add__(self, x):
2427 kwargs = {}
2427 kwargs = {}
2428 if self.isascending() and x.isascending():
2428 if self.isascending() and x.isascending():
2429 kwargs['ascending'] = True
2429 kwargs['ascending'] = True
2430 if self.isdescending() and x.isdescending():
2430 if self.isdescending() and x.isdescending():
2431 kwargs['ascending'] = False
2431 kwargs['ascending'] = False
2432 return _addset(self, x, **kwargs)
2432 return _addset(self, x, **kwargs)
2433
2433
2434 def sort(self, reverse=False):
2434 def sort(self, reverse=False):
2435 if reverse:
2435 if reverse:
2436 if self._ascending:
2436 if self._ascending:
2437 self._subset.sort(reverse=reverse)
2437 self._subset.sort(reverse=reverse)
2438 else:
2438 else:
2439 if not self._ascending:
2439 if not self._ascending:
2440 self._subset.sort(reverse=reverse)
2440 self._subset.sort(reverse=reverse)
2441 self._ascending = not reverse
2441 self._ascending = not reverse
2442
2442
2443 def isascending(self):
2443 def isascending(self):
2444 return self._ascending
2444 return self._ascending
2445
2445
2446 def isdescending(self):
2446 def isdescending(self):
2447 return not self._ascending
2447 return not self._ascending
2448
2448
2449 def reverse(self):
2449 def reverse(self):
2450 self._subset.reverse()
2450 self._subset.reverse()
2451 self._ascending = not self._ascending
2451 self._ascending = not self._ascending
2452
2452
2453 class _addset(_orderedsetmixin):
2453 class _addset(_orderedsetmixin):
2454 """Represent the addition of two sets
2454 """Represent the addition of two sets
2455
2455
2456 Wrapper structure for lazily adding two structures without losing much
2456 Wrapper structure for lazily adding two structures without losing much
2457 performance on the __contains__ method
2457 performance on the __contains__ method
2458
2458
2459 If the ascending attribute is set, that means the two structures are
2459 If the ascending attribute is set, that means the two structures are
2460 ordered in either an ascending or descending way. Therefore, we can add
2460 ordered in either an ascending or descending way. Therefore, we can add
2461 them maintaining the order by iterating over both at the same time
2461 them maintaining the order by iterating over both at the same time
2462
2462
2463 This class does not duck-type baseset and it's only supposed to be used
2463 This class does not duck-type baseset and it's only supposed to be used
2464 internally
2464 internally
2465 """
2465 """
2466 def __init__(self, revs1, revs2, ascending=None):
2466 def __init__(self, revs1, revs2, ascending=None):
2467 self._r1 = revs1
2467 self._r1 = revs1
2468 self._r2 = revs2
2468 self._r2 = revs2
2469 self._iter = None
2469 self._iter = None
2470 self._ascending = ascending
2470 self._ascending = ascending
2471 self._genlist = None
2471 self._genlist = None
2472
2472
2473 def __len__(self):
2473 def __len__(self):
2474 return len(self._list)
2474 return len(self._list)
2475
2475
2476 @util.propertycache
2476 @util.propertycache
2477 def _list(self):
2477 def _list(self):
2478 if not self._genlist:
2478 if not self._genlist:
2479 self._genlist = baseset(self._iterator())
2479 self._genlist = baseset(self._iterator())
2480 return self._genlist
2480 return self._genlist
2481
2481
2482 def filter(self, condition):
2482 def filter(self, condition):
2483 if self._ascending is not None:
2483 if self._ascending is not None:
2484 return orderedlazyset(self, condition, ascending=self._ascending)
2484 return orderedlazyset(self, condition, ascending=self._ascending)
2485 return lazyset(self, condition)
2485 return lazyset(self, condition)
2486
2486
2487 def ascending(self):
2487 def ascending(self):
2488 if self._ascending is None:
2488 if self._ascending is None:
2489 self.sort()
2489 self.sort()
2490 self._ascending = True
2490 self._ascending = True
2491 else:
2491 else:
2492 if not self._ascending:
2492 if not self._ascending:
2493 self.reverse()
2493 self.reverse()
2494
2494
2495 def descending(self):
2495 def descending(self):
2496 if self._ascending is None:
2496 if self._ascending is None:
2497 self.sort(reverse=True)
2497 self.sort(reverse=True)
2498 self._ascending = False
2498 self._ascending = False
2499 else:
2499 else:
2500 if self._ascending:
2500 if self._ascending:
2501 self.reverse()
2501 self.reverse()
2502
2502
2503 def __and__(self, other):
2503 def __and__(self, other):
2504 filterfunc = other.__contains__
2504 filterfunc = other.__contains__
2505 if self._ascending is not None:
2505 if self._ascending is not None:
2506 return orderedlazyset(self, filterfunc, ascending=self._ascending)
2506 return orderedlazyset(self, filterfunc, ascending=self._ascending)
2507 return lazyset(self, filterfunc)
2507 return lazyset(self, filterfunc)
2508
2508
2509 def __sub__(self, other):
2509 def __sub__(self, other):
2510 filterfunc = lambda r: r not in other
2510 filterfunc = lambda r: r not in other
2511 if self._ascending is not None:
2511 if self._ascending is not None:
2512 return orderedlazyset(self, filterfunc, ascending=self._ascending)
2512 return orderedlazyset(self, filterfunc, ascending=self._ascending)
2513 return lazyset(self, filterfunc)
2513 return lazyset(self, filterfunc)
2514
2514
2515 def __add__(self, other):
2515 def __add__(self, other):
2516 """When both collections are ascending or descending, preserve the order
2516 """When both collections are ascending or descending, preserve the order
2517 """
2517 """
2518 kwargs = {}
2518 kwargs = {}
2519 if self._ascending is not None:
2519 if self._ascending is not None:
2520 if self.isascending() and other.isascending():
2520 if self.isascending() and other.isascending():
2521 kwargs['ascending'] = True
2521 kwargs['ascending'] = True
2522 if self.isdescending() and other.isdescending():
2522 if self.isdescending() and other.isdescending():
2523 kwargs['ascending'] = False
2523 kwargs['ascending'] = False
2524 return _addset(self, other, **kwargs)
2524 return _addset(self, other, **kwargs)
2525
2525
2526 def _iterator(self):
2526 def _iterator(self):
2527 """Iterate over both collections without repeating elements
2527 """Iterate over both collections without repeating elements
2528
2528
2529 If the ascending attribute is not set, iterate over the first one and
2529 If the ascending attribute is not set, iterate over the first one and
2530 then over the second one checking for membership on the first one so we
2530 then over the second one checking for membership on the first one so we
2531 dont yield any duplicates.
2531 dont yield any duplicates.
2532
2532
2533 If the ascending attribute is set, iterate over both collections at the
2533 If the ascending attribute is set, iterate over both collections at the
2534 same time, yielding only one value at a time in the given order.
2534 same time, yielding only one value at a time in the given order.
2535 """
2535 """
2536 if not self._iter:
2536 if not self._iter:
2537 def gen():
2537 def gen():
2538 if self._ascending is None:
2538 if self._ascending is None:
2539 for r in self._r1:
2539 for r in self._r1:
2540 yield r
2540 yield r
2541 s = self._r1.set()
2541 s = self._r1.set()
2542 for r in self._r2:
2542 for r in self._r2:
2543 if r not in s:
2543 if r not in s:
2544 yield r
2544 yield r
2545 else:
2545 else:
2546 iter1 = iter(self._r1)
2546 iter1 = iter(self._r1)
2547 iter2 = iter(self._r2)
2547 iter2 = iter(self._r2)
2548
2548
2549 val1 = None
2549 val1 = None
2550 val2 = None
2550 val2 = None
2551
2551
2552 choice = max
2552 choice = max
2553 if self._ascending:
2553 if self._ascending:
2554 choice = min
2554 choice = min
2555 try:
2555 try:
2556 # Consume both iterators in an ordered way until one is
2556 # Consume both iterators in an ordered way until one is
2557 # empty
2557 # empty
2558 while True:
2558 while True:
2559 if val1 is None:
2559 if val1 is None:
2560 val1 = iter1.next()
2560 val1 = iter1.next()
2561 if val2 is None:
2561 if val2 is None:
2562 val2 = iter2.next()
2562 val2 = iter2.next()
2563 next = choice(val1, val2)
2563 next = choice(val1, val2)
2564 yield next
2564 yield next
2565 if val1 == next:
2565 if val1 == next:
2566 val1 = None
2566 val1 = None
2567 if val2 == next:
2567 if val2 == next:
2568 val2 = None
2568 val2 = None
2569 except StopIteration:
2569 except StopIteration:
2570 # Flush any remaining values and consume the other one
2570 # Flush any remaining values and consume the other one
2571 it = iter2
2571 it = iter2
2572 if val1 is not None:
2572 if val1 is not None:
2573 yield val1
2573 yield val1
2574 it = iter1
2574 it = iter1
2575 elif val2 is not None:
2575 elif val2 is not None:
2576 # might have been equality and both are empty
2576 # might have been equality and both are empty
2577 yield val2
2577 yield val2
2578 for val in it:
2578 for val in it:
2579 yield val
2579 yield val
2580
2580
2581 self._iter = _generatorset(gen())
2581 self._iter = _generatorset(gen())
2582
2582
2583 return self._iter
2583 return self._iter
2584
2584
2585 def __iter__(self):
2585 def __iter__(self):
2586 if self._genlist:
2586 if self._genlist:
2587 return iter(self._genlist)
2587 return iter(self._genlist)
2588 return iter(self._iterator())
2588 return iter(self._iterator())
2589
2589
2590 def __contains__(self, x):
2590 def __contains__(self, x):
2591 return x in self._r1 or x in self._r2
2591 return x in self._r1 or x in self._r2
2592
2592
2593 def set(self):
2593 def set(self):
2594 return self
2594 return self
2595
2595
2596 def sort(self, reverse=False):
2596 def sort(self, reverse=False):
2597 """Sort the added set
2597 """Sort the added set
2598
2598
2599 For this we use the cached list with all the generated values and if we
2599 For this we use the cached list with all the generated values and if we
2600 know they are ascending or descending we can sort them in a smart way.
2600 know they are ascending or descending we can sort them in a smart way.
2601 """
2601 """
2602 if self._ascending is None:
2602 if self._ascending is None:
2603 self._list.sort(reverse=reverse)
2603 self._list.sort(reverse=reverse)
2604 self._ascending = not reverse
2604 self._ascending = not reverse
2605 else:
2605 else:
2606 if bool(self._ascending) == bool(reverse):
2606 if bool(self._ascending) == bool(reverse):
2607 self.reverse()
2607 self.reverse()
2608
2608
2609 def isascending(self):
2609 def isascending(self):
2610 return self._ascending is not None and self._ascending
2610 return self._ascending is not None and self._ascending
2611
2611
2612 def isdescending(self):
2612 def isdescending(self):
2613 return self._ascending is not None and not self._ascending
2613 return self._ascending is not None and not self._ascending
2614
2614
2615 def reverse(self):
2615 def reverse(self):
2616 self._list.reverse()
2616 self._list.reverse()
2617 if self._ascending is not None:
2617 if self._ascending is not None:
2618 self._ascending = not self._ascending
2618 self._ascending = not self._ascending
2619
2619
2620 class _generatorset(object):
2620 class _generatorset(object):
2621 """Wrap a generator for lazy iteration
2621 """Wrap a generator for lazy iteration
2622
2622
2623 Wrapper structure for generators that provides lazy membership and can
2623 Wrapper structure for generators that provides lazy membership and can
2624 be iterated more than once.
2624 be iterated more than once.
2625 When asked for membership it generates values until either it finds the
2625 When asked for membership it generates values until either it finds the
2626 requested one or has gone through all the elements in the generator
2626 requested one or has gone through all the elements in the generator
2627
2627
2628 This class does not duck-type baseset and it's only supposed to be used
2628 This class does not duck-type baseset and it's only supposed to be used
2629 internally
2629 internally
2630 """
2630 """
2631 def __init__(self, gen):
2631 def __init__(self, gen):
2632 """
2632 """
2633 gen: a generator producing the values for the generatorset.
2633 gen: a generator producing the values for the generatorset.
2634 """
2634 """
2635 self._gen = gen
2635 self._gen = gen
2636 self._cache = {}
2636 self._cache = {}
2637 self._genlist = baseset([])
2637 self._genlist = baseset([])
2638 self._finished = False
2638 self._finished = False
2639
2639
2640 def __contains__(self, x):
2640 def __contains__(self, x):
2641 if x in self._cache:
2641 if x in self._cache:
2642 return self._cache[x]
2642 return self._cache[x]
2643
2643
2644 # Use new values only, as existing values would be cached.
2644 # Use new values only, as existing values would be cached.
2645 for l in self._consumegen():
2645 for l in self._consumegen():
2646 if l == x:
2646 if l == x:
2647 return True
2647 return True
2648
2648
2649 self._cache[x] = False
2649 self._cache[x] = False
2650 return False
2650 return False
2651
2651
2652 def __iter__(self):
2652 def __iter__(self):
2653 if self._finished:
2653 if self._finished:
2654 for x in self._genlist:
2654 for x in self._genlist:
2655 yield x
2655 yield x
2656 return
2656 return
2657
2657
2658 # We have to use this complex iteration strategy to allow multiple
2658 # We have to use this complex iteration strategy to allow multiple
2659 # iterations at the same time. We need to be able to catch revision
2659 # iterations at the same time. We need to be able to catch revision
2660 # removed from `consumegen` and added to genlist in another instance.
2660 # removed from `consumegen` and added to genlist in another instance.
2661 #
2661 #
2662 # Getting rid of it would provide an about 15% speed up on this
2662 # Getting rid of it would provide an about 15% speed up on this
2663 # iteration.
2663 # iteration.
2664 i = 0
2664 i = 0
2665 genlist = self._genlist
2665 genlist = self._genlist
2666 consume = self._consumegen()
2666 consume = self._consumegen()
2667 while True:
2667 while True:
2668 if i < len(genlist):
2668 if i < len(genlist):
2669 yield genlist[i]
2669 yield genlist[i]
2670 else:
2670 else:
2671 yield consume.next()
2671 yield consume.next()
2672 i += 1
2672 i += 1
2673
2673
2674 def _consumegen(self):
2674 def _consumegen(self):
2675 cache = self._cache
2675 cache = self._cache
2676 genlist = self._genlist.append
2676 genlist = self._genlist.append
2677 for item in self._gen:
2677 for item in self._gen:
2678 cache[item] = True
2678 cache[item] = True
2679 genlist(item)
2679 genlist(item)
2680 yield item
2680 yield item
2681 self._finished = True
2681 self._finished = True
2682
2682
2683 def set(self):
2683 def set(self):
2684 return self
2684 return self
2685
2685
2686 def sort(self, reverse=False):
2686 def sort(self, reverse=False):
2687 if not self._finished:
2687 if not self._finished:
2688 for i in self:
2688 for i in self:
2689 continue
2689 continue
2690 self._genlist.sort(reverse=reverse)
2690 self._genlist.sort(reverse=reverse)
2691
2691
2692 class _ascgeneratorset(_generatorset):
2692 class _ascgeneratorset(_generatorset):
2693 """Wrap a generator of ascending elements for lazy iteration
2693 """Wrap a generator of ascending elements for lazy iteration
2694
2694
2695 Same structure as _generatorset but stops iterating after it goes past
2695 Same structure as _generatorset but stops iterating after it goes past
2696 the value when asked for membership and the element is not contained
2696 the value when asked for membership and the element is not contained
2697
2697
2698 This class does not duck-type baseset and it's only supposed to be used
2698 This class does not duck-type baseset and it's only supposed to be used
2699 internally
2699 internally
2700 """
2700 """
2701 def __contains__(self, x):
2701 def __contains__(self, x):
2702 if x in self._cache:
2702 if x in self._cache:
2703 return self._cache[x]
2703 return self._cache[x]
2704
2704
2705 # Use new values only, as existing values would be cached.
2705 # Use new values only, as existing values would be cached.
2706 for l in self._consumegen():
2706 for l in self._consumegen():
2707 if l == x:
2707 if l == x:
2708 return True
2708 return True
2709 if l > x:
2709 if l > x:
2710 break
2710 break
2711
2711
2712 self._cache[x] = False
2712 self._cache[x] = False
2713 return False
2713 return False
2714
2714
2715 class _descgeneratorset(_generatorset):
2715 class _descgeneratorset(_generatorset):
2716 """Wrap a generator of descending elements for lazy iteration
2716 """Wrap a generator of descending elements for lazy iteration
2717
2717
2718 Same structure as _generatorset but stops iterating after it goes past
2718 Same structure as _generatorset but stops iterating after it goes past
2719 the value when asked for membership and the element is not contained
2719 the value when asked for membership and the element is not contained
2720
2720
2721 This class does not duck-type baseset and it's only supposed to be used
2721 This class does not duck-type baseset and it's only supposed to be used
2722 internally
2722 internally
2723 """
2723 """
2724 def __contains__(self, x):
2724 def __contains__(self, x):
2725 if x in self._cache:
2725 if x in self._cache:
2726 return self._cache[x]
2726 return self._cache[x]
2727
2727
2728 # Use new values only, as existing values would be cached.
2728 # Use new values only, as existing values would be cached.
2729 for l in self._consumegen():
2729 for l in self._consumegen():
2730 if l == x:
2730 if l == x:
2731 return True
2731 return True
2732 if l < x:
2732 if l < x:
2733 break
2733 break
2734
2734
2735 self._cache[x] = False
2735 self._cache[x] = False
2736 return False
2736 return False
2737
2737
2738 def spanset(repo, start=None, end=None):
2738 def spanset(repo, start=None, end=None):
2739 """factory function to dispatch between fullreposet and actual spanset
2739 """factory function to dispatch between fullreposet and actual spanset
2740
2740
2741 Feel free to update all spanset call sites and kill this function at some
2741 Feel free to update all spanset call sites and kill this function at some
2742 point.
2742 point.
2743 """
2743 """
2744 if start is None and end is None:
2744 if start is None and end is None:
2745 return fullreposet(repo)
2745 return fullreposet(repo)
2746 return _spanset(repo, start, end)
2746 return _spanset(repo, start, end)
2747
2747
2748
2748
2749 class _spanset(_orderedsetmixin):
2749 class _spanset(_orderedsetmixin):
2750 """Duck type for baseset class which represents a range of revisions and
2750 """Duck type for baseset class which represents a range of revisions and
2751 can work lazily and without having all the range in memory
2751 can work lazily and without having all the range in memory
2752
2752
2753 Note that spanset(x, y) behave almost like xrange(x, y) except for two
2753 Note that spanset(x, y) behave almost like xrange(x, y) except for two
2754 notable points:
2754 notable points:
2755 - when x < y it will be automatically descending,
2755 - when x < y it will be automatically descending,
2756 - revision filtered with this repoview will be skipped.
2756 - revision filtered with this repoview will be skipped.
2757
2757
2758 """
2758 """
2759 def __init__(self, repo, start=0, end=None):
2759 def __init__(self, repo, start=0, end=None):
2760 """
2760 """
2761 start: first revision included the set
2761 start: first revision included the set
2762 (default to 0)
2762 (default to 0)
2763 end: first revision excluded (last+1)
2763 end: first revision excluded (last+1)
2764 (default to len(repo)
2764 (default to len(repo)
2765
2765
2766 Spanset will be descending if `end` < `start`.
2766 Spanset will be descending if `end` < `start`.
2767 """
2767 """
2768 self._start = start
2768 self._start = start
2769 if end is not None:
2769 if end is not None:
2770 self._end = end
2770 self._end = end
2771 else:
2771 else:
2772 self._end = len(repo)
2772 self._end = len(repo)
2773 self._hiddenrevs = repo.changelog.filteredrevs
2773 self._hiddenrevs = repo.changelog.filteredrevs
2774
2774
2775 def ascending(self):
2775 def ascending(self):
2776 if not self.isascending():
2776 if not self.isascending():
2777 self.reverse()
2777 self.reverse()
2778
2778
2779 def descending(self):
2779 def descending(self):
2780 if not self.isdescending():
2780 if not self.isdescending():
2781 self.reverse()
2781 self.reverse()
2782
2782
2783 def __iter__(self):
2783 def __iter__(self):
2784 if self.isascending():
2784 if self.isascending():
2785 iterrange = xrange(self._start, self._end)
2785 iterrange = xrange(self._start, self._end)
2786 else:
2786 else:
2787 iterrange = xrange(self._start, self._end, -1)
2787 iterrange = xrange(self._start, self._end, -1)
2788
2788
2789 if self._hiddenrevs:
2789 if self._hiddenrevs:
2790 s = self._hiddenrevs
2790 s = self._hiddenrevs
2791 for r in iterrange:
2791 for r in iterrange:
2792 if r not in s:
2792 if r not in s:
2793 yield r
2793 yield r
2794 else:
2794 else:
2795 for r in iterrange:
2795 for r in iterrange:
2796 yield r
2796 yield r
2797
2797
2798 def __contains__(self, rev):
2798 def __contains__(self, rev):
2799 start = self._start
2799 start = self._start
2800 end = self._end
2800 end = self._end
2801 hidden = self._hiddenrevs
2801 hidden = self._hiddenrevs
2802 return (((end < rev <= start) or (start <= rev and rev < end))
2802 return (((end < rev <= start) or (start <= rev and rev < end))
2803 and not (hidden and rev in hidden))
2803 and not (hidden and rev in hidden))
2804
2804
2805 def __nonzero__(self):
2805 def __nonzero__(self):
2806 for r in self:
2806 for r in self:
2807 return True
2807 return True
2808 return False
2808 return False
2809
2809
2810 def __and__(self, x):
2810 def __and__(self, x):
2811 if isinstance(x, baseset):
2811 if isinstance(x, baseset):
2812 x = x.set()
2812 x = x.set()
2813 return orderedlazyset(self, x.__contains__,
2813 return orderedlazyset(self, x.__contains__,
2814 ascending=self.isascending())
2814 ascending=self.isascending())
2815
2815
2816 def __sub__(self, x):
2816 def __sub__(self, x):
2817 if isinstance(x, baseset):
2817 if isinstance(x, baseset):
2818 x = x.set()
2818 x = x.set()
2819 return orderedlazyset(self, lambda r: r not in x,
2819 return orderedlazyset(self, lambda r: r not in x,
2820 ascending=self.isascending())
2820 ascending=self.isascending())
2821
2821
2822 def __add__(self, x):
2822 def __add__(self, x):
2823 kwargs = {}
2823 kwargs = {}
2824 if self.isascending() and x.isascending():
2824 if self.isascending() and x.isascending():
2825 kwargs['ascending'] = True
2825 kwargs['ascending'] = True
2826 if self.isdescending() and x.isdescending():
2826 if self.isdescending() and x.isdescending():
2827 kwargs['ascending'] = False
2827 kwargs['ascending'] = False
2828 return _addset(self, x, **kwargs)
2828 return _addset(self, x, **kwargs)
2829
2829
2830 def __len__(self):
2830 def __len__(self):
2831 if not self._hiddenrevs:
2831 if not self._hiddenrevs:
2832 return abs(self._end - self._start)
2832 return abs(self._end - self._start)
2833 else:
2833 else:
2834 count = 0
2834 count = 0
2835 start = self._start
2835 start = self._start
2836 end = self._end
2836 end = self._end
2837 for rev in self._hiddenrevs:
2837 for rev in self._hiddenrevs:
2838 if (end < rev <= start) or (start <= rev < end):
2838 if (end < rev <= start) or (start <= rev < end):
2839 count += 1
2839 count += 1
2840 return abs(self._end - self._start) - count
2840 return abs(self._end - self._start) - count
2841
2841
2842 def __getitem__(self, x):
2842 def __getitem__(self, x):
2843 # Basic implementation to be changed in future patches.
2843 # Basic implementation to be changed in future patches.
2844 l = baseset([r for r in self])
2844 l = baseset([r for r in self])
2845 return l[x]
2845 return l[x]
2846
2846
2847 def sort(self, reverse=False):
2847 def sort(self, reverse=False):
2848 if bool(reverse) != (self._start > self._end):
2848 if bool(reverse) != (self._start > self._end):
2849 self.reverse()
2849 self.reverse()
2850
2850
2851 def reverse(self):
2851 def reverse(self):
2852 # Just switch the _start and _end parameters
2852 # Just switch the _start and _end parameters
2853 if self.isascending():
2853 if self.isascending():
2854 self._start, self._end = self._end - 1, self._start - 1
2854 self._start, self._end = self._end - 1, self._start - 1
2855 else:
2855 else:
2856 self._start, self._end = self._end + 1, self._start + 1
2856 self._start, self._end = self._end + 1, self._start + 1
2857
2857
2858 def set(self):
2858 def set(self):
2859 return self
2859 return self
2860
2860
2861 def isascending(self):
2861 def isascending(self):
2862 return self._start <= self._end
2862 return self._start <= self._end
2863
2863
2864 def isdescending(self):
2864 def isdescending(self):
2865 return self._start >= self._end
2865 return self._start >= self._end
2866
2866
2867 def filter(self, l):
2867 def filter(self, l):
2868 return orderedlazyset(self, l, ascending=self.isascending())
2868 return orderedlazyset(self, l, ascending=self.isascending())
2869
2869
2870 class fullreposet(_spanset):
2870 class fullreposet(_spanset):
2871 """a set containing all revisions in the repo
2871 """a set containing all revisions in the repo
2872
2872
2873 This class exists to host special optimisation.
2873 This class exists to host special optimisation.
2874 """
2874 """
2875
2875
2876 def __init__(self, repo):
2876 def __init__(self, repo):
2877 super(fullreposet, self).__init__(repo)
2877 super(fullreposet, self).__init__(repo)
2878
2878
2879 def __and__(self, other):
2879 def __and__(self, other):
2880 """fullrepo & other -> other
2880 """fullrepo & other -> other
2881
2881
2882 As self contains the whole repo, all of the other set should also be in
2882 As self contains the whole repo, all of the other set should also be in
2883 self. Therefor `self & other = other`.
2883 self. Therefor `self & other = other`.
2884
2884
2885 This boldly assumes the other contains valid revs only.
2885 This boldly assumes the other contains valid revs only.
2886 """
2886 """
2887 # other not a smartset, make is so
2887 # other not a smartset, make is so
2888 if not util.safehasattr(other, 'set'):
2888 if not util.safehasattr(other, 'set'):
2889 # filter out hidden revision
2889 # filter out hidden revision
2890 # (this boldly assumes all smartset are pure)
2890 # (this boldly assumes all smartset are pure)
2891 #
2891 #
2892 # `other` was used with "&", let's assume this is a set like
2892 # `other` was used with "&", let's assume this is a set like
2893 # object.
2893 # object.
2894 other = baseset(other - self._hiddenrevs)
2894 other = baseset(other - self._hiddenrevs)
2895 elif not util.safehasattr(other, 'ascending'):
2895 elif not util.safehasattr(other, 'ascending'):
2896 # "other" is _generatorset not a real smart set
2896 # "other" is _generatorset not a real smart set
2897 # we fallback to the old way (sad kitten)
2897 # we fallback to the old way (sad kitten)
2898 return super(fullreposet, self).__and__(other)
2898 return super(fullreposet, self).__and__(other)
2899
2899
2900 # preserve order:
2900 # preserve order:
2901 #
2901 #
2902 # this is probably useless and harmful in multiple cases but matches
2902 # this is probably useless and harmful in multiple cases but matches
2903 # the current behavior.
2903 # the current behavior.
2904 if self.isascending():
2904 if self.isascending():
2905 other.ascending()
2905 other.ascending()
2906 else:
2906 else:
2907 other.descending()
2907 other.descending()
2908 return other
2908 return other
2909
2909
2910 # tell hggettext to extract docstrings from these functions:
2910 # tell hggettext to extract docstrings from these functions:
2911 i18nfunctions = symbols.values()
2911 i18nfunctions = symbols.values()
General Comments 0
You need to be logged in to leave comments. Login now