##// END OF EJS Templates
revset: fix - handling in the optimizer
Matt Mackall -
r11283:a6356b26 default
parent child Browse files
Show More
@@ -1,553 +1,553 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, hg
9 import parser, util, hg
10 import match as _match
10 import match as _match
11
11
12 elements = {
12 elements = {
13 "(": (20, ("group", 1, ")"), ("func", 1, ")")),
13 "(": (20, ("group", 1, ")"), ("func", 1, ")")),
14 "-": (19, ("negate", 19), ("minus", 19)),
14 "-": (19, ("negate", 19), ("minus", 19)),
15 "::": (17, ("dagrangepre", 17), ("dagrange", 17),
15 "::": (17, ("dagrangepre", 17), ("dagrange", 17),
16 ("dagrangepost", 17)),
16 ("dagrangepost", 17)),
17 "..": (17, ("dagrangepre", 17), ("dagrange", 17),
17 "..": (17, ("dagrangepre", 17), ("dagrange", 17),
18 ("dagrangepost", 17)),
18 ("dagrangepost", 17)),
19 ":": (15, ("rangepre", 15), ("range", 15), ("rangepost", 15)),
19 ":": (15, ("rangepre", 15), ("range", 15), ("rangepost", 15)),
20 "not": (10, ("not", 10)),
20 "not": (10, ("not", 10)),
21 "!": (10, ("not", 10)),
21 "!": (10, ("not", 10)),
22 "and": (5, None, ("and", 5)),
22 "and": (5, None, ("and", 5)),
23 "&": (5, None, ("and", 5)),
23 "&": (5, None, ("and", 5)),
24 "or": (4, None, ("or", 4)),
24 "or": (4, None, ("or", 4)),
25 "|": (4, None, ("or", 4)),
25 "|": (4, None, ("or", 4)),
26 "+": (4, None, ("or", 4)),
26 "+": (4, None, ("or", 4)),
27 ",": (2, None, ("list", 2)),
27 ",": (2, None, ("list", 2)),
28 ")": (0, None, None),
28 ")": (0, None, None),
29 "symbol": (0, ("symbol",), None),
29 "symbol": (0, ("symbol",), None),
30 "string": (0, ("string",), None),
30 "string": (0, ("string",), None),
31 "end": (0, None, None),
31 "end": (0, None, None),
32 }
32 }
33
33
34 keywords = set(['and', 'or', 'not'])
34 keywords = set(['and', 'or', 'not'])
35
35
36 def tokenize(program):
36 def tokenize(program):
37 pos, l = 0, len(program)
37 pos, l = 0, len(program)
38 while pos < l:
38 while pos < l:
39 c = program[pos]
39 c = program[pos]
40 if c.isspace(): # skip inter-token whitespace
40 if c.isspace(): # skip inter-token whitespace
41 pass
41 pass
42 elif c == ':' and program[pos:pos + 2] == '::': # look ahead carefully
42 elif c == ':' and program[pos:pos + 2] == '::': # look ahead carefully
43 yield ('::', None)
43 yield ('::', None)
44 pos += 1 # skip ahead
44 pos += 1 # skip ahead
45 elif c == '.' and program[pos:pos + 2] == '..': # look ahead carefully
45 elif c == '.' and program[pos:pos + 2] == '..': # look ahead carefully
46 yield ('..', None)
46 yield ('..', None)
47 pos += 1 # skip ahead
47 pos += 1 # skip ahead
48 elif c in "():,-|&+!": # handle simple operators
48 elif c in "():,-|&+!": # handle simple operators
49 yield (c, None)
49 yield (c, None)
50 elif c in '"\'': # handle quoted strings
50 elif c in '"\'': # handle quoted strings
51 pos += 1
51 pos += 1
52 s = pos
52 s = pos
53 while pos < l: # find closing quote
53 while pos < l: # find closing quote
54 d = program[pos]
54 d = program[pos]
55 if d == '\\': # skip over escaped characters
55 if d == '\\': # skip over escaped characters
56 pos += 2
56 pos += 2
57 continue
57 continue
58 if d == c:
58 if d == c:
59 yield ('string', program[s:pos].decode('string-escape'))
59 yield ('string', program[s:pos].decode('string-escape'))
60 break
60 break
61 pos += 1
61 pos += 1
62 else:
62 else:
63 raise "unterminated string"
63 raise "unterminated string"
64 elif c.isalnum() or c in '.': # gather up a symbol/keyword
64 elif c.isalnum() or c in '.': # gather up a symbol/keyword
65 s = pos
65 s = pos
66 pos += 1
66 pos += 1
67 while pos < l: # find end of symbol
67 while pos < l: # find end of symbol
68 d = program[pos]
68 d = program[pos]
69 if not (d.isalnum() or d in "._"):
69 if not (d.isalnum() or d in "._"):
70 break
70 break
71 if d == '.' and program[pos - 1] == '.': # special case for ..
71 if d == '.' and program[pos - 1] == '.': # special case for ..
72 pos -= 1
72 pos -= 1
73 break
73 break
74 pos += 1
74 pos += 1
75 sym = program[s:pos]
75 sym = program[s:pos]
76 if sym in keywords: # operator keywords
76 if sym in keywords: # operator keywords
77 yield (sym, None)
77 yield (sym, None)
78 else:
78 else:
79 yield ('symbol', sym)
79 yield ('symbol', sym)
80 pos -= 1
80 pos -= 1
81 else:
81 else:
82 raise "syntax error at %d" % pos
82 raise "syntax error at %d" % pos
83 pos += 1
83 pos += 1
84 yield ('end', None)
84 yield ('end', None)
85
85
86 # helpers
86 # helpers
87
87
88 def getstring(x, err):
88 def getstring(x, err):
89 if x[0] == 'string' or x[0] == 'symbol':
89 if x[0] == 'string' or x[0] == 'symbol':
90 return x[1]
90 return x[1]
91 raise err
91 raise err
92
92
93 def getlist(x):
93 def getlist(x):
94 if not x:
94 if not x:
95 return []
95 return []
96 if x[0] == 'list':
96 if x[0] == 'list':
97 return getlist(x[1]) + [x[2]]
97 return getlist(x[1]) + [x[2]]
98 return [x]
98 return [x]
99
99
100 def getpair(x, err):
100 def getpair(x, err):
101 l = getlist(x)
101 l = getlist(x)
102 if len(l) != 2:
102 if len(l) != 2:
103 raise err
103 raise err
104 return l
104 return l
105
105
106 def getset(repo, subset, x):
106 def getset(repo, subset, x):
107 if not x:
107 if not x:
108 raise "missing argument"
108 raise "missing argument"
109 return methods[x[0]](repo, subset, *x[1:])
109 return methods[x[0]](repo, subset, *x[1:])
110
110
111 # operator methods
111 # operator methods
112
112
113 def negate(repo, subset, x):
113 def negate(repo, subset, x):
114 return getset(repo, subset,
114 return getset(repo, subset,
115 ('string', '-' + getstring(x, "can't negate that")))
115 ('string', '-' + getstring(x, "can't negate that")))
116
116
117 def stringset(repo, subset, x):
117 def stringset(repo, subset, x):
118 x = repo[x].rev()
118 x = repo[x].rev()
119 if x == -1 and len(subset) == len(repo):
119 if x == -1 and len(subset) == len(repo):
120 return [-1]
120 return [-1]
121 if x in subset:
121 if x in subset:
122 return [x]
122 return [x]
123 return []
123 return []
124
124
125 def symbolset(repo, subset, x):
125 def symbolset(repo, subset, x):
126 if x in symbols:
126 if x in symbols:
127 raise "can't use %s here" % x
127 raise "can't use %s here" % x
128 return stringset(repo, subset, x)
128 return stringset(repo, subset, x)
129
129
130 def rangeset(repo, subset, x, y):
130 def rangeset(repo, subset, x, y):
131 m = getset(repo, subset, x)[0]
131 m = getset(repo, subset, x)[0]
132 n = getset(repo, subset, y)[-1]
132 n = getset(repo, subset, y)[-1]
133 if m < n:
133 if m < n:
134 return range(m, n + 1)
134 return range(m, n + 1)
135 return range(m, n - 1, -1)
135 return range(m, n - 1, -1)
136
136
137 def andset(repo, subset, x, y):
137 def andset(repo, subset, x, y):
138 return getset(repo, getset(repo, subset, x), y)
138 return getset(repo, getset(repo, subset, x), y)
139
139
140 def orset(repo, subset, x, y):
140 def orset(repo, subset, x, y):
141 s = set(getset(repo, subset, x))
141 s = set(getset(repo, subset, x))
142 s |= set(getset(repo, [r for r in subset if r not in s], y))
142 s |= set(getset(repo, [r for r in subset if r not in s], y))
143 return [r for r in subset if r in s]
143 return [r for r in subset if r in s]
144
144
145 def notset(repo, subset, x):
145 def notset(repo, subset, x):
146 s = set(getset(repo, subset, x))
146 s = set(getset(repo, subset, x))
147 return [r for r in subset if r not in s]
147 return [r for r in subset if r not in s]
148
148
149 def listset(repo, subset, a, b):
149 def listset(repo, subset, a, b):
150 raise "can't use a list in this context"
150 raise "can't use a list in this context"
151
151
152 def func(repo, subset, a, b):
152 def func(repo, subset, a, b):
153 if a[0] == 'symbol' and a[1] in symbols:
153 if a[0] == 'symbol' and a[1] in symbols:
154 return symbols[a[1]](repo, subset, b)
154 return symbols[a[1]](repo, subset, b)
155 raise "that's not a function: %s" % a[1]
155 raise "that's not a function: %s" % a[1]
156
156
157 # functions
157 # functions
158
158
159 def p1(repo, subset, x):
159 def p1(repo, subset, x):
160 ps = set()
160 ps = set()
161 cl = repo.changelog
161 cl = repo.changelog
162 for r in getset(repo, subset, x):
162 for r in getset(repo, subset, x):
163 ps.add(cl.parentrevs(r)[0])
163 ps.add(cl.parentrevs(r)[0])
164 return [r for r in subset if r in ps]
164 return [r for r in subset if r in ps]
165
165
166 def p2(repo, subset, x):
166 def p2(repo, subset, x):
167 ps = set()
167 ps = set()
168 cl = repo.changelog
168 cl = repo.changelog
169 for r in getset(repo, subset, x):
169 for r in getset(repo, subset, x):
170 ps.add(cl.parentrevs(r)[1])
170 ps.add(cl.parentrevs(r)[1])
171 return [r for r in subset if r in ps]
171 return [r for r in subset if r in ps]
172
172
173 def parents(repo, subset, x):
173 def parents(repo, subset, x):
174 ps = set()
174 ps = set()
175 cl = repo.changelog
175 cl = repo.changelog
176 for r in getset(repo, subset, x):
176 for r in getset(repo, subset, x):
177 ps.update(cl.parentrevs(r))
177 ps.update(cl.parentrevs(r))
178 return [r for r in subset if r in ps]
178 return [r for r in subset if r in ps]
179
179
180 def maxrev(repo, subset, x):
180 def maxrev(repo, subset, x):
181 s = getset(repo, subset, x)
181 s = getset(repo, subset, x)
182 if s:
182 if s:
183 m = max(s)
183 m = max(s)
184 if m in subset:
184 if m in subset:
185 return [m]
185 return [m]
186 return []
186 return []
187
187
188 def limit(repo, subset, x):
188 def limit(repo, subset, x):
189 l = getpair(x, "limit wants two args")
189 l = getpair(x, "limit wants two args")
190 try:
190 try:
191 lim = int(getstring(l[1], "limit wants a number"))
191 lim = int(getstring(l[1], "limit wants a number"))
192 except ValueError:
192 except ValueError:
193 raise "wants a number"
193 raise "wants a number"
194 return getset(repo, subset, l[0])[:lim]
194 return getset(repo, subset, l[0])[:lim]
195
195
196 def children(repo, subset, x):
196 def children(repo, subset, x):
197 cs = set()
197 cs = set()
198 cl = repo.changelog
198 cl = repo.changelog
199 s = set(getset(repo, subset, x))
199 s = set(getset(repo, subset, x))
200 for r in xrange(0, len(repo)):
200 for r in xrange(0, len(repo)):
201 for p in cl.parentrevs(r):
201 for p in cl.parentrevs(r):
202 if p in s:
202 if p in s:
203 cs.add(r)
203 cs.add(r)
204 return [r for r in subset if r in cs]
204 return [r for r in subset if r in cs]
205
205
206 def branch(repo, subset, x):
206 def branch(repo, subset, x):
207 s = getset(repo, range(len(repo)), x)
207 s = getset(repo, range(len(repo)), x)
208 b = set()
208 b = set()
209 for r in s:
209 for r in s:
210 b.add(repo[r].branch())
210 b.add(repo[r].branch())
211 s = set(s)
211 s = set(s)
212 return [r for r in subset if r in s or repo[r].branch() in b]
212 return [r for r in subset if r in s or repo[r].branch() in b]
213
213
214 def ancestor(repo, subset, x):
214 def ancestor(repo, subset, x):
215 l = getpair(x, "ancestor wants two args")
215 l = getpair(x, "ancestor wants two args")
216 a = getset(repo, subset, l[0])
216 a = getset(repo, subset, l[0])
217 b = getset(repo, subset, l[1])
217 b = getset(repo, subset, l[1])
218 if len(a) > 1 or len(b) > 1:
218 if len(a) > 1 or len(b) > 1:
219 raise "arguments to ancestor must be single revisions"
219 raise "arguments to ancestor must be single revisions"
220 return [repo[a[0]].ancestor(repo[b[0]]).rev()]
220 return [repo[a[0]].ancestor(repo[b[0]]).rev()]
221
221
222 def ancestors(repo, subset, x):
222 def ancestors(repo, subset, x):
223 args = getset(repo, range(len(repo)), x)
223 args = getset(repo, range(len(repo)), x)
224 s = set(repo.changelog.ancestors(*args)) | set(args)
224 s = set(repo.changelog.ancestors(*args)) | set(args)
225 return [r for r in subset if r in s]
225 return [r for r in subset if r in s]
226
226
227 def descendants(repo, subset, x):
227 def descendants(repo, subset, x):
228 args = getset(repo, range(len(repo)), x)
228 args = getset(repo, range(len(repo)), x)
229 s = set(repo.changelog.descendants(*args)) | set(args)
229 s = set(repo.changelog.descendants(*args)) | set(args)
230 return [r for r in subset if r in s]
230 return [r for r in subset if r in s]
231
231
232 def follow(repo, subset, x):
232 def follow(repo, subset, x):
233 if x:
233 if x:
234 raise "follow takes no args"
234 raise "follow takes no args"
235 p = repo['.'].rev()
235 p = repo['.'].rev()
236 s = set(repo.changelog.ancestors(p)) | set([p])
236 s = set(repo.changelog.ancestors(p)) | set([p])
237 return [r for r in subset if r in s]
237 return [r for r in subset if r in s]
238
238
239 def date(repo, subset, x):
239 def date(repo, subset, x):
240 ds = getstring(x, 'date wants a string')
240 ds = getstring(x, 'date wants a string')
241 dm = util.matchdate(ds)
241 dm = util.matchdate(ds)
242 return [r for r in subset if dm(repo[r].date()[0])]
242 return [r for r in subset if dm(repo[r].date()[0])]
243
243
244 def keyword(repo, subset, x):
244 def keyword(repo, subset, x):
245 kw = getstring(x, "keyword wants a string").lower()
245 kw = getstring(x, "keyword wants a string").lower()
246 l = []
246 l = []
247 for r in subset:
247 for r in subset:
248 c = repo[r]
248 c = repo[r]
249 t = " ".join(c.files() + [c.user(), c.description()])
249 t = " ".join(c.files() + [c.user(), c.description()])
250 if kw in t.lower():
250 if kw in t.lower():
251 l.append(r)
251 l.append(r)
252 return l
252 return l
253
253
254 def grep(repo, subset, x):
254 def grep(repo, subset, x):
255 gr = re.compile(getstring(x, "grep wants a string"))
255 gr = re.compile(getstring(x, "grep wants a string"))
256 l = []
256 l = []
257 for r in subset:
257 for r in subset:
258 c = repo[r]
258 c = repo[r]
259 for e in c.files() + [c.user(), c.description()]:
259 for e in c.files() + [c.user(), c.description()]:
260 if gr.search(e):
260 if gr.search(e):
261 l.append(r)
261 l.append(r)
262 continue
262 continue
263 return l
263 return l
264
264
265 def author(repo, subset, x):
265 def author(repo, subset, x):
266 n = getstring(x, "author wants a string").lower()
266 n = getstring(x, "author wants a string").lower()
267 return [r for r in subset if n in repo[r].user().lower()]
267 return [r for r in subset if n in repo[r].user().lower()]
268
268
269 def hasfile(repo, subset, x):
269 def hasfile(repo, subset, x):
270 pat = getstring(x, "file wants a pattern")
270 pat = getstring(x, "file wants a pattern")
271 m = _match.match(repo.root, repo.getcwd(), [pat])
271 m = _match.match(repo.root, repo.getcwd(), [pat])
272 s = []
272 s = []
273 for r in subset:
273 for r in subset:
274 for f in repo[r].files():
274 for f in repo[r].files():
275 if m(f):
275 if m(f):
276 s.append(r)
276 s.append(r)
277 continue
277 continue
278 return s
278 return s
279
279
280 def contains(repo, subset, x):
280 def contains(repo, subset, x):
281 pat = getstring(x, "file wants a pattern")
281 pat = getstring(x, "file wants a pattern")
282 m = _match.match(repo.root, repo.getcwd(), [pat])
282 m = _match.match(repo.root, repo.getcwd(), [pat])
283 s = []
283 s = []
284 if m.files() == [pat]:
284 if m.files() == [pat]:
285 for r in subset:
285 for r in subset:
286 if pat in repo[r]:
286 if pat in repo[r]:
287 s.append(r)
287 s.append(r)
288 continue
288 continue
289 else:
289 else:
290 for r in subset:
290 for r in subset:
291 c = repo[r]
291 c = repo[r]
292 for f in repo[r].manifest():
292 for f in repo[r].manifest():
293 if m(f):
293 if m(f):
294 s.append(r)
294 s.append(r)
295 continue
295 continue
296 return s
296 return s
297
297
298 def checkstatus(repo, subset, pat, field):
298 def checkstatus(repo, subset, pat, field):
299 m = _match.match(repo.root, repo.getcwd(), [pat])
299 m = _match.match(repo.root, repo.getcwd(), [pat])
300 s = []
300 s = []
301 fast = (m.files() == [pat])
301 fast = (m.files() == [pat])
302 for r in subset:
302 for r in subset:
303 c = repo[r]
303 c = repo[r]
304 if fast:
304 if fast:
305 if pat not in c.files():
305 if pat not in c.files():
306 continue
306 continue
307 else:
307 else:
308 for f in c.files():
308 for f in c.files():
309 if m(f):
309 if m(f):
310 break
310 break
311 else:
311 else:
312 continue
312 continue
313 files = repo.status(c.p1().node(), c.node())[field]
313 files = repo.status(c.p1().node(), c.node())[field]
314 if fast:
314 if fast:
315 if pat in files:
315 if pat in files:
316 s.append(r)
316 s.append(r)
317 continue
317 continue
318 else:
318 else:
319 for f in files:
319 for f in files:
320 if m(f):
320 if m(f):
321 s.append(r)
321 s.append(r)
322 continue
322 continue
323 return s
323 return s
324
324
325 def modifies(repo, subset, x):
325 def modifies(repo, subset, x):
326 pat = getstring(x, "modifies wants a pattern")
326 pat = getstring(x, "modifies wants a pattern")
327 return checkstatus(repo, subset, pat, 0)
327 return checkstatus(repo, subset, pat, 0)
328
328
329 def adds(repo, subset, x):
329 def adds(repo, subset, x):
330 pat = getstring(x, "adds wants a pattern")
330 pat = getstring(x, "adds wants a pattern")
331 return checkstatus(repo, subset, pat, 1)
331 return checkstatus(repo, subset, pat, 1)
332
332
333 def removes(repo, subset, x):
333 def removes(repo, subset, x):
334 pat = getstring(x, "removes wants a pattern")
334 pat = getstring(x, "removes wants a pattern")
335 return checkstatus(repo, subset, pat, 2)
335 return checkstatus(repo, subset, pat, 2)
336
336
337 def merge(repo, subset, x):
337 def merge(repo, subset, x):
338 if x:
338 if x:
339 raise "merge takes no args"
339 raise "merge takes no args"
340 cl = repo.changelog
340 cl = repo.changelog
341 return [r for r in subset if cl.parentrevs(r)[1] != -1]
341 return [r for r in subset if cl.parentrevs(r)[1] != -1]
342
342
343 def closed(repo, subset, x):
343 def closed(repo, subset, x):
344 return [r for r in subset if repo[r].extra('close')]
344 return [r for r in subset if repo[r].extra('close')]
345
345
346 def head(repo, subset, x):
346 def head(repo, subset, x):
347 hs = set()
347 hs = set()
348 for b, ls in repo.branchmap().iteritems():
348 for b, ls in repo.branchmap().iteritems():
349 hs.update(repo[h].rev() for h in ls)
349 hs.update(repo[h].rev() for h in ls)
350 return [r for r in subset if r in hs]
350 return [r for r in subset if r in hs]
351
351
352 def reverse(repo, subset, x):
352 def reverse(repo, subset, x):
353 l = getset(repo, subset, x)
353 l = getset(repo, subset, x)
354 l.reverse()
354 l.reverse()
355 return l
355 return l
356
356
357 def sort(repo, subset, x):
357 def sort(repo, subset, x):
358 l = getlist(x)
358 l = getlist(x)
359 keys = "rev"
359 keys = "rev"
360 if len(l) == 2:
360 if len(l) == 2:
361 keys = getstring(l[1], "sort spec must be a string")
361 keys = getstring(l[1], "sort spec must be a string")
362
362
363 s = l[0]
363 s = l[0]
364 keys = keys.split()
364 keys = keys.split()
365 l = []
365 l = []
366 def invert(s):
366 def invert(s):
367 return "".join(chr(255 - ord(c)) for c in s)
367 return "".join(chr(255 - ord(c)) for c in s)
368 for r in getset(repo, subset, s):
368 for r in getset(repo, subset, s):
369 c = repo[r]
369 c = repo[r]
370 e = []
370 e = []
371 for k in keys:
371 for k in keys:
372 if k == 'rev':
372 if k == 'rev':
373 e.append(r)
373 e.append(r)
374 elif k == '-rev':
374 elif k == '-rev':
375 e.append(-r)
375 e.append(-r)
376 elif k == 'branch':
376 elif k == 'branch':
377 e.append(c.branch())
377 e.append(c.branch())
378 elif k == '-branch':
378 elif k == '-branch':
379 e.append(invert(c.branch()))
379 e.append(invert(c.branch()))
380 elif k == 'desc':
380 elif k == 'desc':
381 e.append(c.description())
381 e.append(c.description())
382 elif k == '-desc':
382 elif k == '-desc':
383 e.append(invert(c.description()))
383 e.append(invert(c.description()))
384 elif k in 'user author':
384 elif k in 'user author':
385 e.append(c.user())
385 e.append(c.user())
386 elif k in '-user -author':
386 elif k in '-user -author':
387 e.append(invert(c.user()))
387 e.append(invert(c.user()))
388 elif k == 'date':
388 elif k == 'date':
389 e.append(c.date()[0])
389 e.append(c.date()[0])
390 elif k == '-date':
390 elif k == '-date':
391 e.append(-c.date()[0])
391 e.append(-c.date()[0])
392 else:
392 else:
393 raise "unknown sort key %r" % k
393 raise "unknown sort key %r" % k
394 e.append(r)
394 e.append(r)
395 l.append(e)
395 l.append(e)
396 l.sort()
396 l.sort()
397 return [e[-1] for e in l]
397 return [e[-1] for e in l]
398
398
399 def getall(repo, subset, x):
399 def getall(repo, subset, x):
400 return subset
400 return subset
401
401
402 def heads(repo, subset, x):
402 def heads(repo, subset, x):
403 s = getset(repo, subset, x)
403 s = getset(repo, subset, x)
404 ps = set(parents(repo, subset, x))
404 ps = set(parents(repo, subset, x))
405 return [r for r in s if r not in ps]
405 return [r for r in s if r not in ps]
406
406
407 def roots(repo, subset, x):
407 def roots(repo, subset, x):
408 s = getset(repo, subset, x)
408 s = getset(repo, subset, x)
409 cs = set(children(repo, subset, x))
409 cs = set(children(repo, subset, x))
410 return [r for r in s if r not in cs]
410 return [r for r in s if r not in cs]
411
411
412 def outgoing(repo, subset, x):
412 def outgoing(repo, subset, x):
413 l = getlist(x)
413 l = getlist(x)
414 if len(l) == 1:
414 if len(l) == 1:
415 dest = getstring(l[0], "outgoing wants a repo path")
415 dest = getstring(l[0], "outgoing wants a repo path")
416 else:
416 else:
417 dest = ''
417 dest = ''
418 dest = repo.ui.expandpath(dest or 'default-push', dest or 'default')
418 dest = repo.ui.expandpath(dest or 'default-push', dest or 'default')
419 dest, branches = hg.parseurl(dest)
419 dest, branches = hg.parseurl(dest)
420 other = hg.repository(hg.remoteui(repo, {}), dest)
420 other = hg.repository(hg.remoteui(repo, {}), dest)
421 repo.ui.pushbuffer()
421 repo.ui.pushbuffer()
422 o = repo.findoutgoing(other)
422 o = repo.findoutgoing(other)
423 repo.ui.popbuffer()
423 repo.ui.popbuffer()
424 cl = repo.changelog
424 cl = repo.changelog
425 o = set([cl.rev(r) for r in repo.changelog.nodesbetween(o, None)[0]])
425 o = set([cl.rev(r) for r in repo.changelog.nodesbetween(o, None)[0]])
426 print 'out', dest, o
426 print 'out', dest, o
427 return [r for r in subset if r in o]
427 return [r for r in subset if r in o]
428
428
429 def tagged(repo, subset, x):
429 def tagged(repo, subset, x):
430 cl = repo.changelog
430 cl = repo.changelog
431 s = set([cl.rev(n) for t, n in repo.tagslist() if t != 'tip'])
431 s = set([cl.rev(n) for t, n in repo.tagslist() if t != 'tip'])
432 return [r for r in subset if r in s]
432 return [r for r in subset if r in s]
433
433
434 symbols = {
434 symbols = {
435 "ancestor": ancestor,
435 "ancestor": ancestor,
436 "ancestors": ancestors,
436 "ancestors": ancestors,
437 "descendants": descendants,
437 "descendants": descendants,
438 "follow": follow,
438 "follow": follow,
439 "merge": merge,
439 "merge": merge,
440 "reverse": reverse,
440 "reverse": reverse,
441 "sort": sort,
441 "sort": sort,
442 "branch": branch,
442 "branch": branch,
443 "keyword": keyword,
443 "keyword": keyword,
444 "author": author,
444 "author": author,
445 "user": author,
445 "user": author,
446 "date": date,
446 "date": date,
447 "grep": grep,
447 "grep": grep,
448 "p1": p1,
448 "p1": p1,
449 "p2": p2,
449 "p2": p2,
450 "parents": parents,
450 "parents": parents,
451 "children": children,
451 "children": children,
452 "max": maxrev,
452 "max": maxrev,
453 "limit": limit,
453 "limit": limit,
454 "file": hasfile,
454 "file": hasfile,
455 "contains": contains,
455 "contains": contains,
456 "heads": heads,
456 "heads": heads,
457 "roots": roots,
457 "roots": roots,
458 "all": getall,
458 "all": getall,
459 "closed": closed,
459 "closed": closed,
460 "head": head,
460 "head": head,
461 "modifies": modifies,
461 "modifies": modifies,
462 "adds": adds,
462 "adds": adds,
463 "removes": removes,
463 "removes": removes,
464 "outgoing": outgoing,
464 "outgoing": outgoing,
465 "tagged": tagged,
465 "tagged": tagged,
466 }
466 }
467
467
468 methods = {
468 methods = {
469 "negate": negate,
469 "negate": negate,
470 "range": rangeset,
470 "range": rangeset,
471 "string": stringset,
471 "string": stringset,
472 "symbol": symbolset,
472 "symbol": symbolset,
473 "and": andset,
473 "and": andset,
474 "or": orset,
474 "or": orset,
475 "not": notset,
475 "not": notset,
476 "list": listset,
476 "list": listset,
477 "func": func,
477 "func": func,
478 }
478 }
479
479
480 def optimize(x, small):
480 def optimize(x, small):
481 if x == None:
481 if x == None:
482 return 0, x
482 return 0, x
483
483
484 smallbonus = 1
484 smallbonus = 1
485 if small:
485 if small:
486 smallbonus = .5
486 smallbonus = .5
487
487
488 op = x[0]
488 op = x[0]
489 if op == '-':
489 if op == 'minus':
490 return optimize(('and', x[1], ('not', x[2])), small)
490 return optimize(('and', x[1], ('not', x[2])), small)
491 elif op == 'dagrange':
491 elif op == 'dagrange':
492 return optimize(('and', ('func', ('symbol', 'descendants'), x[1]),
492 return optimize(('and', ('func', ('symbol', 'descendants'), x[1]),
493 ('func', ('symbol', 'ancestors'), x[2])), small)
493 ('func', ('symbol', 'ancestors'), x[2])), small)
494 elif op == 'dagrangepre':
494 elif op == 'dagrangepre':
495 return optimize(('func', ('symbol', 'ancestors'), x[1]), small)
495 return optimize(('func', ('symbol', 'ancestors'), x[1]), small)
496 elif op == 'dagrangepost':
496 elif op == 'dagrangepost':
497 return optimize(('func', ('symbol', 'descendants'), x[1]), small)
497 return optimize(('func', ('symbol', 'descendants'), x[1]), small)
498 elif op == 'rangepre':
498 elif op == 'rangepre':
499 return optimize(('range', ('string', '0'), x[1]), small)
499 return optimize(('range', ('string', '0'), x[1]), small)
500 elif op == 'rangepost':
500 elif op == 'rangepost':
501 return optimize(('range', x[1], ('string', 'tip')), small)
501 return optimize(('range', x[1], ('string', 'tip')), small)
502 elif op in 'string symbol negate':
502 elif op in 'string symbol negate':
503 return smallbonus, x # single revisions are small
503 return smallbonus, x # single revisions are small
504 elif op == 'and' or op == 'dagrange':
504 elif op == 'and' or op == 'dagrange':
505 wa, ta = optimize(x[1], True)
505 wa, ta = optimize(x[1], True)
506 wb, tb = optimize(x[2], True)
506 wb, tb = optimize(x[2], True)
507 w = min(wa, wb)
507 w = min(wa, wb)
508 if wa > wb:
508 if wa > wb:
509 return w, (op, tb, ta)
509 return w, (op, tb, ta)
510 return w, (op, ta, tb)
510 return w, (op, ta, tb)
511 elif op == 'or':
511 elif op == 'or':
512 wa, ta = optimize(x[1], False)
512 wa, ta = optimize(x[1], False)
513 wb, tb = optimize(x[2], False)
513 wb, tb = optimize(x[2], False)
514 if wb < wa:
514 if wb < wa:
515 wb, wa = wa, wb
515 wb, wa = wa, wb
516 return max(wa, wb), (op, ta, tb)
516 return max(wa, wb), (op, ta, tb)
517 elif op == 'not':
517 elif op == 'not':
518 o = optimize(x[1], not small)
518 o = optimize(x[1], not small)
519 return o[0], (op, o[1])
519 return o[0], (op, o[1])
520 elif op == 'group':
520 elif op == 'group':
521 return optimize(x[1], small)
521 return optimize(x[1], small)
522 elif op in 'range list':
522 elif op in 'range list':
523 wa, ta = optimize(x[1], small)
523 wa, ta = optimize(x[1], small)
524 wb, tb = optimize(x[2], small)
524 wb, tb = optimize(x[2], small)
525 return wa + wb, (op, ta, tb)
525 return wa + wb, (op, ta, tb)
526 elif op == 'func':
526 elif op == 'func':
527 f = getstring(x[1], "not a symbol")
527 f = getstring(x[1], "not a symbol")
528 wa, ta = optimize(x[2], small)
528 wa, ta = optimize(x[2], small)
529 if f in "grep date user author keyword branch file":
529 if f in "grep date user author keyword branch file":
530 w = 10 # slow
530 w = 10 # slow
531 elif f in "modifies adds removes outgoing":
531 elif f in "modifies adds removes outgoing":
532 w = 30 # slower
532 w = 30 # slower
533 elif f == "contains":
533 elif f == "contains":
534 w = 100 # very slow
534 w = 100 # very slow
535 elif f == "ancestor":
535 elif f == "ancestor":
536 w = 1 * smallbonus
536 w = 1 * smallbonus
537 elif f == "reverse limit":
537 elif f == "reverse limit":
538 w = 0
538 w = 0
539 elif f in "sort":
539 elif f in "sort":
540 w = 10 # assume most sorts look at changelog
540 w = 10 # assume most sorts look at changelog
541 else:
541 else:
542 w = 1
542 w = 1
543 return w + wa, (op, x[1], ta)
543 return w + wa, (op, x[1], ta)
544 return 1, x
544 return 1, x
545
545
546 parse = parser.parser(tokenize, elements).parse
546 parse = parser.parser(tokenize, elements).parse
547
547
548 def match(spec):
548 def match(spec):
549 tree = parse(spec)
549 tree = parse(spec)
550 weight, tree = optimize(tree, True)
550 weight, tree = optimize(tree, True)
551 def mfunc(repo, subset):
551 def mfunc(repo, subset):
552 return getset(repo, subset, tree)
552 return getset(repo, subset, tree)
553 return mfunc
553 return mfunc
General Comments 0
You need to be logged in to leave comments. Login now