1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
overview: |
Rationale: this special notation was introduced specifically to allow the
dynamic loading of partials. The main advantage that this notation
offers is to allow dynamic loading of partials, which is particularly useful
in cases where polymorphic data needs to be rendered, or in cases where
a child template is shared by multiple parent templates; cases which
otherwise would be possible to render only by using either complex (and
optional) features such as lambdas, or by using solutions that are inefficient
both in terms of space and in terms of computational efficiency, such as:
overloading the template with if blocks or preprocessing the template.
Dynamic Names are a special notation to dynamically determine a tag's content.
Dynamic Names MUST be a non-whitespace character sequence NOT containing
the current closing delimiter. A Dynamic Name consists of an asterisk,
followed by a dotted name. The latter follows the same notation as in an
Interpolation tag.
This tag's dotted name, which is the Dynamic Name excluding the
leading asterisk, references a key in the context whose value will be used in
place of the Dynamic Name itself as content of the tag. The dotted name
resolution produces the same value as an Interpolation tag and does not affect
the context for further processing.
Set Delimiter tags MUST NOT affect the resolution of a Dynamic Name. The
Dynamic Names MUST be resolved against the context stack local to the tag.
Failed resolution of the dynamic name SHOULD result in nothing being rendered.
Engines that implement Dynamic Names MUST support their use in Partial tags.
In engines that also implement the optional inheritance spec, Dynamic Names
inside Parent tags should be supported as well. Dynamic Names cannot be
resolved more than once (Dynamic Names cannot be nested).
tests:
- name: Basic Behavior - Partial
desc: The asterisk operator is used for dynamic partials.
data: { dynamic: 'content' }
template: '"{{>*dynamic}}"'
partials: { content: 'Hello, world!' }
expected: '"Hello, world!"'
- name: Basic Behavior - Name Resolution
desc: |
The asterisk is not part of the name that will be resolved in the contex.
data: { dynamic: 'content', '*dynamic': 'wrong' }
template: '"{{>*dynamic}}"'
partials: { content: 'Hello, world!', wrong: 'Invisible' }
expected: '"Hello, world!"'
- name: Context Misses - Partial
desc: Failed context lookups should be considered falsey.
data: { }
template: '"{{>*missing}}"'
partials: { missing: 'Hello, world!' }
expected: '""'
- name: Failed Lookup - Partial
desc: The empty string should be used when the named partial is not found.
data: { dynamic: 'content' }
template: '"{{>*dynamic}}"'
partials: { foobar: 'Hello, world!' }
expected: '""'
- name: Context
desc: The dynamic partial should operate within the current context.
data: { text: 'Hello, world!', example: 'partial' }
template: '"{{>*example}}"'
partials: { partial: '*{{text}}*' }
expected: '"*Hello, world!*"'
- name: Dotted Names
desc: The dynamic partial should operate within the current context.
data: { text: 'Hello, world!', foo: { bar: { baz: 'partial' } } }
template: '"{{>*foo.bar.baz}}"'
partials: { partial: '*{{text}}*' }
expected: '"*Hello, world!*"'
- name: Dotted Names - Operator Precedence
desc: The dynamic partial should operate within the current context.
data:
text: 'Hello, world!'
foo: 'test'
test:
bar:
baz: 'partial'
template: '"{{>*foo.bar.baz}}"'
partials: { partial: '*{{text}}*' }
expected: '""'
- name: Dotted Names - Failed Lookup
desc: The dynamic partial should operate within the current context.
data:
foo:
text: 'Hello, world!'
bar:
baz: 'partial'
template: '"{{>*foo.bar.baz}}"'
partials: { partial: '*{{text}}*' }
expected: '"**"'
- name: Dotted names - Context Stacking
desc: Dotted names should not push a new frame on the context stack.
data:
section1: { value: 'section1' }
section2: { dynamic: 'partial', value: 'section2' }
template: "{{#section1}}{{>*section2.dynamic}}{{/section1}}"
partials:
partial: '"{{value}}"'
expected: '"section1"'
- name: Dotted names - Context Stacking Under Repetition
desc: Dotted names should not push a new frame on the context stack.
data:
value: 'test'
section1: [ 1, 2 ]
section2: { dynamic: 'partial', value: 'section2' }
template: "{{#section1}}{{>*section2.dynamic}}{{/section1}}"
partials:
partial: "{{value}}"
expected: "testtest"
- name: Dotted names - Context Stacking Failed Lookup
desc: Dotted names should resolve against the proper context stack.
data:
section1: [ 1, 2 ]
section2: { dynamic: 'partial', value: 'section2' }
template: "{{#section1}}{{>*section2.dynamic}}{{/section1}}"
partials:
partial: '"{{value}}"'
expected: '""""'
- name: Recursion
desc: Dynamic partials should properly recurse.
data:
template: 'node'
content: 'X'
nodes: [ { content: 'Y', nodes: [] } ]
template: '{{>*template}}'
partials: { node: '{{content}}<{{#nodes}}{{>*template}}{{/nodes}}>' }
expected: 'X<Y<>>'
# Whitespace Sensitivity
- name: Surrounding Whitespace
desc: |
A dynamic partial should not alter surrounding whitespace; any
whitespace preceding the tag should be treated as indentation while any
whitespace succeding the tag should be left untouched.
data: { partial: 'foobar' }
template: '| {{>*partial}} |'
partials: { foobar: "\t|\t" }
expected: "| \t|\t |"
- name: Inline Indentation
desc: |
Whitespace should be left untouched: whitespaces preceding the tag
should be treated as indentation.
data: { dynamic: 'partial', data: '|' }
template: " {{data}} {{>*dynamic}}\n"
partials: { partial: ">\n>" }
expected: " | >\n>\n"
- name: Standalone Line Endings
desc: '"\r\n" should be considered a newline for standalone tags.'
data: { dynamic: 'partial' }
template: "|\r\n{{>*dynamic}}\r\n|"
partials: { partial: ">" }
expected: "|\r\n>|"
- name: Standalone Without Previous Line
desc: Standalone tags should not require a newline to precede them.
data: { dynamic: 'partial' }
template: " {{>*dynamic}}\n>"
partials: { partial: ">\n>"}
expected: " >\n >>"
- name: Standalone Without Newline
desc: Standalone tags should not require a newline to follow them.
data: { dynamic: 'partial' }
template: ">\n {{>*dynamic}}"
partials: { partial: ">\n>" }
expected: ">\n >\n >"
- name: Standalone Indentation
desc: Each line of the partial should be indented before rendering.
data: { dynamic: 'partial', content: "<\n->" }
template: |
\
{{>*dynamic}}
/
partials:
partial: |
|
{{{content}}}
|
expected: |
\
|
<
->
|
/
# Whitespace Insensitivity
- name: Padding Whitespace
desc: Superfluous in-tag whitespace should be ignored.
data: { dynamic: 'partial', boolean: true }
template: "|{{> * dynamic }}|"
partials: { partial: "[]" }
expected: '|[]|'
|
