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