Abstract

Advanced XSLT processing includes better control of the input and output documents, which can be 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 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>
   <given>Erik</given>
   <given>Thomas</given>
   <sur>Wilde</sur>
  </name>
  <email>dret@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="givenNameKey" match="name" use="given"/>
 <xsl:key name="affiliationKey" match="affiliation" use="."/>
 <xsl:key name="countryKey" match="entry | affiliation" use="@country"/>

• key('givenNameKey', 'Thomas') ≡ //name[given = 'Thomas']

XSLT Key Structure

• key('givenNameKey', 'Thomas') → 2 nodes (1, 2)
• key('countryKey', 'us') → 3 nodes (1b, 3a, 3b)
• key('countryKey', 'us')/self::entry → 1 node (3a)

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 be 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!
  • this will also take you 80% along the way to learning XQuery