Listed below are some of the new features added to the XSLT 2.0 specification:

That’s just a few of the new features in XSLT 2.0; next, I’ll discuss some of the new ones found in XPath 2.0.

Following are just a handful of some of the new features added to the XPath 2.0 specification:

This is by no means a complete review of all the changes and additions to XSLT 2.0 or XPath 2.0—it’s just a quick discussion of a good number of them. These are working drafts; it is possible that they will change somewhat before they become recommendations. Fortunately, you can start playing with some of the new features today by using Saxon 7.7 (or later), which is an experimental implementation of XSLT 2.0 and XPath 2.0. The remaining sections of this chapter will try out some of these features, the first of which is result-document element.

In the last chapter, you used the saxon:output extension element to create more than one result tree from a single stylesheet. XSLT 2.0 has integrated this functionality into the mainstream of the specification with the result-document element. The following example shows you how to use this element to produce three result trees from one source tree.

Example 16-1, the document functions.xml in examples/ch16, describes the new context-related functions from XPath 2.0.

<?xml version="1.0"?>
   
<functions type="context">
 <function>
  <name>fn:context-item(  )</name>
 <description>Returns the context item.</description>
 </function>
 <function>
  <name>fn:position(  )</name>
  <description>Returns the position of the context item within the sequence of items 
currently being processed.</description>
 </function>
 <function>
  <name>fn:last(  )</name>
  <description>Returns the number of items in the sequence of items currently being processed.</description>
 </function>
 <function>
  <name>fn:current-dateTime(  )</name>
  <description>Returns the current xs:dateTime.</description>
 </function>
 <function>
  <name>fn:current-date(  )</name>
  <description>Returns the current xs:date.</description>
 </function>
 <function>
  <name>fn:current-time(  )</name>
  <description>Returns the current xs:time.</description>
 </function>
 <function>
  <name>fn:default-collation(  )</name>
  <description>Returns the value of the default collation property from the static context.</description>
 </function>
 <function>
  <name>fn:implicit-timezone(  )</name>
  <description>Returns the value of the implicit timezone property from the evaluation context.</description>
 </function>
</functions>

The descriptions of the functions are from the specification. The fn:position( ) and fn:last( ) functions are the same as the position( ) and last( ) functions from XPath 1.0. The fn:context-item( ) function is similar to the current( ) function available from XSLT 1.0 and XSLT 2.0. Usually, a context item is the same as the current item, except when a predicate is involved.

Example 16-2, the context.xsl stylesheet, produces four result trees based on functions.xml. The default result tree is text, and the three others are for XML, HTML, and XHTML output, respectively.

<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="text"/>
<xsl:output name="xml" method="xml" indent="yes"/>
<xsl:output name="html" method="html" indent="yes"/>
<xsl:output name="xhtml" method="html" indent="yes"/>
<xsl:param name="dir">file:///C:/LearningXSLT/examples/ch16</xsl:param>
   
<xsl:template match="functions">
 <xsl:text>XPath 2.0 Context Functions&#10;</xsl:text>
 <xsl:text>Date: </xsl:text>
 <xsl:value-of select="current-date(  )"/>
 <xsl:text>&#10;</xsl:text>
 <xsl:apply-templates select="function" mode="text"/>
 <xsl:result-document format="xml" href="{$dir}/context.xml">
 <xsl:message terminate="no">Printing text result tree...</xsl:message>
  <list>
   <description>XPath 2.0 Context Functions</description>
   <date><xsl:value-of select="current-date(  )"/></date>
    <xsl:message terminate="no">Printing XML result tree in functions.xml...</xsl:message>
    <xsl:apply-templates select="function" mode="xml"/>
  </list>
 </xsl:result-document>
 <xsl:result-document format="html" href="{$dir}/context.html">
  <xsl:message terminate="no">Printing HTML result tree in functions.html...</xsl:message>
  <html>
  <body>
  <h2>XPath 2.0 Context Functions</h2>
  <h3>Date: <xsl:value-of select="current-date(  )"/></h3>
  <ul>
   <xsl:apply-templates select="function" mode="html"/>
  </ul>
  </body>
  </html>
 </xsl:result-document>
 <xsl:result-document format="xhtml" href="{$dir}/context-x.html">
  <xsl:message terminate="no">Printing XHTML result tree in functions-x.html...</xsl:message>
  <html xmlns="http://www.w3.org/1999/xhtml">
  <body>
  <h2>XPath 2.0 Context Functions</h2>
  <h3>Date: <xsl:value-of select="current-date(  )"/></h3>
  <ol>
   <xsl:apply-templates select="function" mode="xhtml"/>
  </ol>
  </body>
  </html>
 </xsl:result-document>
