Mercurial > genshi > mirror
annotate doc/xml-templates.txt @ 737:ca72e3dc443d trunk
Implement the `__html__` protocol as suggested in #202. This would allow Genshi to be used in combination with other markup generating tools, as long as they support the same protocol.
author | cmlenz |
---|---|
date | Thu, 05 Jun 2008 17:00:15 +0000 |
parents | 85ff66a8f453 |
children | 25d6cd05746c |
rev | line source |
---|---|
226 | 1 .. -*- mode: rst; encoding: utf-8 -*- |
2 | |
3 ============================ | |
230 | 4 Genshi XML Template Language |
226 | 5 ============================ |
6 | |
241
4d81439bc097
* Added basic documentation for the text-based template language.
cmlenz
parents:
237
diff
changeset
|
7 Genshi provides a XML-based template language that is heavily inspired by Kid_, |
4d81439bc097
* Added basic documentation for the text-based template language.
cmlenz
parents:
237
diff
changeset
|
8 which in turn was inspired by a number of existing template languages, namely |
4d81439bc097
* Added basic documentation for the text-based template language.
cmlenz
parents:
237
diff
changeset
|
9 XSLT_, TAL_, and PHP_. |
226 | 10 |
11 .. _kid: http://kid-templating.org/ | |
12 .. _python: http://www.python.org/ | |
13 .. _xslt: http://www.w3.org/TR/xslt | |
14 .. _tal: http://www.zope.org/Wikis/DevSite/Projects/ZPT/TAL | |
15 .. _php: http://www.php.net/ | |
16 | |
17 This document describes the template language and will be most useful as | |
241
4d81439bc097
* Added basic documentation for the text-based template language.
cmlenz
parents:
237
diff
changeset
|
18 reference to those developing Genshi XML templates. Templates are XML files of |
4d81439bc097
* Added basic documentation for the text-based template language.
cmlenz
parents:
237
diff
changeset
|
19 some kind (such as XHTML) that include processing directives_ (elements or |
226 | 20 attributes identified by a separate namespace) that affect how the template is |
442
97544725bb7f
Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option.
cmlenz
parents:
429
diff
changeset
|
21 rendered, and template expressions that are dynamically substituted by |
226 | 22 variable data. |
23 | |
442
97544725bb7f
Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option.
cmlenz
parents:
429
diff
changeset
|
24 See `Genshi Templating Basics <templates.html>`_ for general information on |
97544725bb7f
Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option.
cmlenz
parents:
429
diff
changeset
|
25 embedding Python code in templates. |
97544725bb7f
Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option.
cmlenz
parents:
429
diff
changeset
|
26 |
226 | 27 |
28 .. contents:: Contents | |
29 :depth: 3 | |
30 .. sectnum:: | |
31 | |
32 | |
33 .. _`directives`: | |
34 | |
35 ------------------- | |
36 Template Directives | |
37 ------------------- | |
38 | |
39 Directives are elements and/or attributes in the template that are identified | |
230 | 40 by the namespace ``http://genshi.edgewall.org/``. They can affect how the |
41 template is rendered in a number of ways: Genshi provides directives for | |
226 | 42 conditionals and looping, among others. |
43 | |
394 | 44 To use directives in a template, the namespace must be declared, which is |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
45 usually done on the root element: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
46 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
47 .. code-block:: genshi |
226 | 48 |
49 <html xmlns="http://www.w3.org/1999/xhtml" | |
230 | 50 xmlns:py="http://genshi.edgewall.org/" |
226 | 51 lang="en"> |
52 ... | |
53 </html> | |
54 | |
55 In this example, the default namespace is set to the XHTML namespace, and the | |
230 | 56 namespace for Genshi directives is bound to the prefix “py”. |
226 | 57 |
58 All directives can be applied as attributes, and some can also be used as | |
59 elements. The ``if`` directives for conditionals, for example, can be used in | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
60 both ways: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
61 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
62 .. code-block:: genshi |
226 | 63 |
64 <html xmlns="http://www.w3.org/1999/xhtml" | |
230 | 65 xmlns:py="http://genshi.edgewall.org/" |
226 | 66 lang="en"> |
67 ... | |
68 <div py:if="foo"> | |
69 <p>Bar</p> | |
70 </div> | |
71 ... | |
72 </html> | |
73 | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
74 This is basically equivalent to the following: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
75 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
76 .. code-block:: genshi |
226 | 77 |
78 <html xmlns="http://www.w3.org/1999/xhtml" | |
230 | 79 xmlns:py="http://genshi.edgewall.org/" |
226 | 80 lang="en"> |
81 ... | |
82 <py:if test="foo"> | |
83 <div> | |
84 <p>Bar</p> | |
85 </div> | |
86 </py:if> | |
87 ... | |
88 </html> | |
89 | |
90 The rationale behind the second form is that directives do not always map | |
91 naturally to elements in the template. In such cases, the ``py:strip`` | |
92 directive can be used to strip off the unwanted element, or the directive can | |
93 simply be used as an element. | |
94 | |
95 | |
237 | 96 Conditional Sections |
226 | 97 ==================== |
98 | |
235 | 99 .. _`py:if`: |
226 | 100 |
235 | 101 ``py:if`` |
237 | 102 --------- |
226 | 103 |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
104 The element is only rendered if the expression evaluates to a truth value: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
105 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
106 .. code-block:: genshi |
226 | 107 |
235 | 108 <div> |
109 <b py:if="foo">${bar}</b> | |
110 </div> | |
226 | 111 |
235 | 112 Given the data ``foo=True`` and ``bar='Hello'`` in the template context, this |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
113 would produce: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
114 |
612
3d2909fe1dda
Using `html` code-blocks for examples isn't so nice when viewing the docs over Trac, so change them to `xml`.
cmlenz
parents:
610
diff
changeset
|
115 .. code-block:: xml |
235 | 116 |
117 <div> | |
118 <b>Hello</b> | |
119 </div> | |
120 | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
121 This directive can also be used as an element: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
122 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
123 .. code-block:: genshi |
235 | 124 |
125 <div> | |
126 <py:if test="foo"> | |
127 <b>${bar}</b> | |
128 </py:if> | |
129 </div> | |
226 | 130 |
131 .. _`py:choose`: | |
132 .. _`py:when`: | |
133 .. _`py:otherwise`: | |
134 | |
237 | 135 ``py:choose`` |
136 ------------- | |
226 | 137 |
237 | 138 The ``py:choose`` directive, in combination with the directives ``py:when`` |
404 | 139 and ``py:otherwise`` provides advanced conditional processing for rendering one |
226 | 140 of several alternatives. The first matching ``py:when`` branch is rendered, or, |
404 | 141 if no ``py:when`` branch matches, the ``py:otherwise`` branch is rendered. |
226 | 142 |
143 If the ``py:choose`` directive is empty the nested ``py:when`` directives will | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
144 be tested for truth: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
145 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
146 .. code-block:: genshi |
226 | 147 |
148 <div py:choose=""> | |
149 <span py:when="0 == 1">0</span> | |
150 <span py:when="1 == 1">1</span> | |
151 <span py:otherwise="">2</span> | |
152 </div> | |
153 | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
154 This would produce the following output: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
155 |
612
3d2909fe1dda
Using `html` code-blocks for examples isn't so nice when viewing the docs over Trac, so change them to `xml`.
cmlenz
parents:
610
diff
changeset
|
156 .. code-block:: xml |
226 | 157 |
158 <div> | |
159 <span>1</span> | |
160 </div> | |
161 | |
162 If the ``py:choose`` directive contains an expression the nested ``py:when`` | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
163 directives will be tested for equality to the parent ``py:choose`` value: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
164 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
165 .. code-block:: genshi |
226 | 166 |
167 <div py:choose="1"> | |
168 <span py:when="0">0</span> | |
169 <span py:when="1">1</span> | |
170 <span py:otherwise="">2</span> | |
171 </div> | |
172 | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
173 This would produce the following output: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
174 |
612
3d2909fe1dda
Using `html` code-blocks for examples isn't so nice when viewing the docs over Trac, so change them to `xml`.
cmlenz
parents:
610
diff
changeset
|
175 .. code-block:: xml |
226 | 176 |
177 <div> | |
178 <span>1</span> | |
179 </div> | |
180 | |
726
85ff66a8f453
Note that py:choose and friends may be used as elements.
athomas
parents:
700
diff
changeset
|
181 These directives can also be used as elements: |
85ff66a8f453
Note that py:choose and friends may be used as elements.
athomas
parents:
700
diff
changeset
|
182 |
85ff66a8f453
Note that py:choose and friends may be used as elements.
athomas
parents:
700
diff
changeset
|
183 .. code-block:: genshi |
85ff66a8f453
Note that py:choose and friends may be used as elements.
athomas
parents:
700
diff
changeset
|
184 |
85ff66a8f453
Note that py:choose and friends may be used as elements.
athomas
parents:
700
diff
changeset
|
185 <py:choose test="1"> |
85ff66a8f453
Note that py:choose and friends may be used as elements.
athomas
parents:
700
diff
changeset
|
186 <py:when test="0">0</py:when> |
85ff66a8f453
Note that py:choose and friends may be used as elements.
athomas
parents:
700
diff
changeset
|
187 <py:when test="1">1</py:when> |
85ff66a8f453
Note that py:choose and friends may be used as elements.
athomas
parents:
700
diff
changeset
|
188 <py:otherwise>2</py:otherwise> |
85ff66a8f453
Note that py:choose and friends may be used as elements.
athomas
parents:
700
diff
changeset
|
189 </py:choose> |
226 | 190 |
235 | 191 Looping |
237 | 192 ======= |
226 | 193 |
235 | 194 .. _`py:for`: |
226 | 195 |
235 | 196 ``py:for`` |
237 | 197 ---------- |
235 | 198 |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
199 The element is repeated for every item in an iterable: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
200 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
201 .. code-block:: genshi |
226 | 202 |
203 <ul> | |
235 | 204 <li py:for="item in items">${item}</li> |
226 | 205 </ul> |
206 | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
207 Given ``items=[1, 2, 3]`` in the context data, this would produce: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
208 |
612
3d2909fe1dda
Using `html` code-blocks for examples isn't so nice when viewing the docs over Trac, so change them to `xml`.
cmlenz
parents:
610
diff
changeset
|
209 .. code-block:: xml |
226 | 210 |
211 <ul> | |
235 | 212 <li>1</li><li>2</li><li>3</li> |
226 | 213 </ul> |
214 | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
215 This directive can also be used as an element: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
216 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
217 .. code-block:: genshi |
226 | 218 |
235 | 219 <ul> |
220 <py:for each="item in items"> | |
221 <li>${item}</li> | |
222 </py:for> | |
223 </ul> | |
224 | |
225 | |
226 Snippet Reuse | |
237 | 227 ============= |
226 | 228 |
229 .. _`py:def`: | |
230 .. _`macros`: | |
231 | |
232 ``py:def`` | |
237 | 233 ---------- |
226 | 234 |
235 The ``py:def`` directive can be used to create macros, i.e. snippets of | |
236 template code that have a name and optionally some parameters, and that can be | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
237 inserted in other places: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
238 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
239 .. code-block:: genshi |
226 | 240 |
241 <div> | |
242 <p py:def="greeting(name)" class="greeting"> | |
243 Hello, ${name}! | |
244 </p> | |
245 ${greeting('world')} | |
246 ${greeting('everyone else')} | |
247 </div> | |
248 | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
249 The above would be rendered to: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
250 |
612
3d2909fe1dda
Using `html` code-blocks for examples isn't so nice when viewing the docs over Trac, so change them to `xml`.
cmlenz
parents:
610
diff
changeset
|
251 .. code-block:: xml |
226 | 252 |
253 <div> | |
254 <p class="greeting"> | |
255 Hello, world! | |
256 </p> | |
257 <p class="greeting"> | |
258 Hello, everyone else! | |
259 </p> | |
260 </div> | |
261 | |
394 | 262 If a macro doesn't require parameters, it can be defined without the |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
263 parenthesis. For example: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
264 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
265 .. code-block:: genshi |
226 | 266 |
267 <div> | |
268 <p py:def="greeting" class="greeting"> | |
269 Hello, world! | |
270 </p> | |
394 | 271 ${greeting()} |
226 | 272 </div> |
273 | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
274 The above would be rendered to: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
275 |
612
3d2909fe1dda
Using `html` code-blocks for examples isn't so nice when viewing the docs over Trac, so change them to `xml`.
cmlenz
parents:
610
diff
changeset
|
276 .. code-block:: xml |
226 | 277 |
278 <div> | |
279 <p class="greeting"> | |
280 Hello, world! | |
281 </p> | |
282 </div> | |
283 | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
284 This directive can also be used as an element: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
285 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
286 .. code-block:: genshi |
226 | 287 |
288 <div> | |
289 <py:def function="greeting(name)"> | |
290 <p class="greeting">Hello, ${name}!</p> | |
291 </py:def> | |
292 </div> | |
293 | |
294 | |
235 | 295 .. _Match Templates: |
226 | 296 .. _`py:match`: |
297 | |
298 ``py:match`` | |
237 | 299 ------------ |
226 | 300 |
301 This directive defines a *match template*: given an XPath expression, it | |
302 replaces any element in the template that matches the expression with its own | |
303 content. | |
304 | |
305 For example, the match template defined in the following template matches any | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
306 element with the tag name “greeting”: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
307 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
308 .. code-block:: genshi |
226 | 309 |
310 <div> | |
311 <span py:match="greeting"> | |
312 Hello ${select('@name')} | |
313 </span> | |
314 <greeting name="Dude" /> | |
315 </div> | |
316 | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
317 This would result in the following output: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
318 |
612
3d2909fe1dda
Using `html` code-blocks for examples isn't so nice when viewing the docs over Trac, so change them to `xml`.
cmlenz
parents:
610
diff
changeset
|
319 .. code-block:: xml |
226 | 320 |
321 <div> | |
322 <span> | |
323 Hello Dude | |
324 </span> | |
325 </div> | |
326 | |
327 Inside the body of a ``py:match`` directive, the ``select(path)`` function is | |
328 made available so that parts or all of the original element can be incorporated | |
451 | 329 in the output of the match template. See `Using XPath`_ for more information |
330 about this function. | |
331 | |
332 .. _`Using XPath`: streams.html#using-xpath | |
226 | 333 |
694
07e3f6f0ef57
Match templates are now applied in a more controlled fashion: in the order they are declared in the template source, all match templates up to (and including) the matching template itself are applied to the matched content, whereas the match templates declared after the matching template are only applied to the generated content. Fixes #186. Many thanks to Matt Chaput for reporting the problem and providing a test case.
cmlenz
parents:
657
diff
changeset
|
334 Match templates are applied both to the original markup as well to the |
07e3f6f0ef57
Match templates are now applied in a more controlled fashion: in the order they are declared in the template source, all match templates up to (and including) the matching template itself are applied to the matched content, whereas the match templates declared after the matching template are only applied to the generated content. Fixes #186. Many thanks to Matt Chaput for reporting the problem and providing a test case.
cmlenz
parents:
657
diff
changeset
|
335 generated markup. The order in which they are applied depends on the order |
07e3f6f0ef57
Match templates are now applied in a more controlled fashion: in the order they are declared in the template source, all match templates up to (and including) the matching template itself are applied to the matched content, whereas the match templates declared after the matching template are only applied to the generated content. Fixes #186. Many thanks to Matt Chaput for reporting the problem and providing a test case.
cmlenz
parents:
657
diff
changeset
|
336 they are declared in the template source: a match template defined after |
07e3f6f0ef57
Match templates are now applied in a more controlled fashion: in the order they are declared in the template source, all match templates up to (and including) the matching template itself are applied to the matched content, whereas the match templates declared after the matching template are only applied to the generated content. Fixes #186. Many thanks to Matt Chaput for reporting the problem and providing a test case.
cmlenz
parents:
657
diff
changeset
|
337 another match template is applied to the output generated by the first match |
07e3f6f0ef57
Match templates are now applied in a more controlled fashion: in the order they are declared in the template source, all match templates up to (and including) the matching template itself are applied to the matched content, whereas the match templates declared after the matching template are only applied to the generated content. Fixes #186. Many thanks to Matt Chaput for reporting the problem and providing a test case.
cmlenz
parents:
657
diff
changeset
|
338 template. The match templates basically form a pipeline. |
07e3f6f0ef57
Match templates are now applied in a more controlled fashion: in the order they are declared in the template source, all match templates up to (and including) the matching template itself are applied to the matched content, whereas the match templates declared after the matching template are only applied to the generated content. Fixes #186. Many thanks to Matt Chaput for reporting the problem and providing a test case.
cmlenz
parents:
657
diff
changeset
|
339 |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
340 This directive can also be used as an element: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
341 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
342 .. code-block:: genshi |
226 | 343 |
344 <div> | |
345 <py:match path="greeting"> | |
346 <span>Hello ${select('@name')}</span> | |
347 </py:match> | |
348 <greeting name="Dude" /> | |
349 </div> | |
350 | |
602 | 351 When used this way, the ``py:match`` directive can also be annotated with a |
352 couple of optimization hints. For example, the following informs the matching | |
353 engine that the match should only be applied once: | |
354 | |
355 .. code-block:: genshi | |
356 | |
357 <py:match path="body" once="true"> | |
358 <body py:attrs="select('@*')"> | |
359 <div id="header">...</div> | |
360 ${select("*|text()")} | |
361 <div id="footer">...</div> | |
362 </body> | |
363 </py:match> | |
364 | |
365 The following optimization hints are recognized: | |
366 | |
367 +---------------+-----------+-----------------------------------------------+ | |
368 | Attribute | Default | Description | | |
369 +===============+===========+===============================================+ | |
700
08f22328303d
Add option for unbuffered match template processing, which could cause excessive memory usage. Closes #190.
cmlenz
parents:
694
diff
changeset
|
370 | ``buffer`` | ``true`` | Whether the matched content should be | |
08f22328303d
Add option for unbuffered match template processing, which could cause excessive memory usage. Closes #190.
cmlenz
parents:
694
diff
changeset
|
371 | | | buffered in memory. Buffering can improve | |
08f22328303d
Add option for unbuffered match template processing, which could cause excessive memory usage. Closes #190.
cmlenz
parents:
694
diff
changeset
|
372 | | | performance a bit at the cost of needing more | |
08f22328303d
Add option for unbuffered match template processing, which could cause excessive memory usage. Closes #190.
cmlenz
parents:
694
diff
changeset
|
373 | | | memory during rendering. Buffering is | |
08f22328303d
Add option for unbuffered match template processing, which could cause excessive memory usage. Closes #190.
cmlenz
parents:
694
diff
changeset
|
374 | | | ''required'' for match templates that contain | |
08f22328303d
Add option for unbuffered match template processing, which could cause excessive memory usage. Closes #190.
cmlenz
parents:
694
diff
changeset
|
375 | | | more than one invocation of the ``select()`` | |
08f22328303d
Add option for unbuffered match template processing, which could cause excessive memory usage. Closes #190.
cmlenz
parents:
694
diff
changeset
|
376 | | | function. If there is only one call, and the | |
08f22328303d
Add option for unbuffered match template processing, which could cause excessive memory usage. Closes #190.
cmlenz
parents:
694
diff
changeset
|
377 | | | matched content can potentially be very long, | |
08f22328303d
Add option for unbuffered match template processing, which could cause excessive memory usage. Closes #190.
cmlenz
parents:
694
diff
changeset
|
378 | | | consider disabling buffering to avoid | |
08f22328303d
Add option for unbuffered match template processing, which could cause excessive memory usage. Closes #190.
cmlenz
parents:
694
diff
changeset
|
379 | | | excessive memory use. | |
08f22328303d
Add option for unbuffered match template processing, which could cause excessive memory usage. Closes #190.
cmlenz
parents:
694
diff
changeset
|
380 +---------------+-----------+-----------------------------------------------+ |
602 | 381 | ``once`` | ``false`` | Whether the engine should stop looking for | |
382 | | | more matching elements after the first match. | | |
383 | | | Use this on match templates that match | | |
384 | | | elements that can only occur once in the | | |
385 | | | stream, such as the ``<head>`` or ``<body>`` | | |
386 | | | elements in an HTML template, or elements | | |
387 | | | with a specific ID. | | |
388 +---------------+-----------+-----------------------------------------------+ | |
389 | ``recursive`` | ``true`` | Whether the match template should be applied | | |
390 | | | to its own output. Note that ``once`` implies | | |
391 | | | non-recursive behavior, so this attribute | | |
392 | | | only needs to be set for match templates that | | |
393 | | | don't also have ``once`` set. | | |
394 +---------------+-----------+-----------------------------------------------+ | |
395 | |
396 .. note:: The ``py:match`` optimization hints were added in the 0.5 release. In | |
397 earlier versions, the attributes have no effect. | |
398 | |
226 | 399 |
235 | 400 Variable Binding |
237 | 401 ================ |
226 | 402 |
403 .. _`with`: | |
404 | |
405 ``py:with`` | |
237 | 406 ----------- |
226 | 407 |
408 The ``py:with`` directive lets you assign expressions to variables, which can | |
409 be used to make expressions inside the directive less verbose and more | |
410 efficient. For example, if you need use the expression ``author.posts`` more | |
411 than once, and that actually results in a database query, assigning the results | |
412 to a variable using this directive would probably help. | |
413 | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
414 For example: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
415 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
416 .. code-block:: genshi |
226 | 417 |
418 <div> | |
419 <span py:with="y=7; z=x+10">$x $y $z</span> | |
420 </div> | |
421 | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
422 Given ``x=42`` in the context data, this would produce: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
423 |
612
3d2909fe1dda
Using `html` code-blocks for examples isn't so nice when viewing the docs over Trac, so change them to `xml`.
cmlenz
parents:
610
diff
changeset
|
424 .. code-block:: xml |
226 | 425 |
426 <div> | |
427 <span>42 7 52</span> | |
428 </div> | |
429 | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
430 This directive can also be used as an element: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
431 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
432 .. code-block:: genshi |
226 | 433 |
434 <div> | |
435 <py:with vars="y=7; z=x+10">$x $y $z</py:with> | |
436 </div> | |
437 | |
438 Note that if a variable of the same name already existed outside of the scope | |
439 of the ``py:with`` directive, it will **not** be overwritten. Instead, it | |
440 will have the same value it had prior to the ``py:with`` assignment. | |
230 | 441 Effectively, this means that variables are immutable in Genshi. |
226 | 442 |
443 | |
235 | 444 Structure Manipulation |
237 | 445 ====================== |
235 | 446 |
447 .. _`py:attrs`: | |
448 | |
449 ``py:attrs`` | |
237 | 450 ------------ |
235 | 451 |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
452 This directive adds, modifies or removes attributes from the element: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
453 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
454 .. code-block:: genshi |
235 | 455 |
456 <ul> | |
457 <li py:attrs="foo">Bar</li> | |
458 </ul> | |
459 | |
460 Given ``foo={'class': 'collapse'}`` in the template context, this would | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
461 produce: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
462 |
612
3d2909fe1dda
Using `html` code-blocks for examples isn't so nice when viewing the docs over Trac, so change them to `xml`.
cmlenz
parents:
610
diff
changeset
|
463 .. code-block:: xml |
235 | 464 |
465 <ul> | |
466 <li class="collapse">Bar</li> | |
467 </ul> | |
468 | |
469 Attributes with the value ``None`` are omitted, so given ``foo={'class': None}`` | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
470 in the context for the same template this would produce: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
471 |
612
3d2909fe1dda
Using `html` code-blocks for examples isn't so nice when viewing the docs over Trac, so change them to `xml`.
cmlenz
parents:
610
diff
changeset
|
472 .. code-block:: xml |
235 | 473 |
474 <ul> | |
475 <li>Bar</li> | |
476 </ul> | |
477 | |
478 This directive can only be used as an attribute. | |
479 | |
480 | |
481 .. _`py:content`: | |
482 | |
483 ``py:content`` | |
237 | 484 -------------- |
235 | 485 |
486 This directive replaces any nested content with the result of evaluating the | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
487 expression: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
488 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
489 .. code-block:: genshi |
235 | 490 |
491 <ul> | |
492 <li py:content="bar">Hello</li> | |
493 </ul> | |
494 | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
495 Given ``bar='Bye'`` in the context data, this would produce: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
496 |
612
3d2909fe1dda
Using `html` code-blocks for examples isn't so nice when viewing the docs over Trac, so change them to `xml`.
cmlenz
parents:
610
diff
changeset
|
497 .. code-block:: xml |
235 | 498 |
499 <ul> | |
500 <li>Bye</li> | |
501 </ul> | |
502 | |
503 This directive can only be used as an attribute. | |
504 | |
505 | |
506 .. _`py:replace`: | |
507 | |
508 ``py:replace`` | |
237 | 509 -------------- |
235 | 510 |
511 This directive replaces the element itself with the result of evaluating the | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
512 expression: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
513 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
514 .. code-block:: genshi |
235 | 515 |
516 <div> | |
517 <span py:replace="bar">Hello</span> | |
518 </div> | |
519 | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
520 Given ``bar='Bye'`` in the context data, this would produce: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
521 |
612
3d2909fe1dda
Using `html` code-blocks for examples isn't so nice when viewing the docs over Trac, so change them to `xml`.
cmlenz
parents:
610
diff
changeset
|
522 .. code-block:: xml |
235 | 523 |
524 <div> | |
525 Bye | |
526 </div> | |
527 | |
657 | 528 This directive can also be used as an element (since version 0.5): |
529 | |
530 .. code-block:: genshi | |
531 | |
532 <div> | |
533 <py:replace value="title">Placeholder</py:replace> | |
534 </div> | |
535 | |
235 | 536 |
537 | |
538 .. _`py:strip`: | |
539 | |
540 ``py:strip`` | |
237 | 541 ------------ |
235 | 542 |
543 This directive conditionally strips the top-level element from the output. When | |
544 the value of the ``py:strip`` attribute evaluates to ``True``, the element is | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
545 stripped from the output: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
546 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
547 .. code-block:: genshi |
235 | 548 |
549 <div> | |
550 <div py:strip="True"><b>foo</b></div> | |
551 </div> | |
552 | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
553 This would be rendered as: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
554 |
612
3d2909fe1dda
Using `html` code-blocks for examples isn't so nice when viewing the docs over Trac, so change them to `xml`.
cmlenz
parents:
610
diff
changeset
|
555 .. code-block:: xml |
235 | 556 |
557 <div> | |
558 <b>foo</b> | |
559 </div> | |
560 | |
561 As a shorthand, if the value of the ``py:strip`` attribute is empty, that has | |
562 the same effect as using a truth value (i.e. the element is stripped). | |
563 | |
564 | |
226 | 565 .. _order: |
566 | |
567 Processing Order | |
568 ================ | |
569 | |
570 It is possible to attach multiple directives to a single element, although not | |
571 all combinations make sense. When multiple directives are encountered, they are | |
572 processed in the following order: | |
573 | |
574 #. `py:def`_ | |
575 #. `py:match`_ | |
576 #. `py:when`_ | |
577 #. `py:otherwise`_ | |
578 #. `py:for`_ | |
579 #. `py:if`_ | |
580 #. `py:choose`_ | |
581 #. `py:with`_ | |
582 #. `py:replace`_ | |
583 #. `py:content`_ | |
584 #. `py:attrs`_ | |
585 #. `py:strip`_ | |
586 | |
587 | |
588 .. _includes: | |
589 | |
590 -------- | |
591 Includes | |
592 -------- | |
593 | |
594 To reuse common snippets of template code, you can include other files using | |
595 XInclude_. | |
596 | |
597 .. _xinclude: http://www.w3.org/TR/xinclude/ | |
598 | |
599 For this, you need to declare the XInclude namespace (commonly bound to the | |
600 prefix “xi”) and use the ``<xi:include>`` element where you want the external | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
601 file to be pulled in: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
602 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
603 .. code-block:: genshi |
226 | 604 |
605 <html xmlns="http://www.w3.org/1999/xhtml" | |
230 | 606 xmlns:py="http://genshi.edgewall.org/" |
226 | 607 xmlns:xi="http://www.w3.org/2001/XInclude"> |
608 <xi:include href="base.html" /> | |
609 ... | |
610 </html> | |
611 | |
612 Include paths are relative to the filename of the template currently being | |
613 processed. So if the example above was in the file "``myapp/index.html``" | |
614 (relative to the template search path), the XInclude processor would look for | |
615 the included file at "``myapp/base.html``". You can also use Unix-style | |
616 relative paths, for example "``../base.html``" to look in the parent directory. | |
617 | |
618 Any content included this way is inserted into the generated output instead of | |
619 the ``<xi:include>`` element. The included template sees the same context data. | |
620 `Match templates`_ and `macros`_ in the included template are also available to | |
621 the including template after the point it was included. | |
622 | |
623 By default, an error will be raised if an included file is not found. If that's | |
624 not what you want, you can specify fallback content that should be used if the | |
625 include fails. For example, to to make the include above fail silently, you'd | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
626 write: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
627 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
628 .. code-block:: genshi |
226 | 629 |
630 <xi:include href="base.html"><xi:fallback /></xi:include> | |
631 | |
273 | 632 See the `XInclude specification`_ for more about fallback content. Note though |
633 that Genshi currently only supports a small subset of XInclude. | |
634 | |
635 .. _`xinclude specification`: http://www.w3.org/TR/xinclude/ | |
226 | 636 |
610
5e358de79e4c
* XInclude elements in markup templates now support the `parse` attribute; when set to "xml" (the default), the include is processed as before, but when set to "text", the included template is parsed as a text template using the new syntax (ticket #101).
cmlenz
parents:
602
diff
changeset
|
637 |
5e358de79e4c
* XInclude elements in markup templates now support the `parse` attribute; when set to "xml" (the default), the include is processed as before, but when set to "text", the included template is parsed as a text template using the new syntax (ticket #101).
cmlenz
parents:
602
diff
changeset
|
638 Dynamic Includes |
5e358de79e4c
* XInclude elements in markup templates now support the `parse` attribute; when set to "xml" (the default), the include is processed as before, but when set to "text", the included template is parsed as a text template using the new syntax (ticket #101).
cmlenz
parents:
602
diff
changeset
|
639 ================ |
5e358de79e4c
* XInclude elements in markup templates now support the `parse` attribute; when set to "xml" (the default), the include is processed as before, but when set to "text", the included template is parsed as a text template using the new syntax (ticket #101).
cmlenz
parents:
602
diff
changeset
|
640 |
230 | 641 Incudes in Genshi are fully dynamic: Just like normal attributes, the `href` |
442
97544725bb7f
Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option.
cmlenz
parents:
429
diff
changeset
|
642 attribute accepts expressions, and directives_ can be used on the |
226 | 643 ``<xi:include />`` element just as on any other element, meaning you can do |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
644 things like conditional includes: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
645 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
646 .. code-block:: genshi |
226 | 647 |
648 <xi:include href="${name}.html" py:if="not in_popup" | |
649 py:for="name in ('foo', 'bar', 'baz')" /> | |
650 | |
651 | |
610
5e358de79e4c
* XInclude elements in markup templates now support the `parse` attribute; when set to "xml" (the default), the include is processed as before, but when set to "text", the included template is parsed as a text template using the new syntax (ticket #101).
cmlenz
parents:
602
diff
changeset
|
652 Including Text Templates |
5e358de79e4c
* XInclude elements in markup templates now support the `parse` attribute; when set to "xml" (the default), the include is processed as before, but when set to "text", the included template is parsed as a text template using the new syntax (ticket #101).
cmlenz
parents:
602
diff
changeset
|
653 ======================== |
5e358de79e4c
* XInclude elements in markup templates now support the `parse` attribute; when set to "xml" (the default), the include is processed as before, but when set to "text", the included template is parsed as a text template using the new syntax (ticket #101).
cmlenz
parents:
602
diff
changeset
|
654 |
5e358de79e4c
* XInclude elements in markup templates now support the `parse` attribute; when set to "xml" (the default), the include is processed as before, but when set to "text", the included template is parsed as a text template using the new syntax (ticket #101).
cmlenz
parents:
602
diff
changeset
|
655 The ``parse`` attribute of the ``<xi:include>`` element can be used to specify |
5e358de79e4c
* XInclude elements in markup templates now support the `parse` attribute; when set to "xml" (the default), the include is processed as before, but when set to "text", the included template is parsed as a text template using the new syntax (ticket #101).
cmlenz
parents:
602
diff
changeset
|
656 whether the included template is an XML template or a text template (using the |
5e358de79e4c
* XInclude elements in markup templates now support the `parse` attribute; when set to "xml" (the default), the include is processed as before, but when set to "text", the included template is parsed as a text template using the new syntax (ticket #101).
cmlenz
parents:
602
diff
changeset
|
657 new syntax added in Genshi 0.5): |
5e358de79e4c
* XInclude elements in markup templates now support the `parse` attribute; when set to "xml" (the default), the include is processed as before, but when set to "text", the included template is parsed as a text template using the new syntax (ticket #101).
cmlenz
parents:
602
diff
changeset
|
658 |
5e358de79e4c
* XInclude elements in markup templates now support the `parse` attribute; when set to "xml" (the default), the include is processed as before, but when set to "text", the included template is parsed as a text template using the new syntax (ticket #101).
cmlenz
parents:
602
diff
changeset
|
659 .. code-block:: genshi |
5e358de79e4c
* XInclude elements in markup templates now support the `parse` attribute; when set to "xml" (the default), the include is processed as before, but when set to "text", the included template is parsed as a text template using the new syntax (ticket #101).
cmlenz
parents:
602
diff
changeset
|
660 |
5e358de79e4c
* XInclude elements in markup templates now support the `parse` attribute; when set to "xml" (the default), the include is processed as before, but when set to "text", the included template is parsed as a text template using the new syntax (ticket #101).
cmlenz
parents:
602
diff
changeset
|
661 <xi:include href="myscript.js" parse="text" /> |
5e358de79e4c
* XInclude elements in markup templates now support the `parse` attribute; when set to "xml" (the default), the include is processed as before, but when set to "text", the included template is parsed as a text template using the new syntax (ticket #101).
cmlenz
parents:
602
diff
changeset
|
662 |
5e358de79e4c
* XInclude elements in markup templates now support the `parse` attribute; when set to "xml" (the default), the include is processed as before, but when set to "text", the included template is parsed as a text template using the new syntax (ticket #101).
cmlenz
parents:
602
diff
changeset
|
663 This example would load the ``myscript.js`` file as a ``NewTextTemplate``. See |
5e358de79e4c
* XInclude elements in markup templates now support the `parse` attribute; when set to "xml" (the default), the include is processed as before, but when set to "text", the included template is parsed as a text template using the new syntax (ticket #101).
cmlenz
parents:
602
diff
changeset
|
664 `text templates`_ for details on the syntax of text templates. |
5e358de79e4c
* XInclude elements in markup templates now support the `parse` attribute; when set to "xml" (the default), the include is processed as before, but when set to "text", the included template is parsed as a text template using the new syntax (ticket #101).
cmlenz
parents:
602
diff
changeset
|
665 |
5e358de79e4c
* XInclude elements in markup templates now support the `parse` attribute; when set to "xml" (the default), the include is processed as before, but when set to "text", the included template is parsed as a text template using the new syntax (ticket #101).
cmlenz
parents:
602
diff
changeset
|
666 .. _`text templates`: text-templates.html |
5e358de79e4c
* XInclude elements in markup templates now support the `parse` attribute; when set to "xml" (the default), the include is processed as before, but when set to "text", the included template is parsed as a text template using the new syntax (ticket #101).
cmlenz
parents:
602
diff
changeset
|
667 |
5e358de79e4c
* XInclude elements in markup templates now support the `parse` attribute; when set to "xml" (the default), the include is processed as before, but when set to "text", the included template is parsed as a text template using the new syntax (ticket #101).
cmlenz
parents:
602
diff
changeset
|
668 |
226 | 669 .. _comments: |
670 | |
671 -------- | |
672 Comments | |
673 -------- | |
674 | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
675 Normal XML/HTML comment syntax can be used in templates: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
676 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
677 .. code-block:: genshi |
226 | 678 |
679 <!-- this is a comment --> | |
680 | |
681 However, such comments get passed through the processing pipeline and are by | |
682 default included in the final output. If that's not desired, prefix the comment | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
683 text with an exclamation mark: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
684 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
685 .. code-block:: genshi |
226 | 686 |
687 <!-- !this is a comment too, but one that will be stripped from the output --> | |
688 | |
689 Note that it does not matter whether there's whitespace before or after the | |
510
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
690 exclamation mark, so the above could also be written as follows: |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
691 |
1bdccd3bda00
Use syntax highlighting on all the other doc pages, too.
cmlenz
parents:
451
diff
changeset
|
692 .. code-block:: genshi |
226 | 693 |
694 <!--! this is a comment too, but one that will be stripped from the output --> |