genshi/genshi-test: doc/xml-templates.txt comparison

comparison doc/xml-templates.txt @ 510:ca7d707d51b0

Use syntax highlighting on all the other doc pages, too.

author	cmlenz
date	Wed, 06 Jun 2007 10:41:41 +0000
parents	bcc1d6c67a2f
children	509b3a5e765e f725e48c9a5f f0bb2c5ea0ff

comparison

equal deleted inserted replaced

-:1997f7af845c
+:ca7d707d51b0
 by the namespace ``http://genshi.edgewall.org/``. They can affect how the
 template is rendered in a number of ways: Genshi provides directives for
 conditionals and looping, among others.
 To use directives in a template, the namespace must be declared, which is
-usually done on the root element::
+usually done on the root element:
+.. code-block:: genshi
 <html xmlns="http://www.w3.org/1999/xhtml"
 xmlns:py="http://genshi.edgewall.org/"
 lang="en">
 ...
 In this example, the default namespace is set to the XHTML namespace, and the
 namespace for Genshi directives is bound to the prefix “py”.
 All directives can be applied as attributes, and some can also be used as
 elements. The ``if`` directives for conditionals, for example, can be used in
-both ways::
+both ways:
+.. code-block:: genshi
 <html xmlns="http://www.w3.org/1999/xhtml"
 xmlns:py="http://genshi.edgewall.org/"
 lang="en">
 ...
 <p>Bar</p>
 </div>
 ...
 </html>
-This is basically equivalent to the following::
+This is basically equivalent to the following:
+.. code-block:: genshi
 <html xmlns="http://www.w3.org/1999/xhtml"
 xmlns:py="http://genshi.edgewall.org/"
 lang="en">
 ...
 .. _`py:if`:
 ``py:if``
 ---------
-The element is only rendered if the expression evaluates to a truth value::
+The element is only rendered if the expression evaluates to a truth value:
+.. code-block:: genshi
 <div>
 <b py:if="foo">${bar}</b>
 </div>
 Given the data ``foo=True`` and ``bar='Hello'`` in the template context, this
-would produce::
+would produce:
+.. code-block:: html
 <div>
 <b>Hello</b>
 </div>
-This directive can also be used as an element::
+This directive can also be used as an element:
+.. code-block:: genshi
 <div>
 <py:if test="foo">
 <b>${bar}</b>
 </py:if>
 and ``py:otherwise`` provides advanced conditional processing for rendering one
 of several alternatives. The first matching ``py:when`` branch is rendered, or,
 if no ``py:when`` branch matches, the ``py:otherwise`` branch is rendered.
 If the ``py:choose`` directive is empty the nested ``py:when`` directives will
-be tested for truth::
+be tested for truth:
+.. code-block:: genshi
 <div py:choose="">
 <span py:when="0 == 1">0</span>
 <span py:when="1 == 1">1</span>
 <span py:otherwise="">2</span>
 </div>
-This would produce the following output::
+This would produce the following output:
+.. code-block:: html
 <div>
 <span>1</span>
 </div>
 If the ``py:choose`` directive contains an expression the nested ``py:when``
-directives will be tested for equality to the parent ``py:choose`` value::
+directives will be tested for equality to the parent ``py:choose`` value:
+.. code-block:: genshi
 <div py:choose="1">
 <span py:when="0">0</span>
 <span py:when="1">1</span>
 <span py:otherwise="">2</span>
 </div>
-This would produce the following output::
+This would produce the following output:
+.. code-block:: html
 <div>
 <span>1</span>
 </div>
 .. _`py:for`:
 ``py:for``
 ----------
-The element is repeated for every item in an iterable::
+The element is repeated for every item in an iterable:
+.. code-block:: genshi
 <ul>
 <li py:for="item in items">${item}</li>
 </ul>
-Given ``items=[1, 2, 3]`` in the context data, this would produce::
+Given ``items=[1, 2, 3]`` in the context data, this would produce:
+.. code-block:: html
 <ul>
 <li>1</li><li>2</li><li>3</li>
 </ul>
-This directive can also be used as an element::
+This directive can also be used as an element:
+.. code-block:: genshi
 <ul>
 <py:for each="item in items">
 <li>${item}</li>
 </py:for>
 ``py:def``
 ----------
 The ``py:def`` directive can be used to create macros, i.e. snippets of
 template code that have a name and optionally some parameters, and that can be
-inserted in other places::
+inserted in other places:
+.. code-block:: genshi
 <div>
 <p py:def="greeting(name)" class="greeting">
 Hello, ${name}!
 </p>
 ${greeting('world')}
 ${greeting('everyone else')}
 </div>
-The above would be rendered to::
+The above would be rendered to:
+.. code-block:: html
 <div>
 <p class="greeting">
 Hello, world!
 </p>
 Hello, everyone else!
 </p>
 </div>
 If a macro doesn't require parameters, it can be defined without the
-parenthesis. For example::
+parenthesis. For example:
+.. code-block:: genshi
 <div>
 <p py:def="greeting" class="greeting">
 Hello, world!
 </p>
 ${greeting()}
 </div>
-The above would be rendered to::
+The above would be rendered to:
+.. code-block:: html
 <div>
 <p class="greeting">
 Hello, world!
 </p>
 </div>
-This directive can also be used as an element::
+This directive can also be used as an element:
+.. code-block:: genshi
 <div>
 <py:def function="greeting(name)">
 <p class="greeting">Hello, ${name}!</p>
 </py:def>
 This directive defines a *match template*: given an XPath expression, it
 replaces any element in the template that matches the expression with its own
 content.
 For example, the match template defined in the following template matches any