</xsl:template>
   
<xsl:template match="function" mode="text">
 <xsl:text> - </xsl:text>
 <xsl:value-of select="name"/>
 <xsl:text>&#10;</xsl:text>
</xsl:template>
   
<xsl:template match="function" mode="xml">
 <function><xsl:value-of select="name"/></function>
</xsl:template>
   
<xsl:template match="function" mode="html">
 <li><xsl:value-of select="name"/></li>
</xsl:template>
   
<xsl:template match="function" mode="xhtml">
 <li xmlns="http://www.w3.org/1999/xhtml"><xsl:value-of select="name"/></li>
</xsl:template>
   
</xsl:stylesheet>

The version attribute on stylesheet shows the 2.0 version number. There are four output elements, three of which are named. This allows a result-document element to reference an output element by name, hence to use the information in it. A global parameter named dir holds the name of the directory where three of the result trees are written as files. This information is referenced by the attribute value template {$dir} in the href attributes on the result-document elements. You could pass in a new value for the dir parameter if you want to change the destination of the output.

The template matching functions creates a text result tree, plus three other result trees inside result-document elements. Each result tree issues its own message using the message element. Each result tree also applies templates to a template matching function, though each in a different mode (text, xml, html, and xhtml). The different modes for each result help create an appropriate tree for each of the given formats. The new current-date( ) function is called in each result tree, too.

To get this to work, you need to use a full Java version of Saxon, preferably Version 7.7 or later, available from http://saxon.sourceforge.net or in the examples/ch16 directory as saxon7-7.zip (the JAR file saxon7.jar has already been extracted from saxon7-7.zip). For specific instructions on how to download, install, and use Saxon with the Java interpreter, see the appendix.

Once everything is installed and working, you can type this command:

java -jar saxon7.jar functions.xml context.xsl

and you will get the following text result tree, plus messages about the other three:

Printing text result tree...
Printing XML result tree in context.xml...
Printing HTML result tree in context.html...
Printing XHTML result tree in context-x.html...
XPath 2.0 Context Functions
Date: 2003-08-26
 - fn:context-item(  )
 - fn:position(  )
 - fn:last(  )
 - fn:current-dateTime(  )
 - fn:current-date(  )
 - fn:current-time(  )
 - fn:default-collation(  )
 - fn:implicit-timezone(  )

The files that the three result-document elements produced contain the other result trees. The first one is context.xml:

<?xml version="1.0" encoding="UTF-8"?>
<list>
   <description>XPath 2.0 Context Functions</description>
   <date>2003-10-03</date>
   <function>fn:context-item(  )</function>
   <function>fn:position(  )</function>
   <function>fn:last(  )</function>
   <function>fn:current-dateTime(  )</function>
   <function>fn:current-date(  )</function>
   <function>fn:current-time(  )</function>
   <function>fn:default-collation(  )</function>
   <function>fn:implicit-timezone(  )</function>
</list>

The second is context.html, an HTML document that uses an unordered (bulleted) list:

<html>
   <body>
      <h2>XPath 2.0 Context Functions</h2>
      <h3>Date: 2003-10-03</h3>
      <ul>
         <li>fn:context-item(  )</li>
         <li>fn:position(  )</li>
         <li>fn:last(  )</li>
         <li>fn:current-dateTime(  )</li>
         <li>fn:current-date(  )</li>
         <li>fn:current-time(  )</li>
         <li>fn:default-collation(  )</li>
         <li>fn:implicit-timezone(  )</li>
      </ul>
   </body>
</html>

And the third is context-x.html, an XHTML document that uses an ordered (numbered) list:

