Abstract

Advanced XSLT processing includes better control of the input and output documents, which can finely controlled in terms of how whitespace is treated. Another interesting feature of XSLT are keys, which allow shorthand notations for frequently used access paths to nodes, and provide XSLT processors with more information for performance optimizations. Instructions for creating all possible kinds of nodes in the output tree make it possible to write code which generates element or attribute names based on runtime evaluations.

XSLT Core Concepts

• XSLT can be used for very simple matching tasks
  • a mostly static result tree can be produced
  • XPaths can be used to fill in parts of the result tree
  • Iterations and Conditional Instructions provide some flexibility for processing
• More complex transformation require a different approach
  • instead of static structures, nodes are individually mapped to small structures
  • these structure fragments together produce the result tree
  • the process is document-driven and based on the XSLT Processing Model

Programming Language Basics

• Variables in programming languages have different purposes
  1. defining a name for something so that it can be referred to
  2. associating this name with a value so that the value can be used
  3. providing a way to update the variable so that its value changes
• Variables in functional languages cannot change
  • they are immutable (often called constants in other languages)
  • more specifically, they are dynamic constants (i.e., can be computed at runtime)
  • they are defined by giving them a name and referring to them by $name
• Variables in XSLT have no type (no static type checking possible)
  • the value that they have is typed
  • but a variable may have values of any type

<xsl:variable name="sum" select="$op1 + $op2"/>
<xsl:variable name="result" select="$sum * $factor"

Why Variables?

• Reuse of values in different locations
  • texts required for the transformation
  • facilitates better separation of structure and content

  <xsl:value-of select="$email-prefix"/> <!-- $email-prefix = 'You have ' -->
  <xsl:value-of select="count(//message)"/>
  <xsl:value-of select="$email-suffix"/> <!-- $email-suffix = ' e-mail messages.' -->

• Using the correct context is essential
  • variables cannot be updated
  • if they need to be updated, they have to be re-created
• Why are they called variables if they are constants?
  • their value varies in different invocations of the context
  • they are computed at runtime (dynamic constants) rather than statically

Scope and Extent

• Variables can be global or local
  • global variables are visible in all templates
  • local variables are visible in their context (i.e., at following-sibling::*/descendant-or-self::*)
  • local variables are allowed to shadow global (not local) variables
• Variable values may be assigned using the select attribute
  • The XPath's result is the value of the variable
• Variables can contain arbitrary XPath code
  • the code is executed in the same way as when constructing the result tree
  • the result tree fragment is the value of the variable
  • it can be used as a string (value-of) or as a tree (copy-of)

Using Variables

 <xsl:variable name="name" select="'value'"/>
 <xsl:template match="/">
  <xsl:choose>
   <xsl:when test="$name = 'value'">
    <xsl:variable name="result" select="'ok'"/>
   </xsl:when>
   <xsl:otherwise>
    <xsl:variable name="result" select="'problem'"/>
   </xsl:otherwise>
  </xsl:choose>
  <xsl:value-of select="$result"/>
 </xsl:template>

 <xsl:variable name="name" select="'value'"/>
 <xsl:template match="/">
  <xsl:variable name="result">
   <xsl:choose>
    <xsl:when test="$name = 'value'">
     <xsl:value-of select="'ok'"/>
    </xsl:when>
    <xsl:otherwise>
     <xsl:value-of select="'problem'"/>
    </xsl:otherwise>
   </xsl:choose>
  </xsl:variable>
  <xsl:value-of select="$result"/>
 </xsl:template>

Parameters vs. Variables

• Parameters are variables with additional semantics
  • they are passed to their scope from the outside
  • they are available within the scope like a variable (scopes are stylesheets and templates)
  • like variables, they cannot be updated (and only global parameters can be shadowed)
• XSLT does not check proper parameter passing
  • if a declared parameter is not passed, it gets a default value (specified or '')
  • if a passed parameter is not declared, it is ignored
  • like variables, parameters have no type (any value can be passed)
  • XSLT's robustness makes it hard to spot programming errors

Stylesheet Parameters

• Passed to the stylesheet when calling the stylesheet
  • the exact way of specifying the parameters depend on the processor and the environment
  • the passed values are available in the same way as global variables
  • parameter checking has to be done by hand

 <xsl:param name="number" select="0"/>
 <xsl:variable name="number-param">
  <xsl:if test="string(number($number)) = 'NaN'">
   <xsl:message terminate="yes">"number" must be a proper number!</xsl:message>
  </xsl:if>
  <xsl:value-of select="$number"/>
 </xsl:variable>
 <xsl:template match="/">
  <xsl:value-of select="10 * $number-param"/>
 </xsl:template>

Template Parameters

• Parameters can be passed to templates
  • works with apply-templates and call-template
  • with-param elements list the passed parameters
  • parameter matching is done by name (there is no particular order to parameters)
• Templates can be programmed as parametrized components
  • checking the signature has to be done by hand
  • with-param elements list the passed parameters
  • parameter matching is done by name (there is no particular order to parameters)
• Parametrized template calls need a lot of markup
  • XSLT's XML syntax makes the code hard to read