-element with the tag name “greeting”::
+element with the tag name “greeting”:
+.. code-block:: genshi
 <div>
 <span py:match="greeting">
 Hello ${select('@name')}
 </span>
 <greeting name="Dude" />
 </div>
-This would result in the following output::
+This would result in the following output:
+.. code-block:: html
 <div>
 <span>
 Hello Dude
 </span>
 in the output of the match template. See `Using XPath`_ for more information
 about this function.
 .. _`Using XPath`: streams.html#using-xpath
-This directive can also be used as an element::
+This directive can also be used as an element:
+.. code-block:: genshi
 <div>
 <py:match path="greeting">
 <span>Hello ${select('@name')}</span>
 </py:match>
 be used to make expressions inside the directive less verbose and more
 efficient. For example, if you need use the expression ``author.posts`` more
 than once, and that actually results in a database query, assigning the results
 to a variable using this directive would probably help.
-For example::
+For example:
+.. code-block:: genshi
 <div>
 <span py:with="y=7; z=x+10">$x $y $z</span>
 </div>
-Given ``x=42`` in the context data, this would produce::
+Given ``x=42`` in the context data, this would produce:
+.. code-block:: html
 <div>
 <span>42 7 52</span>
 </div>
-This directive can also be used as an element::
+This directive can also be used as an element:
+.. code-block:: genshi
 <div>
 <py:with vars="y=7; z=x+10">$x $y $z</py:with>
 </div>
 .. _`py:attrs`:
 ``py:attrs``
 ------------
-This directive adds, modifies or removes attributes from the element::
+This directive adds, modifies or removes attributes from the element:
+.. code-block:: genshi
 <ul>
 <li py:attrs="foo">Bar</li>
 </ul>
 Given ``foo={'class': 'collapse'}`` in the template context, this would
-produce::
+produce:
+.. code-block:: html
 <ul>
 <li class="collapse">Bar</li>
 </ul>
 Attributes with the value ``None`` are omitted, so given ``foo={'class': None}``
-in the context for the same template this would produce::
+in the context for the same template this would produce:
+.. code-block:: html
 <ul>
 <li>Bar</li>
 </ul>
 ``py:content``
 --------------
 This directive replaces any nested content with the result of evaluating the
-expression::
+expression:
+.. code-block:: genshi
 <ul>
 <li py:content="bar">Hello</li>
 </ul>
-Given ``bar='Bye'`` in the context data, this would produce::
+Given ``bar='Bye'`` in the context data, this would produce:
+.. code-block:: html
 <ul>
 <li>Bye</li>
 </ul>
 ``py:replace``
 --------------
 This directive replaces the element itself with the result of evaluating the
-expression::
+expression:
+.. code-block:: genshi
 <div>
 <span py:replace="bar">Hello</span>
 </div>
-Given ``bar='Bye'`` in the context data, this would produce::
+Given ``bar='Bye'`` in the context data, this would produce:
+.. code-block:: html
 <div>
 Bye
 </div>
 ``py:strip``
 ------------
 This directive conditionally strips the top-level element from the output. When
 the value of the ``py:strip`` attribute evaluates to ``True``, the element is
-stripped from the output::
+stripped from the output:
+.. code-block:: genshi
 <div>
 <div py:strip="True"><b>foo</b></div>
 </div>
-This would be rendered as::
+This would be rendered as:
+.. code-block:: html
 <div>
 <b>foo</b>
 </div>
 .. _xinclude: http://www.w3.org/TR/xinclude/
 For this, you need to declare the XInclude namespace (commonly bound to the
 prefix “xi”) and use the ``<xi:include>`` element where you want the external
-file to be pulled in::
+file to be pulled in:
+.. code-block:: genshi
 <html xmlns="http://www.w3.org/1999/xhtml"
 xmlns:py="http://genshi.edgewall.org/"
 xmlns:xi="http://www.w3.org/2001/XInclude">
 <xi:include href="base.html" />
 the including template after the point it was included.
 By default, an error will be raised if an included file is not found. If that's
 not what you want, you can specify fallback content that should be used if the
 include fails. For example, to to make the include above fail silently, you'd
-write::
+write:
+.. code-block:: genshi
 <xi:include href="base.html"><xi:fallback /></xi:include>
 See the `XInclude specification`_ for more about fallback content. Note though
 that Genshi currently only supports a small subset of XInclude.
 .. _`xinclude specification`: http://www.w3.org/TR/xinclude/
 Incudes in Genshi are fully dynamic: Just like normal attributes, the `href`
 attribute accepts expressions, and directives_ can be used on the
 ``<xi:include />`` element just as on any other element, meaning you can do
-things like conditional includes::
+things like conditional includes:
+.. code-block:: genshi
 <xi:include href="${name}.html" py:if="not in_popup"
 py:for="name in ('foo', 'bar', 'baz')" />
 --------
 Comments
 --------
-Normal XML/HTML comment syntax can be used in templates::
+Normal XML/HTML comment syntax can be used in templates:
+.. code-block:: genshi
 <!-- this is a comment -->
 However, such comments get passed through the processing pipeline and are by
 default included in the final output. If that's not desired, prefix the comment
-text with an exclamation mark::
+text with an exclamation mark:
+.. code-block:: genshi
 <!-- !this is a comment too, but one that will be stripped from the output -->
 Note that it does not matter whether there's whitespace before or after the
-exclamation mark, so the above could also be written as follows::
+exclamation mark, so the above could also be written as follows:
+.. code-block:: genshi
 <!--! this is a comment too, but one that will be stripped from the output -->

Mercurial > genshi > genshi-test

comparison doc/xml-templates.txt @ 510:ca7d707d51b0