Embed Size (px)
Citation preview
XSLTExtensible Stylesheet
Language Transformations
CC432 / Short Course 507
Lecturer: Simon Lucas
University of Essex
Spring 2002
Outline• Overview
• Hello World
• The Transformation Process
• XPath
• Iteration, Sorting and Conditionals
• Examples
• Design Guidelines
XSLT Overview
• XML documents are used to mark-up content
• But: this is not very human-friendly
• XML source documents need to be transformed for display purposes
• XSLT is a way of achieving this
• By no means the only way!
XSL: Adding value to HTML
• One view of XSL is as adding value to HTML web-pages
• In this view, one might design an XSL transform by creating a web-page with some sample data in
• Then replacing the sample data with XSL template applications
• The added value is the dynamic data that gets inserted when the transform is now applied to XML source documents
!! Caution !!• Some things in XSL are elegant and easy to
achieve• BUT BEWARE!!!• It is also possible for XSL transforms to
become very complex• Complex XSL docs look ugly, and are hard to
read and debug (though good tools may help)• Therefore: keep it simple!• If your XSL transforms become too complex,
either try to decompose them into a set of simpler transforms
• OR: consider using a different technology
XSL and CSS
• Cascading Style Sheets (CSS) – can also be used to modify presentation of content
• CSS generally used within a browser to modify display of HTML elements
• XSL is much more powerful than CSS – can do sorting, filtering and simple calculations
• CSS can be generated by XSL to produce simple, good looking presentation in compatible browsers
Example Transform Paths
Transform Engine(e.g. Xalan)
XMLSource Doc
XSL-1
XSL-2
HTMLFor Web
PDF forPrinting
Transformation in Browser
• An xml doc can include a stylesheet suggestion
• Compatible browsers will pick up on this, and try to render the XML as HTML
• The next slides show similar XML documents rendered in IE 6
• With and the stylesheet instruction – and with this instruction commented out
hello.xml<?xml version="1.0" ?>
<!–- <?xml-stylesheet
type="text/xsl" href="greetings.xsl"?> -->
<greetings>
<greeting>
hello
</greeting>
<greeting>
bonjour
</greeting>
<greeting>
hola!
</greeting>
</greetings>
Without style sheet
With style sheet
The Transform Process
The Transform Process
• An XSL transform takes an XML source document (tree) and produces a result document.
• The transform engine works by traversing the document source tree, and at each node in the tree working out which templates to apply.
Tree View
• hello.xml /
greeting greeting greeting
greetings
hello holabonjour
Transform Algorithm1. Parse the XSL document2. Parse the Source Document3. Set the context-set to be the root node of the
source document4. Find the most specific template that matches5. Process each element in that template
a. If it is an <xsl:…> instruction, process it; this may involve appending more source elements to the context set e.g. via <xsl:apply-templates> and recursing to step 4
b. Otherwise, copy it to the output
Comments on algorithm
• The transform is complete when the context-set is empty
• Note the recursive step in 5.a
Creating XSL Transforms
XSL Authoring
• To write an XSL transform, consider the source document hierarchy.
• Then, write rules on how to transform this• Each rule does three things:
1.Specifies how it can match a node in the source
2.Specifies what to create in the result document
3.Specifies which child nodes to visit
XSL authoring contd.
• Template matches can be specified as absolute or relative
• Templates can also be given names, and called (invoked) by those names
• This is the closest XSL comes to a function call
Example: Transforming Hello
• We now consider some simple XSL transforms on hello.xml
• They all begin with the same declaration• But we’ll choose various output options• Note that due to the in-built default
template, we get some output even without specifying any user-defined templates
Hello -> text<?xml version="1.0"?><xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method=“text"/>
</xsl:stylesheet>
Which gives:
hello bonjour hola!
Notes on Hello World• The <xsl:stylsheet> attributes specified the
version of XSL to use, and the name-space• We also specified the output method• Common choices are xml, html and text• “text” ignores any elements created during
the transform process• “xml” and “html” options include these
elements, but add different <meta> tags
Built in default template
• To allow an entire document to be processed, the following default template is set up:
<xsl:template match=“*|/”>
<xsl:apply-templates/>
</xsl:template>• Since this is very general, it is overridden by
more specific template matches in the supplied XSL document
Hello -> HTML • Here we illustrate a transform to produce a
simple HTML document• The preamble is much as before• We then match the greetings element below
the document root• And call <apply-templates> to match the rest
of the child nodes• Only the <greetings> elements find matching
templates• Note the way HTML is interspersed with XSL
(just the templates)<xsl:template match="/greetings"> <html> <head> <title> Greetings </title> </head> <body> <center> <h1> Greetings </h1> </center> <hr/> <xsl:apply-templates/> </body> </html></xsl:template>
<xsl:template match="greeting"> <h3> <xsl:value-of select="." /> </h3></xsl:template>
Output in a Browser
An identity transformation (elements only)
<?xml version="1.0"?><xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method=“xml"/>
<xsl:template match="/"> <xsl:apply-templates/></xsl:template>
<xsl:template match="*"> <xsl:element name="{name()}" > <xsl:apply-templates/> </xsl:element></xsl:template>
</xsl:stylesheet>
Notes on identity transform
• A wild-card ‘*’ is used to match any elements• We use <xsl:element> to create a new
element, for each element that the template matches
• The curly braces indicate that the expression should be evaluated
• name() is the Xpath expression that gives the name of the current node
Testing the identity transform• With hello.xml as input, produced:
<?xml version="1.0" encoding="UTF-8"?><greetings> <greeting> hello </greeting> <greeting> bonjour </greeting> <greeting> hola! </greeting></greetings>
• Note that the xml declaration on line 1 is due to the output type being set to “xml”
XPath
• So far we’ve looked at an example of how to match some templates to a source document
• The standard for specifying which elements to match is called XPath
• We’ll now see how to do some basic matching using XPath
<xsl:template match= "/">
• The above template matches the document root
• The fact that it begins with a slash means it specifies an absolute location
• other examples:– match=“*” – matches anything– match=“author”
• Can use ‘|’ as OR in a match
Navigating Trees
• Recall the source document is a tree
• Helpful to relate this to a directory tree on a file system
• Can access the parent or set of children
• Can make accesses relative or absolute
• Can also use wild-cards
• But careful: can be costly
Iteration• XSL gives us two ways of iterating:• <xsl:for-each>• <xsl:apply-templates>• <apply-templates> is often to be preferred,
since this leads to a design that employs more templates, but each one is smaller
• With for-each, the iteration is done in-line in the current template
• However, the for-each method looks like the for-loops we’re all familiar with, and can sometimes be easier to understand initially
‘Function Calling’
• <xsl:call-template> can be used to invoke a specific named template
• This can also specify parameters for the call
• In this way, can also iterate via recursive calls <xsl:call-template>
<xsl:apply-templates>
• One use of XPath expression is in specifying which templates to match from the context node
• Simplest usage is with no arguments:– <xsl:apply-templates/>
• This applies any matching templates to the child elements of the context node
<xsl:apply-templates> contd
• A given element may have many different types of child element
• Apply templates allows us to select which children we want
• E.g. <xsl:apply-templates select=“author”>
• Looks only for author elements i.e. <author> … </author>
Sorting with XSL
• When applying templates, we can select a sort: <xsl:sort>
• This element can appear within a <for-each> or <apply-templates> element (i.e. the main ways of iterating over a set of nodes)
Sort Example - Greetings<xsl:template match="/greetings"> <html> <head> <title> Greetings </title> </head> <body> <center> <h1> Greetings </h1> </center> <hr/> <xsl:apply-templates select="greeting"> <xsl:sort select="." /> </xsl:apply-templates> </body> </html></xsl:template>
Also Illustrate use of position()
<xsl:template match="greeting">
<h3> <xsl:value-of select="position()" />.
<xsl:value-of select="." />
</h3>
</xsl:template>
Expressions
• Used to perform various useful functions• Take arguments of various types• And return single values of various types• e.g. position() – returns the position of this
node among its siblings in the document tree – is affected by <sort> in the way that you would normally want
• position() takes no arguments, and returns a value of type number
Datatypes
• Xpath and XSLT define five datatypes• node-set: can contain any number of
nodes (including zero)• boolean : the value true or false• number : a floating point number• string : zero or more characters• result tree fragment : gets created by
certain XSLT statements
Predicates• Boolean expressions in square brackets can
be used to filter node sets• Suppose we have language attributes: <greeting lang="english"> hello
</greeting>
• Then – can select all English greetings: <xsl:apply-templates select="greeting[@lang=english]">
<xsl:sort select="." />
</xsl:apply-templates>
• Could also filter using conditional instructions
Conditionals
<xsl:if test=“boolean expression”>
• The <xsl:if> instruction evaluates its boolean expression, and if true, its child elements are processed e.g.
<xsl:if test=“position()=1”>
<xsl:text> This is the first sibling! </xsl:text>
</xsl:if>• Note that the <text> tags could have been omitted – they just make the
textual output stricter
• Has no ‘else’ clause
<xsl:choose>• Use the <xsl:choose> instruction with
<xsl:otherwise> if an else clause is needed<xsl:choose>
<xsl:when test=“bool-exp1”>
…
</xsl:when>
<xsl:when test=“bool-exp1”>
…
</xsl:when>
<xsl:otherwise>
…
</xsl:otherwise>
</xsl:choose>
Sorted and Numbered
Attributes
• Select attributes from source doc using the @ notation
• Create attributes in result doc using <xsl:attribute>
• Or by using {}:– <a href=“ref:{position()}” > link </a>
Navigation - Axes
• The abbreviated notation is most commonly used to navigate the source document
• For example, select=“..” identifies the parent of the current node.
• The unabbreviated notation can also be used: select=“parent”
• Various other axes are defined to navigate on other criteria, such as ancestor, child, descendant, attribute etc.
Slides ExampleDTD, XML and XSL for very
simple slides
Illustrates creation of links within a document
Slides Example – DTD
<!-- DTD for slides example -->
<!ELEMENT Presentation (Title, Slide*)>
<!ELEMENT Title (#PCDATA)>
<!ELEMENT Slide (Title, BP*)>
<!ATTLIST Slide level CDATA #IMPLIED>
<!ELEMENT BP (#PCDATA)>
Slides Example – XML
<?xml version="1.0"?><!DOCTYPE Presentation SYSTEM "slides.dtd">
<?xml-stylesheet type="text/xsl" href="slides1.xsl"?>
<Presentation>
<Title> A Short Presentation on XML </Title> <Slide level="basic" > <Title>Brief History of XML</Title> <BP>Derived from SGML</BP> <BP>Nearly as powerful</BP> <BP>Easier to Use</BP> </Slide>
slide.xml continued….
<!-- not really an advanced slide! - just illustrates an attribute-->
<Slide level="advanced">
<Title>XML Syntax</Title>
<BP>An XML Document begins with some declarations</BP>
<BP>The body consists of a tree of elements</BP>
<BP>Each element consists of a begin-end tag pair</BP>
<BP>Which may have other elements embedded within</BP>
<BP>Elements may also have attributes</BP>
<BP>Which must be defined within the opening tag</BP>
</Slide>
</Presentation>
Slides Example – XSL• This example shows illustrates a
procedural XSL style, with few templates and heavy reliance on nested for loops
• Possible to create more elegant versions with a greater number of smaller, simpler templates
slides.xsl (cont)
<?xml version="1.0"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0" >
<xsl:template match ="/"> <html> <body> <center> <h2> <xsl:value-of select="Presentation/Title" />
</h2> </center>
<hr> </hr>
slides.xsl (cont) <!-- create the links -->
<ul>
<xsl:for-each select="Presentation/Slide">
<li>
<a>
<xsl:attribute name="href">
<xsl:text>#Slide-</xsl:text>
<xsl:value-of select="Title" />
</xsl:attribute>
<xsl:value-of select="Title" />
</a>
</li>
</xsl:for-each>
</ul>
<!-- now the actual slides --> <xsl:for-each select="Presentation/Slide"> <hr> </hr> <center> <h3> <a> <xsl:attribute name="name"> <xsl:text>#Slide-</xsl:text> <xsl:value-of select="Title" /> </xsl:attribute> <xsl:value-of select="Title" /> </a> </h3> </center> <ul> <xsl:for-each select="BP" > <li> <xsl:value-of select="." /> </li> </xsl:for-each> </ul> </xsl:for-each>
</body> </html> </xsl:template> </xsl:stylesheet>
Some Design Guidelines
Designing for ease of maintenance and greater re-use
Design Style
• Break the transform down into lots of simple templates
• This makes each template easier to debug
• Also fosters greater reuse
Further Design Principles
• However, under the added-value view, we should be careful to ensure that the XSL documents are well designed
• For example, keep them general, and ensure that any volatile data (in fact, probably any data!) is extracted from the XML source doc, rather than specified in the XSL transform doc.
• This is a footnote to the Once and Once Only principle of software engineering
• Not just once and once only, but also in the right place!
Root Glossary TemplateWhat’s wrong, and how would you fix it?
<xsl:template match="/glossary"> <html> <head> <title> Glossary of XML Terms </title> </head> <body> <center> <h1> Glossary of XML Terms </h1> </center> <hr/> <xsl:apply-templates/> </body> </html></xsl:template>
Sources of Confusion
• XSL can sometimes be confusing and hard to debug
• The main source of confusion arises from not knowing which templates are being applied -
• Since at any one time, there can be any number of possible matching templates
• The other problem is that because of the of the forgiving default template, XSLs that are buggy with respect to how you intended them to work, can still appear to work perfectly!!!
• Except that later on, an innocent change can break it in unexpected ways!
When to apply the transforms
Client?
Server-static?
Server-dynamic?
In the client( browser)
• Takes load off the server
• BUT: only supported by recent browsers (e.g. IE 6)
• May slow down the browsing experience (more requests, more computation) – though you won’t notice this on simple examples
Server-static
• Here, we apply the transforms to create HTML pages, in advance of requests for those pages
• The client and server workload is now identical to if the HTML pages had been authored with an HTML editor
• BUT: the process requires careful management to keep the pages updated
Server-dynamic
• Here the pages are dynamically produced (i.e. transformed) in response to requests
• BUT: a significant workload on the server• Content will be as up-to-date as the XML
source documents (which may themselves be dynamically generated)
• Caching may be used to reduce the workload
Conclusions
• XSL is a technology for transforming XML source documents into a variety of output formats
• We’ve covered some of the most important features of it – but there are many instructions and functions that we’ve left out (see further reading)
• XSL is a good technology to use, providing what you want to do can be expressed easily
• XSL has limitations! Do not use XSL for complex calculations (beware even using it for simple ones!)
Further Reading
• XSLT: Mastering XML Transformations– Doug Tidwell, O’Reilly, 2001
• XSLT Specification– http://www.w3.org/TR/xslt
• XSLT Reference guide– http://www.zvon.org/xxl/XSLTreference/Output/
