home—lects—exams—hws
D2L—breeze (snow day)

lect12b-ch02
XSLT
value-of, for-each

Originally based on XML Visual Quickstart Guide by Kevin Howard Goldberg, and notes therefrom by Jack Davis (jcdavis@radford.edu).

ch02 - XSLT basics

The next step in learning to use XML is understanding how to format these documents. The details for formatting XML documents was originally in a specification called XSLT, which stands for eXtensible Style Language Transformations. Chapters 2-4 explain how to use XSL to transform XML documents. The end result might be another XML document, or an HTML document (most common). You can transform an XML document into practically any document type.

Transforming an XML document means taking in one XML tree and producing another — a function from XML trees to XML trees. For example, consider the input

<my_children>
	<child>
		<name>Logan</name>
		<gender>M</gender>
		<age>7</age>
	</child>
	<child>
		<name>Rebecca</name>
		<gender>F</gender>
		<age>3</age>
	</child>
	<child>
		<name>Lee</name>
		<gender>F</gender>
		<age>2</age>
	</child>
</my_children>

An XSLT program might take this and return a new XML tree:

<html>
  <body>
    <h3>Some Kids</h3>
    <ul>
      <li>Logan, who is 7</li>
      <li>Rebecca, who is 3</li>
      <li>Lee, who is 2</li>
    </ul>
  </body>
</html>

Rather than write such a function in Java or a general-purpose programming language, XSLT is a domain-specific language, specifically invented to make these tree-transformations easy to write. XSLT can be used to reorder the ouput according to user established criteria, display only portions of the document, and more.

Overview

The transformation process starts with two documents: the XML document (the input data, .xml) and the XSLT document (the program, .xsl).
Interestingly, a XSLT program is itself written in XML(!). Its commands are tags which start with “xsl:” — for example,
<xsl:for-each select="nodeSpec"> results... </xsl:for-each>
(We'll discuss how the xsl:for-each loop works below.)
Alas, if you just have your browser request foo.xml, the server doesn't auto-magically look for a corresponding foo.xsl (even though that'd be a mildly sensible convention). Instead, you must specify, in the xml file, a processing instruction telling the server that this xml file should be processed by a particular xsl template:
<?xml-stylesheet type="text/xsl" href="foo.xsl"?>
lect12a-ch02-oneWonder.xml (show-source; note line 3)
lect12a-ch02-oneWonder.xsl
Once the browser has constructed the XML data tree, it then transforms that XML tree using the XSLT instructions, yeilding a new tree. The transformation rules are called “templates”; they correspond to functions in a programming language — a function which is given an XML node as input, and returns a (new) XML node.

(Note: usually the output happens to be XHTML, but it can in theory be any XML.)

A particular transformation (“template”) looks at one node of the input tree [including its subtree], and produces a (sub)tree to include in the overall output. In the my_children example above, there might be one “helper” XSLT template which, given a child node, produces (say) some HTML li tags incorporating some of the info from the child. A different “main” template might take the root element, and return a ul tag, followed by the results of applying the above child→li template to each child node.

In our context, it's the browser which invokes the XSLT processor, and the result is html. (The XSLT is being run client-side.) However, that's not required — XSLT can produce any XML output, and the XSLT processing can be run stand-alone.
Each XSLT template has two parts:
- First, a label that identifies the nodes in the XML document to which the template applies;
- Second, instructions about the actual transformation. The instructions, or rules, will either output or further process the nodes in the source document. They can also contain literal elements that should be output as is. The XSLT transformation begins by processing the root template.
Every XSLT style sheet must have a root template; this is the template that applies to the source document's root node¹, /.

Building an XSL Style Sheet

Every XSLT style sheet itself an XML document, so it begins with a standard XML declaration. Next, the W3C namespace for style sheets is defined.

 
                <?xml version="1.0"?>
                <xsl:stylesheet 
                        xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                        version="1.0">

Of course, at the end of the file the stylesheet tag will be closed:
</xsl:stylesheet>
Create the root template
This is the template that defines the set of rules to apply to the root of the XML document.
<xsl:template match="/" >  </xsl:template>
Note:If you do not include a root template in the XSLT stylesheet, a root template built in to XSLT will be used (typically not what you want).
Recall how php programs intermingle HTML and php processing directives. Well, XSLT is similar: programs can intermingle XML tags with XSLT processing tags. Any tag that's not a xsl processing instruction is passed along as part of the result.
After running the XSLT program, we have newly-built XML tree; the very last step is to flatten that tree back to a string and print it as output. We can use the xsl:output instruction to choose what “to-string” function will be used for this. (What character encoding is used, any DOCTYPE declaration to precede the output with, etc.).

