##// END OF EJS Templates
revset: added lazyset implementation to checkstatus...
Lucas Moscovicz -
r20457:ed7b6748 default
parent child Browse files
Show More
@@ -1,2134 +1,2134 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 match as matchmod
11 import match as matchmod
12 from i18n import _
12 from i18n import _
13 import encoding
13 import encoding
14 import obsolete as obsmod
14 import obsolete as obsmod
15 import pathutil
15 import pathutil
16 import repoview
16 import repoview
17
17
18 def _revancestors(repo, revs, followfirst):
18 def _revancestors(repo, revs, followfirst):
19 """Like revlog.ancestors(), but supports followfirst."""
19 """Like revlog.ancestors(), but supports followfirst."""
20 cut = followfirst and 1 or None
20 cut = followfirst and 1 or None
21 cl = repo.changelog
21 cl = repo.changelog
22 visit = util.deque(revs)
22 visit = util.deque(revs)
23 seen = set([node.nullrev])
23 seen = set([node.nullrev])
24 while visit:
24 while visit:
25 for parent in cl.parentrevs(visit.popleft())[:cut]:
25 for parent in cl.parentrevs(visit.popleft())[:cut]:
26 if parent not in seen:
26 if parent not in seen:
27 visit.append(parent)
27 visit.append(parent)
28 seen.add(parent)
28 seen.add(parent)
29 yield parent
29 yield parent
30
30
31 def _revdescendants(repo, revs, followfirst):
31 def _revdescendants(repo, revs, followfirst):
32 """Like revlog.descendants() but supports followfirst."""
32 """Like revlog.descendants() but supports followfirst."""
33 cut = followfirst and 1 or None
33 cut = followfirst and 1 or None
34 cl = repo.changelog
34 cl = repo.changelog
35 first = min(revs)
35 first = min(revs)
36 nullrev = node.nullrev
36 nullrev = node.nullrev
37 if first == nullrev:
37 if first == nullrev:
38 # Are there nodes with a null first parent and a non-null
38 # Are there nodes with a null first parent and a non-null
39 # second one? Maybe. Do we care? Probably not.
39 # second one? Maybe. Do we care? Probably not.
40 for i in cl:
40 for i in cl:
41 yield i
41 yield i
42 return
42 return
43
43
44 seen = set(revs)
44 seen = set(revs)
45 for i in cl.revs(first + 1):
45 for i in cl.revs(first + 1):
46 for x in cl.parentrevs(i)[:cut]:
46 for x in cl.parentrevs(i)[:cut]:
47 if x != nullrev and x in seen:
47 if x != nullrev and x in seen:
48 seen.add(i)
48 seen.add(i)
49 yield i
49 yield i
50 break
50 break
51
51
52 def _revsbetween(repo, roots, heads):
52 def _revsbetween(repo, roots, heads):
53 """Return all paths between roots and heads, inclusive of both endpoint
53 """Return all paths between roots and heads, inclusive of both endpoint
54 sets."""
54 sets."""
55 if not roots:
55 if not roots:
56 return baseset([])
56 return baseset([])
57 parentrevs = repo.changelog.parentrevs
57 parentrevs = repo.changelog.parentrevs
58 visit = baseset(heads)
58 visit = baseset(heads)
59 reachable = set()
59 reachable = set()
60 seen = {}
60 seen = {}
61 minroot = min(roots)
61 minroot = min(roots)
62 roots = set(roots)
62 roots = set(roots)
63 # open-code the post-order traversal due to the tiny size of
63 # open-code the post-order traversal due to the tiny size of
64 # sys.getrecursionlimit()
64 # sys.getrecursionlimit()
65 while visit:
65 while visit:
66 rev = visit.pop()
66 rev = visit.pop()
67 if rev in roots:
67 if rev in roots:
68 reachable.add(rev)
68 reachable.add(rev)
69 parents = parentrevs(rev)
69 parents = parentrevs(rev)
70 seen[rev] = parents
70 seen[rev] = parents
71 for parent in parents:
71 for parent in parents:
72 if parent >= minroot and parent not in seen:
72 if parent >= minroot and parent not in seen:
73 visit.append(parent)
73 visit.append(parent)
74 if not reachable:
74 if not reachable:
75 return baseset([])
75 return baseset([])
76 for rev in sorted(seen):
76 for rev in sorted(seen):
77 for parent in seen[rev]:
77 for parent in seen[rev]:
78 if parent in reachable:
78 if parent in reachable:
79 reachable.add(rev)
79 reachable.add(rev)
80 return baseset(sorted(reachable))
80 return baseset(sorted(reachable))
81
81
82 elements = {
82 elements = {
83 "(": (20, ("group", 1, ")"), ("func", 1, ")")),
83 "(": (20, ("group", 1, ")"), ("func", 1, ")")),
84 "~": (18, None, ("ancestor", 18)),
84 "~": (18, None, ("ancestor", 18)),
85 "^": (18, None, ("parent", 18), ("parentpost", 18)),
85 "^": (18, None, ("parent", 18), ("parentpost", 18)),
86 "-": (5, ("negate", 19), ("minus", 5)),
86 "-": (5, ("negate", 19), ("minus", 5)),
87 "::": (17, ("dagrangepre", 17), ("dagrange", 17),
87 "::": (17, ("dagrangepre", 17), ("dagrange", 17),
88 ("dagrangepost", 17)),
88 ("dagrangepost", 17)),
89 "..": (17, ("dagrangepre", 17), ("dagrange", 17),
89 "..": (17, ("dagrangepre", 17), ("dagrange", 17),
90 ("dagrangepost", 17)),
90 ("dagrangepost", 17)),
91 ":": (15, ("rangepre", 15), ("range", 15), ("rangepost", 15)),
91 ":": (15, ("rangepre", 15), ("range", 15), ("rangepost", 15)),
92 "not": (10, ("not", 10)),
92 "not": (10, ("not", 10)),
93 "!": (10, ("not", 10)),
93 "!": (10, ("not", 10)),
94 "and": (5, None, ("and", 5)),
94 "and": (5, None, ("and", 5)),
95 "&": (5, None, ("and", 5)),
95 "&": (5, None, ("and", 5)),
96 "or": (4, None, ("or", 4)),
96 "or": (4, None, ("or", 4)),
97 "|": (4, None, ("or", 4)),
97 "|": (4, None, ("or", 4)),
98 "+": (4, None, ("or", 4)),
98 "+": (4, None, ("or", 4)),
99 ",": (2, None, ("list", 2)),
99 ",": (2, None, ("list", 2)),
100 ")": (0, None, None),
100 ")": (0, None, None),
101 "symbol": (0, ("symbol",), None),
101 "symbol": (0, ("symbol",), None),
102 "string": (0, ("string",), None),
102 "string": (0, ("string",), None),
103 "end": (0, None, None),
103 "end": (0, None, None),
104 }
104 }
105
105
106 keywords = set(['and', 'or', 'not'])
106 keywords = set(['and', 'or', 'not'])
107
107
108 def tokenize(program):
108 def tokenize(program):
109 '''
109 '''
110 Parse a revset statement into a stream of tokens
110 Parse a revset statement into a stream of tokens
111
111
112 Check that @ is a valid unquoted token character (issue3686):
112 Check that @ is a valid unquoted token character (issue3686):
113 >>> list(tokenize("@::"))
113 >>> list(tokenize("@::"))
114 [('symbol', '@', 0), ('::', None, 1), ('end', None, 3)]
114 [('symbol', '@', 0), ('::', None, 1), ('end', None, 3)]
115
115
116 '''
116 '''
117
117
118 pos, l = 0, len(program)
118 pos, l = 0, len(program)
119 while pos < l:
119 while pos < l:
120 c = program[pos]
120 c = program[pos]
121 if c.isspace(): # skip inter-token whitespace
121 if c.isspace(): # skip inter-token whitespace
122 pass
122 pass
123 elif c == ':' and program[pos:pos + 2] == '::': # look ahead carefully
123 elif c == ':' and program[pos:pos + 2] == '::': # look ahead carefully
124 yield ('::', None, pos)
124 yield ('::', None, pos)
125 pos += 1 # skip ahead
125 pos += 1 # skip ahead
126 elif c == '.' and program[pos:pos + 2] == '..': # look ahead carefully
126 elif c == '.' and program[pos:pos + 2] == '..': # look ahead carefully
127 yield ('..', None, pos)
127 yield ('..', None, pos)
128 pos += 1 # skip ahead
128 pos += 1 # skip ahead
129 elif c in "():,-|&+!~^": # handle simple operators
129 elif c in "():,-|&+!~^": # handle simple operators
130 yield (c, None, pos)
130 yield (c, None, pos)
131 elif (c in '"\'' or c == 'r' and
131 elif (c in '"\'' or c == 'r' and
132 program[pos:pos + 2] in ("r'", 'r"')): # handle quoted strings
132 program[pos:pos + 2] in ("r'", 'r"')): # handle quoted strings
133 if c == 'r':
133 if c == 'r':
134 pos += 1
134 pos += 1
135 c = program[pos]
135 c = program[pos]
136 decode = lambda x: x
136 decode = lambda x: x
137 else:
137 else:
138 decode = lambda x: x.decode('string-escape')
138 decode = lambda x: x.decode('string-escape')
139 pos += 1
139 pos += 1
140 s = pos
140 s = pos
141 while pos < l: # find closing quote
141 while pos < l: # find closing quote
142 d = program[pos]
142 d = program[pos]
143 if d == '\\': # skip over escaped characters
143 if d == '\\': # skip over escaped characters
144 pos += 2
144 pos += 2
145 continue
145 continue
146 if d == c:
146 if d == c:
147 yield ('string', decode(program[s:pos]), s)
147 yield ('string', decode(program[s:pos]), s)
148 break
148 break
149 pos += 1
149 pos += 1
150 else:
150 else:
151 raise error.ParseError(_("unterminated string"), s)
151 raise error.ParseError(_("unterminated string"), s)
152 # gather up a symbol/keyword
152 # gather up a symbol/keyword
153 elif c.isalnum() or c in '._@' or ord(c) > 127:
153 elif c.isalnum() or c in '._@' or ord(c) > 127:
154 s = pos
154 s = pos
155 pos += 1
155 pos += 1
156 while pos < l: # find end of symbol
156 while pos < l: # find end of symbol
157 d = program[pos]
157 d = program[pos]
158 if not (d.isalnum() or d in "._/@" or ord(d) > 127):
158 if not (d.isalnum() or d in "._/@" or ord(d) > 127):
159 break
159 break
160 if d == '.' and program[pos - 1] == '.': # special case for ..
160 if d == '.' and program[pos - 1] == '.': # special case for ..
161 pos -= 1
161 pos -= 1
162 break
162 break
163 pos += 1
163 pos += 1
164 sym = program[s:pos]
164 sym = program[s:pos]
165 if sym in keywords: # operator keywords
165 if sym in keywords: # operator keywords
166 yield (sym, None, s)
166 yield (sym, None, s)
167 else:
167 else:
168 yield ('symbol', sym, s)
168 yield ('symbol', sym, s)
169 pos -= 1
169 pos -= 1
170 else:
170 else:
171 raise error.ParseError(_("syntax error"), pos)
171 raise error.ParseError(_("syntax error"), pos)
172 pos += 1
172 pos += 1
173 yield ('end', None, pos)
173 yield ('end', None, pos)
174
174
175 # helpers
175 # helpers
176
176
177 def getstring(x, err):
177 def getstring(x, err):
178 if x and (x[0] == 'string' or x[0] == 'symbol'):
178 if x and (x[0] == 'string' or x[0] == 'symbol'):
179 return x[1]
179 return x[1]
180 raise error.ParseError(err)
180 raise error.ParseError(err)
181
181
182 def getlist(x):
182 def getlist(x):
183 if not x:
183 if not x:
184 return []
184 return []
185 if x[0] == 'list':
185 if x[0] == 'list':
186 return getlist(x[1]) + [x[2]]
186 return getlist(x[1]) + [x[2]]
187 return [x]
187 return [x]
188
188
189 def getargs(x, min, max, err):
189 def getargs(x, min, max, err):
190 l = getlist(x)
190 l = getlist(x)
191 if len(l) < min or (max >= 0 and len(l) > max):
191 if len(l) < min or (max >= 0 and len(l) > max):
192 raise error.ParseError(err)
192 raise error.ParseError(err)
193 return l
193 return l
194
194
195 def getset(repo, subset, x):
195 def getset(repo, subset, x):
196 if not x:
196 if not x:
197 raise error.ParseError(_("missing argument"))
197 raise error.ParseError(_("missing argument"))
198 return methods[x[0]](repo, subset, *x[1:])
198 return methods[x[0]](repo, subset, *x[1:])
199
199
200 def _getrevsource(repo, r):
200 def _getrevsource(repo, r):
201 extra = repo[r].extra()
201 extra = repo[r].extra()
202 for label in ('source', 'transplant_source', 'rebase_source'):
202 for label in ('source', 'transplant_source', 'rebase_source'):
203 if label in extra:
203 if label in extra:
204 try:
204 try:
205 return repo[extra[label]].rev()
205 return repo[extra[label]].rev()
206 except error.RepoLookupError:
206 except error.RepoLookupError:
207 pass
207 pass
208 return None
208 return None
209
209
210 # operator methods
210 # operator methods
211
211
212 def stringset(repo, subset, x):
212 def stringset(repo, subset, x):
213 x = repo[x].rev()
213 x = repo[x].rev()
214 if x == -1 and len(subset) == len(repo):
214 if x == -1 and len(subset) == len(repo):
215 return baseset([-1])
215 return baseset([-1])
216 if len(subset) == len(repo) or x in subset:
216 if len(subset) == len(repo) or x in subset:
217 return baseset([x])
217 return baseset([x])
218 return baseset([])
218 return baseset([])
219
219
220 def symbolset(repo, subset, x):
220 def symbolset(repo, subset, x):
221 if x in symbols:
221 if x in symbols:
222 raise error.ParseError(_("can't use %s here") % x)
222 raise error.ParseError(_("can't use %s here") % x)
223 return stringset(repo, subset, x)
223 return stringset(repo, subset, x)
224
224
225 def rangeset(repo, subset, x, y):
225 def rangeset(repo, subset, x, y):
226 cl = baseset(repo.changelog)
226 cl = baseset(repo.changelog)
227 m = getset(repo, cl, x)
227 m = getset(repo, cl, x)
228 n = getset(repo, cl, y)
228 n = getset(repo, cl, y)
229
229
230 if not m or not n:
230 if not m or not n:
231 return baseset([])
231 return baseset([])
232 m, n = m[0], n[-1]
232 m, n = m[0], n[-1]
233
233
234 if m < n:
234 if m < n:
235 r = range(m, n + 1)
235 r = range(m, n + 1)
236 else:
236 else:
237 r = range(m, n - 1, -1)
237 r = range(m, n - 1, -1)
238 s = subset.set()
238 s = subset.set()
239 return baseset([x for x in r if x in s])
239 return baseset([x for x in r if x in s])
240
240
241 def dagrange(repo, subset, x, y):
241 def dagrange(repo, subset, x, y):
242 r = baseset(repo)
242 r = baseset(repo)
243 xs = _revsbetween(repo, getset(repo, r, x), getset(repo, r, y))
243 xs = _revsbetween(repo, getset(repo, r, x), getset(repo, r, y))
244 s = subset.set()
244 s = subset.set()
245 return baseset([r for r in xs if r in s])
245 return baseset([r for r in xs if r in s])
246
246
247 def andset(repo, subset, x, y):
247 def andset(repo, subset, x, y):
248 return getset(repo, getset(repo, subset, x), y)
248 return getset(repo, getset(repo, subset, x), y)
249
249
250 def orset(repo, subset, x, y):
250 def orset(repo, subset, x, y):
251 xl = getset(repo, subset, x)
251 xl = getset(repo, subset, x)
252 yl = getset(repo, subset - xl, y)
252 yl = getset(repo, subset - xl, y)
253 return xl + yl
253 return xl + yl
254
254
255 def notset(repo, subset, x):
255 def notset(repo, subset, x):
256 return subset - getset(repo, subset, x)
256 return subset - getset(repo, subset, x)
257
257
258 def listset(repo, subset, a, b):
258 def listset(repo, subset, a, b):
259 raise error.ParseError(_("can't use a list in this context"))
259 raise error.ParseError(_("can't use a list in this context"))
260
260
261 def func(repo, subset, a, b):
261 def func(repo, subset, a, b):
262 if a[0] == 'symbol' and a[1] in symbols:
262 if a[0] == 'symbol' and a[1] in symbols:
263 return symbols[a[1]](repo, subset, b)
263 return symbols[a[1]](repo, subset, b)
264 raise error.ParseError(_("not a function: %s") % a[1])
264 raise error.ParseError(_("not a function: %s") % a[1])
265
265
266 # functions
266 # functions
267
267
268 def adds(repo, subset, x):
268 def adds(repo, subset, x):
269 """``adds(pattern)``
269 """``adds(pattern)``
270 Changesets that add a file matching pattern.
270 Changesets that add a file matching pattern.
271
271
272 The pattern without explicit kind like ``glob:`` is expected to be
272 The pattern without explicit kind like ``glob:`` is expected to be
273 relative to the current directory and match against a file or a
273 relative to the current directory and match against a file or a
274 directory.
274 directory.
275 """
275 """
276 # i18n: "adds" is a keyword
276 # i18n: "adds" is a keyword
277 pat = getstring(x, _("adds requires a pattern"))
277 pat = getstring(x, _("adds requires a pattern"))
278 return checkstatus(repo, subset, pat, 1)
278 return checkstatus(repo, subset, pat, 1)
279
279
280 def ancestor(repo, subset, x):
280 def ancestor(repo, subset, x):
281 """``ancestor(*changeset)``
281 """``ancestor(*changeset)``
282 Greatest common ancestor of the changesets.
282 Greatest common ancestor of the changesets.
283
283
284 Accepts 0 or more changesets.
284 Accepts 0 or more changesets.
285 Will return empty list when passed no args.
285 Will return empty list when passed no args.
286 Greatest common ancestor of a single changeset is that changeset.
286 Greatest common ancestor of a single changeset is that changeset.
287 """
287 """
288 # i18n: "ancestor" is a keyword
288 # i18n: "ancestor" is a keyword
289 l = getlist(x)
289 l = getlist(x)
290 rl = baseset(repo)
290 rl = baseset(repo)
291 anc = None
291 anc = None
292
292
293 # (getset(repo, rl, i) for i in l) generates a list of lists
293 # (getset(repo, rl, i) for i in l) generates a list of lists
294 rev = repo.changelog.rev
294 rev = repo.changelog.rev
295 ancestor = repo.changelog.ancestor
295 ancestor = repo.changelog.ancestor
296 node = repo.changelog.node
296 node = repo.changelog.node
297 for revs in (getset(repo, rl, i) for i in l):
297 for revs in (getset(repo, rl, i) for i in l):
298 for r in revs:
298 for r in revs:
299 if anc is None:
299 if anc is None:
300 anc = r
300 anc = r
301 else:
301 else:
302 anc = rev(ancestor(node(anc), node(r)))
302 anc = rev(ancestor(node(anc), node(r)))
303
303
304 if anc is not None and anc in subset:
304 if anc is not None and anc in subset:
305 return baseset([anc])
305 return baseset([anc])
306 return baseset([])
306 return baseset([])
307
307
308 def _ancestors(repo, subset, x, followfirst=False):
308 def _ancestors(repo, subset, x, followfirst=False):
309 args = getset(repo, baseset(repo), x)
309 args = getset(repo, baseset(repo), x)
310 if not args:
310 if not args:
311 return baseset([])
311 return baseset([])
312 s = set(_revancestors(repo, args, followfirst)) | set(args)
312 s = set(_revancestors(repo, args, followfirst)) | set(args)
313 return baseset([r for r in subset if r in s])
313 return baseset([r for r in subset if r in s])
314
314
315 def ancestors(repo, subset, x):
315 def ancestors(repo, subset, x):
316 """``ancestors(set)``
316 """``ancestors(set)``
317 Changesets that are ancestors of a changeset in set.
317 Changesets that are ancestors of a changeset in set.
318 """
318 """
319 return _ancestors(repo, subset, x)
319 return _ancestors(repo, subset, x)
320
320
321 def _firstancestors(repo, subset, x):
321 def _firstancestors(repo, subset, x):
322 # ``_firstancestors(set)``
322 # ``_firstancestors(set)``
323 # Like ``ancestors(set)`` but follows only the first parents.
323 # Like ``ancestors(set)`` but follows only the first parents.
324 return _ancestors(repo, subset, x, followfirst=True)
324 return _ancestors(repo, subset, x, followfirst=True)
325
325
326 def ancestorspec(repo, subset, x, n):
326 def ancestorspec(repo, subset, x, n):
327 """``set~n``
327 """``set~n``
328 Changesets that are the Nth ancestor (first parents only) of a changeset
328 Changesets that are the Nth ancestor (first parents only) of a changeset
329 in set.
329 in set.
330 """
330 """
331 try:
331 try:
332 n = int(n[1])
332 n = int(n[1])
333 except (TypeError, ValueError):
333 except (TypeError, ValueError):
334 raise error.ParseError(_("~ expects a number"))
334 raise error.ParseError(_("~ expects a number"))
335 ps = set()
335 ps = set()
336 cl = repo.changelog
336 cl = repo.changelog
337 for r in getset(repo, baseset(cl), x):
337 for r in getset(repo, baseset(cl), x):
338 for i in range(n):
338 for i in range(n):
339 r = cl.parentrevs(r)[0]
339 r = cl.parentrevs(r)[0]
340 ps.add(r)
340 ps.add(r)
341 return baseset([r for r in subset if r in ps])
341 return baseset([r for r in subset if r in ps])
342
342
343 def author(repo, subset, x):
343 def author(repo, subset, x):
344 """``author(string)``
344 """``author(string)``
345 Alias for ``user(string)``.
345 Alias for ``user(string)``.
346 """
346 """
347 # i18n: "author" is a keyword
347 # i18n: "author" is a keyword
348 n = encoding.lower(getstring(x, _("author requires a string")))
348 n = encoding.lower(getstring(x, _("author requires a string")))
349 kind, pattern, matcher = _substringmatcher(n)
349 kind, pattern, matcher = _substringmatcher(n)
350 return lazyset(subset, lambda x: matcher(encoding.lower(repo[x].user())))
350 return lazyset(subset, lambda x: matcher(encoding.lower(repo[x].user())))
351
351
352 def bisect(repo, subset, x):
352 def bisect(repo, subset, x):
353 """``bisect(string)``
353 """``bisect(string)``
354 Changesets marked in the specified bisect status:
354 Changesets marked in the specified bisect status:
355
355
356 - ``good``, ``bad``, ``skip``: csets explicitly marked as good/bad/skip
356 - ``good``, ``bad``, ``skip``: csets explicitly marked as good/bad/skip
357 - ``goods``, ``bads`` : csets topologically good/bad
357 - ``goods``, ``bads`` : csets topologically good/bad
358 - ``range`` : csets taking part in the bisection
358 - ``range`` : csets taking part in the bisection
359 - ``pruned`` : csets that are goods, bads or skipped
359 - ``pruned`` : csets that are goods, bads or skipped
360 - ``untested`` : csets whose fate is yet unknown
360 - ``untested`` : csets whose fate is yet unknown
361 - ``ignored`` : csets ignored due to DAG topology
361 - ``ignored`` : csets ignored due to DAG topology
362 - ``current`` : the cset currently being bisected
362 - ``current`` : the cset currently being bisected
363 """
363 """
364 # i18n: "bisect" is a keyword
364 # i18n: "bisect" is a keyword
365 status = getstring(x, _("bisect requires a string")).lower()
365 status = getstring(x, _("bisect requires a string")).lower()
366 state = set(hbisect.get(repo, status))
366 state = set(hbisect.get(repo, status))
367 return baseset([r for r in subset if r in state])
367 return baseset([r for r in subset if r in state])
368
368
369 # Backward-compatibility
369 # Backward-compatibility
370 # - no help entry so that we do not advertise it any more
370 # - no help entry so that we do not advertise it any more
371 def bisected(repo, subset, x):
371 def bisected(repo, subset, x):
372 return bisect(repo, subset, x)
372 return bisect(repo, subset, x)
373
373
374 def bookmark(repo, subset, x):
374 def bookmark(repo, subset, x):
375 """``bookmark([name])``
375 """``bookmark([name])``
376 The named bookmark or all bookmarks.
376 The named bookmark or all bookmarks.
377
377
378 If `name` starts with `re:`, the remainder of the name is treated as
378 If `name` starts with `re:`, the remainder of the name is treated as
379 a regular expression. To match a bookmark that actually starts with `re:`,
379 a regular expression. To match a bookmark that actually starts with `re:`,
380 use the prefix `literal:`.
380 use the prefix `literal:`.
381 """
381 """
382 # i18n: "bookmark" is a keyword
382 # i18n: "bookmark" is a keyword
383 args = getargs(x, 0, 1, _('bookmark takes one or no arguments'))
383 args = getargs(x, 0, 1, _('bookmark takes one or no arguments'))
384 if args:
384 if args:
385 bm = getstring(args[0],
385 bm = getstring(args[0],
386 # i18n: "bookmark" is a keyword
386 # i18n: "bookmark" is a keyword
387 _('the argument to bookmark must be a string'))
387 _('the argument to bookmark must be a string'))
388 kind, pattern, matcher = _stringmatcher(bm)
388 kind, pattern, matcher = _stringmatcher(bm)
389 if kind == 'literal':
389 if kind == 'literal':
390 bmrev = repo._bookmarks.get(bm, None)
390 bmrev = repo._bookmarks.get(bm, None)
391 if not bmrev:
391 if not bmrev:
392 raise util.Abort(_("bookmark '%s' does not exist") % bm)
392 raise util.Abort(_("bookmark '%s' does not exist") % bm)
393 bmrev = repo[bmrev].rev()
393 bmrev = repo[bmrev].rev()
394 return lazyset(subset, lambda r: r == bmrev)
394 return lazyset(subset, lambda r: r == bmrev)
395 else:
395 else:
396 matchrevs = set()
396 matchrevs = set()
397 for name, bmrev in repo._bookmarks.iteritems():
397 for name, bmrev in repo._bookmarks.iteritems():
398 if matcher(name):
398 if matcher(name):
399 matchrevs.add(bmrev)
399 matchrevs.add(bmrev)
400 if not matchrevs:
400 if not matchrevs:
401 raise util.Abort(_("no bookmarks exist that match '%s'")
401 raise util.Abort(_("no bookmarks exist that match '%s'")
402 % pattern)
402 % pattern)
403 bmrevs = set()
403 bmrevs = set()
404 for bmrev in matchrevs:
404 for bmrev in matchrevs:
405 bmrevs.add(repo[bmrev].rev())
405 bmrevs.add(repo[bmrev].rev())
406 return subset & bmrevs
406 return subset & bmrevs
407
407
408 bms = set([repo[r].rev()
408 bms = set([repo[r].rev()
409 for r in repo._bookmarks.values()])
409 for r in repo._bookmarks.values()])
410 return lazyset(subset, lambda r: r in bms)
410 return lazyset(subset, lambda r: r in bms)
411
411
412 def branch(repo, subset, x):
412 def branch(repo, subset, x):
413 """``branch(string or set)``
413 """``branch(string or set)``
414 All changesets belonging to the given branch or the branches of the given
414 All changesets belonging to the given branch or the branches of the given
415 changesets.
415 changesets.
416
416
417 If `string` starts with `re:`, the remainder of the name is treated as
417 If `string` starts with `re:`, the remainder of the name is treated as
418 a regular expression. To match a branch that actually starts with `re:`,
418 a regular expression. To match a branch that actually starts with `re:`,
419 use the prefix `literal:`.
419 use the prefix `literal:`.
420 """
420 """
421 try:
421 try:
422 b = getstring(x, '')
422 b = getstring(x, '')
423 except error.ParseError:
423 except error.ParseError:
424 # not a string, but another revspec, e.g. tip()
424 # not a string, but another revspec, e.g. tip()
425 pass
425 pass
426 else:
426 else:
427 kind, pattern, matcher = _stringmatcher(b)
427 kind, pattern, matcher = _stringmatcher(b)
428 if kind == 'literal':
428 if kind == 'literal':
429 # note: falls through to the revspec case if no branch with
429 # note: falls through to the revspec case if no branch with
430 # this name exists
430 # this name exists
431 if pattern in repo.branchmap():
431 if pattern in repo.branchmap():
432 return lazyset(subset, lambda r: matcher(repo[r].branch()))
432 return lazyset(subset, lambda r: matcher(repo[r].branch()))
433 else:
433 else:
434 return lazyset(subset, lambda r: matcher(repo[r].branch()))
434 return lazyset(subset, lambda r: matcher(repo[r].branch()))
435
435
436 s = getset(repo, baseset(repo), x)
436 s = getset(repo, baseset(repo), x)
437 b = set()
437 b = set()
438 for r in s:
438 for r in s:
439 b.add(repo[r].branch())
439 b.add(repo[r].branch())
440 s = s.set()
440 s = s.set()
441 return lazyset(subset, lambda r: r in s or repo[r].branch() in b)
441 return lazyset(subset, lambda r: r in s or repo[r].branch() in b)
442
442
443 def bumped(repo, subset, x):
443 def bumped(repo, subset, x):
444 """``bumped()``
444 """``bumped()``
445 Mutable changesets marked as successors of public changesets.
445 Mutable changesets marked as successors of public changesets.
446
446
447 Only non-public and non-obsolete changesets can be `bumped`.
447 Only non-public and non-obsolete changesets can be `bumped`.
448 """
448 """
449 # i18n: "bumped" is a keyword
449 # i18n: "bumped" is a keyword
450 getargs(x, 0, 0, _("bumped takes no arguments"))
450 getargs(x, 0, 0, _("bumped takes no arguments"))
451 bumped = obsmod.getrevs(repo, 'bumped')
451 bumped = obsmod.getrevs(repo, 'bumped')
452 return subset & bumped
452 return subset & bumped
453
453
454 def bundle(repo, subset, x):
454 def bundle(repo, subset, x):
455 """``bundle()``
455 """``bundle()``
456 Changesets in the bundle.
456 Changesets in the bundle.
457
457
458 Bundle must be specified by the -R option."""
458 Bundle must be specified by the -R option."""
459
459
460 try:
460 try:
461 bundlerevs = repo.changelog.bundlerevs
461 bundlerevs = repo.changelog.bundlerevs
462 except AttributeError:
462 except AttributeError:
463 raise util.Abort(_("no bundle provided - specify with -R"))
463 raise util.Abort(_("no bundle provided - specify with -R"))
464 return subset & bundlerevs
464 return subset & bundlerevs
465
465
466 def checkstatus(repo, subset, pat, field):
466 def checkstatus(repo, subset, pat, field):
467 m = None
468 s = []
469 hasset = matchmod.patkind(pat) == 'set'
467 hasset = matchmod.patkind(pat) == 'set'
470 fname = None
468
471 for r in subset:
469 def matches(x):
472 c = repo[r]
470 m = None
471 fname = None
472 c = repo[x]
473 if not m or hasset:
473 if not m or hasset:
474 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c)
474 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c)
475 if not m.anypats() and len(m.files()) == 1:
475 if not m.anypats() and len(m.files()) == 1:
476 fname = m.files()[0]
476 fname = m.files()[0]
477 if fname is not None:
477 if fname is not None:
478 if fname not in c.files():
478 if fname not in c.files():
479 continue
479 return False
480 else:
480 else:
481 for f in c.files():
481 for f in c.files():
482 if m(f):
482 if m(f):
483 break
483 break
484 else:
484 else:
485 continue
485 return False
486 files = repo.status(c.p1().node(), c.node())[field]
486 files = repo.status(c.p1().node(), c.node())[field]
487 if fname is not None:
487 if fname is not None:
488 if fname in files:
488 if fname in files:
489 s.append(r)
489 return True
490 else:
490 else:
491 for f in files:
491 for f in files:
492 if m(f):
492 if m(f):
493 s.append(r)
493 return True
494 break
494
495 return baseset(s)
495 return lazyset(subset, matches)
496
496
497 def _children(repo, narrow, parentset):
497 def _children(repo, narrow, parentset):
498 cs = set()
498 cs = set()
499 if not parentset:
499 if not parentset:
500 return baseset(cs)
500 return baseset(cs)
501 pr = repo.changelog.parentrevs
501 pr = repo.changelog.parentrevs
502 minrev = min(parentset)
502 minrev = min(parentset)
503 for r in narrow:
503 for r in narrow:
504 if r <= minrev:
504 if r <= minrev:
505 continue
505 continue
506 for p in pr(r):
506 for p in pr(r):
507 if p in parentset:
507 if p in parentset:
508 cs.add(r)
508 cs.add(r)
509 return baseset(cs)
509 return baseset(cs)
510
510
511 def children(repo, subset, x):
511 def children(repo, subset, x):
512 """``children(set)``
512 """``children(set)``
513 Child changesets of changesets in set.
513 Child changesets of changesets in set.
514 """
514 """
515 s = getset(repo, baseset(repo), x).set()
515 s = getset(repo, baseset(repo), x).set()
516 cs = _children(repo, subset, s)
516 cs = _children(repo, subset, s)
517 return subset & cs
517 return subset & cs
518
518
519 def closed(repo, subset, x):
519 def closed(repo, subset, x):
520 """``closed()``
520 """``closed()``
521 Changeset is closed.
521 Changeset is closed.
522 """
522 """
523 # i18n: "closed" is a keyword
523 # i18n: "closed" is a keyword
524 getargs(x, 0, 0, _("closed takes no arguments"))
524 getargs(x, 0, 0, _("closed takes no arguments"))
525 return baseset([r for r in subset if repo[r].closesbranch()])
525 return baseset([r for r in subset if repo[r].closesbranch()])
526
526
527 def contains(repo, subset, x):
527 def contains(repo, subset, x):
528 """``contains(pattern)``
528 """``contains(pattern)``
529 Revision contains a file matching pattern. See :hg:`help patterns`
529 Revision contains a file matching pattern. See :hg:`help patterns`
530 for information about file patterns.
530 for information about file patterns.
531
531
532 The pattern without explicit kind like ``glob:`` is expected to be
532 The pattern without explicit kind like ``glob:`` is expected to be
533 relative to the current directory and match against a file exactly
533 relative to the current directory and match against a file exactly
534 for efficiency.
534 for efficiency.
535 """
535 """
536 # i18n: "contains" is a keyword
536 # i18n: "contains" is a keyword
537 pat = getstring(x, _("contains requires a pattern"))
537 pat = getstring(x, _("contains requires a pattern"))
538 s = []
538 s = []
539 if not matchmod.patkind(pat):
539 if not matchmod.patkind(pat):
540 pat = pathutil.canonpath(repo.root, repo.getcwd(), pat)
540 pat = pathutil.canonpath(repo.root, repo.getcwd(), pat)
541 for r in subset:
541 for r in subset:
542 if pat in repo[r]:
542 if pat in repo[r]:
543 s.append(r)
543 s.append(r)
544 else:
544 else:
545 m = None
545 m = None
546 for r in subset:
546 for r in subset:
547 c = repo[r]
547 c = repo[r]
548 if not m or matchmod.patkind(pat) == 'set':
548 if not m or matchmod.patkind(pat) == 'set':
549 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c)
549 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c)
550 for f in c.manifest():
550 for f in c.manifest():
551 if m(f):
551 if m(f):
552 s.append(r)
552 s.append(r)
553 break
553 break
554 return baseset(s)
554 return baseset(s)
555
555
556 def converted(repo, subset, x):
556 def converted(repo, subset, x):
557 """``converted([id])``
557 """``converted([id])``
558 Changesets converted from the given identifier in the old repository if
558 Changesets converted from the given identifier in the old repository if
559 present, or all converted changesets if no identifier is specified.
559 present, or all converted changesets if no identifier is specified.
560 """
560 """
561
561
562 # There is exactly no chance of resolving the revision, so do a simple
562 # There is exactly no chance of resolving the revision, so do a simple
563 # string compare and hope for the best
563 # string compare and hope for the best
564
564
565 rev = None
565 rev = None
566 # i18n: "converted" is a keyword
566 # i18n: "converted" is a keyword
567 l = getargs(x, 0, 1, _('converted takes one or no arguments'))
567 l = getargs(x, 0, 1, _('converted takes one or no arguments'))
568 if l:
568 if l:
569 # i18n: "converted" is a keyword
569 # i18n: "converted" is a keyword
570 rev = getstring(l[0], _('converted requires a revision'))
570 rev = getstring(l[0], _('converted requires a revision'))
571
571
572 def _matchvalue(r):
572 def _matchvalue(r):
573 source = repo[r].extra().get('convert_revision', None)
573 source = repo[r].extra().get('convert_revision', None)
574 return source is not None and (rev is None or source.startswith(rev))
574 return source is not None and (rev is None or source.startswith(rev))
575
575
576 return baseset([r for r in subset if _matchvalue(r)])
576 return baseset([r for r in subset if _matchvalue(r)])
577
577
578 def date(repo, subset, x):
578 def date(repo, subset, x):
579 """``date(interval)``
579 """``date(interval)``
580 Changesets within the interval, see :hg:`help dates`.
580 Changesets within the interval, see :hg:`help dates`.
581 """
581 """
582 # i18n: "date" is a keyword
582 # i18n: "date" is a keyword
583 ds = getstring(x, _("date requires a string"))
583 ds = getstring(x, _("date requires a string"))
584 dm = util.matchdate(ds)
584 dm = util.matchdate(ds)
585 return lazyset(subset, lambda x: dm(repo[x].date()[0]))
585 return lazyset(subset, lambda x: dm(repo[x].date()[0]))
586
586
587 def desc(repo, subset, x):
587 def desc(repo, subset, x):
588 """``desc(string)``
588 """``desc(string)``
589 Search commit message for string. The match is case-insensitive.
589 Search commit message for string. The match is case-insensitive.
590 """
590 """
591 # i18n: "desc" is a keyword
591 # i18n: "desc" is a keyword
592 ds = encoding.lower(getstring(x, _("desc requires a string")))
592 ds = encoding.lower(getstring(x, _("desc requires a string")))
593
593
594 def matches(x):
594 def matches(x):
595 c = repo[x]
595 c = repo[x]
596 return ds in encoding.lower(c.description())
596 return ds in encoding.lower(c.description())
597
597
598 return lazyset(subset, matches)
598 return lazyset(subset, matches)
599
599
600 def _descendants(repo, subset, x, followfirst=False):
600 def _descendants(repo, subset, x, followfirst=False):
601 args = getset(repo, baseset(repo), x)
601 args = getset(repo, baseset(repo), x)
602 if not args:
602 if not args:
603 return baseset([])
603 return baseset([])
604 s = set(_revdescendants(repo, args, followfirst)) | set(args)
604 s = set(_revdescendants(repo, args, followfirst)) | set(args)
605 return baseset([r for r in subset if r in s])
605 return baseset([r for r in subset if r in s])
606
606
607 def descendants(repo, subset, x):
607 def descendants(repo, subset, x):
608 """``descendants(set)``
608 """``descendants(set)``
609 Changesets which are descendants of changesets in set.
609 Changesets which are descendants of changesets in set.
610 """
610 """
611 return _descendants(repo, subset, x)
611 return _descendants(repo, subset, x)
612
612
613 def _firstdescendants(repo, subset, x):
613 def _firstdescendants(repo, subset, x):
614 # ``_firstdescendants(set)``
614 # ``_firstdescendants(set)``
615 # Like ``descendants(set)`` but follows only the first parents.
615 # Like ``descendants(set)`` but follows only the first parents.
616 return _descendants(repo, subset, x, followfirst=True)
616 return _descendants(repo, subset, x, followfirst=True)
617
617
618 def destination(repo, subset, x):
618 def destination(repo, subset, x):
619 """``destination([set])``
619 """``destination([set])``
620 Changesets that were created by a graft, transplant or rebase operation,
620 Changesets that were created by a graft, transplant or rebase operation,
621 with the given revisions specified as the source. Omitting the optional set
621 with the given revisions specified as the source. Omitting the optional set
622 is the same as passing all().
622 is the same as passing all().
623 """
623 """
624 if x is not None:
624 if x is not None:
625 args = getset(repo, baseset(repo), x).set()
625 args = getset(repo, baseset(repo), x).set()
626 else:
626 else:
627 args = getall(repo, baseset(repo), x).set()
627 args = getall(repo, baseset(repo), x).set()
628
628
629 dests = set()
629 dests = set()
630
630
631 # subset contains all of the possible destinations that can be returned, so
631 # subset contains all of the possible destinations that can be returned, so
632 # iterate over them and see if their source(s) were provided in the args.
632 # iterate over them and see if their source(s) were provided in the args.
633 # Even if the immediate src of r is not in the args, src's source (or
633 # Even if the immediate src of r is not in the args, src's source (or
634 # further back) may be. Scanning back further than the immediate src allows
634 # further back) may be. Scanning back further than the immediate src allows
635 # transitive transplants and rebases to yield the same results as transitive
635 # transitive transplants and rebases to yield the same results as transitive
636 # grafts.
636 # grafts.
637 for r in subset:
637 for r in subset:
638 src = _getrevsource(repo, r)
638 src = _getrevsource(repo, r)
639 lineage = None
639 lineage = None
640
640
641 while src is not None:
641 while src is not None:
642 if lineage is None:
642 if lineage is None:
643 lineage = list()
643 lineage = list()
644
644
645 lineage.append(r)
645 lineage.append(r)
646
646
647 # The visited lineage is a match if the current source is in the arg
647 # The visited lineage is a match if the current source is in the arg
648 # set. Since every candidate dest is visited by way of iterating
648 # set. Since every candidate dest is visited by way of iterating
649 # subset, any dests further back in the lineage will be tested by a
649 # subset, any dests further back in the lineage will be tested by a
650 # different iteration over subset. Likewise, if the src was already
650 # different iteration over subset. Likewise, if the src was already
651 # selected, the current lineage can be selected without going back
651 # selected, the current lineage can be selected without going back
652 # further.
652 # further.
653 if src in args or src in dests:
653 if src in args or src in dests:
654 dests.update(lineage)
654 dests.update(lineage)
655 break
655 break
656
656
657 r = src
657 r = src
658 src = _getrevsource(repo, r)
658 src = _getrevsource(repo, r)
659
659
660 return baseset([r for r in subset if r in dests])
660 return baseset([r for r in subset if r in dests])
661
661
662 def divergent(repo, subset, x):
662 def divergent(repo, subset, x):
663 """``divergent()``
663 """``divergent()``
664 Final successors of changesets with an alternative set of final successors.
664 Final successors of changesets with an alternative set of final successors.
665 """
665 """
666 # i18n: "divergent" is a keyword
666 # i18n: "divergent" is a keyword
667 getargs(x, 0, 0, _("divergent takes no arguments"))
667 getargs(x, 0, 0, _("divergent takes no arguments"))
668 divergent = obsmod.getrevs(repo, 'divergent')
668 divergent = obsmod.getrevs(repo, 'divergent')
669 return baseset([r for r in subset if r in divergent])
669 return baseset([r for r in subset if r in divergent])
670
670
671 def draft(repo, subset, x):
671 def draft(repo, subset, x):
672 """``draft()``
672 """``draft()``
673 Changeset in draft phase."""
673 Changeset in draft phase."""
674 # i18n: "draft" is a keyword
674 # i18n: "draft" is a keyword
675 getargs(x, 0, 0, _("draft takes no arguments"))
675 getargs(x, 0, 0, _("draft takes no arguments"))
676 pc = repo._phasecache
676 pc = repo._phasecache
677 return lazyset(subset, lambda r: pc.phase(repo, r) == phases.draft)
677 return lazyset(subset, lambda r: pc.phase(repo, r) == phases.draft)
678
678
679 def extinct(repo, subset, x):
679 def extinct(repo, subset, x):
680 """``extinct()``
680 """``extinct()``
681 Obsolete changesets with obsolete descendants only.
681 Obsolete changesets with obsolete descendants only.
682 """
682 """
683 # i18n: "extinct" is a keyword
683 # i18n: "extinct" is a keyword
684 getargs(x, 0, 0, _("extinct takes no arguments"))
684 getargs(x, 0, 0, _("extinct takes no arguments"))
685 extincts = obsmod.getrevs(repo, 'extinct')
685 extincts = obsmod.getrevs(repo, 'extinct')
686 return subset & extincts
686 return subset & extincts
687
687
688 def extra(repo, subset, x):
688 def extra(repo, subset, x):
689 """``extra(label, [value])``
689 """``extra(label, [value])``
690 Changesets with the given label in the extra metadata, with the given
690 Changesets with the given label in the extra metadata, with the given
691 optional value.
691 optional value.
692
692
693 If `value` starts with `re:`, the remainder of the value is treated as
693 If `value` starts with `re:`, the remainder of the value is treated as
694 a regular expression. To match a value that actually starts with `re:`,
694 a regular expression. To match a value that actually starts with `re:`,
695 use the prefix `literal:`.
695 use the prefix `literal:`.
696 """
696 """
697
697
698 # i18n: "extra" is a keyword
698 # i18n: "extra" is a keyword
699 l = getargs(x, 1, 2, _('extra takes at least 1 and at most 2 arguments'))
699 l = getargs(x, 1, 2, _('extra takes at least 1 and at most 2 arguments'))
700 # i18n: "extra" is a keyword
700 # i18n: "extra" is a keyword
701 label = getstring(l[0], _('first argument to extra must be a string'))
701 label = getstring(l[0], _('first argument to extra must be a string'))
702 value = None
702 value = None
703
703
704 if len(l) > 1:
704 if len(l) > 1:
705 # i18n: "extra" is a keyword
705 # i18n: "extra" is a keyword
706 value = getstring(l[1], _('second argument to extra must be a string'))
706 value = getstring(l[1], _('second argument to extra must be a string'))
707 kind, value, matcher = _stringmatcher(value)
707 kind, value, matcher = _stringmatcher(value)
708
708
709 def _matchvalue(r):
709 def _matchvalue(r):
710 extra = repo[r].extra()
710 extra = repo[r].extra()
711 return label in extra and (value is None or matcher(extra[label]))
711 return label in extra and (value is None or matcher(extra[label]))
712
712
713 return baseset([r for r in subset if _matchvalue(r)])
713 return baseset([r for r in subset if _matchvalue(r)])
714
714
715 def filelog(repo, subset, x):
715 def filelog(repo, subset, x):
716 """``filelog(pattern)``
716 """``filelog(pattern)``
717 Changesets connected to the specified filelog.
717 Changesets connected to the specified filelog.
718
718
719 For performance reasons, ``filelog()`` does not show every changeset
719 For performance reasons, ``filelog()`` does not show every changeset
720 that affects the requested file(s). See :hg:`help log` for details. For
720 that affects the requested file(s). See :hg:`help log` for details. For
721 a slower, more accurate result, use ``file()``.
721 a slower, more accurate result, use ``file()``.
722
722
723 The pattern without explicit kind like ``glob:`` is expected to be
723 The pattern without explicit kind like ``glob:`` is expected to be
724 relative to the current directory and match against a file exactly
724 relative to the current directory and match against a file exactly
725 for efficiency.
725 for efficiency.
726 """
726 """
727
727
728 # i18n: "filelog" is a keyword
728 # i18n: "filelog" is a keyword
729 pat = getstring(x, _("filelog requires a pattern"))
729 pat = getstring(x, _("filelog requires a pattern"))
730 s = set()
730 s = set()
731
731
732 if not matchmod.patkind(pat):
732 if not matchmod.patkind(pat):
733 f = pathutil.canonpath(repo.root, repo.getcwd(), pat)
733 f = pathutil.canonpath(repo.root, repo.getcwd(), pat)
734 fl = repo.file(f)
734 fl = repo.file(f)
735 for fr in fl:
735 for fr in fl:
736 s.add(fl.linkrev(fr))
736 s.add(fl.linkrev(fr))
737 else:
737 else:
738 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=repo[None])
738 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=repo[None])
739 for f in repo[None]:
739 for f in repo[None]:
740 if m(f):
740 if m(f):
741 fl = repo.file(f)
741 fl = repo.file(f)
742 for fr in fl:
742 for fr in fl:
743 s.add(fl.linkrev(fr))
743 s.add(fl.linkrev(fr))
744
744
745 return baseset([r for r in subset if r in s])
745 return baseset([r for r in subset if r in s])
746
746
747 def first(repo, subset, x):
747 def first(repo, subset, x):
748 """``first(set, [n])``
748 """``first(set, [n])``
749 An alias for limit().
749 An alias for limit().
750 """
750 """
751 return limit(repo, subset, x)
751 return limit(repo, subset, x)
752
752
753 def _follow(repo, subset, x, name, followfirst=False):
753 def _follow(repo, subset, x, name, followfirst=False):
754 l = getargs(x, 0, 1, _("%s takes no arguments or a filename") % name)
754 l = getargs(x, 0, 1, _("%s takes no arguments or a filename") % name)
755 c = repo['.']
755 c = repo['.']
756 if l:
756 if l:
757 x = getstring(l[0], _("%s expected a filename") % name)
757 x = getstring(l[0], _("%s expected a filename") % name)
758 if x in c:
758 if x in c:
759 cx = c[x]
759 cx = c[x]
760 s = set(ctx.rev() for ctx in cx.ancestors(followfirst=followfirst))
760 s = set(ctx.rev() for ctx in cx.ancestors(followfirst=followfirst))
761 # include the revision responsible for the most recent version
761 # include the revision responsible for the most recent version
762 s.add(cx.linkrev())
762 s.add(cx.linkrev())
763 else:
763 else:
764 return baseset([])
764 return baseset([])
765 else:
765 else:
766 s = set(_revancestors(repo, [c.rev()], followfirst)) | set([c.rev()])
766 s = set(_revancestors(repo, [c.rev()], followfirst)) | set([c.rev()])
767
767
768 return baseset([r for r in subset if r in s])
768 return baseset([r for r in subset if r in s])
769
769
770 def follow(repo, subset, x):
770 def follow(repo, subset, x):
771 """``follow([file])``
771 """``follow([file])``
772 An alias for ``::.`` (ancestors of the working copy's first parent).
772 An alias for ``::.`` (ancestors of the working copy's first parent).
773 If a filename is specified, the history of the given file is followed,
773 If a filename is specified, the history of the given file is followed,
774 including copies.
774 including copies.
775 """
775 """
776 return _follow(repo, subset, x, 'follow')
776 return _follow(repo, subset, x, 'follow')
777
777
778 def _followfirst(repo, subset, x):
778 def _followfirst(repo, subset, x):
779 # ``followfirst([file])``
779 # ``followfirst([file])``
780 # Like ``follow([file])`` but follows only the first parent of
780 # Like ``follow([file])`` but follows only the first parent of
781 # every revision or file revision.
781 # every revision or file revision.
782 return _follow(repo, subset, x, '_followfirst', followfirst=True)
782 return _follow(repo, subset, x, '_followfirst', followfirst=True)
783
783
784 def getall(repo, subset, x):
784 def getall(repo, subset, x):
785 """``all()``
785 """``all()``
786 All changesets, the same as ``0:tip``.
786 All changesets, the same as ``0:tip``.
787 """
787 """
788 # i18n: "all" is a keyword
788 # i18n: "all" is a keyword
789 getargs(x, 0, 0, _("all takes no arguments"))
789 getargs(x, 0, 0, _("all takes no arguments"))
790 return subset
790 return subset
791
791
792 def grep(repo, subset, x):
792 def grep(repo, subset, x):
793 """``grep(regex)``
793 """``grep(regex)``
794 Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')``
794 Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')``
795 to ensure special escape characters are handled correctly. Unlike
795 to ensure special escape characters are handled correctly. Unlike
796 ``keyword(string)``, the match is case-sensitive.
796 ``keyword(string)``, the match is case-sensitive.
797 """
797 """
798 try:
798 try:
799 # i18n: "grep" is a keyword
799 # i18n: "grep" is a keyword
800 gr = re.compile(getstring(x, _("grep requires a string")))
800 gr = re.compile(getstring(x, _("grep requires a string")))
801 except re.error, e:
801 except re.error, e:
802 raise error.ParseError(_('invalid match pattern: %s') % e)
802 raise error.ParseError(_('invalid match pattern: %s') % e)
803
803
804 def matches(x):
804 def matches(x):
805 c = repo[x]
805 c = repo[x]
806 for e in c.files() + [c.user(), c.description()]:
806 for e in c.files() + [c.user(), c.description()]:
807 if gr.search(e):
807 if gr.search(e):
808 return True
808 return True
809 return False
809 return False
810
810
811 return lazyset(subset, matches)
811 return lazyset(subset, matches)
812
812
813 def _matchfiles(repo, subset, x):
813 def _matchfiles(repo, subset, x):
814 # _matchfiles takes a revset list of prefixed arguments:
814 # _matchfiles takes a revset list of prefixed arguments:
815 #
815 #
816 # [p:foo, i:bar, x:baz]
816 # [p:foo, i:bar, x:baz]
817 #
817 #
818 # builds a match object from them and filters subset. Allowed
818 # builds a match object from them and filters subset. Allowed
819 # prefixes are 'p:' for regular patterns, 'i:' for include
819 # prefixes are 'p:' for regular patterns, 'i:' for include
820 # patterns and 'x:' for exclude patterns. Use 'r:' prefix to pass
820 # patterns and 'x:' for exclude patterns. Use 'r:' prefix to pass
821 # a revision identifier, or the empty string to reference the
821 # a revision identifier, or the empty string to reference the
822 # working directory, from which the match object is
822 # working directory, from which the match object is
823 # initialized. Use 'd:' to set the default matching mode, default
823 # initialized. Use 'd:' to set the default matching mode, default
824 # to 'glob'. At most one 'r:' and 'd:' argument can be passed.
824 # to 'glob'. At most one 'r:' and 'd:' argument can be passed.
825
825
826 # i18n: "_matchfiles" is a keyword
826 # i18n: "_matchfiles" is a keyword
827 l = getargs(x, 1, -1, _("_matchfiles requires at least one argument"))
827 l = getargs(x, 1, -1, _("_matchfiles requires at least one argument"))
828 pats, inc, exc = [], [], []
828 pats, inc, exc = [], [], []
829 hasset = False
829 hasset = False
830 rev, default = None, None
830 rev, default = None, None
831 for arg in l:
831 for arg in l:
832 # i18n: "_matchfiles" is a keyword
832 # i18n: "_matchfiles" is a keyword
833 s = getstring(arg, _("_matchfiles requires string arguments"))
833 s = getstring(arg, _("_matchfiles requires string arguments"))
834 prefix, value = s[:2], s[2:]
834 prefix, value = s[:2], s[2:]
835 if prefix == 'p:':
835 if prefix == 'p:':
836 pats.append(value)
836 pats.append(value)
837 elif prefix == 'i:':
837 elif prefix == 'i:':
838 inc.append(value)
838 inc.append(value)
839 elif prefix == 'x:':
839 elif prefix == 'x:':
840 exc.append(value)
840 exc.append(value)
841 elif prefix == 'r:':
841 elif prefix == 'r:':
842 if rev is not None:
842 if rev is not None:
843 # i18n: "_matchfiles" is a keyword
843 # i18n: "_matchfiles" is a keyword
844 raise error.ParseError(_('_matchfiles expected at most one '
844 raise error.ParseError(_('_matchfiles expected at most one '
845 'revision'))
845 'revision'))
846 rev = value
846 rev = value
847 elif prefix == 'd:':
847 elif prefix == 'd:':
848 if default is not None:
848 if default is not None:
849 # i18n: "_matchfiles" is a keyword
849 # i18n: "_matchfiles" is a keyword
850 raise error.ParseError(_('_matchfiles expected at most one '
850 raise error.ParseError(_('_matchfiles expected at most one '
851 'default mode'))
851 'default mode'))
852 default = value
852 default = value
853 else:
853 else:
854 # i18n: "_matchfiles" is a keyword
854 # i18n: "_matchfiles" is a keyword
855 raise error.ParseError(_('invalid _matchfiles prefix: %s') % prefix)
855 raise error.ParseError(_('invalid _matchfiles prefix: %s') % prefix)
856 if not hasset and matchmod.patkind(value) == 'set':
856 if not hasset and matchmod.patkind(value) == 'set':
857 hasset = True
857 hasset = True
858 if not default:
858 if not default:
859 default = 'glob'
859 default = 'glob'
860 m = None
860 m = None
861 s = []
861 s = []
862 for r in subset:
862 for r in subset:
863 c = repo[r]
863 c = repo[r]
864 if not m or (hasset and rev is None):
864 if not m or (hasset and rev is None):
865 ctx = c
865 ctx = c
866 if rev is not None:
866 if rev is not None:
867 ctx = repo[rev or None]
867 ctx = repo[rev or None]
868 m = matchmod.match(repo.root, repo.getcwd(), pats, include=inc,
868 m = matchmod.match(repo.root, repo.getcwd(), pats, include=inc,
869 exclude=exc, ctx=ctx, default=default)
869 exclude=exc, ctx=ctx, default=default)
870 for f in c.files():
870 for f in c.files():
871 if m(f):
871 if m(f):
872 s.append(r)
872 s.append(r)
873 break
873 break
874 return baseset(s)
874 return baseset(s)
875
875
876 def hasfile(repo, subset, x):
876 def hasfile(repo, subset, x):
877 """``file(pattern)``
877 """``file(pattern)``
878 Changesets affecting files matched by pattern.
878 Changesets affecting files matched by pattern.
879
879
880 For a faster but less accurate result, consider using ``filelog()``
880 For a faster but less accurate result, consider using ``filelog()``
881 instead.
881 instead.
882
882
883 This predicate uses ``glob:`` as the default kind of pattern.
883 This predicate uses ``glob:`` as the default kind of pattern.
884 """
884 """
885 # i18n: "file" is a keyword
885 # i18n: "file" is a keyword
886 pat = getstring(x, _("file requires a pattern"))
886 pat = getstring(x, _("file requires a pattern"))
887 return _matchfiles(repo, subset, ('string', 'p:' + pat))
887 return _matchfiles(repo, subset, ('string', 'p:' + pat))
888
888
889 def head(repo, subset, x):
889 def head(repo, subset, x):
890 """``head()``
890 """``head()``
891 Changeset is a named branch head.
891 Changeset is a named branch head.
892 """
892 """
893 # i18n: "head" is a keyword
893 # i18n: "head" is a keyword
894 getargs(x, 0, 0, _("head takes no arguments"))
894 getargs(x, 0, 0, _("head takes no arguments"))
895 hs = set()
895 hs = set()
896 for b, ls in repo.branchmap().iteritems():
896 for b, ls in repo.branchmap().iteritems():
897 hs.update(repo[h].rev() for h in ls)
897 hs.update(repo[h].rev() for h in ls)
898 return baseset([r for r in subset if r in hs])
898 return baseset([r for r in subset if r in hs])
899
899
900 def heads(repo, subset, x):
900 def heads(repo, subset, x):
901 """``heads(set)``
901 """``heads(set)``
902 Members of set with no children in set.
902 Members of set with no children in set.
903 """
903 """
904 s = getset(repo, subset, x)
904 s = getset(repo, subset, x)
905 ps = parents(repo, subset, x)
905 ps = parents(repo, subset, x)
906 return s - ps
906 return s - ps
907
907
908 def hidden(repo, subset, x):
908 def hidden(repo, subset, x):
909 """``hidden()``
909 """``hidden()``
910 Hidden changesets.
910 Hidden changesets.
911 """
911 """
912 # i18n: "hidden" is a keyword
912 # i18n: "hidden" is a keyword
913 getargs(x, 0, 0, _("hidden takes no arguments"))
913 getargs(x, 0, 0, _("hidden takes no arguments"))
914 hiddenrevs = repoview.filterrevs(repo, 'visible')
914 hiddenrevs = repoview.filterrevs(repo, 'visible')
915 return subset & hiddenrevs
915 return subset & hiddenrevs
916
916
917 def keyword(repo, subset, x):
917 def keyword(repo, subset, x):
918 """``keyword(string)``
918 """``keyword(string)``
919 Search commit message, user name, and names of changed files for
919 Search commit message, user name, and names of changed files for
920 string. The match is case-insensitive.
920 string. The match is case-insensitive.
921 """
921 """
922 # i18n: "keyword" is a keyword
922 # i18n: "keyword" is a keyword
923 kw = encoding.lower(getstring(x, _("keyword requires a string")))
923 kw = encoding.lower(getstring(x, _("keyword requires a string")))
924
924
925 def matches(r):
925 def matches(r):
926 c = repo[r]
926 c = repo[r]
927 return util.any(kw in encoding.lower(t) for t in c.files() + [c.user(),
927 return util.any(kw in encoding.lower(t) for t in c.files() + [c.user(),
928 c.description()])
928 c.description()])
929
929
930 return lazyset(subset, matches)
930 return lazyset(subset, matches)
931
931
932 def limit(repo, subset, x):
932 def limit(repo, subset, x):
933 """``limit(set, [n])``
933 """``limit(set, [n])``
934 First n members of set, defaulting to 1.
934 First n members of set, defaulting to 1.
935 """
935 """
936 # i18n: "limit" is a keyword
936 # i18n: "limit" is a keyword
937 l = getargs(x, 1, 2, _("limit requires one or two arguments"))
937 l = getargs(x, 1, 2, _("limit requires one or two arguments"))
938 try:
938 try:
939 lim = 1
939 lim = 1
940 if len(l) == 2:
940 if len(l) == 2:
941 # i18n: "limit" is a keyword
941 # i18n: "limit" is a keyword
942 lim = int(getstring(l[1], _("limit requires a number")))
942 lim = int(getstring(l[1], _("limit requires a number")))
943 except (TypeError, ValueError):
943 except (TypeError, ValueError):
944 # i18n: "limit" is a keyword
944 # i18n: "limit" is a keyword
945 raise error.ParseError(_("limit expects a number"))
945 raise error.ParseError(_("limit expects a number"))
946 ss = subset.set()
946 ss = subset.set()
947 os = getset(repo, baseset(repo), l[0])
947 os = getset(repo, baseset(repo), l[0])
948 bs = baseset([])
948 bs = baseset([])
949 it = iter(os)
949 it = iter(os)
950 for x in xrange(lim):
950 for x in xrange(lim):
951 try:
951 try:
952 y = it.next()
952 y = it.next()
953 if y in ss:
953 if y in ss:
954 bs.append(y)
954 bs.append(y)
955 except (StopIteration):
955 except (StopIteration):
956 break
956 break
957 return bs
957 return bs
958
958
959 def last(repo, subset, x):
959 def last(repo, subset, x):
960 """``last(set, [n])``
960 """``last(set, [n])``
961 Last n members of set, defaulting to 1.
961 Last n members of set, defaulting to 1.
962 """
962 """
963 # i18n: "last" is a keyword
963 # i18n: "last" is a keyword
964 l = getargs(x, 1, 2, _("last requires one or two arguments"))
964 l = getargs(x, 1, 2, _("last requires one or two arguments"))
965 try:
965 try:
966 lim = 1
966 lim = 1
967 if len(l) == 2:
967 if len(l) == 2:
968 # i18n: "last" is a keyword
968 # i18n: "last" is a keyword
969 lim = int(getstring(l[1], _("last requires a number")))
969 lim = int(getstring(l[1], _("last requires a number")))
970 except (TypeError, ValueError):
970 except (TypeError, ValueError):
971 # i18n: "last" is a keyword
971 # i18n: "last" is a keyword
972 raise error.ParseError(_("last expects a number"))
972 raise error.ParseError(_("last expects a number"))
973 ss = subset.set()
973 ss = subset.set()
974 os = getset(repo, baseset(repo), l[0])[-lim:]
974 os = getset(repo, baseset(repo), l[0])[-lim:]
975 return baseset([r for r in os if r in ss])
975 return baseset([r for r in os if r in ss])
976
976
977 def maxrev(repo, subset, x):
977 def maxrev(repo, subset, x):
978 """``max(set)``
978 """``max(set)``
979 Changeset with highest revision number in set.
979 Changeset with highest revision number in set.
980 """
980 """
981 os = getset(repo, baseset(repo), x)
981 os = getset(repo, baseset(repo), x)
982 if os:
982 if os:
983 m = max(os)
983 m = max(os)
984 if m in subset:
984 if m in subset:
985 return baseset([m])
985 return baseset([m])
986 return baseset([])
986 return baseset([])
987
987
988 def merge(repo, subset, x):
988 def merge(repo, subset, x):
989 """``merge()``
989 """``merge()``
990 Changeset is a merge changeset.
990 Changeset is a merge changeset.
991 """
991 """
992 # i18n: "merge" is a keyword
992 # i18n: "merge" is a keyword
993 getargs(x, 0, 0, _("merge takes no arguments"))
993 getargs(x, 0, 0, _("merge takes no arguments"))
994 cl = repo.changelog
994 cl = repo.changelog
995 return lazyset(subset, lambda r: cl.parentrevs(r)[1] != -1)
995 return lazyset(subset, lambda r: cl.parentrevs(r)[1] != -1)
996
996
997 def branchpoint(repo, subset, x):
997 def branchpoint(repo, subset, x):
998 """``branchpoint()``
998 """``branchpoint()``
999 Changesets with more than one child.
999 Changesets with more than one child.
1000 """
1000 """
1001 # i18n: "branchpoint" is a keyword
1001 # i18n: "branchpoint" is a keyword
1002 getargs(x, 0, 0, _("branchpoint takes no arguments"))
1002 getargs(x, 0, 0, _("branchpoint takes no arguments"))
1003 cl = repo.changelog
1003 cl = repo.changelog
1004 if not subset:
1004 if not subset:
1005 return baseset([])
1005 return baseset([])
1006 baserev = min(subset)
1006 baserev = min(subset)
1007 parentscount = [0]*(len(repo) - baserev)
1007 parentscount = [0]*(len(repo) - baserev)
1008 for r in cl.revs(start=baserev + 1):
1008 for r in cl.revs(start=baserev + 1):
1009 for p in cl.parentrevs(r):
1009 for p in cl.parentrevs(r):
1010 if p >= baserev:
1010 if p >= baserev:
1011 parentscount[p - baserev] += 1
1011 parentscount[p - baserev] += 1
1012 return baseset([r for r in subset if (parentscount[r - baserev] > 1)])
1012 return baseset([r for r in subset if (parentscount[r - baserev] > 1)])
1013
1013
1014 def minrev(repo, subset, x):
1014 def minrev(repo, subset, x):
1015 """``min(set)``
1015 """``min(set)``
1016 Changeset with lowest revision number in set.
1016 Changeset with lowest revision number in set.
1017 """
1017 """
1018 os = getset(repo, baseset(repo), x)
1018 os = getset(repo, baseset(repo), x)
1019 if os:
1019 if os:
1020 m = min(os)
1020 m = min(os)
1021 if m in subset:
1021 if m in subset:
1022 return baseset([m])
1022 return baseset([m])
1023 return baseset([])
1023 return baseset([])
1024
1024
1025 def modifies(repo, subset, x):
1025 def modifies(repo, subset, x):
1026 """``modifies(pattern)``
1026 """``modifies(pattern)``
1027 Changesets modifying files matched by pattern.
1027 Changesets modifying files matched by pattern.
1028
1028
1029 The pattern without explicit kind like ``glob:`` is expected to be
1029 The pattern without explicit kind like ``glob:`` is expected to be
1030 relative to the current directory and match against a file or a
1030 relative to the current directory and match against a file or a
1031 directory.
1031 directory.
1032 """
1032 """
1033 # i18n: "modifies" is a keyword
1033 # i18n: "modifies" is a keyword
1034 pat = getstring(x, _("modifies requires a pattern"))
1034 pat = getstring(x, _("modifies requires a pattern"))
1035 return checkstatus(repo, subset, pat, 0)
1035 return checkstatus(repo, subset, pat, 0)
1036
1036
1037 def node_(repo, subset, x):
1037 def node_(repo, subset, x):
1038 """``id(string)``
1038 """``id(string)``
1039 Revision non-ambiguously specified by the given hex string prefix.
1039 Revision non-ambiguously specified by the given hex string prefix.
1040 """
1040 """
1041 # i18n: "id" is a keyword
1041 # i18n: "id" is a keyword
1042 l = getargs(x, 1, 1, _("id requires one argument"))
1042 l = getargs(x, 1, 1, _("id requires one argument"))
1043 # i18n: "id" is a keyword
1043 # i18n: "id" is a keyword
1044 n = getstring(l[0], _("id requires a string"))
1044 n = getstring(l[0], _("id requires a string"))
1045 if len(n) == 40:
1045 if len(n) == 40:
1046 rn = repo[n].rev()
1046 rn = repo[n].rev()
1047 else:
1047 else:
1048 rn = None
1048 rn = None
1049 pm = repo.changelog._partialmatch(n)
1049 pm = repo.changelog._partialmatch(n)
1050 if pm is not None:
1050 if pm is not None:
1051 rn = repo.changelog.rev(pm)
1051 rn = repo.changelog.rev(pm)
1052
1052
1053 return baseset([r for r in subset if r == rn])
1053 return baseset([r for r in subset if r == rn])
1054
1054
1055 def obsolete(repo, subset, x):
1055 def obsolete(repo, subset, x):
1056 """``obsolete()``
1056 """``obsolete()``
1057 Mutable changeset with a newer version."""
1057 Mutable changeset with a newer version."""
1058 # i18n: "obsolete" is a keyword
1058 # i18n: "obsolete" is a keyword
1059 getargs(x, 0, 0, _("obsolete takes no arguments"))
1059 getargs(x, 0, 0, _("obsolete takes no arguments"))
1060 obsoletes = obsmod.getrevs(repo, 'obsolete')
1060 obsoletes = obsmod.getrevs(repo, 'obsolete')
1061 return subset & obsoletes
1061 return subset & obsoletes
1062
1062
1063 def origin(repo, subset, x):
1063 def origin(repo, subset, x):
1064 """``origin([set])``
1064 """``origin([set])``
1065 Changesets that were specified as a source for the grafts, transplants or
1065 Changesets that were specified as a source for the grafts, transplants or
1066 rebases that created the given revisions. Omitting the optional set is the
1066 rebases that created the given revisions. Omitting the optional set is the
1067 same as passing all(). If a changeset created by these operations is itself
1067 same as passing all(). If a changeset created by these operations is itself
1068 specified as a source for one of these operations, only the source changeset
1068 specified as a source for one of these operations, only the source changeset
1069 for the first operation is selected.
1069 for the first operation is selected.
1070 """
1070 """
1071 if x is not None:
1071 if x is not None:
1072 args = getset(repo, baseset(repo), x).set()
1072 args = getset(repo, baseset(repo), x).set()
1073 else:
1073 else:
1074 args = getall(repo, baseset(repo), x).set()
1074 args = getall(repo, baseset(repo), x).set()
1075
1075
1076 def _firstsrc(rev):
1076 def _firstsrc(rev):
1077 src = _getrevsource(repo, rev)
1077 src = _getrevsource(repo, rev)
1078 if src is None:
1078 if src is None:
1079 return None
1079 return None
1080
1080
1081 while True:
1081 while True:
1082 prev = _getrevsource(repo, src)
1082 prev = _getrevsource(repo, src)
1083
1083
1084 if prev is None:
1084 if prev is None:
1085 return src
1085 return src
1086 src = prev
1086 src = prev
1087
1087
1088 o = set([_firstsrc(r) for r in args])
1088 o = set([_firstsrc(r) for r in args])
1089 return baseset([r for r in subset if r in o])
1089 return baseset([r for r in subset if r in o])
1090
1090
1091 def outgoing(repo, subset, x):
1091 def outgoing(repo, subset, x):
1092 """``outgoing([path])``
1092 """``outgoing([path])``
1093 Changesets not found in the specified destination repository, or the
1093 Changesets not found in the specified destination repository, or the
1094 default push location.
1094 default push location.
1095 """
1095 """
1096 import hg # avoid start-up nasties
1096 import hg # avoid start-up nasties
1097 # i18n: "outgoing" is a keyword
1097 # i18n: "outgoing" is a keyword
1098 l = getargs(x, 0, 1, _("outgoing takes one or no arguments"))
1098 l = getargs(x, 0, 1, _("outgoing takes one or no arguments"))
1099 # i18n: "outgoing" is a keyword
1099 # i18n: "outgoing" is a keyword
1100 dest = l and getstring(l[0], _("outgoing requires a repository path")) or ''
1100 dest = l and getstring(l[0], _("outgoing requires a repository path")) or ''
1101 dest = repo.ui.expandpath(dest or 'default-push', dest or 'default')
1101 dest = repo.ui.expandpath(dest or 'default-push', dest or 'default')
1102 dest, branches = hg.parseurl(dest)
1102 dest, branches = hg.parseurl(dest)
1103 revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
1103 revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
1104 if revs:
1104 if revs:
1105 revs = [repo.lookup(rev) for rev in revs]
1105 revs = [repo.lookup(rev) for rev in revs]
1106 other = hg.peer(repo, {}, dest)
1106 other = hg.peer(repo, {}, dest)
1107 repo.ui.pushbuffer()
1107 repo.ui.pushbuffer()
1108 outgoing = discovery.findcommonoutgoing(repo, other, onlyheads=revs)
1108 outgoing = discovery.findcommonoutgoing(repo, other, onlyheads=revs)
1109 repo.ui.popbuffer()
1109 repo.ui.popbuffer()
1110 cl = repo.changelog
1110 cl = repo.changelog
1111 o = set([cl.rev(r) for r in outgoing.missing])
1111 o = set([cl.rev(r) for r in outgoing.missing])
1112 return baseset([r for r in subset if r in o])
1112 return baseset([r for r in subset if r in o])
1113
1113
1114 def p1(repo, subset, x):
1114 def p1(repo, subset, x):
1115 """``p1([set])``
1115 """``p1([set])``
1116 First parent of changesets in set, or the working directory.
1116 First parent of changesets in set, or the working directory.
1117 """
1117 """
1118 if x is None:
1118 if x is None:
1119 p = repo[x].p1().rev()
1119 p = repo[x].p1().rev()
1120 return baseset([r for r in subset if r == p])
1120 return baseset([r for r in subset if r == p])
1121
1121
1122 ps = set()
1122 ps = set()
1123 cl = repo.changelog
1123 cl = repo.changelog
1124 for r in getset(repo, baseset(repo), x):
1124 for r in getset(repo, baseset(repo), x):
1125 ps.add(cl.parentrevs(r)[0])
1125 ps.add(cl.parentrevs(r)[0])
1126 return subset & ps
1126 return subset & ps
1127
1127
1128 def p2(repo, subset, x):
1128 def p2(repo, subset, x):
1129 """``p2([set])``
1129 """``p2([set])``
1130 Second parent of changesets in set, or the working directory.
1130 Second parent of changesets in set, or the working directory.
1131 """
1131 """
1132 if x is None:
1132 if x is None:
1133 ps = repo[x].parents()
1133 ps = repo[x].parents()
1134 try:
1134 try:
1135 p = ps[1].rev()
1135 p = ps[1].rev()
1136 return baseset([r for r in subset if r == p])
1136 return baseset([r for r in subset if r == p])
1137 except IndexError:
1137 except IndexError:
1138 return baseset([])
1138 return baseset([])
1139
1139
1140 ps = set()
1140 ps = set()
1141 cl = repo.changelog
1141 cl = repo.changelog
1142 for r in getset(repo, baseset(repo), x):
1142 for r in getset(repo, baseset(repo), x):
1143 ps.add(cl.parentrevs(r)[1])
1143 ps.add(cl.parentrevs(r)[1])
1144 return subset & ps
1144 return subset & ps
1145
1145
1146 def parents(repo, subset, x):
1146 def parents(repo, subset, x):
1147 """``parents([set])``
1147 """``parents([set])``
1148 The set of all parents for all changesets in set, or the working directory.
1148 The set of all parents for all changesets in set, or the working directory.
1149 """
1149 """
1150 if x is None:
1150 if x is None:
1151 ps = tuple(p.rev() for p in repo[x].parents())
1151 ps = tuple(p.rev() for p in repo[x].parents())
1152 return subset & ps
1152 return subset & ps
1153
1153
1154 ps = set()
1154 ps = set()
1155 cl = repo.changelog
1155 cl = repo.changelog
1156 for r in getset(repo, baseset(repo), x):
1156 for r in getset(repo, baseset(repo), x):
1157 ps.update(cl.parentrevs(r))
1157 ps.update(cl.parentrevs(r))
1158 return subset & ps
1158 return subset & ps
1159
1159
1160 def parentspec(repo, subset, x, n):
1160 def parentspec(repo, subset, x, n):
1161 """``set^0``
1161 """``set^0``
1162 The set.
1162 The set.
1163 ``set^1`` (or ``set^``), ``set^2``
1163 ``set^1`` (or ``set^``), ``set^2``
1164 First or second parent, respectively, of all changesets in set.
1164 First or second parent, respectively, of all changesets in set.
1165 """
1165 """
1166 try:
1166 try:
1167 n = int(n[1])
1167 n = int(n[1])
1168 if n not in (0, 1, 2):
1168 if n not in (0, 1, 2):
1169 raise ValueError
1169 raise ValueError
1170 except (TypeError, ValueError):
1170 except (TypeError, ValueError):
1171 raise error.ParseError(_("^ expects a number 0, 1, or 2"))
1171 raise error.ParseError(_("^ expects a number 0, 1, or 2"))
1172 ps = set()
1172 ps = set()
1173 cl = repo.changelog
1173 cl = repo.changelog
1174 for r in getset(repo, baseset(cl), x):
1174 for r in getset(repo, baseset(cl), x):
1175 if n == 0:
1175 if n == 0:
1176 ps.add(r)
1176 ps.add(r)
1177 elif n == 1:
1177 elif n == 1:
1178 ps.add(cl.parentrevs(r)[0])
1178 ps.add(cl.parentrevs(r)[0])
1179 elif n == 2:
1179 elif n == 2:
1180 parents = cl.parentrevs(r)
1180 parents = cl.parentrevs(r)
1181 if len(parents) > 1:
1181 if len(parents) > 1:
1182 ps.add(parents[1])
1182 ps.add(parents[1])
1183 return subset & ps
1183 return subset & ps
1184
1184
1185 def present(repo, subset, x):
1185 def present(repo, subset, x):
1186 """``present(set)``
1186 """``present(set)``
1187 An empty set, if any revision in set isn't found; otherwise,
1187 An empty set, if any revision in set isn't found; otherwise,
1188 all revisions in set.
1188 all revisions in set.
1189
1189
1190 If any of specified revisions is not present in the local repository,
1190 If any of specified revisions is not present in the local repository,
1191 the query is normally aborted. But this predicate allows the query
1191 the query is normally aborted. But this predicate allows the query
1192 to continue even in such cases.
1192 to continue even in such cases.
1193 """
1193 """
1194 try:
1194 try:
1195 return getset(repo, subset, x)
1195 return getset(repo, subset, x)
1196 except error.RepoLookupError:
1196 except error.RepoLookupError:
1197 return baseset([])
1197 return baseset([])
1198
1198
1199 def public(repo, subset, x):
1199 def public(repo, subset, x):
1200 """``public()``
1200 """``public()``
1201 Changeset in public phase."""
1201 Changeset in public phase."""
1202 # i18n: "public" is a keyword
1202 # i18n: "public" is a keyword
1203 getargs(x, 0, 0, _("public takes no arguments"))
1203 getargs(x, 0, 0, _("public takes no arguments"))
1204 pc = repo._phasecache
1204 pc = repo._phasecache
1205 return lazyset(subset, lambda r: pc.phase(repo, r) == phases.public)
1205 return lazyset(subset, lambda r: pc.phase(repo, r) == phases.public)
1206
1206
1207 def remote(repo, subset, x):
1207 def remote(repo, subset, x):
1208 """``remote([id [,path]])``
1208 """``remote([id [,path]])``
1209 Local revision that corresponds to the given identifier in a
1209 Local revision that corresponds to the given identifier in a
1210 remote repository, if present. Here, the '.' identifier is a
1210 remote repository, if present. Here, the '.' identifier is a
1211 synonym for the current local branch.
1211 synonym for the current local branch.
1212 """
1212 """
1213
1213
1214 import hg # avoid start-up nasties
1214 import hg # avoid start-up nasties
1215 # i18n: "remote" is a keyword
1215 # i18n: "remote" is a keyword
1216 l = getargs(x, 0, 2, _("remote takes one, two or no arguments"))
1216 l = getargs(x, 0, 2, _("remote takes one, two or no arguments"))
1217
1217
1218 q = '.'
1218 q = '.'
1219 if len(l) > 0:
1219 if len(l) > 0:
1220 # i18n: "remote" is a keyword
1220 # i18n: "remote" is a keyword
1221 q = getstring(l[0], _("remote requires a string id"))
1221 q = getstring(l[0], _("remote requires a string id"))
1222 if q == '.':
1222 if q == '.':
1223 q = repo['.'].branch()
1223 q = repo['.'].branch()
1224
1224
1225 dest = ''
1225 dest = ''
1226 if len(l) > 1:
1226 if len(l) > 1:
1227 # i18n: "remote" is a keyword
1227 # i18n: "remote" is a keyword
1228 dest = getstring(l[1], _("remote requires a repository path"))
1228 dest = getstring(l[1], _("remote requires a repository path"))
1229 dest = repo.ui.expandpath(dest or 'default')
1229 dest = repo.ui.expandpath(dest or 'default')
1230 dest, branches = hg.parseurl(dest)
1230 dest, branches = hg.parseurl(dest)
1231 revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
1231 revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
1232 if revs:
1232 if revs:
1233 revs = [repo.lookup(rev) for rev in revs]
1233 revs = [repo.lookup(rev) for rev in revs]
1234 other = hg.peer(repo, {}, dest)
1234 other = hg.peer(repo, {}, dest)
1235 n = other.lookup(q)
1235 n = other.lookup(q)
1236 if n in repo:
1236 if n in repo:
1237 r = repo[n].rev()
1237 r = repo[n].rev()
1238 if r in subset:
1238 if r in subset:
1239 return baseset([r])
1239 return baseset([r])
1240 return baseset([])
1240 return baseset([])
1241
1241
1242 def removes(repo, subset, x):
1242 def removes(repo, subset, x):
1243 """``removes(pattern)``
1243 """``removes(pattern)``
1244 Changesets which remove files matching pattern.
1244 Changesets which remove files matching pattern.
1245
1245
1246 The pattern without explicit kind like ``glob:`` is expected to be
1246 The pattern without explicit kind like ``glob:`` is expected to be
1247 relative to the current directory and match against a file or a
1247 relative to the current directory and match against a file or a
1248 directory.
1248 directory.
1249 """
1249 """
1250 # i18n: "removes" is a keyword
1250 # i18n: "removes" is a keyword
1251 pat = getstring(x, _("removes requires a pattern"))
1251 pat = getstring(x, _("removes requires a pattern"))
1252 return checkstatus(repo, subset, pat, 2)
1252 return checkstatus(repo, subset, pat, 2)
1253
1253
1254 def rev(repo, subset, x):
1254 def rev(repo, subset, x):
1255 """``rev(number)``
1255 """``rev(number)``
1256 Revision with the given numeric identifier.
1256 Revision with the given numeric identifier.
1257 """
1257 """
1258 # i18n: "rev" is a keyword
1258 # i18n: "rev" is a keyword
1259 l = getargs(x, 1, 1, _("rev requires one argument"))
1259 l = getargs(x, 1, 1, _("rev requires one argument"))
1260 try:
1260 try:
1261 # i18n: "rev" is a keyword
1261 # i18n: "rev" is a keyword
1262 l = int(getstring(l[0], _("rev requires a number")))
1262 l = int(getstring(l[0], _("rev requires a number")))
1263 except (TypeError, ValueError):
1263 except (TypeError, ValueError):
1264 # i18n: "rev" is a keyword
1264 # i18n: "rev" is a keyword
1265 raise error.ParseError(_("rev expects a number"))
1265 raise error.ParseError(_("rev expects a number"))
1266 return baseset([r for r in subset if r == l])
1266 return baseset([r for r in subset if r == l])
1267
1267
1268 def matching(repo, subset, x):
1268 def matching(repo, subset, x):
1269 """``matching(revision [, field])``
1269 """``matching(revision [, field])``
1270 Changesets in which a given set of fields match the set of fields in the
1270 Changesets in which a given set of fields match the set of fields in the
1271 selected revision or set.
1271 selected revision or set.
1272
1272
1273 To match more than one field pass the list of fields to match separated
1273 To match more than one field pass the list of fields to match separated
1274 by spaces (e.g. ``author description``).
1274 by spaces (e.g. ``author description``).
1275
1275
1276 Valid fields are most regular revision fields and some special fields.
1276 Valid fields are most regular revision fields and some special fields.
1277
1277
1278 Regular revision fields are ``description``, ``author``, ``branch``,
1278 Regular revision fields are ``description``, ``author``, ``branch``,
1279 ``date``, ``files``, ``phase``, ``parents``, ``substate``, ``user``
1279 ``date``, ``files``, ``phase``, ``parents``, ``substate``, ``user``
1280 and ``diff``.
1280 and ``diff``.
1281 Note that ``author`` and ``user`` are synonyms. ``diff`` refers to the
1281 Note that ``author`` and ``user`` are synonyms. ``diff`` refers to the
1282 contents of the revision. Two revisions matching their ``diff`` will
1282 contents of the revision. Two revisions matching their ``diff`` will
1283 also match their ``files``.
1283 also match their ``files``.
1284
1284
1285 Special fields are ``summary`` and ``metadata``:
1285 Special fields are ``summary`` and ``metadata``:
1286 ``summary`` matches the first line of the description.
1286 ``summary`` matches the first line of the description.
1287 ``metadata`` is equivalent to matching ``description user date``
1287 ``metadata`` is equivalent to matching ``description user date``
1288 (i.e. it matches the main metadata fields).
1288 (i.e. it matches the main metadata fields).
1289
1289
1290 ``metadata`` is the default field which is used when no fields are
1290 ``metadata`` is the default field which is used when no fields are
1291 specified. You can match more than one field at a time.
1291 specified. You can match more than one field at a time.
1292 """
1292 """
1293 # i18n: "matching" is a keyword
1293 # i18n: "matching" is a keyword
1294 l = getargs(x, 1, 2, _("matching takes 1 or 2 arguments"))
1294 l = getargs(x, 1, 2, _("matching takes 1 or 2 arguments"))
1295
1295
1296 revs = getset(repo, baseset(repo.changelog), l[0])
1296 revs = getset(repo, baseset(repo.changelog), l[0])
1297
1297
1298 fieldlist = ['metadata']
1298 fieldlist = ['metadata']
1299 if len(l) > 1:
1299 if len(l) > 1:
1300 fieldlist = getstring(l[1],
1300 fieldlist = getstring(l[1],
1301 # i18n: "matching" is a keyword
1301 # i18n: "matching" is a keyword
1302 _("matching requires a string "
1302 _("matching requires a string "
1303 "as its second argument")).split()
1303 "as its second argument")).split()
1304
1304
1305 # Make sure that there are no repeated fields,
1305 # Make sure that there are no repeated fields,
1306 # expand the 'special' 'metadata' field type
1306 # expand the 'special' 'metadata' field type
1307 # and check the 'files' whenever we check the 'diff'
1307 # and check the 'files' whenever we check the 'diff'
1308 fields = []
1308 fields = []
1309 for field in fieldlist:
1309 for field in fieldlist:
1310 if field == 'metadata':
1310 if field == 'metadata':
1311 fields += ['user', 'description', 'date']
1311 fields += ['user', 'description', 'date']
1312 elif field == 'diff':
1312 elif field == 'diff':
1313 # a revision matching the diff must also match the files
1313 # a revision matching the diff must also match the files
1314 # since matching the diff is very costly, make sure to
1314 # since matching the diff is very costly, make sure to
1315 # also match the files first
1315 # also match the files first
1316 fields += ['files', 'diff']
1316 fields += ['files', 'diff']
1317 else:
1317 else:
1318 if field == 'author':
1318 if field == 'author':
1319 field = 'user'
1319 field = 'user'
1320 fields.append(field)
1320 fields.append(field)
1321 fields = set(fields)
1321 fields = set(fields)
1322 if 'summary' in fields and 'description' in fields:
1322 if 'summary' in fields and 'description' in fields:
1323 # If a revision matches its description it also matches its summary
1323 # If a revision matches its description it also matches its summary
1324 fields.discard('summary')
1324 fields.discard('summary')
1325
1325
1326 # We may want to match more than one field
1326 # We may want to match more than one field
1327 # Not all fields take the same amount of time to be matched
1327 # Not all fields take the same amount of time to be matched
1328 # Sort the selected fields in order of increasing matching cost
1328 # Sort the selected fields in order of increasing matching cost
1329 fieldorder = ['phase', 'parents', 'user', 'date', 'branch', 'summary',
1329 fieldorder = ['phase', 'parents', 'user', 'date', 'branch', 'summary',
1330 'files', 'description', 'substate', 'diff']
1330 'files', 'description', 'substate', 'diff']
1331 def fieldkeyfunc(f):
1331 def fieldkeyfunc(f):
1332 try:
1332 try:
1333 return fieldorder.index(f)
1333 return fieldorder.index(f)
1334 except ValueError:
1334 except ValueError:
1335 # assume an unknown field is very costly
1335 # assume an unknown field is very costly
1336 return len(fieldorder)
1336 return len(fieldorder)
1337 fields = list(fields)
1337 fields = list(fields)
1338 fields.sort(key=fieldkeyfunc)
1338 fields.sort(key=fieldkeyfunc)
1339
1339
1340 # Each field will be matched with its own "getfield" function
1340 # Each field will be matched with its own "getfield" function
1341 # which will be added to the getfieldfuncs array of functions
1341 # which will be added to the getfieldfuncs array of functions
1342 getfieldfuncs = []
1342 getfieldfuncs = []
1343 _funcs = {
1343 _funcs = {
1344 'user': lambda r: repo[r].user(),
1344 'user': lambda r: repo[r].user(),
1345 'branch': lambda r: repo[r].branch(),
1345 'branch': lambda r: repo[r].branch(),
1346 'date': lambda r: repo[r].date(),
1346 'date': lambda r: repo[r].date(),
1347 'description': lambda r: repo[r].description(),
1347 'description': lambda r: repo[r].description(),
1348 'files': lambda r: repo[r].files(),
1348 'files': lambda r: repo[r].files(),
1349 'parents': lambda r: repo[r].parents(),
1349 'parents': lambda r: repo[r].parents(),
1350 'phase': lambda r: repo[r].phase(),
1350 'phase': lambda r: repo[r].phase(),
1351 'substate': lambda r: repo[r].substate,
1351 'substate': lambda r: repo[r].substate,
1352 'summary': lambda r: repo[r].description().splitlines()[0],
1352 'summary': lambda r: repo[r].description().splitlines()[0],
1353 'diff': lambda r: list(repo[r].diff(git=True),)
1353 'diff': lambda r: list(repo[r].diff(git=True),)
1354 }
1354 }
1355 for info in fields:
1355 for info in fields:
1356 getfield = _funcs.get(info, None)
1356 getfield = _funcs.get(info, None)
1357 if getfield is None:
1357 if getfield is None:
1358 raise error.ParseError(
1358 raise error.ParseError(
1359 # i18n: "matching" is a keyword
1359 # i18n: "matching" is a keyword
1360 _("unexpected field name passed to matching: %s") % info)
1360 _("unexpected field name passed to matching: %s") % info)
1361 getfieldfuncs.append(getfield)
1361 getfieldfuncs.append(getfield)
1362 # convert the getfield array of functions into a "getinfo" function
1362 # convert the getfield array of functions into a "getinfo" function
1363 # which returns an array of field values (or a single value if there
1363 # which returns an array of field values (or a single value if there
1364 # is only one field to match)
1364 # is only one field to match)
1365 getinfo = lambda r: [f(r) for f in getfieldfuncs]
1365 getinfo = lambda r: [f(r) for f in getfieldfuncs]
1366
1366
1367 matches = set()
1367 matches = set()
1368 for rev in revs:
1368 for rev in revs:
1369 target = getinfo(rev)
1369 target = getinfo(rev)
1370 for r in subset:
1370 for r in subset:
1371 match = True
1371 match = True
1372 for n, f in enumerate(getfieldfuncs):
1372 for n, f in enumerate(getfieldfuncs):
1373 if target[n] != f(r):
1373 if target[n] != f(r):
1374 match = False
1374 match = False
1375 break
1375 break
1376 if match:
1376 if match:
1377 matches.add(r)
1377 matches.add(r)
1378 return baseset([r for r in subset if r in matches])
1378 return baseset([r for r in subset if r in matches])
1379
1379
1380 def reverse(repo, subset, x):
1380 def reverse(repo, subset, x):
1381 """``reverse(set)``
1381 """``reverse(set)``
1382 Reverse order of set.
1382 Reverse order of set.
1383 """
1383 """
1384 l = getset(repo, subset, x)
1384 l = getset(repo, subset, x)
1385 l.reverse()
1385 l.reverse()
1386 return l
1386 return l
1387
1387
1388 def roots(repo, subset, x):
1388 def roots(repo, subset, x):
1389 """``roots(set)``
1389 """``roots(set)``
1390 Changesets in set with no parent changeset in set.
1390 Changesets in set with no parent changeset in set.
1391 """
1391 """
1392 s = getset(repo, baseset(repo.changelog), x).set()
1392 s = getset(repo, baseset(repo.changelog), x).set()
1393 subset = baseset([r for r in subset if r in s])
1393 subset = baseset([r for r in subset if r in s])
1394 cs = _children(repo, subset, s)
1394 cs = _children(repo, subset, s)
1395 return subset - cs
1395 return subset - cs
1396
1396
1397 def secret(repo, subset, x):
1397 def secret(repo, subset, x):
1398 """``secret()``
1398 """``secret()``
1399 Changeset in secret phase."""
1399 Changeset in secret phase."""
1400 # i18n: "secret" is a keyword
1400 # i18n: "secret" is a keyword
1401 getargs(x, 0, 0, _("secret takes no arguments"))
1401 getargs(x, 0, 0, _("secret takes no arguments"))
1402 pc = repo._phasecache
1402 pc = repo._phasecache
1403 return baseset([r for r in subset if pc.phase(repo, r) == phases.secret])
1403 return baseset([r for r in subset if pc.phase(repo, r) == phases.secret])
1404
1404
1405 def sort(repo, subset, x):
1405 def sort(repo, subset, x):
1406 """``sort(set[, [-]key...])``
1406 """``sort(set[, [-]key...])``
1407 Sort set by keys. The default sort order is ascending, specify a key
1407 Sort set by keys. The default sort order is ascending, specify a key
1408 as ``-key`` to sort in descending order.
1408 as ``-key`` to sort in descending order.
1409
1409
1410 The keys can be:
1410 The keys can be:
1411
1411
1412 - ``rev`` for the revision number,
1412 - ``rev`` for the revision number,
1413 - ``branch`` for the branch name,
1413 - ``branch`` for the branch name,
1414 - ``desc`` for the commit message (description),
1414 - ``desc`` for the commit message (description),
1415 - ``user`` for user name (``author`` can be used as an alias),
1415 - ``user`` for user name (``author`` can be used as an alias),
1416 - ``date`` for the commit date
1416 - ``date`` for the commit date
1417 """
1417 """
1418 # i18n: "sort" is a keyword
1418 # i18n: "sort" is a keyword
1419 l = getargs(x, 1, 2, _("sort requires one or two arguments"))
1419 l = getargs(x, 1, 2, _("sort requires one or two arguments"))
1420 keys = "rev"
1420 keys = "rev"
1421 if len(l) == 2:
1421 if len(l) == 2:
1422 # i18n: "sort" is a keyword
1422 # i18n: "sort" is a keyword
1423 keys = getstring(l[1], _("sort spec must be a string"))
1423 keys = getstring(l[1], _("sort spec must be a string"))
1424
1424
1425 s = l[0]
1425 s = l[0]
1426 keys = keys.split()
1426 keys = keys.split()
1427 l = []
1427 l = []
1428 def invert(s):
1428 def invert(s):
1429 return "".join(chr(255 - ord(c)) for c in s)
1429 return "".join(chr(255 - ord(c)) for c in s)
1430 for r in getset(repo, subset, s):
1430 for r in getset(repo, subset, s):
1431 c = repo[r]
1431 c = repo[r]
1432 e = []
1432 e = []
1433 for k in keys:
1433 for k in keys:
1434 if k == 'rev':
1434 if k == 'rev':
1435 e.append(r)
1435 e.append(r)
1436 elif k == '-rev':
1436 elif k == '-rev':
1437 e.append(-r)
1437 e.append(-r)
1438 elif k == 'branch':
1438 elif k == 'branch':
1439 e.append(c.branch())
1439 e.append(c.branch())
1440 elif k == '-branch':
1440 elif k == '-branch':
1441 e.append(invert(c.branch()))
1441 e.append(invert(c.branch()))
1442 elif k == 'desc':
1442 elif k == 'desc':
1443 e.append(c.description())
1443 e.append(c.description())
1444 elif k == '-desc':
1444 elif k == '-desc':
1445 e.append(invert(c.description()))
1445 e.append(invert(c.description()))
1446 elif k in 'user author':
1446 elif k in 'user author':
1447 e.append(c.user())
1447 e.append(c.user())
1448 elif k in '-user -author':
1448 elif k in '-user -author':
1449 e.append(invert(c.user()))
1449 e.append(invert(c.user()))
1450 elif k == 'date':
1450 elif k == 'date':
1451 e.append(c.date()[0])
1451 e.append(c.date()[0])
1452 elif k == '-date':
1452 elif k == '-date':
1453 e.append(-c.date()[0])
1453 e.append(-c.date()[0])
1454 else:
1454 else:
1455 raise error.ParseError(_("unknown sort key %r") % k)
1455 raise error.ParseError(_("unknown sort key %r") % k)
1456 e.append(r)
1456 e.append(r)
1457 l.append(e)
1457 l.append(e)
1458 l.sort()
1458 l.sort()
1459 return baseset([e[-1] for e in l])
1459 return baseset([e[-1] for e in l])
1460
1460
1461 def _stringmatcher(pattern):
1461 def _stringmatcher(pattern):
1462 """
1462 """
1463 accepts a string, possibly starting with 're:' or 'literal:' prefix.
1463 accepts a string, possibly starting with 're:' or 'literal:' prefix.
1464 returns the matcher name, pattern, and matcher function.
1464 returns the matcher name, pattern, and matcher function.
1465 missing or unknown prefixes are treated as literal matches.
1465 missing or unknown prefixes are treated as literal matches.
1466
1466
1467 helper for tests:
1467 helper for tests:
1468 >>> def test(pattern, *tests):
1468 >>> def test(pattern, *tests):
1469 ... kind, pattern, matcher = _stringmatcher(pattern)
1469 ... kind, pattern, matcher = _stringmatcher(pattern)
1470 ... return (kind, pattern, [bool(matcher(t)) for t in tests])
1470 ... return (kind, pattern, [bool(matcher(t)) for t in tests])
1471
1471
1472 exact matching (no prefix):
1472 exact matching (no prefix):
1473 >>> test('abcdefg', 'abc', 'def', 'abcdefg')
1473 >>> test('abcdefg', 'abc', 'def', 'abcdefg')
1474 ('literal', 'abcdefg', [False, False, True])
1474 ('literal', 'abcdefg', [False, False, True])
1475
1475
1476 regex matching ('re:' prefix)
1476 regex matching ('re:' prefix)
1477 >>> test('re:a.+b', 'nomatch', 'fooadef', 'fooadefbar')
1477 >>> test('re:a.+b', 'nomatch', 'fooadef', 'fooadefbar')
1478 ('re', 'a.+b', [False, False, True])
1478 ('re', 'a.+b', [False, False, True])
1479
1479
1480 force exact matches ('literal:' prefix)
1480 force exact matches ('literal:' prefix)
1481 >>> test('literal:re:foobar', 'foobar', 're:foobar')
1481 >>> test('literal:re:foobar', 'foobar', 're:foobar')
1482 ('literal', 're:foobar', [False, True])
1482 ('literal', 're:foobar', [False, True])
1483
1483
1484 unknown prefixes are ignored and treated as literals
1484 unknown prefixes are ignored and treated as literals
1485 >>> test('foo:bar', 'foo', 'bar', 'foo:bar')
1485 >>> test('foo:bar', 'foo', 'bar', 'foo:bar')
1486 ('literal', 'foo:bar', [False, False, True])
1486 ('literal', 'foo:bar', [False, False, True])
1487 """
1487 """
1488 if pattern.startswith('re:'):
1488 if pattern.startswith('re:'):
1489 pattern = pattern[3:]
1489 pattern = pattern[3:]
1490 try:
1490 try:
1491 regex = re.compile(pattern)
1491 regex = re.compile(pattern)
1492 except re.error, e:
1492 except re.error, e:
1493 raise error.ParseError(_('invalid regular expression: %s')
1493 raise error.ParseError(_('invalid regular expression: %s')
1494 % e)
1494 % e)
1495 return 're', pattern, regex.search
1495 return 're', pattern, regex.search
1496 elif pattern.startswith('literal:'):
1496 elif pattern.startswith('literal:'):
1497 pattern = pattern[8:]
1497 pattern = pattern[8:]
1498 return 'literal', pattern, pattern.__eq__
1498 return 'literal', pattern, pattern.__eq__
1499
1499
1500 def _substringmatcher(pattern):
1500 def _substringmatcher(pattern):
1501 kind, pattern, matcher = _stringmatcher(pattern)
1501 kind, pattern, matcher = _stringmatcher(pattern)
1502 if kind == 'literal':
1502 if kind == 'literal':
1503 matcher = lambda s: pattern in s
1503 matcher = lambda s: pattern in s
1504 return kind, pattern, matcher
1504 return kind, pattern, matcher
1505
1505
1506 def tag(repo, subset, x):
1506 def tag(repo, subset, x):
1507 """``tag([name])``
1507 """``tag([name])``
1508 The specified tag by name, or all tagged revisions if no name is given.
1508 The specified tag by name, or all tagged revisions if no name is given.
1509 """
1509 """
1510 # i18n: "tag" is a keyword
1510 # i18n: "tag" is a keyword
1511 args = getargs(x, 0, 1, _("tag takes one or no arguments"))
1511 args = getargs(x, 0, 1, _("tag takes one or no arguments"))
1512 cl = repo.changelog
1512 cl = repo.changelog
1513 if args:
1513 if args:
1514 pattern = getstring(args[0],
1514 pattern = getstring(args[0],
1515 # i18n: "tag" is a keyword
1515 # i18n: "tag" is a keyword
1516 _('the argument to tag must be a string'))
1516 _('the argument to tag must be a string'))
1517 kind, pattern, matcher = _stringmatcher(pattern)
1517 kind, pattern, matcher = _stringmatcher(pattern)
1518 if kind == 'literal':
1518 if kind == 'literal':
1519 # avoid resolving all tags
1519 # avoid resolving all tags
1520 tn = repo._tagscache.tags.get(pattern, None)
1520 tn = repo._tagscache.tags.get(pattern, None)
1521 if tn is None:
1521 if tn is None:
1522 raise util.Abort(_("tag '%s' does not exist") % pattern)
1522 raise util.Abort(_("tag '%s' does not exist") % pattern)
1523 s = set([repo[tn].rev()])
1523 s = set([repo[tn].rev()])
1524 else:
1524 else:
1525 s = set([cl.rev(n) for t, n in repo.tagslist() if matcher(t)])
1525 s = set([cl.rev(n) for t, n in repo.tagslist() if matcher(t)])
1526 else:
1526 else:
1527 s = set([cl.rev(n) for t, n in repo.tagslist() if t != 'tip'])
1527 s = set([cl.rev(n) for t, n in repo.tagslist() if t != 'tip'])
1528 return subset & s
1528 return subset & s
1529
1529
1530 def tagged(repo, subset, x):
1530 def tagged(repo, subset, x):
1531 return tag(repo, subset, x)
1531 return tag(repo, subset, x)
1532
1532
1533 def unstable(repo, subset, x):
1533 def unstable(repo, subset, x):
1534 """``unstable()``
1534 """``unstable()``
1535 Non-obsolete changesets with obsolete ancestors.
1535 Non-obsolete changesets with obsolete ancestors.
1536 """
1536 """
1537 # i18n: "unstable" is a keyword
1537 # i18n: "unstable" is a keyword
1538 getargs(x, 0, 0, _("unstable takes no arguments"))
1538 getargs(x, 0, 0, _("unstable takes no arguments"))
1539 unstables = obsmod.getrevs(repo, 'unstable')
1539 unstables = obsmod.getrevs(repo, 'unstable')
1540 return subset & unstables
1540 return subset & unstables
1541
1541
1542
1542
1543 def user(repo, subset, x):
1543 def user(repo, subset, x):
1544 """``user(string)``
1544 """``user(string)``
1545 User name contains string. The match is case-insensitive.
1545 User name contains string. The match is case-insensitive.
1546
1546
1547 If `string` starts with `re:`, the remainder of the string is treated as
1547 If `string` starts with `re:`, the remainder of the string is treated as
1548 a regular expression. To match a user that actually contains `re:`, use
1548 a regular expression. To match a user that actually contains `re:`, use
1549 the prefix `literal:`.
1549 the prefix `literal:`.
1550 """
1550 """
1551 return author(repo, subset, x)
1551 return author(repo, subset, x)
1552
1552
1553 # for internal use
1553 # for internal use
1554 def _list(repo, subset, x):
1554 def _list(repo, subset, x):
1555 s = getstring(x, "internal error")
1555 s = getstring(x, "internal error")
1556 if not s:
1556 if not s:
1557 return baseset([])
1557 return baseset([])
1558 ls = [repo[r].rev() for r in s.split('\0')]
1558 ls = [repo[r].rev() for r in s.split('\0')]
1559 s = subset.set()
1559 s = subset.set()
1560 return baseset([r for r in ls if r in s])
1560 return baseset([r for r in ls if r in s])
1561
1561
1562 symbols = {
1562 symbols = {
1563 "adds": adds,
1563 "adds": adds,
1564 "all": getall,
1564 "all": getall,
1565 "ancestor": ancestor,
1565 "ancestor": ancestor,
1566 "ancestors": ancestors,
1566 "ancestors": ancestors,
1567 "_firstancestors": _firstancestors,
1567 "_firstancestors": _firstancestors,
1568 "author": author,
1568 "author": author,
1569 "bisect": bisect,
1569 "bisect": bisect,
1570 "bisected": bisected,
1570 "bisected": bisected,
1571 "bookmark": bookmark,
1571 "bookmark": bookmark,
1572 "branch": branch,
1572 "branch": branch,
1573 "branchpoint": branchpoint,
1573 "branchpoint": branchpoint,
1574 "bumped": bumped,
1574 "bumped": bumped,
1575 "bundle": bundle,
1575 "bundle": bundle,
1576 "children": children,
1576 "children": children,
1577 "closed": closed,
1577 "closed": closed,
1578 "contains": contains,
1578 "contains": contains,
1579 "converted": converted,
1579 "converted": converted,
1580 "date": date,
1580 "date": date,
1581 "desc": desc,
1581 "desc": desc,
1582 "descendants": descendants,
1582 "descendants": descendants,
1583 "_firstdescendants": _firstdescendants,
1583 "_firstdescendants": _firstdescendants,
1584 "destination": destination,
1584 "destination": destination,
1585 "divergent": divergent,
1585 "divergent": divergent,
1586 "draft": draft,
1586 "draft": draft,
1587 "extinct": extinct,
1587 "extinct": extinct,
1588 "extra": extra,
1588 "extra": extra,
1589 "file": hasfile,
1589 "file": hasfile,
1590 "filelog": filelog,
1590 "filelog": filelog,
1591 "first": first,
1591 "first": first,
1592 "follow": follow,
1592 "follow": follow,
1593 "_followfirst": _followfirst,
1593 "_followfirst": _followfirst,
1594 "grep": grep,
1594 "grep": grep,
1595 "head": head,
1595 "head": head,
1596 "heads": heads,
1596 "heads": heads,
1597 "hidden": hidden,
1597 "hidden": hidden,
1598 "id": node_,
1598 "id": node_,
1599 "keyword": keyword,
1599 "keyword": keyword,
1600 "last": last,
1600 "last": last,
1601 "limit": limit,
1601 "limit": limit,
1602 "_matchfiles": _matchfiles,
1602 "_matchfiles": _matchfiles,
1603 "max": maxrev,
1603 "max": maxrev,
1604 "merge": merge,
1604 "merge": merge,
1605 "min": minrev,
1605 "min": minrev,
1606 "modifies": modifies,
1606 "modifies": modifies,
1607 "obsolete": obsolete,
1607 "obsolete": obsolete,
1608 "origin": origin,
1608 "origin": origin,
1609 "outgoing": outgoing,
1609 "outgoing": outgoing,
1610 "p1": p1,
1610 "p1": p1,
1611 "p2": p2,
1611 "p2": p2,
1612 "parents": parents,
1612 "parents": parents,
1613 "present": present,
1613 "present": present,
1614 "public": public,
1614 "public": public,
1615 "remote": remote,
1615 "remote": remote,
1616 "removes": removes,
1616 "removes": removes,
1617 "rev": rev,
1617 "rev": rev,
1618 "reverse": reverse,
1618 "reverse": reverse,
1619 "roots": roots,
1619 "roots": roots,
1620 "sort": sort,
1620 "sort": sort,
1621 "secret": secret,
1621 "secret": secret,
1622 "matching": matching,
1622 "matching": matching,
1623 "tag": tag,
1623 "tag": tag,
1624 "tagged": tagged,
1624 "tagged": tagged,
1625 "user": user,
1625 "user": user,
1626 "unstable": unstable,
1626 "unstable": unstable,
1627 "_list": _list,
1627 "_list": _list,
1628 }
1628 }
1629
1629
1630 # symbols which can't be used for a DoS attack for any given input
1630 # symbols which can't be used for a DoS attack for any given input
1631 # (e.g. those which accept regexes as plain strings shouldn't be included)
1631 # (e.g. those which accept regexes as plain strings shouldn't be included)
1632 # functions that just return a lot of changesets (like all) don't count here
1632 # functions that just return a lot of changesets (like all) don't count here
1633 safesymbols = set([
1633 safesymbols = set([
1634 "adds",
1634 "adds",
1635 "all",
1635 "all",
1636 "ancestor",
1636 "ancestor",
1637 "ancestors",
1637 "ancestors",
1638 "_firstancestors",
1638 "_firstancestors",
1639 "author",
1639 "author",
1640 "bisect",
1640 "bisect",
1641 "bisected",
1641 "bisected",
1642 "bookmark",
1642 "bookmark",
1643 "branch",
1643 "branch",
1644 "branchpoint",
1644 "branchpoint",
1645 "bumped",
1645 "bumped",
1646 "bundle",
1646 "bundle",
1647 "children",
1647 "children",
1648 "closed",
1648 "closed",
1649 "converted",
1649 "converted",
1650 "date",
1650 "date",
1651 "desc",
1651 "desc",
1652 "descendants",
1652 "descendants",
1653 "_firstdescendants",
1653 "_firstdescendants",
1654 "destination",
1654 "destination",
1655 "divergent",
1655 "divergent",
1656 "draft",
1656 "draft",
1657 "extinct",
1657 "extinct",
1658 "extra",
1658 "extra",
1659 "file",
1659 "file",
1660 "filelog",
1660 "filelog",
1661 "first",
1661 "first",
1662 "follow",
1662 "follow",
1663 "_followfirst",
1663 "_followfirst",
1664 "head",
1664 "head",
1665 "heads",
1665 "heads",
1666 "hidden",
1666 "hidden",
1667 "id",
1667 "id",
1668 "keyword",
1668 "keyword",
1669 "last",
1669 "last",
1670 "limit",
1670 "limit",
1671 "_matchfiles",
1671 "_matchfiles",
1672 "max",
1672 "max",
1673 "merge",
1673 "merge",
1674 "min",
1674 "min",
1675 "modifies",
1675 "modifies",
1676 "obsolete",
1676 "obsolete",
1677 "origin",
1677 "origin",
1678 "outgoing",
1678 "outgoing",
1679 "p1",
1679 "p1",
1680 "p2",
1680 "p2",
1681 "parents",
1681 "parents",
1682 "present",
1682 "present",
1683 "public",
1683 "public",
1684 "remote",
1684 "remote",
1685 "removes",
1685 "removes",
1686 "rev",
1686 "rev",
1687 "reverse",
1687 "reverse",
1688 "roots",
1688 "roots",
1689 "sort",
1689 "sort",
1690 "secret",
1690 "secret",
1691 "matching",
1691 "matching",
1692 "tag",
1692 "tag",
1693 "tagged",
1693 "tagged",
1694 "user",
1694 "user",
1695 "unstable",
1695 "unstable",
1696 "_list",
1696 "_list",
1697 ])
1697 ])
1698
1698
1699 methods = {
1699 methods = {
1700 "range": rangeset,
1700 "range": rangeset,
1701 "dagrange": dagrange,
1701 "dagrange": dagrange,
1702 "string": stringset,
1702 "string": stringset,
1703 "symbol": symbolset,
1703 "symbol": symbolset,
1704 "and": andset,
1704 "and": andset,
1705 "or": orset,
1705 "or": orset,
1706 "not": notset,
1706 "not": notset,
1707 "list": listset,
1707 "list": listset,
1708 "func": func,
1708 "func": func,
1709 "ancestor": ancestorspec,
1709 "ancestor": ancestorspec,
1710 "parent": parentspec,
1710 "parent": parentspec,
1711 "parentpost": p1,
1711 "parentpost": p1,
1712 }
1712 }
1713
1713
1714 def optimize(x, small):
1714 def optimize(x, small):
1715 if x is None:
1715 if x is None:
1716 return 0, x
1716 return 0, x
1717
1717
1718 smallbonus = 1
1718 smallbonus = 1
1719 if small:
1719 if small:
1720 smallbonus = .5
1720 smallbonus = .5
1721
1721
1722 op = x[0]
1722 op = x[0]
1723 if op == 'minus':
1723 if op == 'minus':
1724 return optimize(('and', x[1], ('not', x[2])), small)
1724 return optimize(('and', x[1], ('not', x[2])), small)
1725 elif op == 'dagrangepre':
1725 elif op == 'dagrangepre':
1726 return optimize(('func', ('symbol', 'ancestors'), x[1]), small)
1726 return optimize(('func', ('symbol', 'ancestors'), x[1]), small)
1727 elif op == 'dagrangepost':
1727 elif op == 'dagrangepost':
1728 return optimize(('func', ('symbol', 'descendants'), x[1]), small)
1728 return optimize(('func', ('symbol', 'descendants'), x[1]), small)
1729 elif op == 'rangepre':
1729 elif op == 'rangepre':
1730 return optimize(('range', ('string', '0'), x[1]), small)
1730 return optimize(('range', ('string', '0'), x[1]), small)
1731 elif op == 'rangepost':
1731 elif op == 'rangepost':
1732 return optimize(('range', x[1], ('string', 'tip')), small)
1732 return optimize(('range', x[1], ('string', 'tip')), small)
1733 elif op == 'negate':
1733 elif op == 'negate':
1734 return optimize(('string',
1734 return optimize(('string',
1735 '-' + getstring(x[1], _("can't negate that"))), small)
1735 '-' + getstring(x[1], _("can't negate that"))), small)
1736 elif op in 'string symbol negate':
1736 elif op in 'string symbol negate':
1737 return smallbonus, x # single revisions are small
1737 return smallbonus, x # single revisions are small
1738 elif op == 'and':
1738 elif op == 'and':
1739 wa, ta = optimize(x[1], True)
1739 wa, ta = optimize(x[1], True)
1740 wb, tb = optimize(x[2], True)
1740 wb, tb = optimize(x[2], True)
1741 w = min(wa, wb)
1741 w = min(wa, wb)
1742 if wa > wb:
1742 if wa > wb:
1743 return w, (op, tb, ta)
1743 return w, (op, tb, ta)
1744 return w, (op, ta, tb)
1744 return w, (op, ta, tb)
1745 elif op == 'or':
1745 elif op == 'or':
1746 wa, ta = optimize(x[1], False)
1746 wa, ta = optimize(x[1], False)
1747 wb, tb = optimize(x[2], False)
1747 wb, tb = optimize(x[2], False)
1748 if wb < wa:
1748 if wb < wa:
1749 wb, wa = wa, wb
1749 wb, wa = wa, wb
1750 return max(wa, wb), (op, ta, tb)
1750 return max(wa, wb), (op, ta, tb)
1751 elif op == 'not':
1751 elif op == 'not':
1752 o = optimize(x[1], not small)
1752 o = optimize(x[1], not small)
1753 return o[0], (op, o[1])
1753 return o[0], (op, o[1])
1754 elif op == 'parentpost':
1754 elif op == 'parentpost':
1755 o = optimize(x[1], small)
1755 o = optimize(x[1], small)
1756 return o[0], (op, o[1])
1756 return o[0], (op, o[1])
1757 elif op == 'group':
1757 elif op == 'group':
1758 return optimize(x[1], small)
1758 return optimize(x[1], small)
1759 elif op in 'dagrange range list parent ancestorspec':
1759 elif op in 'dagrange range list parent ancestorspec':
1760 if op == 'parent':
1760 if op == 'parent':
1761 # x^:y means (x^) : y, not x ^ (:y)
1761 # x^:y means (x^) : y, not x ^ (:y)
1762 post = ('parentpost', x[1])
1762 post = ('parentpost', x[1])
1763 if x[2][0] == 'dagrangepre':
1763 if x[2][0] == 'dagrangepre':
1764 return optimize(('dagrange', post, x[2][1]), small)
1764 return optimize(('dagrange', post, x[2][1]), small)
1765 elif x[2][0] == 'rangepre':
1765 elif x[2][0] == 'rangepre':
1766 return optimize(('range', post, x[2][1]), small)
1766 return optimize(('range', post, x[2][1]), small)
1767
1767
1768 wa, ta = optimize(x[1], small)
1768 wa, ta = optimize(x[1], small)
1769 wb, tb = optimize(x[2], small)
1769 wb, tb = optimize(x[2], small)
1770 return wa + wb, (op, ta, tb)
1770 return wa + wb, (op, ta, tb)
1771 elif op == 'func':
1771 elif op == 'func':
1772 f = getstring(x[1], _("not a symbol"))
1772 f = getstring(x[1], _("not a symbol"))
1773 wa, ta = optimize(x[2], small)
1773 wa, ta = optimize(x[2], small)
1774 if f in ("author branch closed date desc file grep keyword "
1774 if f in ("author branch closed date desc file grep keyword "
1775 "outgoing user"):
1775 "outgoing user"):
1776 w = 10 # slow
1776 w = 10 # slow
1777 elif f in "modifies adds removes":
1777 elif f in "modifies adds removes":
1778 w = 30 # slower
1778 w = 30 # slower
1779 elif f == "contains":
1779 elif f == "contains":
1780 w = 100 # very slow
1780 w = 100 # very slow
1781 elif f == "ancestor":
1781 elif f == "ancestor":
1782 w = 1 * smallbonus
1782 w = 1 * smallbonus
1783 elif f in "reverse limit first":
1783 elif f in "reverse limit first":
1784 w = 0
1784 w = 0
1785 elif f in "sort":
1785 elif f in "sort":
1786 w = 10 # assume most sorts look at changelog
1786 w = 10 # assume most sorts look at changelog
1787 else:
1787 else:
1788 w = 1
1788 w = 1
1789 return w + wa, (op, x[1], ta)
1789 return w + wa, (op, x[1], ta)
1790 return 1, x
1790 return 1, x
1791
1791
1792 _aliasarg = ('func', ('symbol', '_aliasarg'))
1792 _aliasarg = ('func', ('symbol', '_aliasarg'))
1793 def _getaliasarg(tree):
1793 def _getaliasarg(tree):
1794 """If tree matches ('func', ('symbol', '_aliasarg'), ('string', X))
1794 """If tree matches ('func', ('symbol', '_aliasarg'), ('string', X))
1795 return X, None otherwise.
1795 return X, None otherwise.
1796 """
1796 """
1797 if (len(tree) == 3 and tree[:2] == _aliasarg
1797 if (len(tree) == 3 and tree[:2] == _aliasarg
1798 and tree[2][0] == 'string'):
1798 and tree[2][0] == 'string'):
1799 return tree[2][1]
1799 return tree[2][1]
1800 return None
1800 return None
1801
1801
1802 def _checkaliasarg(tree, known=None):
1802 def _checkaliasarg(tree, known=None):
1803 """Check tree contains no _aliasarg construct or only ones which
1803 """Check tree contains no _aliasarg construct or only ones which
1804 value is in known. Used to avoid alias placeholders injection.
1804 value is in known. Used to avoid alias placeholders injection.
1805 """
1805 """
1806 if isinstance(tree, tuple):
1806 if isinstance(tree, tuple):
1807 arg = _getaliasarg(tree)
1807 arg = _getaliasarg(tree)
1808 if arg is not None and (not known or arg not in known):
1808 if arg is not None and (not known or arg not in known):
1809 raise error.ParseError(_("not a function: %s") % '_aliasarg')
1809 raise error.ParseError(_("not a function: %s") % '_aliasarg')
1810 for t in tree:
1810 for t in tree:
1811 _checkaliasarg(t, known)
1811 _checkaliasarg(t, known)
1812
1812
1813 class revsetalias(object):
1813 class revsetalias(object):
1814 funcre = re.compile('^([^(]+)\(([^)]+)\)$')
1814 funcre = re.compile('^([^(]+)\(([^)]+)\)$')
1815 args = None
1815 args = None
1816
1816
1817 def __init__(self, name, value):
1817 def __init__(self, name, value):
1818 '''Aliases like:
1818 '''Aliases like:
1819
1819
1820 h = heads(default)
1820 h = heads(default)
1821 b($1) = ancestors($1) - ancestors(default)
1821 b($1) = ancestors($1) - ancestors(default)
1822 '''
1822 '''
1823 m = self.funcre.search(name)
1823 m = self.funcre.search(name)
1824 if m:
1824 if m:
1825 self.name = m.group(1)
1825 self.name = m.group(1)
1826 self.tree = ('func', ('symbol', m.group(1)))
1826 self.tree = ('func', ('symbol', m.group(1)))
1827 self.args = [x.strip() for x in m.group(2).split(',')]
1827 self.args = [x.strip() for x in m.group(2).split(',')]
1828 for arg in self.args:
1828 for arg in self.args:
1829 # _aliasarg() is an unknown symbol only used separate
1829 # _aliasarg() is an unknown symbol only used separate
1830 # alias argument placeholders from regular strings.
1830 # alias argument placeholders from regular strings.
1831 value = value.replace(arg, '_aliasarg(%r)' % (arg,))
1831 value = value.replace(arg, '_aliasarg(%r)' % (arg,))
1832 else:
1832 else:
1833 self.name = name
1833 self.name = name
1834 self.tree = ('symbol', name)
1834 self.tree = ('symbol', name)
1835
1835
1836 self.replacement, pos = parse(value)
1836 self.replacement, pos = parse(value)
1837 if pos != len(value):
1837 if pos != len(value):
1838 raise error.ParseError(_('invalid token'), pos)
1838 raise error.ParseError(_('invalid token'), pos)
1839 # Check for placeholder injection
1839 # Check for placeholder injection
1840 _checkaliasarg(self.replacement, self.args)
1840 _checkaliasarg(self.replacement, self.args)
1841
1841
1842 def _getalias(aliases, tree):
1842 def _getalias(aliases, tree):
1843 """If tree looks like an unexpanded alias, return it. Return None
1843 """If tree looks like an unexpanded alias, return it. Return None
1844 otherwise.
1844 otherwise.
1845 """
1845 """
1846 if isinstance(tree, tuple) and tree:
1846 if isinstance(tree, tuple) and tree:
1847 if tree[0] == 'symbol' and len(tree) == 2:
1847 if tree[0] == 'symbol' and len(tree) == 2:
1848 name = tree[1]
1848 name = tree[1]
1849 alias = aliases.get(name)
1849 alias = aliases.get(name)
1850 if alias and alias.args is None and alias.tree == tree:
1850 if alias and alias.args is None and alias.tree == tree:
1851 return alias
1851 return alias
1852 if tree[0] == 'func' and len(tree) > 1:
1852 if tree[0] == 'func' and len(tree) > 1:
1853 if tree[1][0] == 'symbol' and len(tree[1]) == 2:
1853 if tree[1][0] == 'symbol' and len(tree[1]) == 2:
1854 name = tree[1][1]
1854 name = tree[1][1]
1855 alias = aliases.get(name)
1855 alias = aliases.get(name)
1856 if alias and alias.args is not None and alias.tree == tree[:2]:
1856 if alias and alias.args is not None and alias.tree == tree[:2]:
1857 return alias
1857 return alias
1858 return None
1858 return None
1859
1859
1860 def _expandargs(tree, args):
1860 def _expandargs(tree, args):
1861 """Replace _aliasarg instances with the substitution value of the
1861 """Replace _aliasarg instances with the substitution value of the
1862 same name in args, recursively.
1862 same name in args, recursively.
1863 """
1863 """
1864 if not tree or not isinstance(tree, tuple):
1864 if not tree or not isinstance(tree, tuple):
1865 return tree
1865 return tree
1866 arg = _getaliasarg(tree)
1866 arg = _getaliasarg(tree)
1867 if arg is not None:
1867 if arg is not None:
1868 return args[arg]
1868 return args[arg]
1869 return tuple(_expandargs(t, args) for t in tree)
1869 return tuple(_expandargs(t, args) for t in tree)
1870
1870
1871 def _expandaliases(aliases, tree, expanding, cache):
1871 def _expandaliases(aliases, tree, expanding, cache):
1872 """Expand aliases in tree, recursively.
1872 """Expand aliases in tree, recursively.
1873
1873
1874 'aliases' is a dictionary mapping user defined aliases to
1874 'aliases' is a dictionary mapping user defined aliases to
1875 revsetalias objects.
1875 revsetalias objects.
1876 """
1876 """
1877 if not isinstance(tree, tuple):
1877 if not isinstance(tree, tuple):
1878 # Do not expand raw strings
1878 # Do not expand raw strings
1879 return tree
1879 return tree
1880 alias = _getalias(aliases, tree)
1880 alias = _getalias(aliases, tree)
1881 if alias is not None:
1881 if alias is not None:
1882 if alias in expanding:
1882 if alias in expanding:
1883 raise error.ParseError(_('infinite expansion of revset alias "%s" '
1883 raise error.ParseError(_('infinite expansion of revset alias "%s" '
1884 'detected') % alias.name)
1884 'detected') % alias.name)
1885 expanding.append(alias)
1885 expanding.append(alias)
1886 if alias.name not in cache:
1886 if alias.name not in cache:
1887 cache[alias.name] = _expandaliases(aliases, alias.replacement,
1887 cache[alias.name] = _expandaliases(aliases, alias.replacement,
1888 expanding, cache)
1888 expanding, cache)
1889 result = cache[alias.name]
1889 result = cache[alias.name]
1890 expanding.pop()
1890 expanding.pop()
1891 if alias.args is not None:
1891 if alias.args is not None:
1892 l = getlist(tree[2])
1892 l = getlist(tree[2])
1893 if len(l) != len(alias.args):
1893 if len(l) != len(alias.args):
1894 raise error.ParseError(
1894 raise error.ParseError(
1895 _('invalid number of arguments: %s') % len(l))
1895 _('invalid number of arguments: %s') % len(l))
1896 l = [_expandaliases(aliases, a, [], cache) for a in l]
1896 l = [_expandaliases(aliases, a, [], cache) for a in l]
1897 result = _expandargs(result, dict(zip(alias.args, l)))
1897 result = _expandargs(result, dict(zip(alias.args, l)))
1898 else:
1898 else:
1899 result = tuple(_expandaliases(aliases, t, expanding, cache)
1899 result = tuple(_expandaliases(aliases, t, expanding, cache)
1900 for t in tree)
1900 for t in tree)
1901 return result
1901 return result
1902
1902
1903 def findaliases(ui, tree):
1903 def findaliases(ui, tree):
1904 _checkaliasarg(tree)
1904 _checkaliasarg(tree)
1905 aliases = {}
1905 aliases = {}
1906 for k, v in ui.configitems('revsetalias'):
1906 for k, v in ui.configitems('revsetalias'):
1907 alias = revsetalias(k, v)
1907 alias = revsetalias(k, v)
1908 aliases[alias.name] = alias
1908 aliases[alias.name] = alias
1909 return _expandaliases(aliases, tree, [], {})
1909 return _expandaliases(aliases, tree, [], {})
1910
1910
1911 def parse(spec):
1911 def parse(spec):
1912 p = parser.parser(tokenize, elements)
1912 p = parser.parser(tokenize, elements)
1913 return p.parse(spec)
1913 return p.parse(spec)
1914
1914
1915 def match(ui, spec):
1915 def match(ui, spec):
1916 if not spec:
1916 if not spec:
1917 raise error.ParseError(_("empty query"))
1917 raise error.ParseError(_("empty query"))
1918 tree, pos = parse(spec)
1918 tree, pos = parse(spec)
1919 if (pos != len(spec)):
1919 if (pos != len(spec)):
1920 raise error.ParseError(_("invalid token"), pos)
1920 raise error.ParseError(_("invalid token"), pos)
1921 if ui:
1921 if ui:
1922 tree = findaliases(ui, tree)
1922 tree = findaliases(ui, tree)
1923 weight, tree = optimize(tree, True)
1923 weight, tree = optimize(tree, True)
1924 def mfunc(repo, subset):
1924 def mfunc(repo, subset):
1925 return getset(repo, subset, tree)
1925 return getset(repo, subset, tree)
1926 return mfunc
1926 return mfunc
1927
1927
1928 def formatspec(expr, *args):
1928 def formatspec(expr, *args):
1929 '''
1929 '''
1930 This is a convenience function for using revsets internally, and
1930 This is a convenience function for using revsets internally, and
1931 escapes arguments appropriately. Aliases are intentionally ignored
1931 escapes arguments appropriately. Aliases are intentionally ignored
1932 so that intended expression behavior isn't accidentally subverted.
1932 so that intended expression behavior isn't accidentally subverted.
1933
1933
1934 Supported arguments:
1934 Supported arguments:
1935
1935
1936 %r = revset expression, parenthesized
1936 %r = revset expression, parenthesized
1937 %d = int(arg), no quoting
1937 %d = int(arg), no quoting
1938 %s = string(arg), escaped and single-quoted
1938 %s = string(arg), escaped and single-quoted
1939 %b = arg.branch(), escaped and single-quoted
1939 %b = arg.branch(), escaped and single-quoted
1940 %n = hex(arg), single-quoted
1940 %n = hex(arg), single-quoted
1941 %% = a literal '%'
1941 %% = a literal '%'
1942
1942
1943 Prefixing the type with 'l' specifies a parenthesized list of that type.
1943 Prefixing the type with 'l' specifies a parenthesized list of that type.
1944
1944
1945 >>> formatspec('%r:: and %lr', '10 or 11', ("this()", "that()"))
1945 >>> formatspec('%r:: and %lr', '10 or 11', ("this()", "that()"))
1946 '(10 or 11):: and ((this()) or (that()))'
1946 '(10 or 11):: and ((this()) or (that()))'
1947 >>> formatspec('%d:: and not %d::', 10, 20)
1947 >>> formatspec('%d:: and not %d::', 10, 20)
1948 '10:: and not 20::'
1948 '10:: and not 20::'
1949 >>> formatspec('%ld or %ld', [], [1])
1949 >>> formatspec('%ld or %ld', [], [1])
1950 "_list('') or 1"
1950 "_list('') or 1"
1951 >>> formatspec('keyword(%s)', 'foo\\xe9')
1951 >>> formatspec('keyword(%s)', 'foo\\xe9')
1952 "keyword('foo\\\\xe9')"
1952 "keyword('foo\\\\xe9')"
1953 >>> b = lambda: 'default'
1953 >>> b = lambda: 'default'
1954 >>> b.branch = b
1954 >>> b.branch = b
1955 >>> formatspec('branch(%b)', b)
1955 >>> formatspec('branch(%b)', b)
1956 "branch('default')"
1956 "branch('default')"
1957 >>> formatspec('root(%ls)', ['a', 'b', 'c', 'd'])
1957 >>> formatspec('root(%ls)', ['a', 'b', 'c', 'd'])
1958 "root(_list('a\\x00b\\x00c\\x00d'))"
1958 "root(_list('a\\x00b\\x00c\\x00d'))"
1959 '''
1959 '''
1960
1960
1961 def quote(s):
1961 def quote(s):
1962 return repr(str(s))
1962 return repr(str(s))
1963
1963
1964 def argtype(c, arg):
1964 def argtype(c, arg):
1965 if c == 'd':
1965 if c == 'd':
1966 return str(int(arg))
1966 return str(int(arg))
1967 elif c == 's':
1967 elif c == 's':
1968 return quote(arg)
1968 return quote(arg)
1969 elif c == 'r':
1969 elif c == 'r':
1970 parse(arg) # make sure syntax errors are confined
1970 parse(arg) # make sure syntax errors are confined
1971 return '(%s)' % arg
1971 return '(%s)' % arg
1972 elif c == 'n':
1972 elif c == 'n':
1973 return quote(node.hex(arg))
1973 return quote(node.hex(arg))
1974 elif c == 'b':
1974 elif c == 'b':
1975 return quote(arg.branch())
1975 return quote(arg.branch())
1976
1976
1977 def listexp(s, t):
1977 def listexp(s, t):
1978 l = len(s)
1978 l = len(s)
1979 if l == 0:
1979 if l == 0:
1980 return "_list('')"
1980 return "_list('')"
1981 elif l == 1:
1981 elif l == 1:
1982 return argtype(t, s[0])
1982 return argtype(t, s[0])
1983 elif t == 'd':
1983 elif t == 'd':
1984 return "_list('%s')" % "\0".join(str(int(a)) for a in s)
1984 return "_list('%s')" % "\0".join(str(int(a)) for a in s)
1985 elif t == 's':
1985 elif t == 's':
1986 return "_list('%s')" % "\0".join(s)
1986 return "_list('%s')" % "\0".join(s)
1987 elif t == 'n':
1987 elif t == 'n':
1988 return "_list('%s')" % "\0".join(node.hex(a) for a in s)
1988 return "_list('%s')" % "\0".join(node.hex(a) for a in s)
1989 elif t == 'b':
1989 elif t == 'b':
1990 return "_list('%s')" % "\0".join(a.branch() for a in s)
1990 return "_list('%s')" % "\0".join(a.branch() for a in s)
1991
1991
1992 m = l // 2
1992 m = l // 2
1993 return '(%s or %s)' % (listexp(s[:m], t), listexp(s[m:], t))
1993 return '(%s or %s)' % (listexp(s[:m], t), listexp(s[m:], t))
1994
1994
1995 ret = ''
1995 ret = ''
1996 pos = 0
1996 pos = 0
1997 arg = 0
1997 arg = 0
1998 while pos < len(expr):
1998 while pos < len(expr):
1999 c = expr[pos]
1999 c = expr[pos]
2000 if c == '%':
2000 if c == '%':
2001 pos += 1
2001 pos += 1
2002 d = expr[pos]
2002 d = expr[pos]
2003 if d == '%':
2003 if d == '%':
2004 ret += d
2004 ret += d
2005 elif d in 'dsnbr':
2005 elif d in 'dsnbr':
2006 ret += argtype(d, args[arg])
2006 ret += argtype(d, args[arg])
2007 arg += 1
2007 arg += 1
2008 elif d == 'l':
2008 elif d == 'l':
2009 # a list of some type
2009 # a list of some type
2010 pos += 1
2010 pos += 1
2011 d = expr[pos]
2011 d = expr[pos]
2012 ret += listexp(list(args[arg]), d)
2012 ret += listexp(list(args[arg]), d)
2013 arg += 1
2013 arg += 1
2014 else:
2014 else:
2015 raise util.Abort('unexpected revspec format character %s' % d)
2015 raise util.Abort('unexpected revspec format character %s' % d)
2016 else:
2016 else:
2017 ret += c
2017 ret += c
2018 pos += 1
2018 pos += 1
2019
2019
2020 return ret
2020 return ret
2021
2021
2022 def prettyformat(tree):
2022 def prettyformat(tree):
2023 def _prettyformat(tree, level, lines):
2023 def _prettyformat(tree, level, lines):
2024 if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'):
2024 if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'):
2025 lines.append((level, str(tree)))
2025 lines.append((level, str(tree)))
2026 else:
2026 else:
2027 lines.append((level, '(%s' % tree[0]))
2027 lines.append((level, '(%s' % tree[0]))
2028 for s in tree[1:]:
2028 for s in tree[1:]:
2029 _prettyformat(s, level + 1, lines)
2029 _prettyformat(s, level + 1, lines)
2030 lines[-1:] = [(lines[-1][0], lines[-1][1] + ')')]
2030 lines[-1:] = [(lines[-1][0], lines[-1][1] + ')')]
2031
2031
2032 lines = []
2032 lines = []
2033 _prettyformat(tree, 0, lines)
2033 _prettyformat(tree, 0, lines)
2034 output = '\n'.join((' '*l + s) for l, s in lines)
2034 output = '\n'.join((' '*l + s) for l, s in lines)
2035 return output
2035 return output
2036
2036
2037 def depth(tree):
2037 def depth(tree):
2038 if isinstance(tree, tuple):
2038 if isinstance(tree, tuple):
2039 return max(map(depth, tree)) + 1
2039 return max(map(depth, tree)) + 1
2040 else:
2040 else:
2041 return 0
2041 return 0
2042
2042
2043 def funcsused(tree):
2043 def funcsused(tree):
2044 if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'):
2044 if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'):
2045 return set()
2045 return set()
2046 else:
2046 else:
2047 funcs = set()
2047 funcs = set()
2048 for s in tree[1:]:
2048 for s in tree[1:]:
2049 funcs |= funcsused(s)
2049 funcs |= funcsused(s)
2050 if tree[0] == 'func':
2050 if tree[0] == 'func':
2051 funcs.add(tree[1][1])
2051 funcs.add(tree[1][1])
2052 return funcs
2052 return funcs
2053
2053
2054 class baseset(list):
2054 class baseset(list):
2055 """Basic data structure that represents a revset and contains the basic
2055 """Basic data structure that represents a revset and contains the basic
2056 operation that it should be able to perform.
2056 operation that it should be able to perform.
2057 """
2057 """
2058 def __init__(self, data):
2058 def __init__(self, data):
2059 super(baseset, self).__init__(data)
2059 super(baseset, self).__init__(data)
2060 self._set = None
2060 self._set = None
2061
2061
2062 def set(self):
2062 def set(self):
2063 if not self._set:
2063 if not self._set:
2064 self._set = set(self)
2064 self._set = set(self)
2065 return self._set
2065 return self._set
2066
2066
2067 def __sub__(self, x):
2067 def __sub__(self, x):
2068 if isinstance(x, baseset):
2068 if isinstance(x, baseset):
2069 s = x.set()
2069 s = x.set()
2070 else:
2070 else:
2071 s = set(x)
2071 s = set(x)
2072 return baseset(self.set() - s)
2072 return baseset(self.set() - s)
2073
2073
2074 def __and__(self, x):
2074 def __and__(self, x):
2075 if isinstance(x, baseset):
2075 if isinstance(x, baseset):
2076 x = x.set()
2076 x = x.set()
2077 return baseset([y for y in self if y in x])
2077 return baseset([y for y in self if y in x])
2078
2078
2079 def __add__(self, x):
2079 def __add__(self, x):
2080 s = self.set()
2080 s = self.set()
2081 l = [r for r in x if r not in s]
2081 l = [r for r in x if r not in s]
2082 return baseset(list(self) + l)
2082 return baseset(list(self) + l)
2083
2083
2084 class lazyset(object):
2084 class lazyset(object):
2085 """Duck type for baseset class which iterates lazily over the revisions in
2085 """Duck type for baseset class which iterates lazily over the revisions in
2086 the subset and contains a function which tests for membership in the
2086 the subset and contains a function which tests for membership in the
2087 revset
2087 revset
2088 """
2088 """
2089 def __init__(self, subset, condition):
2089 def __init__(self, subset, condition):
2090 self._subset = subset
2090 self._subset = subset
2091 self._condition = condition
2091 self._condition = condition
2092
2092
2093 def __contains__(self, x):
2093 def __contains__(self, x):
2094 return x in self._subset and self._condition(x)
2094 return x in self._subset and self._condition(x)
2095
2095
2096 def __iter__(self):
2096 def __iter__(self):
2097 cond = self._condition
2097 cond = self._condition
2098 for x in self._subset:
2098 for x in self._subset:
2099 if cond(x):
2099 if cond(x):
2100 yield x
2100 yield x
2101
2101
2102 def __and__(self, x):
2102 def __and__(self, x):
2103 return lazyset(self, lambda r: r in x)
2103 return lazyset(self, lambda r: r in x)
2104
2104
2105 def __sub__(self, x):
2105 def __sub__(self, x):
2106 return lazyset(self, lambda r: r not in x)
2106 return lazyset(self, lambda r: r not in x)
2107
2107
2108 def __add__(self, x):
2108 def __add__(self, x):
2109 l = baseset([r for r in self])
2109 l = baseset([r for r in self])
2110 return l + baseset(x)
2110 return l + baseset(x)
2111
2111
2112 def __len__(self):
2112 def __len__(self):
2113 # Basic implementation to be changed in future patches.
2113 # Basic implementation to be changed in future patches.
2114 l = baseset([r for r in self])
2114 l = baseset([r for r in self])
2115 return len(l)
2115 return len(l)
2116
2116
2117 def __getitem__(self, x):
2117 def __getitem__(self, x):
2118 # Basic implementation to be changed in future patches.
2118 # Basic implementation to be changed in future patches.
2119 l = baseset([r for r in self])
2119 l = baseset([r for r in self])
2120 return l[x]
2120 return l[x]
2121
2121
2122 def sort(self, reverse=False):
2122 def sort(self, reverse=False):
2123 # Basic implementation to be changed in future patches.
2123 # Basic implementation to be changed in future patches.
2124 self._subset = baseset(self._subset)
2124 self._subset = baseset(self._subset)
2125 self._subset.sort(reverse=reverse)
2125 self._subset.sort(reverse=reverse)
2126
2126
2127 def reverse(self):
2127 def reverse(self):
2128 self._subset.reverse()
2128 self._subset.reverse()
2129
2129
2130 def set(self):
2130 def set(self):
2131 return set([r for r in self])
2131 return set([r for r in self])
2132
2132
2133 # tell hggettext to extract docstrings from these functions:
2133 # tell hggettext to extract docstrings from these functions:
2134 i18nfunctions = symbols.values()
2134 i18nfunctions = symbols.values()
General Comments 0
You need to be logged in to leave comments. Login now