main param start = 1 ; param count = 10 ; {
	loop (0) };
loop param counter ; {
	print $start + $counter ;
	if ( $counter < $count - 1) then 
		loop ($counter + 1) ; }

Parameter Passing

 <xsl:param name="start" select="1"/>
 <xsl:param name="count" select="10"/>
 <xsl:template match="/">
  <xsl:call-template name="loop">
   <xsl:with-param name="counter" select="0"/>
  </xsl:call-template>
 </xsl:template>
 <xsl:template name="loop">
  <xsl:param name="counter"/>
  <xsl:message>
   <xsl:value-of select="$start + $counter"/>
  </xsl:message>
  <xsl:if test="$counter &lt; $count - 1">
   <xsl:call-template name="loop">
    <xsl:with-param name="counter" select="$counter + 1"/>
   </xsl:call-template>
  </xsl:if>
 </xsl:template>

Message Facility

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:param name="message" select="'plain'"/>
    <!-- messaging style: 'silent', 'plain', or 'prefixed' -->
    <xsl:template name="message">
        <xsl:param name="level" select="'fatal'"/>
        <!-- message level: 'warning', 'error', or 'fatal' -->
        <xsl:param name="text" select="'no text given'"/>
        <xsl:choose>
            <xsl:when test="$message = 'silent'"/>
            <xsl:when test="$level = 'warning'">
                <xsl:call-template name="print_message">
                    <xsl:with-param name="level" select="'warning'"/>
                    <xsl:with-param name="terminate" select="'no'"/>
                    <xsl:with-param name="text" select="$text"/>
                </xsl:call-template>
            </xsl:when>
            <xsl:when test="$level = 'error'">
                <xsl:call-template name="print_message">
                    <xsl:with-param name="level" select="'error'"/>
                    <xsl:with-param name="terminate" select="'no'"/>
                    <xsl:with-param name="text" select="$text"/>
                </xsl:call-template>
            </xsl:when>
            <xsl:when test="$level = 'fatal'">
                <xsl:call-template name="print_message">
                    <xsl:with-param name="level" select="'fatal'"/>
                    <xsl:with-param name="terminate" select="'yes'"/>
                    <xsl:with-param name="text" select="$text"/>
                </xsl:call-template>
            </xsl:when>
            <xsl:otherwise>
                <xsl:call-template name="print_message">
                    <xsl:with-param name="level" select="'fatal'"/>
                    <xsl:with-param name="terminate" select="'no'"/>
                    <xsl:with-param name="text" select="concat('fatal:unknown level for message [', $text, ']')"/>
                </xsl:call-template>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>
    <xsl:template name="print_message">
        <!-- this template should never be called from outside; for printing messages, call the "message" template. -->
        <xsl:param name="level"/>
        <xsl:param name="terminate"/>
        <xsl:param name="text"/>
        <xsl:choose>
            <xsl:when test="$message = 'plain'">
                <xsl:message terminate="{$terminate}">
                    <xsl:value-of select="$text"/>
                </xsl:message>
            </xsl:when>
            <xsl:otherwise>
                <xsl:message terminate="{$terminate}">
                    <xsl:value-of select="concat($level, ':', $text)"/>
                </xsl:message>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>
</xsl:stylesheet>

XSLT Processing Model

• XSLT was built as a client-side language
  • the browser has an XML document
  • the XSLT is used to transform this XML
  • the result is used for rendering the formatted document
• XSLT provides facilities for accessing additional documents
  • an additional XML might contain localized texts for rendering
  • like everything in XSLT, identification uses URIs

Opening Documents

• Initially, XSLT starts with the XPath node tree of the main document
  • this step is outside of the control of the XSLT programmer
• Additional documents can be accessed using document()
  • the function accepts URIs, which are interpreted relative to the stylesheet
  • only XML documents can be used, they will be parsed into an XPath tree
• XSLT Processors are smart enough to cache documents
  • re-opening the same document will not re-parse it

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
 <xsl:output method="text"/>
 <xsl:template match="/">
  <xsl:text>me: </xsl:text>
  <xsl:value-of select="count(document('document.xsl')/descendant::*)"/>
  <xsl:text>&#xa;http://dret.net/netdret/publications: </xsl:text>
  <xsl:value-of select="count(document('http://dret.net/netdret/publications')/descendant::*)"/>
 </xsl:template>
</xsl:stylesheet>

Whitespace in Documents

• Documents often contain many irrelevant whitespace text nodes
  • many XML documents are pretty-printed for readability
  • pretty-printing produces many line-feeds and tabs/spaces
• XSLT can be instructed to ignore whitespace nodes
  • strip-space lists all elements for which whitespace children should be ignored
  • this may be a bit too much, because Mixed Content may contain significant whitespace

  <p>do <u>not</u> <em>throw</em> <b>away</b> these whitespace nodes!</p>

• XSLT can be instructed to preserve some whitespace nodes
  • preserve-space lists all elements for which whitespace children should be preserved
  • usually, preserve-space lists the exceptions for strip-space
  • usually, preserve-space contains a list of all mixed content elements

