Mercurial > public > mercurial-scm > hg-stable
annotate mercurial/fileset.py @ 31202:951d95b13487
fileset: add function to switch revision where fileset will be evaluated
If the subset isn't filtered yet, i.e. if fullmatchctx, the new subset is
recalculated from scratch. Otherwise, it is narrowed by the existing subset.
| author | Yuya Nishihara <yuya@tcha.org> |
|---|---|
| date | Sat, 24 Jan 2015 19:41:56 +0900 |
| parents | 3c3ab84e6e78 |
| children | 4140d49d2efb |
| rev | line source |
|---|---|
|
14511
30506b894359
filesets: introduce basic fileset expression parser
Matt Mackall <mpm@selenic.com>
parents:
14509
diff
changeset
|
1 # fileset.py - file set queries for mercurial |
| 11275 | 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 | |
|
25938
e194ada8d45f
fileset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
8 from __future__ import absolute_import |
|
e194ada8d45f
fileset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
9 |
|
20034
1e5b38a919dd
cleanup: move stdlib imports to their own import statement
Augie Fackler <raf@durin42.com>
parents:
19470
diff
changeset
|
10 import re |
|
25938
e194ada8d45f
fileset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
11 |
|
e194ada8d45f
fileset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
12 from .i18n import _ |
|
e194ada8d45f
fileset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
13 from . import ( |
|
e194ada8d45f
fileset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
14 error, |
|
e194ada8d45f
fileset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
15 merge, |
|
e194ada8d45f
fileset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
16 parser, |
|
28448
7108834c76a2
fileset: replace predicate by filesetpredicate of registrar (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28447
diff
changeset
|
17 registrar, |
|
25938
e194ada8d45f
fileset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
18 util, |
|
e194ada8d45f
fileset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
19 ) |
| 11275 | 20 |
| 21 elements = { | |
|
25815
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
22 # token-type: binding-strength, primary, prefix, infix, suffix |
|
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
23 "(": (20, None, ("group", 1, ")"), ("func", 1, ")"), None), |
|
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
24 "-": (5, None, ("negate", 19), ("minus", 5), None), |
|
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
25 "not": (10, None, ("not", 10), None, None), |
|
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
26 "!": (10, None, ("not", 10), None, None), |
|
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
27 "and": (5, None, None, ("and", 5), None), |
|
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
28 "&": (5, None, None, ("and", 5), None), |
|
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
29 "or": (4, None, None, ("or", 4), None), |
|
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
30 "|": (4, None, None, ("or", 4), None), |
|
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
31 "+": (4, None, None, ("or", 4), None), |
|
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
32 ",": (2, None, None, ("list", 2), None), |
|
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
33 ")": (0, None, None, None, None), |
|
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
34 "symbol": (0, "symbol", None, None, None), |
|
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
35 "string": (0, "string", None, None, None), |
|
e71e5629e006
parser: separate actions for primary expression and prefix operator
Yuya Nishihara <yuya@tcha.org>
parents:
25801
diff
changeset
|
36 "end": (0, None, None, None, None), |
| 11275 | 37 } |
| 38 | |
| 39 keywords = set(['and', 'or', 'not']) | |
| 40 | |
|
19470
19ac0d8ee9a2
fileset: handle underbar in symbols
Matt Mackall <mpm@selenic.com>
parents:
19194
diff
changeset
|
41 globchars = ".*{}[]?/\\_" |
|
14551
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
42 |
| 11275 | 43 def tokenize(program): |
| 44 pos, l = 0, len(program) | |
| 45 while pos < l: | |
| 46 c = program[pos] | |
| 47 if c.isspace(): # skip inter-token whitespace | |
| 48 pass | |
|
14511
30506b894359
filesets: introduce basic fileset expression parser
Matt Mackall <mpm@selenic.com>
parents:
14509
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: |
|
26233
d3dbb65c8dc6
fileset: handle error of string unescaping
Yuya Nishihara <yuya@tcha.org>
parents:
26195
diff
changeset
|
58 decode = parser.unescapestr |
| 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) |
|
14551
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
72 elif c.isalnum() or c in globchars or ord(c) > 127: |
| 14513 | 73 # gather up a symbol/keyword |
| 11275 | 74 s = pos |
| 75 pos += 1 | |
| 76 while pos < l: # find end of symbol | |
| 77 d = program[pos] | |
|
14551
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
78 if not (d.isalnum() or d in globchars or ord(d) > 127): |
| 11275 | 79 break |
| 80 pos += 1 | |
| 81 sym = program[s:pos] | |
| 82 if sym in keywords: # operator keywords | |
|
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
83 yield (sym, None, s) |
| 11275 | 84 else: |
|
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
85 yield ('symbol', sym, s) |
| 11275 | 86 pos -= 1 |
| 87 else: | |
|
11383
de544774ebea
revset: all your error messages are belong to _
Martin Geisler <mg@lazybytes.net>
parents:
11349
diff
changeset
|
88 raise error.ParseError(_("syntax error"), pos) |
| 11275 | 89 pos += 1 |
|
11289
4215ce511134
revset: raise ParseError exceptions
Matt Mackall <mpm@selenic.com>
parents:
11284
diff
changeset
|
90 yield ('end', None, pos) |
| 11275 | 91 |
|
20208
61a47fd64f30
fileset, revset: do not use global parser object for thread safety
Yuya Nishihara <yuya@tcha.org>
parents:
19470
diff
changeset
|
92 def parse(expr): |
|
25654
af329a84310c
parser: accept iterator of tokens instead of tokenizer function and program
Yuya Nishihara <yuya@tcha.org>
parents:
25633
diff
changeset
|
93 p = parser.parser(elements) |
|
af329a84310c
parser: accept iterator of tokens instead of tokenizer function and program
Yuya Nishihara <yuya@tcha.org>
parents:
25633
diff
changeset
|
94 tree, pos = p.parse(tokenize(expr)) |
|
25252
ac381dd7a21f
fileset: move validation of incomplete parsing to parse() function
Yuya Nishihara <yuya@tcha.org>
parents:
24408
diff
changeset
|
95 if pos != len(expr): |
|
ac381dd7a21f
fileset: move validation of incomplete parsing to parse() function
Yuya Nishihara <yuya@tcha.org>
parents:
24408
diff
changeset
|
96 raise error.ParseError(_("invalid token"), pos) |
|
ac381dd7a21f
fileset: move validation of incomplete parsing to parse() function
Yuya Nishihara <yuya@tcha.org>
parents:
24408
diff
changeset
|
97 return tree |
| 11275 | 98 |
|
14551
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
99 def getstring(x, err): |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
100 if x and (x[0] == 'string' or x[0] == 'symbol'): |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
101 return x[1] |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
102 raise error.ParseError(err) |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
103 |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
104 def getset(mctx, x): |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
105 if not x: |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
106 raise error.ParseError(_("missing argument")) |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
107 return methods[x[0]](mctx, *x[1:]) |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
108 |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
109 def stringset(mctx, x): |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
110 m = mctx.matcher([x]) |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
111 return [f for f in mctx.subset if m(f)] |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
112 |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
113 def andset(mctx, x, y): |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
114 return getset(mctx.narrow(getset(mctx, x)), y) |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
115 |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
116 def orset(mctx, x, y): |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
117 # needs optimizing |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
118 xl = getset(mctx, x) |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
119 yl = getset(mctx, y) |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
120 return xl + [f for f in yl if f not in xl] |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
121 |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
122 def notset(mctx, x): |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
123 s = set(getset(mctx, x)) |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
124 return [r for r in mctx.subset if r not in s] |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
125 |
|
17363
5d9e2031c0b1
fileset: actually implement 'minusset'
Patrick Mezard <patrick@mezard.eu>
parents:
16443
diff
changeset
|
126 def minusset(mctx, x, y): |
|
5d9e2031c0b1
fileset: actually implement 'minusset'
Patrick Mezard <patrick@mezard.eu>
parents:
16443
diff
changeset
|
127 xl = getset(mctx, x) |
|
5d9e2031c0b1
fileset: actually implement 'minusset'
Patrick Mezard <patrick@mezard.eu>
parents:
16443
diff
changeset
|
128 yl = set(getset(mctx, y)) |
|
5d9e2031c0b1
fileset: actually implement 'minusset'
Patrick Mezard <patrick@mezard.eu>
parents:
16443
diff
changeset
|
129 return [f for f in xl if f not in yl] |
|
5d9e2031c0b1
fileset: actually implement 'minusset'
Patrick Mezard <patrick@mezard.eu>
parents:
16443
diff
changeset
|
130 |
|
14551
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
131 def listset(mctx, a, b): |
|
27518
737ffdabbde9
fileset: add hint for list error to use or
timeless <timeless@mozdev.org>
parents:
27464
diff
changeset
|
132 raise error.ParseError(_("can't use a list in this context"), |
|
737ffdabbde9
fileset: add hint for list error to use or
timeless <timeless@mozdev.org>
parents:
27464
diff
changeset
|
133 hint=_('see hg help "filesets.x or y"')) |
|
14551
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
134 |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
135 # symbols are callable like: |
|
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
136 # fun(mctx, x) |
|
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
137 # with: |
|
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
138 # mctx - current matchctx instance |
|
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
139 # x - argument in tree form |
|
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
140 symbols = {} |
|
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
141 |
|
27461
afa76585c955
fileset: use decorator to mark a predicate as "status caller"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27460
diff
changeset
|
142 # filesets using matchctx.status() |
|
27463
a8afdc5a7885
fileset: use set instead of list to mark predicates for efficiency (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27462
diff
changeset
|
143 _statuscallers = set() |
|
27461
afa76585c955
fileset: use decorator to mark a predicate as "status caller"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27460
diff
changeset
|
144 |
|
27462
470ea34ba593
fileset: use decorator to mark a predicate as "existing caller"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27461
diff
changeset
|
145 # filesets using matchctx.existing() |
|
27463
a8afdc5a7885
fileset: use set instead of list to mark predicates for efficiency (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27462
diff
changeset
|
146 _existingcallers = set() |
|
27462
470ea34ba593
fileset: use decorator to mark a predicate as "existing caller"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27461
diff
changeset
|
147 |
|
28448
7108834c76a2
fileset: replace predicate by filesetpredicate of registrar (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28447
diff
changeset
|
148 predicate = registrar.filesetpredicate() |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
149 |
|
27461
afa76585c955
fileset: use decorator to mark a predicate as "status caller"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27460
diff
changeset
|
150 @predicate('modified()', callstatus=True) |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
151 def modified(mctx, x): |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
152 """File that is modified according to :hg:`status`. |
|
14681
0744db5eb51c
fileset: add some function help text
Matt Mackall <mpm@selenic.com>
parents:
14680
diff
changeset
|
153 """ |
|
14785
0f0bd4d028d3
fileset: add i18n hints for keywords
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
14718
diff
changeset
|
154 # i18n: "modified" is a keyword |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
155 getargs(x, 0, 0, _("modified takes no arguments")) |
|
22924
325babf1de93
fileset: access status fields by name rather than index
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
20209
diff
changeset
|
156 s = mctx.status().modified |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
157 return [f for f in mctx.subset if f in s] |
|
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
158 |
|
27461
afa76585c955
fileset: use decorator to mark a predicate as "status caller"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27460
diff
changeset
|
159 @predicate('added()', callstatus=True) |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
160 def added(mctx, x): |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
161 """File that is added according to :hg:`status`. |
|
14681
0744db5eb51c
fileset: add some function help text
Matt Mackall <mpm@selenic.com>
parents:
14680
diff
changeset
|
162 """ |
|
14785
0f0bd4d028d3
fileset: add i18n hints for keywords
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
14718
diff
changeset
|
163 # i18n: "added" is a keyword |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
164 getargs(x, 0, 0, _("added takes no arguments")) |
|
22924
325babf1de93
fileset: access status fields by name rather than index
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
20209
diff
changeset
|
165 s = mctx.status().added |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
166 return [f for f in mctx.subset if f in s] |
|
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
167 |
|
27461
afa76585c955
fileset: use decorator to mark a predicate as "status caller"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27460
diff
changeset
|
168 @predicate('removed()', callstatus=True) |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
169 def removed(mctx, x): |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
170 """File that is removed according to :hg:`status`. |
|
14681
0744db5eb51c
fileset: add some function help text
Matt Mackall <mpm@selenic.com>
parents:
14680
diff
changeset
|
171 """ |
|
14785
0f0bd4d028d3
fileset: add i18n hints for keywords
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
14718
diff
changeset
|
172 # i18n: "removed" is a keyword |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
173 getargs(x, 0, 0, _("removed takes no arguments")) |
|
22924
325babf1de93
fileset: access status fields by name rather than index
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
20209
diff
changeset
|
174 s = mctx.status().removed |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
175 return [f for f in mctx.subset if f in s] |
|
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
176 |
|
27461
afa76585c955
fileset: use decorator to mark a predicate as "status caller"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27460
diff
changeset
|
177 @predicate('deleted()', callstatus=True) |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
178 def deleted(mctx, x): |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
179 """Alias for ``missing()``. |
|
14681
0744db5eb51c
fileset: add some function help text
Matt Mackall <mpm@selenic.com>
parents:
14680
diff
changeset
|
180 """ |
|
14785
0f0bd4d028d3
fileset: add i18n hints for keywords
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
14718
diff
changeset
|
181 # i18n: "deleted" is a keyword |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
182 getargs(x, 0, 0, _("deleted takes no arguments")) |
|
22924
325babf1de93
fileset: access status fields by name rather than index
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
20209
diff
changeset
|
183 s = mctx.status().deleted |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
184 return [f for f in mctx.subset if f in s] |
|
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
185 |
|
27461
afa76585c955
fileset: use decorator to mark a predicate as "status caller"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27460
diff
changeset
|
186 @predicate('missing()', callstatus=True) |
|
27024
ceef5fb14872
fileset: add missing() predicate (issue4925)
liscju <piotr.listkiewicz@gmail.com>
parents:
26995
diff
changeset
|
187 def missing(mctx, x): |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
188 """File that is missing according to :hg:`status`. |
|
27024
ceef5fb14872
fileset: add missing() predicate (issue4925)
liscju <piotr.listkiewicz@gmail.com>
parents:
26995
diff
changeset
|
189 """ |
|
ceef5fb14872
fileset: add missing() predicate (issue4925)
liscju <piotr.listkiewicz@gmail.com>
parents:
26995
diff
changeset
|
190 # i18n: "missing" is a keyword |
|
ceef5fb14872
fileset: add missing() predicate (issue4925)
liscju <piotr.listkiewicz@gmail.com>
parents:
26995
diff
changeset
|
191 getargs(x, 0, 0, _("missing takes no arguments")) |
|
ceef5fb14872
fileset: add missing() predicate (issue4925)
liscju <piotr.listkiewicz@gmail.com>
parents:
26995
diff
changeset
|
192 s = mctx.status().deleted |
|
ceef5fb14872
fileset: add missing() predicate (issue4925)
liscju <piotr.listkiewicz@gmail.com>
parents:
26995
diff
changeset
|
193 return [f for f in mctx.subset if f in s] |
|
ceef5fb14872
fileset: add missing() predicate (issue4925)
liscju <piotr.listkiewicz@gmail.com>
parents:
26995
diff
changeset
|
194 |
|
27461
afa76585c955
fileset: use decorator to mark a predicate as "status caller"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27460
diff
changeset
|
195 @predicate('unknown()', callstatus=True) |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
196 def unknown(mctx, x): |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
197 """File that is unknown according to :hg:`status`. These files will only be |
|
14681
0744db5eb51c
fileset: add some function help text
Matt Mackall <mpm@selenic.com>
parents:
14680
diff
changeset
|
198 considered if this predicate is used. |
|
0744db5eb51c
fileset: add some function help text
Matt Mackall <mpm@selenic.com>
parents:
14680
diff
changeset
|
199 """ |
|
14785
0f0bd4d028d3
fileset: add i18n hints for keywords
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
14718
diff
changeset
|
200 # i18n: "unknown" is a keyword |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
201 getargs(x, 0, 0, _("unknown takes no arguments")) |
|
22924
325babf1de93
fileset: access status fields by name rather than index
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
20209
diff
changeset
|
202 s = mctx.status().unknown |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
203 return [f for f in mctx.subset if f in s] |
|
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
204 |
|
27461
afa76585c955
fileset: use decorator to mark a predicate as "status caller"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27460
diff
changeset
|
205 @predicate('ignored()', callstatus=True) |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
206 def ignored(mctx, x): |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
207 """File that is ignored according to :hg:`status`. These files will only be |
|
14681
0744db5eb51c
fileset: add some function help text
Matt Mackall <mpm@selenic.com>
parents:
14680
diff
changeset
|
208 considered if this predicate is used. |
|
0744db5eb51c
fileset: add some function help text
Matt Mackall <mpm@selenic.com>
parents:
14680
diff
changeset
|
209 """ |
|
14785
0f0bd4d028d3
fileset: add i18n hints for keywords
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
14718
diff
changeset
|
210 # i18n: "ignored" is a keyword |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
211 getargs(x, 0, 0, _("ignored takes no arguments")) |
|
22924
325babf1de93
fileset: access status fields by name rather than index
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
20209
diff
changeset
|
212 s = mctx.status().ignored |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
213 return [f for f in mctx.subset if f in s] |
|
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
214 |
|
27461
afa76585c955
fileset: use decorator to mark a predicate as "status caller"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27460
diff
changeset
|
215 @predicate('clean()', callstatus=True) |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
216 def clean(mctx, x): |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
217 """File that is clean according to :hg:`status`. |
|
14681
0744db5eb51c
fileset: add some function help text
Matt Mackall <mpm@selenic.com>
parents:
14680
diff
changeset
|
218 """ |
|
14785
0f0bd4d028d3
fileset: add i18n hints for keywords
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
14718
diff
changeset
|
219 # i18n: "clean" is a keyword |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
220 getargs(x, 0, 0, _("clean takes no arguments")) |
|
22924
325babf1de93
fileset: access status fields by name rather than index
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
20209
diff
changeset
|
221 s = mctx.status().clean |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
222 return [f for f in mctx.subset if f in s] |
|
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
223 |
|
14676
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
224 def func(mctx, a, b): |
|
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
225 if a[0] == 'symbol' and a[1] in symbols: |
|
27464
c39ecb2b86b3
fileset: detect unintentional existing() invocation at runtime
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27463
diff
changeset
|
226 funcname = a[1] |
|
c39ecb2b86b3
fileset: detect unintentional existing() invocation at runtime
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27463
diff
changeset
|
227 enabled = mctx._existingenabled |
|
c39ecb2b86b3
fileset: detect unintentional existing() invocation at runtime
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27463
diff
changeset
|
228 mctx._existingenabled = funcname in _existingcallers |
|
c39ecb2b86b3
fileset: detect unintentional existing() invocation at runtime
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27463
diff
changeset
|
229 try: |
|
c39ecb2b86b3
fileset: detect unintentional existing() invocation at runtime
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27463
diff
changeset
|
230 return symbols[funcname](mctx, b) |
|
c39ecb2b86b3
fileset: detect unintentional existing() invocation at runtime
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27463
diff
changeset
|
231 finally: |
|
c39ecb2b86b3
fileset: detect unintentional existing() invocation at runtime
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27463
diff
changeset
|
232 mctx._existingenabled = enabled |
|
25633
0f44d35731d6
fileset: don't suggest private or undocumented queries
Matt Harbison <matt_harbison@yahoo.com>
parents:
25255
diff
changeset
|
233 |
|
0f44d35731d6
fileset: don't suggest private or undocumented queries
Matt Harbison <matt_harbison@yahoo.com>
parents:
25255
diff
changeset
|
234 keep = lambda fn: getattr(fn, '__doc__', None) is not None |
|
0f44d35731d6
fileset: don't suggest private or undocumented queries
Matt Harbison <matt_harbison@yahoo.com>
parents:
25255
diff
changeset
|
235 |
|
0f44d35731d6
fileset: don't suggest private or undocumented queries
Matt Harbison <matt_harbison@yahoo.com>
parents:
25255
diff
changeset
|
236 syms = [s for (s, fn) in symbols.items() if keep(fn)] |
|
0f44d35731d6
fileset: don't suggest private or undocumented queries
Matt Harbison <matt_harbison@yahoo.com>
parents:
25255
diff
changeset
|
237 raise error.UnknownIdentifier(a[1], syms) |
|
14676
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
238 |
|
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
239 def getlist(x): |
|
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
240 if not x: |
|
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
241 return [] |
|
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
242 if x[0] == 'list': |
|
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
243 return getlist(x[1]) + [x[2]] |
|
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
244 return [x] |
|
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
245 |
|
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
246 def getargs(x, min, max, err): |
|
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
247 l = getlist(x) |
|
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
248 if len(l) < min or len(l) > max: |
|
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
249 raise error.ParseError(err) |
|
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
250 return l |
|
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
251 |
|
27462
470ea34ba593
fileset: use decorator to mark a predicate as "existing caller"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27461
diff
changeset
|
252 @predicate('binary()', callexisting=True) |
|
14676
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
253 def binary(mctx, x): |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
254 """File that appears to be binary (contains NUL bytes). |
|
14681
0744db5eb51c
fileset: add some function help text
Matt Mackall <mpm@selenic.com>
parents:
14680
diff
changeset
|
255 """ |
|
14785
0f0bd4d028d3
fileset: add i18n hints for keywords
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
14718
diff
changeset
|
256 # i18n: "binary" is a keyword |
|
14676
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
257 getargs(x, 0, 0, _("binary takes no arguments")) |
|
15963
042e84e39dee
fileset: don't attempt to check data predicates against removed files
Matt Mackall <mpm@selenic.com>
parents:
14830
diff
changeset
|
258 return [f for f in mctx.existing() if util.binary(mctx.ctx[f].data())] |
|
14676
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
259 |
|
27462
470ea34ba593
fileset: use decorator to mark a predicate as "existing caller"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27461
diff
changeset
|
260 @predicate('exec()', callexisting=True) |
|
14676
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
261 def exec_(mctx, x): |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
262 """File that is marked as executable. |
|
14681
0744db5eb51c
fileset: add some function help text
Matt Mackall <mpm@selenic.com>
parents:
14680
diff
changeset
|
263 """ |
|
14785
0f0bd4d028d3
fileset: add i18n hints for keywords
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
14718
diff
changeset
|
264 # i18n: "exec" is a keyword |
|
14676
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
265 getargs(x, 0, 0, _("exec takes no arguments")) |
|
15963
042e84e39dee
fileset: don't attempt to check data predicates against removed files
Matt Mackall <mpm@selenic.com>
parents:
14830
diff
changeset
|
266 return [f for f in mctx.existing() if mctx.ctx.flags(f) == 'x'] |
|
14676
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
267 |
|
27462
470ea34ba593
fileset: use decorator to mark a predicate as "existing caller"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27461
diff
changeset
|
268 @predicate('symlink()', callexisting=True) |
|
14676
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
269 def symlink(mctx, x): |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
270 """File that is marked as a symlink. |
|
14681
0744db5eb51c
fileset: add some function help text
Matt Mackall <mpm@selenic.com>
parents:
14680
diff
changeset
|
271 """ |
|
14785
0f0bd4d028d3
fileset: add i18n hints for keywords
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
14718
diff
changeset
|
272 # i18n: "symlink" is a keyword |
|
14676
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
273 getargs(x, 0, 0, _("symlink takes no arguments")) |
|
15963
042e84e39dee
fileset: don't attempt to check data predicates against removed files
Matt Mackall <mpm@selenic.com>
parents:
14830
diff
changeset
|
274 return [f for f in mctx.existing() if mctx.ctx.flags(f) == 'l'] |
|
14676
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
275 |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
276 @predicate('resolved()') |
|
14679
e141e1cee0cc
fileset: add resolved and unresolved predicates
Matt Mackall <mpm@selenic.com>
parents:
14678
diff
changeset
|
277 def resolved(mctx, x): |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
278 """File that is marked resolved according to :hg:`resolve -l`. |
|
14681
0744db5eb51c
fileset: add some function help text
Matt Mackall <mpm@selenic.com>
parents:
14680
diff
changeset
|
279 """ |
|
14785
0f0bd4d028d3
fileset: add i18n hints for keywords
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
14718
diff
changeset
|
280 # i18n: "resolved" is a keyword |
|
14679
e141e1cee0cc
fileset: add resolved and unresolved predicates
Matt Mackall <mpm@selenic.com>
parents:
14678
diff
changeset
|
281 getargs(x, 0, 0, _("resolved takes no arguments")) |
|
e141e1cee0cc
fileset: add resolved and unresolved predicates
Matt Mackall <mpm@selenic.com>
parents:
14678
diff
changeset
|
282 if mctx.ctx.rev() is not None: |
|
e141e1cee0cc
fileset: add resolved and unresolved predicates
Matt Mackall <mpm@selenic.com>
parents:
14678
diff
changeset
|
283 return [] |
|
26995
d5a6be56970b
fileset: switch to mergestate.read()
Siddharth Agarwal <sid0@fb.com>
parents:
26587
diff
changeset
|
284 ms = merge.mergestate.read(mctx.ctx.repo()) |
|
14679
e141e1cee0cc
fileset: add resolved and unresolved predicates
Matt Mackall <mpm@selenic.com>
parents:
14678
diff
changeset
|
285 return [f for f in mctx.subset if f in ms and ms[f] == 'r'] |
|
e141e1cee0cc
fileset: add resolved and unresolved predicates
Matt Mackall <mpm@selenic.com>
parents:
14678
diff
changeset
|
286 |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
287 @predicate('unresolved()') |
|
14679
e141e1cee0cc
fileset: add resolved and unresolved predicates
Matt Mackall <mpm@selenic.com>
parents:
14678
diff
changeset
|
288 def unresolved(mctx, x): |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
289 """File that is marked unresolved according to :hg:`resolve -l`. |
|
14681
0744db5eb51c
fileset: add some function help text
Matt Mackall <mpm@selenic.com>
parents:
14680
diff
changeset
|
290 """ |
|
14785
0f0bd4d028d3
fileset: add i18n hints for keywords
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
14718
diff
changeset
|
291 # i18n: "unresolved" is a keyword |
|
14679
e141e1cee0cc
fileset: add resolved and unresolved predicates
Matt Mackall <mpm@selenic.com>
parents:
14678
diff
changeset
|
292 getargs(x, 0, 0, _("unresolved takes no arguments")) |
|
e141e1cee0cc
fileset: add resolved and unresolved predicates
Matt Mackall <mpm@selenic.com>
parents:
14678
diff
changeset
|
293 if mctx.ctx.rev() is not None: |
|
e141e1cee0cc
fileset: add resolved and unresolved predicates
Matt Mackall <mpm@selenic.com>
parents:
14678
diff
changeset
|
294 return [] |
|
26995
d5a6be56970b
fileset: switch to mergestate.read()
Siddharth Agarwal <sid0@fb.com>
parents:
26587
diff
changeset
|
295 ms = merge.mergestate.read(mctx.ctx.repo()) |
|
14679
e141e1cee0cc
fileset: add resolved and unresolved predicates
Matt Mackall <mpm@selenic.com>
parents:
14678
diff
changeset
|
296 return [f for f in mctx.subset if f in ms and ms[f] == 'u'] |
|
e141e1cee0cc
fileset: add resolved and unresolved predicates
Matt Mackall <mpm@selenic.com>
parents:
14678
diff
changeset
|
297 |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
298 @predicate('hgignore()') |
| 14680 | 299 def hgignore(mctx, x): |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
300 """File that matches the active .hgignore pattern. |
|
14681
0744db5eb51c
fileset: add some function help text
Matt Mackall <mpm@selenic.com>
parents:
14680
diff
changeset
|
301 """ |
|
23113
c2dd79ad99cb
i18n: add i18n comment to error messages of filesets predicates
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22924
diff
changeset
|
302 # i18n: "hgignore" is a keyword |
| 14680 | 303 getargs(x, 0, 0, _("hgignore takes no arguments")) |
|
24334
eda2f36889b5
fileset: replace 'ctx._repo' with 'ctx.repo()'
Matt Harbison <matt_harbison@yahoo.com>
parents:
24218
diff
changeset
|
304 ignore = mctx.ctx.repo().dirstate._ignore |
| 14680 | 305 return [f for f in mctx.subset if ignore(f)] |
| 306 | |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
307 @predicate('portable()') |
|
24408
caa6b6c65dc3
fileset: add a fileset for portable filenames
Siddharth Agarwal <sid0@fb.com>
parents:
24334
diff
changeset
|
308 def portable(mctx, x): |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
309 """File that has a portable name. (This doesn't include filenames with case |
|
24408
caa6b6c65dc3
fileset: add a fileset for portable filenames
Siddharth Agarwal <sid0@fb.com>
parents:
24334
diff
changeset
|
310 collisions.) |
|
caa6b6c65dc3
fileset: add a fileset for portable filenames
Siddharth Agarwal <sid0@fb.com>
parents:
24334
diff
changeset
|
311 """ |
|
caa6b6c65dc3
fileset: add a fileset for portable filenames
Siddharth Agarwal <sid0@fb.com>
parents:
24334
diff
changeset
|
312 # i18n: "portable" is a keyword |
|
caa6b6c65dc3
fileset: add a fileset for portable filenames
Siddharth Agarwal <sid0@fb.com>
parents:
24334
diff
changeset
|
313 getargs(x, 0, 0, _("portable takes no arguments")) |
|
caa6b6c65dc3
fileset: add a fileset for portable filenames
Siddharth Agarwal <sid0@fb.com>
parents:
24334
diff
changeset
|
314 checkwinfilename = util.checkwinfilename |
|
caa6b6c65dc3
fileset: add a fileset for portable filenames
Siddharth Agarwal <sid0@fb.com>
parents:
24334
diff
changeset
|
315 return [f for f in mctx.subset if checkwinfilename(f) is None] |
|
caa6b6c65dc3
fileset: add a fileset for portable filenames
Siddharth Agarwal <sid0@fb.com>
parents:
24334
diff
changeset
|
316 |
|
27462
470ea34ba593
fileset: use decorator to mark a predicate as "existing caller"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27461
diff
changeset
|
317 @predicate('grep(regex)', callexisting=True) |
|
14682
8785fd757077
fileset: add grep predicate
Matt Mackall <mpm@selenic.com>
parents:
14681
diff
changeset
|
318 def grep(mctx, x): |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
319 """File contains the given regular expression. |
|
14682
8785fd757077
fileset: add grep predicate
Matt Mackall <mpm@selenic.com>
parents:
14681
diff
changeset
|
320 """ |
|
17368
01cc267fc105
fileset: do not traceback on invalid grep pattern
Patrick Mezard <patrick@mezard.eu>
parents:
17367
diff
changeset
|
321 try: |
|
01cc267fc105
fileset: do not traceback on invalid grep pattern
Patrick Mezard <patrick@mezard.eu>
parents:
17367
diff
changeset
|
322 # i18n: "grep" is a keyword |
|
01cc267fc105
fileset: do not traceback on invalid grep pattern
Patrick Mezard <patrick@mezard.eu>
parents:
17367
diff
changeset
|
323 r = re.compile(getstring(x, _("grep requires a pattern"))) |
|
25660
328739ea70c3
global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25654
diff
changeset
|
324 except re.error as e: |
|
17368
01cc267fc105
fileset: do not traceback on invalid grep pattern
Patrick Mezard <patrick@mezard.eu>
parents:
17367
diff
changeset
|
325 raise error.ParseError(_('invalid match pattern: %s') % e) |
|
15963
042e84e39dee
fileset: don't attempt to check data predicates against removed files
Matt Mackall <mpm@selenic.com>
parents:
14830
diff
changeset
|
326 return [f for f in mctx.existing() if r.search(mctx.ctx[f].data())] |
|
14682
8785fd757077
fileset: add grep predicate
Matt Mackall <mpm@selenic.com>
parents:
14681
diff
changeset
|
327 |
|
14683
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
328 def _sizetomax(s): |
|
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
329 try: |
|
25925
23c4589fc678
filesets: ignore unit case in size() predicate for single value
Anton Shestakov <av6@dwimlabs.net>
parents:
25815
diff
changeset
|
330 s = s.strip().lower() |
|
19194
1d08df65cd3c
util: migrate fileset._sizetoint to util.sizetoint
Bryan O'Sullivan <bryano@fb.com>
parents:
18842
diff
changeset
|
331 for k, v in util._sizeunits: |
|
14683
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
332 if s.endswith(k): |
|
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
333 # max(4k) = 5k - 1, max(4.5k) = 4.6k - 1 |
|
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
334 n = s[:-len(k)] |
|
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
335 inc = 1.0 |
|
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
336 if "." in n: |
|
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
337 inc /= 10 ** len(n.split(".")[1]) |
|
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
338 return int((float(n) + inc) * v) - 1 |
|
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
339 # no extension, this is a precise value |
|
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
340 return int(s) |
|
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
341 except ValueError: |
|
14716
552329013bac
fileset: use ParseError pos field correctly
Mads Kiilerich <mads@kiilerich.com>
parents:
14701
diff
changeset
|
342 raise error.ParseError(_("couldn't parse size: %s") % s) |
|
14683
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
343 |
|
27462
470ea34ba593
fileset: use decorator to mark a predicate as "existing caller"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27461
diff
changeset
|
344 @predicate('size(expression)', callexisting=True) |
|
14683
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
345 def size(mctx, x): |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
346 """File size matches the given expression. Examples: |
|
14683
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
347 |
|
29991
d532ef155b0e
help: clarify quotes are needed for filesets.size expressions
timeless <timeless@mozdev.org>
parents:
28448
diff
changeset
|
348 - size('1k') - files from 1024 to 2047 bytes |
|
d532ef155b0e
help: clarify quotes are needed for filesets.size expressions
timeless <timeless@mozdev.org>
parents:
28448
diff
changeset
|
349 - size('< 20k') - files less than 20480 bytes |
|
d532ef155b0e
help: clarify quotes are needed for filesets.size expressions
timeless <timeless@mozdev.org>
parents:
28448
diff
changeset
|
350 - size('>= .5MB') - files at least 524288 bytes |
|
d532ef155b0e
help: clarify quotes are needed for filesets.size expressions
timeless <timeless@mozdev.org>
parents:
28448
diff
changeset
|
351 - size('4k - 1MB') - files from 4096 bytes to 1048576 bytes |
|
14683
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
352 """ |
|
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
353 |
|
14785
0f0bd4d028d3
fileset: add i18n hints for keywords
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
14718
diff
changeset
|
354 # i18n: "size" is a keyword |
|
14717
c8ee2729e89f
revset and fileset: fix typos in parser error messages
Mads Kiilerich <mads@kiilerich.com>
parents:
14716
diff
changeset
|
355 expr = getstring(x, _("size requires an expression")).strip() |
|
14683
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
356 if '-' in expr: # do we have a range? |
|
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
357 a, b = expr.split('-', 1) |
|
19194
1d08df65cd3c
util: migrate fileset._sizetoint to util.sizetoint
Bryan O'Sullivan <bryano@fb.com>
parents:
18842
diff
changeset
|
358 a = util.sizetoint(a) |
|
1d08df65cd3c
util: migrate fileset._sizetoint to util.sizetoint
Bryan O'Sullivan <bryano@fb.com>
parents:
18842
diff
changeset
|
359 b = util.sizetoint(b) |
|
14683
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
360 m = lambda x: x >= a and x <= b |
|
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
361 elif expr.startswith("<="): |
|
19194
1d08df65cd3c
util: migrate fileset._sizetoint to util.sizetoint
Bryan O'Sullivan <bryano@fb.com>
parents:
18842
diff
changeset
|
362 a = util.sizetoint(expr[2:]) |
|
14683
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
363 m = lambda x: x <= a |
|
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
364 elif expr.startswith("<"): |
|
19194
1d08df65cd3c
util: migrate fileset._sizetoint to util.sizetoint
Bryan O'Sullivan <bryano@fb.com>
parents:
18842
diff
changeset
|
365 a = util.sizetoint(expr[1:]) |
|
14683
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
366 m = lambda x: x < a |
|
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
367 elif expr.startswith(">="): |
|
19194
1d08df65cd3c
util: migrate fileset._sizetoint to util.sizetoint
Bryan O'Sullivan <bryano@fb.com>
parents:
18842
diff
changeset
|
368 a = util.sizetoint(expr[2:]) |
|
14683
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
369 m = lambda x: x >= a |
|
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
370 elif expr.startswith(">"): |
|
19194
1d08df65cd3c
util: migrate fileset._sizetoint to util.sizetoint
Bryan O'Sullivan <bryano@fb.com>
parents:
18842
diff
changeset
|
371 a = util.sizetoint(expr[1:]) |
|
14683
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
372 m = lambda x: x > a |
|
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
373 elif expr[0].isdigit or expr[0] == '.': |
|
19194
1d08df65cd3c
util: migrate fileset._sizetoint to util.sizetoint
Bryan O'Sullivan <bryano@fb.com>
parents:
18842
diff
changeset
|
374 a = util.sizetoint(expr) |
|
14683
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
375 b = _sizetomax(expr) |
|
14690
15faf0e66909
fileset: add missing whitespace around operator
Thomas Arendsen Hein <thomas@intevation.de>
parents:
14689
diff
changeset
|
376 m = lambda x: x >= a and x <= b |
|
14683
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
377 else: |
|
14716
552329013bac
fileset: use ParseError pos field correctly
Mads Kiilerich <mads@kiilerich.com>
parents:
14701
diff
changeset
|
378 raise error.ParseError(_("couldn't parse size: %s") % expr) |
|
14683
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
379 |
|
15963
042e84e39dee
fileset: don't attempt to check data predicates against removed files
Matt Mackall <mpm@selenic.com>
parents:
14830
diff
changeset
|
380 return [f for f in mctx.existing() if m(mctx.ctx[f].size())] |
|
14683
281102f37b24
fileset: add size() predicate
Matt Mackall <mpm@selenic.com>
parents:
14682
diff
changeset
|
381 |
|
27462
470ea34ba593
fileset: use decorator to mark a predicate as "existing caller"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27461
diff
changeset
|
382 @predicate('encoding(name)', callexisting=True) |
|
14684
87b9d6a7d807
fileset: add encoding() predicate
Matt Mackall <mpm@selenic.com>
parents:
14683
diff
changeset
|
383 def encoding(mctx, x): |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
384 """File can be successfully decoded with the given character |
|
14684
87b9d6a7d807
fileset: add encoding() predicate
Matt Mackall <mpm@selenic.com>
parents:
14683
diff
changeset
|
385 encoding. May not be useful for encodings other than ASCII and |
|
87b9d6a7d807
fileset: add encoding() predicate
Matt Mackall <mpm@selenic.com>
parents:
14683
diff
changeset
|
386 UTF-8. |
|
87b9d6a7d807
fileset: add encoding() predicate
Matt Mackall <mpm@selenic.com>
parents:
14683
diff
changeset
|
387 """ |
|
87b9d6a7d807
fileset: add encoding() predicate
Matt Mackall <mpm@selenic.com>
parents:
14683
diff
changeset
|
388 |
|
14785
0f0bd4d028d3
fileset: add i18n hints for keywords
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
14718
diff
changeset
|
389 # i18n: "encoding" is a keyword |
|
14684
87b9d6a7d807
fileset: add encoding() predicate
Matt Mackall <mpm@selenic.com>
parents:
14683
diff
changeset
|
390 enc = getstring(x, _("encoding requires an encoding name")) |
|
87b9d6a7d807
fileset: add encoding() predicate
Matt Mackall <mpm@selenic.com>
parents:
14683
diff
changeset
|
391 |
|
87b9d6a7d807
fileset: add encoding() predicate
Matt Mackall <mpm@selenic.com>
parents:
14683
diff
changeset
|
392 s = [] |
|
15963
042e84e39dee
fileset: don't attempt to check data predicates against removed files
Matt Mackall <mpm@selenic.com>
parents:
14830
diff
changeset
|
393 for f in mctx.existing(): |
|
14684
87b9d6a7d807
fileset: add encoding() predicate
Matt Mackall <mpm@selenic.com>
parents:
14683
diff
changeset
|
394 d = mctx.ctx[f].data() |
|
87b9d6a7d807
fileset: add encoding() predicate
Matt Mackall <mpm@selenic.com>
parents:
14683
diff
changeset
|
395 try: |
|
87b9d6a7d807
fileset: add encoding() predicate
Matt Mackall <mpm@selenic.com>
parents:
14683
diff
changeset
|
396 d.decode(enc) |
|
87b9d6a7d807
fileset: add encoding() predicate
Matt Mackall <mpm@selenic.com>
parents:
14683
diff
changeset
|
397 except LookupError: |
|
26587
56b2bcea2529
error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26233
diff
changeset
|
398 raise error.Abort(_("unknown encoding '%s'") % enc) |
|
14684
87b9d6a7d807
fileset: add encoding() predicate
Matt Mackall <mpm@selenic.com>
parents:
14683
diff
changeset
|
399 except UnicodeDecodeError: |
|
87b9d6a7d807
fileset: add encoding() predicate
Matt Mackall <mpm@selenic.com>
parents:
14683
diff
changeset
|
400 continue |
|
87b9d6a7d807
fileset: add encoding() predicate
Matt Mackall <mpm@selenic.com>
parents:
14683
diff
changeset
|
401 s.append(f) |
|
87b9d6a7d807
fileset: add encoding() predicate
Matt Mackall <mpm@selenic.com>
parents:
14683
diff
changeset
|
402 |
|
87b9d6a7d807
fileset: add encoding() predicate
Matt Mackall <mpm@selenic.com>
parents:
14683
diff
changeset
|
403 return s |
|
87b9d6a7d807
fileset: add encoding() predicate
Matt Mackall <mpm@selenic.com>
parents:
14683
diff
changeset
|
404 |
|
27462
470ea34ba593
fileset: use decorator to mark a predicate as "existing caller"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27461
diff
changeset
|
405 @predicate('eol(style)', callexisting=True) |
|
18842
3ce3f2b059a1
filesets: add eol predicate
Matt Mackall <mpm@selenic.com>
parents:
18364
diff
changeset
|
406 def eol(mctx, x): |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
407 """File contains newlines of the given style (dos, unix, mac). Binary |
|
18842
3ce3f2b059a1
filesets: add eol predicate
Matt Mackall <mpm@selenic.com>
parents:
18364
diff
changeset
|
408 files are excluded, files with mixed line endings match multiple |
|
3ce3f2b059a1
filesets: add eol predicate
Matt Mackall <mpm@selenic.com>
parents:
18364
diff
changeset
|
409 styles. |
|
3ce3f2b059a1
filesets: add eol predicate
Matt Mackall <mpm@selenic.com>
parents:
18364
diff
changeset
|
410 """ |
|
3ce3f2b059a1
filesets: add eol predicate
Matt Mackall <mpm@selenic.com>
parents:
18364
diff
changeset
|
411 |
|
28056
4f8ced23345e
fileset: fix copy/paste in eol() error message
Matt Harbison <matt_harbison@yahoo.com>
parents:
27518
diff
changeset
|
412 # i18n: "eol" is a keyword |
|
4f8ced23345e
fileset: fix copy/paste in eol() error message
Matt Harbison <matt_harbison@yahoo.com>
parents:
27518
diff
changeset
|
413 enc = getstring(x, _("eol requires a style name")) |
|
18842
3ce3f2b059a1
filesets: add eol predicate
Matt Mackall <mpm@selenic.com>
parents:
18364
diff
changeset
|
414 |
|
3ce3f2b059a1
filesets: add eol predicate
Matt Mackall <mpm@selenic.com>
parents:
18364
diff
changeset
|
415 s = [] |
|
3ce3f2b059a1
filesets: add eol predicate
Matt Mackall <mpm@selenic.com>
parents:
18364
diff
changeset
|
416 for f in mctx.existing(): |
|
3ce3f2b059a1
filesets: add eol predicate
Matt Mackall <mpm@selenic.com>
parents:
18364
diff
changeset
|
417 d = mctx.ctx[f].data() |
|
3ce3f2b059a1
filesets: add eol predicate
Matt Mackall <mpm@selenic.com>
parents:
18364
diff
changeset
|
418 if util.binary(d): |
|
3ce3f2b059a1
filesets: add eol predicate
Matt Mackall <mpm@selenic.com>
parents:
18364
diff
changeset
|
419 continue |
|
3ce3f2b059a1
filesets: add eol predicate
Matt Mackall <mpm@selenic.com>
parents:
18364
diff
changeset
|
420 if (enc == 'dos' or enc == 'win') and '\r\n' in d: |
|
3ce3f2b059a1
filesets: add eol predicate
Matt Mackall <mpm@selenic.com>
parents:
18364
diff
changeset
|
421 s.append(f) |
|
3ce3f2b059a1
filesets: add eol predicate
Matt Mackall <mpm@selenic.com>
parents:
18364
diff
changeset
|
422 elif enc == 'unix' and re.search('(?<!\r)\n', d): |
|
3ce3f2b059a1
filesets: add eol predicate
Matt Mackall <mpm@selenic.com>
parents:
18364
diff
changeset
|
423 s.append(f) |
|
3ce3f2b059a1
filesets: add eol predicate
Matt Mackall <mpm@selenic.com>
parents:
18364
diff
changeset
|
424 elif enc == 'mac' and re.search('\r(?!\n)', d): |
|
3ce3f2b059a1
filesets: add eol predicate
Matt Mackall <mpm@selenic.com>
parents:
18364
diff
changeset
|
425 s.append(f) |
|
3ce3f2b059a1
filesets: add eol predicate
Matt Mackall <mpm@selenic.com>
parents:
18364
diff
changeset
|
426 return s |
|
3ce3f2b059a1
filesets: add eol predicate
Matt Mackall <mpm@selenic.com>
parents:
18364
diff
changeset
|
427 |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
428 @predicate('copied()') |
|
14685
394121d9f4fc
fileset: add copied predicate
Matt Mackall <mpm@selenic.com>
parents:
14684
diff
changeset
|
429 def copied(mctx, x): |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
430 """File that is recorded as being copied. |
|
14685
394121d9f4fc
fileset: add copied predicate
Matt Mackall <mpm@selenic.com>
parents:
14684
diff
changeset
|
431 """ |
|
14785
0f0bd4d028d3
fileset: add i18n hints for keywords
Wagner Bruna <wbruna@softwareexpress.com.br>
parents:
14718
diff
changeset
|
432 # i18n: "copied" is a keyword |
|
14718
0c81948636f3
fileset: copied takes no arguments
Mads Kiilerich <mads@kiilerich.com>
parents:
14717
diff
changeset
|
433 getargs(x, 0, 0, _("copied takes no arguments")) |
|
14685
394121d9f4fc
fileset: add copied predicate
Matt Mackall <mpm@selenic.com>
parents:
14684
diff
changeset
|
434 s = [] |
|
394121d9f4fc
fileset: add copied predicate
Matt Mackall <mpm@selenic.com>
parents:
14684
diff
changeset
|
435 for f in mctx.subset: |
|
394121d9f4fc
fileset: add copied predicate
Matt Mackall <mpm@selenic.com>
parents:
14684
diff
changeset
|
436 p = mctx.ctx[f].parents() |
|
394121d9f4fc
fileset: add copied predicate
Matt Mackall <mpm@selenic.com>
parents:
14684
diff
changeset
|
437 if p and p[0].path() != f: |
|
394121d9f4fc
fileset: add copied predicate
Matt Mackall <mpm@selenic.com>
parents:
14684
diff
changeset
|
438 s.append(f) |
|
394121d9f4fc
fileset: add copied predicate
Matt Mackall <mpm@selenic.com>
parents:
14684
diff
changeset
|
439 return s |
|
394121d9f4fc
fileset: add copied predicate
Matt Mackall <mpm@selenic.com>
parents:
14684
diff
changeset
|
440 |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
441 @predicate('subrepo([pattern])') |
|
16443
9e02e032b522
fileset: add "subrepo" fileset symbol
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
15963
diff
changeset
|
442 def subrepo(mctx, x): |
|
27460
11286ac374f3
fileset: use decorator to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27459
diff
changeset
|
443 """Subrepositories whose paths match the given pattern. |
|
16443
9e02e032b522
fileset: add "subrepo" fileset symbol
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
15963
diff
changeset
|
444 """ |
|
9e02e032b522
fileset: add "subrepo" fileset symbol
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
15963
diff
changeset
|
445 # i18n: "subrepo" is a keyword |
|
9e02e032b522
fileset: add "subrepo" fileset symbol
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
15963
diff
changeset
|
446 getargs(x, 0, 1, _("subrepo takes at most one argument")) |
|
9e02e032b522
fileset: add "subrepo" fileset symbol
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
15963
diff
changeset
|
447 ctx = mctx.ctx |
|
18364
6252b4f1c4b4
subrepos: process subrepos in sorted order
Mads Kiilerich <mads@kiilerich.com>
parents:
17371
diff
changeset
|
448 sstate = sorted(ctx.substate) |
|
16443
9e02e032b522
fileset: add "subrepo" fileset symbol
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
15963
diff
changeset
|
449 if x: |
|
23113
c2dd79ad99cb
i18n: add i18n comment to error messages of filesets predicates
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22924
diff
changeset
|
450 # i18n: "subrepo" is a keyword |
|
16443
9e02e032b522
fileset: add "subrepo" fileset symbol
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
15963
diff
changeset
|
451 pat = getstring(x, _("subrepo requires a pattern or no arguments")) |
|
9e02e032b522
fileset: add "subrepo" fileset symbol
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
15963
diff
changeset
|
452 |
|
25938
e194ada8d45f
fileset: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
453 from . import match as matchmod # avoid circular import issues |
|
16443
9e02e032b522
fileset: add "subrepo" fileset symbol
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
15963
diff
changeset
|
454 fast = not matchmod.patkind(pat) |
|
9e02e032b522
fileset: add "subrepo" fileset symbol
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
15963
diff
changeset
|
455 if fast: |
|
9e02e032b522
fileset: add "subrepo" fileset symbol
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
15963
diff
changeset
|
456 def m(s): |
|
9e02e032b522
fileset: add "subrepo" fileset symbol
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
15963
diff
changeset
|
457 return (s == pat) |
|
9e02e032b522
fileset: add "subrepo" fileset symbol
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
15963
diff
changeset
|
458 else: |
|
24334
eda2f36889b5
fileset: replace 'ctx._repo' with 'ctx.repo()'
Matt Harbison <matt_harbison@yahoo.com>
parents:
24218
diff
changeset
|
459 m = matchmod.match(ctx.repo().root, '', [pat], ctx=ctx) |
|
16443
9e02e032b522
fileset: add "subrepo" fileset symbol
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
15963
diff
changeset
|
460 return [sub for sub in sstate if m(sub)] |
|
9e02e032b522
fileset: add "subrepo" fileset symbol
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
15963
diff
changeset
|
461 else: |
|
9e02e032b522
fileset: add "subrepo" fileset symbol
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
15963
diff
changeset
|
462 return [sub for sub in sstate] |
|
9e02e032b522
fileset: add "subrepo" fileset symbol
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
15963
diff
changeset
|
463 |
|
14551
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
464 methods = { |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
465 'string': stringset, |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
466 'symbol': stringset, |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
467 'and': andset, |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
468 'or': orset, |
|
17363
5d9e2031c0b1
fileset: actually implement 'minusset'
Patrick Mezard <patrick@mezard.eu>
parents:
16443
diff
changeset
|
469 'minus': minusset, |
|
14551
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
470 'list': listset, |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
471 'group': getset, |
|
14676
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
472 'not': notset, |
|
e80fa502b8cf
fileset: add some basic predicates
Matt Mackall <mpm@selenic.com>
parents:
14673
diff
changeset
|
473 'func': func, |
|
14551
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
474 } |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
475 |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
476 class matchctx(object): |
|
31200
2f881e7d1ade
fileset: build initial subset in fullmatchctx class
Yuya Nishihara <yuya@tcha.org>
parents:
31199
diff
changeset
|
477 def __init__(self, ctx, subset, status=None): |
|
14551
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
478 self.ctx = ctx |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
479 self.subset = subset |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
480 self._status = status |
|
27464
c39ecb2b86b3
fileset: detect unintentional existing() invocation at runtime
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27463
diff
changeset
|
481 self._existingenabled = False |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
482 def status(self): |
|
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
483 return self._status |
| 14673 | 484 def matcher(self, patterns): |
| 485 return self.ctx.match(patterns) | |
|
14551
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
486 def filter(self, files): |
|
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
487 return [f for f in files if f in self.subset] |
|
15963
042e84e39dee
fileset: don't attempt to check data predicates against removed files
Matt Mackall <mpm@selenic.com>
parents:
14830
diff
changeset
|
488 def existing(self): |
|
27464
c39ecb2b86b3
fileset: detect unintentional existing() invocation at runtime
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27463
diff
changeset
|
489 assert self._existingenabled, 'unexpected existing() invocation' |
|
17365
8a0513bf030a
fileset: exclude deleted files from matchctx.existing()
Patrick Mezard <patrick@mezard.eu>
parents:
17363
diff
changeset
|
490 if self._status is not None: |
|
8a0513bf030a
fileset: exclude deleted files from matchctx.existing()
Patrick Mezard <patrick@mezard.eu>
parents:
17363
diff
changeset
|
491 removed = set(self._status[3]) |
|
17367
ce625185cfd9
fileset: matchctx.existing() must consider ignored files
Patrick Mezard <patrick@mezard.eu>
parents:
17366
diff
changeset
|
492 unknown = set(self._status[4] + self._status[5]) |
|
17365
8a0513bf030a
fileset: exclude deleted files from matchctx.existing()
Patrick Mezard <patrick@mezard.eu>
parents:
17363
diff
changeset
|
493 else: |
|
8a0513bf030a
fileset: exclude deleted files from matchctx.existing()
Patrick Mezard <patrick@mezard.eu>
parents:
17363
diff
changeset
|
494 removed = set() |
|
17366
04c65cb59467
fileset: matchctx.existing() must consider unknown files
Patrick Mezard <patrick@mezard.eu>
parents:
17365
diff
changeset
|
495 unknown = set() |
|
17365
8a0513bf030a
fileset: exclude deleted files from matchctx.existing()
Patrick Mezard <patrick@mezard.eu>
parents:
17363
diff
changeset
|
496 return (f for f in self.subset |
|
17366
04c65cb59467
fileset: matchctx.existing() must consider unknown files
Patrick Mezard <patrick@mezard.eu>
parents:
17365
diff
changeset
|
497 if (f in self.ctx and f not in removed) or f in unknown) |
|
14551
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
498 def narrow(self, files): |
|
14677
2a758ffc821e
fileset: add support for file status predicates
Matt Mackall <mpm@selenic.com>
parents:
14676
diff
changeset
|
499 return matchctx(self.ctx, self.filter(files), self._status) |
|
31202
951d95b13487
fileset: add function to switch revision where fileset will be evaluated
Yuya Nishihara <yuya@tcha.org>
parents:
31201
diff
changeset
|
500 def switch(self, ctx, status=None): |
|
951d95b13487
fileset: add function to switch revision where fileset will be evaluated
Yuya Nishihara <yuya@tcha.org>
parents:
31201
diff
changeset
|
501 subset = self.filter(_buildsubset(ctx, status)) |
|
951d95b13487
fileset: add function to switch revision where fileset will be evaluated
Yuya Nishihara <yuya@tcha.org>
parents:
31201
diff
changeset
|
502 return matchctx(ctx, subset, status) |
|
14551
68d814a3cefd
fileset: basic pattern and boolean support
Matt Mackall <mpm@selenic.com>
parents:
14513
diff
changeset
|
503 |
|
31198
ec5b56b50e19
fileset: add class to host special handling of initial subset
Yuya Nishihara <yuya@tcha.org>
parents:
29991
diff
changeset
|
504 class fullmatchctx(matchctx): |
|
ec5b56b50e19
fileset: add class to host special handling of initial subset
Yuya Nishihara <yuya@tcha.org>
parents:
29991
diff
changeset
|
505 """A match context where any files in any revisions should be valid""" |
|
ec5b56b50e19
fileset: add class to host special handling of initial subset
Yuya Nishihara <yuya@tcha.org>
parents:
29991
diff
changeset
|
506 |
|
31200
2f881e7d1ade
fileset: build initial subset in fullmatchctx class
Yuya Nishihara <yuya@tcha.org>
parents:
31199
diff
changeset
|
507 def __init__(self, ctx, status=None): |
|
2f881e7d1ade
fileset: build initial subset in fullmatchctx class
Yuya Nishihara <yuya@tcha.org>
parents:
31199
diff
changeset
|
508 subset = _buildsubset(ctx, status) |
|
31198
ec5b56b50e19
fileset: add class to host special handling of initial subset
Yuya Nishihara <yuya@tcha.org>
parents:
29991
diff
changeset
|
509 super(fullmatchctx, self).__init__(ctx, subset, status) |
|
31202
951d95b13487
fileset: add function to switch revision where fileset will be evaluated
Yuya Nishihara <yuya@tcha.org>
parents:
31201
diff
changeset
|
510 def switch(self, ctx, status=None): |
|
951d95b13487
fileset: add function to switch revision where fileset will be evaluated
Yuya Nishihara <yuya@tcha.org>
parents:
31201
diff
changeset
|
511 return fullmatchctx(ctx, status) |
|
951d95b13487
fileset: add function to switch revision where fileset will be evaluated
Yuya Nishihara <yuya@tcha.org>
parents:
31201
diff
changeset
|
512 |
|
951d95b13487
fileset: add function to switch revision where fileset will be evaluated
Yuya Nishihara <yuya@tcha.org>
parents:
31201
diff
changeset
|
513 # filesets using matchctx.switch() |
|
951d95b13487
fileset: add function to switch revision where fileset will be evaluated
Yuya Nishihara <yuya@tcha.org>
parents:
31201
diff
changeset
|
514 _switchcallers = [ |
|
951d95b13487
fileset: add function to switch revision where fileset will be evaluated
Yuya Nishihara <yuya@tcha.org>
parents:
31201
diff
changeset
|
515 ] |
|
31198
ec5b56b50e19
fileset: add class to host special handling of initial subset
Yuya Nishihara <yuya@tcha.org>
parents:
29991
diff
changeset
|
516 |
|
14678
5ef7b87530f6
fileset: prescan parse tree to optimize status usage
Matt Mackall <mpm@selenic.com>
parents:
14677
diff
changeset
|
517 def _intree(funcs, tree): |
|
5ef7b87530f6
fileset: prescan parse tree to optimize status usage
Matt Mackall <mpm@selenic.com>
parents:
14677
diff
changeset
|
518 if isinstance(tree, tuple): |
|
5ef7b87530f6
fileset: prescan parse tree to optimize status usage
Matt Mackall <mpm@selenic.com>
parents:
14677
diff
changeset
|
519 if tree[0] == 'func' and tree[1][0] == 'symbol': |
|
5ef7b87530f6
fileset: prescan parse tree to optimize status usage
Matt Mackall <mpm@selenic.com>
parents:
14677
diff
changeset
|
520 if tree[1][1] in funcs: |
|
5ef7b87530f6
fileset: prescan parse tree to optimize status usage
Matt Mackall <mpm@selenic.com>
parents:
14677
diff
changeset
|
521 return True |
|
31202
951d95b13487
fileset: add function to switch revision where fileset will be evaluated
Yuya Nishihara <yuya@tcha.org>
parents:
31201
diff
changeset
|
522 if tree[1][1] in _switchcallers: |
|
951d95b13487
fileset: add function to switch revision where fileset will be evaluated
Yuya Nishihara <yuya@tcha.org>
parents:
31201
diff
changeset
|
523 # arguments won't be evaluated in the current context |
|
951d95b13487
fileset: add function to switch revision where fileset will be evaluated
Yuya Nishihara <yuya@tcha.org>
parents:
31201
diff
changeset
|
524 return False |
|
14678
5ef7b87530f6
fileset: prescan parse tree to optimize status usage
Matt Mackall <mpm@selenic.com>
parents:
14677
diff
changeset
|
525 for s in tree[1:]: |
|
5ef7b87530f6
fileset: prescan parse tree to optimize status usage
Matt Mackall <mpm@selenic.com>
parents:
14677
diff
changeset
|
526 if _intree(funcs, s): |
|
5ef7b87530f6
fileset: prescan parse tree to optimize status usage
Matt Mackall <mpm@selenic.com>
parents:
14677
diff
changeset
|
527 return True |
|
5ef7b87530f6
fileset: prescan parse tree to optimize status usage
Matt Mackall <mpm@selenic.com>
parents:
14677
diff
changeset
|
528 return False |
|
5ef7b87530f6
fileset: prescan parse tree to optimize status usage
Matt Mackall <mpm@selenic.com>
parents:
14677
diff
changeset
|
529 |
|
31199
3c32a3fdfd16
fileset: extract function that builds initial subset from ctx or status
Yuya Nishihara <yuya@tcha.org>
parents:
31198
diff
changeset
|
530 def _buildsubset(ctx, status): |
|
3c32a3fdfd16
fileset: extract function that builds initial subset from ctx or status
Yuya Nishihara <yuya@tcha.org>
parents:
31198
diff
changeset
|
531 if status: |
|
3c32a3fdfd16
fileset: extract function that builds initial subset from ctx or status
Yuya Nishihara <yuya@tcha.org>
parents:
31198
diff
changeset
|
532 subset = [] |
|
3c32a3fdfd16
fileset: extract function that builds initial subset from ctx or status
Yuya Nishihara <yuya@tcha.org>
parents:
31198
diff
changeset
|
533 for c in status: |
|
3c32a3fdfd16
fileset: extract function that builds initial subset from ctx or status
Yuya Nishihara <yuya@tcha.org>
parents:
31198
diff
changeset
|
534 subset.extend(c) |
|
3c32a3fdfd16
fileset: extract function that builds initial subset from ctx or status
Yuya Nishihara <yuya@tcha.org>
parents:
31198
diff
changeset
|
535 return subset |
|
3c32a3fdfd16
fileset: extract function that builds initial subset from ctx or status
Yuya Nishihara <yuya@tcha.org>
parents:
31198
diff
changeset
|
536 else: |
|
3c32a3fdfd16
fileset: extract function that builds initial subset from ctx or status
Yuya Nishihara <yuya@tcha.org>
parents:
31198
diff
changeset
|
537 return list(ctx.walk(ctx.match([]))) |
|
3c32a3fdfd16
fileset: extract function that builds initial subset from ctx or status
Yuya Nishihara <yuya@tcha.org>
parents:
31198
diff
changeset
|
538 |
| 14673 | 539 def getfileset(ctx, expr): |
|
25252
ac381dd7a21f
fileset: move validation of incomplete parsing to parse() function
Yuya Nishihara <yuya@tcha.org>
parents:
24408
diff
changeset
|
540 tree = parse(expr) |
|
31201
3c3ab84e6e78
fileset: extract function that builds status tuple only if necessary
Yuya Nishihara <yuya@tcha.org>
parents:
31200
diff
changeset
|
541 return getset(fullmatchctx(ctx, _buildstatus(ctx, tree)), tree) |
|
14678
5ef7b87530f6
fileset: prescan parse tree to optimize status usage
Matt Mackall <mpm@selenic.com>
parents:
14677
diff
changeset
|
542 |
|
31201
3c3ab84e6e78
fileset: extract function that builds status tuple only if necessary
Yuya Nishihara <yuya@tcha.org>
parents:
31200
diff
changeset
|
543 def _buildstatus(ctx, tree): |
|
14678
5ef7b87530f6
fileset: prescan parse tree to optimize status usage
Matt Mackall <mpm@selenic.com>
parents:
14677
diff
changeset
|
544 # do we need status info? |
|
27461
afa76585c955
fileset: use decorator to mark a predicate as "status caller"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
27460
diff
changeset
|
545 if (_intree(_statuscallers, tree) or |
|
17365
8a0513bf030a
fileset: exclude deleted files from matchctx.existing()
Patrick Mezard <patrick@mezard.eu>
parents:
17363
diff
changeset
|
546 # Using matchctx.existing() on a workingctx requires us to check |
|
8a0513bf030a
fileset: exclude deleted files from matchctx.existing()
Patrick Mezard <patrick@mezard.eu>
parents:
17363
diff
changeset
|
547 # for deleted files. |
|
8a0513bf030a
fileset: exclude deleted files from matchctx.existing()
Patrick Mezard <patrick@mezard.eu>
parents:
17363
diff
changeset
|
548 (ctx.rev() is None and _intree(_existingcallers, tree))): |
|
14678
5ef7b87530f6
fileset: prescan parse tree to optimize status usage
Matt Mackall <mpm@selenic.com>
parents:
14677
diff
changeset
|
549 unknown = _intree(['unknown'], tree) |
|
5ef7b87530f6
fileset: prescan parse tree to optimize status usage
Matt Mackall <mpm@selenic.com>
parents:
14677
diff
changeset
|
550 ignored = _intree(['ignored'], tree) |
|
5ef7b87530f6
fileset: prescan parse tree to optimize status usage
Matt Mackall <mpm@selenic.com>
parents:
14677
diff
changeset
|
551 |
|
24334
eda2f36889b5
fileset: replace 'ctx._repo' with 'ctx.repo()'
Matt Harbison <matt_harbison@yahoo.com>
parents:
24218
diff
changeset
|
552 r = ctx.repo() |
|
31201
3c3ab84e6e78
fileset: extract function that builds status tuple only if necessary
Yuya Nishihara <yuya@tcha.org>
parents:
31200
diff
changeset
|
553 return r.status(ctx.p1(), ctx, |
|
3c3ab84e6e78
fileset: extract function that builds status tuple only if necessary
Yuya Nishihara <yuya@tcha.org>
parents:
31200
diff
changeset
|
554 unknown=unknown, ignored=ignored, clean=True) |
|
14678
5ef7b87530f6
fileset: prescan parse tree to optimize status usage
Matt Mackall <mpm@selenic.com>
parents:
14677
diff
changeset
|
555 else: |
|
31201
3c3ab84e6e78
fileset: extract function that builds status tuple only if necessary
Yuya Nishihara <yuya@tcha.org>
parents:
31200
diff
changeset
|
556 return None |
|
14681
0744db5eb51c
fileset: add some function help text
Matt Mackall <mpm@selenic.com>
parents:
14680
diff
changeset
|
557 |
|
25255
ad1d2c952889
fileset: pretty print syntax tree in debug output
Yuya Nishihara <yuya@tcha.org>
parents:
25252
diff
changeset
|
558 def prettyformat(tree): |
|
ad1d2c952889
fileset: pretty print syntax tree in debug output
Yuya Nishihara <yuya@tcha.org>
parents:
25252
diff
changeset
|
559 return parser.prettyformat(tree, ('string', 'symbol')) |
|
ad1d2c952889
fileset: pretty print syntax tree in debug output
Yuya Nishihara <yuya@tcha.org>
parents:
25252
diff
changeset
|
560 |
|
28447
4eb5496c2bd4
registrar: add filesetpredicate to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28056
diff
changeset
|
561 def loadpredicate(ui, extname, registrarobj): |
|
4eb5496c2bd4
registrar: add filesetpredicate to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28056
diff
changeset
|
562 """Load fileset predicates from specified registrarobj |
|
4eb5496c2bd4
registrar: add filesetpredicate to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28056
diff
changeset
|
563 """ |
|
4eb5496c2bd4
registrar: add filesetpredicate to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28056
diff
changeset
|
564 for name, func in registrarobj._table.iteritems(): |
|
4eb5496c2bd4
registrar: add filesetpredicate to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28056
diff
changeset
|
565 symbols[name] = func |
|
4eb5496c2bd4
registrar: add filesetpredicate to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28056
diff
changeset
|
566 if func._callstatus: |
|
4eb5496c2bd4
registrar: add filesetpredicate to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28056
diff
changeset
|
567 _statuscallers.add(name) |
|
4eb5496c2bd4
registrar: add filesetpredicate to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28056
diff
changeset
|
568 if func._callexisting: |
|
4eb5496c2bd4
registrar: add filesetpredicate to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28056
diff
changeset
|
569 _existingcallers.add(name) |
|
4eb5496c2bd4
registrar: add filesetpredicate to mark a function as fileset predicate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28056
diff
changeset
|
570 |
|
28448
7108834c76a2
fileset: replace predicate by filesetpredicate of registrar (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28447
diff
changeset
|
571 # load built-in predicates explicitly to setup _statuscallers/_existingcallers |
|
7108834c76a2
fileset: replace predicate by filesetpredicate of registrar (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28447
diff
changeset
|
572 loadpredicate(None, None, predicate) |
|
7108834c76a2
fileset: replace predicate by filesetpredicate of registrar (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
28447
diff
changeset
|
573 |
|
14681
0744db5eb51c
fileset: add some function help text
Matt Mackall <mpm@selenic.com>
parents:
14680
diff
changeset
|
574 # tell hggettext to extract docstrings from these functions: |
|
0744db5eb51c
fileset: add some function help text
Matt Mackall <mpm@selenic.com>
parents:
14680
diff
changeset
|
575 i18nfunctions = symbols.values() |