<html xmlns="http://www.w3.org/1999/xhtml">
   <body>
      <h2>XPath 2.0 Context Functions</h2>
      <h3>Date: 2003-10-03</h3>
      <ol>
         <li>fn:context-item(  )</li>
         <li>fn:position(  )</li>
         <li>fn:last(  )</li>
         <li>fn:current-dateTime(  )</li>
         <li>fn:current-date(  )</li>
         <li>fn:current-time(  )</li>
         <li>fn:default-collation(  )</li>
         <li>fn:implicit-timezone(  )</li>
      </ol>
   </body>
</html>

As you can see, result-document provides a great convenience creating more than one result tree from just one stylesheet. Next is an example that uses regular expressions.

Regular expressions allow you to define specific patterns for searching strings of text. XML Schema supports regular expressions, and XSLT 2.0 relies on XML Schema-style regular expressions. Table 16-1 shows a sampling of symbols used in regular expressions that XSLT 2.0 supports. The table represents only a few of the possibilities.

In regular expressions, you can mix these symbols with actual characters to form a search string. For example, using these symbols, you could match:

XPath 2.0 adds three new functions for use with regular expressions: matches( ), replace( ) , and tokenize( ) . For more information on these new functions, see Section 7.5 of the functions and operators specification for XPath 2.0 and XQuery 1.0 at http://www.w3.org/TR/xpath-functions/. XSLT 2.0 offers the new analyze-string element. See Section 15 of the XSLT 2.0 spec at http://www.w3.org/TR/xslt20/ for more information on that. I’ll show you examples of the matches( ) and replace( ) functions, and the analyze-string element.

<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" indent="yes"/>
   
<xsl:template match="functions">
 <xsl:element name="list">
  <xsl:element name="description">XPath 2.0 Context Functions</xsl:element>
  <xsl:element name="date">
   <xsl:value-of select="current-date(  )"/>
  </xsl:element>
   <xsl:apply-templates select="function"/>
 </xsl:element>
</xsl:template>
   
<xsl:template match="function">
 <xsl:copy>
  <xsl:if test="matches(name,'^fn:')">
                  <xsl:value-of select="substring(name, 4)"/>
                  </xsl:if>
 </xsl:copy>
</xsl:template>
   
</xsl:stylesheet>

java -jar saxon7.jar functions.xml match.xsl

<?xml version="1.0" encoding="UTF-8"?>
<list>
   <description>XPath 2.0 Context Functions</description>
   <date>2003-10-03</date>
   <function>context-item(  )</function>
   <function>position(  )</function>
   <function>last(  )</function>
   <function>current-dateTime(  )</function>
   <function>current-date(  )</function>
   <function>current-time(  )</function>
   <function>default-collation(  )</function>
   <function>implicit-timezone(  )</function>
</list>

<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" indent="yes"/>
   
<xsl:template match="functions">
 <xsl:element name="list">
  <xsl:element name="description">XPath 2.0 Context Functions</xsl:element>
  <xsl:element name="date">
   <xsl:value-of select="current-date(  )"/>
  </xsl:element>
   <xsl:apply-templates select="function"/>
 </xsl:element>
</xsl:template>
   
<xsl:template match="function">
 <xsl:copy>
  <xsl:value-of select="replace(name, '^fn:', '')"/>
 </xsl:copy>
</xsl:template>
   
</xsl:stylesheet>

java -jar saxon7.jar functions.xml replace.xsl

<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" indent="yes"/>
   
<xsl:template match="functions">
 <xsl:element name="list">
  <xsl:element name="description">XPath 2.0 Context Functions</xsl:element>
  <xsl:element name="date">
   <xsl:value-of select="current-date(  )"/>
  </xsl:element>
   <xsl:apply-templates select="function"/>
 </xsl:element>
</xsl:template>
   
<xsl:template match="function">
 <xsl:copy>
 <xsl:analyze-string select="name" regex="^fn:">
                  <xsl:matching-substring></xsl:matching-substring>
                  <xsl:non-matching-substring>
                  <xsl:value-of select="."/>
                  </xsl:non-matching-substring>
                  </xsl:analyze-string>
 </xsl:copy>
