Mercurial > hg
annotate mercurial/templateutil.py @ 39634:9dffa99f9158
wireprotov2: add bookmarks to "changesetdata" command
Like we did for phases, we want to emit bookmarks data attached
to each changeset.
The approach here is very similar to phases: we emit bookmarks
data inline with requested revision data. But we emit
records for nodes that weren't requested as well so consumers have
access to the full set of defined bookmarks.
Differential Revision: https://phab.mercurial-scm.org/D4485
author | Gregory Szorc <gregory.szorc@gmail.com> |
---|---|
date | Thu, 23 Aug 2018 18:14:19 -0700 |
parents | 28f974d83c0a |
children | 8fa26f3baf30 |
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 |
37499
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
475 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
|
476 """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
|
477 |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
478 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
|
479 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
|
480 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
|
481 """ |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
482 |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
483 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
|
484 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
|
485 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
|
486 |
38267
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
487 def contains(self, context, mapping, item): |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
488 item = stringify(context, mapping, item) |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
489 return item in self.tovalue(context, mapping) |
fb874fc1d9b4
templater: abstract ifcontains() over wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38266
diff
changeset
|
490 |
37499
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
491 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
|
492 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
|
493 |
38243
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
494 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
|
495 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
|
496 |
38265
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
497 def getmin(self, context, mapping): |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
498 return self._getby(context, mapping, min) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
499 |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
500 def getmax(self, context, mapping): |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
501 return self._getby(context, mapping, max) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
502 |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
503 def _getby(self, context, mapping, func): |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
504 xs = self.tovalue(context, mapping) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
505 if not xs: |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
506 raise error.ParseError(_('empty sequence')) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
507 return func(xs) |
41ae9b3cbfb9
templater: abstract min/max away
Yuya Nishihara <yuya@tcha.org>
parents:
38244
diff
changeset
|
508 |
38448
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
509 @staticmethod |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
510 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
|
511 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
|
512 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
|
513 if select(wrappedbytes(s)): |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
514 yield s |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
515 |
dae829b4de78
templater: introduce filter() function to remove empty items from list
Yuya Nishihara <yuya@tcha.org>
parents:
38447
diff
changeset
|
516 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
|
517 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
|
518 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
|
519 |
37499
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
520 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
|
521 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
|
522 |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
523 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
|
524 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
|
525 |
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
526 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
|
527 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
|
528 |
38289
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
529 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
|
530 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
|
531 |
37499
75c13343cf38
templater: wrap result of '%' operation so it never looks like a thunk
Yuya Nishihara <yuya@tcha.org>
parents:
37405
diff
changeset
|
532 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
|
533 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
|
534 |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
535 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
|
536 """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
|
537 prefmt = pycompat.identity |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
538 if fmt is None: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
539 fmt = '%s=%s' |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
540 prefmt = pycompat.bytestr |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
541 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
|
542 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
|
543 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
544 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
|
545 """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
|
546 prefmt = pycompat.identity |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
547 if fmt is None: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
548 fmt = '%s' |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
549 prefmt = pycompat.bytestr |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
550 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
|
551 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
552 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
|
553 fmt=None, plural=None, separator=' '): |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
554 """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
|
555 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
556 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
|
557 hybriddict() for new template keywords. |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
558 """ |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
559 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
|
560 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
|
561 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
|
562 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
563 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
|
564 plural=None, separator=' '): |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
565 """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
|
566 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
567 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
|
568 hybridlist() for new template keywords. |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
569 """ |
37068
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
570 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
|
571 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
|
572 |
39368
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
573 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
|
574 """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
|
575 template and field names |
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
576 |
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
577 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
|
578 keywords. |
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
579 """ |
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
580 # 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
|
581 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
|
582 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
|
583 copies = util.sortdict(copies) |
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
584 return hybrid(f, copies, |
5b1d406b39f1
templatekw: alias {name} of file copies dict to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
39367
diff
changeset
|
585 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
|
586 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
|
587 |
39367
83f8f7b9fa60
templatekw: alias {file} of files list to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
38930
diff
changeset
|
588 def compatfileslist(context, mapping, name, files): |
83f8f7b9fa60
templatekw: alias {file} of files list to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
38930
diff
changeset
|
589 """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
|
590 names |
83f8f7b9fa60
templatekw: alias {file} of files list to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
38930
diff
changeset
|
591 |
83f8f7b9fa60
templatekw: alias {file} of files list to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
38930
diff
changeset
|
592 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
|
593 keywords. |
83f8f7b9fa60
templatekw: alias {file} of files list to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
38930
diff
changeset
|
594 """ |
83f8f7b9fa60
templatekw: alias {file} of files list to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
38930
diff
changeset
|
595 f = _showcompatlist(context, mapping, name, files) |
83f8f7b9fa60
templatekw: alias {file} of files list to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
38930
diff
changeset
|
596 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
|
597 pycompat.identity) |
83f8f7b9fa60
templatekw: alias {file} of files list to {path}
Yuya Nishihara <yuya@tcha.org>
parents:
38930
diff
changeset
|
598 |
37068
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
599 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
|
600 """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
|
601 |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
602 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
|
603 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
|
604 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
|
605 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
|
606 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
607 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
|
608 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
609 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
|
610 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
611 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
|
612 joined by 'separator'. |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
613 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
614 expand 'start_foos'. |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
615 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
616 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
|
617 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
|
618 |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
619 expand 'end_foos'. |
37068
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
620 """ |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
621 if not plural: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
622 plural = name + 's' |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
623 if not values: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
624 noname = 'no_' + plural |
37068
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
625 if context.preload(noname): |
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
626 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
|
627 return |
37068
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
628 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
|
629 if isinstance(values[0], bytes): |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
630 yield separator.join(values) |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
631 else: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
632 for v in values: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
633 r = dict(v) |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
634 r.update(mapping) |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
635 yield r |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
636 return |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
637 startname = 'start_' + plural |
37068
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
638 if context.preload(startname): |
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
639 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
|
640 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
|
641 vmapping = {} |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
642 try: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
643 vmapping.update(v) |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
644 # 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
|
645 # 3 raises TypeError. |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
646 except (AttributeError, TypeError, ValueError): |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
647 try: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
648 # 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
|
649 # bytes. Python 3 raises TypeError. |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
650 for a, b in v: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
651 vmapping[a] = b |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
652 except (TypeError, ValueError): |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
653 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
|
654 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
|
655 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
|
656 lastname = 'last_' + name |
37068
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
657 if context.preload(lastname): |
36921
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
658 last = values.pop() |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
659 else: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
660 last = None |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
661 for v in values: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
662 yield one(v) |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
663 if last is not None: |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
664 yield one(last, tag=lastname) |
32f9b7e3f056
templater: move hybrid class and functions to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36920
diff
changeset
|
665 endname = 'end_' + plural |
37068
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
666 if context.preload(endname): |
aa97e06a1912
templater: use template context to render old-style list template
Yuya Nishihara <yuya@tcha.org>
parents:
37019
diff
changeset
|
667 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
|
668 |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
669 def flatten(context, mapping, thing): |
37157
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
670 """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
|
671 if isinstance(thing, wrapped): |
630c62804383
templater: inline unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
38269
diff
changeset
|
672 thing = thing.show(context, mapping) |
37157
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
673 if isinstance(thing, bytes): |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
674 yield thing |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
675 elif isinstance(thing, str): |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
676 # 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
|
677 # against infinite recursion. |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
678 raise error.ProgrammingError('Mercurial IO including templates is done' |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
679 ' with bytes, not strings, got %r' % thing) |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
680 elif thing is None: |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
681 pass |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
682 elif not util.safehasattr(thing, '__iter__'): |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
683 yield pycompat.bytestr(thing) |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
684 else: |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
685 for i in thing: |
38270
630c62804383
templater: inline unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
38269
diff
changeset
|
686 if isinstance(i, wrapped): |
630c62804383
templater: inline unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
38269
diff
changeset
|
687 i = i.show(context, mapping) |
37157
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
688 if isinstance(i, bytes): |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
689 yield i |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
690 elif i is None: |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
691 pass |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
692 elif not util.safehasattr(i, '__iter__'): |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
693 yield pycompat.bytestr(i) |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
694 else: |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
695 for j in flatten(context, mapping, i): |
37157
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
696 yield j |
888507ec655e
templateutil: move flatten() from templater
Yuya Nishihara <yuya@tcha.org>
parents:
37104
diff
changeset
|
697 |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
698 def stringify(context, mapping, thing): |
36920
6ff6e1d6b5b8
templater: move stringify() to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36913
diff
changeset
|
699 """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
|
700 if isinstance(thing, bytes): |
e09d2183e226
templateutil: reimplement stringify() using flatten()
Yuya Nishihara <yuya@tcha.org>
parents:
37157
diff
changeset
|
701 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
|
702 return b''.join(flatten(context, mapping, thing)) |
36920
6ff6e1d6b5b8
templater: move stringify() to templateutil module
Yuya Nishihara <yuya@tcha.org>
parents:
36913
diff
changeset
|
703 |
31927
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
704 def findsymbolicname(arg): |
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
705 """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
|
706 if nothing found reliably""" |
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
707 while True: |
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
708 func, data = arg |
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
709 if func is runsymbol: |
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
710 return data |
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
711 elif func is runfilter: |
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
712 arg = data[0] |
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
713 else: |
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
714 return None |
2abc556dbe92
templater: find keyword name more thoroughly on filtering error
Yuya Nishihara <yuya@tcha.org>
parents:
31926
diff
changeset
|
715 |
38289
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
716 def _nonempty(xiter): |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
717 try: |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
718 next(xiter) |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
719 return True |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
720 except StopIteration: |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
721 return False |
f9c426385853
templater: abstract truth testing to fix {if(list_of_empty_strings)}
Yuya Nishihara <yuya@tcha.org>
parents:
38286
diff
changeset
|
722 |
37278
671a01cd50b5
templater: extract private function to evaluate generator to byte string
Yuya Nishihara <yuya@tcha.org>
parents:
37277
diff
changeset
|
723 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
|
724 """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
|
725 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
|
726 return thing |
671a01cd50b5
templater: extract private function to evaluate generator to byte string
Yuya Nishihara <yuya@tcha.org>
parents:
37277
diff
changeset
|
727 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
|
728 |
34326
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
729 def evalrawexp(context, mapping, arg): |
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
730 """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
|
731 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
|
732 func, data = arg |
34326
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
733 return func(context, mapping, data) |
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
734 |
38226
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
735 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
|
736 """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
|
737 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
|
738 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
|
739 |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
740 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
|
741 """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
|
742 if isinstance(thing, wrapped): |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
743 return thing |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
744 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
|
745 if isinstance(thing, bytes): |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
746 return wrappedbytes(thing) |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
747 return wrappedvalue(thing) |
7824783a6d5e
templater: add wrapped types for pure non-list/dict values
Yuya Nishihara <yuya@tcha.org>
parents:
38225
diff
changeset
|
748 |
34326
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
749 def evalfuncarg(context, mapping, arg): |
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
750 """Evaluate given argument as value type""" |
38225
d48b80d58848
templater: unify unwrapvalue() with _unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
38224
diff
changeset
|
751 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
|
752 |
38225
d48b80d58848
templater: unify unwrapvalue() with _unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
38224
diff
changeset
|
753 def unwrapvalue(context, mapping, thing): |
d48b80d58848
templater: unify unwrapvalue() with _unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
38224
diff
changeset
|
754 """Move the inner value object out of the wrapper""" |
38224
61cecab0cc20
templater: inline unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
37502
diff
changeset
|
755 if isinstance(thing, wrapped): |
61cecab0cc20
templater: inline unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
37502
diff
changeset
|
756 return thing.tovalue(context, mapping) |
34326
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
757 # 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
|
758 # 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
|
759 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
|
760 |
29816
034412ca28c3
templater: fix if() to not evaluate False as bool('False')
Yuya Nishihara <yuya@tcha.org>
parents:
29815
diff
changeset
|
761 def evalboolean(context, mapping, arg): |
29817
cc11079644fc
templater: make pad() evaluate boolean argument (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29816
diff
changeset
|
762 """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
|
763 func, data = arg |
29817
cc11079644fc
templater: make pad() evaluate boolean argument (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29816
diff
changeset
|
764 if func is runsymbol: |
cc11079644fc
templater: make pad() evaluate boolean argument (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29816
diff
changeset
|
765 thing = func(context, mapping, data, default=None) |
cc11079644fc
templater: make pad() evaluate boolean argument (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29816
diff
changeset
|
766 if thing is None: |
cc11079644fc
templater: make pad() evaluate boolean argument (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29816
diff
changeset
|
767 # 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
|
768 thing = stringutil.parsebool(data) |
29817
cc11079644fc
templater: make pad() evaluate boolean argument (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29816
diff
changeset
|
769 else: |
cc11079644fc
templater: make pad() evaluate boolean argument (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
29816
diff
changeset
|
770 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
|
771 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
|
772 |
37224
67efce231633
templater: factor out function that parses argument as date tuple
Yuya Nishihara <yuya@tcha.org>
parents:
37222
diff
changeset
|
773 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
|
774 """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
|
775 a (unixtime, offset) tuple""" |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
776 thing = evalrawexp(context, mapping, arg) |
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
777 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
|
778 |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
779 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
|
780 if isinstance(thing, date): |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
781 return thing.tovalue(context, mapping) |
8d6109b49b31
templater: introduce a wrapper for date tuple (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
38284
diff
changeset
|
782 # 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
|
783 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
|
784 try: |
67efce231633
templater: factor out function that parses argument as date tuple
Yuya Nishihara <yuya@tcha.org>
parents:
37222
diff
changeset
|
785 return dateutil.parsedate(thing) |
67efce231633
templater: factor out function that parses argument as date tuple
Yuya Nishihara <yuya@tcha.org>
parents:
37222
diff
changeset
|
786 except AttributeError: |
67efce231633
templater: factor out function that parses argument as date tuple
Yuya Nishihara <yuya@tcha.org>
parents:
37222
diff
changeset
|
787 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
|
788 except error.ParseError: |
e70a90a72b80
templatefuncs: use evaldate() where seems appropriate
Yuya Nishihara <yuya@tcha.org>
parents:
37224
diff
changeset
|
789 if not err: |
e70a90a72b80
templatefuncs: use evaldate() where seems appropriate
Yuya Nishihara <yuya@tcha.org>
parents:
37224
diff
changeset
|
790 raise |
e70a90a72b80
templatefuncs: use evaldate() where seems appropriate
Yuya Nishihara <yuya@tcha.org>
parents:
37224
diff
changeset
|
791 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
|
792 |
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
|
793 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
|
794 thing = evalrawexp(context, mapping, arg) |
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
795 return unwrapinteger(context, mapping, thing, err) |
37162
9ab3491f84c2
templater: extract unwrapinteger() function from evalinteger()
Yuya Nishihara <yuya@tcha.org>
parents:
37161
diff
changeset
|
796 |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
797 def unwrapinteger(context, mapping, thing, err=None): |
38225
d48b80d58848
templater: unify unwrapvalue() with _unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
38224
diff
changeset
|
798 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
|
799 try: |
37162
9ab3491f84c2
templater: extract unwrapinteger() function from evalinteger()
Yuya Nishihara <yuya@tcha.org>
parents:
37161
diff
changeset
|
800 return int(thing) |
28344
ac371d4c007f
templater: drop redundant type conversion when evaluating integer argument
Yuya Nishihara <yuya@tcha.org>
parents:
28343
diff
changeset
|
801 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
|
802 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
|
803 |
28348
ccedb17a5657
templater: factor out thin helper that evaluates argument as string
Yuya Nishihara <yuya@tcha.org>
parents:
28346
diff
changeset
|
804 def evalstring(context, mapping, arg): |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
805 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
|
806 |
28373
9a9dd71e882c
templater: make label() take unknown symbol as color literal
Yuya Nishihara <yuya@tcha.org>
parents:
28349
diff
changeset
|
807 def evalstringliteral(context, mapping, arg): |
9a9dd71e882c
templater: make label() take unknown symbol as color literal
Yuya Nishihara <yuya@tcha.org>
parents:
28349
diff
changeset
|
808 """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
|
809 if it is unknown""" |
9a9dd71e882c
templater: make label() take unknown symbol as color literal
Yuya Nishihara <yuya@tcha.org>
parents:
28349
diff
changeset
|
810 func, data = arg |
9a9dd71e882c
templater: make label() take unknown symbol as color literal
Yuya Nishihara <yuya@tcha.org>
parents:
28349
diff
changeset
|
811 if func is runsymbol: |
9a9dd71e882c
templater: make label() take unknown symbol as color literal
Yuya Nishihara <yuya@tcha.org>
parents:
28349
diff
changeset
|
812 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
|
813 else: |
9a9dd71e882c
templater: make label() take unknown symbol as color literal
Yuya Nishihara <yuya@tcha.org>
parents:
28349
diff
changeset
|
814 thing = func(context, mapping, data) |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
815 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
|
816 |
37163
0fb28899e81a
templater: factor out unwrapastype() from evalastype()
Yuya Nishihara <yuya@tcha.org>
parents:
37162
diff
changeset
|
817 _unwrapfuncbytype = { |
38225
d48b80d58848
templater: unify unwrapvalue() with _unwrapvalue()
Yuya Nishihara <yuya@tcha.org>
parents:
38224
diff
changeset
|
818 None: unwrapvalue, |
37163
0fb28899e81a
templater: factor out unwrapastype() from evalastype()
Yuya Nishihara <yuya@tcha.org>
parents:
37162
diff
changeset
|
819 bytes: stringify, |
37227
9bcf096a2da2
templatefilters: declare input type as date where appropriate
Yuya Nishihara <yuya@tcha.org>
parents:
37226
diff
changeset
|
820 date: unwrapdate, |
37163
0fb28899e81a
templater: factor out unwrapastype() from evalastype()
Yuya Nishihara <yuya@tcha.org>
parents:
37162
diff
changeset
|
821 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
|
822 } |
ee0d74083a22
templater: store revisions as ints so min/max won't compare them as strings
Yuya Nishihara <yuya@tcha.org>
parents:
34536
diff
changeset
|
823 |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
824 def unwrapastype(context, mapping, thing, typ): |
37163
0fb28899e81a
templater: factor out unwrapastype() from evalastype()
Yuya Nishihara <yuya@tcha.org>
parents:
37162
diff
changeset
|
825 """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
|
826 try: |
37163
0fb28899e81a
templater: factor out unwrapastype() from evalastype()
Yuya Nishihara <yuya@tcha.org>
parents:
37162
diff
changeset
|
827 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
|
828 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
|
829 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
|
830 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
|
831 |
25002
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
832 def runinteger(context, mapping, data): |
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
833 return int(data) |
829faf8ab605
templater: tokenize decimal integer literal (issue4638) (BC)
Yuya Nishihara <yuya@tcha.org>
parents:
25001
diff
changeset
|
834 |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
835 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
|
836 return data |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
837 |
27939
7ed3a3c0cef1
templater: abort if infinite recursion detected while evaluation (issue4758)
Yuya Nishihara <yuya@tcha.org>
parents:
27892
diff
changeset
|
838 def _recursivesymbolblocker(key): |
38930
382b055cc358
templatekw: deprecate old-style template keyword function (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38449
diff
changeset
|
839 def showrecursion(context, mapping): |
27939
7ed3a3c0cef1
templater: abort if infinite recursion detected while evaluation (issue4758)
Yuya Nishihara <yuya@tcha.org>
parents:
27892
diff
changeset
|
840 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
|
841 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
|
842 return showrecursion |
7ed3a3c0cef1
templater: abort if infinite recursion detected while evaluation (issue4758)
Yuya Nishihara <yuya@tcha.org>
parents:
27892
diff
changeset
|
843 |
28373
9a9dd71e882c
templater: make label() take unknown symbol as color literal
Yuya Nishihara <yuya@tcha.org>
parents:
28349
diff
changeset
|
844 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
|
845 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
|
846 if v is None: |
27939
7ed3a3c0cef1
templater: abort if infinite recursion detected while evaluation (issue4758)
Yuya Nishihara <yuya@tcha.org>
parents:
27892
diff
changeset
|
847 # 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
|
848 # 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
|
849 safemapping = mapping.copy() |
7ed3a3c0cef1
templater: abort if infinite recursion detected while evaluation (issue4758)
Yuya Nishihara <yuya@tcha.org>
parents:
27892
diff
changeset
|
850 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
|
851 try: |
27939
7ed3a3c0cef1
templater: abort if infinite recursion detected while evaluation (issue4758)
Yuya Nishihara <yuya@tcha.org>
parents:
27892
diff
changeset
|
852 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
|
853 except TemplateNotFound: |
28373
9a9dd71e882c
templater: make label() take unknown symbol as color literal
Yuya Nishihara <yuya@tcha.org>
parents:
28349
diff
changeset
|
854 v = default |
36445
e8d37838f5df
templatekw: add 'requires' flag to switch to exception-safe interface
Yuya Nishihara <yuya@tcha.org>
parents:
36444
diff
changeset
|
855 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
|
856 # 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
|
857 # (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
|
858 # can be removed.) |
39582
28f974d83c0a
templater: remove unused context argument from most resourcemapper functions
Yuya Nishihara <yuya@tcha.org>
parents:
39368
diff
changeset
|
859 props = {k: context._resources.lookup(mapping, k) |
37073
44757e6dad93
templater: introduce resourcemapper class
Yuya Nishihara <yuya@tcha.org>
parents:
37070
diff
changeset
|
860 for k in context._resources.knownkeys()} |
37070
1101d6747d2d
templater: drop 'templ' from resources dict
Yuya Nishihara <yuya@tcha.org>
parents:
37068
diff
changeset
|
861 # pass context to _showcompatlist() through templatekw._showlist() |
1101d6747d2d
templater: drop 'templ' from resources dict
Yuya Nishihara <yuya@tcha.org>
parents:
37068
diff
changeset
|
862 props['templ'] = context |
35468
32c278eb876f
templater: keep default resources per template engine (API)
Yuya Nishihara <yuya@tcha.org>
parents:
35467
diff
changeset
|
863 props.update(mapping) |
38930
382b055cc358
templatekw: deprecate old-style template keyword function (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38449
diff
changeset
|
864 ui = props.get('ui') |
382b055cc358
templatekw: deprecate old-style template keyword function (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38449
diff
changeset
|
865 if ui: |
382b055cc358
templatekw: deprecate old-style template keyword function (API)
Yuya Nishihara <yuya@tcha.org>
parents:
38449
diff
changeset
|
866 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
|
867 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
|
868 if callable(v): |
e8d37838f5df
templatekw: add 'requires' flag to switch to exception-safe interface
Yuya Nishihara <yuya@tcha.org>
parents:
36444
diff
changeset
|
869 # new templatekw |
e8d37838f5df
templatekw: add 'requires' flag to switch to exception-safe interface
Yuya Nishihara <yuya@tcha.org>
parents:
36444
diff
changeset
|
870 try: |
e8d37838f5df
templatekw: add 'requires' flag to switch to exception-safe interface
Yuya Nishihara <yuya@tcha.org>
parents:
36444
diff
changeset
|
871 return v(context, mapping) |
e8d37838f5df
templatekw: add 'requires' flag to switch to exception-safe interface
Yuya Nishihara <yuya@tcha.org>
parents:
36444
diff
changeset
|
872 except ResourceUnavailable: |
e8d37838f5df
templatekw: add 'requires' flag to switch to exception-safe interface
Yuya Nishihara <yuya@tcha.org>
parents:
36444
diff
changeset
|
873 # 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
|
874 return None |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
875 return v |
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
876 |
25595
a7dd6692e5cb
templater: move runtemplate function out of buildmap/runmap pair
Yuya Nishihara <yuya@tcha.org>
parents:
25580
diff
changeset
|
877 def runtemplate(context, mapping, template): |
34326
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
878 for arg in template: |
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
879 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
|
880 |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
881 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
|
882 arg, filt = data |
37222
54355c243042
templatefilters: allow declaration of input data type
Yuya Nishihara <yuya@tcha.org>
parents:
37163
diff
changeset
|
883 thing = evalrawexp(context, mapping, arg) |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
884 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
|
885 try: |
37272
7d3bc1d4e871
templater: pass (context, mapping) down to unwraphybrid()
Yuya Nishihara <yuya@tcha.org>
parents:
37231
diff
changeset
|
886 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
|
887 return filt(thing) |
37226
920589f52be9
templater: attach hint to input-type error of runfilter()
Yuya Nishihara <yuya@tcha.org>
parents:
37225
diff
changeset
|
888 except error.ParseError as e: |
920589f52be9
templater: attach hint to input-type error of runfilter()
Yuya Nishihara <yuya@tcha.org>
parents:
37225
diff
changeset
|
889 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
|
890 |
920589f52be9
templater: attach hint to input-type error of runfilter()
Yuya Nishihara <yuya@tcha.org>
parents:
37225
diff
changeset
|
891 def _formatfiltererror(arg, filt): |
920589f52be9
templater: attach hint to input-type error of runfilter()
Yuya Nishihara <yuya@tcha.org>
parents:
37225
diff
changeset
|
892 fn = pycompat.sysbytes(filt.__name__) |
920589f52be9
templater: attach hint to input-type error of runfilter()
Yuya Nishihara <yuya@tcha.org>
parents:
37225
diff
changeset
|
893 sym = findsymbolicname(arg) |
920589f52be9
templater: attach hint to input-type error of runfilter()
Yuya Nishihara <yuya@tcha.org>
parents:
37225
diff
changeset
|
894 if not sym: |
920589f52be9
templater: attach hint to input-type error of runfilter()
Yuya Nishihara <yuya@tcha.org>
parents:
37225
diff
changeset
|
895 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
|
896 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
|
897 % (fn, sym)) |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
898 |
37399
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
899 def _iteroverlaymaps(context, origmapping, newmappings): |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
900 """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
|
901 of partial mappings to override the original""" |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
902 for i, nm in enumerate(newmappings): |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
903 lm = context.overlaymap(origmapping, nm) |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
904 lm['index'] = i |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
905 yield lm |
0b64416224d9
templater: add class representing a nested mappings
Yuya Nishihara <yuya@tcha.org>
parents:
37329
diff
changeset
|
906 |
38271
4b0f39e7406e
templater: show slightly better hint on map operation error
Yuya Nishihara <yuya@tcha.org>
parents:
38270
diff
changeset
|
907 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
|
908 try: |
4b0f39e7406e
templater: show slightly better hint on map operation error
Yuya Nishihara <yuya@tcha.org>
parents:
38270
diff
changeset
|
909 diter = d.itermaps(context) |
4b0f39e7406e
templater: show slightly better hint on map operation error
Yuya Nishihara <yuya@tcha.org>
parents:
38270
diff
changeset
|
910 except error.ParseError as err: |
4b0f39e7406e
templater: show slightly better hint on map operation error
Yuya Nishihara <yuya@tcha.org>
parents:
38270
diff
changeset
|
911 sym = findsymbolicname(darg) |
4b0f39e7406e
templater: show slightly better hint on map operation error
Yuya Nishihara <yuya@tcha.org>
parents:
38270
diff
changeset
|
912 if not sym: |
4b0f39e7406e
templater: show slightly better hint on map operation error
Yuya Nishihara <yuya@tcha.org>
parents:
38270
diff
changeset
|
913 raise |
4b0f39e7406e
templater: show slightly better hint on map operation error
Yuya Nishihara <yuya@tcha.org>
parents:
38270
diff
changeset
|
914 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
|
915 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
|
916 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
|
917 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
|
918 |
13176
895f54a79c6e
templater: use the parser.py parser to extend the templater syntax
Matt Mackall <mpm@selenic.com>
parents:
13175
diff
changeset
|
919 def runmap(context, mapping, data): |
34326
e60c601953d7
templater: extract helper to just evaluate template expression
Yuya Nishihara <yuya@tcha.org>
parents:
34325
diff
changeset
|
920 darg, targ = data |
38229
7701c2d4a438
templater: always map over a wrapped object
Yuya Nishihara <yuya@tcha.org>
parents:
38228
diff
changeset
|
921 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
|
922 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
|
923 |
34535
78590585c0db
templater: add dot operator to easily access a sub item
Yuya Nishihara <yuya@tcha.org>
parents:
34534
diff
changeset
|
924 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
|
925 darg, memb = data |
38240
c2456a7726c1
templater: do dict lookup over a wrapped object
Yuya Nishihara <yuya@tcha.org>
parents:
38229
diff
changeset
|
926 d = evalwrapped(context, mapping, darg) |
38284
e72697893c93
templater: promote tomap() to an interface type
Yuya Nishihara <yuya@tcha.org>
parents:
38283
diff
changeset
|
927 if isinstance(d, mappable): |
e72697893c93
templater: promote tomap() to an interface type
Yuya Nishihara <yuya@tcha.org>
parents:
38283
diff
changeset
|
928 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
|
929 return runsymbol(context, lm, memb) |
38241
ad06a4264daf
templater: add try-except stub to runmember()
Yuya Nishihara <yuya@tcha.org>
parents:
38240
diff
changeset
|
930 try: |
38243
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
931 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
|
932 except error.ParseError as err: |
38241
ad06a4264daf
templater: add try-except stub to runmember()
Yuya Nishihara <yuya@tcha.org>
parents:
38240
diff
changeset
|
933 sym = findsymbolicname(darg) |
38243
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
934 if not sym: |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
935 raise |
06d11cd90516
templater: promote getmember() to an interface of wrapped types
Yuya Nishihara <yuya@tcha.org>
parents:
38242
diff
changeset
|
936 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
|
937 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
|
938 |
30115
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
939 def runnegate(context, mapping, data): |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
940 data = evalinteger(context, mapping, data, |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
941 _('negation needs an integer argument')) |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
942 return -data |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
943 |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
944 def runarithmetic(context, mapping, data): |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
945 func, left, right = data |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
946 left = evalinteger(context, mapping, left, |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
947 _('arithmetic only defined on integers')) |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
948 right = evalinteger(context, mapping, right, |
8e42dfde93d1
templater: provide arithmetic operations on integers
Simon Farnsworth <simonfar@fb.com>
parents:
30083
diff
changeset
|
949 _('arithmetic only defined on integers')) |
30116
1c01fa29630f
templater: handle division by zero in arithmetic
Simon Farnsworth <simonfar@fb.com>
parents:
30115
diff
changeset
|
950 try: |
1c01fa29630f
templater: handle division by zero in arithmetic
Simon Farnsworth <simonfar@fb.com>
parents:
30115
diff
changeset
|
951 return func(left, right) |
1c01fa29630f
templater: handle division by zero in arithmetic
Simon Farnsworth <simonfar@fb.com>
parents:
30115
diff
changeset
|
952 except ZeroDivisionError: |
1c01fa29630f
templater: handle division by zero in arithmetic
Simon Farnsworth <simonfar@fb.com>
parents:
30115
diff
changeset
|
953 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
|
954 |
37325
41a5d815d2c1
templater: factor out generator of join()-ed items
Yuya Nishihara <yuya@tcha.org>
parents:
37324
diff
changeset
|
955 def joinitems(itemiter, sep): |
41a5d815d2c1
templater: factor out generator of join()-ed items
Yuya Nishihara <yuya@tcha.org>
parents:
37324
diff
changeset
|
956 """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
|
957 first = True |
41a5d815d2c1
templater: factor out generator of join()-ed items
Yuya Nishihara <yuya@tcha.org>
parents:
37324
diff
changeset
|
958 for x in itemiter: |
41a5d815d2c1
templater: factor out generator of join()-ed items
Yuya Nishihara <yuya@tcha.org>
parents:
37324
diff
changeset
|
959 if first: |
41a5d815d2c1
templater: factor out generator of join()-ed items
Yuya Nishihara <yuya@tcha.org>
parents:
37324
diff
changeset
|
960 first = False |
37326
9cd88dd3bf64
templater: micro-optimize join() with empty separator
Yuya Nishihara <yuya@tcha.org>
parents:
37325
diff
changeset
|
961 elif sep: |
37325
41a5d815d2c1
templater: factor out generator of join()-ed items
Yuya Nishihara <yuya@tcha.org>
parents:
37324
diff
changeset
|
962 yield sep |
41a5d815d2c1
templater: factor out generator of join()-ed items
Yuya Nishihara <yuya@tcha.org>
parents:
37324
diff
changeset
|
963 yield x |