Mercurial > public > mercurial-scm > hg-stable
annotate mercurial/revset.py @ 12929:515c2786e1cf
revsets: let parents() return parents of working dir
This patch makes the 'set' argument to revset function parents() optional.
Like p1() and p2(), if no argument is given, returns the parent(s) of the
working directory.
Morally equivalent to 'p1()+p2()', as expected.
| author | Kevin Bullock <kbullock@ringworld.org> |
|---|---|
| date | Thu, 04 Nov 2010 17:09:00 -0500 |
| parents | a5f7f1e9340e |
| children | 98b79c892768 |
| 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 |
|
12085
6f833fc3ccab
Consistently import foo as foomod when foo to avoid shadowing
Martin Geisler <mg@aragost.com>
parents:
11944
diff
changeset
|
10 import match as matchmod |
|
12855
d01c21002e82
i18n: translate revset predicate docstrings
Wagner Bruna <wbruna@yahoo.com>
parents:
12823
diff
changeset
|
11 from i18n import _, gettext |
| 11275 | 12 |
| 13 elements = { | |
| 14 "(": (20, ("group", 1, ")"), ("func", 1, ")")), | |
|
12616
e797fdf91df4
revset: lower precedence of minus infix (issue2361)
Matt Mackall <mpm@selenic.com>
parents:
12615
diff
changeset
|
15 "-": (5, ("negate", 19), ("minus", 5)), |
|
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) |
|
12408
78a97859b90d
revset: support raw string literals
Brodie Rao <brodie@bitheap.org>
parents:
12401
diff
changeset
|
51 elif (c in '"\'' or c == 'r' and |
|
78a97859b90d
revset: support raw string literals
Brodie Rao <brodie@bitheap.org>
parents:
12401
diff
changeset
|
52 program[pos:pos + 2] in ("r'", 'r"')): # handle quoted strings |
|
78a97859b90d
revset: support raw string literals
Brodie Rao <brodie@bitheap.org>
parents:
12401
diff
changeset
|
53 if c == 'r': |
|
78a97859b90d
revset: support raw string literals
Brodie Rao <brodie@bitheap.org>
parents:
12401
diff
changeset
|
54 pos += 1 |
|
78a97859b90d
revset: support raw string literals
Brodie Rao <brodie@bitheap.org>
parents:
12401
diff
changeset
|
55 c = program[pos] |
|
78a97859b90d
revset: support raw string literals
Brodie Rao <brodie@bitheap.org>
parents:
12401
diff
changeset
|
56 decode = lambda x: x |
|
78a97859b90d
revset: support raw string literals
Brodie Rao <brodie@bitheap.org>
parents:
12401
diff
changeset
|
57 else: |
|
78a97859b90d
revset: support raw string literals
Brodie Rao <brodie@bitheap.org>
parents:
12401
diff
changeset
|
58 decode = lambda x: x.decode('string-escape') |
| 11275 | 59 pos += 1 |
| 60 s = pos | |
| 61 while pos < l: # find closing quote | |
| 62 d = program[pos] | |
| 63 if d == '\\': # skip over escaped characters | |
| 64 pos += 2 | |
| 65 continue | |
| 66 if d == c: | |
|
12408
78a97859b90d
revset: support raw string literals
Brodie Rao <brodie@bitheap.org>
parents:
12401
diff
changeset
|
67 yield ('string', decode(program[s:pos]), s) |
| 11275 | 68 break |
| 69 pos += 1 | |
| 70 else: | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
71 raise error.ParseError(_("unterminated string"), s) |
|
11404
37cbedbeae96
revset: allow extended characters in symbols
Matt Mackall <mpm@selenic.com>
parents:
11385
diff
changeset
|
72 elif c.isalnum() or c in '._' or ord(c) > 127: # gather up a symbol/keyword |
| 11275 | 73 s = pos |
| 74 pos += 1 | |
| 75 while pos < l: # find end of symbol | |
| 76 d = program[pos] | |
|
11404
37cbedbeae96
revset: allow extended characters in symbols
Matt Mackall <mpm@selenic.com>
parents:
11385
diff
changeset
|
77 if not (d.isalnum() or d in "._" or ord(d) > 127): |
| 11275 | 78 break |
| 79 if d == '.' and program[pos - 1] == '.': # special case for .. | |
| 80 pos -= 1 | |
| 81 break | |
| 82 pos += 1 | |
| 83 sym = program[s:pos] | |
| 84 if sym in keywords: # operator keywords | |
|
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
85 yield (sym, None, s) |
| 11275 | 86 else: |
|
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
87 yield ('symbol', sym, s) |
| 11275 | 88 pos -= 1 |
| 89 else: | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
90 raise error.ParseError(_("syntax error"), pos) |
| 11275 | 91 pos += 1 |
|
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
92 yield ('end', None, pos) |
| 11275 | 93 |
| 94 # helpers | |
| 95 | |
| 96 def getstring(x, err): | |
|
11406
42408cd43f55
revset: fix up contains/getstring when no args passed
Matt Mackall <mpm@selenic.com>
parents:
11404
diff
changeset
|
97 if x and (x[0] == 'string' or x[0] == 'symbol'): |
| 11275 | 98 return x[1] |
|
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
99 raise error.ParseError(err) |
| 11275 | 100 |
| 101 def getlist(x): | |
| 102 if not x: | |
| 103 return [] | |
| 104 if x[0] == 'list': | |
| 105 return getlist(x[1]) + [x[2]] | |
| 106 return [x] | |
| 107 | |
|
11339
744d5b73f776
revset: improve filter argument handling
Matt Mackall <mpm@selenic.com>
parents:
11304
diff
changeset
|
108 def getargs(x, min, max, err): |
| 11275 | 109 l = getlist(x) |
|
11339
744d5b73f776
revset: improve filter argument handling
Matt Mackall <mpm@selenic.com>
parents:
11304
diff
changeset
|
110 if len(l) < min or len(l) > max: |
|
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
111 raise error.ParseError(err) |
| 11275 | 112 return l |
| 113 | |
| 114 def getset(repo, subset, x): | |
| 115 if not x: | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
116 raise error.ParseError(_("missing argument")) |
| 11275 | 117 return methods[x[0]](repo, subset, *x[1:]) |
| 118 | |
| 119 # operator methods | |
| 120 | |
| 121 def stringset(repo, subset, x): | |
| 122 x = repo[x].rev() | |
| 11282 | 123 if x == -1 and len(subset) == len(repo): |
| 124 return [-1] | |
| 11275 | 125 if x in subset: |
| 126 return [x] | |
| 127 return [] | |
| 128 | |
| 129 def symbolset(repo, subset, x): | |
| 130 if x in symbols: | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
131 raise error.ParseError(_("can't use %s here") % x) |
| 11275 | 132 return stringset(repo, subset, x) |
| 133 | |
| 134 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
|
135 m = getset(repo, subset, x) |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
136 if not m: |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
137 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
|
138 |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
139 n = getset(repo, subset, y) |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
140 if not n: |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
141 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
|
142 |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
143 if not m or not n: |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
144 return [] |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
145 m, n = m[0], n[-1] |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
146 |
| 11275 | 147 if m < n: |
|
11456
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
148 r = range(m, n + 1) |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
149 else: |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
150 r = range(m, n - 1, -1) |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
151 s = set(subset) |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
152 return [x for x in r if x in s] |
| 11275 | 153 |
| 154 def andset(repo, subset, x, y): | |
| 155 return getset(repo, getset(repo, subset, x), y) | |
| 156 | |
| 157 def orset(repo, subset, x, y): | |
| 158 s = set(getset(repo, subset, x)) | |
| 159 s |= set(getset(repo, [r for r in subset if r not in s], y)) | |
| 160 return [r for r in subset if r in s] | |
| 161 | |
| 162 def notset(repo, subset, x): | |
| 163 s = set(getset(repo, subset, x)) | |
| 164 return [r for r in subset if r not in s] | |
| 165 | |
| 166 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
|
167 raise error.ParseError(_("can't use a list in this context")) |
| 11275 | 168 |
| 169 def func(repo, subset, a, b): | |
| 170 if a[0] == 'symbol' and a[1] in symbols: | |
| 171 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
|
172 raise error.ParseError(_("not a function: %s") % a[1]) |
| 11275 | 173 |
| 174 # functions | |
| 175 | |
|
12716
c7e619e30ba3
revset: add id() and rev() to allow explicitly referring to changes by hash or rev
Augie Fackler <durin42@gmail.com>
parents:
12715
diff
changeset
|
176 def node(repo, subset, x): |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
177 """``id(string)`` |
|
12859
76066903ae08
revset: fix missing dot in docstring
Wagner Bruna <wbruna@yahoo.com>
parents:
12855
diff
changeset
|
178 Revision non-ambiguously specified by the given hex string prefix. |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
179 """ |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
180 # i18n: "id" is a keyword |
|
12736
7e14e67e6622
revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12733
diff
changeset
|
181 l = getargs(x, 1, 1, _("id requires one argument")) |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
182 # i18n: "id" is a keyword |
|
12736
7e14e67e6622
revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12733
diff
changeset
|
183 n = getstring(l[0], _("id requires a string")) |
|
12716
c7e619e30ba3
revset: add id() and rev() to allow explicitly referring to changes by hash or rev
Augie Fackler <durin42@gmail.com>
parents:
12715
diff
changeset
|
184 if len(n) == 40: |
|
c7e619e30ba3
revset: add id() and rev() to allow explicitly referring to changes by hash or rev
Augie Fackler <durin42@gmail.com>
parents:
12715
diff
changeset
|
185 rn = repo[n].rev() |
|
c7e619e30ba3
revset: add id() and rev() to allow explicitly referring to changes by hash or rev
Augie Fackler <durin42@gmail.com>
parents:
12715
diff
changeset
|
186 else: |
|
c7e619e30ba3
revset: add id() and rev() to allow explicitly referring to changes by hash or rev
Augie Fackler <durin42@gmail.com>
parents:
12715
diff
changeset
|
187 rn = repo.changelog.rev(repo.changelog._partialmatch(n)) |
|
c7e619e30ba3
revset: add id() and rev() to allow explicitly referring to changes by hash or rev
Augie Fackler <durin42@gmail.com>
parents:
12715
diff
changeset
|
188 return [r for r in subset if r == rn] |
|
c7e619e30ba3
revset: add id() and rev() to allow explicitly referring to changes by hash or rev
Augie Fackler <durin42@gmail.com>
parents:
12715
diff
changeset
|
189 |
|
c7e619e30ba3
revset: add id() and rev() to allow explicitly referring to changes by hash or rev
Augie Fackler <durin42@gmail.com>
parents:
12715
diff
changeset
|
190 def rev(repo, subset, x): |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
191 """``rev(number)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
192 Revision with the given numeric identifier. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
193 """ |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
194 # i18n: "rev" is a keyword |
|
12736
7e14e67e6622
revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12733
diff
changeset
|
195 l = getargs(x, 1, 1, _("rev requires one argument")) |
|
12716
c7e619e30ba3
revset: add id() and rev() to allow explicitly referring to changes by hash or rev
Augie Fackler <durin42@gmail.com>
parents:
12715
diff
changeset
|
196 try: |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
197 # i18n: "rev" is a keyword |
|
12736
7e14e67e6622
revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12733
diff
changeset
|
198 l = int(getstring(l[0], _("rev requires a number"))) |
|
12716
c7e619e30ba3
revset: add id() and rev() to allow explicitly referring to changes by hash or rev
Augie Fackler <durin42@gmail.com>
parents:
12715
diff
changeset
|
199 except ValueError: |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
200 # i18n: "rev" is a keyword |
|
12716
c7e619e30ba3
revset: add id() and rev() to allow explicitly referring to changes by hash or rev
Augie Fackler <durin42@gmail.com>
parents:
12715
diff
changeset
|
201 raise error.ParseError(_("rev expects a number")) |
|
c7e619e30ba3
revset: add id() and rev() to allow explicitly referring to changes by hash or rev
Augie Fackler <durin42@gmail.com>
parents:
12715
diff
changeset
|
202 return [r for r in subset if r == l] |
|
c7e619e30ba3
revset: add id() and rev() to allow explicitly referring to changes by hash or rev
Augie Fackler <durin42@gmail.com>
parents:
12715
diff
changeset
|
203 |
| 11275 | 204 def p1(repo, subset, x): |
|
12928
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
205 """``p1([set])`` |
|
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
206 First parent of changesets in set, or the working directory. |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
207 """ |
|
12928
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
208 if x is None: |
|
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
209 return [repo[x].parents()[0].rev()] |
|
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
210 |
| 11275 | 211 ps = set() |
| 212 cl = repo.changelog | |
|
12786
9aae04f4fcf6
revset: disable subset optimization for parents() and children() (issue2437)
Wagner Bruna <wbruna@yahoo.com>
parents:
12736
diff
changeset
|
213 for r in getset(repo, range(len(repo)), x): |
| 11275 | 214 ps.add(cl.parentrevs(r)[0]) |
| 215 return [r for r in subset if r in ps] | |
| 216 | |
| 217 def p2(repo, subset, x): | |
|
12928
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
218 """``p2([set])`` |
|
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
219 Second parent of changesets in set, or the working directory. |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
220 """ |
|
12928
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
221 if x is None: |
|
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
222 ps = repo[x].parents() |
|
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
223 try: |
|
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
224 return [ps[1].rev()] |
|
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
225 except IndexError: |
|
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
226 return [] |
|
a5f7f1e9340e
revsets: let p1() and p2() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12859
diff
changeset
|
227 |
| 11275 | 228 ps = set() |
| 229 cl = repo.changelog | |
|
12786
9aae04f4fcf6
revset: disable subset optimization for parents() and children() (issue2437)
Wagner Bruna <wbruna@yahoo.com>
parents:
12736
diff
changeset
|
230 for r in getset(repo, range(len(repo)), x): |
| 11275 | 231 ps.add(cl.parentrevs(r)[1]) |
| 232 return [r for r in subset if r in ps] | |
| 233 | |
| 234 def parents(repo, subset, x): | |
|
12929
515c2786e1cf
revsets: let parents() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12928
diff
changeset
|
235 """``parents([set])`` |
|
515c2786e1cf
revsets: let parents() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12928
diff
changeset
|
236 The set of all parents for all changesets in set, or the working directory. |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
237 """ |
|
12929
515c2786e1cf
revsets: let parents() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12928
diff
changeset
|
238 repo.ui.debug(repr(x), '\n') |
|
515c2786e1cf
revsets: let parents() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12928
diff
changeset
|
239 if x is None: |
|
515c2786e1cf
revsets: let parents() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12928
diff
changeset
|
240 return [r.rev() for r in repo[x].parents()] |
|
515c2786e1cf
revsets: let parents() return parents of working dir
Kevin Bullock <kbullock@ringworld.org>
parents:
12928
diff
changeset
|
241 |
| 11275 | 242 ps = set() |
| 243 cl = repo.changelog | |
|
12786
9aae04f4fcf6
revset: disable subset optimization for parents() and children() (issue2437)
Wagner Bruna <wbruna@yahoo.com>
parents:
12736
diff
changeset
|
244 for r in getset(repo, range(len(repo)), x): |
| 11275 | 245 ps.update(cl.parentrevs(r)) |
| 246 return [r for r in subset if r in ps] | |
| 247 | |
| 248 def maxrev(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
249 """``max(set)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
250 Changeset with highest revision number in set. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
251 """ |
| 11275 | 252 s = getset(repo, subset, x) |
| 253 if s: | |
| 254 m = max(s) | |
| 255 if m in subset: | |
| 256 return [m] | |
| 257 return [] | |
| 258 | |
|
11708
ba65d61f3158
revset: add min function
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11650
diff
changeset
|
259 def minrev(repo, subset, x): |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
260 """``min(set)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
261 Changeset with lowest revision number in set. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
262 """ |
|
11708
ba65d61f3158
revset: add min function
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11650
diff
changeset
|
263 s = getset(repo, subset, x) |
|
ba65d61f3158
revset: add min function
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11650
diff
changeset
|
264 if s: |
|
ba65d61f3158
revset: add min function
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11650
diff
changeset
|
265 m = min(s) |
|
ba65d61f3158
revset: add min function
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11650
diff
changeset
|
266 if m in subset: |
|
ba65d61f3158
revset: add min function
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11650
diff
changeset
|
267 return [m] |
|
ba65d61f3158
revset: add min function
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11650
diff
changeset
|
268 return [] |
|
ba65d61f3158
revset: add min function
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11650
diff
changeset
|
269 |
| 11275 | 270 def limit(repo, subset, x): |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
271 """``limit(set, n)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
272 First n members of set. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
273 """ |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
274 # i18n: "limit" is a keyword |
|
12736
7e14e67e6622
revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12733
diff
changeset
|
275 l = getargs(x, 2, 2, _("limit requires two arguments")) |
| 11275 | 276 try: |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
277 # i18n: "limit" is a keyword |
|
12736
7e14e67e6622
revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12733
diff
changeset
|
278 lim = int(getstring(l[1], _("limit requires a number"))) |
| 11275 | 279 except ValueError: |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
280 # i18n: "limit" is a keyword |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
281 raise error.ParseError(_("limit expects a number")) |
| 11275 | 282 return getset(repo, subset, l[0])[:lim] |
| 283 | |
| 284 def children(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
285 """``children(set)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
286 Child changesets of changesets in set. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
287 """ |
| 11275 | 288 cs = set() |
| 289 cl = repo.changelog | |
|
12786
9aae04f4fcf6
revset: disable subset optimization for parents() and children() (issue2437)
Wagner Bruna <wbruna@yahoo.com>
parents:
12736
diff
changeset
|
290 s = set(getset(repo, range(len(repo)), x)) |
| 11275 | 291 for r in xrange(0, len(repo)): |
| 292 for p in cl.parentrevs(r): | |
| 293 if p in s: | |
| 294 cs.add(r) | |
| 295 return [r for r in subset if r in cs] | |
| 296 | |
| 297 def branch(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
298 """``branch(set)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
299 All changesets belonging to the branches of changesets in set. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
300 """ |
| 11275 | 301 s = getset(repo, range(len(repo)), x) |
| 302 b = set() | |
| 303 for r in s: | |
| 304 b.add(repo[r].branch()) | |
| 305 s = set(s) | |
| 306 return [r for r in subset if r in s or repo[r].branch() in b] | |
| 307 | |
| 308 def ancestor(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
309 """``ancestor(single, single)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
310 Greatest common ancestor of the two changesets. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
311 """ |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
312 # i18n: "ancestor" is a keyword |
|
12736
7e14e67e6622
revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12733
diff
changeset
|
313 l = getargs(x, 2, 2, _("ancestor requires two arguments")) |
|
11650
ebaf117c2642
revset: fix ancestor subset handling (issue2298)
Matt Mackall <mpm@selenic.com>
parents:
11467
diff
changeset
|
314 r = range(len(repo)) |
|
ebaf117c2642
revset: fix ancestor subset handling (issue2298)
Matt Mackall <mpm@selenic.com>
parents:
11467
diff
changeset
|
315 a = getset(repo, r, l[0]) |
|
ebaf117c2642
revset: fix ancestor subset handling (issue2298)
Matt Mackall <mpm@selenic.com>
parents:
11467
diff
changeset
|
316 b = getset(repo, r, l[1]) |
|
ebaf117c2642
revset: fix ancestor subset handling (issue2298)
Matt Mackall <mpm@selenic.com>
parents:
11467
diff
changeset
|
317 if len(a) != 1 or len(b) != 1: |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
318 # i18n: "ancestor" is a keyword |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
319 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
|
320 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
|
321 |
|
ebaf117c2642
revset: fix ancestor subset handling (issue2298)
Matt Mackall <mpm@selenic.com>
parents:
11467
diff
changeset
|
322 return [r for r in an if r in subset] |
| 11275 | 323 |
| 324 def ancestors(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
325 """``ancestors(set)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
326 Changesets that are ancestors of a changeset in set. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
327 """ |
| 11275 | 328 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
|
329 if not args: |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
330 return [] |
| 11275 | 331 s = set(repo.changelog.ancestors(*args)) | set(args) |
| 332 return [r for r in subset if r in s] | |
| 333 | |
| 334 def descendants(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
335 """``descendants(set)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
336 Changesets which are descendants of changesets in set. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
337 """ |
| 11275 | 338 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
|
339 if not args: |
|
88abbb046e66
revset: deal with empty sets in range endpoints
Matt Mackall <mpm@selenic.com>
parents:
11446
diff
changeset
|
340 return [] |
| 11275 | 341 s = set(repo.changelog.descendants(*args)) | set(args) |
| 342 return [r for r in subset if r in s] | |
| 343 | |
| 344 def follow(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
345 """``follow()`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
346 An alias for ``::.`` (ancestors of the working copy's first parent). |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
347 """ |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
348 # i18n: "follow" is a keyword |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
349 getargs(x, 0, 0, _("follow takes no arguments")) |
| 11275 | 350 p = repo['.'].rev() |
| 351 s = set(repo.changelog.ancestors(p)) | set([p]) | |
| 352 return [r for r in subset if r in s] | |
| 353 | |
| 354 def date(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
355 """``date(interval)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
356 Changesets within the interval, see :hg:`help dates`. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
357 """ |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
358 # i18n: "date" is a keyword |
|
12736
7e14e67e6622
revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12733
diff
changeset
|
359 ds = getstring(x, _("date requires a string")) |
| 11275 | 360 dm = util.matchdate(ds) |
| 361 return [r for r in subset if dm(repo[r].date()[0])] | |
| 362 | |
| 363 def keyword(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
364 """``keyword(string)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
365 Search commit message, user name, and names of changed files for |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
366 string. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
367 """ |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
368 # i18n: "keyword" is a keyword |
|
12736
7e14e67e6622
revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12733
diff
changeset
|
369 kw = getstring(x, _("keyword requires a string")).lower() |
| 11275 | 370 l = [] |
| 371 for r in subset: | |
| 372 c = repo[r] | |
| 373 t = " ".join(c.files() + [c.user(), c.description()]) | |
| 374 if kw in t.lower(): | |
| 375 l.append(r) | |
| 376 return l | |
| 377 | |
| 378 def grep(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
379 """``grep(regex)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
380 Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
381 to ensure special escape characters are handled correctly. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
382 """ |
|
12320
40c40c6f20b8
revset: handle re.compile() errors in grep()
Brodie Rao <brodie@bitheap.org>
parents:
11882
diff
changeset
|
383 try: |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
384 # i18n: "grep" is a keyword |
|
12736
7e14e67e6622
revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12733
diff
changeset
|
385 gr = re.compile(getstring(x, _("grep requires a string"))) |
|
12320
40c40c6f20b8
revset: handle re.compile() errors in grep()
Brodie Rao <brodie@bitheap.org>
parents:
11882
diff
changeset
|
386 except re.error, e: |
|
40c40c6f20b8
revset: handle re.compile() errors in grep()
Brodie Rao <brodie@bitheap.org>
parents:
11882
diff
changeset
|
387 raise error.ParseError(_('invalid match pattern: %s') % e) |
| 11275 | 388 l = [] |
| 389 for r in subset: | |
| 390 c = repo[r] | |
| 391 for e in c.files() + [c.user(), c.description()]: | |
| 392 if gr.search(e): | |
| 393 l.append(r) | |
| 394 continue | |
| 395 return l | |
| 396 | |
| 397 def author(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
398 """``author(string)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
399 Alias for ``user(string)``. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
400 """ |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
401 # i18n: "author" is a keyword |
|
12736
7e14e67e6622
revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12733
diff
changeset
|
402 n = getstring(x, _("author requires a string")).lower() |
| 11275 | 403 return [r for r in subset if n in repo[r].user().lower()] |
| 404 | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
405 def user(repo, subset, x): |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
406 """``user(string)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
407 User name is string. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
408 """ |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
409 return author(repo, subset, x) |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
410 |
| 11275 | 411 def hasfile(repo, subset, x): |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
412 """``file(pattern)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
413 Changesets affecting files matched by pattern. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
414 """ |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
415 # i18n: "file" is a keyword |
|
12736
7e14e67e6622
revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12733
diff
changeset
|
416 pat = getstring(x, _("file requires a pattern")) |
|
12085
6f833fc3ccab
Consistently import foo as foomod when foo to avoid shadowing
Martin Geisler <mg@aragost.com>
parents:
11944
diff
changeset
|
417 m = matchmod.match(repo.root, repo.getcwd(), [pat]) |
| 11275 | 418 s = [] |
| 419 for r in subset: | |
| 420 for f in repo[r].files(): | |
| 421 if m(f): | |
| 422 s.append(r) | |
| 423 continue | |
| 424 return s | |
| 425 | |
| 426 def contains(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
427 """``contains(pattern)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
428 Revision contains pattern. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
429 """ |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
430 # i18n: "contains" is a keyword |
|
12736
7e14e67e6622
revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12733
diff
changeset
|
431 pat = getstring(x, _("contains requires a pattern")) |
|
12085
6f833fc3ccab
Consistently import foo as foomod when foo to avoid shadowing
Martin Geisler <mg@aragost.com>
parents:
11944
diff
changeset
|
432 m = matchmod.match(repo.root, repo.getcwd(), [pat]) |
| 11275 | 433 s = [] |
| 434 if m.files() == [pat]: | |
| 435 for r in subset: | |
| 436 if pat in repo[r]: | |
| 437 s.append(r) | |
| 438 continue | |
| 439 else: | |
| 440 for r in subset: | |
| 441 for f in repo[r].manifest(): | |
| 442 if m(f): | |
| 443 s.append(r) | |
| 444 continue | |
| 445 return s | |
| 446 | |
| 447 def checkstatus(repo, subset, pat, field): | |
|
12085
6f833fc3ccab
Consistently import foo as foomod when foo to avoid shadowing
Martin Geisler <mg@aragost.com>
parents:
11944
diff
changeset
|
448 m = matchmod.match(repo.root, repo.getcwd(), [pat]) |
| 11275 | 449 s = [] |
| 450 fast = (m.files() == [pat]) | |
| 451 for r in subset: | |
| 452 c = repo[r] | |
| 453 if fast: | |
| 454 if pat not in c.files(): | |
| 455 continue | |
| 456 else: | |
| 457 for f in c.files(): | |
| 458 if m(f): | |
| 459 break | |
| 460 else: | |
| 461 continue | |
| 462 files = repo.status(c.p1().node(), c.node())[field] | |
| 463 if fast: | |
| 464 if pat in files: | |
| 465 s.append(r) | |
| 466 continue | |
| 467 else: | |
| 468 for f in files: | |
| 469 if m(f): | |
| 470 s.append(r) | |
| 471 continue | |
| 472 return s | |
| 473 | |
| 474 def modifies(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
475 """``modifies(pattern)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
476 Changesets modifying files matched by pattern. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
477 """ |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
478 # i18n: "modifies" is a keyword |
|
12736
7e14e67e6622
revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12733
diff
changeset
|
479 pat = getstring(x, _("modifies requires a pattern")) |
| 11275 | 480 return checkstatus(repo, subset, pat, 0) |
| 481 | |
| 482 def adds(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
483 """``adds(pattern)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
484 Changesets that add a file matching pattern. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
485 """ |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
486 # i18n: "adds" is a keyword |
|
12736
7e14e67e6622
revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12733
diff
changeset
|
487 pat = getstring(x, _("adds requires a pattern")) |
| 11275 | 488 return checkstatus(repo, subset, pat, 1) |
| 489 | |
| 490 def removes(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
491 """``removes(pattern)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
492 Changesets which remove files matching pattern. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
493 """ |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
494 # i18n: "removes" is a keyword |
|
12736
7e14e67e6622
revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12733
diff
changeset
|
495 pat = getstring(x, _("removes requires a pattern")) |
| 11275 | 496 return checkstatus(repo, subset, pat, 2) |
| 497 | |
| 498 def merge(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
499 """``merge()`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
500 Changeset is a merge changeset. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
501 """ |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
502 # i18n: "merge" is a keyword |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
503 getargs(x, 0, 0, _("merge takes no arguments")) |
| 11275 | 504 cl = repo.changelog |
| 505 return [r for r in subset if cl.parentrevs(r)[1] != -1] | |
| 506 | |
| 507 def closed(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
508 """``closed()`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
509 Changeset is closed. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
510 """ |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
511 # i18n: "closed" is a keyword |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
512 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
|
513 return [r for r in subset if repo[r].extra().get('close')] |
| 11275 | 514 |
| 515 def head(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
516 """``head()`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
517 Changeset is a named branch head. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
518 """ |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
519 # i18n: "head" is a keyword |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
520 getargs(x, 0, 0, _("head takes no arguments")) |
| 11275 | 521 hs = set() |
| 522 for b, ls in repo.branchmap().iteritems(): | |
| 523 hs.update(repo[h].rev() for h in ls) | |
| 524 return [r for r in subset if r in hs] | |
| 525 | |
| 526 def reverse(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
527 """``reverse(set)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
528 Reverse order of set. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
529 """ |
| 11275 | 530 l = getset(repo, subset, x) |
| 531 l.reverse() | |
| 532 return l | |
| 533 | |
|
11944
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
534 def present(repo, subset, x): |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
535 """``present(set)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
536 An empty set, if any revision in set isn't found; otherwise, |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
537 all revisions in set. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
538 """ |
|
11944
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
539 try: |
|
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
540 return getset(repo, subset, x) |
|
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
541 except error.RepoLookupError: |
|
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
542 return [] |
|
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
543 |
| 11275 | 544 def sort(repo, subset, x): |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
545 """``sort(set[, [-]key...])`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
546 Sort set by keys. The default sort order is ascending, specify a key |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
547 as ``-key`` to sort in descending order. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
548 |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
549 The keys can be: |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
550 |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
551 - ``rev`` for the revision number, |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
552 - ``branch`` for the branch name, |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
553 - ``desc`` for the commit message (description), |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
554 - ``user`` for user name (``author`` can be used as an alias), |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
555 - ``date`` for the commit date |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
556 """ |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
557 # i18n: "sort" is a keyword |
|
12736
7e14e67e6622
revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12733
diff
changeset
|
558 l = getargs(x, 1, 2, _("sort requires one or two arguments")) |
| 11275 | 559 keys = "rev" |
| 560 if len(l) == 2: | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
561 keys = getstring(l[1], _("sort spec must be a string")) |
| 11275 | 562 |
| 563 s = l[0] | |
| 564 keys = keys.split() | |
| 565 l = [] | |
| 566 def invert(s): | |
| 567 return "".join(chr(255 - ord(c)) for c in s) | |
| 568 for r in getset(repo, subset, s): | |
| 569 c = repo[r] | |
| 570 e = [] | |
| 571 for k in keys: | |
| 572 if k == 'rev': | |
| 573 e.append(r) | |
| 574 elif k == '-rev': | |
| 575 e.append(-r) | |
| 576 elif k == 'branch': | |
| 577 e.append(c.branch()) | |
| 578 elif k == '-branch': | |
| 579 e.append(invert(c.branch())) | |
| 580 elif k == 'desc': | |
| 581 e.append(c.description()) | |
| 582 elif k == '-desc': | |
| 583 e.append(invert(c.description())) | |
| 584 elif k in 'user author': | |
| 585 e.append(c.user()) | |
| 586 elif k in '-user -author': | |
| 587 e.append(invert(c.user())) | |
| 588 elif k == 'date': | |
| 589 e.append(c.date()[0]) | |
| 590 elif k == '-date': | |
| 591 e.append(-c.date()[0]) | |
| 592 else: | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
593 raise error.ParseError(_("unknown sort key %r") % k) |
| 11275 | 594 e.append(r) |
| 595 l.append(e) | |
| 596 l.sort() | |
| 597 return [e[-1] for e in l] | |
| 598 | |
| 599 def getall(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
600 """``all()`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
601 All changesets, the same as ``0:tip``. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
602 """ |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
603 # i18n: "all" is a keyword |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
604 getargs(x, 0, 0, _("all takes no arguments")) |
| 11275 | 605 return subset |
| 606 | |
| 607 def heads(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
608 """``heads(set)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
609 Members of set with no children in set. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
610 """ |
| 11275 | 611 s = getset(repo, subset, x) |
| 612 ps = set(parents(repo, subset, x)) | |
| 613 return [r for r in s if r not in ps] | |
| 614 | |
| 615 def roots(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
616 """``roots(set)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
617 Changesets with no parent changeset in set. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
618 """ |
| 11275 | 619 s = getset(repo, subset, x) |
| 620 cs = set(children(repo, subset, x)) | |
| 621 return [r for r in s if r not in cs] | |
| 622 | |
| 623 def outgoing(repo, subset, x): | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
624 """``outgoing([path])`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
625 Changesets not found in the specified destination repository, or the |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
626 default push location. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
627 """ |
|
11293
0e5ce2325795
revset: delay import of hg to avoid start-up import loops
Matt Mackall <mpm@selenic.com>
parents:
11289
diff
changeset
|
628 import hg # avoid start-up nasties |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
629 # i18n: "outgoing" is a keyword |
|
12736
7e14e67e6622
revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12733
diff
changeset
|
630 l = getargs(x, 0, 1, _("outgoing requires a repository path")) |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
631 # i18n: "outgoing" is a keyword |
|
12736
7e14e67e6622
revset: use 'requires' instead of 'wants' in error message
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
12733
diff
changeset
|
632 dest = l and getstring(l[0], _("outgoing requires a repository path")) or '' |
| 11275 | 633 dest = repo.ui.expandpath(dest or 'default-push', dest or 'default') |
| 634 dest, branches = hg.parseurl(dest) | |
|
12614
f314723f36f5
revset: fix #branch in urls for outgoing()
Adrian Buehlmann <adrian@cadifra.com>
parents:
12320
diff
changeset
|
635 revs, checkout = hg.addbranchrevs(repo, repo, branches, []) |
|
f314723f36f5
revset: fix #branch in urls for outgoing()
Adrian Buehlmann <adrian@cadifra.com>
parents:
12320
diff
changeset
|
636 if revs: |
|
f314723f36f5
revset: fix #branch in urls for outgoing()
Adrian Buehlmann <adrian@cadifra.com>
parents:
12320
diff
changeset
|
637 revs = [repo.lookup(rev) for rev in revs] |
| 11275 | 638 other = hg.repository(hg.remoteui(repo, {}), dest) |
| 639 repo.ui.pushbuffer() | |
|
11301
3d0591a66118
move discovery methods from localrepo into new discovery module
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
11293
diff
changeset
|
640 o = discovery.findoutgoing(repo, other) |
| 11275 | 641 repo.ui.popbuffer() |
| 642 cl = repo.changelog | |
|
12614
f314723f36f5
revset: fix #branch in urls for outgoing()
Adrian Buehlmann <adrian@cadifra.com>
parents:
12320
diff
changeset
|
643 o = set([cl.rev(r) for r in repo.changelog.nodesbetween(o, revs)[0]]) |
| 11275 | 644 return [r for r in subset if r in o] |
| 645 | |
|
12715
33820dccbea4
revset: rename tagged() to tag() and allow it to take an optional tag name
Augie Fackler <durin42@gmail.com>
parents:
12616
diff
changeset
|
646 def tag(repo, subset, x): |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
647 """``tag(name)`` |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
648 The specified tag by name, or all tagged revisions if no name is given. |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
649 """ |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
650 # i18n: "tag" is a keyword |
|
12715
33820dccbea4
revset: rename tagged() to tag() and allow it to take an optional tag name
Augie Fackler <durin42@gmail.com>
parents:
12616
diff
changeset
|
651 args = getargs(x, 0, 1, _("tag takes one or no arguments")) |
|
11280
a5eb0bf7e158
revset: add tagged predicate
Matt Mackall <mpm@selenic.com>
parents:
11279
diff
changeset
|
652 cl = repo.changelog |
|
12715
33820dccbea4
revset: rename tagged() to tag() and allow it to take an optional tag name
Augie Fackler <durin42@gmail.com>
parents:
12616
diff
changeset
|
653 if args: |
|
33820dccbea4
revset: rename tagged() to tag() and allow it to take an optional tag name
Augie Fackler <durin42@gmail.com>
parents:
12616
diff
changeset
|
654 tn = getstring(args[0], |
|
12815
079a618ea89d
revset: add translator comments to i18n strings
Martin Geisler <mg@lazybytes.net>
parents:
12786
diff
changeset
|
655 # i18n: "tag" is a keyword |
|
12715
33820dccbea4
revset: rename tagged() to tag() and allow it to take an optional tag name
Augie Fackler <durin42@gmail.com>
parents:
12616
diff
changeset
|
656 _('the argument to tag must be a string')) |
|
33820dccbea4
revset: rename tagged() to tag() and allow it to take an optional tag name
Augie Fackler <durin42@gmail.com>
parents:
12616
diff
changeset
|
657 s = set([cl.rev(n) for t, n in repo.tagslist() if t == tn]) |
|
33820dccbea4
revset: rename tagged() to tag() and allow it to take an optional tag name
Augie Fackler <durin42@gmail.com>
parents:
12616
diff
changeset
|
658 else: |
|
33820dccbea4
revset: rename tagged() to tag() and allow it to take an optional tag name
Augie Fackler <durin42@gmail.com>
parents:
12616
diff
changeset
|
659 s = set([cl.rev(n) for t, n in repo.tagslist() if t != 'tip']) |
|
11280
a5eb0bf7e158
revset: add tagged predicate
Matt Mackall <mpm@selenic.com>
parents:
11279
diff
changeset
|
660 return [r for r in subset if r in s] |
|
a5eb0bf7e158
revset: add tagged predicate
Matt Mackall <mpm@selenic.com>
parents:
11279
diff
changeset
|
661 |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
662 def tagged(repo, subset, x): |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
663 return tag(repo, subset, x) |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
664 |
| 11275 | 665 symbols = { |
|
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
666 "adds": adds, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
667 "all": getall, |
| 11275 | 668 "ancestor": ancestor, |
| 669 "ancestors": ancestors, | |
|
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
670 "author": author, |
| 11275 | 671 "branch": branch, |
|
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
672 "children": children, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
673 "closed": closed, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
674 "contains": contains, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
675 "date": date, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
676 "descendants": descendants, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
677 "file": hasfile, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
678 "follow": follow, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
679 "grep": grep, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
680 "head": head, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
681 "heads": heads, |
| 11275 | 682 "keyword": keyword, |
|
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
683 "limit": limit, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
684 "max": maxrev, |
|
11708
ba65d61f3158
revset: add min function
Nicolas Dumazet <nicdumz.commits@gmail.com>
parents:
11650
diff
changeset
|
685 "min": minrev, |
|
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
686 "merge": merge, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
687 "modifies": modifies, |
|
12716
c7e619e30ba3
revset: add id() and rev() to allow explicitly referring to changes by hash or rev
Augie Fackler <durin42@gmail.com>
parents:
12715
diff
changeset
|
688 "id": node, |
|
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
689 "outgoing": outgoing, |
| 11275 | 690 "p1": p1, |
| 691 "p2": p2, | |
| 692 "parents": parents, | |
|
11944
df52ff0980fe
revset: predicate to avoid lookup errors
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
11886
diff
changeset
|
693 "present": present, |
|
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
694 "removes": removes, |
|
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
695 "reverse": reverse, |
|
12716
c7e619e30ba3
revset: add id() and rev() to allow explicitly referring to changes by hash or rev
Augie Fackler <durin42@gmail.com>
parents:
12715
diff
changeset
|
696 "rev": rev, |
| 11275 | 697 "roots": roots, |
|
11284
0b5c2e82aeb5
revset: sort the predicate list
Matt Mackall <mpm@selenic.com>
parents:
11283
diff
changeset
|
698 "sort": sort, |
|
12715
33820dccbea4
revset: rename tagged() to tag() and allow it to take an optional tag name
Augie Fackler <durin42@gmail.com>
parents:
12616
diff
changeset
|
699 "tag": tag, |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
700 "tagged": tagged, |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
701 "user": user, |
| 11275 | 702 } |
| 703 | |
| 704 methods = { | |
| 705 "range": rangeset, | |
| 706 "string": stringset, | |
| 707 "symbol": symbolset, | |
| 708 "and": andset, | |
| 709 "or": orset, | |
| 710 "not": notset, | |
| 711 "list": listset, | |
| 712 "func": func, | |
| 713 } | |
| 714 | |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
715 def optimize(x, small): |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
716 if x == None: |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
717 return 0, x |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
718 |
| 11275 | 719 smallbonus = 1 |
| 720 if small: | |
| 721 smallbonus = .5 | |
| 722 | |
| 723 op = x[0] | |
|
11283
a6356b2695a3
revset: fix - handling in the optimizer
Matt Mackall <mpm@selenic.com>
parents:
11282
diff
changeset
|
724 if op == 'minus': |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
725 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
|
726 elif op == 'dagrange': |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
727 return optimize(('and', ('func', ('symbol', 'descendants'), x[1]), |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
728 ('func', ('symbol', 'ancestors'), x[2])), small) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
729 elif op == 'dagrangepre': |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
730 return optimize(('func', ('symbol', 'ancestors'), x[1]), small) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
731 elif op == 'dagrangepost': |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
732 return optimize(('func', ('symbol', 'descendants'), x[1]), small) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
733 elif op == 'rangepre': |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
734 return optimize(('range', ('string', '0'), x[1]), small) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
735 elif op == 'rangepost': |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
736 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
|
737 elif op == 'negate': |
|
6b836d5c8c9e
revset: make negate work for sort specs
Matt Mackall <mpm@selenic.com>
parents:
11456
diff
changeset
|
738 return optimize(('string', |
|
6b836d5c8c9e
revset: make negate work for sort specs
Matt Mackall <mpm@selenic.com>
parents:
11456
diff
changeset
|
739 '-' + 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
|
740 elif op in 'string symbol negate': |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
741 return smallbonus, x # single revisions are small |
| 11275 | 742 elif op == 'and' or op == 'dagrange': |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
743 wa, ta = optimize(x[1], True) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
744 wb, tb = optimize(x[2], True) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
745 w = min(wa, wb) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
746 if wa > wb: |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
747 return w, (op, tb, ta) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
748 return w, (op, ta, tb) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
749 elif op == 'or': |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
750 wa, ta = optimize(x[1], False) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
751 wb, tb = optimize(x[2], False) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
752 if wb < wa: |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
753 wb, wa = wa, wb |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
754 return max(wa, wb), (op, ta, tb) |
| 11275 | 755 elif op == 'not': |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
756 o = optimize(x[1], not small) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
757 return o[0], (op, o[1]) |
| 11275 | 758 elif op == 'group': |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
759 return optimize(x[1], small) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
760 elif op in 'range list': |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
761 wa, ta = optimize(x[1], small) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
762 wb, tb = optimize(x[2], small) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
763 return wa + wb, (op, ta, tb) |
| 11275 | 764 elif op == 'func': |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
765 f = getstring(x[1], _("not a symbol")) |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
766 wa, ta = optimize(x[2], small) |
|
12351
b913232d13c1
revsets: reduce cost of outgoing in the optimizer
Matt Mackall <mpm@selenic.com>
parents:
12321
diff
changeset
|
767 if f in "grep date user author keyword branch file outgoing": |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
768 w = 10 # slow |
|
12351
b913232d13c1
revsets: reduce cost of outgoing in the optimizer
Matt Mackall <mpm@selenic.com>
parents:
12321
diff
changeset
|
769 elif f in "modifies adds removes": |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
770 w = 30 # slower |
| 11275 | 771 elif f == "contains": |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
772 w = 100 # very slow |
| 11275 | 773 elif f == "ancestor": |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
774 w = 1 * smallbonus |
| 11275 | 775 elif f == "reverse limit": |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
776 w = 0 |
| 11275 | 777 elif f in "sort": |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
778 w = 10 # assume most sorts look at changelog |
| 11275 | 779 else: |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
780 w = 1 |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
781 return w + wa, (op, x[1], ta) |
|
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
782 return 1, x |
| 11275 | 783 |
| 784 parse = parser.parser(tokenize, elements).parse | |
| 785 | |
| 786 def match(spec): | |
|
11385
e5a2134c083b
revset: nicer exception for empty queries
Matt Mackall <mpm@selenic.com>
parents:
11383
diff
changeset
|
787 if not spec: |
|
e5a2134c083b
revset: nicer exception for empty queries
Matt Mackall <mpm@selenic.com>
parents:
11383
diff
changeset
|
788 raise error.ParseError(_("empty query")) |
| 11275 | 789 tree = parse(spec) |
|
11279
62ccf4cd6e7f
revset: optimize the parse tree directly
Matt Mackall <mpm@selenic.com>
parents:
11278
diff
changeset
|
790 weight, tree = optimize(tree, True) |
| 11275 | 791 def mfunc(repo, subset): |
| 792 return getset(repo, subset, tree) | |
| 793 return mfunc | |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
794 |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
795 def makedoc(topic, doc): |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
796 """Generate and include predicates help in revsets topic.""" |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
797 predicates = [] |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
798 for name in sorted(symbols): |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
799 text = symbols[name].__doc__ |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
800 if not text: |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
801 continue |
|
12855
d01c21002e82
i18n: translate revset predicate docstrings
Wagner Bruna <wbruna@yahoo.com>
parents:
12823
diff
changeset
|
802 text = gettext(text.rstrip()) |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
803 lines = text.splitlines() |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
804 lines[1:] = [(' ' + l.strip()) for l in lines[1:]] |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
805 predicates.append('\n'.join(lines)) |
|
12855
d01c21002e82
i18n: translate revset predicate docstrings
Wagner Bruna <wbruna@yahoo.com>
parents:
12823
diff
changeset
|
806 predicates = '\n\n'.join(predicates) |
|
12821
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
807 doc = doc.replace('.. predicatesmarker', predicates) |
|
165079e564f0
revsets: generate predicate help dynamically
Patrick Mezard <pmezard@gmail.com>
parents:
12815
diff
changeset
|
808 return doc |
|
12823
80deae3bc5ea
hggettext: handle i18nfunctions declaration for docstrings translations
Patrick Mezard <pmezard@gmail.com>
parents:
12821
diff
changeset
|
809 |
|
80deae3bc5ea
hggettext: handle i18nfunctions declaration for docstrings translations
Patrick Mezard <pmezard@gmail.com>
parents:
12821
diff
changeset
|
810 # tell hggettext to extract docstrings from these functions: |
|
80deae3bc5ea
hggettext: handle i18nfunctions declaration for docstrings translations
Patrick Mezard <pmezard@gmail.com>
parents:
12821
diff
changeset
|
811 i18nfunctions = symbols.values() |