</xsl:template>
   
</xsl:stylesheet>

java -jar saxon7.jar functions.xml regex.xsl

<?xml version="1.0" encoding="UTF-8"?>
<list>
   <description>XPath 2.0 Context Functions</description>
   <date>2003-08-26</date>
   <function>context-item(  )</function>
   <function>position(  )</function>
   <function>last(  )</function>
   <function>current-dateTime(  )</function>
   <function>current-date(  )</function>
   <function>current-time(  )</function>
   <function>default-collation(  )</function>
   <function>implicit-timezone(  )</function>
</list>

Grouping in XSLT is the process by which you can group nodes based on a given criterion. In XSLT 1.0, the process is a little complicated and requires somewhat elaborate expressions, often employing the preceding-sibling axes to check whether a node belongs to a group. You could also group nodes with a key using the Muenchian method, which was demonstrated in Chapter 11. You can also read about how to do XSLT 1.0 grouping in Chapter 6 of Doug Tidwell’s XSLT (O’Reilly) or in Chapter 9 of Michael Kay’s XSLT Programmer’s Reference, Second Edition (Wrox). I prefer grouping in XSLT 2.0 because it is much simpler and easier to explain, the ease of which probably grew out of my experience with grouping in Version 1.0

Grouping in XSLT 1.0 usually brings the for-each instruction element into service. XSLT 2.0 has a new instruction element called for-each-group that makes grouping a relative snap. I’ll show you how in the following example.

Glance at group2.xml , in Example 16-6, which lumps the XPath 2.0’s context-related functions into two piles by labeling them with a type attribute.

<?xml version="1.0"?>
   
<list>
 <description>XPath 2.0 Context Functions</description>
 <date>2003-10-03</date>
 <function type="new">context-item(  )</function>
 <function type="new">current-date(  )</function>
 <function type="new">current-dateTime(  )</function>
 <function type="new">current-time(  )</function>
 <function type="new">default-collation(  )</function>
 <function type="new">implicit-timezone(  )</function>
 <function type="legacy">last(  )</function>
 <function type="legacy">position(  )</function>
</list>

The eight functions in this list are either legacy or new functions. The group2.xsl stylesheet, in Example 16-7, groups the functions in group2.xml according to the content of the type attribute.

<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" indent="yes"/>
   
<xsl:template match="list">
<xsl:copy>
 <xsl:for-each-group select="function" group-by="@type">
  <functions type="{@type}">
   <xsl:value-of select="current-group(  )" separator=", "/>
  </functions>
 </xsl:for-each-group>
</xsl:copy>
</xsl:template>
   
</xsl:stylesheet>

The for-each-group function selects the node-set to group with the select attribute—all function children of list, that is. The group-by attribute determines the key for grouping, which, in this case, is the content of the type attribute in the source. The functions literal result element uses an attribute value template to reflect the value of the type attribute.

The value-of element’s select attribute uses the current-group( ) function—also a new kid on the block in XSLT 2.0—to keep track of which group is which. The separator attribute is also a new addition to XSLT 2.0. It tells the XSLT 2.0 processor to write a comma followed by a space after each found node is sent to the result tree.

You might guess correctly that for-each-group has several other attributes, which it does, namely, group-adjacent, group-starting-with, group-ending-with, and collation. I’m not going to cover them here, but you can read more about for-each-group and its attributes in Section 14 of the XSLT 2.0 specification.

Use this command to transform group.xml:

java -jar saxon7.jar group2.xml group2.xsl

The result is two lists of functions, grouped and comma-separated, in functions elements:

<?xml version="1.0" encoding="UTF-8"?>
<list>
   <functions type="new">context-item(  ), current-date(  ), current-dateTime(  ), 
current-time(  ), default-collation(  ), implicit-timezone(  )</functions>
   <functions type="legacy">last(  ), position(  )</functions>
</list>

This example should give you a feel of how to group nodes in XSLT 2.0. In the example that follows, you will learn how to use the new top-level function element.

You learned about external extension functions in the last chapter. You can now add extension functions on the stylesheet level in XSLT 2.0 using the function element. These are called stylesheet functions, but they work like any extension function in an expression. The difference is that they are completely portable between one XSLT 2.0 processor and another.

