XSLT

XSLT stands for Extensible Stylesheet Language Transformations.

Links

• https://www.w3.org/TR/xslt
• http://www.w3schools.com/xsl/
• http://xmlsoft.org/XSLT/xslt.html

Gnome library

exslt (extensions)

• http://exslt.org/

Extensions supported in libxml (xsltproc processor)

XPath

• https://www.w3.org/TR/xpath/ — Reference specification, which has several xpath examples at the top.

Overview

Currently there are two versions of the XSLT standards: XSLT 1.0 and XSLT 2.0.

XSLT 1.0

On linux, the standard XSLT 1.0 processor is xsltproc (from package xsltproc, libxml2 library).

In XSLT 1.0, most functions come from XSLT extensions (like http://exslt.org/).

XSLT 2.0

• On linux, the standard XSLT 2.0 processor is saxonb-xslt (from package libsaxonb-java).
• XSLT 2.0 introduces XQuery, XPath 2.0, and XSLT functions (with prefix fn:). See here for a detailed list of features.

Extensions

From w3.org [1]:

• The element extension mechanism allows namespaces to be designated as extension namespaces. When a namespace is designated as an extension namespace and an element with a name from that namespace occurs in a template, then the element is treated as an instruction rather than as a literal result element.

Extensions available in the XSLT processor

Using xsltproc (package xsltproc [2], we can get the list of built-in extensions with:

xsltproc --dumpextensions 
# Registered XSLT Extensions
# --------------------------
# Registered Extension Functions:
# {http://exslt.org/math}atan2
# {http://exslt.org/strings}align
# ...

exslt.org/crypto

• "Hidden" extensions that provides basic crypto functions (apparently from patch [3], introduced in July 5 2004 [4])
• See also [5]
• CAUTION — These extensions are not available if using a custom implementation of Python like Anaconda

xsltproc --dumpextensions|grep crypto
# {http://exslt.org/crypto}rc4_decrypt
# {http://exslt.org/crypto}md4
# {http://exslt.org/crypto}sha1
# {http://exslt.org/crypto}md5
# {http://exslt.org/crypto}rc4_encrypt

Example of use:

<xsl:template match="rootnode">
<xsl:value-of select="crypto:md5('ahahah')"/>
</xsl:template>

Quick reference

Minimal stylesheet

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

</xsl:stylesheet>

This is the minimal stylesheet. Another solution is to use an xsl:transform element, which is a synonym to xsl:stylesheet [6].

<?xml version="1.0"?>
<books>
  <book>
    <title>XML in a Nutshell</title>
    <editor>O'Reilly</editor>
  </book>
  <book>
    <title>XSL in a Nutshell</title>
    <editor>O'Reilly</editor>
  </book>
</book>

When applied to the example XML file above (with xsltproc minimal.xsl example.xml), the minimal stylesheet produces this result:

<?xml version="1.0"?>

  
    XML in a Nutshell
    O'Reilly
  
  
    XSL in a Nutshell
    O'Reilly

The result is not empty. This is because by default XSLT has a default template for text node that simply copy the content of the node without transform.

xsl:attribute

Input	Output
<link site="www.stackoverflow.com"/>	<a href="http://www.stackoverflow.com">Click here</a>

Use

<xsl:template match="link">
    <a>
        <xsl:attribute name="href">
            <xsl:text>http://</xsl:text><xsl:value-of select="@site"/>
        </xsl:attribute>
        <xsl:text>Link</xsl:text>
    </a>
</xsl:template>

Or shorter using curly braces {...} [7]:

<xsl:template match="link">
    <a href="http://{@site}">Click here</a>
</xsl:template>

Also for:

• Using variables (like in <a href="http://{$varName}">Click here</a>)

func:functions

References:

• exslt:func extension
• XSLT 1.0 functions

Using the exslt:func extension, we can define functions in XSLT 1.0.

Here an example stylesheet:

Stylesheet <?xml version="1.0"?> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:func="http://exslt.org/functions" xmlns:exsl="http://exslt.org/common" xmlns:str="http://exslt.org/strings" xmlns:my="http://myserver.org/xsl/functions" extension-element-prefixes="func" exclude-result-prefixes="exsl str func my"> <func:function name="my:dirname"> <xsl:param name="filename" /> <func:result> <xsl:for-each select="exsl:node-set(str:tokenize($filename,'/'))"> <xsl:if test="(position()!=1) and (position()!=last())">/</xsl:if> <xsl:if test="position()!=last()"><xsl:value-of select="."/></xsl:if> </xsl:for-each> </func:result> </func:function> <xsl:template match="file"> <directory><xsl:value-of select="my:dirname(.)"/></directory> </xsl:template> </xsl:stylesheet>

Input <?xml version="1.0"?> <root> <file>your/dir/file.ext</file> <file>more/directory/with space/dir/file.ext</file> <file>file.ext</file> <file></file> </root>

We get the following result (xsltproc style.xsl data.xml):

<?xml version="1.0"?>

    <directory>your/dir</directory>
    <directory>more/directory/with space/dir</directory>
    <directory/>
    <directory/>

Some remarks:

• extension-element-prefixes="func" is mandatory, or xsltproc will complain with meaning less errors like:

{http://myserver.org/xsl/functions}dirname: called with too many arguments
xsltApplySequenceConstructor: param was not compiled
xsltApplySequenceConstructor: for-each was not compiled

Types

Boolean

Boolean are constructed with expression false() and true() [8].

<xsl:variable name="var_false" select="false()"/>
<xsl:variable name="var_true" select="true()"/>

which is same as

<xsl:variable name="var_false" select="1 = 0"/>
<xsl:variable name="var_true" select="'true' = 'true'"/>

String

Test for empty

<!-- Test if a string in variable 'var' is empty -->
<xsl:variable name="is_var_empty" select="$var = ''"/>

Use multi-token str:replace

Using node-set:

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:exsl="http://exslt.org/common" xmlns:str="http://exslt.org/strings" exclude-result-prefixes="exsl str">

    <xsl:template match="/">
        <xsl:variable name="from"><a>a</a><a>b</a></xsl:variable>
        <xsl:variable name="to"><a>A</a><a>B</a></xsl:variable>
        <xsl:value-of select="str:replace('abcde',exsl:node-set($from)/a,exsl:node-set($to)/a)"/>
    </xsl:template>
</xsl:stylesheet>

This changes the string abcde into ABcde. Note the special construct exsl:node-set($from)/a, where the trailing /a is necessary to tell which elements to use.

Another solution is to use str:split to build a node set in expression context:

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:exsl="http://exslt.org/common" xmlns:str="http://exslt.org/strings" exclude-result-prefixes="exsl str">

    <xsl:template match="/">
        <xsl:value-of select="str:replace('abcde',str:split('ab',''),str:split('AB',''))"/>
    </xsl:template>
</xsl:stylesheet>

Result Tree Fragment vs Node Tree

These are XSLT 1.0 concepts [9]:

Node Tree

These are built using something like

<xsl:variable name="n" select="---some-path-expression" />

Result is a set of nodes, actually a set of references to nodes. These are original nodes in the source document, and they retain their original position in the source document, which means for example that you can process each node in the set to ask how many ancestors it has.

Result Tree Fragment

Result Tree Fragment (RTF) are called temporary tree in XSLT 2.0. These are built using something like

<xsl:variable name="n" />
---some-instruction---
</xsl:variable>

The result is a new document. The term "fragment" comes from DOM, and means a document that isn't constrained to have a single element at the top level. The nodes in this tree are newly constructed nodes; they may be copies of nodes in the source tree (or not) but they have separate identity and have lost their relationships to other nodes in the source tree.

Expressions and XPath

Test that two element references are the pointing to same element

<xsl:if test='generate-id(A)=generate-id(B)'>  <!-- XPath 1.0 -->
<xsl:if test='A is B'>                         <!-- XPath 2.0 -->

Match all elements y that are not the first element of a parent element c

<xsl:template match="y[not(generate-id(.) = generate-id(ancestor::c//y)[1])]" />

XSLT Elements

Reference: w3schools - XSLT Elements Reference

<xsl:message>

The <xsl:message> element writes a message to the output. This element is primarily used to report errors. It can also be used to log XSLT processing activity [10].

<xsl:message terminate="yes|no">
<!-- Content:template -->
</xsl:message>

<xsl:import>

Imports the contents of one style sheet into another.

• Has lower priority than the importing stylesheet
• Must be first child of <xsl:stylesheet>

<xsl:import href="URI"/>

<xsl:include>

Includes the contents of one style sheet into another.

• Has same priority than the importing stylesheet
• Must be first child of <xsl:stylesheet>

<xsl:include href="URI"/>

Patterns

Overriding the identity transformation

Overriding the identity transformation is one of the most fundamental XSLT design patterns [11], [12].

The principle is to start with the identity transformation

<xsl:template match="node()|@*">                <!-- Whenever you match any node or any attribute -->
  <xsl:copy>                                    <!-- Copy the current node --
     <xsl:apply-templates select="node()|@*"/>  <!-- Including any attributes it has and any child nodes -->
  </xsl:copy>
</xsl:template>

and then override this template with a more specific one that has priority:

<xsl:template match="Element[@fruit='apple' and @animal='cat']"/>

Here the template will simply delete any element with attributes <... fruit='apple' animal='cat'>.

Variants

There are two variants of the identity template in common use. This version:

<xsl:template match="*">
    <xsl:copy>
        <xsl:copy-of select="@*"/>
        <xsl:apply-templates/>
    </xsl:copy>
</xsl:template>

processes all *elements* by copying them, and can be overridden for individual elements.

This version:

<xsl:template match="node()|@*">
    <xsl:copy>
        <xsl:apply-templates select="@*|node()"/>
    </xsl:copy>
</xsl:template>

processes all *nodes* by copying them, and can be overridden for individual elements, attributes, comments, processing instructions, or text nodes.

Tips

Output tags like <?fileVersion 4.0.0 ?>

Use a xsl:text tag with attribute disable-output-escaping="yes": [13]:

<xsl:template match="/">
<xsl:text disable-output-escaping="yes">&lt;?fileVersion 4.0.0?&gt;</xsl:text>
</xsl:template>

This will produce:

<?fileVersion 4.0.0?>

Generate a random UID

<xsl:stylesheet
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    xmlns:data="http://exslt.org/dates-and-times"
    xmlns:math="http://exslt.org/math"
    extension-element-prefixes="date math"
    version='1.0'>
<!-- .... -->
<xsl:variable name="noncels" select="floor(math:random()*800)+100"/>
<xsl:variable name="noncems" select="data:seconds(date:date-time())-date:seconds('1970-01-01T00:00:00')"/>
<!-- .... -->
<xsl:value-of select="concat($noncems,noncels+0)"/>
</xsl:stylesheet>

Beautify / indent an XML file

Use the identity transform: [14]

<?xml version="1.0" encoding="UTF-8" ?>
<xsl:transform xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
    <xsl:output method="xml"  encoding="UTF-8" indent="yes" />
    <xsl:strip-space elements="*"/>

    <xsl:template match="@*|node()">
        <xsl:copy>
            <xsl:apply-templates select="@*|node()"/>
        </xsl:copy>
    </xsl:template>
</xsl:transform>

Add an attribute to an existing element

We cannot use <copy-of>, which does not allow to modify an element. Instead we must use <copy>, which copies only the element name and namespace, and complete as necessary as in code below [15]:

<xsl:template match="/root/Algemeen/foto/img">
    <xsl:copy>
        <xsl:attribute name="width">100</xsl:attribute>
        <xsl:apply-templates select="@*|node()" />
    </xsl:copy>
</xsl:template>

Use str:split or str:tokenize to generate node-set in expression context

Using str:split and str:tokenize is an effective way to build a node-set in expression context:

<xsl:template match="/">
    <xsl:value-of select="str:replace('abcde',str:split('abcde',''),str:tokenize('one|two,three/four-five','|,/-'))"/>
</xsl:template>

The example above generates two node-sets to use the multi-token version of str:replace.

Examples

Simple <xsl:template>

XSLT file <?xml version='1.0' encoding="UTF-8"?> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version='1.0'> <xsl:output method="text" indent="no" encoding="UTF-8"/> <xsl:param name="PARAM"/> <xsl:template match="project"> <xsl:text/>This template will replace 'project' by a simple <xsl:value-of select="$PARAM"/><xsl:text/> </xsl:template> </xsl:stylesheet> Source file <?xml version="1.0"?> <project name="myproject"> <target name="myname"/> </project> Processed with xsltproc -param PARAM "'text'" style.xsl source output This template will replace 'project' by a simple text

Spaces and CR

XSLT file <?xml version='1.0' encoding="UTF-8"?> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version='1.0'> <xsl:output method="text" indent="no" encoding="UTF-8"/> <xsl:param name="WORLD"/> <xsl:template match="project"> <xsl:text>CR/spaces are preserved... inside 'xsl:text'.</xsl:text> <xsl:text> But spaces/CR between two tags are deleted.</xsl:text> Except if ... it contains non-blanks. <xsl:text/>So better use empty text tags<xsl:text/> <xsl:text/> to eat spaces/CR, while still using ... xslt <xsl:value-of select="$PARAM"/><xsl:text/> </xsl:template> </xsl:stylesheet> Source file <?xml version="1.0"?> <project name="myproject"> <target name="myname"/> </project> Processed with xsltproc -param PARAM "'parameters.'" style.xsl source output CR/spaces are preserved... inside 'xsl:text'. But spaces/CR between two tags are deleted. Except if ... it contains non-blanks. So better use empty text tags to eat spaces/CR, while still using ... xslt parameters.

Using entities

XSLT file <?xml version='1.0' encoding="UTF-8"?> <!DOCTYPE xsl:stylesheet [ <!ENTITY cr '<xsl:text xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> </xsl:text>'> <!ENTITY space '<xsl:text xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> </xsl:text>'> <!ENTITY param '<xsl:value-of xmlns:xsl="http://www.w3.org/1999/XSL/Transform" select="$PARAM"/>'> <!ENTITY entity '<xsl:value-of xmlns:xsl="http://www.w3.org/1999/XSL/Transform" select="$ENTITY"/>'> ]> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version='1.0'> <xsl:output method="text" indent="no" encoding="UTF-8"/> <xsl:template match="project"> <xsl:text/>Use entities for special characters like<xsl:text/> <xsl:text/>&cr;&cr;<xsl:text/> carriage return <xsl:text/>&cr;&cr;<xsl:text/> <xsl:text/>or "<xsl:text/>&space;&space;&param;&space;&space;<xsl:text/> <xsl:text/>" where normal "<xsl:text/> <xsl:text/> &param; <xsl:text/>" or <xsl:text/> <xsl:text/>carriage return<xsl:text/> <xsl:text/> <xsl:text/> does not work. Using &entity; is also shorter than using 'xsl:value-of' tags. </xsl:template> </xsl:stylesheet> Source file <?xml version="1.0"?> <project name="myproject"> <target name="myname"/> </project> Processed with xsltproc -param PARAM "'space'" -param ENTITY "'entities'" style.xsl source output Use entities for special characters like carriage return or " space " where normal "space" or carriage return does not work. Using entities is also shorter than using 'xsl:value-of' tags.

Using template parameters

XSLT file <?xml version='1.0' encoding="UTF-8"?> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version='1.0'> <xsl:output method="text" indent="no" encoding="UTF-8"/> <xsl:template match="project"> <xsl:text/>Calling template by matching, passing a string: <xsl:apply-templates select="target"> <xsl:with-param name="PARAM" select="'a string'"/> </xsl:apply-templates> Calling template by matching, passing a GLOBALPARAM: <xsl:apply-templates select="target"> <xsl:with-param name="PARAM" select="$GLOBALPARAM"/> </xsl:apply-templates> Calling template by name <xsl:call-template name="named"> <xsl:with-param name="PARAM" select="'a string'"/> </xsl:call-template> </xsl:template> <xsl:template match="target"> <xsl:param name="PARAM"/> <xsl:text/>parameter is <xsl:value-of select="$PARAM"/><xsl:text/> </xsl:template> <xsl:template name="named"> <xsl:param name="PARAM"/> <xsl:text/>parameter is <xsl:value-of select="$PARAM"/><xsl:text/> </xsl:template> </xsl:stylesheet> Source file <?xml version="1.0"?> <project name="myproject"> <target name="myname"/> </project> Processed with xsltproc -param GLOBALPARAM "'global param'" style.xsl source output Calling template by matching, passing a string: parameter is a string Calling template by matching, passing a GLOBALPARAM: parameter is global param Calling template by name parameter is a string

Simple <xsl-apply-templates> and .

XSLT file <?xml version='1.0' encoding="UTF-8"?> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version='1.0'> <xsl:output method="text" indent="no" encoding="UTF-8"/> <xsl:template match="project"> <xsl:apply-templates select="target/*"/> </xsl:template> <xsl:template match="content"> <xsl:text/>dot is '<xsl:value-of select="."/>', <xsl:text/> </xsl:template> </xsl:stylesheet> Source file <?xml version="1.0"?> <project name="myproject"> <target name="target1"> <content>content1</content> <content>content2</content> <content>content3</content> </target> </project> Processed with xsltproc style.xsl source output dot is 'content1', dot is 'content2', dot is 'content3',

Example of <xsl:for-each>

XSLT file <?xml version='1.0' encoding="UTF-8"?> <!DOCTYPE xsl:stylesheet [ <!ENTITY name '<xsl:value-of xmlns:xsl="http://www.w3.org/1999/XSL/Transform" select="@name"/>'> ]> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version='1.0'> <xsl:output method="text" indent="no" encoding="UTF-8"/> <xsl:template match="project"> <xsl:text/>Simple for-each loop: <xsl:for-each select="target/*"><xsl:text/>dot is '<xsl:value-of select="."/>', </xsl:for-each> For-each loop with select condition: <xsl:for-each select="target/content[@id='second']">&name;, </xsl:for-each> </xsl:template> </xsl:stylesheet> Source file <?xml version="1.0"?> <project name="myproject"> <target name="target1"> <content id='first' name="only">content1</content> <content id='second' name="double">content2</content> <content id='third' name="last">content3</content> </target> </project> Processed with xsltproc style.xsl source output Simple for-each loop: dot is 'content1', dot is 'content2', dot is 'content3', For-each loop with select condition: double,

Example of <xsl:choose>

XSLT file <?xml version='1.0' encoding="UTF-8"?> <!DOCTYPE xsl:stylesheet [ <!ENTITY name '<xsl:value-of xmlns:xsl="http://www.w3.org/1999/XSL/Transform" select="@name"/>'> ]> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version='1.0'> <xsl:output method="text" indent="no" encoding="UTF-8"/> <xsl:template match="project"> <xsl:apply-templates select="target/*"/> </xsl:template> <xsl:template match="target/*"> <xsl:text/><xsl:variable name="TGTTYPE"> <xsl:choose> <xsl:when test="@type='small'"> <xsl:text/><xsl:value-of select="small"/><xsl:text/> </xsl:when> <xsl:otherwise> <xsl:text/><xsl:value-of select="big"/><xsl:text/> </xsl:otherwise> </xsl:choose> </xsl:variable><xsl:text/> <xsl:text/>We have <xsl:value-of select="$TGTTYPE"/> for <xsl:value-of select="@type"/>. </xsl:template> </xsl:stylesheet> Source file <?xml version="1.0"?> <project name="myproject"> <target name="target1"> <content type='small'><small>content1</small><big>CONTENT1</big></content> <content type='big'><small>content2</small><big>CONTENT2</big></content> <content type='small'><small>content3</small><big>CONTENT3</big></content> </target> </project> Processed with xsltproc style.xsl source output We have content1 for small. We have CONTENT2 for big. We have content3 for small.

Template with match rule and dynamic entity

XSLT file <?xml version='1.0' encoding="UTF-8"?> <!DOCTYPE xsl:stylesheet [ <!ENTITY name '<xsl:value-of xmlns:xsl="http://www.w3.org/1999/XSL/Transform" select="@name"/>'> ]> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version='1.0'> <xsl:output method="text" indent="no" encoding="UTF-8"/> <xsl:template match="project/target/*"> <xsl:value-of select="@type"/> </xsl:template> </xsl:stylesheet> Source file <?xml version="1.0"?> <project name="myproject"> <target name="target1"> <content type='small'><small>content1</small><big>CONTENT1</big></content> <content type='big'><small>content2</small><big>CONTENT2</big></content> <content type='small'><small>content3</small><big>CONTENT3</big></content> </target> </project> Processed with xsltproc style.xsl source output small big small

More complex apply-templates, with dynamic entities

XSLT file <?xml version='1.0' encoding="UTF-8"?> <!DOCTYPE xsl:stylesheet [ <!ENTITY name '<xsl:value-of xmlns:xsl="http://www.w3.org/1999/XSL/Transform" select="@name"/>'> ]> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version='1.0'> <xsl:output method="text" indent="no" encoding="UTF-8"/> <xsl:template match="project"> <xsl:apply-templates select="target/*"/> </xsl:template> <xsl:template match="project/target/*"> <xsl:value-of select="@type"/> </xsl:template> </xsl:stylesheet> Source file <?xml version="1.0"?> <project name="myproject"> <target name="target1"> <content type='small'><small>content1</small><big>CONTENT1</big></content> <content type='big'><small>content2</small><big>CONTENT2</big></content> <content type='small'><small>content3</small><big>CONTENT3</big></content> </target> </project> Processed with xsltproc style.xsl source output smallbigsmall

Using namespace

XSLT file <?xml version='1.0' encoding="UTF-8"?> <!DOCTYPE xsl:stylesheet [ <!ENTITY name '<xsl:value-of xmlns:xsl="http://www.w3.org/1999/XSL/Transform" select="@name"/>'> ]> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:ns="http://your.server.org/your/xsl/url/MYNS" exclude-result-prefixes="xsl ns" version='1.0'> <xsl:output method="text" indent="no" encoding="UTF-8"/> <xsl:template match="ns:project"> <xsl:apply-templates select="ns:target/*"/> </xsl:template> <xsl:template match="ns:project/ns:target/*"> <xsl:if test="@type='small'">SMALL </xsl:if> <xsl:if test="@type='big'">BIG </xsl:if> </xsl:template> </xsl:stylesheet> Source file <?xml version="1.0"?> <ns:project xmlns:ns="http://your.server.org/your/xsl/url/MYNS" name="myproject"> <ns:target name="target1"> <ns:content type='small'>content1</ns:content> <ns:content type='big'>content2</ns:content> <ns:content type='small'>content3</ns:content> </ns:target> </ns:project> Processed with xsltproc style.xsl source output SMALL BIG SMALL

Example of expressions

XSLT file <?xml version='1.0' encoding="UTF-8"?> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:math="http://exslt.org/math" extension-element-prefixes="math" version='1.0'> <xsl:output method="xml" indent="yes" encoding="UTF-8"/> <xsl:template match="project"> <xsl:apply-templates select="target/*"/> </xsl:template> <xsl:template match="project/target/*"> <p> <msg>dot is current tag content, here '.' is '<xsl:value-of select="."/>'</msg> <msg attr="{.}">Use braces {...} in attributes</msg> <msg random="unique.{floor(math:random()*2147483647)}">{...} can be any expression</msg> </p> </xsl:template> </xsl:stylesheet> Source file <?xml version="1.0"?> <project name="myproject"> <target name="target1"> <content type='small'>content1</content> <content type='big'>content2</content> <content type='small'>content3</content> </target> </project> Processed with xsltproc style.xsl source output <?xml version="1.0" encoding="UTF-8"?> <p> <msg>dot is current tag content, here '.' is 'content1'</msg> <msg attr="content1">Use braces {...} in attributes</msg> <msg random="unique.799522789">{...} can be any expression</msg> </p><p> <msg>dot is current tag content, here '.' is 'content2'</msg> <msg attr="content2">Use braces {...} in attributes</msg> <msg random="unique.90206728">{...} can be any expression</msg> </p><p> <msg>dot is current tag content, here '.' is 'content3'</msg> <msg attr="content3">Use braces {...} in attributes</msg> <msg random="unique.2005052793">{...} can be any expression</msg> </p>

Generate custom XML tags

XSLT file <?xml version='1.0' encoding="UTF-8"?> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:math="http://exslt.org/math" extension-element-prefixes="math" version='1.0'> <xsl:output method="xml" indent="yes" encoding="UTF-8"/> <xsl:template match="project"> <xsl:text disable-output-escaping="yes">&lt;?fileVersion 4.0.0?&gt;</xsl:text><cproject id="my project"/> <p>Use 'disable-output-escaping' to generate xml tags.</p> </xsl:template> </xsl:stylesheet> Source file <?xml version="1.0"?> <project name="myproject"> <target name="target1"> <content type='small'>content1</content> <content type='big'>content2</content> <content type='small'>content3</content> </target> </project> Processed with xsltproc style.xsl source output <?xml version="1.0" encoding="UTF-8"?> <?fileVersion 4.0.0?><cproject id="my project"/><p>Use 'disable-output-escaping' to generate xml tags.</p>

Removing white spaces

XSLT file <?xml version='1.0' encoding="UTF-8"?> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version='1.0'> <xsl:output method="xml" indent="yes" version="1.0" encoding="UTF-8" standalone="no"/> <xsl:template match="project"> <project> <xsl:apply-templates select="*"/> </project> </xsl:template> <xsl:template match="target"> <cleaned_target><xsl:value-of select="normalize-space(.)"/></cleaned_target> </xsl:template> </xsl:stylesheet> Source file <?xml version="1.0"?> <project name="myproject"> <target>no_space_at_all</target> <target> with_space_around </target> <target>with carriage returns </target> <target>with spaces between the words</target> </project> Processed with xsltproc style.xsl source output <?xml version="1.0" encoding="UTF-8" standalone="no"?> <project> <cleaned_target>no_space_at_all</cleaned_target> <cleaned_target>with_space_around</cleaned_target> <cleaned_target>with carriage returns</cleaned_target> <cleaned_target>with spaces between the words</cleaned_target> </project>

Two-stage xml using variables and node-set

References:

• http://www.usingxml.com/Transforms/XslPipelines (see example below)
• http://www.xml.com/pub/a/2003/07/16/nodeset.html (very detailed example).

XSLT file <?xml version='1.0' encoding="UTF-8"?> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:exsl="http://exslt.org/common" exclude-result-prefixes="exsl" version='1.0'> <xsl:variable name="myvar"> <xsl:apply-templates select="books" mode="stageone"/> </xsl:variable> <xsl:template match="book" mode="stageone"> <title><xsl:value-of select="title"/></title> </xsl:template> <xsl:template match="/"> <!-- Must use mode="...", or we have recursion since we match "/" --> <xsl:apply-templates select="exsl:node-set($myvar)" mode="stagetwo"/> </xsl:template> <xsl:template match="title" mode="stagetwo"> <p><xsl:value-of select="."/></p> </xsl:template> </xsl:stylesheet> Source file <?xml version="1.0"?> <books> <book> <title>XML in a Nutshell</title> <editor>O'Reilly</editor> </book> <book> <title>XSL for the Noobs</title> <editor>O'Reilly</editor> </book> </books> Processed with xsltproc style.xsl source output <?xml version="1.0"?> <p>XML in a Nutshell</p> <p>XSL for the Noobs</p>

Using call-template

XSLT file <?xml version='1.0' encoding="UTF-8"?> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version='1.0'> <xsl:template match="*"> <xsl:call-template name="wrap_with_p"> <xsl:with-param name="content" select="concat('abc','def')"/> </xsl:call-template> </xsl:template> <xsl:template name="wrap_with_p"> <xsl:param name="content"/> <p><xsl:value-of select="$content"/></p> </xsl:template> </xsl:stylesheet> Source file <?xml version="1.0"?> <title>XSL for the Noobs</title> Processed with xsltproc style.xsl source output <?xml version="1.0"?> <p>abcdef</p>

Example recursive function

<xsl:template name="escape">
    <xsl:param name="content"/>
    <xsl:if test="string-length($content)>0">
    <xsl:choose>
        <xsl:when test="starts-with($content,'(')"><xsl:text>\(</xsl:text><xsl:call-template name="escapeForMake"><xsl:with-param name="content" select="substring($content, 2)"/></xsl:call-template></xsl:when>
        <xsl:when test="starts-with($content,')')"><xsl:text>\)</xsl:text><xsl:call-template name="escapeForMake"><xsl:with-param name="content" select="substring($content, 2)"/></xsl:call-template></xsl:when>
        <xsl:when test="starts-with($content,'\')"><xsl:text>\\</xsl:text><xsl:call-template name="escapeForMake"><xsl:with-param name="content" select="substring($content, 2)"/></xsl:call-template></xsl:when>
        <xsl:otherwise>
            <xsl:value-of select="substring($content,1,1)"/>
            <xsl:call-template name="escapeForMake">
                <xsl:with-param name="content" select="substring($content, 2)"/>
            </xsl:call-template>
        </xsl:otherwise>
    </xsl:choose>
    </xsl:if>
</xsl:template>

Call it as follow:

<xsl:call-template name="escape"><xsl:with-param name="content"> select="@synopsis" /></xsl:call-template>

Note that the same template could be implemented using string extension:

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:func="http://exslt.org/functions" xmlns:exsl="http://exslt.org/common" xmlns:str="http://exslt.org/strings" extension-element-prefixes="func" xmlns:my="http://myserver.org/xsl/functions" exclude-result-prefixes="exsl str func my">

    <func:function name="my:escape">
        <xsl:param name="filename" />
        <func:result>
            <xsl:value-of select="str:replace(str:replace(str:replace($filename,'\','\\'),'(','\('),')','\)')" />
        </func:result>
    </func:function>

    <xsl:template match="file">
        <directory><xsl:value-of select="my:escape()"/></directory>
    </xsl:template>
</xsl:stylesheet>

Or even shorter, using the multi-token version of str:replace:

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:func="http://exslt.org/functions" xmlns:exsl="http://exslt.org/common" xmlns:str="http://exslt.org/strings" extension-element-prefixes="func" xmlns:my="http://myserver.org/xsl/functions" exclude-result-prefixes="exsl str func my">

    <func:function name="my:escape">
        <xsl:param name="filename" />
        <func:result>
            <xsl:value-of select="str:replace($filename,str:split('()\',''),str:split('\(,\),\\',','))" />
        </func:result>
    </func:function>

    <xsl:template match="file">
        <directory><xsl:value-of select="my:escape()"/></directory>
    </xsl:template>
</xsl:stylesheet>

Example using node-set to compute sum-products

From http://www.xml.com/pub/a/2003/07/16/nodeset.html:

Stylesheet <?xml version="1.0" encoding="utf-8"?> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:exsl="http://exslt.org/common" extension-element-prefixes="exsl" version="1.0"> <xsl:template match="/"> <html> <head> <title>Invoice</title> </head> <body> <h1>Invoice</h1> <!-- Format invoice items as a table --> <table border="1" style="text-align: center"> <tr> <th>Description</th> <th>Quantity</th> <th>Unit price</th> <th>Subtotal</th> </tr> <xsl:for-each select="invoice/item"> <tr> <td><xsl:value-of select="description"/></td> <td><xsl:value-of select="qty"/></td> <td><xsl:value-of select="unitPrice"/></td> <td><xsl:value-of select="qty * unitPrice"/></td> </tr> </xsl:for-each> <tr> <th colspan="3">Total</th> <th> <!-- Gather subtotals into variable --> <xsl:variable name="subTotals"> <xsl:for-each select="invoice/item"> <number> <xsl:value-of select="qty * unitPrice"/> </number> </xsl:for-each> </xsl:variable> <!-- Sum subtotals stored as a result tree fragment in the variable --> <xsl:value-of select="sum(exsl:node-set($subTotals)/number)"/> </th> </tr> </table> </body> </html> </xsl:template> </xsl:stylesheet>

source <?xml version="1.0" encoding="utf-8"?> <invoice> <item> <description>Pilsner Beer</description> <qty>6</qty> <unitPrice>1.69</unitPrice> </item> <item> <description>Sausage</description> <qty>3</qty> <unitPrice>0.59</unitPrice> </item> <item> <description>Portable Barbecue</description> <qty>1</qty> <unitPrice>23.99</unitPrice> </item> <item> <description>Charcoal</description> <qty>2</qty> <unitPrice>1.19</unitPrice> </item> </invoice>

In particular, we observe:

• We first construct a set of sub-totals with

<xsl:variable name="subTotals"> 
  <xsl:for-each  select="invoice/item">
    <number><xsl:value-of select="qty * unitPrice"/></number>
  </xsl:for-each>
</xsl:variable>

• Then we compute the sum with

sum(exsl:node-set($subTotals)/number).

Note the special construct node-set(...)/number, and not simply node-set(...).

Miscellaneous

• <xsl:param name="MYPARAM"> in <xsl:stylesheet> node declares a global parameter.

After this declaration we can use $MYPARAM to get the value of the parameter. If it is not declared, we can only use $MYPARAM if it is passed as a parameter (e.g. via command line xsltproc -param MYPARAM "'myparamvalu'"), otherwise an error is triggered.