(5) Input and Output

(7) Templates as Building Blocks

• Templates are the main unit of code
  • the match attribute defines which nodes are processed by a template
  • whenever such a node needs to be processed, the template is executed (applied)
  • XPaths are interpreted with the matched node as context
• Templates contain a mix of Literal Result Elements [XML Transformations (XSLT) – Part IV; Literal Result Elements (1)] and XSLT code
  • Literal Result Elements [XML Transformations (XSLT) – Part IV; Literal Result Elements (1)] and text nodes are copied to the result tree
  • XSLT elements are executed (depending on their semantics)
  • apply-templates plays a special role because it selects nodes to be processed
• The template application process is special
  • probably the most challenging aspect when learning the language
  • XSLT is much easier to use when understanding the underlying principle

(8) Basic Mechanics

1. The source node list contains only the root node
2. The result tree is created by inserting the result from processing a node from the source node list
3. Processing typically puts more nodes on the source node list
4. The process is repeated until the source node list is empty

 <xsl:template match="/ | *">
  <xsl:text>( Element: </xsl:text>
  <xsl:value-of select="local-name()"/>
  <xsl:apply-templates select="@* | *"/>
  <xsl:text>)</xsl:text>
 </xsl:template>

 <xsl:template match="@*">
  <xsl:text>Attribute: </xsl:text>
  <xsl:value-of select="local-name()"/>
 </xsl:template>

(9) Template Selection

• Templates are connected through two statements
  • apply-templates selects which are put on the source node list
  • the XSLT processor selects the best template and executes it
• What happens if there is no template?
  • templates use Patterns [Patterns (1)] to specify their applicability
  • users may not specify a template for a node they select
  • instead of an error, Built-In Templates [Built-In Templates (1)] are used to handle this situation

(10) Patterns

• Patterns are a subset of XPath
  • they are used to specify to which nodes certain language constructs apply
  • patterns specify a set of conditions on a node
• The specification is short, but hard to understand
  • A node matches a pattern if the node is a member of the result of evaluating the pattern as an expression with respect to some possible context; the possible contexts are those whose context node is the node being matched or one of its ancestors. [http://www.w3.org/TR/xslt#patterns]
• Practically, patterns are node tests, node contexts, and predicates
  • * matches any element
  • tr matches tr elements
  • thead/tr matches tr elements within thead elements
  • p[@class='warning'] matches p elements with their class set to warning
  • these mechanisms can be combined (and connected by the union operator |)

(11) Pattern-Based Processing

    <ul>
     <xsl:for-each select="/people/entry">
      <li>
       <xsl:value-of select="concat(name/given[1], ' ', name/sur, ': ')"/>
       <xsl:apply-templates select="*[local-name() != 'name']"/>
      </li>
     </xsl:for-each>
    </ul>
   </body>
  </html>
 </xsl:template>
 <xsl:template match="email">
  <a href="mailto:{.}" title="{.}">✉</a>
  <xsl:text> </xsl:text>
 </xsl:template>
 <xsl:template match="phone">
  <a href="tel:{.}" title="{@location}/{@type}:{.}">☎</a>
  <xsl:text> </xsl:text>
 </xsl:template>
 <xsl:template match="affiliation"/>

(13) XSLT Default Behavior

• Built into every XSLT processor
  • covering all seven XPath node types
  • the XSLT processor always finds a template to process a node
• Conflicts are thus also built into the language
  • every user template is in conflict with a built-in template
  • Conflict Resolution [Conflict Resolution (1)] is a core concept of XSLT

(14) Root and Elements

• The most important node types
  • every XML document has a root and at least one element
• The default behavior traverses the tree recursively
  • the recursion only selects child nodes (the default is select="node()")
  • attributes are not children of the elements nodes!

 <xsl:template match="* | /">
  <xsl:apply-templates/>
 </xsl:template>

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

</xsl:stylesheet>

(15) Text and Attributes

• These nodes create text output
• The processing does not continue with apply-templates
  • text and attribute nodes are always leaf nodes
• Attributes are not selected by the built-in rules
  • they are only processed when selected by a user instruction

 <xsl:template match="text() | @*">
  <xsl:value-of select="."/>
 </xsl:template>

(16) Processing Instructions and Comments

• These nodes are ignored
• Processing instructions and comments are selected by the built-in rules
  • the built-in behavior can be overwritten if required

 <xsl:template match="processing-instruction() | comment()"/>

(18) Template Selection

• XSLT processes nodes on the source node list [Basic Mechanics (1)]
• For processing each node, the best template must be found
• XSLT supports incremental development
  • templates can be added for more specialized processing
  • other code does not have to be changed at all
  • the source node list provides support for this decoupling
• For simple cases, the default mechanism is sufficient
  • advanced XSLT programming sometimes requires manual intervention

(19) Template Selection

1. All templates with a match attribute
   • this excludes Named Templates [XML Transformations (XSLT) – Part III; Named Templates (1)]
2. All templates with the same mode
   • part of the apply-templates instruction selecting the node
3. The Pattern [Patterns (1)] must match
4. If more than one template matches, order by import precedence
   • the import tree of the stylesheet is considered (this includes the built-in rules)
5. If more than one template matches, order by priority
   • this sorts rules according to the specificity
6. Execute resulting rule
   • if still more than one, signal error or execute last in stylesheet

(20) Import Precedence

(21) Priorities

• Template priorities are computed
  • a very simple pattern-based process
  • a higher value means it is a better match
• Five steps are used to compute the priority
  1. templates using the union operator are treated as if there were multiple templates
  2. QNames and processing instructions are assigned a priority of 0
  3. Namespace-prefixed names are assigned a priority of 0.25
  4. other node tests with axis specifiers are assigned a priority of -0.25
  5. all other patterns are assigned a priority of 0.5

(22) Different Conflicts

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
 <xsl:template match="/">
  <xsl:apply-templates select="descendant::a"/>
 </xsl:template>
 <xsl:template match="*"/>
 <xsl:template match="a"/>
 <xsl:template match="b/a"/>
 <xsl:template match="c/b/a"/>
</xsl:stylesheet>

<?xml version="1.0" encoding="UTF-8"?>
<c>
 <b>
  <a/>
 </b>
</c>

(23) Resolution Process

(24) Adjusting Priorities

• Computed priorities always lie between -0.5 and 0.5
• Non-trivial patterns almost always have the priority 0.5
• Priorities can be set explicitly
  • template match="…" priority="1"
• Managing priority values is up to the programmer
  • it is rarely necessary to manage a large set of competing priorities

(26) Document-Driven Transformations

• XSLT often requires document-driven programming
• Imperative programmers are more used to control the program flow
• Document-driven processing is a powerful design principle
• Complex (highly variable) documents are much better handled by document-driven processing