Example 16-8, function.xsl , uses function to declare a stylesheet function.

<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:xs="http://www.w3.org/2001/XMLSchema-datatypes"
xmlns:wy="http://www.wyeast.net/functions">
<xsl:output method="text"/>
<xsl:function name="wy:kilometers">
               <xsl:param name="miles" as="xs:decimal"/>
               <xsl:sequence select="$miles * 1.609347"/>
               </xsl:function>
   
<xsl:template match="/">
 <xsl:apply-templates select="trip"/>
</xsl:template>
   
<xsl:template match="trip">
 <xsl:apply-templates select="distance"/>
</xsl:template>
   
<xsl:template match="distance">
 <xsl:text>The distance from </xsl:text>
 <xsl:value-of select="location"/>
 <xsl:text> to </xsl:text>
 <xsl:value-of select="destination"/>
 <xsl:text> is </xsl:text>
 <xsl:value-of select="round(wy:kilometers(miles))"/>
 <xsl:text> kilometers.&#10;</xsl:text>
</xsl:template>
   
</xsl:stylesheet>

When I tested this, it appeared that stylesheet functions must have at least one argument, but this may not be the case, given that 2.0 is still in the early stages. Stylesheet functions must also be identified with a QName that uses a prefix (this is to ensure that user-defined functions don’t clash with system-defined functions). The namespace URI and prefix associated with the QName in this example is http://www.wyeast.net/functions and wy:, respectively. It’s declared on the stylesheet element.

The function element must be on the top level and declares the stylesheet function named wy:kilometers( ). The function performs a simple conversion of miles to kilometers by accepting a single parameter, miles. Parameters for stylesheet functions are defined with param elements but cannot have default values. The new as attribute on param declares the value of miles as an xs:decimal value, according to the boundaries set by XML Schema datatypes (the namespace is declared on the document element).

The new XSLT 2.0 sequence element adds a sequence of nodes or atomic values to the result tree. In this case, it returns a product (a single atomic value) and works much like value-of. In other situations, you can add existing nodes to a sequence with this element, not just new ones. The factor for converting miles to kilometers (1.609347) comes from the National Institute of Standards and Technology (NIST), and is based on the U.S. survey foot (see http://physics.nist.gov/Pubs/SP811/appenB8.html).

The wy:kilometers( ) function is called later in the stylesheet in a value-of element. It takes a miles node as an argument, and its return value is rounded up or down with the round( ) function. The result is output as text, embedded in a sentence formed from the nodes in the source tree.

Soon, you’ll apply this stylesheet to trip.xml, shown in Example 16-9, which holds the road mileage between several U.S. cities.

<?xml version="1.0"?>

<trip>
 <distance>
  <location>Tucson</location>
  <destination>Flagstaff</destination>
  <miles>253</miles>
 </distance>
 <distance>
  <location>Portland</location>
  <destination>Medford</destination>
  <miles>272</miles>
 </distance>
 <distance>
  <location>Denver</location>
  <destination>Colorado Springs</destination>
  <miles>67</miles>
 </distance>
</trip>

Perform the transformation with:

java -jar saxon7.jar trip.xml function.xsl

You will see this outcome on your screen:

The distance from Tucson to Flagstaff is 407 kilometers.
The distance from Portland to Medford is 438 kilometers.
The distance from Denver to Colorado Springs is 108 kilometers.

The wy:kilometers( ) stylesheet function may be reused as often as you need it in this stylesheet. A stylesheet function can also be included or imported from another stylesheet.

XSLT 2.0 and XPath 2.0 offer an almost overwhelming number of new features. Some have complained about the new versions of XSLT and XPath on this count. Personally, I like most of the new offerings and, fortunately, no one is forced to adopt all the new functionality. Nevertheless, the terminology will definitely require devotees to plow deeply into the new specifications in order to get a grip on it.

This chapter lightly introduced you to many highlights from these new technologies. It also walked you through how to output multiple result documents, define and use regular expressions, use grouping, and create stylesheet functions.

The next chapter shows programmers how to use APIs to write your own interface to an XSLT processor.