##// END OF EJS Templates
baseset: fix isascending and isdescending...
Pierre-Yves David -
r22828:966860f7 default
parent child Browse files
Show More
@@ -1,3023 +1,3023 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 generatorset(iterate(), iterasc=False)
49 return generatorset(iterate(), iterasc=False)
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 generatorset(iterate(), iterasc=True)
73 return generatorset(iterate(), iterasc=True)
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.first(), n.last()
274 m, n = m.first(), n.last()
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 filteredset(subset, results.__contains__)
412 return filteredset(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 = (filteredset(s, subset.__contains__, ascending=True) +
668 result = (filteredset(s, subset.__contains__, ascending=True) +
669 filteredset(args, subset.__contains__, ascending=True))
669 filteredset(args, subset.__contains__, ascending=True))
670
670
671 # Wrap result in a filteredset since it's an addset, which doesn't
671 # Wrap result in a filteredset since it's an addset, which doesn't
672 # implement all the necessary functions to be consumed by callers.
672 # implement all the necessary functions to be consumed by callers.
673 return filteredset(result, lambda r: True, ascending=True)
673 return filteredset(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 & s
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 & s
837 return subset & s
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 result = []
1018 result = []
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 result.append(y)
1024 result.append(y)
1025 except (StopIteration):
1025 except (StopIteration):
1026 break
1026 break
1027 return baseset(result)
1027 return baseset(result)
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 result = []
1046 result = []
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 result.append(y)
1052 result.append(y)
1053 except (StopIteration):
1053 except (StopIteration):
1054 break
1054 break
1055 return baseset(result)
1055 return baseset(result)
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 & o
1170 return subset & o
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 if p >= 0:
1201 if p >= 0:
1202 return subset & baseset([p])
1202 return subset & baseset([p])
1203 return baseset()
1203 return baseset()
1204
1204
1205 ps = set()
1205 ps = set()
1206 cl = repo.changelog
1206 cl = repo.changelog
1207 for r in getset(repo, spanset(repo), x):
1207 for r in getset(repo, spanset(repo), x):
1208 ps.add(cl.parentrevs(r)[0])
1208 ps.add(cl.parentrevs(r)[0])
1209 ps -= set([node.nullrev])
1209 ps -= set([node.nullrev])
1210 return subset & ps
1210 return subset & ps
1211
1211
1212 def p2(repo, subset, x):
1212 def p2(repo, subset, x):
1213 """``p2([set])``
1213 """``p2([set])``
1214 Second parent of changesets in set, or the working directory.
1214 Second parent of changesets in set, or the working directory.
1215 """
1215 """
1216 if x is None:
1216 if x is None:
1217 ps = repo[x].parents()
1217 ps = repo[x].parents()
1218 try:
1218 try:
1219 p = ps[1].rev()
1219 p = ps[1].rev()
1220 if p >= 0:
1220 if p >= 0:
1221 return subset & baseset([p])
1221 return subset & baseset([p])
1222 return baseset()
1222 return baseset()
1223 except IndexError:
1223 except IndexError:
1224 return baseset()
1224 return baseset()
1225
1225
1226 ps = set()
1226 ps = set()
1227 cl = repo.changelog
1227 cl = repo.changelog
1228 for r in getset(repo, spanset(repo), x):
1228 for r in getset(repo, spanset(repo), x):
1229 ps.add(cl.parentrevs(r)[1])
1229 ps.add(cl.parentrevs(r)[1])
1230 ps -= set([node.nullrev])
1230 ps -= set([node.nullrev])
1231 return subset & ps
1231 return subset & ps
1232
1232
1233 def parents(repo, subset, x):
1233 def parents(repo, subset, x):
1234 """``parents([set])``
1234 """``parents([set])``
1235 The set of all parents for all changesets in set, or the working directory.
1235 The set of all parents for all changesets in set, or the working directory.
1236 """
1236 """
1237 if x is None:
1237 if x is None:
1238 ps = set(p.rev() for p in repo[x].parents())
1238 ps = set(p.rev() for p in repo[x].parents())
1239 else:
1239 else:
1240 ps = set()
1240 ps = set()
1241 cl = repo.changelog
1241 cl = repo.changelog
1242 for r in getset(repo, spanset(repo), x):
1242 for r in getset(repo, spanset(repo), x):
1243 ps.update(cl.parentrevs(r))
1243 ps.update(cl.parentrevs(r))
1244 ps -= set([node.nullrev])
1244 ps -= set([node.nullrev])
1245 return subset & ps
1245 return subset & ps
1246
1246
1247 def parentspec(repo, subset, x, n):
1247 def parentspec(repo, subset, x, n):
1248 """``set^0``
1248 """``set^0``
1249 The set.
1249 The set.
1250 ``set^1`` (or ``set^``), ``set^2``
1250 ``set^1`` (or ``set^``), ``set^2``
1251 First or second parent, respectively, of all changesets in set.
1251 First or second parent, respectively, of all changesets in set.
1252 """
1252 """
1253 try:
1253 try:
1254 n = int(n[1])
1254 n = int(n[1])
1255 if n not in (0, 1, 2):
1255 if n not in (0, 1, 2):
1256 raise ValueError
1256 raise ValueError
1257 except (TypeError, ValueError):
1257 except (TypeError, ValueError):
1258 raise error.ParseError(_("^ expects a number 0, 1, or 2"))
1258 raise error.ParseError(_("^ expects a number 0, 1, or 2"))
1259 ps = set()
1259 ps = set()
1260 cl = repo.changelog
1260 cl = repo.changelog
1261 for r in getset(repo, baseset(cl), x):
1261 for r in getset(repo, baseset(cl), x):
1262 if n == 0:
1262 if n == 0:
1263 ps.add(r)
1263 ps.add(r)
1264 elif n == 1:
1264 elif n == 1:
1265 ps.add(cl.parentrevs(r)[0])
1265 ps.add(cl.parentrevs(r)[0])
1266 elif n == 2:
1266 elif n == 2:
1267 parents = cl.parentrevs(r)
1267 parents = cl.parentrevs(r)
1268 if len(parents) > 1:
1268 if len(parents) > 1:
1269 ps.add(parents[1])
1269 ps.add(parents[1])
1270 return subset & ps
1270 return subset & ps
1271
1271
1272 def present(repo, subset, x):
1272 def present(repo, subset, x):
1273 """``present(set)``
1273 """``present(set)``
1274 An empty set, if any revision in set isn't found; otherwise,
1274 An empty set, if any revision in set isn't found; otherwise,
1275 all revisions in set.
1275 all revisions in set.
1276
1276
1277 If any of specified revisions is not present in the local repository,
1277 If any of specified revisions is not present in the local repository,
1278 the query is normally aborted. But this predicate allows the query
1278 the query is normally aborted. But this predicate allows the query
1279 to continue even in such cases.
1279 to continue even in such cases.
1280 """
1280 """
1281 try:
1281 try:
1282 return getset(repo, subset, x)
1282 return getset(repo, subset, x)
1283 except error.RepoLookupError:
1283 except error.RepoLookupError:
1284 return baseset()
1284 return baseset()
1285
1285
1286 def public(repo, subset, x):
1286 def public(repo, subset, x):
1287 """``public()``
1287 """``public()``
1288 Changeset in public phase."""
1288 Changeset in public phase."""
1289 # i18n: "public" is a keyword
1289 # i18n: "public" is a keyword
1290 getargs(x, 0, 0, _("public takes no arguments"))
1290 getargs(x, 0, 0, _("public takes no arguments"))
1291 pc = repo._phasecache
1291 pc = repo._phasecache
1292 return subset.filter(lambda r: pc.phase(repo, r) == phases.public)
1292 return subset.filter(lambda r: pc.phase(repo, r) == phases.public)
1293
1293
1294 def remote(repo, subset, x):
1294 def remote(repo, subset, x):
1295 """``remote([id [,path]])``
1295 """``remote([id [,path]])``
1296 Local revision that corresponds to the given identifier in a
1296 Local revision that corresponds to the given identifier in a
1297 remote repository, if present. Here, the '.' identifier is a
1297 remote repository, if present. Here, the '.' identifier is a
1298 synonym for the current local branch.
1298 synonym for the current local branch.
1299 """
1299 """
1300
1300
1301 import hg # avoid start-up nasties
1301 import hg # avoid start-up nasties
1302 # i18n: "remote" is a keyword
1302 # i18n: "remote" is a keyword
1303 l = getargs(x, 0, 2, _("remote takes one, two or no arguments"))
1303 l = getargs(x, 0, 2, _("remote takes one, two or no arguments"))
1304
1304
1305 q = '.'
1305 q = '.'
1306 if len(l) > 0:
1306 if len(l) > 0:
1307 # i18n: "remote" is a keyword
1307 # i18n: "remote" is a keyword
1308 q = getstring(l[0], _("remote requires a string id"))
1308 q = getstring(l[0], _("remote requires a string id"))
1309 if q == '.':
1309 if q == '.':
1310 q = repo['.'].branch()
1310 q = repo['.'].branch()
1311
1311
1312 dest = ''
1312 dest = ''
1313 if len(l) > 1:
1313 if len(l) > 1:
1314 # i18n: "remote" is a keyword
1314 # i18n: "remote" is a keyword
1315 dest = getstring(l[1], _("remote requires a repository path"))
1315 dest = getstring(l[1], _("remote requires a repository path"))
1316 dest = repo.ui.expandpath(dest or 'default')
1316 dest = repo.ui.expandpath(dest or 'default')
1317 dest, branches = hg.parseurl(dest)
1317 dest, branches = hg.parseurl(dest)
1318 revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
1318 revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
1319 if revs:
1319 if revs:
1320 revs = [repo.lookup(rev) for rev in revs]
1320 revs = [repo.lookup(rev) for rev in revs]
1321 other = hg.peer(repo, {}, dest)
1321 other = hg.peer(repo, {}, dest)
1322 n = other.lookup(q)
1322 n = other.lookup(q)
1323 if n in repo:
1323 if n in repo:
1324 r = repo[n].rev()
1324 r = repo[n].rev()
1325 if r in subset:
1325 if r in subset:
1326 return baseset([r])
1326 return baseset([r])
1327 return baseset()
1327 return baseset()
1328
1328
1329 def removes(repo, subset, x):
1329 def removes(repo, subset, x):
1330 """``removes(pattern)``
1330 """``removes(pattern)``
1331 Changesets which remove files matching pattern.
1331 Changesets which remove files matching pattern.
1332
1332
1333 The pattern without explicit kind like ``glob:`` is expected to be
1333 The pattern without explicit kind like ``glob:`` is expected to be
1334 relative to the current directory and match against a file or a
1334 relative to the current directory and match against a file or a
1335 directory.
1335 directory.
1336 """
1336 """
1337 # i18n: "removes" is a keyword
1337 # i18n: "removes" is a keyword
1338 pat = getstring(x, _("removes requires a pattern"))
1338 pat = getstring(x, _("removes requires a pattern"))
1339 return checkstatus(repo, subset, pat, 2)
1339 return checkstatus(repo, subset, pat, 2)
1340
1340
1341 def rev(repo, subset, x):
1341 def rev(repo, subset, x):
1342 """``rev(number)``
1342 """``rev(number)``
1343 Revision with the given numeric identifier.
1343 Revision with the given numeric identifier.
1344 """
1344 """
1345 # i18n: "rev" is a keyword
1345 # i18n: "rev" is a keyword
1346 l = getargs(x, 1, 1, _("rev requires one argument"))
1346 l = getargs(x, 1, 1, _("rev requires one argument"))
1347 try:
1347 try:
1348 # i18n: "rev" is a keyword
1348 # i18n: "rev" is a keyword
1349 l = int(getstring(l[0], _("rev requires a number")))
1349 l = int(getstring(l[0], _("rev requires a number")))
1350 except (TypeError, ValueError):
1350 except (TypeError, ValueError):
1351 # i18n: "rev" is a keyword
1351 # i18n: "rev" is a keyword
1352 raise error.ParseError(_("rev expects a number"))
1352 raise error.ParseError(_("rev expects a number"))
1353 return subset & baseset([l])
1353 return subset & baseset([l])
1354
1354
1355 def matching(repo, subset, x):
1355 def matching(repo, subset, x):
1356 """``matching(revision [, field])``
1356 """``matching(revision [, field])``
1357 Changesets in which a given set of fields match the set of fields in the
1357 Changesets in which a given set of fields match the set of fields in the
1358 selected revision or set.
1358 selected revision or set.
1359
1359
1360 To match more than one field pass the list of fields to match separated
1360 To match more than one field pass the list of fields to match separated
1361 by spaces (e.g. ``author description``).
1361 by spaces (e.g. ``author description``).
1362
1362
1363 Valid fields are most regular revision fields and some special fields.
1363 Valid fields are most regular revision fields and some special fields.
1364
1364
1365 Regular revision fields are ``description``, ``author``, ``branch``,
1365 Regular revision fields are ``description``, ``author``, ``branch``,
1366 ``date``, ``files``, ``phase``, ``parents``, ``substate``, ``user``
1366 ``date``, ``files``, ``phase``, ``parents``, ``substate``, ``user``
1367 and ``diff``.
1367 and ``diff``.
1368 Note that ``author`` and ``user`` are synonyms. ``diff`` refers to the
1368 Note that ``author`` and ``user`` are synonyms. ``diff`` refers to the
1369 contents of the revision. Two revisions matching their ``diff`` will
1369 contents of the revision. Two revisions matching their ``diff`` will
1370 also match their ``files``.
1370 also match their ``files``.
1371
1371
1372 Special fields are ``summary`` and ``metadata``:
1372 Special fields are ``summary`` and ``metadata``:
1373 ``summary`` matches the first line of the description.
1373 ``summary`` matches the first line of the description.
1374 ``metadata`` is equivalent to matching ``description user date``
1374 ``metadata`` is equivalent to matching ``description user date``
1375 (i.e. it matches the main metadata fields).
1375 (i.e. it matches the main metadata fields).
1376
1376
1377 ``metadata`` is the default field which is used when no fields are
1377 ``metadata`` is the default field which is used when no fields are
1378 specified. You can match more than one field at a time.
1378 specified. You can match more than one field at a time.
1379 """
1379 """
1380 # i18n: "matching" is a keyword
1380 # i18n: "matching" is a keyword
1381 l = getargs(x, 1, 2, _("matching takes 1 or 2 arguments"))
1381 l = getargs(x, 1, 2, _("matching takes 1 or 2 arguments"))
1382
1382
1383 revs = getset(repo, baseset(repo.changelog), l[0])
1383 revs = getset(repo, baseset(repo.changelog), l[0])
1384
1384
1385 fieldlist = ['metadata']
1385 fieldlist = ['metadata']
1386 if len(l) > 1:
1386 if len(l) > 1:
1387 fieldlist = getstring(l[1],
1387 fieldlist = getstring(l[1],
1388 # i18n: "matching" is a keyword
1388 # i18n: "matching" is a keyword
1389 _("matching requires a string "
1389 _("matching requires a string "
1390 "as its second argument")).split()
1390 "as its second argument")).split()
1391
1391
1392 # Make sure that there are no repeated fields,
1392 # Make sure that there are no repeated fields,
1393 # expand the 'special' 'metadata' field type
1393 # expand the 'special' 'metadata' field type
1394 # and check the 'files' whenever we check the 'diff'
1394 # and check the 'files' whenever we check the 'diff'
1395 fields = []
1395 fields = []
1396 for field in fieldlist:
1396 for field in fieldlist:
1397 if field == 'metadata':
1397 if field == 'metadata':
1398 fields += ['user', 'description', 'date']
1398 fields += ['user', 'description', 'date']
1399 elif field == 'diff':
1399 elif field == 'diff':
1400 # a revision matching the diff must also match the files
1400 # a revision matching the diff must also match the files
1401 # since matching the diff is very costly, make sure to
1401 # since matching the diff is very costly, make sure to
1402 # also match the files first
1402 # also match the files first
1403 fields += ['files', 'diff']
1403 fields += ['files', 'diff']
1404 else:
1404 else:
1405 if field == 'author':
1405 if field == 'author':
1406 field = 'user'
1406 field = 'user'
1407 fields.append(field)
1407 fields.append(field)
1408 fields = set(fields)
1408 fields = set(fields)
1409 if 'summary' in fields and 'description' in fields:
1409 if 'summary' in fields and 'description' in fields:
1410 # If a revision matches its description it also matches its summary
1410 # If a revision matches its description it also matches its summary
1411 fields.discard('summary')
1411 fields.discard('summary')
1412
1412
1413 # We may want to match more than one field
1413 # We may want to match more than one field
1414 # Not all fields take the same amount of time to be matched
1414 # Not all fields take the same amount of time to be matched
1415 # Sort the selected fields in order of increasing matching cost
1415 # Sort the selected fields in order of increasing matching cost
1416 fieldorder = ['phase', 'parents', 'user', 'date', 'branch', 'summary',
1416 fieldorder = ['phase', 'parents', 'user', 'date', 'branch', 'summary',
1417 'files', 'description', 'substate', 'diff']
1417 'files', 'description', 'substate', 'diff']
1418 def fieldkeyfunc(f):
1418 def fieldkeyfunc(f):
1419 try:
1419 try:
1420 return fieldorder.index(f)
1420 return fieldorder.index(f)
1421 except ValueError:
1421 except ValueError:
1422 # assume an unknown field is very costly
1422 # assume an unknown field is very costly
1423 return len(fieldorder)
1423 return len(fieldorder)
1424 fields = list(fields)
1424 fields = list(fields)
1425 fields.sort(key=fieldkeyfunc)
1425 fields.sort(key=fieldkeyfunc)
1426
1426
1427 # Each field will be matched with its own "getfield" function
1427 # Each field will be matched with its own "getfield" function
1428 # which will be added to the getfieldfuncs array of functions
1428 # which will be added to the getfieldfuncs array of functions
1429 getfieldfuncs = []
1429 getfieldfuncs = []
1430 _funcs = {
1430 _funcs = {
1431 'user': lambda r: repo[r].user(),
1431 'user': lambda r: repo[r].user(),
1432 'branch': lambda r: repo[r].branch(),
1432 'branch': lambda r: repo[r].branch(),
1433 'date': lambda r: repo[r].date(),
1433 'date': lambda r: repo[r].date(),
1434 'description': lambda r: repo[r].description(),
1434 'description': lambda r: repo[r].description(),
1435 'files': lambda r: repo[r].files(),
1435 'files': lambda r: repo[r].files(),
1436 'parents': lambda r: repo[r].parents(),
1436 'parents': lambda r: repo[r].parents(),
1437 'phase': lambda r: repo[r].phase(),
1437 'phase': lambda r: repo[r].phase(),
1438 'substate': lambda r: repo[r].substate,
1438 'substate': lambda r: repo[r].substate,
1439 'summary': lambda r: repo[r].description().splitlines()[0],
1439 'summary': lambda r: repo[r].description().splitlines()[0],
1440 'diff': lambda r: list(repo[r].diff(git=True),)
1440 'diff': lambda r: list(repo[r].diff(git=True),)
1441 }
1441 }
1442 for info in fields:
1442 for info in fields:
1443 getfield = _funcs.get(info, None)
1443 getfield = _funcs.get(info, None)
1444 if getfield is None:
1444 if getfield is None:
1445 raise error.ParseError(
1445 raise error.ParseError(
1446 # i18n: "matching" is a keyword
1446 # i18n: "matching" is a keyword
1447 _("unexpected field name passed to matching: %s") % info)
1447 _("unexpected field name passed to matching: %s") % info)
1448 getfieldfuncs.append(getfield)
1448 getfieldfuncs.append(getfield)
1449 # convert the getfield array of functions into a "getinfo" function
1449 # convert the getfield array of functions into a "getinfo" function
1450 # which returns an array of field values (or a single value if there
1450 # which returns an array of field values (or a single value if there
1451 # is only one field to match)
1451 # is only one field to match)
1452 getinfo = lambda r: [f(r) for f in getfieldfuncs]
1452 getinfo = lambda r: [f(r) for f in getfieldfuncs]
1453
1453
1454 def matches(x):
1454 def matches(x):
1455 for rev in revs:
1455 for rev in revs:
1456 target = getinfo(rev)
1456 target = getinfo(rev)
1457 match = True
1457 match = True
1458 for n, f in enumerate(getfieldfuncs):
1458 for n, f in enumerate(getfieldfuncs):
1459 if target[n] != f(x):
1459 if target[n] != f(x):
1460 match = False
1460 match = False
1461 if match:
1461 if match:
1462 return True
1462 return True
1463 return False
1463 return False
1464
1464
1465 return subset.filter(matches)
1465 return subset.filter(matches)
1466
1466
1467 def reverse(repo, subset, x):
1467 def reverse(repo, subset, x):
1468 """``reverse(set)``
1468 """``reverse(set)``
1469 Reverse order of set.
1469 Reverse order of set.
1470 """
1470 """
1471 l = getset(repo, subset, x)
1471 l = getset(repo, subset, x)
1472 l.reverse()
1472 l.reverse()
1473 return l
1473 return l
1474
1474
1475 def roots(repo, subset, x):
1475 def roots(repo, subset, x):
1476 """``roots(set)``
1476 """``roots(set)``
1477 Changesets in set with no parent changeset in set.
1477 Changesets in set with no parent changeset in set.
1478 """
1478 """
1479 s = getset(repo, spanset(repo), x).set()
1479 s = getset(repo, spanset(repo), x).set()
1480 subset = baseset([r for r in s if r in subset.set()])
1480 subset = baseset([r for r in s if r in subset.set()])
1481 cs = _children(repo, subset, s)
1481 cs = _children(repo, subset, s)
1482 return subset - cs
1482 return subset - cs
1483
1483
1484 def secret(repo, subset, x):
1484 def secret(repo, subset, x):
1485 """``secret()``
1485 """``secret()``
1486 Changeset in secret phase."""
1486 Changeset in secret phase."""
1487 # i18n: "secret" is a keyword
1487 # i18n: "secret" is a keyword
1488 getargs(x, 0, 0, _("secret takes no arguments"))
1488 getargs(x, 0, 0, _("secret takes no arguments"))
1489 pc = repo._phasecache
1489 pc = repo._phasecache
1490 return subset.filter(lambda x: pc.phase(repo, x) == phases.secret)
1490 return subset.filter(lambda x: pc.phase(repo, x) == phases.secret)
1491
1491
1492 def sort(repo, subset, x):
1492 def sort(repo, subset, x):
1493 """``sort(set[, [-]key...])``
1493 """``sort(set[, [-]key...])``
1494 Sort set by keys. The default sort order is ascending, specify a key
1494 Sort set by keys. The default sort order is ascending, specify a key
1495 as ``-key`` to sort in descending order.
1495 as ``-key`` to sort in descending order.
1496
1496
1497 The keys can be:
1497 The keys can be:
1498
1498
1499 - ``rev`` for the revision number,
1499 - ``rev`` for the revision number,
1500 - ``branch`` for the branch name,
1500 - ``branch`` for the branch name,
1501 - ``desc`` for the commit message (description),
1501 - ``desc`` for the commit message (description),
1502 - ``user`` for user name (``author`` can be used as an alias),
1502 - ``user`` for user name (``author`` can be used as an alias),
1503 - ``date`` for the commit date
1503 - ``date`` for the commit date
1504 """
1504 """
1505 # i18n: "sort" is a keyword
1505 # i18n: "sort" is a keyword
1506 l = getargs(x, 1, 2, _("sort requires one or two arguments"))
1506 l = getargs(x, 1, 2, _("sort requires one or two arguments"))
1507 keys = "rev"
1507 keys = "rev"
1508 if len(l) == 2:
1508 if len(l) == 2:
1509 # i18n: "sort" is a keyword
1509 # i18n: "sort" is a keyword
1510 keys = getstring(l[1], _("sort spec must be a string"))
1510 keys = getstring(l[1], _("sort spec must be a string"))
1511
1511
1512 s = l[0]
1512 s = l[0]
1513 keys = keys.split()
1513 keys = keys.split()
1514 l = []
1514 l = []
1515 def invert(s):
1515 def invert(s):
1516 return "".join(chr(255 - ord(c)) for c in s)
1516 return "".join(chr(255 - ord(c)) for c in s)
1517 revs = getset(repo, subset, s)
1517 revs = getset(repo, subset, s)
1518 if keys == ["rev"]:
1518 if keys == ["rev"]:
1519 revs.sort()
1519 revs.sort()
1520 return revs
1520 return revs
1521 elif keys == ["-rev"]:
1521 elif keys == ["-rev"]:
1522 revs.sort(reverse=True)
1522 revs.sort(reverse=True)
1523 return revs
1523 return revs
1524 for r in revs:
1524 for r in revs:
1525 c = repo[r]
1525 c = repo[r]
1526 e = []
1526 e = []
1527 for k in keys:
1527 for k in keys:
1528 if k == 'rev':
1528 if k == 'rev':
1529 e.append(r)
1529 e.append(r)
1530 elif k == '-rev':
1530 elif k == '-rev':
1531 e.append(-r)
1531 e.append(-r)
1532 elif k == 'branch':
1532 elif k == 'branch':
1533 e.append(c.branch())
1533 e.append(c.branch())
1534 elif k == '-branch':
1534 elif k == '-branch':
1535 e.append(invert(c.branch()))
1535 e.append(invert(c.branch()))
1536 elif k == 'desc':
1536 elif k == 'desc':
1537 e.append(c.description())
1537 e.append(c.description())
1538 elif k == '-desc':
1538 elif k == '-desc':
1539 e.append(invert(c.description()))
1539 e.append(invert(c.description()))
1540 elif k in 'user author':
1540 elif k in 'user author':
1541 e.append(c.user())
1541 e.append(c.user())
1542 elif k in '-user -author':
1542 elif k in '-user -author':
1543 e.append(invert(c.user()))
1543 e.append(invert(c.user()))
1544 elif k == 'date':
1544 elif k == 'date':
1545 e.append(c.date()[0])
1545 e.append(c.date()[0])
1546 elif k == '-date':
1546 elif k == '-date':
1547 e.append(-c.date()[0])
1547 e.append(-c.date()[0])
1548 else:
1548 else:
1549 raise error.ParseError(_("unknown sort key %r") % k)
1549 raise error.ParseError(_("unknown sort key %r") % k)
1550 e.append(r)
1550 e.append(r)
1551 l.append(e)
1551 l.append(e)
1552 l.sort()
1552 l.sort()
1553 return baseset([e[-1] for e in l])
1553 return baseset([e[-1] for e in l])
1554
1554
1555 def _stringmatcher(pattern):
1555 def _stringmatcher(pattern):
1556 """
1556 """
1557 accepts a string, possibly starting with 're:' or 'literal:' prefix.
1557 accepts a string, possibly starting with 're:' or 'literal:' prefix.
1558 returns the matcher name, pattern, and matcher function.
1558 returns the matcher name, pattern, and matcher function.
1559 missing or unknown prefixes are treated as literal matches.
1559 missing or unknown prefixes are treated as literal matches.
1560
1560
1561 helper for tests:
1561 helper for tests:
1562 >>> def test(pattern, *tests):
1562 >>> def test(pattern, *tests):
1563 ... kind, pattern, matcher = _stringmatcher(pattern)
1563 ... kind, pattern, matcher = _stringmatcher(pattern)
1564 ... return (kind, pattern, [bool(matcher(t)) for t in tests])
1564 ... return (kind, pattern, [bool(matcher(t)) for t in tests])
1565
1565
1566 exact matching (no prefix):
1566 exact matching (no prefix):
1567 >>> test('abcdefg', 'abc', 'def', 'abcdefg')
1567 >>> test('abcdefg', 'abc', 'def', 'abcdefg')
1568 ('literal', 'abcdefg', [False, False, True])
1568 ('literal', 'abcdefg', [False, False, True])
1569
1569
1570 regex matching ('re:' prefix)
1570 regex matching ('re:' prefix)
1571 >>> test('re:a.+b', 'nomatch', 'fooadef', 'fooadefbar')
1571 >>> test('re:a.+b', 'nomatch', 'fooadef', 'fooadefbar')
1572 ('re', 'a.+b', [False, False, True])
1572 ('re', 'a.+b', [False, False, True])
1573
1573
1574 force exact matches ('literal:' prefix)
1574 force exact matches ('literal:' prefix)
1575 >>> test('literal:re:foobar', 'foobar', 're:foobar')
1575 >>> test('literal:re:foobar', 'foobar', 're:foobar')
1576 ('literal', 're:foobar', [False, True])
1576 ('literal', 're:foobar', [False, True])
1577
1577
1578 unknown prefixes are ignored and treated as literals
1578 unknown prefixes are ignored and treated as literals
1579 >>> test('foo:bar', 'foo', 'bar', 'foo:bar')
1579 >>> test('foo:bar', 'foo', 'bar', 'foo:bar')
1580 ('literal', 'foo:bar', [False, False, True])
1580 ('literal', 'foo:bar', [False, False, True])
1581 """
1581 """
1582 if pattern.startswith('re:'):
1582 if pattern.startswith('re:'):
1583 pattern = pattern[3:]
1583 pattern = pattern[3:]
1584 try:
1584 try:
1585 regex = re.compile(pattern)
1585 regex = re.compile(pattern)
1586 except re.error, e:
1586 except re.error, e:
1587 raise error.ParseError(_('invalid regular expression: %s')
1587 raise error.ParseError(_('invalid regular expression: %s')
1588 % e)
1588 % e)
1589 return 're', pattern, regex.search
1589 return 're', pattern, regex.search
1590 elif pattern.startswith('literal:'):
1590 elif pattern.startswith('literal:'):
1591 pattern = pattern[8:]
1591 pattern = pattern[8:]
1592 return 'literal', pattern, pattern.__eq__
1592 return 'literal', pattern, pattern.__eq__
1593
1593
1594 def _substringmatcher(pattern):
1594 def _substringmatcher(pattern):
1595 kind, pattern, matcher = _stringmatcher(pattern)
1595 kind, pattern, matcher = _stringmatcher(pattern)
1596 if kind == 'literal':
1596 if kind == 'literal':
1597 matcher = lambda s: pattern in s
1597 matcher = lambda s: pattern in s
1598 return kind, pattern, matcher
1598 return kind, pattern, matcher
1599
1599
1600 def tag(repo, subset, x):
1600 def tag(repo, subset, x):
1601 """``tag([name])``
1601 """``tag([name])``
1602 The specified tag by name, or all tagged revisions if no name is given.
1602 The specified tag by name, or all tagged revisions if no name is given.
1603
1603
1604 If `name` starts with `re:`, the remainder of the name is treated as
1604 If `name` starts with `re:`, the remainder of the name is treated as
1605 a regular expression. To match a tag that actually starts with `re:`,
1605 a regular expression. To match a tag that actually starts with `re:`,
1606 use the prefix `literal:`.
1606 use the prefix `literal:`.
1607 """
1607 """
1608 # i18n: "tag" is a keyword
1608 # i18n: "tag" is a keyword
1609 args = getargs(x, 0, 1, _("tag takes one or no arguments"))
1609 args = getargs(x, 0, 1, _("tag takes one or no arguments"))
1610 cl = repo.changelog
1610 cl = repo.changelog
1611 if args:
1611 if args:
1612 pattern = getstring(args[0],
1612 pattern = getstring(args[0],
1613 # i18n: "tag" is a keyword
1613 # i18n: "tag" is a keyword
1614 _('the argument to tag must be a string'))
1614 _('the argument to tag must be a string'))
1615 kind, pattern, matcher = _stringmatcher(pattern)
1615 kind, pattern, matcher = _stringmatcher(pattern)
1616 if kind == 'literal':
1616 if kind == 'literal':
1617 # avoid resolving all tags
1617 # avoid resolving all tags
1618 tn = repo._tagscache.tags.get(pattern, None)
1618 tn = repo._tagscache.tags.get(pattern, None)
1619 if tn is None:
1619 if tn is None:
1620 raise util.Abort(_("tag '%s' does not exist") % pattern)
1620 raise util.Abort(_("tag '%s' does not exist") % pattern)
1621 s = set([repo[tn].rev()])
1621 s = set([repo[tn].rev()])
1622 else:
1622 else:
1623 s = set([cl.rev(n) for t, n in repo.tagslist() if matcher(t)])
1623 s = set([cl.rev(n) for t, n in repo.tagslist() if matcher(t)])
1624 else:
1624 else:
1625 s = set([cl.rev(n) for t, n in repo.tagslist() if t != 'tip'])
1625 s = set([cl.rev(n) for t, n in repo.tagslist() if t != 'tip'])
1626 return subset & s
1626 return subset & s
1627
1627
1628 def tagged(repo, subset, x):
1628 def tagged(repo, subset, x):
1629 return tag(repo, subset, x)
1629 return tag(repo, subset, x)
1630
1630
1631 def unstable(repo, subset, x):
1631 def unstable(repo, subset, x):
1632 """``unstable()``
1632 """``unstable()``
1633 Non-obsolete changesets with obsolete ancestors.
1633 Non-obsolete changesets with obsolete ancestors.
1634 """
1634 """
1635 # i18n: "unstable" is a keyword
1635 # i18n: "unstable" is a keyword
1636 getargs(x, 0, 0, _("unstable takes no arguments"))
1636 getargs(x, 0, 0, _("unstable takes no arguments"))
1637 unstables = obsmod.getrevs(repo, 'unstable')
1637 unstables = obsmod.getrevs(repo, 'unstable')
1638 return subset & unstables
1638 return subset & unstables
1639
1639
1640
1640
1641 def user(repo, subset, x):
1641 def user(repo, subset, x):
1642 """``user(string)``
1642 """``user(string)``
1643 User name contains string. The match is case-insensitive.
1643 User name contains string. The match is case-insensitive.
1644
1644
1645 If `string` starts with `re:`, the remainder of the string is treated as
1645 If `string` starts with `re:`, the remainder of the string is treated as
1646 a regular expression. To match a user that actually contains `re:`, use
1646 a regular expression. To match a user that actually contains `re:`, use
1647 the prefix `literal:`.
1647 the prefix `literal:`.
1648 """
1648 """
1649 return author(repo, subset, x)
1649 return author(repo, subset, x)
1650
1650
1651 # for internal use
1651 # for internal use
1652 def _list(repo, subset, x):
1652 def _list(repo, subset, x):
1653 s = getstring(x, "internal error")
1653 s = getstring(x, "internal error")
1654 if not s:
1654 if not s:
1655 return baseset()
1655 return baseset()
1656 ls = [repo[r].rev() for r in s.split('\0')]
1656 ls = [repo[r].rev() for r in s.split('\0')]
1657 s = subset.set()
1657 s = subset.set()
1658 return baseset([r for r in ls if r in s])
1658 return baseset([r for r in ls if r in s])
1659
1659
1660 # for internal use
1660 # for internal use
1661 def _intlist(repo, subset, x):
1661 def _intlist(repo, subset, x):
1662 s = getstring(x, "internal error")
1662 s = getstring(x, "internal error")
1663 if not s:
1663 if not s:
1664 return baseset()
1664 return baseset()
1665 ls = [int(r) for r in s.split('\0')]
1665 ls = [int(r) for r in s.split('\0')]
1666 s = subset.set()
1666 s = subset.set()
1667 return baseset([r for r in ls if r in s])
1667 return baseset([r for r in ls if r in s])
1668
1668
1669 # for internal use
1669 # for internal use
1670 def _hexlist(repo, subset, x):
1670 def _hexlist(repo, subset, x):
1671 s = getstring(x, "internal error")
1671 s = getstring(x, "internal error")
1672 if not s:
1672 if not s:
1673 return baseset()
1673 return baseset()
1674 cl = repo.changelog
1674 cl = repo.changelog
1675 ls = [cl.rev(node.bin(r)) for r in s.split('\0')]
1675 ls = [cl.rev(node.bin(r)) for r in s.split('\0')]
1676 s = subset.set()
1676 s = subset.set()
1677 return baseset([r for r in ls if r in s])
1677 return baseset([r for r in ls if r in s])
1678
1678
1679 symbols = {
1679 symbols = {
1680 "adds": adds,
1680 "adds": adds,
1681 "all": getall,
1681 "all": getall,
1682 "ancestor": ancestor,
1682 "ancestor": ancestor,
1683 "ancestors": ancestors,
1683 "ancestors": ancestors,
1684 "_firstancestors": _firstancestors,
1684 "_firstancestors": _firstancestors,
1685 "author": author,
1685 "author": author,
1686 "only": only,
1686 "only": only,
1687 "bisect": bisect,
1687 "bisect": bisect,
1688 "bisected": bisected,
1688 "bisected": bisected,
1689 "bookmark": bookmark,
1689 "bookmark": bookmark,
1690 "branch": branch,
1690 "branch": branch,
1691 "branchpoint": branchpoint,
1691 "branchpoint": branchpoint,
1692 "bumped": bumped,
1692 "bumped": bumped,
1693 "bundle": bundle,
1693 "bundle": bundle,
1694 "children": children,
1694 "children": children,
1695 "closed": closed,
1695 "closed": closed,
1696 "contains": contains,
1696 "contains": contains,
1697 "converted": converted,
1697 "converted": converted,
1698 "date": date,
1698 "date": date,
1699 "desc": desc,
1699 "desc": desc,
1700 "descendants": descendants,
1700 "descendants": descendants,
1701 "_firstdescendants": _firstdescendants,
1701 "_firstdescendants": _firstdescendants,
1702 "destination": destination,
1702 "destination": destination,
1703 "divergent": divergent,
1703 "divergent": divergent,
1704 "draft": draft,
1704 "draft": draft,
1705 "extinct": extinct,
1705 "extinct": extinct,
1706 "extra": extra,
1706 "extra": extra,
1707 "file": hasfile,
1707 "file": hasfile,
1708 "filelog": filelog,
1708 "filelog": filelog,
1709 "first": first,
1709 "first": first,
1710 "follow": follow,
1710 "follow": follow,
1711 "_followfirst": _followfirst,
1711 "_followfirst": _followfirst,
1712 "grep": grep,
1712 "grep": grep,
1713 "head": head,
1713 "head": head,
1714 "heads": heads,
1714 "heads": heads,
1715 "hidden": hidden,
1715 "hidden": hidden,
1716 "id": node_,
1716 "id": node_,
1717 "keyword": keyword,
1717 "keyword": keyword,
1718 "last": last,
1718 "last": last,
1719 "limit": limit,
1719 "limit": limit,
1720 "_matchfiles": _matchfiles,
1720 "_matchfiles": _matchfiles,
1721 "max": maxrev,
1721 "max": maxrev,
1722 "merge": merge,
1722 "merge": merge,
1723 "min": minrev,
1723 "min": minrev,
1724 "modifies": modifies,
1724 "modifies": modifies,
1725 "obsolete": obsolete,
1725 "obsolete": obsolete,
1726 "origin": origin,
1726 "origin": origin,
1727 "outgoing": outgoing,
1727 "outgoing": outgoing,
1728 "p1": p1,
1728 "p1": p1,
1729 "p2": p2,
1729 "p2": p2,
1730 "parents": parents,
1730 "parents": parents,
1731 "present": present,
1731 "present": present,
1732 "public": public,
1732 "public": public,
1733 "remote": remote,
1733 "remote": remote,
1734 "removes": removes,
1734 "removes": removes,
1735 "rev": rev,
1735 "rev": rev,
1736 "reverse": reverse,
1736 "reverse": reverse,
1737 "roots": roots,
1737 "roots": roots,
1738 "sort": sort,
1738 "sort": sort,
1739 "secret": secret,
1739 "secret": secret,
1740 "matching": matching,
1740 "matching": matching,
1741 "tag": tag,
1741 "tag": tag,
1742 "tagged": tagged,
1742 "tagged": tagged,
1743 "user": user,
1743 "user": user,
1744 "unstable": unstable,
1744 "unstable": unstable,
1745 "_list": _list,
1745 "_list": _list,
1746 "_intlist": _intlist,
1746 "_intlist": _intlist,
1747 "_hexlist": _hexlist,
1747 "_hexlist": _hexlist,
1748 }
1748 }
1749
1749
1750 # symbols which can't be used for a DoS attack for any given input
1750 # symbols which can't be used for a DoS attack for any given input
1751 # (e.g. those which accept regexes as plain strings shouldn't be included)
1751 # (e.g. those which accept regexes as plain strings shouldn't be included)
1752 # functions that just return a lot of changesets (like all) don't count here
1752 # functions that just return a lot of changesets (like all) don't count here
1753 safesymbols = set([
1753 safesymbols = set([
1754 "adds",
1754 "adds",
1755 "all",
1755 "all",
1756 "ancestor",
1756 "ancestor",
1757 "ancestors",
1757 "ancestors",
1758 "_firstancestors",
1758 "_firstancestors",
1759 "author",
1759 "author",
1760 "bisect",
1760 "bisect",
1761 "bisected",
1761 "bisected",
1762 "bookmark",
1762 "bookmark",
1763 "branch",
1763 "branch",
1764 "branchpoint",
1764 "branchpoint",
1765 "bumped",
1765 "bumped",
1766 "bundle",
1766 "bundle",
1767 "children",
1767 "children",
1768 "closed",
1768 "closed",
1769 "converted",
1769 "converted",
1770 "date",
1770 "date",
1771 "desc",
1771 "desc",
1772 "descendants",
1772 "descendants",
1773 "_firstdescendants",
1773 "_firstdescendants",
1774 "destination",
1774 "destination",
1775 "divergent",
1775 "divergent",
1776 "draft",
1776 "draft",
1777 "extinct",
1777 "extinct",
1778 "extra",
1778 "extra",
1779 "file",
1779 "file",
1780 "filelog",
1780 "filelog",
1781 "first",
1781 "first",
1782 "follow",
1782 "follow",
1783 "_followfirst",
1783 "_followfirst",
1784 "head",
1784 "head",
1785 "heads",
1785 "heads",
1786 "hidden",
1786 "hidden",
1787 "id",
1787 "id",
1788 "keyword",
1788 "keyword",
1789 "last",
1789 "last",
1790 "limit",
1790 "limit",
1791 "_matchfiles",
1791 "_matchfiles",
1792 "max",
1792 "max",
1793 "merge",
1793 "merge",
1794 "min",
1794 "min",
1795 "modifies",
1795 "modifies",
1796 "obsolete",
1796 "obsolete",
1797 "origin",
1797 "origin",
1798 "outgoing",
1798 "outgoing",
1799 "p1",
1799 "p1",
1800 "p2",
1800 "p2",
1801 "parents",
1801 "parents",
1802 "present",
1802 "present",
1803 "public",
1803 "public",
1804 "remote",
1804 "remote",
1805 "removes",
1805 "removes",
1806 "rev",
1806 "rev",
1807 "reverse",
1807 "reverse",
1808 "roots",
1808 "roots",
1809 "sort",
1809 "sort",
1810 "secret",
1810 "secret",
1811 "matching",
1811 "matching",
1812 "tag",
1812 "tag",
1813 "tagged",
1813 "tagged",
1814 "user",
1814 "user",
1815 "unstable",
1815 "unstable",
1816 "_list",
1816 "_list",
1817 "_intlist",
1817 "_intlist",
1818 "_hexlist",
1818 "_hexlist",
1819 ])
1819 ])
1820
1820
1821 methods = {
1821 methods = {
1822 "range": rangeset,
1822 "range": rangeset,
1823 "dagrange": dagrange,
1823 "dagrange": dagrange,
1824 "string": stringset,
1824 "string": stringset,
1825 "symbol": symbolset,
1825 "symbol": symbolset,
1826 "and": andset,
1826 "and": andset,
1827 "or": orset,
1827 "or": orset,
1828 "not": notset,
1828 "not": notset,
1829 "list": listset,
1829 "list": listset,
1830 "func": func,
1830 "func": func,
1831 "ancestor": ancestorspec,
1831 "ancestor": ancestorspec,
1832 "parent": parentspec,
1832 "parent": parentspec,
1833 "parentpost": p1,
1833 "parentpost": p1,
1834 }
1834 }
1835
1835
1836 def optimize(x, small):
1836 def optimize(x, small):
1837 if x is None:
1837 if x is None:
1838 return 0, x
1838 return 0, x
1839
1839
1840 smallbonus = 1
1840 smallbonus = 1
1841 if small:
1841 if small:
1842 smallbonus = .5
1842 smallbonus = .5
1843
1843
1844 op = x[0]
1844 op = x[0]
1845 if op == 'minus':
1845 if op == 'minus':
1846 return optimize(('and', x[1], ('not', x[2])), small)
1846 return optimize(('and', x[1], ('not', x[2])), small)
1847 elif op == 'dagrangepre':
1847 elif op == 'dagrangepre':
1848 return optimize(('func', ('symbol', 'ancestors'), x[1]), small)
1848 return optimize(('func', ('symbol', 'ancestors'), x[1]), small)
1849 elif op == 'dagrangepost':
1849 elif op == 'dagrangepost':
1850 return optimize(('func', ('symbol', 'descendants'), x[1]), small)
1850 return optimize(('func', ('symbol', 'descendants'), x[1]), small)
1851 elif op == 'rangepre':
1851 elif op == 'rangepre':
1852 return optimize(('range', ('string', '0'), x[1]), small)
1852 return optimize(('range', ('string', '0'), x[1]), small)
1853 elif op == 'rangepost':
1853 elif op == 'rangepost':
1854 return optimize(('range', x[1], ('string', 'tip')), small)
1854 return optimize(('range', x[1], ('string', 'tip')), small)
1855 elif op == 'negate':
1855 elif op == 'negate':
1856 return optimize(('string',
1856 return optimize(('string',
1857 '-' + getstring(x[1], _("can't negate that"))), small)
1857 '-' + getstring(x[1], _("can't negate that"))), small)
1858 elif op in 'string symbol negate':
1858 elif op in 'string symbol negate':
1859 return smallbonus, x # single revisions are small
1859 return smallbonus, x # single revisions are small
1860 elif op == 'and':
1860 elif op == 'and':
1861 wa, ta = optimize(x[1], True)
1861 wa, ta = optimize(x[1], True)
1862 wb, tb = optimize(x[2], True)
1862 wb, tb = optimize(x[2], True)
1863
1863
1864 # (::x and not ::y)/(not ::y and ::x) have a fast path
1864 # (::x and not ::y)/(not ::y and ::x) have a fast path
1865 def isonly(revs, bases):
1865 def isonly(revs, bases):
1866 return (
1866 return (
1867 revs[0] == 'func'
1867 revs[0] == 'func'
1868 and getstring(revs[1], _('not a symbol')) == 'ancestors'
1868 and getstring(revs[1], _('not a symbol')) == 'ancestors'
1869 and bases[0] == 'not'
1869 and bases[0] == 'not'
1870 and bases[1][0] == 'func'
1870 and bases[1][0] == 'func'
1871 and getstring(bases[1][1], _('not a symbol')) == 'ancestors')
1871 and getstring(bases[1][1], _('not a symbol')) == 'ancestors')
1872
1872
1873 w = min(wa, wb)
1873 w = min(wa, wb)
1874 if isonly(ta, tb):
1874 if isonly(ta, tb):
1875 return w, ('func', ('symbol', 'only'), ('list', ta[2], tb[1][2]))
1875 return w, ('func', ('symbol', 'only'), ('list', ta[2], tb[1][2]))
1876 if isonly(tb, ta):
1876 if isonly(tb, ta):
1877 return w, ('func', ('symbol', 'only'), ('list', tb[2], ta[1][2]))
1877 return w, ('func', ('symbol', 'only'), ('list', tb[2], ta[1][2]))
1878
1878
1879 if wa > wb:
1879 if wa > wb:
1880 return w, (op, tb, ta)
1880 return w, (op, tb, ta)
1881 return w, (op, ta, tb)
1881 return w, (op, ta, tb)
1882 elif op == 'or':
1882 elif op == 'or':
1883 wa, ta = optimize(x[1], False)
1883 wa, ta = optimize(x[1], False)
1884 wb, tb = optimize(x[2], False)
1884 wb, tb = optimize(x[2], False)
1885 if wb < wa:
1885 if wb < wa:
1886 wb, wa = wa, wb
1886 wb, wa = wa, wb
1887 return max(wa, wb), (op, ta, tb)
1887 return max(wa, wb), (op, ta, tb)
1888 elif op == 'not':
1888 elif op == 'not':
1889 o = optimize(x[1], not small)
1889 o = optimize(x[1], not small)
1890 return o[0], (op, o[1])
1890 return o[0], (op, o[1])
1891 elif op == 'parentpost':
1891 elif op == 'parentpost':
1892 o = optimize(x[1], small)
1892 o = optimize(x[1], small)
1893 return o[0], (op, o[1])
1893 return o[0], (op, o[1])
1894 elif op == 'group':
1894 elif op == 'group':
1895 return optimize(x[1], small)
1895 return optimize(x[1], small)
1896 elif op in 'dagrange range list parent ancestorspec':
1896 elif op in 'dagrange range list parent ancestorspec':
1897 if op == 'parent':
1897 if op == 'parent':
1898 # x^:y means (x^) : y, not x ^ (:y)
1898 # x^:y means (x^) : y, not x ^ (:y)
1899 post = ('parentpost', x[1])
1899 post = ('parentpost', x[1])
1900 if x[2][0] == 'dagrangepre':
1900 if x[2][0] == 'dagrangepre':
1901 return optimize(('dagrange', post, x[2][1]), small)
1901 return optimize(('dagrange', post, x[2][1]), small)
1902 elif x[2][0] == 'rangepre':
1902 elif x[2][0] == 'rangepre':
1903 return optimize(('range', post, x[2][1]), small)
1903 return optimize(('range', post, x[2][1]), small)
1904
1904
1905 wa, ta = optimize(x[1], small)
1905 wa, ta = optimize(x[1], small)
1906 wb, tb = optimize(x[2], small)
1906 wb, tb = optimize(x[2], small)
1907 return wa + wb, (op, ta, tb)
1907 return wa + wb, (op, ta, tb)
1908 elif op == 'func':
1908 elif op == 'func':
1909 f = getstring(x[1], _("not a symbol"))
1909 f = getstring(x[1], _("not a symbol"))
1910 wa, ta = optimize(x[2], small)
1910 wa, ta = optimize(x[2], small)
1911 if f in ("author branch closed date desc file grep keyword "
1911 if f in ("author branch closed date desc file grep keyword "
1912 "outgoing user"):
1912 "outgoing user"):
1913 w = 10 # slow
1913 w = 10 # slow
1914 elif f in "modifies adds removes":
1914 elif f in "modifies adds removes":
1915 w = 30 # slower
1915 w = 30 # slower
1916 elif f == "contains":
1916 elif f == "contains":
1917 w = 100 # very slow
1917 w = 100 # very slow
1918 elif f == "ancestor":
1918 elif f == "ancestor":
1919 w = 1 * smallbonus
1919 w = 1 * smallbonus
1920 elif f in "reverse limit first _intlist":
1920 elif f in "reverse limit first _intlist":
1921 w = 0
1921 w = 0
1922 elif f in "sort":
1922 elif f in "sort":
1923 w = 10 # assume most sorts look at changelog
1923 w = 10 # assume most sorts look at changelog
1924 else:
1924 else:
1925 w = 1
1925 w = 1
1926 return w + wa, (op, x[1], ta)
1926 return w + wa, (op, x[1], ta)
1927 return 1, x
1927 return 1, x
1928
1928
1929 _aliasarg = ('func', ('symbol', '_aliasarg'))
1929 _aliasarg = ('func', ('symbol', '_aliasarg'))
1930 def _getaliasarg(tree):
1930 def _getaliasarg(tree):
1931 """If tree matches ('func', ('symbol', '_aliasarg'), ('string', X))
1931 """If tree matches ('func', ('symbol', '_aliasarg'), ('string', X))
1932 return X, None otherwise.
1932 return X, None otherwise.
1933 """
1933 """
1934 if (len(tree) == 3 and tree[:2] == _aliasarg
1934 if (len(tree) == 3 and tree[:2] == _aliasarg
1935 and tree[2][0] == 'string'):
1935 and tree[2][0] == 'string'):
1936 return tree[2][1]
1936 return tree[2][1]
1937 return None
1937 return None
1938
1938
1939 def _checkaliasarg(tree, known=None):
1939 def _checkaliasarg(tree, known=None):
1940 """Check tree contains no _aliasarg construct or only ones which
1940 """Check tree contains no _aliasarg construct or only ones which
1941 value is in known. Used to avoid alias placeholders injection.
1941 value is in known. Used to avoid alias placeholders injection.
1942 """
1942 """
1943 if isinstance(tree, tuple):
1943 if isinstance(tree, tuple):
1944 arg = _getaliasarg(tree)
1944 arg = _getaliasarg(tree)
1945 if arg is not None and (not known or arg not in known):
1945 if arg is not None and (not known or arg not in known):
1946 raise error.ParseError(_("not a function: %s") % '_aliasarg')
1946 raise error.ParseError(_("not a function: %s") % '_aliasarg')
1947 for t in tree:
1947 for t in tree:
1948 _checkaliasarg(t, known)
1948 _checkaliasarg(t, known)
1949
1949
1950 class revsetalias(object):
1950 class revsetalias(object):
1951 funcre = re.compile('^([^(]+)\(([^)]+)\)$')
1951 funcre = re.compile('^([^(]+)\(([^)]+)\)$')
1952 args = None
1952 args = None
1953
1953
1954 def __init__(self, name, value):
1954 def __init__(self, name, value):
1955 '''Aliases like:
1955 '''Aliases like:
1956
1956
1957 h = heads(default)
1957 h = heads(default)
1958 b($1) = ancestors($1) - ancestors(default)
1958 b($1) = ancestors($1) - ancestors(default)
1959 '''
1959 '''
1960 m = self.funcre.search(name)
1960 m = self.funcre.search(name)
1961 if m:
1961 if m:
1962 self.name = m.group(1)
1962 self.name = m.group(1)
1963 self.tree = ('func', ('symbol', m.group(1)))
1963 self.tree = ('func', ('symbol', m.group(1)))
1964 self.args = [x.strip() for x in m.group(2).split(',')]
1964 self.args = [x.strip() for x in m.group(2).split(',')]
1965 for arg in self.args:
1965 for arg in self.args:
1966 # _aliasarg() is an unknown symbol only used separate
1966 # _aliasarg() is an unknown symbol only used separate
1967 # alias argument placeholders from regular strings.
1967 # alias argument placeholders from regular strings.
1968 value = value.replace(arg, '_aliasarg(%r)' % (arg,))
1968 value = value.replace(arg, '_aliasarg(%r)' % (arg,))
1969 else:
1969 else:
1970 self.name = name
1970 self.name = name
1971 self.tree = ('symbol', name)
1971 self.tree = ('symbol', name)
1972
1972
1973 self.replacement, pos = parse(value)
1973 self.replacement, pos = parse(value)
1974 if pos != len(value):
1974 if pos != len(value):
1975 raise error.ParseError(_('invalid token'), pos)
1975 raise error.ParseError(_('invalid token'), pos)
1976 # Check for placeholder injection
1976 # Check for placeholder injection
1977 _checkaliasarg(self.replacement, self.args)
1977 _checkaliasarg(self.replacement, self.args)
1978
1978
1979 def _getalias(aliases, tree):
1979 def _getalias(aliases, tree):
1980 """If tree looks like an unexpanded alias, return it. Return None
1980 """If tree looks like an unexpanded alias, return it. Return None
1981 otherwise.
1981 otherwise.
1982 """
1982 """
1983 if isinstance(tree, tuple) and tree:
1983 if isinstance(tree, tuple) and tree:
1984 if tree[0] == 'symbol' and len(tree) == 2:
1984 if tree[0] == 'symbol' and len(tree) == 2:
1985 name = tree[1]
1985 name = tree[1]
1986 alias = aliases.get(name)
1986 alias = aliases.get(name)
1987 if alias and alias.args is None and alias.tree == tree:
1987 if alias and alias.args is None and alias.tree == tree:
1988 return alias
1988 return alias
1989 if tree[0] == 'func' and len(tree) > 1:
1989 if tree[0] == 'func' and len(tree) > 1:
1990 if tree[1][0] == 'symbol' and len(tree[1]) == 2:
1990 if tree[1][0] == 'symbol' and len(tree[1]) == 2:
1991 name = tree[1][1]
1991 name = tree[1][1]
1992 alias = aliases.get(name)
1992 alias = aliases.get(name)
1993 if alias and alias.args is not None and alias.tree == tree[:2]:
1993 if alias and alias.args is not None and alias.tree == tree[:2]:
1994 return alias
1994 return alias
1995 return None
1995 return None
1996
1996
1997 def _expandargs(tree, args):
1997 def _expandargs(tree, args):
1998 """Replace _aliasarg instances with the substitution value of the
1998 """Replace _aliasarg instances with the substitution value of the
1999 same name in args, recursively.
1999 same name in args, recursively.
2000 """
2000 """
2001 if not tree or not isinstance(tree, tuple):
2001 if not tree or not isinstance(tree, tuple):
2002 return tree
2002 return tree
2003 arg = _getaliasarg(tree)
2003 arg = _getaliasarg(tree)
2004 if arg is not None:
2004 if arg is not None:
2005 return args[arg]
2005 return args[arg]
2006 return tuple(_expandargs(t, args) for t in tree)
2006 return tuple(_expandargs(t, args) for t in tree)
2007
2007
2008 def _expandaliases(aliases, tree, expanding, cache):
2008 def _expandaliases(aliases, tree, expanding, cache):
2009 """Expand aliases in tree, recursively.
2009 """Expand aliases in tree, recursively.
2010
2010
2011 'aliases' is a dictionary mapping user defined aliases to
2011 'aliases' is a dictionary mapping user defined aliases to
2012 revsetalias objects.
2012 revsetalias objects.
2013 """
2013 """
2014 if not isinstance(tree, tuple):
2014 if not isinstance(tree, tuple):
2015 # Do not expand raw strings
2015 # Do not expand raw strings
2016 return tree
2016 return tree
2017 alias = _getalias(aliases, tree)
2017 alias = _getalias(aliases, tree)
2018 if alias is not None:
2018 if alias is not None:
2019 if alias in expanding:
2019 if alias in expanding:
2020 raise error.ParseError(_('infinite expansion of revset alias "%s" '
2020 raise error.ParseError(_('infinite expansion of revset alias "%s" '
2021 'detected') % alias.name)
2021 'detected') % alias.name)
2022 expanding.append(alias)
2022 expanding.append(alias)
2023 if alias.name not in cache:
2023 if alias.name not in cache:
2024 cache[alias.name] = _expandaliases(aliases, alias.replacement,
2024 cache[alias.name] = _expandaliases(aliases, alias.replacement,
2025 expanding, cache)
2025 expanding, cache)
2026 result = cache[alias.name]
2026 result = cache[alias.name]
2027 expanding.pop()
2027 expanding.pop()
2028 if alias.args is not None:
2028 if alias.args is not None:
2029 l = getlist(tree[2])
2029 l = getlist(tree[2])
2030 if len(l) != len(alias.args):
2030 if len(l) != len(alias.args):
2031 raise error.ParseError(
2031 raise error.ParseError(
2032 _('invalid number of arguments: %s') % len(l))
2032 _('invalid number of arguments: %s') % len(l))
2033 l = [_expandaliases(aliases, a, [], cache) for a in l]
2033 l = [_expandaliases(aliases, a, [], cache) for a in l]
2034 result = _expandargs(result, dict(zip(alias.args, l)))
2034 result = _expandargs(result, dict(zip(alias.args, l)))
2035 else:
2035 else:
2036 result = tuple(_expandaliases(aliases, t, expanding, cache)
2036 result = tuple(_expandaliases(aliases, t, expanding, cache)
2037 for t in tree)
2037 for t in tree)
2038 return result
2038 return result
2039
2039
2040 def findaliases(ui, tree):
2040 def findaliases(ui, tree):
2041 _checkaliasarg(tree)
2041 _checkaliasarg(tree)
2042 aliases = {}
2042 aliases = {}
2043 for k, v in ui.configitems('revsetalias'):
2043 for k, v in ui.configitems('revsetalias'):
2044 alias = revsetalias(k, v)
2044 alias = revsetalias(k, v)
2045 aliases[alias.name] = alias
2045 aliases[alias.name] = alias
2046 return _expandaliases(aliases, tree, [], {})
2046 return _expandaliases(aliases, tree, [], {})
2047
2047
2048 def parse(spec, lookup=None):
2048 def parse(spec, lookup=None):
2049 p = parser.parser(tokenize, elements)
2049 p = parser.parser(tokenize, elements)
2050 return p.parse(spec, lookup=lookup)
2050 return p.parse(spec, lookup=lookup)
2051
2051
2052 def match(ui, spec, repo=None):
2052 def match(ui, spec, repo=None):
2053 if not spec:
2053 if not spec:
2054 raise error.ParseError(_("empty query"))
2054 raise error.ParseError(_("empty query"))
2055 lookup = None
2055 lookup = None
2056 if repo:
2056 if repo:
2057 lookup = repo.__contains__
2057 lookup = repo.__contains__
2058 tree, pos = parse(spec, lookup)
2058 tree, pos = parse(spec, lookup)
2059 if (pos != len(spec)):
2059 if (pos != len(spec)):
2060 raise error.ParseError(_("invalid token"), pos)
2060 raise error.ParseError(_("invalid token"), pos)
2061 if ui:
2061 if ui:
2062 tree = findaliases(ui, tree)
2062 tree = findaliases(ui, tree)
2063 weight, tree = optimize(tree, True)
2063 weight, tree = optimize(tree, True)
2064 def mfunc(repo, subset):
2064 def mfunc(repo, subset):
2065 if util.safehasattr(subset, 'set'):
2065 if util.safehasattr(subset, 'set'):
2066 result = getset(repo, subset, tree)
2066 result = getset(repo, subset, tree)
2067 else:
2067 else:
2068 result = getset(repo, baseset(subset), tree)
2068 result = getset(repo, baseset(subset), tree)
2069 return result
2069 return result
2070 return mfunc
2070 return mfunc
2071
2071
2072 def formatspec(expr, *args):
2072 def formatspec(expr, *args):
2073 '''
2073 '''
2074 This is a convenience function for using revsets internally, and
2074 This is a convenience function for using revsets internally, and
2075 escapes arguments appropriately. Aliases are intentionally ignored
2075 escapes arguments appropriately. Aliases are intentionally ignored
2076 so that intended expression behavior isn't accidentally subverted.
2076 so that intended expression behavior isn't accidentally subverted.
2077
2077
2078 Supported arguments:
2078 Supported arguments:
2079
2079
2080 %r = revset expression, parenthesized
2080 %r = revset expression, parenthesized
2081 %d = int(arg), no quoting
2081 %d = int(arg), no quoting
2082 %s = string(arg), escaped and single-quoted
2082 %s = string(arg), escaped and single-quoted
2083 %b = arg.branch(), escaped and single-quoted
2083 %b = arg.branch(), escaped and single-quoted
2084 %n = hex(arg), single-quoted
2084 %n = hex(arg), single-quoted
2085 %% = a literal '%'
2085 %% = a literal '%'
2086
2086
2087 Prefixing the type with 'l' specifies a parenthesized list of that type.
2087 Prefixing the type with 'l' specifies a parenthesized list of that type.
2088
2088
2089 >>> formatspec('%r:: and %lr', '10 or 11', ("this()", "that()"))
2089 >>> formatspec('%r:: and %lr', '10 or 11', ("this()", "that()"))
2090 '(10 or 11):: and ((this()) or (that()))'
2090 '(10 or 11):: and ((this()) or (that()))'
2091 >>> formatspec('%d:: and not %d::', 10, 20)
2091 >>> formatspec('%d:: and not %d::', 10, 20)
2092 '10:: and not 20::'
2092 '10:: and not 20::'
2093 >>> formatspec('%ld or %ld', [], [1])
2093 >>> formatspec('%ld or %ld', [], [1])
2094 "_list('') or 1"
2094 "_list('') or 1"
2095 >>> formatspec('keyword(%s)', 'foo\\xe9')
2095 >>> formatspec('keyword(%s)', 'foo\\xe9')
2096 "keyword('foo\\\\xe9')"
2096 "keyword('foo\\\\xe9')"
2097 >>> b = lambda: 'default'
2097 >>> b = lambda: 'default'
2098 >>> b.branch = b
2098 >>> b.branch = b
2099 >>> formatspec('branch(%b)', b)
2099 >>> formatspec('branch(%b)', b)
2100 "branch('default')"
2100 "branch('default')"
2101 >>> formatspec('root(%ls)', ['a', 'b', 'c', 'd'])
2101 >>> formatspec('root(%ls)', ['a', 'b', 'c', 'd'])
2102 "root(_list('a\\x00b\\x00c\\x00d'))"
2102 "root(_list('a\\x00b\\x00c\\x00d'))"
2103 '''
2103 '''
2104
2104
2105 def quote(s):
2105 def quote(s):
2106 return repr(str(s))
2106 return repr(str(s))
2107
2107
2108 def argtype(c, arg):
2108 def argtype(c, arg):
2109 if c == 'd':
2109 if c == 'd':
2110 return str(int(arg))
2110 return str(int(arg))
2111 elif c == 's':
2111 elif c == 's':
2112 return quote(arg)
2112 return quote(arg)
2113 elif c == 'r':
2113 elif c == 'r':
2114 parse(arg) # make sure syntax errors are confined
2114 parse(arg) # make sure syntax errors are confined
2115 return '(%s)' % arg
2115 return '(%s)' % arg
2116 elif c == 'n':
2116 elif c == 'n':
2117 return quote(node.hex(arg))
2117 return quote(node.hex(arg))
2118 elif c == 'b':
2118 elif c == 'b':
2119 return quote(arg.branch())
2119 return quote(arg.branch())
2120
2120
2121 def listexp(s, t):
2121 def listexp(s, t):
2122 l = len(s)
2122 l = len(s)
2123 if l == 0:
2123 if l == 0:
2124 return "_list('')"
2124 return "_list('')"
2125 elif l == 1:
2125 elif l == 1:
2126 return argtype(t, s[0])
2126 return argtype(t, s[0])
2127 elif t == 'd':
2127 elif t == 'd':
2128 return "_intlist('%s')" % "\0".join(str(int(a)) for a in s)
2128 return "_intlist('%s')" % "\0".join(str(int(a)) for a in s)
2129 elif t == 's':
2129 elif t == 's':
2130 return "_list('%s')" % "\0".join(s)
2130 return "_list('%s')" % "\0".join(s)
2131 elif t == 'n':
2131 elif t == 'n':
2132 return "_hexlist('%s')" % "\0".join(node.hex(a) for a in s)
2132 return "_hexlist('%s')" % "\0".join(node.hex(a) for a in s)
2133 elif t == 'b':
2133 elif t == 'b':
2134 return "_list('%s')" % "\0".join(a.branch() for a in s)
2134 return "_list('%s')" % "\0".join(a.branch() for a in s)
2135
2135
2136 m = l // 2
2136 m = l // 2
2137 return '(%s or %s)' % (listexp(s[:m], t), listexp(s[m:], t))
2137 return '(%s or %s)' % (listexp(s[:m], t), listexp(s[m:], t))
2138
2138
2139 ret = ''
2139 ret = ''
2140 pos = 0
2140 pos = 0
2141 arg = 0
2141 arg = 0
2142 while pos < len(expr):
2142 while pos < len(expr):
2143 c = expr[pos]
2143 c = expr[pos]
2144 if c == '%':
2144 if c == '%':
2145 pos += 1
2145 pos += 1
2146 d = expr[pos]
2146 d = expr[pos]
2147 if d == '%':
2147 if d == '%':
2148 ret += d
2148 ret += d
2149 elif d in 'dsnbr':
2149 elif d in 'dsnbr':
2150 ret += argtype(d, args[arg])
2150 ret += argtype(d, args[arg])
2151 arg += 1
2151 arg += 1
2152 elif d == 'l':
2152 elif d == 'l':
2153 # a list of some type
2153 # a list of some type
2154 pos += 1
2154 pos += 1
2155 d = expr[pos]
2155 d = expr[pos]
2156 ret += listexp(list(args[arg]), d)
2156 ret += listexp(list(args[arg]), d)
2157 arg += 1
2157 arg += 1
2158 else:
2158 else:
2159 raise util.Abort('unexpected revspec format character %s' % d)
2159 raise util.Abort('unexpected revspec format character %s' % d)
2160 else:
2160 else:
2161 ret += c
2161 ret += c
2162 pos += 1
2162 pos += 1
2163
2163
2164 return ret
2164 return ret
2165
2165
2166 def prettyformat(tree):
2166 def prettyformat(tree):
2167 def _prettyformat(tree, level, lines):
2167 def _prettyformat(tree, level, lines):
2168 if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'):
2168 if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'):
2169 lines.append((level, str(tree)))
2169 lines.append((level, str(tree)))
2170 else:
2170 else:
2171 lines.append((level, '(%s' % tree[0]))
2171 lines.append((level, '(%s' % tree[0]))
2172 for s in tree[1:]:
2172 for s in tree[1:]:
2173 _prettyformat(s, level + 1, lines)
2173 _prettyformat(s, level + 1, lines)
2174 lines[-1:] = [(lines[-1][0], lines[-1][1] + ')')]
2174 lines[-1:] = [(lines[-1][0], lines[-1][1] + ')')]
2175
2175
2176 lines = []
2176 lines = []
2177 _prettyformat(tree, 0, lines)
2177 _prettyformat(tree, 0, lines)
2178 output = '\n'.join((' '*l + s) for l, s in lines)
2178 output = '\n'.join((' '*l + s) for l, s in lines)
2179 return output
2179 return output
2180
2180
2181 def depth(tree):
2181 def depth(tree):
2182 if isinstance(tree, tuple):
2182 if isinstance(tree, tuple):
2183 return max(map(depth, tree)) + 1
2183 return max(map(depth, tree)) + 1
2184 else:
2184 else:
2185 return 0
2185 return 0
2186
2186
2187 def funcsused(tree):
2187 def funcsused(tree):
2188 if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'):
2188 if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'):
2189 return set()
2189 return set()
2190 else:
2190 else:
2191 funcs = set()
2191 funcs = set()
2192 for s in tree[1:]:
2192 for s in tree[1:]:
2193 funcs |= funcsused(s)
2193 funcs |= funcsused(s)
2194 if tree[0] == 'func':
2194 if tree[0] == 'func':
2195 funcs.add(tree[1][1])
2195 funcs.add(tree[1][1])
2196 return funcs
2196 return funcs
2197
2197
2198 class abstractsmartset(object):
2198 class abstractsmartset(object):
2199
2199
2200 def __nonzero__(self):
2200 def __nonzero__(self):
2201 """True if the smartset is not empty"""
2201 """True if the smartset is not empty"""
2202 raise NotImplementedError()
2202 raise NotImplementedError()
2203
2203
2204 def __contains__(self, rev):
2204 def __contains__(self, rev):
2205 """provide fast membership testing"""
2205 """provide fast membership testing"""
2206 raise NotImplementedError()
2206 raise NotImplementedError()
2207
2207
2208 def __set__(self):
2208 def __set__(self):
2209 """Returns a set or a smartset containing all the elements.
2209 """Returns a set or a smartset containing all the elements.
2210
2210
2211 The returned structure should be the fastest option for membership
2211 The returned structure should be the fastest option for membership
2212 testing.
2212 testing.
2213
2213
2214 This is part of the mandatory API for smartset."""
2214 This is part of the mandatory API for smartset."""
2215 raise NotImplementedError()
2215 raise NotImplementedError()
2216
2216
2217 def __iter__(self):
2217 def __iter__(self):
2218 """iterate the set in the order it is supposed to be iterated"""
2218 """iterate the set in the order it is supposed to be iterated"""
2219 raise NotImplementedError()
2219 raise NotImplementedError()
2220
2220
2221 # Attributes containing a function to perform a fast iteration in a given
2221 # Attributes containing a function to perform a fast iteration in a given
2222 # direction. A smartset can have none, one, or both defined.
2222 # direction. A smartset can have none, one, or both defined.
2223 #
2223 #
2224 # Default value is None instead of a function returning None to avoid
2224 # Default value is None instead of a function returning None to avoid
2225 # initializing an iterator just for testing if a fast method exists.
2225 # initializing an iterator just for testing if a fast method exists.
2226 fastasc = None
2226 fastasc = None
2227 fastdesc = None
2227 fastdesc = None
2228
2228
2229 def isascending(self):
2229 def isascending(self):
2230 """True if the set will iterate in ascending order"""
2230 """True if the set will iterate in ascending order"""
2231 raise NotImplementedError()
2231 raise NotImplementedError()
2232
2232
2233 def ascending(self):
2233 def ascending(self):
2234 """Sorts the set in ascending order (in place).
2234 """Sorts the set in ascending order (in place).
2235
2235
2236 This is part of the mandatory API for smartset."""
2236 This is part of the mandatory API for smartset."""
2237 self.sort()
2237 self.sort()
2238
2238
2239 def isdescending(self):
2239 def isdescending(self):
2240 """True if the set will iterate in descending order"""
2240 """True if the set will iterate in descending order"""
2241 raise NotImplementedError()
2241 raise NotImplementedError()
2242
2242
2243 def descending(self):
2243 def descending(self):
2244 """Sorts the set in descending order (in place).
2244 """Sorts the set in descending order (in place).
2245
2245
2246 This is part of the mandatory API for smartset."""
2246 This is part of the mandatory API for smartset."""
2247 self.sort(reverse=True)
2247 self.sort(reverse=True)
2248
2248
2249 def min(self):
2249 def min(self):
2250 """return the minimum element in the set"""
2250 """return the minimum element in the set"""
2251 if self.fastasc is not None:
2251 if self.fastasc is not None:
2252 for r in self.fastasc():
2252 for r in self.fastasc():
2253 return r
2253 return r
2254 raise ValueError('arg is an empty sequence')
2254 raise ValueError('arg is an empty sequence')
2255 return min(self)
2255 return min(self)
2256
2256
2257 def max(self):
2257 def max(self):
2258 """return the maximum element in the set"""
2258 """return the maximum element in the set"""
2259 if self.fastdesc is not None:
2259 if self.fastdesc is not None:
2260 for r in self.fastdesc():
2260 for r in self.fastdesc():
2261 return r
2261 return r
2262 raise ValueError('arg is an empty sequence')
2262 raise ValueError('arg is an empty sequence')
2263 return max(self)
2263 return max(self)
2264
2264
2265 def first(self):
2265 def first(self):
2266 """return the first element in the set (user iteration perspective)
2266 """return the first element in the set (user iteration perspective)
2267
2267
2268 Return None if the set is empty"""
2268 Return None if the set is empty"""
2269 raise NotImplementedError()
2269 raise NotImplementedError()
2270
2270
2271 def last(self):
2271 def last(self):
2272 """return the last element in the set (user iteration perspective)
2272 """return the last element in the set (user iteration perspective)
2273
2273
2274 Return None if the set is empty"""
2274 Return None if the set is empty"""
2275 raise NotImplementedError()
2275 raise NotImplementedError()
2276
2276
2277 def reverse(self):
2277 def reverse(self):
2278 """reverse the expected iteration order"""
2278 """reverse the expected iteration order"""
2279 raise NotImplementedError()
2279 raise NotImplementedError()
2280
2280
2281 def sort(self, reverse=True):
2281 def sort(self, reverse=True):
2282 """get the set to iterate in an ascending or descending order"""
2282 """get the set to iterate in an ascending or descending order"""
2283 raise NotImplementedError()
2283 raise NotImplementedError()
2284
2284
2285 def __and__(self, other):
2285 def __and__(self, other):
2286 """Returns a new object with the intersection of the two collections.
2286 """Returns a new object with the intersection of the two collections.
2287
2287
2288 This is part of the mandatory API for smartset."""
2288 This is part of the mandatory API for smartset."""
2289 return self.filter(other.__contains__)
2289 return self.filter(other.__contains__)
2290
2290
2291 def __add__(self, other):
2291 def __add__(self, other):
2292 """Returns a new object with the union of the two collections.
2292 """Returns a new object with the union of the two collections.
2293
2293
2294 This is part of the mandatory API for smartset."""
2294 This is part of the mandatory API for smartset."""
2295 kwargs = {}
2295 kwargs = {}
2296 if self.isascending() and other.isascending():
2296 if self.isascending() and other.isascending():
2297 kwargs['ascending'] = True
2297 kwargs['ascending'] = True
2298 if self.isdescending() and other.isdescending():
2298 if self.isdescending() and other.isdescending():
2299 kwargs['ascending'] = False
2299 kwargs['ascending'] = False
2300 return addset(self, other, **kwargs)
2300 return addset(self, other, **kwargs)
2301
2301
2302 def __sub__(self, other):
2302 def __sub__(self, other):
2303 """Returns a new object with the substraction of the two collections.
2303 """Returns a new object with the substraction of the two collections.
2304
2304
2305 This is part of the mandatory API for smartset."""
2305 This is part of the mandatory API for smartset."""
2306 c = other.__contains__
2306 c = other.__contains__
2307 return self.filter(lambda r: not c(r))
2307 return self.filter(lambda r: not c(r))
2308
2308
2309 def filter(self, condition):
2309 def filter(self, condition):
2310 """Returns this smartset filtered by condition as a new smartset.
2310 """Returns this smartset filtered by condition as a new smartset.
2311
2311
2312 `condition` is a callable which takes a revision number and returns a
2312 `condition` is a callable which takes a revision number and returns a
2313 boolean.
2313 boolean.
2314
2314
2315 This is part of the mandatory API for smartset."""
2315 This is part of the mandatory API for smartset."""
2316 kwargs = {}
2316 kwargs = {}
2317 if self.isascending():
2317 if self.isascending():
2318 kwargs['ascending'] = True
2318 kwargs['ascending'] = True
2319 elif self.isdescending():
2319 elif self.isdescending():
2320 kwargs['ascending'] = False
2320 kwargs['ascending'] = False
2321 return filteredset(self, condition, **kwargs)
2321 return filteredset(self, condition, **kwargs)
2322
2322
2323 class baseset(abstractsmartset):
2323 class baseset(abstractsmartset):
2324 """Basic data structure that represents a revset and contains the basic
2324 """Basic data structure that represents a revset and contains the basic
2325 operation that it should be able to perform.
2325 operation that it should be able to perform.
2326
2326
2327 Every method in this class should be implemented by any smartset class.
2327 Every method in this class should be implemented by any smartset class.
2328 """
2328 """
2329 def __init__(self, data=()):
2329 def __init__(self, data=()):
2330 if not isinstance(data, list):
2330 if not isinstance(data, list):
2331 data = list(data)
2331 data = list(data)
2332 self._list = data
2332 self._list = data
2333 self._set = None
2333 self._set = None
2334 self._ascending = None
2334 self._ascending = None
2335
2335
2336 @util.propertycache
2336 @util.propertycache
2337 def _asclist(self):
2337 def _asclist(self):
2338 asclist = self._list[:]
2338 asclist = self._list[:]
2339 asclist.sort()
2339 asclist.sort()
2340 return asclist
2340 return asclist
2341
2341
2342 def __iter__(self):
2342 def __iter__(self):
2343 if self._ascending is None:
2343 if self._ascending is None:
2344 return iter(self._list)
2344 return iter(self._list)
2345 elif self._ascending:
2345 elif self._ascending:
2346 return iter(self._asclist)
2346 return iter(self._asclist)
2347 else:
2347 else:
2348 return reversed(self._asclist)
2348 return reversed(self._asclist)
2349
2349
2350 def fastasc(self):
2350 def fastasc(self):
2351 return iter(self._asclist)
2351 return iter(self._asclist)
2352
2352
2353 def fastdesc(self):
2353 def fastdesc(self):
2354 return reversed(self._asclist)
2354 return reversed(self._asclist)
2355
2355
2356 def set(self):
2356 def set(self):
2357 """Returns a set or a smartset containing all the elements.
2357 """Returns a set or a smartset containing all the elements.
2358
2358
2359 The returned structure should be the fastest option for membership
2359 The returned structure should be the fastest option for membership
2360 testing.
2360 testing.
2361
2361
2362 This is part of the mandatory API for smartset."""
2362 This is part of the mandatory API for smartset."""
2363 if not self._set:
2363 if not self._set:
2364 self._set = set(self)
2364 self._set = set(self)
2365 return self._set
2365 return self._set
2366
2366
2367 @util.propertycache
2367 @util.propertycache
2368 def __contains__(self):
2368 def __contains__(self):
2369 return self.set().__contains__
2369 return self.set().__contains__
2370
2370
2371 def __nonzero__(self):
2371 def __nonzero__(self):
2372 return bool(self._list)
2372 return bool(self._list)
2373
2373
2374 def sort(self, reverse=False):
2374 def sort(self, reverse=False):
2375 self._list.sort(reverse=reverse)
2375 self._list.sort(reverse=reverse)
2376
2376
2377 def reverse(self):
2377 def reverse(self):
2378 self._list.reverse()
2378 self._list.reverse()
2379
2379
2380 def __len__(self):
2380 def __len__(self):
2381 return len(self._list)
2381 return len(self._list)
2382
2382
2383 def __sub__(self, other):
2383 def __sub__(self, other):
2384 """Returns a new object with the substraction of the two collections.
2384 """Returns a new object with the substraction of the two collections.
2385
2385
2386 This is part of the mandatory API for smartset."""
2386 This is part of the mandatory API for smartset."""
2387 # If we are operating on 2 baseset, do the computation now since all
2387 # If we are operating on 2 baseset, do the computation now since all
2388 # data is available. The alternative is to involve a filteredset, which
2388 # data is available. The alternative is to involve a filteredset, which
2389 # may be slow.
2389 # may be slow.
2390 if isinstance(other, baseset):
2390 if isinstance(other, baseset):
2391 other = other.set()
2391 other = other.set()
2392 return baseset([x for x in self if x not in other])
2392 return baseset([x for x in self if x not in other])
2393
2393
2394 return self.filter(lambda x: x not in other)
2394 return self.filter(lambda x: x not in other)
2395
2395
2396 def __and__(self, other):
2396 def __and__(self, other):
2397 """Returns a new object with the intersection of the two collections.
2397 """Returns a new object with the intersection of the two collections.
2398
2398
2399 This is part of the mandatory API for smartset."""
2399 This is part of the mandatory API for smartset."""
2400 return baseset([y for y in self if y in other])
2400 return baseset([y for y in self if y in other])
2401
2401
2402 def __add__(self, other):
2402 def __add__(self, other):
2403 """Returns a new object with the union of the two collections.
2403 """Returns a new object with the union of the two collections.
2404
2404
2405 This is part of the mandatory API for smartset."""
2405 This is part of the mandatory API for smartset."""
2406 s = self.set()
2406 s = self.set()
2407 l = [r for r in other if r not in s]
2407 l = [r for r in other if r not in s]
2408 return baseset(list(self) + l)
2408 return baseset(list(self) + l)
2409
2409
2410 def isascending(self):
2410 def isascending(self):
2411 """Returns True if the collection is ascending order, False if not.
2411 """Returns True if the collection is ascending order, False if not.
2412
2412
2413 This is part of the mandatory API for smartset."""
2413 This is part of the mandatory API for smartset."""
2414 return False
2414 return self._ascending is not None and self._ascending
2415
2415
2416 def isdescending(self):
2416 def isdescending(self):
2417 """Returns True if the collection is descending order, False if not.
2417 """Returns True if the collection is descending order, False if not.
2418
2418
2419 This is part of the mandatory API for smartset."""
2419 This is part of the mandatory API for smartset."""
2420 return False
2420 return self._ascending is not None and not self._ascending
2421
2421
2422 def first(self):
2422 def first(self):
2423 if self:
2423 if self:
2424 return self._list[0]
2424 return self._list[0]
2425 return None
2425 return None
2426
2426
2427 def last(self):
2427 def last(self):
2428 if self:
2428 if self:
2429 return self._list[-1]
2429 return self._list[-1]
2430 return None
2430 return None
2431
2431
2432 class filteredset(abstractsmartset):
2432 class filteredset(abstractsmartset):
2433 """Duck type for baseset class which iterates lazily over the revisions in
2433 """Duck type for baseset class which iterates lazily over the revisions in
2434 the subset and contains a function which tests for membership in the
2434 the subset and contains a function which tests for membership in the
2435 revset
2435 revset
2436 """
2436 """
2437 def __init__(self, subset, condition=lambda x: True, ascending=None):
2437 def __init__(self, subset, condition=lambda x: True, ascending=None):
2438 """
2438 """
2439 condition: a function that decide whether a revision in the subset
2439 condition: a function that decide whether a revision in the subset
2440 belongs to the revset or not.
2440 belongs to the revset or not.
2441 """
2441 """
2442 self._subset = subset
2442 self._subset = subset
2443 self._condition = condition
2443 self._condition = condition
2444 self._cache = {}
2444 self._cache = {}
2445 if ascending is not None:
2445 if ascending is not None:
2446 ascending = bool(ascending)
2446 ascending = bool(ascending)
2447 self._ascending = ascending
2447 self._ascending = ascending
2448
2448
2449 def __contains__(self, x):
2449 def __contains__(self, x):
2450 c = self._cache
2450 c = self._cache
2451 if x not in c:
2451 if x not in c:
2452 v = c[x] = x in self._subset and self._condition(x)
2452 v = c[x] = x in self._subset and self._condition(x)
2453 return v
2453 return v
2454 return c[x]
2454 return c[x]
2455
2455
2456 def __iter__(self):
2456 def __iter__(self):
2457 return self._iterfilter(self._subset)
2457 return self._iterfilter(self._subset)
2458
2458
2459 def _iterfilter(self, it):
2459 def _iterfilter(self, it):
2460 cond = self._condition
2460 cond = self._condition
2461 for x in it:
2461 for x in it:
2462 if cond(x):
2462 if cond(x):
2463 yield x
2463 yield x
2464
2464
2465 @property
2465 @property
2466 def fastasc(self):
2466 def fastasc(self):
2467 it = self._subset.fastasc
2467 it = self._subset.fastasc
2468 if it is None:
2468 if it is None:
2469 return None
2469 return None
2470 return lambda: self._iterfilter(it())
2470 return lambda: self._iterfilter(it())
2471
2471
2472 @property
2472 @property
2473 def fastdesc(self):
2473 def fastdesc(self):
2474 it = self._subset.fastdesc
2474 it = self._subset.fastdesc
2475 if it is None:
2475 if it is None:
2476 return None
2476 return None
2477 return lambda: self._iterfilter(it())
2477 return lambda: self._iterfilter(it())
2478
2478
2479 def __nonzero__(self):
2479 def __nonzero__(self):
2480 for r in self:
2480 for r in self:
2481 return True
2481 return True
2482 return False
2482 return False
2483
2483
2484 def __len__(self):
2484 def __len__(self):
2485 # Basic implementation to be changed in future patches.
2485 # Basic implementation to be changed in future patches.
2486 l = baseset([r for r in self])
2486 l = baseset([r for r in self])
2487 return len(l)
2487 return len(l)
2488
2488
2489 def __getitem__(self, x):
2489 def __getitem__(self, x):
2490 # Basic implementation to be changed in future patches.
2490 # Basic implementation to be changed in future patches.
2491 l = baseset([r for r in self])
2491 l = baseset([r for r in self])
2492 return l[x]
2492 return l[x]
2493
2493
2494 def sort(self, reverse=False):
2494 def sort(self, reverse=False):
2495 if self._ascending is None:
2495 if self._ascending is None:
2496 if not util.safehasattr(self._subset, 'sort'):
2496 if not util.safehasattr(self._subset, 'sort'):
2497 self._subset = baseset(self._subset)
2497 self._subset = baseset(self._subset)
2498 self._subset.sort(reverse=reverse)
2498 self._subset.sort(reverse=reverse)
2499 self._ascending = not reverse
2499 self._ascending = not reverse
2500 elif bool(reverse) == self._ascending:
2500 elif bool(reverse) == self._ascending:
2501 self.reverse()
2501 self.reverse()
2502
2502
2503 def reverse(self):
2503 def reverse(self):
2504 self._subset.reverse()
2504 self._subset.reverse()
2505 if self._ascending is not None:
2505 if self._ascending is not None:
2506 self._ascending = not self._ascending
2506 self._ascending = not self._ascending
2507
2507
2508 def set(self):
2508 def set(self):
2509 return set([r for r in self])
2509 return set([r for r in self])
2510
2510
2511 def isascending(self):
2511 def isascending(self):
2512 return self._ascending is not None and self._ascending
2512 return self._ascending is not None and self._ascending
2513
2513
2514 def isdescending(self):
2514 def isdescending(self):
2515 return self._ascending is not None and not self._ascending
2515 return self._ascending is not None and not self._ascending
2516
2516
2517 def first(self):
2517 def first(self):
2518 for x in self:
2518 for x in self:
2519 return x
2519 return x
2520 return None
2520 return None
2521
2521
2522 def last(self):
2522 def last(self):
2523 it = None
2523 it = None
2524 if self._ascending is not None:
2524 if self._ascending is not None:
2525 if self._ascending:
2525 if self._ascending:
2526 it = self.fastdesc
2526 it = self.fastdesc
2527 else:
2527 else:
2528 it = self.fastasc
2528 it = self.fastasc
2529 if it is None:
2529 if it is None:
2530 # slowly consume everything. This needs improvement
2530 # slowly consume everything. This needs improvement
2531 it = lambda: reversed(list(self))
2531 it = lambda: reversed(list(self))
2532 for x in it():
2532 for x in it():
2533 return x
2533 return x
2534 return None
2534 return None
2535
2535
2536 class addset(abstractsmartset):
2536 class addset(abstractsmartset):
2537 """Represent the addition of two sets
2537 """Represent the addition of two sets
2538
2538
2539 Wrapper structure for lazily adding two structures without losing much
2539 Wrapper structure for lazily adding two structures without losing much
2540 performance on the __contains__ method
2540 performance on the __contains__ method
2541
2541
2542 If the ascending attribute is set, that means the two structures are
2542 If the ascending attribute is set, that means the two structures are
2543 ordered in either an ascending or descending way. Therefore, we can add
2543 ordered in either an ascending or descending way. Therefore, we can add
2544 them maintaining the order by iterating over both at the same time
2544 them maintaining the order by iterating over both at the same time
2545 """
2545 """
2546 def __init__(self, revs1, revs2, ascending=None):
2546 def __init__(self, revs1, revs2, ascending=None):
2547 self._r1 = revs1
2547 self._r1 = revs1
2548 self._r2 = revs2
2548 self._r2 = revs2
2549 self._iter = None
2549 self._iter = None
2550 self._ascending = ascending
2550 self._ascending = ascending
2551 self._genlist = None
2551 self._genlist = None
2552
2552
2553 def __len__(self):
2553 def __len__(self):
2554 return len(self._list)
2554 return len(self._list)
2555
2555
2556 def __nonzero__(self):
2556 def __nonzero__(self):
2557 return bool(self._r1 or self._r2)
2557 return bool(self._r1 or self._r2)
2558
2558
2559 @util.propertycache
2559 @util.propertycache
2560 def _list(self):
2560 def _list(self):
2561 if not self._genlist:
2561 if not self._genlist:
2562 self._genlist = baseset(self._iterator())
2562 self._genlist = baseset(self._iterator())
2563 return self._genlist
2563 return self._genlist
2564
2564
2565 def _iterator(self):
2565 def _iterator(self):
2566 """Iterate over both collections without repeating elements
2566 """Iterate over both collections without repeating elements
2567
2567
2568 If the ascending attribute is not set, iterate over the first one and
2568 If the ascending attribute is not set, iterate over the first one and
2569 then over the second one checking for membership on the first one so we
2569 then over the second one checking for membership on the first one so we
2570 dont yield any duplicates.
2570 dont yield any duplicates.
2571
2571
2572 If the ascending attribute is set, iterate over both collections at the
2572 If the ascending attribute is set, iterate over both collections at the
2573 same time, yielding only one value at a time in the given order.
2573 same time, yielding only one value at a time in the given order.
2574 """
2574 """
2575 if self._ascending is None:
2575 if self._ascending is None:
2576 def gen():
2576 def gen():
2577 for r in self._r1:
2577 for r in self._r1:
2578 yield r
2578 yield r
2579 s = self._r1.set()
2579 s = self._r1.set()
2580 for r in self._r2:
2580 for r in self._r2:
2581 if r not in s:
2581 if r not in s:
2582 yield r
2582 yield r
2583 gen = gen()
2583 gen = gen()
2584 else:
2584 else:
2585 iter1 = iter(self._r1)
2585 iter1 = iter(self._r1)
2586 iter2 = iter(self._r2)
2586 iter2 = iter(self._r2)
2587 gen = self._iterordered(self._ascending, iter1, iter2)
2587 gen = self._iterordered(self._ascending, iter1, iter2)
2588 return gen
2588 return gen
2589
2589
2590 def __iter__(self):
2590 def __iter__(self):
2591 if self._genlist:
2591 if self._genlist:
2592 return iter(self._genlist)
2592 return iter(self._genlist)
2593 return iter(self._iterator())
2593 return iter(self._iterator())
2594
2594
2595 @property
2595 @property
2596 def fastasc(self):
2596 def fastasc(self):
2597 iter1 = self._r1.fastasc
2597 iter1 = self._r1.fastasc
2598 iter2 = self._r2.fastasc
2598 iter2 = self._r2.fastasc
2599 if None in (iter1, iter2):
2599 if None in (iter1, iter2):
2600 return None
2600 return None
2601 return lambda: self._iterordered(True, iter1(), iter2())
2601 return lambda: self._iterordered(True, iter1(), iter2())
2602
2602
2603 @property
2603 @property
2604 def fastdesc(self):
2604 def fastdesc(self):
2605 iter1 = self._r1.fastdesc
2605 iter1 = self._r1.fastdesc
2606 iter2 = self._r2.fastdesc
2606 iter2 = self._r2.fastdesc
2607 if None in (iter1, iter2):
2607 if None in (iter1, iter2):
2608 return None
2608 return None
2609 return lambda: self._iterordered(False, iter1(), iter2())
2609 return lambda: self._iterordered(False, iter1(), iter2())
2610
2610
2611 def _iterordered(self, ascending, iter1, iter2):
2611 def _iterordered(self, ascending, iter1, iter2):
2612 """produce an ordered iteration from two iterators with the same order
2612 """produce an ordered iteration from two iterators with the same order
2613
2613
2614 The ascending is used to indicated the iteration direction.
2614 The ascending is used to indicated the iteration direction.
2615 """
2615 """
2616 choice = max
2616 choice = max
2617 if ascending:
2617 if ascending:
2618 choice = min
2618 choice = min
2619
2619
2620 val1 = None
2620 val1 = None
2621 val2 = None
2621 val2 = None
2622
2622
2623 choice = max
2623 choice = max
2624 if ascending:
2624 if ascending:
2625 choice = min
2625 choice = min
2626 try:
2626 try:
2627 # Consume both iterators in an ordered way until one is
2627 # Consume both iterators in an ordered way until one is
2628 # empty
2628 # empty
2629 while True:
2629 while True:
2630 if val1 is None:
2630 if val1 is None:
2631 val1 = iter1.next()
2631 val1 = iter1.next()
2632 if val2 is None:
2632 if val2 is None:
2633 val2 = iter2.next()
2633 val2 = iter2.next()
2634 next = choice(val1, val2)
2634 next = choice(val1, val2)
2635 yield next
2635 yield next
2636 if val1 == next:
2636 if val1 == next:
2637 val1 = None
2637 val1 = None
2638 if val2 == next:
2638 if val2 == next:
2639 val2 = None
2639 val2 = None
2640 except StopIteration:
2640 except StopIteration:
2641 # Flush any remaining values and consume the other one
2641 # Flush any remaining values and consume the other one
2642 it = iter2
2642 it = iter2
2643 if val1 is not None:
2643 if val1 is not None:
2644 yield val1
2644 yield val1
2645 it = iter1
2645 it = iter1
2646 elif val2 is not None:
2646 elif val2 is not None:
2647 # might have been equality and both are empty
2647 # might have been equality and both are empty
2648 yield val2
2648 yield val2
2649 for val in it:
2649 for val in it:
2650 yield val
2650 yield val
2651
2651
2652 def __contains__(self, x):
2652 def __contains__(self, x):
2653 return x in self._r1 or x in self._r2
2653 return x in self._r1 or x in self._r2
2654
2654
2655 def set(self):
2655 def set(self):
2656 return self
2656 return self
2657
2657
2658 def sort(self, reverse=False):
2658 def sort(self, reverse=False):
2659 """Sort the added set
2659 """Sort the added set
2660
2660
2661 For this we use the cached list with all the generated values and if we
2661 For this we use the cached list with all the generated values and if we
2662 know they are ascending or descending we can sort them in a smart way.
2662 know they are ascending or descending we can sort them in a smart way.
2663 """
2663 """
2664 if self._ascending is None:
2664 if self._ascending is None:
2665 self._list.sort(reverse=reverse)
2665 self._list.sort(reverse=reverse)
2666 self._ascending = not reverse
2666 self._ascending = not reverse
2667 else:
2667 else:
2668 if bool(self._ascending) == bool(reverse):
2668 if bool(self._ascending) == bool(reverse):
2669 self.reverse()
2669 self.reverse()
2670
2670
2671 def isascending(self):
2671 def isascending(self):
2672 return self._ascending is not None and self._ascending
2672 return self._ascending is not None and self._ascending
2673
2673
2674 def isdescending(self):
2674 def isdescending(self):
2675 return self._ascending is not None and not self._ascending
2675 return self._ascending is not None and not self._ascending
2676
2676
2677 def reverse(self):
2677 def reverse(self):
2678 self._list.reverse()
2678 self._list.reverse()
2679 if self._ascending is not None:
2679 if self._ascending is not None:
2680 self._ascending = not self._ascending
2680 self._ascending = not self._ascending
2681
2681
2682 def first(self):
2682 def first(self):
2683 if self:
2683 if self:
2684 return self._list.first()
2684 return self._list.first()
2685 return None
2685 return None
2686
2686
2687 def last(self):
2687 def last(self):
2688 if self:
2688 if self:
2689 return self._list.last()
2689 return self._list.last()
2690 return None
2690 return None
2691
2691
2692 class generatorset(abstractsmartset):
2692 class generatorset(abstractsmartset):
2693 """Wrap a generator for lazy iteration
2693 """Wrap a generator for lazy iteration
2694
2694
2695 Wrapper structure for generators that provides lazy membership and can
2695 Wrapper structure for generators that provides lazy membership and can
2696 be iterated more than once.
2696 be iterated more than once.
2697 When asked for membership it generates values until either it finds the
2697 When asked for membership it generates values until either it finds the
2698 requested one or has gone through all the elements in the generator
2698 requested one or has gone through all the elements in the generator
2699 """
2699 """
2700 def __init__(self, gen, iterasc=None):
2700 def __init__(self, gen, iterasc=None):
2701 """
2701 """
2702 gen: a generator producing the values for the generatorset.
2702 gen: a generator producing the values for the generatorset.
2703 """
2703 """
2704 self._gen = gen
2704 self._gen = gen
2705 self._asclist = None
2705 self._asclist = None
2706 self._cache = {}
2706 self._cache = {}
2707 self._genlist = []
2707 self._genlist = []
2708 self._finished = False
2708 self._finished = False
2709 self._ascending = True
2709 self._ascending = True
2710 if iterasc is not None:
2710 if iterasc is not None:
2711 if iterasc:
2711 if iterasc:
2712 self.fastasc = self._iterator
2712 self.fastasc = self._iterator
2713 self.__contains__ = self._asccontains
2713 self.__contains__ = self._asccontains
2714 else:
2714 else:
2715 self.fastdesc = self._iterator
2715 self.fastdesc = self._iterator
2716 self.__contains__ = self._desccontains
2716 self.__contains__ = self._desccontains
2717
2717
2718 def __nonzero__(self):
2718 def __nonzero__(self):
2719 for r in self:
2719 for r in self:
2720 return True
2720 return True
2721 return False
2721 return False
2722
2722
2723 def __contains__(self, x):
2723 def __contains__(self, x):
2724 if x in self._cache:
2724 if x in self._cache:
2725 return self._cache[x]
2725 return self._cache[x]
2726
2726
2727 # Use new values only, as existing values would be cached.
2727 # Use new values only, as existing values would be cached.
2728 for l in self._consumegen():
2728 for l in self._consumegen():
2729 if l == x:
2729 if l == x:
2730 return True
2730 return True
2731
2731
2732 self._cache[x] = False
2732 self._cache[x] = False
2733 return False
2733 return False
2734
2734
2735 def _asccontains(self, x):
2735 def _asccontains(self, x):
2736 """version of contains optimised for ascending generator"""
2736 """version of contains optimised for ascending generator"""
2737 if x in self._cache:
2737 if x in self._cache:
2738 return self._cache[x]
2738 return self._cache[x]
2739
2739
2740 # Use new values only, as existing values would be cached.
2740 # Use new values only, as existing values would be cached.
2741 for l in self._consumegen():
2741 for l in self._consumegen():
2742 if l == x:
2742 if l == x:
2743 return True
2743 return True
2744 if l > x:
2744 if l > x:
2745 break
2745 break
2746
2746
2747 self._cache[x] = False
2747 self._cache[x] = False
2748 return False
2748 return False
2749
2749
2750 def _desccontains(self, x):
2750 def _desccontains(self, x):
2751 """version of contains optimised for descending generator"""
2751 """version of contains optimised for descending generator"""
2752 if x in self._cache:
2752 if x in self._cache:
2753 return self._cache[x]
2753 return self._cache[x]
2754
2754
2755 # Use new values only, as existing values would be cached.
2755 # Use new values only, as existing values would be cached.
2756 for l in self._consumegen():
2756 for l in self._consumegen():
2757 if l == x:
2757 if l == x:
2758 return True
2758 return True
2759 if l < x:
2759 if l < x:
2760 break
2760 break
2761
2761
2762 self._cache[x] = False
2762 self._cache[x] = False
2763 return False
2763 return False
2764
2764
2765 def __iter__(self):
2765 def __iter__(self):
2766 if self._ascending:
2766 if self._ascending:
2767 it = self.fastasc
2767 it = self.fastasc
2768 else:
2768 else:
2769 it = self.fastdesc
2769 it = self.fastdesc
2770 if it is not None:
2770 if it is not None:
2771 return it()
2771 return it()
2772 # we need to consume the iterator
2772 # we need to consume the iterator
2773 for x in self._consumegen():
2773 for x in self._consumegen():
2774 pass
2774 pass
2775 # recall the same code
2775 # recall the same code
2776 return iter(self)
2776 return iter(self)
2777
2777
2778 def _iterator(self):
2778 def _iterator(self):
2779 if self._finished:
2779 if self._finished:
2780 return iter(self._genlist)
2780 return iter(self._genlist)
2781
2781
2782 # We have to use this complex iteration strategy to allow multiple
2782 # We have to use this complex iteration strategy to allow multiple
2783 # iterations at the same time. We need to be able to catch revision
2783 # iterations at the same time. We need to be able to catch revision
2784 # removed from `consumegen` and added to genlist in another instance.
2784 # removed from `consumegen` and added to genlist in another instance.
2785 #
2785 #
2786 # Getting rid of it would provide an about 15% speed up on this
2786 # Getting rid of it would provide an about 15% speed up on this
2787 # iteration.
2787 # iteration.
2788 genlist = self._genlist
2788 genlist = self._genlist
2789 nextrev = self._consumegen().next
2789 nextrev = self._consumegen().next
2790 _len = len # cache global lookup
2790 _len = len # cache global lookup
2791 def gen():
2791 def gen():
2792 i = 0
2792 i = 0
2793 while True:
2793 while True:
2794 if i < _len(genlist):
2794 if i < _len(genlist):
2795 yield genlist[i]
2795 yield genlist[i]
2796 else:
2796 else:
2797 yield nextrev()
2797 yield nextrev()
2798 i += 1
2798 i += 1
2799 return gen()
2799 return gen()
2800
2800
2801 def _consumegen(self):
2801 def _consumegen(self):
2802 cache = self._cache
2802 cache = self._cache
2803 genlist = self._genlist.append
2803 genlist = self._genlist.append
2804 for item in self._gen:
2804 for item in self._gen:
2805 cache[item] = True
2805 cache[item] = True
2806 genlist(item)
2806 genlist(item)
2807 yield item
2807 yield item
2808 if not self._finished:
2808 if not self._finished:
2809 self._finished = True
2809 self._finished = True
2810 asc = self._genlist[:]
2810 asc = self._genlist[:]
2811 asc.sort()
2811 asc.sort()
2812 self._asclist = asc
2812 self._asclist = asc
2813 self.fastasc = asc.__iter__
2813 self.fastasc = asc.__iter__
2814 self.fastdesc = asc.__reversed__
2814 self.fastdesc = asc.__reversed__
2815
2815
2816 def set(self):
2816 def set(self):
2817 return self
2817 return self
2818
2818
2819 def sort(self, reverse=False):
2819 def sort(self, reverse=False):
2820 self._ascending = not reverse
2820 self._ascending = not reverse
2821
2821
2822 def reverse(self):
2822 def reverse(self):
2823 self._ascending = not self._ascending
2823 self._ascending = not self._ascending
2824
2824
2825 def isascending(self):
2825 def isascending(self):
2826 return self._ascending
2826 return self._ascending
2827
2827
2828 def isdescending(self):
2828 def isdescending(self):
2829 return not self._ascending
2829 return not self._ascending
2830
2830
2831 def first(self):
2831 def first(self):
2832 if self._ascending:
2832 if self._ascending:
2833 it = self.fastasc
2833 it = self.fastasc
2834 else:
2834 else:
2835 it = self.fastdesc
2835 it = self.fastdesc
2836 if it is None:
2836 if it is None:
2837 # we need to consume all and try again
2837 # we need to consume all and try again
2838 for x in self._consumegen():
2838 for x in self._consumegen():
2839 pass
2839 pass
2840 return self.first()
2840 return self.first()
2841 if self:
2841 if self:
2842 return it.next()
2842 return it.next()
2843 return None
2843 return None
2844
2844
2845 def last(self):
2845 def last(self):
2846 if self._ascending:
2846 if self._ascending:
2847 it = self.fastdesc
2847 it = self.fastdesc
2848 else:
2848 else:
2849 it = self.fastasc
2849 it = self.fastasc
2850 if it is None:
2850 if it is None:
2851 # we need to consume all and try again
2851 # we need to consume all and try again
2852 for x in self._consumegen():
2852 for x in self._consumegen():
2853 pass
2853 pass
2854 return self.first()
2854 return self.first()
2855 if self:
2855 if self:
2856 return it.next()
2856 return it.next()
2857 return None
2857 return None
2858
2858
2859 def spanset(repo, start=None, end=None):
2859 def spanset(repo, start=None, end=None):
2860 """factory function to dispatch between fullreposet and actual spanset
2860 """factory function to dispatch between fullreposet and actual spanset
2861
2861
2862 Feel free to update all spanset call sites and kill this function at some
2862 Feel free to update all spanset call sites and kill this function at some
2863 point.
2863 point.
2864 """
2864 """
2865 if start is None and end is None:
2865 if start is None and end is None:
2866 return fullreposet(repo)
2866 return fullreposet(repo)
2867 return _spanset(repo, start, end)
2867 return _spanset(repo, start, end)
2868
2868
2869
2869
2870 class _spanset(abstractsmartset):
2870 class _spanset(abstractsmartset):
2871 """Duck type for baseset class which represents a range of revisions and
2871 """Duck type for baseset class which represents a range of revisions and
2872 can work lazily and without having all the range in memory
2872 can work lazily and without having all the range in memory
2873
2873
2874 Note that spanset(x, y) behave almost like xrange(x, y) except for two
2874 Note that spanset(x, y) behave almost like xrange(x, y) except for two
2875 notable points:
2875 notable points:
2876 - when x < y it will be automatically descending,
2876 - when x < y it will be automatically descending,
2877 - revision filtered with this repoview will be skipped.
2877 - revision filtered with this repoview will be skipped.
2878
2878
2879 """
2879 """
2880 def __init__(self, repo, start=0, end=None):
2880 def __init__(self, repo, start=0, end=None):
2881 """
2881 """
2882 start: first revision included the set
2882 start: first revision included the set
2883 (default to 0)
2883 (default to 0)
2884 end: first revision excluded (last+1)
2884 end: first revision excluded (last+1)
2885 (default to len(repo)
2885 (default to len(repo)
2886
2886
2887 Spanset will be descending if `end` < `start`.
2887 Spanset will be descending if `end` < `start`.
2888 """
2888 """
2889 if end is None:
2889 if end is None:
2890 end = len(repo)
2890 end = len(repo)
2891 self._ascending = start <= end
2891 self._ascending = start <= end
2892 if not self._ascending:
2892 if not self._ascending:
2893 start, end = end + 1, start +1
2893 start, end = end + 1, start +1
2894 self._start = start
2894 self._start = start
2895 self._end = end
2895 self._end = end
2896 self._hiddenrevs = repo.changelog.filteredrevs
2896 self._hiddenrevs = repo.changelog.filteredrevs
2897
2897
2898 def sort(self, reverse=False):
2898 def sort(self, reverse=False):
2899 self._ascending = not reverse
2899 self._ascending = not reverse
2900
2900
2901 def reverse(self):
2901 def reverse(self):
2902 self._ascending = not self._ascending
2902 self._ascending = not self._ascending
2903
2903
2904 def _iterfilter(self, iterrange):
2904 def _iterfilter(self, iterrange):
2905 s = self._hiddenrevs
2905 s = self._hiddenrevs
2906 for r in iterrange:
2906 for r in iterrange:
2907 if r not in s:
2907 if r not in s:
2908 yield r
2908 yield r
2909
2909
2910 def __iter__(self):
2910 def __iter__(self):
2911 if self._ascending:
2911 if self._ascending:
2912 return self.fastasc()
2912 return self.fastasc()
2913 else:
2913 else:
2914 return self.fastdesc()
2914 return self.fastdesc()
2915
2915
2916 def fastasc(self):
2916 def fastasc(self):
2917 iterrange = xrange(self._start, self._end)
2917 iterrange = xrange(self._start, self._end)
2918 if self._hiddenrevs:
2918 if self._hiddenrevs:
2919 return self._iterfilter(iterrange)
2919 return self._iterfilter(iterrange)
2920 return iter(iterrange)
2920 return iter(iterrange)
2921
2921
2922 def fastdesc(self):
2922 def fastdesc(self):
2923 iterrange = xrange(self._end - 1, self._start - 1, -1)
2923 iterrange = xrange(self._end - 1, self._start - 1, -1)
2924 if self._hiddenrevs:
2924 if self._hiddenrevs:
2925 return self._iterfilter(iterrange)
2925 return self._iterfilter(iterrange)
2926 return iter(iterrange)
2926 return iter(iterrange)
2927
2927
2928 def __contains__(self, rev):
2928 def __contains__(self, rev):
2929 hidden = self._hiddenrevs
2929 hidden = self._hiddenrevs
2930 return ((self._start <= rev < self._end)
2930 return ((self._start <= rev < self._end)
2931 and not (hidden and rev in hidden))
2931 and not (hidden and rev in hidden))
2932
2932
2933 def __nonzero__(self):
2933 def __nonzero__(self):
2934 for r in self:
2934 for r in self:
2935 return True
2935 return True
2936 return False
2936 return False
2937
2937
2938 def __len__(self):
2938 def __len__(self):
2939 if not self._hiddenrevs:
2939 if not self._hiddenrevs:
2940 return abs(self._end - self._start)
2940 return abs(self._end - self._start)
2941 else:
2941 else:
2942 count = 0
2942 count = 0
2943 start = self._start
2943 start = self._start
2944 end = self._end
2944 end = self._end
2945 for rev in self._hiddenrevs:
2945 for rev in self._hiddenrevs:
2946 if (end < rev <= start) or (start <= rev < end):
2946 if (end < rev <= start) or (start <= rev < end):
2947 count += 1
2947 count += 1
2948 return abs(self._end - self._start) - count
2948 return abs(self._end - self._start) - count
2949
2949
2950 def __getitem__(self, x):
2950 def __getitem__(self, x):
2951 # Basic implementation to be changed in future patches.
2951 # Basic implementation to be changed in future patches.
2952 l = baseset([r for r in self])
2952 l = baseset([r for r in self])
2953 return l[x]
2953 return l[x]
2954
2954
2955 def set(self):
2955 def set(self):
2956 return self
2956 return self
2957
2957
2958 def isascending(self):
2958 def isascending(self):
2959 return self._start <= self._end
2959 return self._start <= self._end
2960
2960
2961 def isdescending(self):
2961 def isdescending(self):
2962 return self._start >= self._end
2962 return self._start >= self._end
2963
2963
2964 def first(self):
2964 def first(self):
2965 if self._ascending:
2965 if self._ascending:
2966 it = self.fastasc
2966 it = self.fastasc
2967 else:
2967 else:
2968 it = self.fastdesc
2968 it = self.fastdesc
2969 for x in it():
2969 for x in it():
2970 return x
2970 return x
2971 return None
2971 return None
2972
2972
2973 def last(self):
2973 def last(self):
2974 if self._ascending:
2974 if self._ascending:
2975 it = self.fastdesc
2975 it = self.fastdesc
2976 else:
2976 else:
2977 it = self.fastasc
2977 it = self.fastasc
2978 for x in it():
2978 for x in it():
2979 return x
2979 return x
2980 return None
2980 return None
2981
2981
2982 class fullreposet(_spanset):
2982 class fullreposet(_spanset):
2983 """a set containing all revisions in the repo
2983 """a set containing all revisions in the repo
2984
2984
2985 This class exists to host special optimisation.
2985 This class exists to host special optimisation.
2986 """
2986 """
2987
2987
2988 def __init__(self, repo):
2988 def __init__(self, repo):
2989 super(fullreposet, self).__init__(repo)
2989 super(fullreposet, self).__init__(repo)
2990
2990
2991 def __and__(self, other):
2991 def __and__(self, other):
2992 """fullrepo & other -> other
2992 """fullrepo & other -> other
2993
2993
2994 As self contains the whole repo, all of the other set should also be in
2994 As self contains the whole repo, all of the other set should also be in
2995 self. Therefor `self & other = other`.
2995 self. Therefor `self & other = other`.
2996
2996
2997 This boldly assumes the other contains valid revs only.
2997 This boldly assumes the other contains valid revs only.
2998 """
2998 """
2999 # other not a smartset, make is so
2999 # other not a smartset, make is so
3000 if not util.safehasattr(other, 'set'):
3000 if not util.safehasattr(other, 'set'):
3001 # filter out hidden revision
3001 # filter out hidden revision
3002 # (this boldly assumes all smartset are pure)
3002 # (this boldly assumes all smartset are pure)
3003 #
3003 #
3004 # `other` was used with "&", let's assume this is a set like
3004 # `other` was used with "&", let's assume this is a set like
3005 # object.
3005 # object.
3006 other = baseset(other - self._hiddenrevs)
3006 other = baseset(other - self._hiddenrevs)
3007 elif not util.safehasattr(other, 'ascending'):
3007 elif not util.safehasattr(other, 'ascending'):
3008 # "other" is generatorset not a real smart set
3008 # "other" is generatorset not a real smart set
3009 # we fallback to the old way (sad kitten)
3009 # we fallback to the old way (sad kitten)
3010 return super(fullreposet, self).__and__(other)
3010 return super(fullreposet, self).__and__(other)
3011
3011
3012 # preserve order:
3012 # preserve order:
3013 #
3013 #
3014 # this is probably useless and harmful in multiple cases but matches
3014 # this is probably useless and harmful in multiple cases but matches
3015 # the current behavior.
3015 # the current behavior.
3016 if self.isascending():
3016 if self.isascending():
3017 other.ascending()
3017 other.ascending()
3018 else:
3018 else:
3019 other.descending()
3019 other.descending()
3020 return other
3020 return other
3021
3021
3022 # tell hggettext to extract docstrings from these functions:
3022 # tell hggettext to extract docstrings from these functions:
3023 i18nfunctions = symbols.values()
3023 i18nfunctions = symbols.values()
General Comments 0
You need to be logged in to leave comments. Login now