In 95% of all cases, our resulting XML tree is HTML, and so we'll include
<xsl:output method="html"/>
You can give further arguments to specify the character-encoding, etc..

Note that xsl:output only is specified once, at the top level of the XSLT stylesheet.

Example: Putting the above together, we'll make a trivial XSLT program which ignores its input entirely, always generating the same, constant output page:
lect12a-ch02-constant.xml
lect12a-ch02-constant.xsl
Extracting data from an input node:
Use the xsl:value-of command to extract data from the XML input. (It can do more than this, but we'll come back to it.) <xsl:value-of select="expression"/>
where the expression selects a particular node in the xml document
If the select expression matches more than one node in the XML, only the first node's value will be used
lect12a-ch02-nameOneWonder.xsl
lect12a-ch02-nameOneWonder.xml
Looping over Nodes
Use xsl:for-each to loop over several nodes:
<xsl:for-each select="expression"> body</xsl:for-each>
Example:
lect12a-ch02-wonders-table.xsl
lect12a-ch02-wonders-table.xml

The body of the loop is XSLT, where the implicit-root of any relative XPATHS is one of the things selected by the for-each.

Note how the syntax of xsl:for-each gathers the control-flow into attributes, and the activity-to-be-repeated is exactly the tag's body. This is reminiscent of how (say) Java's for loops are an improvement over while loops which cleanly pull the loop-control into one line instead of while, where the initialization and end-of-loop update are more co-mingled with other code.

A conditional construct is xsl:choose, which is like an if-else-if in other languages:

<p>
  This person is
    <xsl:choose>                     
       <xsl:when test="height > 200">
         extremely
       </xsl:when>                 
       <xsl:when test="height != 0">
         <xsl:value-of select="height"/> cm
       </xsl:when>                 
       <xsl:otherwise>            
          unknown
       </xsl:otherwise>         
    </xsl:choose>
  tall.
</p>

Example: The 'height' column:
lect12a-ch02-choose.xml
lect12a-ch02-choose.xsl
(These are also examples of using xsl:if (below), for the non-English name, if present.)

The one-armed if:
<xsl:if test="boolean expression">  </xsl:if>
For example, if we only want to include the name when the language attribute is “English”:
<xsl:if test="name[@language='English']"> It's called <xsl:value-of select='name'>. </xsl:if>
Rather unintuitively², the xsl:if instruction does not have a complementary ~~xml:else~~ instruction! So in practice use xsl:if to explicitly tell readers “I'll do nothing otherwise”³, and you'll find xsl:choose will get used relatively often.
Example:
lect12a-ch02-if.xml
lect12a-ch02-if.xsl
Sorting Nodes
To sort nodes before processing:
- Directly after an xsl:for-each element, insert a xsl:sort tag (which has attributes, but is otherwise empty).
- <xsl:sort select="criteria" order="descending" data-type="text" />
- Example:
  lect12a-ch02-sort.xsl
  lect12a-ch02-sort.xml
observation: Placing the xsl:sort tag as the first-child inside the loop's body is definitely odd. It would be more natural to have a stand-alone sort tag which takes the XPATH of the nodes to sort, and returns a “list” of the sorted nodes seems that the loop's control-flow should all be set via attributes. Alas, they didn't ask me when designing it. (Also, there are XPATH issues since the xsl:for-each is working on the parent, but the sort's select expression is relative to a child.)

¹ Remember, one of the XML requirements is that there is exactly one top-level tag. ↩

² The reason for the lack of xsl:else is because it's a bit unclear where the else tag should be placed — conceptually it belongs beside the if tag, but requiring side-by-side tags is unlike any other instruction. Putting the else inside the if makes more sense, but even then the condition attributes now seem placed oddly. A more appropriate version might have an if tag with exactly two children: “then” and “else”. … hey now we've arrived back at what xsl:choose does, except we're limited to exactly-two! I guess they designed the choice tag correctly after all! ↩

³ Perhaps they should use an English term beside “if”; perhaps when or unless? ↩

home—lects—exams—hws
D2L—breeze (snow day)

©2012, Ian Barland, Radford University
Last modified 2012.Nov.14 (Wed) Please mail any suggestions
(incl. typos, broken links)
to ibarlandradford.edu

lect12b-ch02 XSLTvalue-of, for-each

ch02 - XSLT basics

Overview

Building an XSL Style Sheet

lect12b-ch02
XSLT
value-of, for-each