Mercurial > public > mercurial-scm > hg
annotate mercurial/revset.py @ 11944:df52ff0980fe
revset: predicate to avoid lookup errors
A query like
head() and (descendants("bad") and not descendants("fix"))
(testing if repo heads are affected by a bug) will abort with a
RepoLookupError if either badrev or fixrev aren't found inside
the repository, which is not very informative.
The new predicate returns an empty set for lookup errors, so
head() and (descendants(present("bad")) and not descendants(present("fix")))
will behave as wanted even if those revisions are not found.
| author | Wagner Bruna <wbruna@softwareexpress.com.br> |
|---|---|
| date | Fri, 13 Aug 2010 13:11:41 -0300 |
| parents | 73112cb2a6d7 |
| children | 6f833fc3ccab |
| rev | line source |
|---|---|
| 11275 | 1 # revset.py - revision set queries for mercurial |
| 2 # | |
| 3 # Copyright 2010 Matt Mackall <mpm@selenic.com> | |
| 4 # | |
| 5 # This software may be used and distributed according to the terms of the | |
| 6 # GNU General Public License version 2 or any later version. | |
| 7 | |
| 8 import re | |
|
11301
3d0591a66118
move discovery methods from localrepo into new discovery module
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
11293
diff
changeset
|
9 import parser, util, error, discovery |
| 11275 | 10 import match as _match |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
11 from i18n import _ |
| 11275 | 12 |
| 13 elements = { | |
| 14 "(": (20, ("group", 1, ")"), ("func", 1, ")")), | |
| 15 "-": (19, ("negate", 19), ("minus", 19)), | |
|
11278
7df88cdf47fd
revset: add support for prefix and suffix versions of : and ::
Matt Mackall <mpm@selenic.com>
parents:
11275
diff
changeset
|
16 "::": (17, ("dagrangepre", 17), ("dagrange", 17), |
|
7df88cdf47fd
revset: add support for prefix and suffix versions of : and ::
Matt Mackall <mpm@selenic.com>
parents:
11275
diff
changeset
|
17 ("dagrangepost", 17)), |
|
7df88cdf47fd
revset: add support for prefix and suffix versions of : and ::
Matt Mackall <mpm@selenic.com>
parents:
11275
diff
changeset
|
18 "..": (17, ("dagrangepre", 17), ("dagrange", 17), |
|
7df88cdf47fd
revset: add support for prefix and suffix versions of : and ::
Matt Mackall <mpm@selenic.com>
parents:
11275
diff
changeset
|
19 ("dagrangepost", 17)), |
|
7df88cdf47fd
revset: add support for prefix and suffix versions of : and ::
Matt Mackall <mpm@selenic.com>
parents:
11275
diff
changeset
|
20 ":": (15, ("rangepre", 15), ("range", 15), ("rangepost", 15)), |
| 11275 | 21 "not": (10, ("not", 10)), |
| 22 "!": (10, ("not", 10)), | |
| 23 "and": (5, None, ("and", 5)), | |
| 24 "&": (5, None, ("and", 5)), | |
| 25 "or": (4, None, ("or", 4)), | |
| 26 "|": (4, None, ("or", 4)), | |
| 27 "+": (4, None, ("or", 4)), | |
| 28 ",": (2, None, ("list", 2)), | |
| 29 ")": (0, None, None), | |
| 30 "symbol": (0, ("symbol",), None), | |
| 31 "string": (0, ("string",), None), | |
| 32 "end": (0, None, None), | |
| 33 } | |
| 34 | |
| 35 keywords = set(['and', 'or', 'not']) | |
| 36 | |
| 37 def tokenize(program): | |
| 38 pos, l = 0, len(program) | |
| 39 while pos < l: | |
| 40 c = program[pos] | |
| 41 if c.isspace(): # skip inter-token whitespace | |
| 42 pass | |
|
11278
7df88cdf47fd
revset: add support for prefix and suffix versions of : and ::
Matt Mackall <mpm@selenic.com>
parents:
11275
diff
changeset
|
43 elif c == ':' and program[pos:pos + 2] == '::': # look ahead carefully |
|
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
44 yield ('::', None, pos) |
|
11278
7df88cdf47fd
revset: add support for prefix and suffix versions of : and ::
Matt Mackall <mpm@selenic.com>
parents:
11275
diff
changeset
|
45 pos += 1 # skip ahead |
| 11275 | 46 elif c == '.' and program[pos:pos + 2] == '..': # look ahead carefully |
|
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
47 yield ('..', None, pos) |
| 11275 | 48 pos += 1 # skip ahead |
|
11278
7df88cdf47fd
revset: add support for prefix and suffix versions of : and ::
Matt Mackall <mpm@selenic.com>
parents:
11275
diff
changeset
|
49 elif c in "():,-|&+!": # handle simple operators |
|
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
50 yield (c, None, pos) |
| 11275 | 51 elif c in '"\'': # handle quoted strings |
| 52 pos += 1 | |
| 53 s = pos | |
| 54 while pos < l: # find closing quote | |
| 55 d = program[pos] | |
| 56 if d == '\\': # skip over escaped characters | |
| 57 pos += 2 | |
| 58 continue | |
| 59 if d == c: | |
|
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
60 yield ('string', program[s:pos].decode('string-escape'), s) |
| 11275 | 61 break |
| 62 pos += 1 | |
| 63 else: | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
64 raise error.ParseError(_("unterminated string"), s) |
|
11404
37cbedbeae96
revset: allow extended characters in symbols
Matt Mackall <mpm@selenic.com>
parents:
11385
diff
changeset
|
65 elif c.isalnum() or c in '._' or ord(c) > 127: # gather up a symbol/keyword |
| 11275 | 66 s = pos |
| 67 pos += 1 | |
| 68 while pos < l: # find end of symbol | |
| 69 d = program[pos] | |
|
11404
37cbedbeae96
revset: allow extended characters in symbols
Matt Mackall <mpm@selenic.com>
parents:
11385
diff
changeset
|
70 if not (d.isalnum() or d in "._" or ord(d) > 127): |
| 11275 | 71 break |
| 72 if d == '.' and program[pos - 1] == '.': # special case for .. | |
| 73 pos -= 1 | |
| 74 break | |
| 75 pos += 1 | |
| 76 sym = program[s:pos] | |
| 77 if sym in keywords: # operator keywords | |
|
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
78 yield (sym, None, s) |
| 11275 | 79 else: |
|
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
80 yield ('symbol', sym, s) |
| 11275 | 81 pos -= 1 |
| 82 else: | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
83 raise error.ParseError(_("syntax error"), pos) |
| 11275 | 84 pos += 1 |
|
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
85 yield ('end', None, pos) |
| 11275 | 86 |
| 87 # helpers | |
| 88 | |
| 89 def getstring(x, err): | |
|
11406
42408cd43f55
revset: fix up contains/getstring when no args passed
Matt Mackall <mpm@selenic.com>
parents:
11404
diff
changeset
|
90 if x and (x[0] == 'string' or x[0] == 'symbol'): |
| 11275 | 91 return x[1] |
|
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
92 raise error.ParseError(err) |
| 11275 | 93 |
| 94 def getlist(x): | |
| 95 if not x: | |
| 96 return [] | |
| 97 if x[0] == 'list': | |
| 98 return getlist(x[1]) + [x[2]] | |
| 99 return [x] | |
| 100 | |
|
11339
744d5b73f776
revset: improve filter argument handling
Matt Mackall <mpm@selenic.com>
parents:
11304
diff
changeset
|
101 def getargs(x, min, max, err): |
| 11275 | 102 l = getlist(x) |
|
11339
744d5b73f776
revset: improve filter argument handling
Matt Mackall <mpm@selenic.com>
parents:
11304
diff
changeset
|
103 if len(l) < min or len(l) > max: |
|
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
104 raise error.ParseError(err) |
| 11275 | 105 return l |
| 106 | |
| 107 def getset(repo, subset, x): | |
| 108 if not x: | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
109 raise error.ParseError(_("missing argument")) |
| 11275 | 110 return methods[x[0]](repo, subset, *x[1:]) |
| 111 | |
| 112 # operator methods | |
| 113 | |
| 114 def stringset(repo, subset, x): | |
| 115 x = repo[x].rev() | |
| 11282 | 116 if x == -1 and len(subset) == len(repo): |
| 117 return [-1] | |
| 11275 | 118 if x in subset: |
| 119 return [x] | |
| 120 return [] | |
| 121 | |
| 122 def symbolset(repo, subset, x): | |
| 123 if x in symbols: | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
124 raise error.ParseError(_("can't use %s here") % x) |
| 11275 | 125 return stringset(repo, subset, x) |
| 126 | |
| 127 def rangeset(repo, subset, x, y): | |
|
11456
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
128 m = getset(repo, subset, x) |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
129 if not m: |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
130 m = getset(repo, range(len(repo)), x) |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
131 |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
132 n = getset(repo, subset, y) |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
133 if not n: |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
134 n = getset(repo, range(len(repo)), y) |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
135 |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
136 if not m or not n: |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
137 return [] |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
138 m, n = m[0], n[-1] |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
139 |
| 11275 | 140 if m < n: |
|
11456
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
141 r = range(m, n + 1) |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
142 else: |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
143 r = range(m, n - 1, -1) |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
144 s = set(subset) |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
145 return [x for x in r if x in s] |
| 11275 | 146 |
| 147 def andset(repo, subset, x, y): | |
| 148 return getset(repo, getset(repo, subset, x), y) | |
| 149 | |
| 150 def orset(repo, subset, x, y): | |
| 151 s = set(getset(repo, subset, x)) | |
| 152 s |= set(getset(repo, [r for r in subset if r not in s], y)) | |
| 153 return [r for r in subset if r in s] | |
| 154 | |
| 155 def notset(repo, subset, x): | |
| 156 s = set(getset(repo, subset, x)) | |
| 157 return [r for r in subset if r not in s] | |
| 158 | |
| 159 def listset(repo, subset, a, b): | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
160 raise error.ParseError(_("can't use a list in this context")) |
| 11275 | 161 |
| 162 def func(repo, subset, a, b): | |
| 163 if a[0] == 'symbol' and a[1] in symbols: | |
| 164 return symbols[a[1]](repo, subset, b) | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
165 raise error.ParseError(_("not a function: %s") % a[1]) |
| 11275 | 166 |
| 167 # functions | |
| 168 | |
| 169 def p1(repo, subset, x): | |
| 170 ps = set() | |
| 171 cl = repo.changelog | |
| 172 for r in getset(repo, subset, x): | |
| 173 ps.add(cl.parentrevs(r)[0]) | |
| 174 return [r for r in subset if r in ps] | |
| 175 | |
| 176 def p2(repo, subset, x): | |
| 177 ps = set() | |
| 178 cl = repo.changelog | |
| 179 for r in getset(repo, subset, x): | |
| 180 ps.add(cl.parentrevs(r)[1]) | |
| 181 return [r for r in subset if r in ps] | |
| 182 | |
| 183 def parents(repo, subset, x): | |
| 184 ps = set() | |
| 185 cl = repo.changelog | |
| 186 for r in getset(repo, subset, x): | |
| 187 ps.update(cl.parentrevs(r)) | |
| 188 return [r for r in subset if r in ps] | |
| 189 | |
| 190 def maxrev(repo, subset, x): | |
| 191 s = getset(repo, subset, x) | |
| 192 if s: | |
| 193 m = max(s) | |
| 194 if m in subset: | |
| 195 return [m] | |
| 196 return [] | |
| 197 | |
|
11708
ba65d61f3158
revset: add min function
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11650
diff
changeset
|
198 def minrev(repo, subset, x): |
|
ba65d61f3158
revset: add min function
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11650
diff
changeset
|
199 s = getset(repo, subset, x) |
|
ba65d61f3158
revset: add min function
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11650
diff
changeset
|
200 if s: |
|
ba65d61f3158
revset: add min function
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11650
diff
changeset
|
201 m = min(s) |
|
ba65d61f3158
revset: add min function
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11650
diff
changeset
|
202 if m in subset: |
|
ba65d61f3158
revset: add min function
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11650
diff
changeset
|
203 return [m] |
|
ba65d61f3158
revset: add min function
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11650
diff
changeset
|
204 return [] |
|
ba65d61f3158
revset: add min function
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11650
diff
changeset
|
205 |
| 11275 | 206 def limit(repo, subset, x): |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
207 l = getargs(x, 2, 2, _("limit wants two arguments")) |
| 11275 | 208 try: |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
209 lim = int(getstring(l[1], _("limit wants a number"))) |
| 11275 | 210 except ValueError: |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
211 raise error.ParseError(_("limit expects a number")) |
| 11275 | 212 return getset(repo, subset, l[0])[:lim] |
| 213 | |
| 214 def children(repo, subset, x): | |
| 215 cs = set() | |
| 216 cl = repo.changelog | |
| 217 s = set(getset(repo, subset, x)) | |
| 218 for r in xrange(0, len(repo)): | |
| 219 for p in cl.parentrevs(r): | |
| 220 if p in s: | |
| 221 cs.add(r) | |
| 222 return [r for r in subset if r in cs] | |
| 223 | |
| 224 def branch(repo, subset, x): | |
| 225 s = getset(repo, range(len(repo)), x) | |
| 226 b = set() | |
| 227 for r in s: | |
| 228 b.add(repo[r].branch()) | |
| 229 s = set(s) | |
| 230 return [r for r in subset if r in s or repo[r].branch() in b] | |
| 231 | |
| 232 def ancestor(repo, subset, x): | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
233 l = getargs(x, 2, 2, _("ancestor wants two arguments")) |
|
11650
ebaf117c2642
revset: fix ancestor subset handling (issue2298)
Matt Mackall <mpm@selenic.com>
parents:
11467
diff
changeset
|
234 r = range(len(repo)) |
|
ebaf117c2642
revset: fix ancestor subset handling (issue2298)
Matt Mackall <mpm@selenic.com>
parents:
11467
diff
changeset
|
235 a = getset(repo, r, l[0]) |
|
ebaf117c2642
revset: fix ancestor subset handling (issue2298)
Matt Mackall <mpm@selenic.com>
parents:
11467
diff
changeset
|
236 b = getset(repo, r, l[1]) |
|
ebaf117c2642
revset: fix ancestor subset handling (issue2298)
Matt Mackall <mpm@selenic.com>
parents:
11467
diff
changeset
|
237 if len(a) != 1 or len(b) != 1: |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
238 raise error.ParseError(_("ancestor arguments must be single revisions")) |
|
11650
ebaf117c2642
revset: fix ancestor subset handling (issue2298)
Matt Mackall <mpm@selenic.com>
parents:
11467
diff
changeset
|
239 an = [repo[a[0]].ancestor(repo[b[0]]).rev()] |
|
ebaf117c2642
revset: fix ancestor subset handling (issue2298)
Matt Mackall <mpm@selenic.com>
parents:
11467
diff
changeset
|
240 |
|
ebaf117c2642
revset: fix ancestor subset handling (issue2298)
Matt Mackall <mpm@selenic.com>
parents:
11467
diff
changeset
|
241 return [r for r in an if r in subset] |
| 11275 | 242 |
| 243 def ancestors(repo, subset, x): | |
| 244 args = getset(repo, range(len(repo)), x) | |
|
11456
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
245 if not args: |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
246 return [] |
| 11275 | 247 s = set(repo.changelog.ancestors(*args)) | set(args) |
| 248 return [r for r in subset if r in s] | |
| 249 | |
| 250 def descendants(repo, subset, x): | |
| 251 args = getset(repo, range(len(repo)), x) | |
|
11456
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
252 if not args: |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
253 return [] |
| 11275 | 254 s = set(repo.changelog.descendants(*args)) | set(args) |
| 255 return [r for r in subset if r in s] | |
| 256 | |
| 257 def follow(repo, subset, x): | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
258 getargs(x, 0, 0, _("follow takes no arguments")) |
| 11275 | 259 p = repo['.'].rev() |
| 260 s = set(repo.changelog.ancestors(p)) | set([p]) | |
| 261 return [r for r in subset if r in s] | |
| 262 | |
| 263 def date(repo, subset, x): | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
264 ds = getstring(x, _("date wants a string")) |
| 11275 | 265 dm = util.matchdate(ds) |
| 266 return [r for r in subset if dm(repo[r].date()[0])] | |
| 267 | |
| 268 def keyword(repo, subset, x): | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
269 kw = getstring(x, _("keyword wants a string")).lower() |
| 11275 | 270 l = [] |
| 271 for r in subset: | |
| 272 c = repo[r] | |
| 273 t = " ".join(c.files() + [c.user(), c.description()]) | |
| 274 if kw in t.lower(): | |
| 275 l.append(r) | |
| 276 return l | |
| 277 | |
| 278 def grep(repo, subset, x): | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
279 gr = re.compile(getstring(x, _("grep wants a string"))) |
| 11275 | 280 l = [] |
| 281 for r in subset: | |
| 282 c = repo[r] | |
| 283 for e in c.files() + [c.user(), c.description()]: | |
| 284 if gr.search(e): | |
| 285 l.append(r) | |
| 286 continue | |
| 287 return l | |
| 288 | |
| 289 def author(repo, subset, x): | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
290 n = getstring(x, _("author wants a string")).lower() |
| 11275 | 291 return [r for r in subset if n in repo[r].user().lower()] |
| 292 | |
| 293 def hasfile(repo, subset, x): | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
294 pat = getstring(x, _("file wants a pattern")) |
| 11275 | 295 m = _match.match(repo.root, repo.getcwd(), [pat]) |
| 296 s = [] | |
| 297 for r in subset: | |
| 298 for f in repo[r].files(): | |
| 299 if m(f): | |
| 300 s.append(r) | |
| 301 continue | |
| 302 return s | |
| 303 | |
| 304 def contains(repo, subset, x): | |
|
11406
42408cd43f55
revset: fix up contains/getstring when no args passed
Matt Mackall <mpm@selenic.com>
parents:
11404
diff
changeset
|
305 pat = getstring(x, _("contains wants a pattern")) |
| 11275 | 306 m = _match.match(repo.root, repo.getcwd(), [pat]) |
| 307 s = [] | |
| 308 if m.files() == [pat]: | |
| 309 for r in subset: | |
| 310 if pat in repo[r]: | |
| 311 s.append(r) | |
| 312 continue | |
| 313 else: | |
| 314 for r in subset: | |
| 315 for f in repo[r].manifest(): | |
| 316 if m(f): | |
| 317 s.append(r) | |
| 318 continue | |
| 319 return s | |
| 320 | |
| 321 def checkstatus(repo, subset, pat, field): | |
| 322 m = _match.match(repo.root, repo.getcwd(), [pat]) | |
| 323 s = [] | |
| 324 fast = (m.files() == [pat]) | |
| 325 for r in subset: | |
| 326 c = repo[r] | |
| 327 if fast: | |
| 328 if pat not in c.files(): | |
| 329 continue | |
| 330 else: | |
| 331 for f in c.files(): | |
| 332 if m(f): | |
| 333 break | |
| 334 else: | |
| 335 continue | |
| 336 files = repo.status(c.p1().node(), c.node())[field] | |
| 337 if fast: | |
| 338 if pat in files: | |
| 339 s.append(r) | |
| 340 continue | |
| 341 else: | |
| 342 for f in files: | |
| 343 if m(f): | |
| 344 s.append(r) | |
| 345 continue | |
| 346 return s | |
| 347 | |
| 348 def modifies(repo, subset, x): | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
349 pat = getstring(x, _("modifies wants a pattern")) |
| 11275 | 350 return checkstatus(repo, subset, pat, 0) |
| 351 | |
| 352 def adds(repo, subset, x): | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
353 pat = getstring(x, _("adds wants a pattern")) |
| 11275 | 354 return checkstatus(repo, subset, pat, 1) |
| 355 | |
| 356 def removes(repo, subset, x): | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
357 pat = getstring(x, _("removes wants a pattern")) |
| 11275 | 358 return checkstatus(repo, subset, pat, 2) |
| 359 | |
| 360 def merge(repo, subset, x): | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
361 getargs(x, 0, 0, _("merge takes no arguments")) |
| 11275 | 362 cl = repo.changelog |
| 363 return [r for r in subset if cl.parentrevs(r)[1] != -1] | |
| 364 | |
| 365 def closed(repo, subset, x): | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
366 getargs(x, 0, 0, _("closed takes no arguments")) |
|
11349
cf8a9154a362
revset: fix call to ctx.extra() in closed()
Georg Brandl <georg@python.org>
parents:
11339
diff
changeset
|
367 return [r for r in subset if repo[r].extra().get('close')] |
| 11275 | 368 |
| 369 def head(repo, subset, x): | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
370 getargs(x, 0, 0, _("head takes no arguments")) |
| 11275 | 371 hs = set() |
| 372 for b, ls in repo.branchmap().iteritems(): | |
| 373 hs.update(repo[h].rev() for h in ls) | |
| 374 return [r for r in subset if r in hs] | |
| 375 | |
| 376 def reverse(repo, subset, x): | |
| 377 l = getset(repo, subset, x) | |
| 378 l.reverse() | |
| 379 return l | |
| 380 | |
|
11944
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
381 def present(repo, subset, x): |
|
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
382 try: |
|
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
383 return getset(repo, subset, x) |
|
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
384 except error.RepoLookupError: |
|
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
385 return [] |
|
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
386 |
| 11275 | 387 def sort(repo, subset, x): |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
388 l = getargs(x, 1, 2, _("sort wants one or two arguments")) |
| 11275 | 389 keys = "rev" |
| 390 if len(l) == 2: | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
391 keys = getstring(l[1], _("sort spec must be a string")) |
| 11275 | 392 |
| 393 s = l[0] | |
| 394 keys = keys.split() | |
| 395 l = [] | |
| 396 def invert(s): | |
| 397 return "".join(chr(255 - ord(c)) for c in s) | |
| 398 for r in getset(repo, subset, s): | |
| 399 c = repo[r] | |
| 400 e = [] | |
| 401 for k in keys: | |
| 402 if k == 'rev': | |
| 403 e.append(r) | |
| 404 elif k == '-rev': | |
| 405 e.append(-r) | |
| 406 elif k == 'branch': | |
| 407 e.append(c.branch()) | |
| 408 elif k == '-branch': | |
| 409 e.append(invert(c.branch())) | |
| 410 elif k == 'desc': | |
| 411 e.append(c.description()) | |
| 412 elif k == '-desc': | |
| 413 e.append(invert(c.description())) | |
| 414 elif k in 'user author': | |
| 415 e.append(c.user()) | |
| 416 elif k in '-user -author': | |
| 417 e.append(invert(c.user())) | |
| 418 elif k == 'date': | |
| 419 e.append(c.date()[0]) | |
| 420 elif k == '-date': | |
| 421 e.append(-c.date()[0]) | |
| 422 else: | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
423 raise error.ParseError(_("unknown sort key %r") % k) |
| 11275 | 424 e.append(r) |
| 425 l.append(e) | |
| 426 l.sort() | |
| 427 return [e[-1] for e in l] | |
| 428 | |
| 429 def getall(repo, subset, x): | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
430 getargs(x, 0, 0, _("all takes no arguments")) |
| 11275 | 431 return subset |
| 432 | |
| 433 def heads(repo, subset, x): | |
| 434 s = getset(repo, subset, x) | |
| 435 ps = set(parents(repo, subset, x)) | |
| 436 return [r for r in s if r not in ps] | |
| 437 | |
| 438 def roots(repo, subset, x): | |
| 439 s = getset(repo, subset, x) | |
| 440 cs = set(children(repo, subset, x)) | |
| 441 return [r for r in s if r not in cs] | |
| 442 | |
| 443 def outgoing(repo, subset, x): | |
|
11293
0e5ce2325795
revset: delay import of hg to avoid start-up import loops
Matt Mackall <mpm@selenic.com>
parents:
11289
diff
changeset
|
444 import hg # avoid start-up nasties |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
445 l = getargs(x, 0, 1, _("outgoing wants a repository path")) |
|
11882
b75dea24e296
revset: fix outgoing argument handling
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11650
diff
changeset
|
446 dest = l and getstring(l[0], _("outgoing wants a repository path")) or '' |
| 11275 | 447 dest = repo.ui.expandpath(dest or 'default-push', dest or 'default') |
| 448 dest, branches = hg.parseurl(dest) | |
| 449 other = hg.repository(hg.remoteui(repo, {}), dest) | |
| 450 repo.ui.pushbuffer() | |
|
11301
3d0591a66118
move discovery methods from localrepo into new discovery module
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
11293
diff
changeset
|
451 o = discovery.findoutgoing(repo, other) |
| 11275 | 452 repo.ui.popbuffer() |
| 453 cl = repo.changelog | |
| 454 o = set([cl.rev(r) for r in repo.changelog.nodesbetween(o, None)[0]]) | |
| 455 return [r for r in subset if r in o] | |
| 456 | |
|
11280
a5eb0bf7e158
revset: add tagged predicate
Matt Mackall <mpm@selenic.com>
parents:
11279
diff
changeset
|
457 def tagged(repo, subset, x): |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
458 getargs(x, 0, 0, _("tagged takes no arguments")) |
|
11280
a5eb0bf7e158
revset: add tagged predicate
Matt Mackall <mpm@selenic.com>
parents:
11279
diff
changeset
|
459 cl = repo.changelog |
|
a5eb0bf7e158
revset: add tagged predicate
Matt Mackall <mpm@selenic.com>
parents:
11279
diff
changeset
|
460 s = set([cl.rev(n) for t, n in repo.tagslist() if t != 'tip']) |
|
a5eb0bf7e158
revset: add tagged predicate
Matt Mackall <mpm@selenic.com>
parents:
11279
diff
changeset
|
461 return [r for r in subset if r in s] |
|
a5eb0bf7e158
revset: add tagged predicate
Matt Mackall <mpm@selenic.com>
parents:
11279
diff
changeset
|
462 |
| 11275 | 463 symbols = { |
|
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
464 "adds": adds, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
465 "all": getall, |
| 11275 | 466 "ancestor": ancestor, |
| 467 "ancestors": ancestors, | |
|
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
468 "author": author, |
| 11275 | 469 "branch": branch, |
|
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
470 "children": children, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
471 "closed": closed, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
472 "contains": contains, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
473 "date": date, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
474 "descendants": descendants, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
475 "file": hasfile, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
476 "follow": follow, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
477 "grep": grep, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
478 "head": head, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
479 "heads": heads, |
| 11275 | 480 "keyword": keyword, |
|
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
481 "limit": limit, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
482 "max": maxrev, |
|
11708
ba65d61f3158
revset: add min function
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11650
diff
changeset
|
483 "min": minrev, |
|
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
484 "merge": merge, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
485 "modifies": modifies, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
486 "outgoing": outgoing, |
| 11275 | 487 "p1": p1, |
| 488 "p2": p2, | |
| 489 "parents": parents, | |
|
11944
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
490 "present": present, |
|
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
491 "removes": removes, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
492 "reverse": reverse, |
| 11275 | 493 "roots": roots, |
|
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
494 "sort": sort, |
|
11280
a5eb0bf7e158
revset: add tagged predicate
Matt Mackall <mpm@selenic.com>
parents:
11279
diff
changeset
|
495 "tagged": tagged, |
|
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
496 "user": author, |
| 11275 | 497 } |
| 498 | |
| 499 methods = { | |
| 500 "range": rangeset, | |
| 501 "string": stringset, | |
| 502 "symbol": symbolset, | |
| 503 "and": andset, | |
| 504 "or": orset, | |
| 505 "not": notset, | |
| 506 "list": listset, | |
| 507 "func": func, | |
| 508 } | |
| 509 | |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
510 def optimize(x, small): |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
511 if x == None: |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
512 return 0, x |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
513 |
| 11275 | 514 smallbonus = 1 |
| 515 if small: | |
| 516 smallbonus = .5 | |
| 517 | |
| 518 op = x[0] | |
|
11283
a6356b2695a3
revset: fix - handling in the optimizer
Matt Mackall <mpm@selenic.com>
parents:
11282
diff
changeset
|
519 if op == 'minus': |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
520 return optimize(('and', x[1], ('not', x[2])), small) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
521 elif op == 'dagrange': |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
522 return optimize(('and', ('func', ('symbol', 'descendants'), x[1]), |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
523 ('func', ('symbol', 'ancestors'), x[2])), small) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
524 elif op == 'dagrangepre': |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
525 return optimize(('func', ('symbol', 'ancestors'), x[1]), small) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
526 elif op == 'dagrangepost': |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
527 return optimize(('func', ('symbol', 'descendants'), x[1]), small) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
528 elif op == 'rangepre': |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
529 return optimize(('range', ('string', '0'), x[1]), small) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
530 elif op == 'rangepost': |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
531 return optimize(('range', x[1], ('string', 'tip')), small) |
|
11467
6b836d5c8c9e
revset: make negate work for sort specs
Matt Mackall <mpm@selenic.com>
parents:
11456
diff
changeset
|
532 elif op == 'negate': |
|
6b836d5c8c9e
revset: make negate work for sort specs
Matt Mackall <mpm@selenic.com>
parents:
11456
diff
changeset
|
533 return optimize(('string', |
|
6b836d5c8c9e
revset: make negate work for sort specs
Matt Mackall <mpm@selenic.com>
parents:
11456
diff
changeset
|
534 '-' + getstring(x[1], _("can't negate that"))), small) |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
535 elif op in 'string symbol negate': |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
536 return smallbonus, x # single revisions are small |
| 11275 | 537 elif op == 'and' or op == 'dagrange': |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
538 wa, ta = optimize(x[1], True) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
539 wb, tb = optimize(x[2], True) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
540 w = min(wa, wb) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
541 if wa > wb: |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
542 return w, (op, tb, ta) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
543 return w, (op, ta, tb) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
544 elif op == 'or': |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
545 wa, ta = optimize(x[1], False) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
546 wb, tb = optimize(x[2], False) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
547 if wb < wa: |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
548 wb, wa = wa, wb |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
549 return max(wa, wb), (op, ta, tb) |
| 11275 | 550 elif op == 'not': |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
551 o = optimize(x[1], not small) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
552 return o[0], (op, o[1]) |
| 11275 | 553 elif op == 'group': |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
554 return optimize(x[1], small) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
555 elif op in 'range list': |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
556 wa, ta = optimize(x[1], small) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
557 wb, tb = optimize(x[2], small) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
558 return wa + wb, (op, ta, tb) |
| 11275 | 559 elif op == 'func': |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
560 f = getstring(x[1], _("not a symbol")) |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
561 wa, ta = optimize(x[2], small) |
| 11275 | 562 if f in "grep date user author keyword branch file": |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
563 w = 10 # slow |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
564 elif f in "modifies adds removes outgoing": |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
565 w = 30 # slower |
| 11275 | 566 elif f == "contains": |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
567 w = 100 # very slow |
| 11275 | 568 elif f == "ancestor": |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
569 w = 1 * smallbonus |
| 11275 | 570 elif f == "reverse limit": |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
571 w = 0 |
| 11275 | 572 elif f in "sort": |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
573 w = 10 # assume most sorts look at changelog |
| 11275 | 574 else: |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
575 w = 1 |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
576 return w + wa, (op, x[1], ta) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
577 return 1, x |
| 11275 | 578 |
| 579 parse = parser.parser(tokenize, elements).parse | |
| 580 | |
| 581 def match(spec): | |
|
11385
e5a2134c083b
revset: nicer exception for empty queries
Matt Mackall <mpm@selenic.com>
parents:
11383
diff
changeset
|
582 if not spec: |
|
e5a2134c083b
revset: nicer exception for empty queries
Matt Mackall <mpm@selenic.com>
parents:
11383
diff
changeset
|
583 raise error.ParseError(_("empty query")) |
| 11275 | 584 tree = parse(spec) |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
585 weight, tree = optimize(tree, True) |
| 11275 | 586 def mfunc(repo, subset): |
| 587 return getset(repo, subset, tree) | |
| 588 return mfunc |