Controlling Whitespace

 <xsl:strip-space elements="*"/>
 <xsl:preserve-space elements="xsl:text"/>
 <xsl:template match="/">
  <xsl:text>xsl:text is used for outputting text.</xsl:text>
  <xsl:text> </xsl:text>
  <xsl:text>it also is the only element where whitespace nodes in the stylesheet are significant</xsl:text>
  <xsl:text>&#xa;</xsl:text>
  <xsl:value-of select="count(//text())"/>
 </xsl:template>

Serialization

• XSLT always produces a result tree
  • stylesheet processing starts with an empty tree (root node only)
  • XSLT code producing output then adds nodes to this tree
  • text, value-of, copy-of, copy, element, attribute, comment, processing-instruction, Literal Result Elements
• Serialization is the process of externalizing the final tree
  • output controls how the tree is serialized
  • xml writes the tree as an XML document
  • html writes the tree as an HTML document (img ... instead of img .../)
  • text writes the tree's string value (the concatenation of all text nodes)

Multiple Output Documents

• XSLT 1.0 does not support more than one output document
  • message is another output channel, but not a document
  • this was one of the most requested features for language improvements
• How can stylesheets produce more than one document?
  • XSLT 1.0 may produce one document which is then post-processed
  • XSLT 2.0 offers language facilities for more than one output document

Document Access

• Some parts of documents may be accessed frequently
  • //person[@ss = $ss]/name/surname for getting a name by social security number
  • costs depend on document size and access frequency
  • the document structure has to be used in all places where the name is used
• Keys provide access to frequently used nodes
  • key('ssKey', $ss)/name/surname is based on a predefined access path (the key)
  • very easy to optimize even for very simple XSLT processors
  • easier to understand from the programmer's point of view
• For nested predicates, non-optimized evaluation is very expensive
  • //reference[@crossref = //reference[@title = $title]/@name]

Declaring and Using Keys

• key defines a key on the stylesheet's top level
  • key name="ssKey" match="person" use="@ss"/
  • name is used for referring to the key (most people use ...Key)
  • match selects all nodes which will be part of the key (i.e., accessible through it)
  • use selects the value(s) which will retrieve the nodes
• key() is used for retrieving nodes from a key
  • the first argument specifies the name of the key (defined by key name="..." ...)
  • the second argument specifies the value for which to look in that key
  • key() returns a node set (empty or any number of nodes)

XML and XSLT for using a Key

<people>
 <entry id="dret" country="de">
  <name>
   <pre>Erik</pre>
   <pre>Thomas</pre>
   <sur>Wilde</sur>
  </name>
  <email>dret@sims.berkeley.edu</email>
  <affiliation country="us">iSchool/UCB</affiliation>
  <phone location="office" type="voice">+1-510-6432253</phone>
  <phone location="office" type="fax">+1-510-6425814</phone>

 <xsl:key name="preNameKey" match="name" use="pre"/>
 <xsl:key name="affiliationKey" match="affiliation" use="."/>
 <xsl:key name="countryKey" match="entry | affiliation" use="@country"/>

• key('preNameKey', 'Thomas') ≡ //name[pre = 'Thomas']

XSLT Key Structure

Using Keys

• Finding nodes by intersecting key() results
  • key() always returns node sets
  • interesting sets of nodes may be the intersection of several keys
  • unfortunately, XPath does not provide an operator for set intersection

Node Set Intersection

$a[count(. | $b) = count($b)]: Find all nodes in $a where the cardinality of $b does not change when adding this node to it. This means the node must be in $b, and it is in $a to start with.

Literal Result Elements

• Non-XSLT elements are copied to the result tree
  • this is the most common way of producing nodes
  • in this case, the nodes' names are hard-coded in the stylesheet
• Attributes are also copied to the result tree
  • this means the attribute will always we there
  • conditional creation of attributes needs other language constructs

Producing Nodes Explicitly

• Element nodes can be produced by using element
  • the element name must be specified and can be computed
  • additional instructions exist for all node types

 <xsl:template match="*">
  <xsl:element name="{translate(local-name(), 'abcdefghijklmnopqrstuvwxyz', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ')}">
   <xsl:apply-templates select="node() | @*"/>
  </xsl:element>
 </xsl:template>
 <xsl:template match="@*">
  <xsl:attribute name="{translate(local-name(), 'abcdefghijklmnopqrstuvwxyz', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ')}">
   <xsl:value-of select="."/>
  </xsl:attribute>
 </xsl:template>

Including and Importing

• XSLT supports two ways of modularizing code
  • including simply distributes code across multiple files
  • importing creates a dependency and a hierarchy
• include is mainly used for keeping files manageable
  • it is used within managed projects
• import is mainly used for reusing code from elsewhere
  • it imports reused code and assigns this code a lower precedence
  • local instructions can then overwrite (if required) some of the imported code

Import Precedence

XSLT in Practice

• XSLT is a simple programming language
• The processing model needs some time to get used to
• Sometimes the language is really too simple
• If you are really interested in XSLT, learn XSLT 2.0!