Mercurial > hg
annotate mercurial/templater.py @ 25596:c1975809a6b5
templater: take any string literals as template, but not for rawstring (BC)
This patch series is intended to unify the interpretation of string literals.
It is breaking change that boldly assumes
a. string literal "..." never contains template-like fragment or it is
intended to be a template
b. we tend to use raw string literal r"..." for regexp pattern in which "{"
should have different meaning
Currently, we don't have a comprehensible rule how string literals are
evaluated in template functions. For example, fill() takes "initialindent"
and "hangindent" as templates, but not for "text", whereas "text" is a
template in pad() function.
date(date, fmt)
diff(includepattern, excludepattern)
fill(text, width, initialident: T, hangindent: T)
get(dict, key)
if(expr, then: T, else: T)
ifcontains(search, thing, then: T, else: T)
ifeq(expr1, expr2, then: T, else: T)
indent(text, indentchars, firstline)
join(list, sep)
label(label: T, expr: T)
pad(text: T, width, fillchar, right)
revset(query, formatargs...])
rstdoc(text, style)
shortest(node, minlength)
startswith(pattern, text)
strip(text, chars)
sub(pattern, replacement, expression: T)
word(number, text, separator)
expr % template: T
T: interpret "string" or r"rawstring" as template
This patch series adjusts the rule as follows:
a. string literal, '' or "", starts template processing (BC)
b. raw string literal, r'' or r"", disables both \-escape and template
processing (BC, done by subsequent patches)
c. fragment not surrounded by {} is non-templated string
"ccc{'aaa'}{r'bbb'}"
------------------ *: template
--- c: string
--- a: template
--- b: rawstring
Because this can eliminate the compilation of template arguments from the
evaluation phase, "hg log -Tdefault" gets faster.
% cd mozilla-central
% LANG=C HGRCPATH=/dev/null hg log -Tdefault -r0:10000 --time > /dev/null
before: real 4.870 secs (user 4.860+0.000 sys 0.010+0.000)
after: real 3.480 secs (user 3.440+0.000 sys 0.030+0.000)
Also, this will allow us to parse nested templates at once for better error
indication.
author | Yuya Nishihara <yuya@tcha.org> |
---|---|
date | Sat, 13 Jun 2015 19:49:54 +0900 |
parents | a7dd6692e5cb |
children | fd5bc660c9f0 |
rev | line source |
---|---|
1909
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
1 # templater.py - template expansion for output |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
2 # |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
3 # Copyright 2005, 2006 Matt Mackall <mpm@selenic.com> |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
4 # |
8225
46293a0c7e9f
updated license to be explicit about GPL version 2
Martin Geisler <mg@lazybytes.net>
parents:
8223
diff
changeset
|
5 # This software may be used and distributed according to the terms of the |
10263 | 6 # GNU General Public License version 2 or any later version. |
1909
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
7 |
3891 | 8 from i18n import _ |
22633
92b54547ac5d
util: introduce datapath for getting the location of supporting data files
Mads Kiilerich <madski@unity3d.com>
parents:
22434
diff
changeset
|
9 import os, re |
20519
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
10 import util, config, templatefilters, templatekw, parser, error |
22304
5678b0e3608f
templater: enable alias predicates to be used in "revset()" function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21960
diff
changeset
|
11 import revset as revsetmod |
17982
e06e9fd2d99f
template engine: convert generator-based iterator to list-based iterator
Weiwen <weiwen@fb.com>
parents:
17890
diff
changeset
|
12 import types |
18747
f5db3092790f
hgweb: generate HTML documentation
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
18582
diff
changeset
|
13 import minirst |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
14 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
15 # template parsing |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
16 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
17 elements = { |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
18 "(": (20, ("group", 1, ")"), ("func", 1, ")")), |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
19 ",": (2, None, ("list", 2)), |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
20 "|": (5, None, ("|", 5)), |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
21 "%": (6, None, ("%", 6)), |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
22 ")": (0, None, None), |
25002
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
23 "integer": (0, ("integer",), None), |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
24 "symbol": (0, ("symbol",), None), |
25596
c1975809a6b5
templater: take any string literals as template, but not for rawstring (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25595
diff
changeset
|
25 "string": (0, ("template",), None), |
20663
5ab28a2e9962
templater: make strings in template expressions be "string-escape"-ed correctly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20662
diff
changeset
|
26 "rawstring": (0, ("rawstring",), None), |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
27 "end": (0, None, None), |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
28 } |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
29 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
30 def tokenizer(data): |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
31 program, start, end = data |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
32 pos = start |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
33 while pos < end: |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
34 c = program[pos] |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
35 if c.isspace(): # skip inter-token whitespace |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
36 pass |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
37 elif c in "(,)%|": # handle simple operators |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
38 yield (c, None, pos) |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
39 elif (c in '"\'' or c == 'r' and |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
40 program[pos:pos + 2] in ("r'", 'r"')): # handle quoted strings |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
41 if c == 'r': |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
42 pos += 1 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
43 c = program[pos] |
17634
6b307730c9f0
templater: correctly deal with r"" strings
Matt Mackall <mpm@selenic.com>
parents:
17633
diff
changeset
|
44 decode = False |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
45 else: |
17634
6b307730c9f0
templater: correctly deal with r"" strings
Matt Mackall <mpm@selenic.com>
parents:
17633
diff
changeset
|
46 decode = True |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
47 pos += 1 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
48 s = pos |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
49 while pos < end: # find closing quote |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
50 d = program[pos] |
17634
6b307730c9f0
templater: correctly deal with r"" strings
Matt Mackall <mpm@selenic.com>
parents:
17633
diff
changeset
|
51 if decode and d == '\\': # skip over escaped characters |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
52 pos += 2 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
53 continue |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
54 if d == c: |
17634
6b307730c9f0
templater: correctly deal with r"" strings
Matt Mackall <mpm@selenic.com>
parents:
17633
diff
changeset
|
55 if not decode: |
20663
5ab28a2e9962
templater: make strings in template expressions be "string-escape"-ed correctly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20662
diff
changeset
|
56 yield ('rawstring', program[s:pos], s) |
17634
6b307730c9f0
templater: correctly deal with r"" strings
Matt Mackall <mpm@selenic.com>
parents:
17633
diff
changeset
|
57 break |
20066
64b4f0cd7336
templater: fix escaping in nested string literals (issue4102)
Matt Mackall <mpm@selenic.com>
parents:
19770
diff
changeset
|
58 yield ('string', program[s:pos], s) |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
59 break |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
60 pos += 1 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
61 else: |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
62 raise error.ParseError(_("unterminated string"), s) |
25002
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
63 elif c.isdigit() or c == '-': |
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
64 s = pos |
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
65 if c == '-': # simply take negate operator as part of integer |
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
66 pos += 1 |
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
67 if pos >= end or not program[pos].isdigit(): |
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
68 raise error.ParseError(_("integer literal without digits"), s) |
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
69 pos += 1 |
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
70 while pos < end: |
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
71 d = program[pos] |
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
72 if not d.isdigit(): |
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
73 break |
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
74 pos += 1 |
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
75 yield ('integer', program[s:pos], s) |
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
76 pos -= 1 |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
77 elif c.isalnum() or c in '_': |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
78 s = pos |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
79 pos += 1 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
80 while pos < end: # find end of symbol |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
81 d = program[pos] |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
82 if not (d.isalnum() or d == "_"): |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
83 break |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
84 pos += 1 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
85 sym = program[s:pos] |
18893
74ea61318ea8
templater: back out 0615b22da148, it breaks schemes ({1})
Brendan Cully <brendan@kublai.com>
parents:
18889
diff
changeset
|
86 yield ('symbol', sym, s) |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
87 pos -= 1 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
88 elif c == '}': |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
89 pos += 1 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
90 break |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
91 else: |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
92 raise error.ParseError(_("syntax error"), pos) |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
93 pos += 1 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
94 yield ('end', None, pos) |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
95 |
20663
5ab28a2e9962
templater: make strings in template expressions be "string-escape"-ed correctly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20662
diff
changeset
|
96 def compiletemplate(tmpl, context, strtoken="string"): |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
97 parsed = [] |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
98 pos, stop = 0, len(tmpl) |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
99 p = parser.parser(tokenizer, elements) |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
100 while pos < stop: |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
101 n = tmpl.find('{', pos) |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
102 if n < 0: |
20663
5ab28a2e9962
templater: make strings in template expressions be "string-escape"-ed correctly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20662
diff
changeset
|
103 parsed.append((strtoken, tmpl[pos:])) |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
104 break |
24949
890845af1ac2
templater: strictly parse leading backslashes of '{' (issue4569) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
24948
diff
changeset
|
105 bs = (n - pos) - len(tmpl[pos:n].rstrip('\\')) |
890845af1ac2
templater: strictly parse leading backslashes of '{' (issue4569) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
24948
diff
changeset
|
106 if strtoken == 'string' and bs % 2 == 1: |
890845af1ac2
templater: strictly parse leading backslashes of '{' (issue4569) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
24948
diff
changeset
|
107 # escaped (e.g. '\{', '\\\{', but not '\\{' nor r'\{') |
20663
5ab28a2e9962
templater: make strings in template expressions be "string-escape"-ed correctly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20662
diff
changeset
|
108 parsed.append((strtoken, (tmpl[pos:n - 1] + "{"))) |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
109 pos = n + 1 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
110 continue |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
111 if n > pos: |
20663
5ab28a2e9962
templater: make strings in template expressions be "string-escape"-ed correctly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20662
diff
changeset
|
112 parsed.append((strtoken, tmpl[pos:n])) |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
113 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
114 pd = [tmpl, n + 1, stop] |
13665
e798e430c5e5
revset: report a parse error if a revset is not parsed completely (issue2654)
Bernhard Leiner <bleiner@gmail.com>
parents:
13187
diff
changeset
|
115 parseres, pos = p.parse(pd) |
e798e430c5e5
revset: report a parse error if a revset is not parsed completely (issue2654)
Bernhard Leiner <bleiner@gmail.com>
parents:
13187
diff
changeset
|
116 parsed.append(parseres) |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
117 |
25001
9668c1a433b3
templater: switch methods table on compileexp() of func args and inner expr
Yuya Nishihara <yuya@tcha.org>
parents:
24988
diff
changeset
|
118 return [compileexp(e, context, methods) for e in parsed] |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
119 |
25001
9668c1a433b3
templater: switch methods table on compileexp() of func args and inner expr
Yuya Nishihara <yuya@tcha.org>
parents:
24988
diff
changeset
|
120 def compileexp(exp, context, curmethods): |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
121 t = exp[0] |
25001
9668c1a433b3
templater: switch methods table on compileexp() of func args and inner expr
Yuya Nishihara <yuya@tcha.org>
parents:
24988
diff
changeset
|
122 if t in curmethods: |
9668c1a433b3
templater: switch methods table on compileexp() of func args and inner expr
Yuya Nishihara <yuya@tcha.org>
parents:
24988
diff
changeset
|
123 return curmethods[t](exp, context) |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
124 raise error.ParseError(_("unknown method '%s'") % t) |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
125 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
126 # template evaluation |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
127 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
128 def getsymbol(exp): |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
129 if exp[0] == 'symbol': |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
130 return exp[1] |
21822
028a48105191
templater: add symbol to error
Ryan McElroy <rmcelroy@fb.com>
parents:
21821
diff
changeset
|
131 raise error.ParseError(_("expected a symbol, got '%s'") % exp[0]) |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
132 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
133 def getlist(x): |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
134 if not x: |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
135 return [] |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
136 if x[0] == 'list': |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
137 return getlist(x[1]) + [x[2]] |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
138 return [x] |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
139 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
140 def getfilter(exp, context): |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
141 f = getsymbol(exp) |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
142 if f not in context._filters: |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
143 raise error.ParseError(_("unknown function '%s'") % f) |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
144 return context._filters[f] |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
145 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
146 def gettemplate(exp, context): |
25596
c1975809a6b5
templater: take any string literals as template, but not for rawstring (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25595
diff
changeset
|
147 if exp[0] == 'template': |
c1975809a6b5
templater: take any string literals as template, but not for rawstring (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25595
diff
changeset
|
148 return compiletemplate(exp[1], context) |
c1975809a6b5
templater: take any string literals as template, but not for rawstring (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25595
diff
changeset
|
149 if exp[0] == 'rawstring': |
20663
5ab28a2e9962
templater: make strings in template expressions be "string-escape"-ed correctly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20662
diff
changeset
|
150 return compiletemplate(exp[1], context, strtoken=exp[0]) |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
151 if exp[0] == 'symbol': |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
152 return context._load(exp[1]) |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
153 raise error.ParseError(_("expected template specifier")) |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
154 |
25002
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
155 def runinteger(context, mapping, data): |
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
156 return int(data) |
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
157 |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
158 def runstring(context, mapping, data): |
20663
5ab28a2e9962
templater: make strings in template expressions be "string-escape"-ed correctly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20662
diff
changeset
|
159 return data.decode("string-escape") |
5ab28a2e9962
templater: make strings in template expressions be "string-escape"-ed correctly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20662
diff
changeset
|
160 |
5ab28a2e9962
templater: make strings in template expressions be "string-escape"-ed correctly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20662
diff
changeset
|
161 def runrawstring(context, mapping, data): |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
162 return data |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
163 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
164 def runsymbol(context, mapping, key): |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
165 v = mapping.get(key) |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
166 if v is None: |
19770
0361163efbaf
templater: support using templates with non-standard names from map file
Alexander Plavin <alexander@plav.in>
parents:
19390
diff
changeset
|
167 v = context._defaults.get(key) |
0361163efbaf
templater: support using templates with non-standard names from map file
Alexander Plavin <alexander@plav.in>
parents:
19390
diff
changeset
|
168 if v is None: |
0361163efbaf
templater: support using templates with non-standard names from map file
Alexander Plavin <alexander@plav.in>
parents:
19390
diff
changeset
|
169 try: |
0361163efbaf
templater: support using templates with non-standard names from map file
Alexander Plavin <alexander@plav.in>
parents:
19390
diff
changeset
|
170 v = context.process(key, mapping) |
0361163efbaf
templater: support using templates with non-standard names from map file
Alexander Plavin <alexander@plav.in>
parents:
19390
diff
changeset
|
171 except TemplateNotFound: |
0361163efbaf
templater: support using templates with non-standard names from map file
Alexander Plavin <alexander@plav.in>
parents:
19390
diff
changeset
|
172 v = '' |
21798
f2c617ff2abc
templater: restore use of callable() since it was readded in Python 3.2
Augie Fackler <raf@durin42.com>
parents:
21540
diff
changeset
|
173 if callable(v): |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
174 return v(**mapping) |
17982
e06e9fd2d99f
template engine: convert generator-based iterator to list-based iterator
Weiwen <weiwen@fb.com>
parents:
17890
diff
changeset
|
175 if isinstance(v, types.GeneratorType): |
e06e9fd2d99f
template engine: convert generator-based iterator to list-based iterator
Weiwen <weiwen@fb.com>
parents:
17890
diff
changeset
|
176 v = list(v) |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
177 return v |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
178 |
25596
c1975809a6b5
templater: take any string literals as template, but not for rawstring (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25595
diff
changeset
|
179 def buildtemplate(exp, context): |
c1975809a6b5
templater: take any string literals as template, but not for rawstring (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25595
diff
changeset
|
180 ctmpl = compiletemplate(exp[1], context) |
c1975809a6b5
templater: take any string literals as template, but not for rawstring (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25595
diff
changeset
|
181 if len(ctmpl) == 1: |
c1975809a6b5
templater: take any string literals as template, but not for rawstring (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25595
diff
changeset
|
182 return ctmpl[0] # fast path for string with no template fragment |
c1975809a6b5
templater: take any string literals as template, but not for rawstring (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25595
diff
changeset
|
183 return (runtemplate, ctmpl) |
c1975809a6b5
templater: take any string literals as template, but not for rawstring (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25595
diff
changeset
|
184 |
25595
a7dd6692e5cb
templater: move runtemplate function out of buildmap/runmap pair
Yuya Nishihara <yuya@tcha.org>
parents:
25580
diff
changeset
|
185 def runtemplate(context, mapping, template): |
a7dd6692e5cb
templater: move runtemplate function out of buildmap/runmap pair
Yuya Nishihara <yuya@tcha.org>
parents:
25580
diff
changeset
|
186 for func, data in template: |
a7dd6692e5cb
templater: move runtemplate function out of buildmap/runmap pair
Yuya Nishihara <yuya@tcha.org>
parents:
25580
diff
changeset
|
187 yield func(context, mapping, data) |
a7dd6692e5cb
templater: move runtemplate function out of buildmap/runmap pair
Yuya Nishihara <yuya@tcha.org>
parents:
25580
diff
changeset
|
188 |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
189 def buildfilter(exp, context): |
25001
9668c1a433b3
templater: switch methods table on compileexp() of func args and inner expr
Yuya Nishihara <yuya@tcha.org>
parents:
24988
diff
changeset
|
190 func, data = compileexp(exp[1], context, methods) |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
191 filt = getfilter(exp[2], context) |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
192 return (runfilter, (func, data, filt)) |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
193 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
194 def runfilter(context, mapping, data): |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
195 func, data, filt = data |
24280
6c55e37ba5f2
templater: allow piping generator-type function output to filters
Yuya Nishihara <yuya@tcha.org>
parents:
24240
diff
changeset
|
196 # func() may return string, generator of strings or arbitrary object such |
6c55e37ba5f2
templater: allow piping generator-type function output to filters
Yuya Nishihara <yuya@tcha.org>
parents:
24240
diff
changeset
|
197 # as date tuple, but filter does not want generator. |
6c55e37ba5f2
templater: allow piping generator-type function output to filters
Yuya Nishihara <yuya@tcha.org>
parents:
24240
diff
changeset
|
198 thing = func(context, mapping, data) |
6c55e37ba5f2
templater: allow piping generator-type function output to filters
Yuya Nishihara <yuya@tcha.org>
parents:
24240
diff
changeset
|
199 if isinstance(thing, types.GeneratorType): |
6c55e37ba5f2
templater: allow piping generator-type function output to filters
Yuya Nishihara <yuya@tcha.org>
parents:
24240
diff
changeset
|
200 thing = stringify(thing) |
17383
099c778ceb33
templater: abort when a template filter raises an exception (issue2987)
Neil Kodner <neilk@fb.com>
parents:
17334
diff
changeset
|
201 try: |
24280
6c55e37ba5f2
templater: allow piping generator-type function output to filters
Yuya Nishihara <yuya@tcha.org>
parents:
24240
diff
changeset
|
202 return filt(thing) |
17383
099c778ceb33
templater: abort when a template filter raises an exception (issue2987)
Neil Kodner <neilk@fb.com>
parents:
17334
diff
changeset
|
203 except (ValueError, AttributeError, TypeError): |
099c778ceb33
templater: abort when a template filter raises an exception (issue2987)
Neil Kodner <neilk@fb.com>
parents:
17334
diff
changeset
|
204 if isinstance(data, tuple): |
099c778ceb33
templater: abort when a template filter raises an exception (issue2987)
Neil Kodner <neilk@fb.com>
parents:
17334
diff
changeset
|
205 dt = data[1] |
099c778ceb33
templater: abort when a template filter raises an exception (issue2987)
Neil Kodner <neilk@fb.com>
parents:
17334
diff
changeset
|
206 else: |
099c778ceb33
templater: abort when a template filter raises an exception (issue2987)
Neil Kodner <neilk@fb.com>
parents:
17334
diff
changeset
|
207 dt = data |
099c778ceb33
templater: abort when a template filter raises an exception (issue2987)
Neil Kodner <neilk@fb.com>
parents:
17334
diff
changeset
|
208 raise util.Abort(_("template filter '%s' is not compatible with " |
099c778ceb33
templater: abort when a template filter raises an exception (issue2987)
Neil Kodner <neilk@fb.com>
parents:
17334
diff
changeset
|
209 "keyword '%s'") % (filt.func_name, dt)) |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
210 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
211 def buildmap(exp, context): |
25001
9668c1a433b3
templater: switch methods table on compileexp() of func args and inner expr
Yuya Nishihara <yuya@tcha.org>
parents:
24988
diff
changeset
|
212 func, data = compileexp(exp[1], context, methods) |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
213 ctmpl = gettemplate(exp[2], context) |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
214 return (runmap, (func, data, ctmpl)) |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
215 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
216 def runmap(context, mapping, data): |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
217 func, data, ctmpl = data |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
218 d = func(context, mapping, data) |
21798
f2c617ff2abc
templater: restore use of callable() since it was readded in Python 3.2
Augie Fackler <raf@durin42.com>
parents:
21540
diff
changeset
|
219 if callable(d): |
17631
0b241d7a8c62
templating: make new-style templating features work with command line lists
Matt Mackall <mpm@selenic.com>
parents:
17383
diff
changeset
|
220 d = d() |
0b241d7a8c62
templating: make new-style templating features work with command line lists
Matt Mackall <mpm@selenic.com>
parents:
17383
diff
changeset
|
221 |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
222 lm = mapping.copy() |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
223 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
224 for i in d: |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
225 if isinstance(i, dict): |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
226 lm.update(i) |
17991
d605a82cf189
hgweb: display diff for a changeset against any parents (issue2810)
Weiwen <weiwen@fb.com>
parents:
17982
diff
changeset
|
227 lm['originalnode'] = mapping.get('node') |
17632
523625e46760
templater: factor out runtemplate method
Matt Mackall <mpm@selenic.com>
parents:
17631
diff
changeset
|
228 yield runtemplate(context, lm, ctmpl) |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
229 else: |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
230 # v is not an iterable of dicts, this happen when 'key' |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
231 # has been fully expanded already and format is useless. |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
232 # If so, return the expanded value. |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
233 yield i |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
234 |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
235 def buildfunc(exp, context): |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
236 n = getsymbol(exp[1]) |
25001
9668c1a433b3
templater: switch methods table on compileexp() of func args and inner expr
Yuya Nishihara <yuya@tcha.org>
parents:
24988
diff
changeset
|
237 args = [compileexp(x, context, exprmethods) for x in getlist(exp[2])] |
14925
ab545a15d807
templater: use a global funcs table
Matt Mackall <mpm@selenic.com>
parents:
14168
diff
changeset
|
238 if n in funcs: |
ab545a15d807
templater: use a global funcs table
Matt Mackall <mpm@selenic.com>
parents:
14168
diff
changeset
|
239 f = funcs[n] |
ab545a15d807
templater: use a global funcs table
Matt Mackall <mpm@selenic.com>
parents:
14168
diff
changeset
|
240 return (f, args) |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
241 if n in context._filters: |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
242 if len(args) != 1: |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
243 raise error.ParseError(_("filter %s expects one argument") % n) |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
244 f = context._filters[n] |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
245 return (runfilter, (args[0][0], args[0][1], f)) |
20857
6eb55310fcbc
templater: raise error for unknown func
Sean Farley <sean.michael.farley@gmail.com>
parents:
20663
diff
changeset
|
246 raise error.ParseError(_("unknown function '%s'") % n) |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
247 |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
248 def date(context, mapping, args): |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
249 """:date(date[, fmt]): Format a date. See :hg:`help dates` for formatting |
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
250 strings.""" |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
251 if not (1 <= len(args) <= 2): |
23112
3226ed457928
i18n: add i18n comment to error messages of template functions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22844
diff
changeset
|
252 # i18n: "date" is a keyword |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
253 raise error.ParseError(_("date expects one or two arguments")) |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
254 |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
255 date = args[0][0](context, mapping, args[0][1]) |
24903
09124cce913f
templater: fix crash by passing invalid object to date() function
Yuya Nishihara <yuya@tcha.org>
parents:
24886
diff
changeset
|
256 fmt = None |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
257 if len(args) == 2: |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
258 fmt = stringify(args[1][0](context, mapping, args[1][1])) |
24903
09124cce913f
templater: fix crash by passing invalid object to date() function
Yuya Nishihara <yuya@tcha.org>
parents:
24886
diff
changeset
|
259 try: |
09124cce913f
templater: fix crash by passing invalid object to date() function
Yuya Nishihara <yuya@tcha.org>
parents:
24886
diff
changeset
|
260 if fmt is None: |
09124cce913f
templater: fix crash by passing invalid object to date() function
Yuya Nishihara <yuya@tcha.org>
parents:
24886
diff
changeset
|
261 return util.datestr(date) |
09124cce913f
templater: fix crash by passing invalid object to date() function
Yuya Nishihara <yuya@tcha.org>
parents:
24886
diff
changeset
|
262 else: |
09124cce913f
templater: fix crash by passing invalid object to date() function
Yuya Nishihara <yuya@tcha.org>
parents:
24886
diff
changeset
|
263 return util.datestr(date, fmt) |
09124cce913f
templater: fix crash by passing invalid object to date() function
Yuya Nishihara <yuya@tcha.org>
parents:
24886
diff
changeset
|
264 except (TypeError, ValueError): |
09124cce913f
templater: fix crash by passing invalid object to date() function
Yuya Nishihara <yuya@tcha.org>
parents:
24886
diff
changeset
|
265 # i18n: "date" is a keyword |
09124cce913f
templater: fix crash by passing invalid object to date() function
Yuya Nishihara <yuya@tcha.org>
parents:
24886
diff
changeset
|
266 raise error.ParseError(_("date expects a date information")) |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
267 |
22434
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
268 def diff(context, mapping, args): |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
269 """:diff([includepattern [, excludepattern]]): Show a diff, optionally |
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
270 specifying files to include or exclude.""" |
22434
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
271 if len(args) > 2: |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
272 # i18n: "diff" is a keyword |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
273 raise error.ParseError(_("diff expects one, two or no arguments")) |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
274 |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
275 def getpatterns(i): |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
276 if i < len(args): |
25562
9452112c8eb0
templater: evaluate arguments passed to diff() appropriately
Yuya Nishihara <yuya@tcha.org>
parents:
25471
diff
changeset
|
277 s = stringify(args[i][0](context, mapping, args[i][1])).strip() |
22434
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
278 if s: |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
279 return [s] |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
280 return [] |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
281 |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
282 ctx = mapping['ctx'] |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
283 chunks = ctx.diff(match=ctx.match([], getpatterns(0), getpatterns(1))) |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
284 |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
285 return ''.join(chunks) |
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
286 |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
287 def fill(context, mapping, args): |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
288 """:fill(text[, width[, initialident[, hangindent]]]): Fill many |
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
289 paragraphs with optional indentation. See the "fill" filter.""" |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
290 if not (1 <= len(args) <= 4): |
23112
3226ed457928
i18n: add i18n comment to error messages of template functions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22844
diff
changeset
|
291 # i18n: "fill" is a keyword |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
292 raise error.ParseError(_("fill expects one to four arguments")) |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
293 |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
294 text = stringify(args[0][0](context, mapping, args[0][1])) |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
295 width = 76 |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
296 initindent = '' |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
297 hangindent = '' |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
298 if 2 <= len(args) <= 4: |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
299 try: |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
300 width = int(stringify(args[1][0](context, mapping, args[1][1]))) |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
301 except ValueError: |
23112
3226ed457928
i18n: add i18n comment to error messages of template functions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22844
diff
changeset
|
302 # i18n: "fill" is a keyword |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
303 raise error.ParseError(_("fill expects an integer width")) |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
304 try: |
20661
7e627fe63e5e
templater: avoid recursive evaluation of string literals completely
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20312
diff
changeset
|
305 initindent = stringify(_evalifliteral(args[2], context, mapping)) |
7e627fe63e5e
templater: avoid recursive evaluation of string literals completely
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20312
diff
changeset
|
306 hangindent = stringify(_evalifliteral(args[3], context, mapping)) |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
307 except IndexError: |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
308 pass |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
309 |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
310 return templatefilters.fill(text, width, initindent, hangindent) |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
311 |
20370
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
312 def pad(context, mapping, args): |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
313 """:pad(text, width[, fillchar=' '[, right=False]]): Pad text with a |
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
314 fill character.""" |
20370
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
315 if not (2 <= len(args) <= 4): |
23112
3226ed457928
i18n: add i18n comment to error messages of template functions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22844
diff
changeset
|
316 # i18n: "pad" is a keyword |
20370
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
317 raise error.ParseError(_("pad() expects two to four arguments")) |
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
318 |
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
319 width = int(args[1][1]) |
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
320 |
25509
576d6c74784b
templater: make pad function evaluate both string and rawstring templates
Yuya Nishihara <yuya@tcha.org>
parents:
25490
diff
changeset
|
321 text = stringify(_evalifliteral(args[0], context, mapping)) |
20370
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
322 |
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
323 right = False |
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
324 fillchar = ' ' |
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
325 if len(args) > 2: |
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
326 fillchar = stringify(args[2][0](context, mapping, args[2][1])) |
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
327 if len(args) > 3: |
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
328 right = util.parsebool(args[3][1]) |
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
329 |
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
330 if right: |
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
331 return text.rjust(width, fillchar) |
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
332 else: |
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
333 return text.ljust(width, fillchar) |
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
334 |
25489
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
335 def indent(context, mapping, args): |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
336 """:indent(text, indentchars[, firstline]): Indents all non-empty lines |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
337 with the characters given in the indentchars string. An optional |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
338 third parameter will override the indent for the first line only |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
339 if present.""" |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
340 if not (2 <= len(args) <= 3): |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
341 # i18n: "indent" is a keyword |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
342 raise error.ParseError(_("indent() expects two or three arguments")) |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
343 |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
344 text = stringify(args[0][0](context, mapping, args[0][1])) |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
345 indent = stringify(args[1][0](context, mapping, args[1][1])) |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
346 |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
347 if len(args) == 3: |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
348 firstline = stringify(args[2][0](context, mapping, args[2][1])) |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
349 else: |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
350 firstline = indent |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
351 |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
352 # the indent function doesn't indent the first line, so we do it here |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
353 return templatefilters.indent(firstline + text, indent) |
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
354 |
18582
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
355 def get(context, mapping, args): |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
356 """:get(dict, key): Get an attribute/key from an object. Some keywords |
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
357 are complex types. This function allows you to obtain the value of an |
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
358 attribute on these type.""" |
18582
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
359 if len(args) != 2: |
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
360 # i18n: "get" is a keyword |
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
361 raise error.ParseError(_("get() expects two arguments")) |
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
362 |
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
363 dictarg = args[0][0](context, mapping, args[0][1]) |
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
364 if not util.safehasattr(dictarg, 'get'): |
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
365 # i18n: "get" is a keyword |
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
366 raise error.ParseError(_("get() expects a dict as first argument")) |
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
367 |
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
368 key = args[1][0](context, mapping, args[1][1]) |
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
369 yield dictarg.get(key) |
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
370 |
20067
3d8bfe2ecf6d
templater: only recursively evaluate string literals as templates (issue4103)
Matt Mackall <mpm@selenic.com>
parents:
20066
diff
changeset
|
371 def _evalifliteral(arg, context, mapping): |
25471
7298da81f5a9
templater: do not preprocess template string in "if" expression (issue4714)
Yuya Nishihara <yuya@tcha.org>
parents:
24949
diff
changeset
|
372 # get back to token tag to reinterpret string as template |
25596
c1975809a6b5
templater: take any string literals as template, but not for rawstring (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25595
diff
changeset
|
373 strtoken = {runrawstring: 'rawstring'}.get(arg[0]) |
25471
7298da81f5a9
templater: do not preprocess template string in "if" expression (issue4714)
Yuya Nishihara <yuya@tcha.org>
parents:
24949
diff
changeset
|
374 if strtoken: |
20663
5ab28a2e9962
templater: make strings in template expressions be "string-escape"-ed correctly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20662
diff
changeset
|
375 yield runtemplate(context, mapping, |
25471
7298da81f5a9
templater: do not preprocess template string in "if" expression (issue4714)
Yuya Nishihara <yuya@tcha.org>
parents:
24949
diff
changeset
|
376 compiletemplate(arg[1], context, strtoken)) |
20067
3d8bfe2ecf6d
templater: only recursively evaluate string literals as templates (issue4103)
Matt Mackall <mpm@selenic.com>
parents:
20066
diff
changeset
|
377 else: |
25471
7298da81f5a9
templater: do not preprocess template string in "if" expression (issue4714)
Yuya Nishihara <yuya@tcha.org>
parents:
24949
diff
changeset
|
378 yield stringify(arg[0](context, mapping, arg[1])) |
20067
3d8bfe2ecf6d
templater: only recursively evaluate string literals as templates (issue4103)
Matt Mackall <mpm@selenic.com>
parents:
20066
diff
changeset
|
379 |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
380 def if_(context, mapping, args): |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
381 """:if(expr, then[, else]): Conditionally execute based on the result of |
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
382 an expression.""" |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
383 if not (2 <= len(args) <= 3): |
17890
ca6850b9dd9e
i18n: add "i18n" comment to error messages of template functions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17729
diff
changeset
|
384 # i18n: "if" is a keyword |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
385 raise error.ParseError(_("if expects two or three arguments")) |
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
386 |
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
387 test = stringify(args[0][0](context, mapping, args[0][1])) |
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
388 if test: |
20067
3d8bfe2ecf6d
templater: only recursively evaluate string literals as templates (issue4103)
Matt Mackall <mpm@selenic.com>
parents:
20066
diff
changeset
|
389 yield _evalifliteral(args[1], context, mapping) |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
390 elif len(args) == 3: |
20067
3d8bfe2ecf6d
templater: only recursively evaluate string literals as templates (issue4103)
Matt Mackall <mpm@selenic.com>
parents:
20066
diff
changeset
|
391 yield _evalifliteral(args[2], context, mapping) |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
392 |
20518
1e43f15a647f
template: add ifcontains template function
Durham Goode <durham@fb.com>
parents:
20371
diff
changeset
|
393 def ifcontains(context, mapping, args): |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
394 """:ifcontains(search, thing, then[, else]): Conditionally execute based |
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
395 on whether the item "search" is in "thing".""" |
20518
1e43f15a647f
template: add ifcontains template function
Durham Goode <durham@fb.com>
parents:
20371
diff
changeset
|
396 if not (3 <= len(args) <= 4): |
1e43f15a647f
template: add ifcontains template function
Durham Goode <durham@fb.com>
parents:
20371
diff
changeset
|
397 # i18n: "ifcontains" is a keyword |
1e43f15a647f
template: add ifcontains template function
Durham Goode <durham@fb.com>
parents:
20371
diff
changeset
|
398 raise error.ParseError(_("ifcontains expects three or four arguments")) |
1e43f15a647f
template: add ifcontains template function
Durham Goode <durham@fb.com>
parents:
20371
diff
changeset
|
399 |
1e43f15a647f
template: add ifcontains template function
Durham Goode <durham@fb.com>
parents:
20371
diff
changeset
|
400 item = stringify(args[0][0](context, mapping, args[0][1])) |
1e43f15a647f
template: add ifcontains template function
Durham Goode <durham@fb.com>
parents:
20371
diff
changeset
|
401 items = args[1][0](context, mapping, args[1][1]) |
1e43f15a647f
template: add ifcontains template function
Durham Goode <durham@fb.com>
parents:
20371
diff
changeset
|
402 |
24240
bd504d90588d
templater: implement _hybrid.__contains__ so that ifcontains can accept dict
Yuya Nishihara <yuya@tcha.org>
parents:
24114
diff
changeset
|
403 if item in items: |
20518
1e43f15a647f
template: add ifcontains template function
Durham Goode <durham@fb.com>
parents:
20371
diff
changeset
|
404 yield _evalifliteral(args[2], context, mapping) |
1e43f15a647f
template: add ifcontains template function
Durham Goode <durham@fb.com>
parents:
20371
diff
changeset
|
405 elif len(args) == 4: |
1e43f15a647f
template: add ifcontains template function
Durham Goode <durham@fb.com>
parents:
20371
diff
changeset
|
406 yield _evalifliteral(args[3], context, mapping) |
1e43f15a647f
template: add ifcontains template function
Durham Goode <durham@fb.com>
parents:
20371
diff
changeset
|
407 |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
408 def ifeq(context, mapping, args): |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
409 """:ifeq(expr1, expr2, then[, else]): Conditionally execute based on |
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
410 whether 2 items are equivalent.""" |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
411 if not (3 <= len(args) <= 4): |
17890
ca6850b9dd9e
i18n: add "i18n" comment to error messages of template functions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17729
diff
changeset
|
412 # i18n: "ifeq" is a keyword |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
413 raise error.ParseError(_("ifeq expects three or four arguments")) |
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
414 |
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
415 test = stringify(args[0][0](context, mapping, args[0][1])) |
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
416 match = stringify(args[1][0](context, mapping, args[1][1])) |
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
417 if test == match: |
20067
3d8bfe2ecf6d
templater: only recursively evaluate string literals as templates (issue4103)
Matt Mackall <mpm@selenic.com>
parents:
20066
diff
changeset
|
418 yield _evalifliteral(args[2], context, mapping) |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
419 elif len(args) == 4: |
20067
3d8bfe2ecf6d
templater: only recursively evaluate string literals as templates (issue4103)
Matt Mackall <mpm@selenic.com>
parents:
20066
diff
changeset
|
420 yield _evalifliteral(args[3], context, mapping) |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
421 |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
422 def join(context, mapping, args): |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
423 """:join(list, sep): Join items in a list with a delimiter.""" |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
424 if not (1 <= len(args) <= 2): |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
425 # i18n: "join" is a keyword |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
426 raise error.ParseError(_("join expects one or two arguments")) |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
427 |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
428 joinset = args[0][0](context, mapping, args[0][1]) |
21798
f2c617ff2abc
templater: restore use of callable() since it was readded in Python 3.2
Augie Fackler <raf@durin42.com>
parents:
21540
diff
changeset
|
429 if callable(joinset): |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
430 jf = joinset.joinfmt |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
431 joinset = [jf(x) for x in joinset()] |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
432 |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
433 joiner = " " |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
434 if len(args) > 1: |
20662
a54c0d830499
templater: apply "stringify()" on sub expression to get string correctly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20661
diff
changeset
|
435 joiner = stringify(args[1][0](context, mapping, args[1][1])) |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
436 |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
437 first = True |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
438 for x in joinset: |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
439 if first: |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
440 first = False |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
441 else: |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
442 yield joiner |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
443 yield x |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
444 |
18289
9bfb53106328
templater: add no-op template function 'label'
Sean Farley <sean.michael.farley@gmail.com>
parents:
17991
diff
changeset
|
445 def label(context, mapping, args): |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
446 """:label(label, expr): Apply a label to generated content. Content with |
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
447 a label applied can result in additional post-processing, such as |
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
448 automatic colorization.""" |
18289
9bfb53106328
templater: add no-op template function 'label'
Sean Farley <sean.michael.farley@gmail.com>
parents:
17991
diff
changeset
|
449 if len(args) != 2: |
9bfb53106328
templater: add no-op template function 'label'
Sean Farley <sean.michael.farley@gmail.com>
parents:
17991
diff
changeset
|
450 # i18n: "label" is a keyword |
9bfb53106328
templater: add no-op template function 'label'
Sean Farley <sean.michael.farley@gmail.com>
parents:
17991
diff
changeset
|
451 raise error.ParseError(_("label expects two arguments")) |
9bfb53106328
templater: add no-op template function 'label'
Sean Farley <sean.michael.farley@gmail.com>
parents:
17991
diff
changeset
|
452 |
9bfb53106328
templater: add no-op template function 'label'
Sean Farley <sean.michael.farley@gmail.com>
parents:
17991
diff
changeset
|
453 # ignore args[0] (the label string) since this is supposed to be a a no-op |
20067
3d8bfe2ecf6d
templater: only recursively evaluate string literals as templates (issue4103)
Matt Mackall <mpm@selenic.com>
parents:
20066
diff
changeset
|
454 yield _evalifliteral(args[1], context, mapping) |
18289
9bfb53106328
templater: add no-op template function 'label'
Sean Farley <sean.michael.farley@gmail.com>
parents:
17991
diff
changeset
|
455 |
20519
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
456 def revset(context, mapping, args): |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
457 """:revset(query[, formatargs...]): Execute a revision set query. See |
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
458 :hg:`help revset`.""" |
20519
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
459 if not len(args) > 0: |
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
460 # i18n: "revset" is a keyword |
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
461 raise error.ParseError(_("revset expects one or more arguments")) |
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
462 |
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
463 raw = args[0][1] |
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
464 ctx = mapping['ctx'] |
24337
696ab1a24ae0
templater: replace 'ctx._repo' with 'ctx.repo()'
Matt Harbison <matt_harbison@yahoo.com>
parents:
24306
diff
changeset
|
465 repo = ctx.repo() |
20519
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
466 |
22304
5678b0e3608f
templater: enable alias predicates to be used in "revset()" function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21960
diff
changeset
|
467 def query(expr): |
5678b0e3608f
templater: enable alias predicates to be used in "revset()" function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21960
diff
changeset
|
468 m = revsetmod.match(repo.ui, expr) |
24114
fafd9a1284cf
revset: make match function initiate query from full set by default
Yuya Nishihara <yuya@tcha.org>
parents:
23167
diff
changeset
|
469 return m(repo) |
22304
5678b0e3608f
templater: enable alias predicates to be used in "revset()" function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21960
diff
changeset
|
470 |
20519
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
471 if len(args) > 1: |
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
472 formatargs = list([a[0](context, mapping, a[1]) for a in args[1:]]) |
22304
5678b0e3608f
templater: enable alias predicates to be used in "revset()" function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21960
diff
changeset
|
473 revs = query(revsetmod.formatspec(raw, *formatargs)) |
20519
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
474 revs = list([str(r) for r in revs]) |
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
475 else: |
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
476 revsetcache = mapping['cache'].setdefault("revsetcache", {}) |
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
477 if raw in revsetcache: |
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
478 revs = revsetcache[raw] |
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
479 else: |
22304
5678b0e3608f
templater: enable alias predicates to be used in "revset()" function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21960
diff
changeset
|
480 revs = query(raw) |
20519
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
481 revs = list([str(r) for r in revs]) |
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
482 revsetcache[raw] = revs |
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
483 |
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
484 return templatekw.showlist("revision", revs, **mapping) |
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
485 |
18747
f5db3092790f
hgweb: generate HTML documentation
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
18582
diff
changeset
|
486 def rstdoc(context, mapping, args): |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
487 """:rstdoc(text, style): Format ReStructuredText.""" |
18747
f5db3092790f
hgweb: generate HTML documentation
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
18582
diff
changeset
|
488 if len(args) != 2: |
f5db3092790f
hgweb: generate HTML documentation
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
18582
diff
changeset
|
489 # i18n: "rstdoc" is a keyword |
f5db3092790f
hgweb: generate HTML documentation
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
18582
diff
changeset
|
490 raise error.ParseError(_("rstdoc expects two arguments")) |
f5db3092790f
hgweb: generate HTML documentation
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
18582
diff
changeset
|
491 |
f5db3092790f
hgweb: generate HTML documentation
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
18582
diff
changeset
|
492 text = stringify(args[0][0](context, mapping, args[0][1])) |
f5db3092790f
hgweb: generate HTML documentation
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
18582
diff
changeset
|
493 style = stringify(args[1][0](context, mapping, args[1][1])) |
f5db3092790f
hgweb: generate HTML documentation
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
18582
diff
changeset
|
494 |
19079
1e433b5457fd
hgweb: make help verbose again (issue3899)
Alexander Plavin <me@aplavin.ru>
parents:
19058
diff
changeset
|
495 return minirst.format(text, style=style, keep=['verbose']) |
18747
f5db3092790f
hgweb: generate HTML documentation
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
18582
diff
changeset
|
496 |
20369
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
497 def shortest(context, mapping, args): |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
498 """:shortest(node, minlength=4): Obtain the shortest representation of |
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
499 a node.""" |
20369
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
500 if not (1 <= len(args) <= 2): |
23112
3226ed457928
i18n: add i18n comment to error messages of template functions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22844
diff
changeset
|
501 # i18n: "shortest" is a keyword |
20369
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
502 raise error.ParseError(_("shortest() expects one or two arguments")) |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
503 |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
504 node = stringify(args[0][0](context, mapping, args[0][1])) |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
505 |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
506 minlength = 4 |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
507 if len(args) > 1: |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
508 minlength = int(args[1][1]) |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
509 |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
510 cl = mapping['ctx']._repo.changelog |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
511 def isvalid(test): |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
512 try: |
20371
6f3fb6a974e0
template: fix shortest(node) function in pure mercurial
Durham Goode <durham@fb.com>
parents:
20370
diff
changeset
|
513 try: |
6f3fb6a974e0
template: fix shortest(node) function in pure mercurial
Durham Goode <durham@fb.com>
parents:
20370
diff
changeset
|
514 cl.index.partialmatch(test) |
6f3fb6a974e0
template: fix shortest(node) function in pure mercurial
Durham Goode <durham@fb.com>
parents:
20370
diff
changeset
|
515 except AttributeError: |
6f3fb6a974e0
template: fix shortest(node) function in pure mercurial
Durham Goode <durham@fb.com>
parents:
20370
diff
changeset
|
516 # Pure mercurial doesn't support partialmatch on the index. |
6f3fb6a974e0
template: fix shortest(node) function in pure mercurial
Durham Goode <durham@fb.com>
parents:
20370
diff
changeset
|
517 # Fallback to the slow way. |
6f3fb6a974e0
template: fix shortest(node) function in pure mercurial
Durham Goode <durham@fb.com>
parents:
20370
diff
changeset
|
518 if cl._partialmatch(test) is None: |
6f3fb6a974e0
template: fix shortest(node) function in pure mercurial
Durham Goode <durham@fb.com>
parents:
20370
diff
changeset
|
519 return False |
6f3fb6a974e0
template: fix shortest(node) function in pure mercurial
Durham Goode <durham@fb.com>
parents:
20370
diff
changeset
|
520 |
20369
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
521 try: |
20539
aa021ece4506
templater: shorten pure integers
Sean Farley <sean.michael.farley@gmail.com>
parents:
20519
diff
changeset
|
522 i = int(test) |
aa021ece4506
templater: shorten pure integers
Sean Farley <sean.michael.farley@gmail.com>
parents:
20519
diff
changeset
|
523 # if we are a pure int, then starting with zero will not be |
aa021ece4506
templater: shorten pure integers
Sean Farley <sean.michael.farley@gmail.com>
parents:
20519
diff
changeset
|
524 # confused as a rev; or, obviously, if the int is larger than |
aa021ece4506
templater: shorten pure integers
Sean Farley <sean.michael.farley@gmail.com>
parents:
20519
diff
changeset
|
525 # the value of the tip rev |
aa021ece4506
templater: shorten pure integers
Sean Farley <sean.michael.farley@gmail.com>
parents:
20519
diff
changeset
|
526 if test[0] == '0' or i > len(cl): |
aa021ece4506
templater: shorten pure integers
Sean Farley <sean.michael.farley@gmail.com>
parents:
20519
diff
changeset
|
527 return True |
20369
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
528 return False |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
529 except ValueError: |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
530 return True |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
531 except error.RevlogError: |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
532 return False |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
533 |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
534 shortest = node |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
535 startlength = max(6, minlength) |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
536 length = startlength |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
537 while True: |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
538 test = node[:length] |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
539 if isvalid(test): |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
540 shortest = test |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
541 if length == minlength or length > startlength: |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
542 return shortest |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
543 length -= 1 |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
544 else: |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
545 length += 1 |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
546 if len(shortest) <= length: |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
547 return shortest |
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
548 |
19330
867b9957d895
templater: add strip function with chars as an extra argument
Alexander Plavin <me@aplavin.ru>
parents:
19228
diff
changeset
|
549 def strip(context, mapping, args): |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
550 """:strip(text[, chars]): Strip characters from a string.""" |
19330
867b9957d895
templater: add strip function with chars as an extra argument
Alexander Plavin <me@aplavin.ru>
parents:
19228
diff
changeset
|
551 if not (1 <= len(args) <= 2): |
23112
3226ed457928
i18n: add i18n comment to error messages of template functions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22844
diff
changeset
|
552 # i18n: "strip" is a keyword |
19330
867b9957d895
templater: add strip function with chars as an extra argument
Alexander Plavin <me@aplavin.ru>
parents:
19228
diff
changeset
|
553 raise error.ParseError(_("strip expects one or two arguments")) |
867b9957d895
templater: add strip function with chars as an extra argument
Alexander Plavin <me@aplavin.ru>
parents:
19228
diff
changeset
|
554 |
20662
a54c0d830499
templater: apply "stringify()" on sub expression to get string correctly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20661
diff
changeset
|
555 text = stringify(args[0][0](context, mapping, args[0][1])) |
19330
867b9957d895
templater: add strip function with chars as an extra argument
Alexander Plavin <me@aplavin.ru>
parents:
19228
diff
changeset
|
556 if len(args) == 2: |
20662
a54c0d830499
templater: apply "stringify()" on sub expression to get string correctly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20661
diff
changeset
|
557 chars = stringify(args[1][0](context, mapping, args[1][1])) |
19330
867b9957d895
templater: add strip function with chars as an extra argument
Alexander Plavin <me@aplavin.ru>
parents:
19228
diff
changeset
|
558 return text.strip(chars) |
867b9957d895
templater: add strip function with chars as an extra argument
Alexander Plavin <me@aplavin.ru>
parents:
19228
diff
changeset
|
559 return text.strip() |
867b9957d895
templater: add strip function with chars as an extra argument
Alexander Plavin <me@aplavin.ru>
parents:
19228
diff
changeset
|
560 |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
561 def sub(context, mapping, args): |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
562 """:sub(pattern, replacement, expression): Perform text substitution |
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
563 using regular expressions.""" |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
564 if len(args) != 3: |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
565 # i18n: "sub" is a keyword |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
566 raise error.ParseError(_("sub expects three arguments")) |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
567 |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
568 pat = stringify(args[0][0](context, mapping, args[0][1])) |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
569 rpl = stringify(args[1][0](context, mapping, args[1][1])) |
20661
7e627fe63e5e
templater: avoid recursive evaluation of string literals completely
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20312
diff
changeset
|
570 src = stringify(_evalifliteral(args[2], context, mapping)) |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
571 yield re.sub(pat, rpl, src) |
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
572 |
21821
4a445dc5abff
templater: introduce startswith function
Ryan McElroy <rmcelroy@fb.com>
parents:
21798
diff
changeset
|
573 def startswith(context, mapping, args): |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
574 """:startswith(pattern, text): Returns the value from the "text" argument |
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
575 if it begins with the content from the "pattern" argument.""" |
21821
4a445dc5abff
templater: introduce startswith function
Ryan McElroy <rmcelroy@fb.com>
parents:
21798
diff
changeset
|
576 if len(args) != 2: |
21960
2896d450fec4
templater: add i18n comments to error messages of newly added functions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21846
diff
changeset
|
577 # i18n: "startswith" is a keyword |
21821
4a445dc5abff
templater: introduce startswith function
Ryan McElroy <rmcelroy@fb.com>
parents:
21798
diff
changeset
|
578 raise error.ParseError(_("startswith expects two arguments")) |
4a445dc5abff
templater: introduce startswith function
Ryan McElroy <rmcelroy@fb.com>
parents:
21798
diff
changeset
|
579 |
4a445dc5abff
templater: introduce startswith function
Ryan McElroy <rmcelroy@fb.com>
parents:
21798
diff
changeset
|
580 patn = stringify(args[0][0](context, mapping, args[0][1])) |
4a445dc5abff
templater: introduce startswith function
Ryan McElroy <rmcelroy@fb.com>
parents:
21798
diff
changeset
|
581 text = stringify(args[1][0](context, mapping, args[1][1])) |
4a445dc5abff
templater: introduce startswith function
Ryan McElroy <rmcelroy@fb.com>
parents:
21798
diff
changeset
|
582 if text.startswith(patn): |
4a445dc5abff
templater: introduce startswith function
Ryan McElroy <rmcelroy@fb.com>
parents:
21798
diff
changeset
|
583 return text |
4a445dc5abff
templater: introduce startswith function
Ryan McElroy <rmcelroy@fb.com>
parents:
21798
diff
changeset
|
584 return '' |
4a445dc5abff
templater: introduce startswith function
Ryan McElroy <rmcelroy@fb.com>
parents:
21798
diff
changeset
|
585 |
4a445dc5abff
templater: introduce startswith function
Ryan McElroy <rmcelroy@fb.com>
parents:
21798
diff
changeset
|
586 |
21846
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
587 def word(context, mapping, args): |
24586
90e3f5d22dad
templater: add consistent docstrings to functions
Gregory Szorc <gregory.szorc@gmail.com>
parents:
24337
diff
changeset
|
588 """:word(number, text[, separator]): Return the nth word from a string.""" |
21846
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
589 if not (2 <= len(args) <= 3): |
21960
2896d450fec4
templater: add i18n comments to error messages of newly added functions
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21846
diff
changeset
|
590 # i18n: "word" is a keyword |
21846
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
591 raise error.ParseError(_("word expects two or three arguments, got %d") |
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
592 % len(args)) |
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
593 |
24886
10a13da8840d
templater: fail more gracefully for blank strings to word
Ryan McElroy <rmcelroy@fb.com>
parents:
24601
diff
changeset
|
594 try: |
10a13da8840d
templater: fail more gracefully for blank strings to word
Ryan McElroy <rmcelroy@fb.com>
parents:
24601
diff
changeset
|
595 num = int(stringify(args[0][0](context, mapping, args[0][1]))) |
10a13da8840d
templater: fail more gracefully for blank strings to word
Ryan McElroy <rmcelroy@fb.com>
parents:
24601
diff
changeset
|
596 except ValueError: |
10a13da8840d
templater: fail more gracefully for blank strings to word
Ryan McElroy <rmcelroy@fb.com>
parents:
24601
diff
changeset
|
597 # i18n: "word" is a keyword |
25003
5e584edbb211
templater: update error message of invalid number passed to word() function
Yuya Nishihara <yuya@tcha.org>
parents:
25002
diff
changeset
|
598 raise error.ParseError(_("word expects an integer index")) |
21846
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
599 text = stringify(args[1][0](context, mapping, args[1][1])) |
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
600 if len(args) == 3: |
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
601 splitter = stringify(args[2][0](context, mapping, args[2][1])) |
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
602 else: |
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
603 splitter = None |
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
604 |
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
605 tokens = text.split(splitter) |
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
606 if num >= len(tokens): |
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
607 return '' |
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
608 else: |
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
609 return tokens[num] |
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
610 |
25001
9668c1a433b3
templater: switch methods table on compileexp() of func args and inner expr
Yuya Nishihara <yuya@tcha.org>
parents:
24988
diff
changeset
|
611 # methods to interpret function arguments or inner expressions (e.g. {_(x)}) |
9668c1a433b3
templater: switch methods table on compileexp() of func args and inner expr
Yuya Nishihara <yuya@tcha.org>
parents:
24988
diff
changeset
|
612 exprmethods = { |
25002
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
613 "integer": lambda e, c: (runinteger, e[1]), |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
614 "string": lambda e, c: (runstring, e[1]), |
20663
5ab28a2e9962
templater: make strings in template expressions be "string-escape"-ed correctly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20662
diff
changeset
|
615 "rawstring": lambda e, c: (runrawstring, e[1]), |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
616 "symbol": lambda e, c: (runsymbol, e[1]), |
25596
c1975809a6b5
templater: take any string literals as template, but not for rawstring (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25595
diff
changeset
|
617 "template": buildtemplate, |
25001
9668c1a433b3
templater: switch methods table on compileexp() of func args and inner expr
Yuya Nishihara <yuya@tcha.org>
parents:
24988
diff
changeset
|
618 "group": lambda e, c: compileexp(e[1], c, exprmethods), |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
619 # ".": buildmember, |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
620 "|": buildfilter, |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
621 "%": buildmap, |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
622 "func": buildfunc, |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
623 } |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
624 |
25001
9668c1a433b3
templater: switch methods table on compileexp() of func args and inner expr
Yuya Nishihara <yuya@tcha.org>
parents:
24988
diff
changeset
|
625 # methods to interpret top-level template (e.g. {x}, {x|_}, {x % "y"}) |
9668c1a433b3
templater: switch methods table on compileexp() of func args and inner expr
Yuya Nishihara <yuya@tcha.org>
parents:
24988
diff
changeset
|
626 methods = exprmethods.copy() |
25002
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
627 methods["integer"] = exprmethods["symbol"] # '{1}' as variable |
25001
9668c1a433b3
templater: switch methods table on compileexp() of func args and inner expr
Yuya Nishihara <yuya@tcha.org>
parents:
24988
diff
changeset
|
628 |
14925
ab545a15d807
templater: use a global funcs table
Matt Mackall <mpm@selenic.com>
parents:
14168
diff
changeset
|
629 funcs = { |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
630 "date": date, |
22434
40ce05b50148
templater: add "diff" template function
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
22304
diff
changeset
|
631 "diff": diff, |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
632 "fill": fill, |
18582
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
633 "get": get, |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
634 "if": if_, |
20518
1e43f15a647f
template: add ifcontains template function
Durham Goode <durham@fb.com>
parents:
20371
diff
changeset
|
635 "ifcontains": ifcontains, |
17636
ce18dbcd91c8
templater: add if/ifeq conditionals
Matt Mackall <mpm@selenic.com>
parents:
17635
diff
changeset
|
636 "ifeq": ifeq, |
25489
ef8956aa8755
templater: introduce indent function
Ryan McElroy <rmcelroy@fb.com>
parents:
25096
diff
changeset
|
637 "indent": indent, |
17633
312184f930b7
template: add join function
Matt Mackall <mpm@selenic.com>
parents:
17632
diff
changeset
|
638 "join": join, |
18582
ef78450c8df6
templater: add get() function to access dict element (e.g. extra)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
18289
diff
changeset
|
639 "label": label, |
20370
aa51392da507
template: add pad function for padding output
Durham Goode <durham@fb.com>
parents:
20369
diff
changeset
|
640 "pad": pad, |
20519
cda9d2b6beab
template: add revset() template function
Durham Goode <durham@fb.com>
parents:
20518
diff
changeset
|
641 "revset": revset, |
18747
f5db3092790f
hgweb: generate HTML documentation
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
18582
diff
changeset
|
642 "rstdoc": rstdoc, |
20369
9c6b86dd2ed2
template: add shortest(node) template function
Durham Goode <durham@fb.com>
parents:
20312
diff
changeset
|
643 "shortest": shortest, |
21821
4a445dc5abff
templater: introduce startswith function
Ryan McElroy <rmcelroy@fb.com>
parents:
21798
diff
changeset
|
644 "startswith": startswith, |
19390
3af3a165db18
templater: sort functions alphabetically, as filters are
Alexander Plavin <me@aplavin.ru>
parents:
19330
diff
changeset
|
645 "strip": strip, |
17635
8804e3cb51bd
templater: add sub() function
Matt Mackall <mpm@selenic.com>
parents:
17634
diff
changeset
|
646 "sub": sub, |
21846
8f23f8096606
templater: introduce word function
Ryan McElroy <rmcelroy@fb.com>
parents:
21822
diff
changeset
|
647 "word": word, |
14925
ab545a15d807
templater: use a global funcs table
Matt Mackall <mpm@selenic.com>
parents:
14168
diff
changeset
|
648 } |
ab545a15d807
templater: use a global funcs table
Matt Mackall <mpm@selenic.com>
parents:
14168
diff
changeset
|
649 |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
650 # template engine |
1901
c64bef3d7043
use safer string parser for template engine.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1900
diff
changeset
|
651 |
8360
acc202b71619
templater: provide the standard template filters by default
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
8312
diff
changeset
|
652 stringify = templatefilters.stringify |
7107
125c8fedcbe0
Allow hgweb to search for templates in more than one path.
Brendan Cully <brendan@kublai.com>
parents:
6783
diff
changeset
|
653 |
10850
a63391e26284
templater: use recursive flattening
Matt Mackall <mpm@selenic.com>
parents:
10849
diff
changeset
|
654 def _flatten(thing): |
a63391e26284
templater: use recursive flattening
Matt Mackall <mpm@selenic.com>
parents:
10849
diff
changeset
|
655 '''yield a single stream from a possibly nested set of iterators''' |
a63391e26284
templater: use recursive flattening
Matt Mackall <mpm@selenic.com>
parents:
10849
diff
changeset
|
656 if isinstance(thing, str): |
a63391e26284
templater: use recursive flattening
Matt Mackall <mpm@selenic.com>
parents:
10849
diff
changeset
|
657 yield thing |
14944
e2c413bde8a5
globally: use safehasattr(x, '__iter__') instead of hasattr(x, '__iter__')
Augie Fackler <durin42@gmail.com>
parents:
14943
diff
changeset
|
658 elif not util.safehasattr(thing, '__iter__'): |
11305
d4cafcb63f77
cleanups: undefined variables
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
10855
diff
changeset
|
659 if thing is not None: |
10852
0d50586a9d31
templater: raise nested functions
Matt Mackall <mpm@selenic.com>
parents:
10850
diff
changeset
|
660 yield str(thing) |
0d50586a9d31
templater: raise nested functions
Matt Mackall <mpm@selenic.com>
parents:
10850
diff
changeset
|
661 else: |
10850
a63391e26284
templater: use recursive flattening
Matt Mackall <mpm@selenic.com>
parents:
10849
diff
changeset
|
662 for i in thing: |
a63391e26284
templater: use recursive flattening
Matt Mackall <mpm@selenic.com>
parents:
10849
diff
changeset
|
663 if isinstance(i, str): |
a63391e26284
templater: use recursive flattening
Matt Mackall <mpm@selenic.com>
parents:
10849
diff
changeset
|
664 yield i |
14944
e2c413bde8a5
globally: use safehasattr(x, '__iter__') instead of hasattr(x, '__iter__')
Augie Fackler <durin42@gmail.com>
parents:
14943
diff
changeset
|
665 elif not util.safehasattr(i, '__iter__'): |
10852
0d50586a9d31
templater: raise nested functions
Matt Mackall <mpm@selenic.com>
parents:
10850
diff
changeset
|
666 if i is not None: |
0d50586a9d31
templater: raise nested functions
Matt Mackall <mpm@selenic.com>
parents:
10850
diff
changeset
|
667 yield str(i) |
10850
a63391e26284
templater: use recursive flattening
Matt Mackall <mpm@selenic.com>
parents:
10849
diff
changeset
|
668 elif i is not None: |
a63391e26284
templater: use recursive flattening
Matt Mackall <mpm@selenic.com>
parents:
10849
diff
changeset
|
669 for j in _flatten(i): |
a63391e26284
templater: use recursive flattening
Matt Mackall <mpm@selenic.com>
parents:
10849
diff
changeset
|
670 yield j |
a63391e26284
templater: use recursive flattening
Matt Mackall <mpm@selenic.com>
parents:
10849
diff
changeset
|
671 |
24988
e8ff0b09acac
templater: rename parsestring() to unquotestring() (API)
Yuya Nishihara <yuya@tcha.org>
parents:
24987
diff
changeset
|
672 def unquotestring(s): |
24987
fd7287f0b43c
templater: remove noop calls of parsestring(s, quoted=False) (API)
Yuya Nishihara <yuya@tcha.org>
parents:
24966
diff
changeset
|
673 '''unwrap quotes''' |
fd7287f0b43c
templater: remove noop calls of parsestring(s, quoted=False) (API)
Yuya Nishihara <yuya@tcha.org>
parents:
24966
diff
changeset
|
674 if len(s) < 2 or s[0] != s[-1]: |
fd7287f0b43c
templater: remove noop calls of parsestring(s, quoted=False) (API)
Yuya Nishihara <yuya@tcha.org>
parents:
24966
diff
changeset
|
675 raise SyntaxError(_('unmatched quotes')) |
fd7287f0b43c
templater: remove noop calls of parsestring(s, quoted=False) (API)
Yuya Nishihara <yuya@tcha.org>
parents:
24966
diff
changeset
|
676 # de-backslash-ify only <\">. it is invalid syntax in non-string part of |
fd7287f0b43c
templater: remove noop calls of parsestring(s, quoted=False) (API)
Yuya Nishihara <yuya@tcha.org>
parents:
24966
diff
changeset
|
677 # template, but we are likely to escape <"> in quoted string and it was |
fd7287f0b43c
templater: remove noop calls of parsestring(s, quoted=False) (API)
Yuya Nishihara <yuya@tcha.org>
parents:
24966
diff
changeset
|
678 # accepted before, thanks to issue4290. <\\"> is unmodified because it |
fd7287f0b43c
templater: remove noop calls of parsestring(s, quoted=False) (API)
Yuya Nishihara <yuya@tcha.org>
parents:
24966
diff
changeset
|
679 # is ambiguous and it was processed as such before 2.8.1. |
fd7287f0b43c
templater: remove noop calls of parsestring(s, quoted=False) (API)
Yuya Nishihara <yuya@tcha.org>
parents:
24966
diff
changeset
|
680 # |
fd7287f0b43c
templater: remove noop calls of parsestring(s, quoted=False) (API)
Yuya Nishihara <yuya@tcha.org>
parents:
24966
diff
changeset
|
681 # template result |
fd7287f0b43c
templater: remove noop calls of parsestring(s, quoted=False) (API)
Yuya Nishihara <yuya@tcha.org>
parents:
24966
diff
changeset
|
682 # --------- ------------------------ |
fd7287f0b43c
templater: remove noop calls of parsestring(s, quoted=False) (API)
Yuya Nishihara <yuya@tcha.org>
parents:
24966
diff
changeset
|
683 # {\"\"} parse error |
fd7287f0b43c
templater: remove noop calls of parsestring(s, quoted=False) (API)
Yuya Nishihara <yuya@tcha.org>
parents:
24966
diff
changeset
|
684 # "{""}" {""} -> <> |
fd7287f0b43c
templater: remove noop calls of parsestring(s, quoted=False) (API)
Yuya Nishihara <yuya@tcha.org>
parents:
24966
diff
changeset
|
685 # "{\"\"}" {""} -> <> |
fd7287f0b43c
templater: remove noop calls of parsestring(s, quoted=False) (API)
Yuya Nishihara <yuya@tcha.org>
parents:
24966
diff
changeset
|
686 # {"\""} {"\""} -> <"> |
fd7287f0b43c
templater: remove noop calls of parsestring(s, quoted=False) (API)
Yuya Nishihara <yuya@tcha.org>
parents:
24966
diff
changeset
|
687 # '{"\""}' {"\""} -> <"> |
fd7287f0b43c
templater: remove noop calls of parsestring(s, quoted=False) (API)
Yuya Nishihara <yuya@tcha.org>
parents:
24966
diff
changeset
|
688 # "{"\""}" parse error (don't care) |
fd7287f0b43c
templater: remove noop calls of parsestring(s, quoted=False) (API)
Yuya Nishihara <yuya@tcha.org>
parents:
24966
diff
changeset
|
689 q = s[0] |
fd7287f0b43c
templater: remove noop calls of parsestring(s, quoted=False) (API)
Yuya Nishihara <yuya@tcha.org>
parents:
24966
diff
changeset
|
690 return s[1:-1].replace('\\\\' + q, '\\\\\\' + q).replace('\\' + q, q) |
1896
f8f818a04f5b
move hgweb template code out to templater
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
diff
changeset
|
691 |
8218
e61cb2813d2a
templater: separate template management and actual string processing
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
8198
diff
changeset
|
692 class engine(object): |
1909
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
693 '''template expansion engine. |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
694 |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
695 template expansion works like this. a map file contains key=value |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
696 pairs. if value is quoted, it is treated as string. otherwise, it |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
697 is treated as name of template file. |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
698 |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
699 templater is asked to expand a key in map. it looks up key, and |
4334
66a3fe30f9fc
minor typo fix in templater's docstring
TK Soh <teekaysoh@yahoo.com>
parents:
3904
diff
changeset
|
700 looks for strings like this: {foo}. it expands {foo} by looking up |
1909
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
701 foo in map, and substituting it. expansion is recursive: it stops |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
702 when there is no more {foo} to replace. |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
703 |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
704 expansion also allows formatting and filtering. |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
705 |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
706 format uses key to expand each item in list. syntax is |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
707 {key%format}. |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
708 |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
709 filter uses function to transform value. syntax is |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
710 {key|filter1|filter2|...}.''' |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
711 |
8218
e61cb2813d2a
templater: separate template management and actual string processing
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
8198
diff
changeset
|
712 def __init__(self, loader, filters={}, defaults={}): |
10848
01346cea5485
templater: privatize class variables
Matt Mackall <mpm@selenic.com>
parents:
10847
diff
changeset
|
713 self._loader = loader |
01346cea5485
templater: privatize class variables
Matt Mackall <mpm@selenic.com>
parents:
10847
diff
changeset
|
714 self._filters = filters |
01346cea5485
templater: privatize class variables
Matt Mackall <mpm@selenic.com>
parents:
10847
diff
changeset
|
715 self._defaults = defaults |
01346cea5485
templater: privatize class variables
Matt Mackall <mpm@selenic.com>
parents:
10847
diff
changeset
|
716 self._cache = {} |
8218
e61cb2813d2a
templater: separate template management and actual string processing
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
8198
diff
changeset
|
717 |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
718 def _load(self, t): |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
719 '''load, parse, and cache a template''' |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
720 if t not in self._cache: |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
721 self._cache[t] = compiletemplate(self._loader(t), self) |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
722 return self._cache[t] |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
723 |
10853
b6f6d9fd53d6
templater: drop raw method
Matt Mackall <mpm@selenic.com>
parents:
10852
diff
changeset
|
724 def process(self, t, mapping): |
b6f6d9fd53d6
templater: drop raw method
Matt Mackall <mpm@selenic.com>
parents:
10852
diff
changeset
|
725 '''Perform expansion. t is name of map element to expand. |
b6f6d9fd53d6
templater: drop raw method
Matt Mackall <mpm@selenic.com>
parents:
10852
diff
changeset
|
726 mapping contains added elements for use during expansion. Is a |
b6f6d9fd53d6
templater: drop raw method
Matt Mackall <mpm@selenic.com>
parents:
10852
diff
changeset
|
727 generator.''' |
17632
523625e46760
templater: factor out runtemplate method
Matt Mackall <mpm@selenic.com>
parents:
17631
diff
changeset
|
728 return _flatten(runtemplate(self, mapping, self._load(t))) |
8218
e61cb2813d2a
templater: separate template management and actual string processing
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
8198
diff
changeset
|
729 |
8361
d8c5a7f25a40
templater: make the templating engine pluggable to some extent
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
8360
diff
changeset
|
730 engines = {'default': engine} |
d8c5a7f25a40
templater: make the templating engine pluggable to some extent
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
8360
diff
changeset
|
731 |
19125
6ba6e345961e
templater: show the style list when I try to use a wrong one
Iulian Stana <julian.stana@gmail.com>
parents:
19079
diff
changeset
|
732 def stylelist(): |
22634
e48a5d3996c2
templater: introduce templatepaths for getting paths searched for templates
Mads Kiilerich <madski@unity3d.com>
parents:
22633
diff
changeset
|
733 paths = templatepaths() |
20312
268a5ab5c27b
templater: selecting a style with no templates does not crash (issue4140)
Simon Heimberg <simohe@besonet.ch>
parents:
20067
diff
changeset
|
734 if not paths: |
268a5ab5c27b
templater: selecting a style with no templates does not crash (issue4140)
Simon Heimberg <simohe@besonet.ch>
parents:
20067
diff
changeset
|
735 return _('no templates found, try `hg debuginstall` for more info') |
268a5ab5c27b
templater: selecting a style with no templates does not crash (issue4140)
Simon Heimberg <simohe@besonet.ch>
parents:
20067
diff
changeset
|
736 dirlist = os.listdir(paths[0]) |
19125
6ba6e345961e
templater: show the style list when I try to use a wrong one
Iulian Stana <julian.stana@gmail.com>
parents:
19079
diff
changeset
|
737 stylelist = [] |
6ba6e345961e
templater: show the style list when I try to use a wrong one
Iulian Stana <julian.stana@gmail.com>
parents:
19079
diff
changeset
|
738 for file in dirlist: |
6ba6e345961e
templater: show the style list when I try to use a wrong one
Iulian Stana <julian.stana@gmail.com>
parents:
19079
diff
changeset
|
739 split = file.split(".") |
6ba6e345961e
templater: show the style list when I try to use a wrong one
Iulian Stana <julian.stana@gmail.com>
parents:
19079
diff
changeset
|
740 if split[0] == "map-cmdline": |
6ba6e345961e
templater: show the style list when I try to use a wrong one
Iulian Stana <julian.stana@gmail.com>
parents:
19079
diff
changeset
|
741 stylelist.append(split[1]) |
19127
d982edcfe7f0
templater: fix output instability from gsoc patches
Augie Fackler <raf@durin42.com>
parents:
19125
diff
changeset
|
742 return ", ".join(sorted(stylelist)) |
19125
6ba6e345961e
templater: show the style list when I try to use a wrong one
Iulian Stana <julian.stana@gmail.com>
parents:
19079
diff
changeset
|
743 |
19770
0361163efbaf
templater: support using templates with non-standard names from map file
Alexander Plavin <alexander@plav.in>
parents:
19390
diff
changeset
|
744 class TemplateNotFound(util.Abort): |
0361163efbaf
templater: support using templates with non-standard names from map file
Alexander Plavin <alexander@plav.in>
parents:
19390
diff
changeset
|
745 pass |
0361163efbaf
templater: support using templates with non-standard names from map file
Alexander Plavin <alexander@plav.in>
parents:
19390
diff
changeset
|
746 |
8218
e61cb2813d2a
templater: separate template management and actual string processing
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
8198
diff
changeset
|
747 class templater(object): |
e61cb2813d2a
templater: separate template management and actual string processing
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
8198
diff
changeset
|
748 |
7396
526c40a74bd0
templater: return data in increasing chunk sizes
Brendan Cully <brendan@kublai.com>
parents:
7107
diff
changeset
|
749 def __init__(self, mapfile, filters={}, defaults={}, cache={}, |
526c40a74bd0
templater: return data in increasing chunk sizes
Brendan Cully <brendan@kublai.com>
parents:
7107
diff
changeset
|
750 minchunk=1024, maxchunk=65536): |
1909
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
751 '''set up template engine. |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
752 mapfile is name of file to read map definitions from. |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
753 filters is dict of functions. each transforms a value into another. |
37b9f80a5fbb
add doc comments to template code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1906
diff
changeset
|
754 defaults is dict of default map definitions.''' |
1905
0c760737b996
improve template errors when something is wrong.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1904
diff
changeset
|
755 self.mapfile = mapfile or 'template' |
1975
6e1a8ea5d717
Duplicate cache when creating templater.
Shun-ichi Goto <shunichi.goto@gmail.com>
parents:
1964
diff
changeset
|
756 self.cache = cache.copy() |
1896
f8f818a04f5b
move hgweb template code out to templater
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
diff
changeset
|
757 self.map = {} |
24306
6ddc86eedc3b
style: kill ersatz if-else ternary operators
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
24303
diff
changeset
|
758 if mapfile: |
6ddc86eedc3b
style: kill ersatz if-else ternary operators
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
24303
diff
changeset
|
759 self.base = os.path.dirname(mapfile) |
6ddc86eedc3b
style: kill ersatz if-else ternary operators
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
24303
diff
changeset
|
760 else: |
6ddc86eedc3b
style: kill ersatz if-else ternary operators
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
24303
diff
changeset
|
761 self.base = '' |
8360
acc202b71619
templater: provide the standard template filters by default
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
8312
diff
changeset
|
762 self.filters = templatefilters.filters.copy() |
acc202b71619
templater: provide the standard template filters by default
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
8312
diff
changeset
|
763 self.filters.update(filters) |
1964
778281d46bb2
fix template bug that made hgweb break.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1955
diff
changeset
|
764 self.defaults = defaults |
7396
526c40a74bd0
templater: return data in increasing chunk sizes
Brendan Cully <brendan@kublai.com>
parents:
7107
diff
changeset
|
765 self.minchunk, self.maxchunk = minchunk, maxchunk |
13187
e3b87fb34d00
templater: clarify engine caching
Matt Mackall <mpm@selenic.com>
parents:
13176
diff
changeset
|
766 self.ecache = {} |
1896
f8f818a04f5b
move hgweb template code out to templater
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
diff
changeset
|
767 |
1905
0c760737b996
improve template errors when something is wrong.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1904
diff
changeset
|
768 if not mapfile: |
0c760737b996
improve template errors when something is wrong.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1904
diff
changeset
|
769 return |
6337
d2713d902524
give better error message on non-existent mapfile (issue813)
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
5976
diff
changeset
|
770 if not os.path.exists(mapfile): |
19125
6ba6e345961e
templater: show the style list when I try to use a wrong one
Iulian Stana <julian.stana@gmail.com>
parents:
19079
diff
changeset
|
771 raise util.Abort(_("style '%s' not found") % mapfile, |
6ba6e345961e
templater: show the style list when I try to use a wrong one
Iulian Stana <julian.stana@gmail.com>
parents:
19079
diff
changeset
|
772 hint=_("available styles: %s") % stylelist()) |
6337
d2713d902524
give better error message on non-existent mapfile (issue813)
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
5976
diff
changeset
|
773 |
25096
081b08e4ea13
templater: look for mapfiles in template paths
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
25003
diff
changeset
|
774 conf = config.config(includepaths=templatepaths()) |
8194
63c47e4ac617
templater: use new config parser
Matt Mackall <mpm@selenic.com>
parents:
8015
diff
changeset
|
775 conf.read(mapfile) |
63c47e4ac617
templater: use new config parser
Matt Mackall <mpm@selenic.com>
parents:
8015
diff
changeset
|
776 |
63c47e4ac617
templater: use new config parser
Matt Mackall <mpm@selenic.com>
parents:
8015
diff
changeset
|
777 for key, val in conf[''].items(): |
17334
39c01f8e7b39
templater: handle a missing value correctly
Ross Lagerwall <rosslagerwall@gmail.com>
parents:
16686
diff
changeset
|
778 if not val: |
39c01f8e7b39
templater: handle a missing value correctly
Ross Lagerwall <rosslagerwall@gmail.com>
parents:
16686
diff
changeset
|
779 raise SyntaxError(_('%s: missing value') % conf.source('', key)) |
8194
63c47e4ac617
templater: use new config parser
Matt Mackall <mpm@selenic.com>
parents:
8015
diff
changeset
|
780 if val[0] in "'\"": |
63c47e4ac617
templater: use new config parser
Matt Mackall <mpm@selenic.com>
parents:
8015
diff
changeset
|
781 try: |
24988
e8ff0b09acac
templater: rename parsestring() to unquotestring() (API)
Yuya Nishihara <yuya@tcha.org>
parents:
24987
diff
changeset
|
782 self.cache[key] = unquotestring(val) |
8194
63c47e4ac617
templater: use new config parser
Matt Mackall <mpm@selenic.com>
parents:
8015
diff
changeset
|
783 except SyntaxError, inst: |
63c47e4ac617
templater: use new config parser
Matt Mackall <mpm@selenic.com>
parents:
8015
diff
changeset
|
784 raise SyntaxError('%s: %s' % |
8198
cf9accffd0b3
config: getsource -> source
Matt Mackall <mpm@selenic.com>
parents:
8194
diff
changeset
|
785 (conf.source('', key), inst.args[0])) |
1896
f8f818a04f5b
move hgweb template code out to templater
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
diff
changeset
|
786 else: |
8361
d8c5a7f25a40
templater: make the templating engine pluggable to some extent
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
8360
diff
changeset
|
787 val = 'default', val |
d8c5a7f25a40
templater: make the templating engine pluggable to some extent
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
8360
diff
changeset
|
788 if ':' in val[1]: |
d8c5a7f25a40
templater: make the templating engine pluggable to some extent
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
8360
diff
changeset
|
789 val = val[1].split(':', 1) |
d8c5a7f25a40
templater: make the templating engine pluggable to some extent
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
8360
diff
changeset
|
790 self.map[key] = val[0], os.path.join(self.base, val[1]) |
1896
f8f818a04f5b
move hgweb template code out to templater
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
diff
changeset
|
791 |
1899
888d298ddb91
many small changes to templater.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1897
diff
changeset
|
792 def __contains__(self, key): |
3637
e7639888bb2f
templater: simplify cache and remove filter argument in __call__
Matt Mackall <mpm@selenic.com>
parents:
3636
diff
changeset
|
793 return key in self.cache or key in self.map |
1899
888d298ddb91
many small changes to templater.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1897
diff
changeset
|
794 |
8218
e61cb2813d2a
templater: separate template management and actual string processing
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
8198
diff
changeset
|
795 def load(self, t): |
6783
6d824dc86907
templater: make a template a string-only iterator
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
6434
diff
changeset
|
796 '''Get the template for the given template name. Use a local cache.''' |
16686
67964cda8701
cleanup: "not x in y" -> "x not in y"
Brodie Rao <brodie@sf.io>
parents:
14944
diff
changeset
|
797 if t not in self.cache: |
1905
0c760737b996
improve template errors when something is wrong.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1904
diff
changeset
|
798 try: |
14168
135e244776f0
prevent transient leaks of file handle by using new helper functions
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
13665
diff
changeset
|
799 self.cache[t] = util.readfile(self.map[t][1]) |
13175
09cde75e0613
templater: give slightly nicer error for unknown map entries
Matt Mackall <mpm@selenic.com>
parents:
13020
diff
changeset
|
800 except KeyError, inst: |
19770
0361163efbaf
templater: support using templates with non-standard names from map file
Alexander Plavin <alexander@plav.in>
parents:
19390
diff
changeset
|
801 raise TemplateNotFound(_('"%s" not in template map') % |
0361163efbaf
templater: support using templates with non-standard names from map file
Alexander Plavin <alexander@plav.in>
parents:
19390
diff
changeset
|
802 inst.args[0]) |
1905
0c760737b996
improve template errors when something is wrong.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1904
diff
changeset
|
803 except IOError, inst: |
0c760737b996
improve template errors when something is wrong.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
1904
diff
changeset
|
804 raise IOError(inst.args[0], _('template file %s: %s') % |
8361
d8c5a7f25a40
templater: make the templating engine pluggable to some extent
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
8360
diff
changeset
|
805 (self.map[t][1], inst.args[1])) |
6783
6d824dc86907
templater: make a template a string-only iterator
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
6434
diff
changeset
|
806 return self.cache[t] |
1896
f8f818a04f5b
move hgweb template code out to templater
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
diff
changeset
|
807 |
10847 | 808 def __call__(self, t, **mapping): |
8361
d8c5a7f25a40
templater: make the templating engine pluggable to some extent
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
8360
diff
changeset
|
809 ttype = t in self.map and self.map[t][0] or 'default' |
13187
e3b87fb34d00
templater: clarify engine caching
Matt Mackall <mpm@selenic.com>
parents:
13176
diff
changeset
|
810 if ttype not in self.ecache: |
e3b87fb34d00
templater: clarify engine caching
Matt Mackall <mpm@selenic.com>
parents:
13176
diff
changeset
|
811 self.ecache[ttype] = engines[ttype](self.load, |
e3b87fb34d00
templater: clarify engine caching
Matt Mackall <mpm@selenic.com>
parents:
13176
diff
changeset
|
812 self.filters, self.defaults) |
e3b87fb34d00
templater: clarify engine caching
Matt Mackall <mpm@selenic.com>
parents:
13176
diff
changeset
|
813 proc = self.ecache[ttype] |
8361
d8c5a7f25a40
templater: make the templating engine pluggable to some extent
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
8360
diff
changeset
|
814 |
10847 | 815 stream = proc.process(t, mapping) |
7396
526c40a74bd0
templater: return data in increasing chunk sizes
Brendan Cully <brendan@kublai.com>
parents:
7107
diff
changeset
|
816 if self.minchunk: |
526c40a74bd0
templater: return data in increasing chunk sizes
Brendan Cully <brendan@kublai.com>
parents:
7107
diff
changeset
|
817 stream = util.increasingchunks(stream, min=self.minchunk, |
526c40a74bd0
templater: return data in increasing chunk sizes
Brendan Cully <brendan@kublai.com>
parents:
7107
diff
changeset
|
818 max=self.maxchunk) |
526c40a74bd0
templater: return data in increasing chunk sizes
Brendan Cully <brendan@kublai.com>
parents:
7107
diff
changeset
|
819 return stream |
7434
cf7741aa1e96
kill some trailing spaces
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
7396
diff
changeset
|
820 |
22634
e48a5d3996c2
templater: introduce templatepaths for getting paths searched for templates
Mads Kiilerich <madski@unity3d.com>
parents:
22633
diff
changeset
|
821 def templatepaths(): |
e48a5d3996c2
templater: introduce templatepaths for getting paths searched for templates
Mads Kiilerich <madski@unity3d.com>
parents:
22633
diff
changeset
|
822 '''return locations used for template files.''' |
22636
d844e220792a
templater: don't search randomly for templates - trust util.datapath
Mads Kiilerich <madski@unity3d.com>
parents:
22635
diff
changeset
|
823 pathsrel = ['templates'] |
22635
660861a6fad4
templater: inline global 'path' list in templatepaths
Mads Kiilerich <madski@unity3d.com>
parents:
22634
diff
changeset
|
824 paths = [os.path.normpath(os.path.join(util.datapath, f)) |
660861a6fad4
templater: inline global 'path' list in templatepaths
Mads Kiilerich <madski@unity3d.com>
parents:
22634
diff
changeset
|
825 for f in pathsrel] |
660861a6fad4
templater: inline global 'path' list in templatepaths
Mads Kiilerich <madski@unity3d.com>
parents:
22634
diff
changeset
|
826 return [p for p in paths if os.path.isdir(p)] |
2189
e3eba577a0ae
move changeset_templater into templater module.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2001
diff
changeset
|
827 |
22634
e48a5d3996c2
templater: introduce templatepaths for getting paths searched for templates
Mads Kiilerich <madski@unity3d.com>
parents:
22633
diff
changeset
|
828 def templatepath(name): |
e48a5d3996c2
templater: introduce templatepaths for getting paths searched for templates
Mads Kiilerich <madski@unity3d.com>
parents:
22633
diff
changeset
|
829 '''return location of template file. returns None if not found.''' |
e48a5d3996c2
templater: introduce templatepaths for getting paths searched for templates
Mads Kiilerich <madski@unity3d.com>
parents:
22633
diff
changeset
|
830 for p in templatepaths(): |
e48a5d3996c2
templater: introduce templatepaths for getting paths searched for templates
Mads Kiilerich <madski@unity3d.com>
parents:
22633
diff
changeset
|
831 f = os.path.join(p, name) |
e48a5d3996c2
templater: introduce templatepaths for getting paths searched for templates
Mads Kiilerich <madski@unity3d.com>
parents:
22633
diff
changeset
|
832 if os.path.exists(f): |
e48a5d3996c2
templater: introduce templatepaths for getting paths searched for templates
Mads Kiilerich <madski@unity3d.com>
parents:
22633
diff
changeset
|
833 return f |
e48a5d3996c2
templater: introduce templatepaths for getting paths searched for templates
Mads Kiilerich <madski@unity3d.com>
parents:
22633
diff
changeset
|
834 return None |
2189
e3eba577a0ae
move changeset_templater into templater module.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2001
diff
changeset
|
835 |
9842
d3dbdca92458
hgweb: don't choke when an inexistent style is requested (issue1901)
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
9372
diff
changeset
|
836 def stylemap(styles, paths=None): |
7966
aa983c3d94a9
templater: move stylemap function from hgweb to templater
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
7434
diff
changeset
|
837 """Return path to mapfile for a given style. |
aa983c3d94a9
templater: move stylemap function from hgweb to templater
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
7434
diff
changeset
|
838 |
aa983c3d94a9
templater: move stylemap function from hgweb to templater
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
7434
diff
changeset
|
839 Searches mapfile in the following locations: |
aa983c3d94a9
templater: move stylemap function from hgweb to templater
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
7434
diff
changeset
|
840 1. templatepath/style/map |
aa983c3d94a9
templater: move stylemap function from hgweb to templater
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
7434
diff
changeset
|
841 2. templatepath/map-style |
aa983c3d94a9
templater: move stylemap function from hgweb to templater
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
7434
diff
changeset
|
842 3. templatepath/map |
aa983c3d94a9
templater: move stylemap function from hgweb to templater
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
7434
diff
changeset
|
843 """ |
aa983c3d94a9
templater: move stylemap function from hgweb to templater
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
7434
diff
changeset
|
844 |
aa983c3d94a9
templater: move stylemap function from hgweb to templater
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
7434
diff
changeset
|
845 if paths is None: |
22634
e48a5d3996c2
templater: introduce templatepaths for getting paths searched for templates
Mads Kiilerich <madski@unity3d.com>
parents:
22633
diff
changeset
|
846 paths = templatepaths() |
7966
aa983c3d94a9
templater: move stylemap function from hgweb to templater
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
7434
diff
changeset
|
847 elif isinstance(paths, str): |
8223
02145b700fe4
templater: fix little problem from stylemap() changes
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
8218
diff
changeset
|
848 paths = [paths] |
7966
aa983c3d94a9
templater: move stylemap function from hgweb to templater
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
7434
diff
changeset
|
849 |
9842
d3dbdca92458
hgweb: don't choke when an inexistent style is requested (issue1901)
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
9372
diff
changeset
|
850 if isinstance(styles, str): |
d3dbdca92458
hgweb: don't choke when an inexistent style is requested (issue1901)
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
9372
diff
changeset
|
851 styles = [styles] |
d3dbdca92458
hgweb: don't choke when an inexistent style is requested (issue1901)
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
9372
diff
changeset
|
852 |
d3dbdca92458
hgweb: don't choke when an inexistent style is requested (issue1901)
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
9372
diff
changeset
|
853 for style in styles: |
24296
b73a22d1d9bf
hgweb: prevent loading style map from directories other than specified paths
Yuya Nishihara <yuya@tcha.org>
parents:
23167
diff
changeset
|
854 # only plain name is allowed to honor template paths |
b73a22d1d9bf
hgweb: prevent loading style map from directories other than specified paths
Yuya Nishihara <yuya@tcha.org>
parents:
23167
diff
changeset
|
855 if (not style |
b73a22d1d9bf
hgweb: prevent loading style map from directories other than specified paths
Yuya Nishihara <yuya@tcha.org>
parents:
23167
diff
changeset
|
856 or style in (os.curdir, os.pardir) |
b73a22d1d9bf
hgweb: prevent loading style map from directories other than specified paths
Yuya Nishihara <yuya@tcha.org>
parents:
23167
diff
changeset
|
857 or os.sep in style |
b73a22d1d9bf
hgweb: prevent loading style map from directories other than specified paths
Yuya Nishihara <yuya@tcha.org>
parents:
23167
diff
changeset
|
858 or os.altsep and os.altsep in style): |
9842
d3dbdca92458
hgweb: don't choke when an inexistent style is requested (issue1901)
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
9372
diff
changeset
|
859 continue |
d3dbdca92458
hgweb: don't choke when an inexistent style is requested (issue1901)
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
9372
diff
changeset
|
860 locations = [os.path.join(style, 'map'), 'map-' + style] |
d3dbdca92458
hgweb: don't choke when an inexistent style is requested (issue1901)
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
9372
diff
changeset
|
861 locations.append('map') |
d3dbdca92458
hgweb: don't choke when an inexistent style is requested (issue1901)
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
9372
diff
changeset
|
862 |
d3dbdca92458
hgweb: don't choke when an inexistent style is requested (issue1901)
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
9372
diff
changeset
|
863 for path in paths: |
d3dbdca92458
hgweb: don't choke when an inexistent style is requested (issue1901)
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
9372
diff
changeset
|
864 for location in locations: |
d3dbdca92458
hgweb: don't choke when an inexistent style is requested (issue1901)
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
9372
diff
changeset
|
865 mapfile = os.path.join(path, location) |
d3dbdca92458
hgweb: don't choke when an inexistent style is requested (issue1901)
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
9372
diff
changeset
|
866 if os.path.isfile(mapfile): |
d3dbdca92458
hgweb: don't choke when an inexistent style is requested (issue1901)
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
9372
diff
changeset
|
867 return style, mapfile |
7966
aa983c3d94a9
templater: move stylemap function from hgweb to templater
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
7434
diff
changeset
|
868 |
aa983c3d94a9
templater: move stylemap function from hgweb to templater
Dirkjan Ochtman <dirkjan@ochtman.nl>
parents:
7434
diff
changeset
|
869 raise RuntimeError("No hgweb templates found in %r" % paths) |
24601
d80819f67d59
templater: tell hggettext to collect help of template functions
Yuya Nishihara <yuya@tcha.org>
parents:
24586
diff
changeset
|
870 |
d80819f67d59
templater: tell hggettext to collect help of template functions
Yuya Nishihara <yuya@tcha.org>
parents:
24586
diff
changeset
|
871 # tell hggettext to extract docstrings from these functions: |
d80819f67d59
templater: tell hggettext to collect help of template functions
Yuya Nishihara <yuya@tcha.org>
parents:
24586
diff
changeset
|
872 i18nfunctions = funcs.values() |