Mercurial > hg
annotate mercurial/templateutil.py @ 41160:a9905045b992
tests: get access to thirdparty.cbor without requiring it to be installed
This makes the test a noop when run from a tarball, but in return we can stop
shipping a library we don't use.
Differential Revision: https://phab.mercurial-scm.org/D5523
author | Augie Fackler <augie@google.com> |
---|---|
date | Mon, 07 Jan 2019 18:41:53 -0500 |
parents | 4591c9791a82 |
children | 832c59d1196e |
rev | line source |
---|---|
36913
da2977e674a3
templater: extract template evaluation utility to new module
Yuya Nishihara <yuya@tcha.org>
parents:
36912
diff
changeset
|
1 # templateutil.py - utility for template evaluation |
1909
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 |
36913
da2977e674a3
templater: extract template evaluation utility to new module
Yuya Nishihara <yuya@tcha.org>
parents:
36912
diff
changeset
|
8 from __future__ import absolute_import |
25985
7eb357b5f774
templater: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
9 |
37273
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
10 import abc |
17982
e06e9fd2d99f
template engine: convert generator-based iterator to list-based iterator
Weiwen <weiwen@fb.com>
parents:
17890
diff
changeset
|
11 import types |
25985
7eb357b5f774
templater: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
12 |
7eb357b5f774
templater: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
13 from .i18n import _ |
7eb357b5f774
templater: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
14 from . import ( |
7eb357b5f774
templater: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
15 error, |
30615
bb77654dc7ae
py3: replace os.sep with pycompat.ossep (part 3 of 4)
Pulkit Goyal <7895pulkit@gmail.com>
parents:
30332
diff
changeset
|
16 pycompat, |
25985
7eb357b5f774
templater: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
17 util, |
7eb357b5f774
templater: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25815
diff
changeset
|
18 ) |
37084
f0b6fbea00cf
stringutil: bulk-replace call sites to point to new module
Yuya Nishihara <yuya@tcha.org>
parents:
37074
diff
changeset
|
19 from .utils import ( |
37224
67efce231633
templater: factor out function that parses argument as date tuple
Yuya Nishihara <yuya@tcha.org>
parents:
37222
diff
changeset
|
20 dateutil, |
37084
f0b6fbea00cf
stringutil: bulk-replace call sites to point to new module
Yuya Nishihara <yuya@tcha.org>
parents:
37074
diff
changeset
|
21 stringutil, |
f0b6fbea00cf
stringutil: bulk-replace call sites to point to new module
Yuya Nishihara <yuya@tcha.org>
parents:
37074
diff
changeset
|
22 ) |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
23 |
36444
717a279c0c21
templater: specialize ResourceUnavailable error so that it can be caught
Yuya Nishihara <yuya@tcha.org>
parents:
36443
diff
changeset
|
24 class ResourceUnavailable(error.Abort): |
717a279c0c21
templater: specialize ResourceUnavailable error so that it can be caught
Yuya Nishihara <yuya@tcha.org>
parents:
36443
diff
changeset
|
25 pass |
717a279c0c21
templater: specialize ResourceUnavailable error so that it can be caught
Yuya Nishihara <yuya@tcha.org>
parents:
36443
diff
changeset
|
26 |
36443
8dbd97aef915
templater: move specialized exception types to top
Yuya Nishihara <yuya@tcha.org>
parents:
36245
diff
changeset
|
27 class TemplateNotFound(error.Abort): |
8dbd97aef915
templater: move specialized exception types to top
Yuya Nishihara <yuya@tcha.org>
parents:
36245
diff
changeset
|
28 pass |
8dbd97aef915
templater: move specialized exception types to top
Yuya Nishihara <yuya@tcha.org>
parents:
36245
diff
changeset
|
29 |
37273
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
30 class wrapped(object): |
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
31 """Object requiring extra conversion prior to displaying or processing |
37279
26f6fc179e62
templater: define interface for objects requiring unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
37278
diff
changeset
|
32 as value |
26f6fc179e62
templater: define interface for objects requiring unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
37278
diff
changeset
|
33 |
38270
630c62804383
templater: inline unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
38269
diff
changeset
|
34 Use unwrapvalue() or unwrapastype() to obtain the inner object. |
37279
26f6fc179e62
templater: define interface for objects requiring unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
37278
diff
changeset
|
35 """ |
37273
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
36 |
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
37 __metaclass__ = abc.ABCMeta |
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
38 |
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
39 @abc.abstractmethod |
38267
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
40 def contains(self, context, mapping, item): |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
41 """Test if the specified item is in self |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
42 |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
43 The item argument may be a wrapped object. |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
44 """ |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
45 |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
46 @abc.abstractmethod |
38243
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
47 def getmember(self, context, mapping, key): |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
48 """Return a member item for the specified key |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
49 |
38244
688fbb758ba9
templater: resolve type of dict key in getmember()
Yuya Nishihara <yuya@tcha.org>
parents:
38243
diff
changeset
|
50 The key argument may be a wrapped object. |
38243
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
51 A returned object may be either a wrapped object or a pure value |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
52 depending on the self type. |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
53 """ |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
54 |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
55 @abc.abstractmethod |
38265
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
56 def getmin(self, context, mapping): |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
57 """Return the smallest item, which may be either a wrapped or a pure |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
58 value depending on the self type""" |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
59 |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
60 @abc.abstractmethod |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
61 def getmax(self, context, mapping): |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
62 """Return the largest item, which may be either a wrapped or a pure |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
63 value depending on the self type""" |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
64 |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
65 @abc.abstractmethod |
38448
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
66 def filter(self, context, mapping, select): |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
67 """Return new container of the same type which includes only the |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
68 selected elements |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
69 |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
70 select() takes each item as a wrapped object and returns True/False. |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
71 """ |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
72 |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
73 @abc.abstractmethod |
37324
c2f74b8f6b7f
templater: pass context to itermaps() for future extension
Yuya Nishihara <yuya@tcha.org>
parents:
37323
diff
changeset
|
74 def itermaps(self, context): |
37323
8c31b434697f
templater: define interface for objects which act as iterator of mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37279
diff
changeset
|
75 """Yield each template mapping""" |
8c31b434697f
templater: define interface for objects which act as iterator of mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37279
diff
changeset
|
76 |
8c31b434697f
templater: define interface for objects which act as iterator of mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37279
diff
changeset
|
77 @abc.abstractmethod |
37327
ebf139cbd4a1
templater: abstract away from joinfmt
Yuya Nishihara <yuya@tcha.org>
parents:
37326
diff
changeset
|
78 def join(self, context, mapping, sep): |
ebf139cbd4a1
templater: abstract away from joinfmt
Yuya Nishihara <yuya@tcha.org>
parents:
37326
diff
changeset
|
79 """Join items with the separator; Returns a bytes or (possibly nested) |
ebf139cbd4a1
templater: abstract away from joinfmt
Yuya Nishihara <yuya@tcha.org>
parents:
37326
diff
changeset
|
80 generator of bytes |
ebf139cbd4a1
templater: abstract away from joinfmt
Yuya Nishihara <yuya@tcha.org>
parents:
37326
diff
changeset
|
81 |
ebf139cbd4a1
templater: abstract away from joinfmt
Yuya Nishihara <yuya@tcha.org>
parents:
37326
diff
changeset
|
82 A pre-configured template may be rendered per item if this container |
ebf139cbd4a1
templater: abstract away from joinfmt
Yuya Nishihara <yuya@tcha.org>
parents:
37326
diff
changeset
|
83 holds unprintable items. |
ebf139cbd4a1
templater: abstract away from joinfmt
Yuya Nishihara <yuya@tcha.org>
parents:
37326
diff
changeset
|
84 """ |
ebf139cbd4a1
templater: abstract away from joinfmt
Yuya Nishihara <yuya@tcha.org>
parents:
37326
diff
changeset
|
85 |
ebf139cbd4a1
templater: abstract away from joinfmt
Yuya Nishihara <yuya@tcha.org>
parents:
37326
diff
changeset
|
86 @abc.abstractmethod |
37273
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
87 def show(self, context, mapping): |
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
88 """Return a bytes or (possibly nested) generator of bytes representing |
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
89 the underlying object |
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
90 |
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
91 A pre-configured template may be rendered if the underlying object is |
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
92 not printable. |
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
93 """ |
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
94 |
37279
26f6fc179e62
templater: define interface for objects requiring unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
37278
diff
changeset
|
95 @abc.abstractmethod |
38289
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
96 def tobool(self, context, mapping): |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
97 """Return a boolean representation of the inner value""" |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
98 |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
99 @abc.abstractmethod |
37279
26f6fc179e62
templater: define interface for objects requiring unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
37278
diff
changeset
|
100 def tovalue(self, context, mapping): |
26f6fc179e62
templater: define interface for objects requiring unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
37278
diff
changeset
|
101 """Move the inner value object out or create a value representation |
26f6fc179e62
templater: define interface for objects requiring unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
37278
diff
changeset
|
102 |
26f6fc179e62
templater: define interface for objects requiring unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
37278
diff
changeset
|
103 A returned value must be serializable by templaterfilters.json(). |
26f6fc179e62
templater: define interface for objects requiring unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
37278
diff
changeset
|
104 """ |
26f6fc179e62
templater: define interface for objects requiring unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
37278
diff
changeset
|
105 |
38284
e72697893c93
templater: promote tomap() to an interface type
Yuya Nishihara <yuya@tcha.org>
parents:
38283
diff
changeset
|
106 class mappable(object): |
e72697893c93
templater: promote tomap() to an interface type
Yuya Nishihara <yuya@tcha.org>
parents:
38283
diff
changeset
|
107 """Object which can be converted to a single template mapping""" |
e72697893c93
templater: promote tomap() to an interface type
Yuya Nishihara <yuya@tcha.org>
parents:
38283
diff
changeset
|
108 |
e72697893c93
templater: promote tomap() to an interface type
Yuya Nishihara <yuya@tcha.org>
parents:
38283
diff
changeset
|
109 def itermaps(self, context): |
e72697893c93
templater: promote tomap() to an interface type
Yuya Nishihara <yuya@tcha.org>
parents:
38283
diff
changeset
|
110 yield self.tomap(context) |
e72697893c93
templater: promote tomap() to an interface type
Yuya Nishihara <yuya@tcha.org>
parents:
38283
diff
changeset
|
111 |
e72697893c93
templater: promote tomap() to an interface type
Yuya Nishihara <yuya@tcha.org>
parents:
38283
diff
changeset
|
112 @abc.abstractmethod |
e72697893c93
templater: promote tomap() to an interface type
Yuya Nishihara <yuya@tcha.org>
parents:
38283
diff
changeset
|
113 def tomap(self, context): |
e72697893c93
templater: promote tomap() to an interface type
Yuya Nishihara <yuya@tcha.org>
parents:
38283
diff
changeset
|
114 """Create a single template mapping representing this""" |
e72697893c93
templater: promote tomap() to an interface type
Yuya Nishihara <yuya@tcha.org>
parents:
38283
diff
changeset
|
115 |
38226
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
116 class wrappedbytes(wrapped): |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
117 """Wrapper for byte string""" |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
118 |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
119 def __init__(self, value): |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
120 self._value = value |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
121 |
38267
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
122 def contains(self, context, mapping, item): |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
123 item = stringify(context, mapping, item) |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
124 return item in self._value |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
125 |
38243
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
126 def getmember(self, context, mapping, key): |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
127 raise error.ParseError(_('%r is not a dictionary') |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
128 % pycompat.bytestr(self._value)) |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
129 |
38265
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
130 def getmin(self, context, mapping): |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
131 return self._getby(context, mapping, min) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
132 |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
133 def getmax(self, context, mapping): |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
134 return self._getby(context, mapping, max) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
135 |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
136 def _getby(self, context, mapping, func): |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
137 if not self._value: |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
138 raise error.ParseError(_('empty string')) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
139 return func(pycompat.iterbytestr(self._value)) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
140 |
38448
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
141 def filter(self, context, mapping, select): |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
142 raise error.ParseError(_('%r is not filterable') |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
143 % pycompat.bytestr(self._value)) |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
144 |
38226
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
145 def itermaps(self, context): |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
146 raise error.ParseError(_('%r is not iterable of mappings') |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
147 % pycompat.bytestr(self._value)) |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
148 |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
149 def join(self, context, mapping, sep): |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
150 return joinitems(pycompat.iterbytestr(self._value), sep) |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
151 |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
152 def show(self, context, mapping): |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
153 return self._value |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
154 |
38289
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
155 def tobool(self, context, mapping): |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
156 return bool(self._value) |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
157 |
38226
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
158 def tovalue(self, context, mapping): |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
159 return self._value |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
160 |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
161 class wrappedvalue(wrapped): |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
162 """Generic wrapper for pure non-list/dict/bytes value""" |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
163 |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
164 def __init__(self, value): |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
165 self._value = value |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
166 |
38267
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
167 def contains(self, context, mapping, item): |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
168 raise error.ParseError(_("%r is not iterable") % self._value) |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
169 |
38243
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
170 def getmember(self, context, mapping, key): |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
171 raise error.ParseError(_('%r is not a dictionary') % self._value) |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
172 |
38265
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
173 def getmin(self, context, mapping): |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
174 raise error.ParseError(_("%r is not iterable") % self._value) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
175 |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
176 def getmax(self, context, mapping): |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
177 raise error.ParseError(_("%r is not iterable") % self._value) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
178 |
38448
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
179 def filter(self, context, mapping, select): |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
180 raise error.ParseError(_("%r is not iterable") % self._value) |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
181 |
38226
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
182 def itermaps(self, context): |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
183 raise error.ParseError(_('%r is not iterable of mappings') |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
184 % self._value) |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
185 |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
186 def join(self, context, mapping, sep): |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
187 raise error.ParseError(_('%r is not iterable') % self._value) |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
188 |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
189 def show(self, context, mapping): |
38272
354fad8697fd
templater: fix string representation of wrapped None
Yuya Nishihara <yuya@tcha.org>
parents:
38271
diff
changeset
|
190 if self._value is None: |
354fad8697fd
templater: fix string representation of wrapped None
Yuya Nishihara <yuya@tcha.org>
parents:
38271
diff
changeset
|
191 return b'' |
38226
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
192 return pycompat.bytestr(self._value) |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
193 |
38289
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
194 def tobool(self, context, mapping): |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
195 if self._value is None: |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
196 return False |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
197 if isinstance(self._value, bool): |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
198 return self._value |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
199 # otherwise evaluate as string, which means 0 is True |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
200 return bool(pycompat.bytestr(self._value)) |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
201 |
38226
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
202 def tovalue(self, context, mapping): |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
203 return self._value |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
204 |
38286
851fc9d42d6d
templater: make date wrapper support dot/map operations
Yuya Nishihara <yuya@tcha.org>
parents:
38285
diff
changeset
|
205 class date(mappable, wrapped): |
38285
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
206 """Wrapper for date tuple""" |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
207 |
38299
88e7105b5cd9
templater: restore the original string format of {date}
Yuya Nishihara <yuya@tcha.org>
parents:
38289
diff
changeset
|
208 def __init__(self, value, showfmt='%d %d'): |
38285
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
209 # value may be (float, int), but public interface shouldn't support |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
210 # floating-point timestamp |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
211 self._unixtime, self._tzoffset = map(int, value) |
38299
88e7105b5cd9
templater: restore the original string format of {date}
Yuya Nishihara <yuya@tcha.org>
parents:
38289
diff
changeset
|
212 self._showfmt = showfmt |
38285
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
213 |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
214 def contains(self, context, mapping, item): |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
215 raise error.ParseError(_('date is not iterable')) |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
216 |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
217 def getmember(self, context, mapping, key): |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
218 raise error.ParseError(_('date is not a dictionary')) |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
219 |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
220 def getmin(self, context, mapping): |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
221 raise error.ParseError(_('date is not iterable')) |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
222 |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
223 def getmax(self, context, mapping): |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
224 raise error.ParseError(_('date is not iterable')) |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
225 |
38448
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
226 def filter(self, context, mapping, select): |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
227 raise error.ParseError(_('date is not iterable')) |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
228 |
38285
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
229 def join(self, context, mapping, sep): |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
230 raise error.ParseError(_("date is not iterable")) |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
231 |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
232 def show(self, context, mapping): |
38299
88e7105b5cd9
templater: restore the original string format of {date}
Yuya Nishihara <yuya@tcha.org>
parents:
38289
diff
changeset
|
233 return self._showfmt % (self._unixtime, self._tzoffset) |
38285
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
234 |
38286
851fc9d42d6d
templater: make date wrapper support dot/map operations
Yuya Nishihara <yuya@tcha.org>
parents:
38285
diff
changeset
|
235 def tomap(self, context): |
851fc9d42d6d
templater: make date wrapper support dot/map operations
Yuya Nishihara <yuya@tcha.org>
parents:
38285
diff
changeset
|
236 return {'unixtime': self._unixtime, 'tzoffset': self._tzoffset} |
851fc9d42d6d
templater: make date wrapper support dot/map operations
Yuya Nishihara <yuya@tcha.org>
parents:
38285
diff
changeset
|
237 |
38289
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
238 def tobool(self, context, mapping): |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
239 return True |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
240 |
38285
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
241 def tovalue(self, context, mapping): |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
242 return (self._unixtime, self._tzoffset) |
37227
9bcf096a2da2
templatefilters: declare input type as date where appropriate
Yuya Nishihara <yuya@tcha.org>
parents:
37226
diff
changeset
|
243 |
37273
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
244 class hybrid(wrapped): |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
245 """Wrapper for list or dict to support legacy template |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
246 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
247 This class allows us to handle both: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
248 - "{files}" (legacy command-line-specific list hack) and |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
249 - "{files % '{file}\n'}" (hgweb-style with inlining and function support) |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
250 and to access raw values: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
251 - "{ifcontains(file, files, ...)}", "{ifcontains(key, extras, ...)}" |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
252 - "{get(extras, key)}" |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
253 - "{files|json}" |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
254 """ |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
255 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
256 def __init__(self, gen, values, makemap, joinfmt, keytype=None): |
37325
41a5d815d2c1
templater: factor out generator of join()-ed items
Yuya Nishihara <yuya@tcha.org>
parents:
37324
diff
changeset
|
257 self._gen = gen # generator or function returning generator |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
258 self._values = values |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
259 self._makemap = makemap |
37329
676664592313
templater: mark .joinfmt as a private attribute
Yuya Nishihara <yuya@tcha.org>
parents:
37327
diff
changeset
|
260 self._joinfmt = joinfmt |
38268
49ef1539b84e
templater: mark .keytype as a private attribute
Yuya Nishihara <yuya@tcha.org>
parents:
38267
diff
changeset
|
261 self._keytype = keytype # hint for 'x in y' where type(x) is unresolved |
37275
8c84dc8264dc
templater: mark .gen as a private attribute
Yuya Nishihara <yuya@tcha.org>
parents:
37273
diff
changeset
|
262 |
38267
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
263 def contains(self, context, mapping, item): |
38268
49ef1539b84e
templater: mark .keytype as a private attribute
Yuya Nishihara <yuya@tcha.org>
parents:
38267
diff
changeset
|
264 item = unwrapastype(context, mapping, item, self._keytype) |
38267
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
265 return item in self._values |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
266 |
38242
12b6ee9e88f3
templater: move getdictitem() to hybrid class
Yuya Nishihara <yuya@tcha.org>
parents:
38241
diff
changeset
|
267 def getmember(self, context, mapping, key): |
12b6ee9e88f3
templater: move getdictitem() to hybrid class
Yuya Nishihara <yuya@tcha.org>
parents:
38241
diff
changeset
|
268 # TODO: maybe split hybrid list/dict types? |
12b6ee9e88f3
templater: move getdictitem() to hybrid class
Yuya Nishihara <yuya@tcha.org>
parents:
38241
diff
changeset
|
269 if not util.safehasattr(self._values, 'get'): |
12b6ee9e88f3
templater: move getdictitem() to hybrid class
Yuya Nishihara <yuya@tcha.org>
parents:
38241
diff
changeset
|
270 raise error.ParseError(_('not a dictionary')) |
38268
49ef1539b84e
templater: mark .keytype as a private attribute
Yuya Nishihara <yuya@tcha.org>
parents:
38267
diff
changeset
|
271 key = unwrapastype(context, mapping, key, self._keytype) |
38242
12b6ee9e88f3
templater: move getdictitem() to hybrid class
Yuya Nishihara <yuya@tcha.org>
parents:
38241
diff
changeset
|
272 return self._wrapvalue(key, self._values.get(key)) |
12b6ee9e88f3
templater: move getdictitem() to hybrid class
Yuya Nishihara <yuya@tcha.org>
parents:
38241
diff
changeset
|
273 |
38265
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
274 def getmin(self, context, mapping): |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
275 return self._getby(context, mapping, min) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
276 |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
277 def getmax(self, context, mapping): |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
278 return self._getby(context, mapping, max) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
279 |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
280 def _getby(self, context, mapping, func): |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
281 if not self._values: |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
282 raise error.ParseError(_('empty sequence')) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
283 val = func(self._values) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
284 return self._wrapvalue(val, val) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
285 |
38242
12b6ee9e88f3
templater: move getdictitem() to hybrid class
Yuya Nishihara <yuya@tcha.org>
parents:
38241
diff
changeset
|
286 def _wrapvalue(self, key, val): |
12b6ee9e88f3
templater: move getdictitem() to hybrid class
Yuya Nishihara <yuya@tcha.org>
parents:
38241
diff
changeset
|
287 if val is None: |
12b6ee9e88f3
templater: move getdictitem() to hybrid class
Yuya Nishihara <yuya@tcha.org>
parents:
38241
diff
changeset
|
288 return |
38266
80f423a14c90
templater: inline wraphybridvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
38265
diff
changeset
|
289 if util.safehasattr(val, '_makemap'): |
80f423a14c90
templater: inline wraphybridvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
38265
diff
changeset
|
290 # a nested hybrid list/dict, which has its own way of map operation |
80f423a14c90
templater: inline wraphybridvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
38265
diff
changeset
|
291 return val |
38283
0e0d03d09ecd
templater: rename mappable to hybriditem as it is the primary use case
Yuya Nishihara <yuya@tcha.org>
parents:
38272
diff
changeset
|
292 return hybriditem(None, key, val, self._makemap) |
38242
12b6ee9e88f3
templater: move getdictitem() to hybrid class
Yuya Nishihara <yuya@tcha.org>
parents:
38241
diff
changeset
|
293 |
38448
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
294 def filter(self, context, mapping, select): |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
295 if util.safehasattr(self._values, 'get'): |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
296 values = {k: v for k, v in self._values.iteritems() |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
297 if select(self._wrapvalue(k, v))} |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
298 else: |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
299 values = [v for v in self._values if select(self._wrapvalue(v, v))] |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
300 return hybrid(None, values, self._makemap, self._joinfmt, self._keytype) |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
301 |
37324
c2f74b8f6b7f
templater: pass context to itermaps() for future extension
Yuya Nishihara <yuya@tcha.org>
parents:
37323
diff
changeset
|
302 def itermaps(self, context): |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
303 makemap = self._makemap |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
304 for x in self._values: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
305 yield makemap(x) |
37273
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
306 |
37327
ebf139cbd4a1
templater: abstract away from joinfmt
Yuya Nishihara <yuya@tcha.org>
parents:
37326
diff
changeset
|
307 def join(self, context, mapping, sep): |
ebf139cbd4a1
templater: abstract away from joinfmt
Yuya Nishihara <yuya@tcha.org>
parents:
37326
diff
changeset
|
308 # TODO: switch gen to (context, mapping) API? |
37329
676664592313
templater: mark .joinfmt as a private attribute
Yuya Nishihara <yuya@tcha.org>
parents:
37327
diff
changeset
|
309 return joinitems((self._joinfmt(x) for x in self._values), sep) |
37327
ebf139cbd4a1
templater: abstract away from joinfmt
Yuya Nishihara <yuya@tcha.org>
parents:
37326
diff
changeset
|
310 |
37273
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
311 def show(self, context, mapping): |
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
312 # TODO: switch gen to (context, mapping) API? |
37275
8c84dc8264dc
templater: mark .gen as a private attribute
Yuya Nishihara <yuya@tcha.org>
parents:
37273
diff
changeset
|
313 gen = self._gen |
37325
41a5d815d2c1
templater: factor out generator of join()-ed items
Yuya Nishihara <yuya@tcha.org>
parents:
37324
diff
changeset
|
314 if gen is None: |
37327
ebf139cbd4a1
templater: abstract away from joinfmt
Yuya Nishihara <yuya@tcha.org>
parents:
37326
diff
changeset
|
315 return self.join(context, mapping, ' ') |
37273
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
316 if callable(gen): |
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
317 return gen() |
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
318 return gen |
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
319 |
38289
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
320 def tobool(self, context, mapping): |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
321 return bool(self._values) |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
322 |
37279
26f6fc179e62
templater: define interface for objects requiring unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
37278
diff
changeset
|
323 def tovalue(self, context, mapping): |
38269
cf8d210dfac4
templater: drop hybrid-ness on unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
38268
diff
changeset
|
324 # TODO: make it non-recursive for trivial lists/dicts |
cf8d210dfac4
templater: drop hybrid-ness on unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
38268
diff
changeset
|
325 xs = self._values |
cf8d210dfac4
templater: drop hybrid-ness on unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
38268
diff
changeset
|
326 if util.safehasattr(xs, 'get'): |
cf8d210dfac4
templater: drop hybrid-ness on unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
38268
diff
changeset
|
327 return {k: unwrapvalue(context, mapping, v) |
cf8d210dfac4
templater: drop hybrid-ness on unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
38268
diff
changeset
|
328 for k, v in xs.iteritems()} |
cf8d210dfac4
templater: drop hybrid-ness on unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
38268
diff
changeset
|
329 return [unwrapvalue(context, mapping, x) for x in xs] |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
330 |
38284
e72697893c93
templater: promote tomap() to an interface type
Yuya Nishihara <yuya@tcha.org>
parents:
38283
diff
changeset
|
331 class hybriditem(mappable, wrapped): |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
332 """Wrapper for non-list/dict object to support map operation |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
333 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
334 This class allows us to handle both: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
335 - "{manifest}" |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
336 - "{manifest % '{rev}:{node}'}" |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
337 - "{manifest.rev}" |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
338 """ |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
339 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
340 def __init__(self, gen, key, value, makemap): |
37276
b4630e332a99
templater: drop unneeded generator from mappable object
Yuya Nishihara <yuya@tcha.org>
parents:
37275
diff
changeset
|
341 self._gen = gen # generator or function returning generator |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
342 self._key = key |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
343 self._value = value # may be generator of strings |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
344 self._makemap = makemap |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
345 |
38284
e72697893c93
templater: promote tomap() to an interface type
Yuya Nishihara <yuya@tcha.org>
parents:
38283
diff
changeset
|
346 def tomap(self, context): |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
347 return self._makemap(self._key) |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
348 |
38267
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
349 def contains(self, context, mapping, item): |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
350 w = makewrapped(context, mapping, self._value) |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
351 return w.contains(context, mapping, item) |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
352 |
38243
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
353 def getmember(self, context, mapping, key): |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
354 w = makewrapped(context, mapping, self._value) |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
355 return w.getmember(context, mapping, key) |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
356 |
38265
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
357 def getmin(self, context, mapping): |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
358 w = makewrapped(context, mapping, self._value) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
359 return w.getmin(context, mapping) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
360 |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
361 def getmax(self, context, mapping): |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
362 w = makewrapped(context, mapping, self._value) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
363 return w.getmax(context, mapping) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
364 |
38448
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
365 def filter(self, context, mapping, select): |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
366 w = makewrapped(context, mapping, self._value) |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
367 return w.filter(context, mapping, select) |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
368 |
37327
ebf139cbd4a1
templater: abstract away from joinfmt
Yuya Nishihara <yuya@tcha.org>
parents:
37326
diff
changeset
|
369 def join(self, context, mapping, sep): |
38228
8bded7eae26c
templater: consistently join() string-like object per character (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38226
diff
changeset
|
370 w = makewrapped(context, mapping, self._value) |
8bded7eae26c
templater: consistently join() string-like object per character (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38226
diff
changeset
|
371 return w.join(context, mapping, sep) |
37327
ebf139cbd4a1
templater: abstract away from joinfmt
Yuya Nishihara <yuya@tcha.org>
parents:
37326
diff
changeset
|
372 |
37273
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
373 def show(self, context, mapping): |
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
374 # TODO: switch gen to (context, mapping) API? |
37275
8c84dc8264dc
templater: mark .gen as a private attribute
Yuya Nishihara <yuya@tcha.org>
parents:
37273
diff
changeset
|
375 gen = self._gen |
37276
b4630e332a99
templater: drop unneeded generator from mappable object
Yuya Nishihara <yuya@tcha.org>
parents:
37275
diff
changeset
|
376 if gen is None: |
b4630e332a99
templater: drop unneeded generator from mappable object
Yuya Nishihara <yuya@tcha.org>
parents:
37275
diff
changeset
|
377 return pycompat.bytestr(self._value) |
37273
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
378 if callable(gen): |
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
379 return gen() |
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
380 return gen |
83e1bbd48991
templater: define interface for objects requiring unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37272
diff
changeset
|
381 |
38289
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
382 def tobool(self, context, mapping): |
38447
b6294c113794
templater: fix truth testing of integer 0 taken from a list/dict
Yuya Nishihara <yuya@tcha.org>
parents:
38299
diff
changeset
|
383 w = makewrapped(context, mapping, self._value) |
b6294c113794
templater: fix truth testing of integer 0 taken from a list/dict
Yuya Nishihara <yuya@tcha.org>
parents:
38299
diff
changeset
|
384 return w.tobool(context, mapping) |
38289
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
385 |
37279
26f6fc179e62
templater: define interface for objects requiring unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
37278
diff
changeset
|
386 def tovalue(self, context, mapping): |
26f6fc179e62
templater: define interface for objects requiring unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
37278
diff
changeset
|
387 return _unthunk(context, mapping, self._value) |
26f6fc179e62
templater: define interface for objects requiring unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
37278
diff
changeset
|
388 |
37399
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
389 class _mappingsequence(wrapped): |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
390 """Wrapper for sequence of template mappings |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
391 |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
392 This represents an inner template structure (i.e. a list of dicts), |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
393 which can also be rendered by the specified named/literal template. |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
394 |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
395 Template mappings may be nested. |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
396 """ |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
397 |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
398 def __init__(self, name=None, tmpl=None, sep=''): |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
399 if name is not None and tmpl is not None: |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
400 raise error.ProgrammingError('name and tmpl are mutually exclusive') |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
401 self._name = name |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
402 self._tmpl = tmpl |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
403 self._defaultsep = sep |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
404 |
38267
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
405 def contains(self, context, mapping, item): |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
406 raise error.ParseError(_('not comparable')) |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
407 |
38243
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
408 def getmember(self, context, mapping, key): |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
409 raise error.ParseError(_('not a dictionary')) |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
410 |
38265
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
411 def getmin(self, context, mapping): |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
412 raise error.ParseError(_('not comparable')) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
413 |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
414 def getmax(self, context, mapping): |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
415 raise error.ParseError(_('not comparable')) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
416 |
38448
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
417 def filter(self, context, mapping, select): |
38449
bc8d925342f0
templater: extend filter() to accept template expression for emptiness test
Yuya Nishihara <yuya@tcha.org>
parents:
38448
diff
changeset
|
418 # implement if necessary; we'll need a wrapped type for a mapping dict |
38448
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
419 raise error.ParseError(_('not filterable without template')) |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
420 |
37399
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
421 def join(self, context, mapping, sep): |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
422 mapsiter = _iteroverlaymaps(context, mapping, self.itermaps(context)) |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
423 if self._name: |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
424 itemiter = (context.process(self._name, m) for m in mapsiter) |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
425 elif self._tmpl: |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
426 itemiter = (context.expand(self._tmpl, m) for m in mapsiter) |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
427 else: |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
428 raise error.ParseError(_('not displayable without template')) |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
429 return joinitems(itemiter, sep) |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
430 |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
431 def show(self, context, mapping): |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
432 return self.join(context, mapping, self._defaultsep) |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
433 |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
434 def tovalue(self, context, mapping): |
37502
40c7347f6848
formatter: remove template resources from nested items before generating JSON
Yuya Nishihara <yuya@tcha.org>
parents:
37499
diff
changeset
|
435 knownres = context.knownresourcekeys() |
40c7347f6848
formatter: remove template resources from nested items before generating JSON
Yuya Nishihara <yuya@tcha.org>
parents:
37499
diff
changeset
|
436 items = [] |
40c7347f6848
formatter: remove template resources from nested items before generating JSON
Yuya Nishihara <yuya@tcha.org>
parents:
37499
diff
changeset
|
437 for nm in self.itermaps(context): |
40c7347f6848
formatter: remove template resources from nested items before generating JSON
Yuya Nishihara <yuya@tcha.org>
parents:
37499
diff
changeset
|
438 # drop internal resources (recursively) which shouldn't be displayed |
40c7347f6848
formatter: remove template resources from nested items before generating JSON
Yuya Nishihara <yuya@tcha.org>
parents:
37499
diff
changeset
|
439 lm = context.overlaymap(mapping, nm) |
40c7347f6848
formatter: remove template resources from nested items before generating JSON
Yuya Nishihara <yuya@tcha.org>
parents:
37499
diff
changeset
|
440 items.append({k: unwrapvalue(context, lm, v) |
40c7347f6848
formatter: remove template resources from nested items before generating JSON
Yuya Nishihara <yuya@tcha.org>
parents:
37499
diff
changeset
|
441 for k, v in nm.iteritems() if k not in knownres}) |
40c7347f6848
formatter: remove template resources from nested items before generating JSON
Yuya Nishihara <yuya@tcha.org>
parents:
37499
diff
changeset
|
442 return items |
37399
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
443 |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
444 class mappinggenerator(_mappingsequence): |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
445 """Wrapper for generator of template mappings |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
446 |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
447 The function ``make(context, *args)`` should return a generator of |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
448 mapping dicts. |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
449 """ |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
450 |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
451 def __init__(self, make, args=(), name=None, tmpl=None, sep=''): |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
452 super(mappinggenerator, self).__init__(name, tmpl, sep) |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
453 self._make = make |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
454 self._args = args |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
455 |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
456 def itermaps(self, context): |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
457 return self._make(context, *self._args) |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
458 |
38289
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
459 def tobool(self, context, mapping): |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
460 return _nonempty(self.itermaps(context)) |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
461 |
37399
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
462 class mappinglist(_mappingsequence): |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
463 """Wrapper for list of template mappings""" |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
464 |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
465 def __init__(self, mappings, name=None, tmpl=None, sep=''): |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
466 super(mappinglist, self).__init__(name, tmpl, sep) |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
467 self._mappings = mappings |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
468 |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
469 def itermaps(self, context): |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
470 return iter(self._mappings) |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
471 |
38289
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
472 def tobool(self, context, mapping): |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
473 return bool(self._mappings) |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
474 |
40475
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
475 class mappingdict(mappable, _mappingsequence): |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
476 """Wrapper for a single template mapping |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
477 |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
478 This isn't a sequence in a way that the underlying dict won't be iterated |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
479 as a dict, but shares most of the _mappingsequence functions. |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
480 """ |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
481 |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
482 def __init__(self, mapping, name=None, tmpl=None): |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
483 super(mappingdict, self).__init__(name, tmpl) |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
484 self._mapping = mapping |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
485 |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
486 def tomap(self, context): |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
487 return self._mapping |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
488 |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
489 def tobool(self, context, mapping): |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
490 # no idea when a template mapping should be considered an empty, but |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
491 # a mapping dict should have at least one item in practice, so always |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
492 # mark this as non-empty. |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
493 return True |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
494 |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
495 def tovalue(self, context, mapping): |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
496 return super(mappingdict, self).tovalue(context, mapping)[0] |
8fa26f3baf30
templater: add wrapper for a single template mapping
Yuya Nishihara <yuya@tcha.org>
parents:
39582
diff
changeset
|
497 |
40935
4591c9791a82
templatefuncs: specialize "no match" value of search() to allow % operation
Yuya Nishihara <yuya@tcha.org>
parents:
40475
diff
changeset
|
498 class mappingnone(wrappedvalue): |
4591c9791a82
templatefuncs: specialize "no match" value of search() to allow % operation
Yuya Nishihara <yuya@tcha.org>
parents:
40475
diff
changeset
|
499 """Wrapper for None, but supports map operation |
4591c9791a82
templatefuncs: specialize "no match" value of search() to allow % operation
Yuya Nishihara <yuya@tcha.org>
parents:
40475
diff
changeset
|
500 |
4591c9791a82
templatefuncs: specialize "no match" value of search() to allow % operation
Yuya Nishihara <yuya@tcha.org>
parents:
40475
diff
changeset
|
501 This represents None of Optional[mappable]. It's similar to |
4591c9791a82
templatefuncs: specialize "no match" value of search() to allow % operation
Yuya Nishihara <yuya@tcha.org>
parents:
40475
diff
changeset
|
502 mapplinglist([]), but the underlying value is not [], but None. |
4591c9791a82
templatefuncs: specialize "no match" value of search() to allow % operation
Yuya Nishihara <yuya@tcha.org>
parents:
40475
diff
changeset
|
503 """ |
4591c9791a82
templatefuncs: specialize "no match" value of search() to allow % operation
Yuya Nishihara <yuya@tcha.org>
parents:
40475
diff
changeset
|
504 |
4591c9791a82
templatefuncs: specialize "no match" value of search() to allow % operation
Yuya Nishihara <yuya@tcha.org>
parents:
40475
diff
changeset
|
505 def __init__(self): |
4591c9791a82
templatefuncs: specialize "no match" value of search() to allow % operation
Yuya Nishihara <yuya@tcha.org>
parents:
40475
diff
changeset
|
506 super(mappingnone, self).__init__(None) |
4591c9791a82
templatefuncs: specialize "no match" value of search() to allow % operation
Yuya Nishihara <yuya@tcha.org>
parents:
40475
diff
changeset
|
507 |
4591c9791a82
templatefuncs: specialize "no match" value of search() to allow % operation
Yuya Nishihara <yuya@tcha.org>
parents:
40475
diff
changeset
|
508 def itermaps(self, context): |
4591c9791a82
templatefuncs: specialize "no match" value of search() to allow % operation
Yuya Nishihara <yuya@tcha.org>
parents:
40475
diff
changeset
|
509 return iter([]) |
4591c9791a82
templatefuncs: specialize "no match" value of search() to allow % operation
Yuya Nishihara <yuya@tcha.org>
parents:
40475
diff
changeset
|
510 |
37499
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
511 class mappedgenerator(wrapped): |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
512 """Wrapper for generator of strings which acts as a list |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
513 |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
514 The function ``make(context, *args)`` should return a generator of |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
515 byte strings, or a generator of (possibly nested) generators of byte |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
516 strings (i.e. a generator for a list of byte strings.) |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
517 """ |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
518 |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
519 def __init__(self, make, args=()): |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
520 self._make = make |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
521 self._args = args |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
522 |
38267
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
523 def contains(self, context, mapping, item): |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
524 item = stringify(context, mapping, item) |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
525 return item in self.tovalue(context, mapping) |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
526 |
37499
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
527 def _gen(self, context): |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
528 return self._make(context, *self._args) |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
529 |
38243
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
530 def getmember(self, context, mapping, key): |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
531 raise error.ParseError(_('not a dictionary')) |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
532 |
38265
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
533 def getmin(self, context, mapping): |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
534 return self._getby(context, mapping, min) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
535 |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
536 def getmax(self, context, mapping): |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
537 return self._getby(context, mapping, max) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
538 |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
539 def _getby(self, context, mapping, func): |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
540 xs = self.tovalue(context, mapping) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
541 if not xs: |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
542 raise error.ParseError(_('empty sequence')) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
543 return func(xs) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
544 |
38448
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
545 @staticmethod |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
546 def _filteredgen(context, mapping, make, args, select): |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
547 for x in make(context, *args): |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
548 s = stringify(context, mapping, x) |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
549 if select(wrappedbytes(s)): |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
550 yield s |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
551 |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
552 def filter(self, context, mapping, select): |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
553 args = (mapping, self._make, self._args, select) |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
554 return mappedgenerator(self._filteredgen, args) |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
555 |
37499
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
556 def itermaps(self, context): |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
557 raise error.ParseError(_('list of strings is not mappable')) |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
558 |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
559 def join(self, context, mapping, sep): |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
560 return joinitems(self._gen(context), sep) |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
561 |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
562 def show(self, context, mapping): |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
563 return self.join(context, mapping, '') |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
564 |
38289
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
565 def tobool(self, context, mapping): |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
566 return _nonempty(self._gen(context)) |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
567 |
37499
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
568 def tovalue(self, context, mapping): |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
569 return [stringify(context, mapping, x) for x in self._gen(context)] |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
570 |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
571 def hybriddict(data, key='key', value='value', fmt=None, gen=None): |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
572 """Wrap data to support both dict-like and string-like operations""" |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
573 prefmt = pycompat.identity |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
574 if fmt is None: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
575 fmt = '%s=%s' |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
576 prefmt = pycompat.bytestr |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
577 return hybrid(gen, data, lambda k: {key: k, value: data[k]}, |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
578 lambda k: fmt % (prefmt(k), prefmt(data[k]))) |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
579 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
580 def hybridlist(data, name, fmt=None, gen=None): |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
581 """Wrap data to support both list-like and string-like operations""" |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
582 prefmt = pycompat.identity |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
583 if fmt is None: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
584 fmt = '%s' |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
585 prefmt = pycompat.bytestr |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
586 return hybrid(gen, data, lambda x: {name: x}, lambda x: fmt % prefmt(x)) |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
587 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
588 def compatdict(context, mapping, name, data, key='key', value='value', |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
589 fmt=None, plural=None, separator=' '): |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
590 """Wrap data like hybriddict(), but also supports old-style list template |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
591 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
592 This exists for backward compatibility with the old-style template. Use |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
593 hybriddict() for new template keywords. |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
594 """ |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
595 c = [{key: k, value: v} for k, v in data.iteritems()] |
37068
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
596 f = _showcompatlist(context, mapping, name, c, plural, separator) |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
597 return hybriddict(data, key=key, value=value, fmt=fmt, gen=f) |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
598 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
599 def compatlist(context, mapping, name, data, element=None, fmt=None, |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
600 plural=None, separator=' '): |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
601 """Wrap data like hybridlist(), but also supports old-style list template |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
602 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
603 This exists for backward compatibility with the old-style template. Use |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
604 hybridlist() for new template keywords. |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
605 """ |
37068
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
606 f = _showcompatlist(context, mapping, name, data, plural, separator) |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
607 return hybridlist(data, name=element or name, fmt=fmt, gen=f) |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
608 |
39368
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
609 def compatfilecopiesdict(context, mapping, name, copies): |
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
610 """Wrap list of (dest, source) file names to support old-style list |
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
611 template and field names |
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
612 |
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
613 This exists for backward compatibility. Use hybriddict for new template |
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
614 keywords. |
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
615 """ |
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
616 # no need to provide {path} to old-style list template |
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
617 c = [{'name': k, 'source': v} for k, v in copies] |
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
618 f = _showcompatlist(context, mapping, name, c, plural='file_copies') |
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
619 copies = util.sortdict(copies) |
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
620 return hybrid(f, copies, |
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
621 lambda k: {'name': k, 'path': k, 'source': copies[k]}, |
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
622 lambda k: '%s (%s)' % (k, copies[k])) |
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
623 |
39367
83f8f7b9fa60
templatekw: alias {file} of files list to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
38930
diff
changeset
|
624 def compatfileslist(context, mapping, name, files): |
83f8f7b9fa60
templatekw: alias {file} of files list to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
38930
diff
changeset
|
625 """Wrap list of file names to support old-style list template and field |
83f8f7b9fa60
templatekw: alias {file} of files list to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
38930
diff
changeset
|
626 names |
83f8f7b9fa60
templatekw: alias {file} of files list to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
38930
diff
changeset
|
627 |
83f8f7b9fa60
templatekw: alias {file} of files list to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
38930
diff
changeset
|
628 This exists for backward compatibility. Use hybridlist for new template |
83f8f7b9fa60
templatekw: alias {file} of files list to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
38930
diff
changeset
|
629 keywords. |
83f8f7b9fa60
templatekw: alias {file} of files list to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
38930
diff
changeset
|
630 """ |
83f8f7b9fa60
templatekw: alias {file} of files list to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
38930
diff
changeset
|
631 f = _showcompatlist(context, mapping, name, files) |
83f8f7b9fa60
templatekw: alias {file} of files list to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
38930
diff
changeset
|
632 return hybrid(f, files, lambda x: {'file': x, 'path': x}, |
83f8f7b9fa60
templatekw: alias {file} of files list to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
38930
diff
changeset
|
633 pycompat.identity) |
83f8f7b9fa60
templatekw: alias {file} of files list to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
38930
diff
changeset
|
634 |
37068
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
635 def _showcompatlist(context, mapping, name, values, plural=None, separator=' '): |
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
636 """Return a generator that renders old-style list template |
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
637 |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
638 name is name of key in template map. |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
639 values is list of strings or dicts. |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
640 plural is plural of name, if not simply name + 's'. |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
641 separator is used to join values as a string |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
642 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
643 expansion works like this, given name 'foo'. |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
644 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
645 if values is empty, expand 'no_foos'. |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
646 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
647 if 'foo' not in template map, return values as a string, |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
648 joined by 'separator'. |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
649 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
650 expand 'start_foos'. |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
651 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
652 for each value, expand 'foo'. if 'last_foo' in template |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
653 map, expand it instead of 'foo' for last key. |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
654 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
655 expand 'end_foos'. |
37068
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
656 """ |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
657 if not plural: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
658 plural = name + 's' |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
659 if not values: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
660 noname = 'no_' + plural |
37068
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
661 if context.preload(noname): |
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
662 yield context.process(noname, mapping) |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
663 return |
37068
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
664 if not context.preload(name): |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
665 if isinstance(values[0], bytes): |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
666 yield separator.join(values) |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
667 else: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
668 for v in values: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
669 r = dict(v) |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
670 r.update(mapping) |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
671 yield r |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
672 return |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
673 startname = 'start_' + plural |
37068
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
674 if context.preload(startname): |
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
675 yield context.process(startname, mapping) |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
676 def one(v, tag=name): |
37074
2891079fb0c0
templater: factor out function to create mapping dict for nested evaluation
Yuya Nishihara <yuya@tcha.org>
parents:
37073
diff
changeset
|
677 vmapping = {} |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
678 try: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
679 vmapping.update(v) |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
680 # Python 2 raises ValueError if the type of v is wrong. Python |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
681 # 3 raises TypeError. |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
682 except (AttributeError, TypeError, ValueError): |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
683 try: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
684 # Python 2 raises ValueError trying to destructure an e.g. |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
685 # bytes. Python 3 raises TypeError. |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
686 for a, b in v: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
687 vmapping[a] = b |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
688 except (TypeError, ValueError): |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
689 vmapping[name] = v |
37074
2891079fb0c0
templater: factor out function to create mapping dict for nested evaluation
Yuya Nishihara <yuya@tcha.org>
parents:
37073
diff
changeset
|
690 vmapping = context.overlaymap(mapping, vmapping) |
37068
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
691 return context.process(tag, vmapping) |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
692 lastname = 'last_' + name |
37068
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
693 if context.preload(lastname): |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
694 last = values.pop() |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
695 else: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
696 last = None |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
697 for v in values: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
698 yield one(v) |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
699 if last is not None: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
700 yield one(last, tag=lastname) |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
701 endname = 'end_' + plural |
37068
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
702 if context.preload(endname): |
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
703 yield context.process(endname, mapping) |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
704 |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
705 def flatten(context, mapping, thing): |
37157
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
706 """Yield a single stream from a possibly nested set of iterators""" |
38270
630c62804383
templater: inline unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
38269
diff
changeset
|
707 if isinstance(thing, wrapped): |
630c62804383
templater: inline unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
38269
diff
changeset
|
708 thing = thing.show(context, mapping) |
37157
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
709 if isinstance(thing, bytes): |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
710 yield thing |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
711 elif isinstance(thing, str): |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
712 # We can only hit this on Python 3, and it's here to guard |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
713 # against infinite recursion. |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
714 raise error.ProgrammingError('Mercurial IO including templates is done' |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
715 ' with bytes, not strings, got %r' % thing) |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
716 elif thing is None: |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
717 pass |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
718 elif not util.safehasattr(thing, '__iter__'): |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
719 yield pycompat.bytestr(thing) |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
720 else: |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
721 for i in thing: |
38270
630c62804383
templater: inline unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
38269
diff
changeset
|
722 if isinstance(i, wrapped): |
630c62804383
templater: inline unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
38269
diff
changeset
|
723 i = i.show(context, mapping) |
37157
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
724 if isinstance(i, bytes): |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
725 yield i |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
726 elif i is None: |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
727 pass |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
728 elif not util.safehasattr(i, '__iter__'): |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
729 yield pycompat.bytestr(i) |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
730 else: |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
731 for j in flatten(context, mapping, i): |
37157
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
732 yield j |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
733 |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
734 def stringify(context, mapping, thing): |
36920
6ff6e1d6b5b8
templater: move stringify() to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36913
diff
changeset
|
735 """Turn values into bytes by converting into text and concatenating them""" |
37158
e09d2183e226
templateutil: reimplement stringify() using flatten()
Yuya Nishihara <yuya@tcha.org>
parents:
37157
diff
changeset
|
736 if isinstance(thing, bytes): |
e09d2183e226
templateutil: reimplement stringify() using flatten()
Yuya Nishihara <yuya@tcha.org>
parents:
37157
diff
changeset
|
737 return thing # retain localstr to be round-tripped |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
738 return b''.join(flatten(context, mapping, thing)) |
36920
6ff6e1d6b5b8
templater: move stringify() to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36913
diff
changeset
|
739 |
31927
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
740 def findsymbolicname(arg): |
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
741 """Find symbolic name for the given compiled expression; returns None |
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
742 if nothing found reliably""" |
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
743 while True: |
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
744 func, data = arg |
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
745 if func is runsymbol: |
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
746 return data |
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
747 elif func is runfilter: |
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
748 arg = data[0] |
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
749 else: |
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
750 return None |
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
751 |
38289
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
752 def _nonempty(xiter): |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
753 try: |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
754 next(xiter) |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
755 return True |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
756 except StopIteration: |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
757 return False |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
758 |
37278
671a01cd50b5
templater: extract private function to evaluate generator to byte string
Yuya Nishihara <yuya@tcha.org>
parents:
37277
diff
changeset
|
759 def _unthunk(context, mapping, thing): |
671a01cd50b5
templater: extract private function to evaluate generator to byte string
Yuya Nishihara <yuya@tcha.org>
parents:
37277
diff
changeset
|
760 """Evaluate a lazy byte string into value""" |
671a01cd50b5
templater: extract private function to evaluate generator to byte string
Yuya Nishihara <yuya@tcha.org>
parents:
37277
diff
changeset
|
761 if not isinstance(thing, types.GeneratorType): |
671a01cd50b5
templater: extract private function to evaluate generator to byte string
Yuya Nishihara <yuya@tcha.org>
parents:
37277
diff
changeset
|
762 return thing |
671a01cd50b5
templater: extract private function to evaluate generator to byte string
Yuya Nishihara <yuya@tcha.org>
parents:
37277
diff
changeset
|
763 return stringify(context, mapping, thing) |
671a01cd50b5
templater: extract private function to evaluate generator to byte string
Yuya Nishihara <yuya@tcha.org>
parents:
37277
diff
changeset
|
764 |
34326
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
765 def evalrawexp(context, mapping, arg): |
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
766 """Evaluate given argument as a bare template object which may require |
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
767 further processing (such as folding generator of strings)""" |
26124
604a7c941103
templater: extract helper that evaluates filter or function argument
Yuya Nishihara <yuya@tcha.org>
parents:
26106
diff
changeset
|
768 func, data = arg |
34326
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
769 return func(context, mapping, data) |
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
770 |
38226
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
771 def evalwrapped(context, mapping, arg): |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
772 """Evaluate given argument to wrapped object""" |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
773 thing = evalrawexp(context, mapping, arg) |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
774 return makewrapped(context, mapping, thing) |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
775 |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
776 def makewrapped(context, mapping, thing): |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
777 """Lift object to a wrapped type""" |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
778 if isinstance(thing, wrapped): |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
779 return thing |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
780 thing = _unthunk(context, mapping, thing) |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
781 if isinstance(thing, bytes): |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
782 return wrappedbytes(thing) |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
783 return wrappedvalue(thing) |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
784 |
34326
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
785 def evalfuncarg(context, mapping, arg): |
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
786 """Evaluate given argument as value type""" |
38225
d48b80d58848
templater: unify unwrapvalue() with _unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
38224
diff
changeset
|
787 return unwrapvalue(context, mapping, evalrawexp(context, mapping, arg)) |
37161
0023da2910c9
templater: extract type conversion from evalfuncarg()
Yuya Nishihara <yuya@tcha.org>
parents:
37160
diff
changeset
|
788 |
38225
d48b80d58848
templater: unify unwrapvalue() with _unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
38224
diff
changeset
|
789 def unwrapvalue(context, mapping, thing): |
d48b80d58848
templater: unify unwrapvalue() with _unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
38224
diff
changeset
|
790 """Move the inner value object out of the wrapper""" |
38224
61cecab0cc20
templater: inline unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
37502
diff
changeset
|
791 if isinstance(thing, wrapped): |
61cecab0cc20
templater: inline unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
37502
diff
changeset
|
792 return thing.tovalue(context, mapping) |
34326
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
793 # evalrawexp() may return string, generator of strings or arbitrary object |
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
794 # such as date tuple, but filter does not want generator. |
37278
671a01cd50b5
templater: extract private function to evaluate generator to byte string
Yuya Nishihara <yuya@tcha.org>
parents:
37277
diff
changeset
|
795 return _unthunk(context, mapping, thing) |
26124
604a7c941103
templater: extract helper that evaluates filter or function argument
Yuya Nishihara <yuya@tcha.org>
parents:
26106
diff
changeset
|
796 |
29816
034412ca28c3
templater: fix if() to not evaluate False as bool('False')
Yuya Nishihara <yuya@tcha.org>
parents:
29815
diff
changeset
|
797 def evalboolean(context, mapping, arg): |
29817
cc11079644fc
templater: make pad() evaluate boolean argument (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29816
diff
changeset
|
798 """Evaluate given argument as boolean, but also takes boolean literals""" |
29816
034412ca28c3
templater: fix if() to not evaluate False as bool('False')
Yuya Nishihara <yuya@tcha.org>
parents:
29815
diff
changeset
|
799 func, data = arg |
29817
cc11079644fc
templater: make pad() evaluate boolean argument (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29816
diff
changeset
|
800 if func is runsymbol: |
cc11079644fc
templater: make pad() evaluate boolean argument (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29816
diff
changeset
|
801 thing = func(context, mapping, data, default=None) |
cc11079644fc
templater: make pad() evaluate boolean argument (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29816
diff
changeset
|
802 if thing is None: |
cc11079644fc
templater: make pad() evaluate boolean argument (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29816
diff
changeset
|
803 # not a template keyword, takes as a boolean literal |
37084
f0b6fbea00cf
stringutil: bulk-replace call sites to point to new module
Yuya Nishihara <yuya@tcha.org>
parents:
37074
diff
changeset
|
804 thing = stringutil.parsebool(data) |
29817
cc11079644fc
templater: make pad() evaluate boolean argument (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29816
diff
changeset
|
805 else: |
cc11079644fc
templater: make pad() evaluate boolean argument (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29816
diff
changeset
|
806 thing = func(context, mapping, data) |
38289
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
807 return makewrapped(context, mapping, thing).tobool(context, mapping) |
29816
034412ca28c3
templater: fix if() to not evaluate False as bool('False')
Yuya Nishihara <yuya@tcha.org>
parents:
29815
diff
changeset
|
808 |
37224
67efce231633
templater: factor out function that parses argument as date tuple
Yuya Nishihara <yuya@tcha.org>
parents:
37222
diff
changeset
|
809 def evaldate(context, mapping, arg, err=None): |
67efce231633
templater: factor out function that parses argument as date tuple
Yuya Nishihara <yuya@tcha.org>
parents:
37222
diff
changeset
|
810 """Evaluate given argument as a date tuple or a date string; returns |
67efce231633
templater: factor out function that parses argument as date tuple
Yuya Nishihara <yuya@tcha.org>
parents:
37222
diff
changeset
|
811 a (unixtime, offset) tuple""" |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
812 thing = evalrawexp(context, mapping, arg) |
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
813 return unwrapdate(context, mapping, thing, err) |
37224
67efce231633
templater: factor out function that parses argument as date tuple
Yuya Nishihara <yuya@tcha.org>
parents:
37222
diff
changeset
|
814 |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
815 def unwrapdate(context, mapping, thing, err=None): |
38285
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
816 if isinstance(thing, date): |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
817 return thing.tovalue(context, mapping) |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
818 # TODO: update hgweb to not return bare tuple; then just stringify 'thing' |
38225
d48b80d58848
templater: unify unwrapvalue() with _unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
38224
diff
changeset
|
819 thing = unwrapvalue(context, mapping, thing) |
37224
67efce231633
templater: factor out function that parses argument as date tuple
Yuya Nishihara <yuya@tcha.org>
parents:
37222
diff
changeset
|
820 try: |
67efce231633
templater: factor out function that parses argument as date tuple
Yuya Nishihara <yuya@tcha.org>
parents:
37222
diff
changeset
|
821 return dateutil.parsedate(thing) |
67efce231633
templater: factor out function that parses argument as date tuple
Yuya Nishihara <yuya@tcha.org>
parents:
37222
diff
changeset
|
822 except AttributeError: |
67efce231633
templater: factor out function that parses argument as date tuple
Yuya Nishihara <yuya@tcha.org>
parents:
37222
diff
changeset
|
823 raise error.ParseError(err or _('not a date tuple nor a string')) |
37225
e70a90a72b80
templatefuncs: use evaldate() where seems appropriate
Yuya Nishihara <yuya@tcha.org>
parents:
37224
diff
changeset
|
824 except error.ParseError: |
e70a90a72b80
templatefuncs: use evaldate() where seems appropriate
Yuya Nishihara <yuya@tcha.org>
parents:
37224
diff
changeset
|
825 if not err: |
e70a90a72b80
templatefuncs: use evaldate() where seems appropriate
Yuya Nishihara <yuya@tcha.org>
parents:
37224
diff
changeset
|
826 raise |
e70a90a72b80
templatefuncs: use evaldate() where seems appropriate
Yuya Nishihara <yuya@tcha.org>
parents:
37224
diff
changeset
|
827 raise error.ParseError(err) |
37224
67efce231633
templater: factor out function that parses argument as date tuple
Yuya Nishihara <yuya@tcha.org>
parents:
37222
diff
changeset
|
828 |
34581
ee0d74083a22
templater: store revisions as ints so min/max won't compare them as strings
Yuya Nishihara <yuya@tcha.org>
parents:
34536
diff
changeset
|
829 def evalinteger(context, mapping, arg, err=None): |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
830 thing = evalrawexp(context, mapping, arg) |
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
831 return unwrapinteger(context, mapping, thing, err) |
37162
9ab3491f84c2
templater: extract unwrapinteger() function from evalinteger()
Yuya Nishihara <yuya@tcha.org>
parents:
37161
diff
changeset
|
832 |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
833 def unwrapinteger(context, mapping, thing, err=None): |
38225
d48b80d58848
templater: unify unwrapvalue() with _unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
38224
diff
changeset
|
834 thing = unwrapvalue(context, mapping, thing) |
28343
a6c2310b3827
templater: factor out function that evaluates argument as integer
Yuya Nishihara <yuya@tcha.org>
parents:
28334
diff
changeset
|
835 try: |
37162
9ab3491f84c2
templater: extract unwrapinteger() function from evalinteger()
Yuya Nishihara <yuya@tcha.org>
parents:
37161
diff
changeset
|
836 return int(thing) |
28344
ac371d4c007f
templater: drop redundant type conversion when evaluating integer argument
Yuya Nishihara <yuya@tcha.org>
parents:
28343
diff
changeset
|
837 except (TypeError, ValueError): |
34581
ee0d74083a22
templater: store revisions as ints so min/max won't compare them as strings
Yuya Nishihara <yuya@tcha.org>
parents:
34536
diff
changeset
|
838 raise error.ParseError(err or _('not an integer')) |
28343
a6c2310b3827
templater: factor out function that evaluates argument as integer
Yuya Nishihara <yuya@tcha.org>
parents:
28334
diff
changeset
|
839 |
28348
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
840 def evalstring(context, mapping, arg): |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
841 return stringify(context, mapping, evalrawexp(context, mapping, arg)) |
28348
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
842 |
28373
9a9dd71e882c
templater: make label() take unknown symbol as color literal
Yuya Nishihara <yuya@tcha.org>
parents:
28349
diff
changeset
|
843 def evalstringliteral(context, mapping, arg): |
9a9dd71e882c
templater: make label() take unknown symbol as color literal
Yuya Nishihara <yuya@tcha.org>
parents:
28349
diff
changeset
|
844 """Evaluate given argument as string template, but returns symbol name |
9a9dd71e882c
templater: make label() take unknown symbol as color literal
Yuya Nishihara <yuya@tcha.org>
parents:
28349
diff
changeset
|
845 if it is unknown""" |
9a9dd71e882c
templater: make label() take unknown symbol as color literal
Yuya Nishihara <yuya@tcha.org>
parents:
28349
diff
changeset
|
846 func, data = arg |
9a9dd71e882c
templater: make label() take unknown symbol as color literal
Yuya Nishihara <yuya@tcha.org>
parents:
28349
diff
changeset
|
847 if func is runsymbol: |
9a9dd71e882c
templater: make label() take unknown symbol as color literal
Yuya Nishihara <yuya@tcha.org>
parents:
28349
diff
changeset
|
848 thing = func(context, mapping, data, default=data) |
9a9dd71e882c
templater: make label() take unknown symbol as color literal
Yuya Nishihara <yuya@tcha.org>
parents:
28349
diff
changeset
|
849 else: |
9a9dd71e882c
templater: make label() take unknown symbol as color literal
Yuya Nishihara <yuya@tcha.org>
parents:
28349
diff
changeset
|
850 thing = func(context, mapping, data) |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
851 return stringify(context, mapping, thing) |
28373
9a9dd71e882c
templater: make label() take unknown symbol as color literal
Yuya Nishihara <yuya@tcha.org>
parents:
28349
diff
changeset
|
852 |
37163
0fb28899e81a
templater: factor out unwrapastype() from evalastype()
Yuya Nishihara <yuya@tcha.org>
parents:
37162
diff
changeset
|
853 _unwrapfuncbytype = { |
38225
d48b80d58848
templater: unify unwrapvalue() with _unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
38224
diff
changeset
|
854 None: unwrapvalue, |
37163
0fb28899e81a
templater: factor out unwrapastype() from evalastype()
Yuya Nishihara <yuya@tcha.org>
parents:
37162
diff
changeset
|
855 bytes: stringify, |
37227
9bcf096a2da2
templatefilters: declare input type as date where appropriate
Yuya Nishihara <yuya@tcha.org>
parents:
37226
diff
changeset
|
856 date: unwrapdate, |
37163
0fb28899e81a
templater: factor out unwrapastype() from evalastype()
Yuya Nishihara <yuya@tcha.org>
parents:
37162
diff
changeset
|
857 int: unwrapinteger, |
34581
ee0d74083a22
templater: store revisions as ints so min/max won't compare them as strings
Yuya Nishihara <yuya@tcha.org>
parents:
34536
diff
changeset
|
858 } |
ee0d74083a22
templater: store revisions as ints so min/max won't compare them as strings
Yuya Nishihara <yuya@tcha.org>
parents:
34536
diff
changeset
|
859 |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
860 def unwrapastype(context, mapping, thing, typ): |
37163
0fb28899e81a
templater: factor out unwrapastype() from evalastype()
Yuya Nishihara <yuya@tcha.org>
parents:
37162
diff
changeset
|
861 """Move the inner value object out of the wrapper and coerce its type""" |
34581
ee0d74083a22
templater: store revisions as ints so min/max won't compare them as strings
Yuya Nishihara <yuya@tcha.org>
parents:
34536
diff
changeset
|
862 try: |
37163
0fb28899e81a
templater: factor out unwrapastype() from evalastype()
Yuya Nishihara <yuya@tcha.org>
parents:
37162
diff
changeset
|
863 f = _unwrapfuncbytype[typ] |
34581
ee0d74083a22
templater: store revisions as ints so min/max won't compare them as strings
Yuya Nishihara <yuya@tcha.org>
parents:
34536
diff
changeset
|
864 except KeyError: |
ee0d74083a22
templater: store revisions as ints so min/max won't compare them as strings
Yuya Nishihara <yuya@tcha.org>
parents:
34536
diff
changeset
|
865 raise error.ProgrammingError('invalid type specified: %r' % typ) |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
866 return f(context, mapping, thing) |
34581
ee0d74083a22
templater: store revisions as ints so min/max won't compare them as strings
Yuya Nishihara <yuya@tcha.org>
parents:
34536
diff
changeset
|
867 |
25002
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
868 def runinteger(context, mapping, data): |
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
869 return int(data) |
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
870 |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
871 def runstring(context, mapping, data): |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
872 return data |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
873 |
27939
7ed3a3c0cef1
templater: abort if infinite recursion detected while evaluation (issue4758)
Yuya Nishihara <yuya@tcha.org>
parents:
27892
diff
changeset
|
874 def _recursivesymbolblocker(key): |
38930
382b055cc358
templatekw: deprecate old-style template keyword function (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38449
diff
changeset
|
875 def showrecursion(context, mapping): |
27939
7ed3a3c0cef1
templater: abort if infinite recursion detected while evaluation (issue4758)
Yuya Nishihara <yuya@tcha.org>
parents:
27892
diff
changeset
|
876 raise error.Abort(_("recursive reference '%s' in template") % key) |
38930
382b055cc358
templatekw: deprecate old-style template keyword function (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38449
diff
changeset
|
877 showrecursion._requires = () # mark as new-style templatekw |
27939
7ed3a3c0cef1
templater: abort if infinite recursion detected while evaluation (issue4758)
Yuya Nishihara <yuya@tcha.org>
parents:
27892
diff
changeset
|
878 return showrecursion |
7ed3a3c0cef1
templater: abort if infinite recursion detected while evaluation (issue4758)
Yuya Nishihara <yuya@tcha.org>
parents:
27892
diff
changeset
|
879 |
28373
9a9dd71e882c
templater: make label() take unknown symbol as color literal
Yuya Nishihara <yuya@tcha.org>
parents:
28349
diff
changeset
|
880 def runsymbol(context, mapping, key, default=''): |
35467
d6cfa722b044
templater: look up mapping table through template engine
Yuya Nishihara <yuya@tcha.org>
parents:
35414
diff
changeset
|
881 v = context.symbol(mapping, key) |
19770
0361163efbaf
templater: support using templates with non-standard names from map file
Alexander Plavin <alexander@plav.in>
parents:
19390
diff
changeset
|
882 if v is None: |
27939
7ed3a3c0cef1
templater: abort if infinite recursion detected while evaluation (issue4758)
Yuya Nishihara <yuya@tcha.org>
parents:
27892
diff
changeset
|
883 # put poison to cut recursion. we can't move this to parsing phase |
7ed3a3c0cef1
templater: abort if infinite recursion detected while evaluation (issue4758)
Yuya Nishihara <yuya@tcha.org>
parents:
27892
diff
changeset
|
884 # because "x = {x}" is allowed if "x" is a keyword. (issue4758) |
7ed3a3c0cef1
templater: abort if infinite recursion detected while evaluation (issue4758)
Yuya Nishihara <yuya@tcha.org>
parents:
27892
diff
changeset
|
885 safemapping = mapping.copy() |
7ed3a3c0cef1
templater: abort if infinite recursion detected while evaluation (issue4758)
Yuya Nishihara <yuya@tcha.org>
parents:
27892
diff
changeset
|
886 safemapping[key] = _recursivesymbolblocker(key) |
19770
0361163efbaf
templater: support using templates with non-standard names from map file
Alexander Plavin <alexander@plav.in>
parents:
19390
diff
changeset
|
887 try: |
27939
7ed3a3c0cef1
templater: abort if infinite recursion detected while evaluation (issue4758)
Yuya Nishihara <yuya@tcha.org>
parents:
27892
diff
changeset
|
888 v = context.process(key, safemapping) |
19770
0361163efbaf
templater: support using templates with non-standard names from map file
Alexander Plavin <alexander@plav.in>
parents:
19390
diff
changeset
|
889 except TemplateNotFound: |
28373
9a9dd71e882c
templater: make label() take unknown symbol as color literal
Yuya Nishihara <yuya@tcha.org>
parents:
28349
diff
changeset
|
890 v = default |
36445
e8d37838f5df
templatekw: add 'requires' flag to switch to exception-safe interface
Yuya Nishihara <yuya@tcha.org>
parents:
36444
diff
changeset
|
891 if callable(v) and getattr(v, '_requires', None) is None: |
e8d37838f5df
templatekw: add 'requires' flag to switch to exception-safe interface
Yuya Nishihara <yuya@tcha.org>
parents:
36444
diff
changeset
|
892 # old templatekw: expand all keywords and resources |
38930
382b055cc358
templatekw: deprecate old-style template keyword function (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38449
diff
changeset
|
893 # (TODO: drop support for old-style functions. 'f._requires = ()' |
382b055cc358
templatekw: deprecate old-style template keyword function (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38449
diff
changeset
|
894 # can be removed.) |
39582
28f974d83c0a
templater: remove unused context argument from most resourcemapper functions
Yuya Nishihara <yuya@tcha.org>
parents:
39368
diff
changeset
|
895 props = {k: context._resources.lookup(mapping, k) |
37073
44757e6dad93
templater: introduce resourcemapper class
Yuya Nishihara <yuya@tcha.org>
parents:
37070
diff
changeset
|
896 for k in context._resources.knownkeys()} |
37070
1101d6747d2d
templater: drop 'templ' from resources dict
Yuya Nishihara <yuya@tcha.org>
parents:
37068
diff
changeset
|
897 # pass context to _showcompatlist() through templatekw._showlist() |
1101d6747d2d
templater: drop 'templ' from resources dict
Yuya Nishihara <yuya@tcha.org>
parents:
37068
diff
changeset
|
898 props['templ'] = context |
35468
32c278eb876f
templater: keep default resources per template engine (API)
Yuya Nishihara <yuya@tcha.org>
parents:
35467
diff
changeset
|
899 props.update(mapping) |
38930
382b055cc358
templatekw: deprecate old-style template keyword function (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38449
diff
changeset
|
900 ui = props.get('ui') |
382b055cc358
templatekw: deprecate old-style template keyword function (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38449
diff
changeset
|
901 if ui: |
382b055cc358
templatekw: deprecate old-style template keyword function (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38449
diff
changeset
|
902 ui.deprecwarn("old-style template keyword '%s'" % key, '4.8') |
35588
dadbf213a765
py3: convert dict keys' to str before passing as kwargs
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35481
diff
changeset
|
903 return v(**pycompat.strkwargs(props)) |
36445
e8d37838f5df
templatekw: add 'requires' flag to switch to exception-safe interface
Yuya Nishihara <yuya@tcha.org>
parents:
36444
diff
changeset
|
904 if callable(v): |
e8d37838f5df
templatekw: add 'requires' flag to switch to exception-safe interface
Yuya Nishihara <yuya@tcha.org>
parents:
36444
diff
changeset
|
905 # new templatekw |
e8d37838f5df
templatekw: add 'requires' flag to switch to exception-safe interface
Yuya Nishihara <yuya@tcha.org>
parents:
36444
diff
changeset
|
906 try: |
e8d37838f5df
templatekw: add 'requires' flag to switch to exception-safe interface
Yuya Nishihara <yuya@tcha.org>
parents:
36444
diff
changeset
|
907 return v(context, mapping) |
e8d37838f5df
templatekw: add 'requires' flag to switch to exception-safe interface
Yuya Nishihara <yuya@tcha.org>
parents:
36444
diff
changeset
|
908 except ResourceUnavailable: |
e8d37838f5df
templatekw: add 'requires' flag to switch to exception-safe interface
Yuya Nishihara <yuya@tcha.org>
parents:
36444
diff
changeset
|
909 # unsupported keyword is mapped to empty just like unknown keyword |
e8d37838f5df
templatekw: add 'requires' flag to switch to exception-safe interface
Yuya Nishihara <yuya@tcha.org>
parents:
36444
diff
changeset
|
910 return None |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
911 return v |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
912 |
25595
a7dd6692e5cb
templater: move runtemplate function out of buildmap/runmap pair
Yuya Nishihara <yuya@tcha.org>
parents:
25580
diff
changeset
|
913 def runtemplate(context, mapping, template): |
34326
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
914 for arg in template: |
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
915 yield evalrawexp(context, mapping, arg) |
25595
a7dd6692e5cb
templater: move runtemplate function out of buildmap/runmap pair
Yuya Nishihara <yuya@tcha.org>
parents:
25580
diff
changeset
|
916 |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
917 def runfilter(context, mapping, data): |
26125
c990afab2243
templater: drop unneeded destructuring of argument tuple at buildfilter
Yuya Nishihara <yuya@tcha.org>
parents:
26124
diff
changeset
|
918 arg, filt = data |
37222
54355c243042
templatefilters: allow declaration of input data type
Yuya Nishihara <yuya@tcha.org>
parents:
37163
diff
changeset
|
919 thing = evalrawexp(context, mapping, arg) |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
920 intype = getattr(filt, '_intype', None) |
17383
099c778ceb33
templater: abort when a template filter raises an exception (issue2987)
Neil Kodner <neilk@fb.com>
parents:
17334
diff
changeset
|
921 try: |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
922 thing = unwrapastype(context, mapping, thing, intype) |
24280
6c55e37ba5f2
templater: allow piping generator-type function output to filters
Yuya Nishihara <yuya@tcha.org>
parents:
24240
diff
changeset
|
923 return filt(thing) |
37226
920589f52be9
templater: attach hint to input-type error of runfilter()
Yuya Nishihara <yuya@tcha.org>
parents:
37225
diff
changeset
|
924 except error.ParseError as e: |
920589f52be9
templater: attach hint to input-type error of runfilter()
Yuya Nishihara <yuya@tcha.org>
parents:
37225
diff
changeset
|
925 raise error.ParseError(bytes(e), hint=_formatfiltererror(arg, filt)) |
920589f52be9
templater: attach hint to input-type error of runfilter()
Yuya Nishihara <yuya@tcha.org>
parents:
37225
diff
changeset
|
926 |
920589f52be9
templater: attach hint to input-type error of runfilter()
Yuya Nishihara <yuya@tcha.org>
parents:
37225
diff
changeset
|
927 def _formatfiltererror(arg, filt): |
920589f52be9
templater: attach hint to input-type error of runfilter()
Yuya Nishihara <yuya@tcha.org>
parents:
37225
diff
changeset
|
928 fn = pycompat.sysbytes(filt.__name__) |
920589f52be9
templater: attach hint to input-type error of runfilter()
Yuya Nishihara <yuya@tcha.org>
parents:
37225
diff
changeset
|
929 sym = findsymbolicname(arg) |
920589f52be9
templater: attach hint to input-type error of runfilter()
Yuya Nishihara <yuya@tcha.org>
parents:
37225
diff
changeset
|
930 if not sym: |
920589f52be9
templater: attach hint to input-type error of runfilter()
Yuya Nishihara <yuya@tcha.org>
parents:
37225
diff
changeset
|
931 return _("incompatible use of template filter '%s'") % fn |
920589f52be9
templater: attach hint to input-type error of runfilter()
Yuya Nishihara <yuya@tcha.org>
parents:
37225
diff
changeset
|
932 return (_("template filter '%s' is not compatible with keyword '%s'") |
920589f52be9
templater: attach hint to input-type error of runfilter()
Yuya Nishihara <yuya@tcha.org>
parents:
37225
diff
changeset
|
933 % (fn, sym)) |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
934 |
37399
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
935 def _iteroverlaymaps(context, origmapping, newmappings): |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
936 """Generate combined mappings from the original mapping and an iterable |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
937 of partial mappings to override the original""" |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
938 for i, nm in enumerate(newmappings): |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
939 lm = context.overlaymap(origmapping, nm) |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
940 lm['index'] = i |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
941 yield lm |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
942 |
38271
4b0f39e7406e
templater: show slightly better hint on map operation error
Yuya Nishihara <yuya@tcha.org>
parents:
38270
diff
changeset
|
943 def _applymap(context, mapping, d, darg, targ): |
4b0f39e7406e
templater: show slightly better hint on map operation error
Yuya Nishihara <yuya@tcha.org>
parents:
38270
diff
changeset
|
944 try: |
4b0f39e7406e
templater: show slightly better hint on map operation error
Yuya Nishihara <yuya@tcha.org>
parents:
38270
diff
changeset
|
945 diter = d.itermaps(context) |
4b0f39e7406e
templater: show slightly better hint on map operation error
Yuya Nishihara <yuya@tcha.org>
parents:
38270
diff
changeset
|
946 except error.ParseError as err: |
4b0f39e7406e
templater: show slightly better hint on map operation error
Yuya Nishihara <yuya@tcha.org>
parents:
38270
diff
changeset
|
947 sym = findsymbolicname(darg) |
4b0f39e7406e
templater: show slightly better hint on map operation error
Yuya Nishihara <yuya@tcha.org>
parents:
38270
diff
changeset
|
948 if not sym: |
4b0f39e7406e
templater: show slightly better hint on map operation error
Yuya Nishihara <yuya@tcha.org>
parents:
38270
diff
changeset
|
949 raise |
4b0f39e7406e
templater: show slightly better hint on map operation error
Yuya Nishihara <yuya@tcha.org>
parents:
38270
diff
changeset
|
950 hint = _("keyword '%s' does not support map operation") % sym |
4b0f39e7406e
templater: show slightly better hint on map operation error
Yuya Nishihara <yuya@tcha.org>
parents:
38270
diff
changeset
|
951 raise error.ParseError(bytes(err), hint=hint) |
4b0f39e7406e
templater: show slightly better hint on map operation error
Yuya Nishihara <yuya@tcha.org>
parents:
38270
diff
changeset
|
952 for lm in _iteroverlaymaps(context, mapping, diter): |
37499
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
953 yield evalrawexp(context, lm, targ) |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
954 |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
955 def runmap(context, mapping, data): |
34326
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
956 darg, targ = data |
38229
7701c2d4a438
templater: always map over a wrapped object
Yuya Nishihara <yuya@tcha.org>
parents:
38228
diff
changeset
|
957 d = evalwrapped(context, mapping, darg) |
38271
4b0f39e7406e
templater: show slightly better hint on map operation error
Yuya Nishihara <yuya@tcha.org>
parents:
38270
diff
changeset
|
958 return mappedgenerator(_applymap, args=(mapping, d, darg, targ)) |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
959 |
34535
78590585c0db
templater: add dot operator to easily access a sub item
Yuya Nishihara <yuya@tcha.org>
parents:
34534
diff
changeset
|
960 def runmember(context, mapping, data): |
78590585c0db
templater: add dot operator to easily access a sub item
Yuya Nishihara <yuya@tcha.org>
parents:
34534
diff
changeset
|
961 darg, memb = data |
38240
c2456a7726c1
templater: do dict lookup over a wrapped object
Yuya Nishihara <yuya@tcha.org>
parents:
38229
diff
changeset
|
962 d = evalwrapped(context, mapping, darg) |
38284
e72697893c93
templater: promote tomap() to an interface type
Yuya Nishihara <yuya@tcha.org>
parents:
38283
diff
changeset
|
963 if isinstance(d, mappable): |
e72697893c93
templater: promote tomap() to an interface type
Yuya Nishihara <yuya@tcha.org>
parents:
38283
diff
changeset
|
964 lm = context.overlaymap(mapping, d.tomap(context)) |
34535
78590585c0db
templater: add dot operator to easily access a sub item
Yuya Nishihara <yuya@tcha.org>
parents:
34534
diff
changeset
|
965 return runsymbol(context, lm, memb) |
38241
ad06a4264daf
templater: add try-except stub to runmember()
Yuya Nishihara <yuya@tcha.org>
parents:
38240
diff
changeset
|
966 try: |
38243
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
967 return d.getmember(context, mapping, memb) |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
968 except error.ParseError as err: |
38241
ad06a4264daf
templater: add try-except stub to runmember()
Yuya Nishihara <yuya@tcha.org>
parents:
38240
diff
changeset
|
969 sym = findsymbolicname(darg) |
38243
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
970 if not sym: |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
971 raise |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
972 hint = _("keyword '%s' does not support member operation") % sym |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
973 raise error.ParseError(bytes(err), hint=hint) |
34535
78590585c0db
templater: add dot operator to easily access a sub item
Yuya Nishihara <yuya@tcha.org>
parents:
34534
diff
changeset
|
974 |
30115
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
975 def runnegate(context, mapping, data): |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
976 data = evalinteger(context, mapping, data, |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
977 _('negation needs an integer argument')) |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
978 return -data |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
979 |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
980 def runarithmetic(context, mapping, data): |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
981 func, left, right = data |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
982 left = evalinteger(context, mapping, left, |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
983 _('arithmetic only defined on integers')) |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
984 right = evalinteger(context, mapping, right, |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
985 _('arithmetic only defined on integers')) |
30116
1c01fa29630f
templater: handle division by zero in arithmetic
Simon Farnsworth <simonfar@fb.com>
parents:
30115
diff
changeset
|
986 try: |
1c01fa29630f
templater: handle division by zero in arithmetic
Simon Farnsworth <simonfar@fb.com>
parents:
30115
diff
changeset
|
987 return func(left, right) |
1c01fa29630f
templater: handle division by zero in arithmetic
Simon Farnsworth <simonfar@fb.com>
parents:
30115
diff
changeset
|
988 except ZeroDivisionError: |
1c01fa29630f
templater: handle division by zero in arithmetic
Simon Farnsworth <simonfar@fb.com>
parents:
30115
diff
changeset
|
989 raise error.Abort(_('division by zero is not defined')) |
30115
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
990 |
37325
41a5d815d2c1
templater: factor out generator of join()-ed items
Yuya Nishihara <yuya@tcha.org>
parents:
37324
diff
changeset
|
991 def joinitems(itemiter, sep): |
41a5d815d2c1
templater: factor out generator of join()-ed items
Yuya Nishihara <yuya@tcha.org>
parents:
37324
diff
changeset
|
992 """Join items with the separator; Returns generator of bytes""" |
41a5d815d2c1
templater: factor out generator of join()-ed items
Yuya Nishihara <yuya@tcha.org>
parents:
37324
diff
changeset
|
993 first = True |
41a5d815d2c1
templater: factor out generator of join()-ed items
Yuya Nishihara <yuya@tcha.org>
parents:
37324
diff
changeset
|
994 for x in itemiter: |
41a5d815d2c1
templater: factor out generator of join()-ed items
Yuya Nishihara <yuya@tcha.org>
parents:
37324
diff
changeset
|
995 if first: |
41a5d815d2c1
templater: factor out generator of join()-ed items
Yuya Nishihara <yuya@tcha.org>
parents:
37324
diff
changeset
|
996 first = False |
37326
9cd88dd3bf64
templater: micro-optimize join() with empty separator
Yuya Nishihara <yuya@tcha.org>
parents:
37325
diff
changeset
|
997 elif sep: |
37325
41a5d815d2c1
templater: factor out generator of join()-ed items
Yuya Nishihara <yuya@tcha.org>
parents:
37324
diff
changeset
|
998 yield sep |
41a5d815d2c1
templater: factor out generator of join()-ed items
Yuya Nishihara <yuya@tcha.org>
parents:
37324
diff
changeset
|
999 yield x |