Extensions to XSLT 1.0, and XSLT 2.0

Transcription

1 ...

2 Extensions A typical problem: XSLT 1.0 does not have any way of finding the current date and time. However, some XSLT 1.0 processors allow you to use extensions to XSLT 1.0. The EXSLT initiative tries to standardize extension functions that are common across processors, to increase portability.

3 Extensions for date One of the extensions described at is for handling dates and times. It provides a lot of functions that you can use in your stylesheet: date:date-time, date:date, date:time, date:year, date:leap-year, date:month-in-year, date:month-name, date:month-abbreviation, date:week-in-year, date:day-in-year, date:day-in-month, date:day-of-week-in-month, date:day-in-week, date:day-name, date:day-abbreviation, date:hour-in-day, date:minute-in-hour, date:second-in-minute.

4 Using extension date functions The function date:date() can be used to get the current date and time. We will have to add a namespace declaration to the stylesheet, and mark it as an extension:. <xsl:stylesheet version="1.0" xmlns:date=" xmlns:xsl=" extension-element-prefixes="date">... <xsl:variable name="now" select="translate(date:date(),'-','')"/> <xsl:apply-templates se- lect="atom:entry[translate(substring(ev:startdate,1,10),'- ','')>$now]"/>... </xsl:stylesheet>...

5 Another use of date function We can also use the function called date:day-name to output the day associated with the date. From. <xsl:template name="outputday"> <xsl:param name="date"/> <xsl:value-of select="date:day-name($date)"/> </xsl:template> <xsl:template match="atom:entry"> <xsl:call-template name="outputday"> <xsl:with-param name="date" select="ev:startdate"/> </xsl:call-template>. </xsl:template>.. We will get output like: Monday 5 March 2007

6 Another extension: node-set() Sometimes we want to apply some XSL to what we are creating, not the input. Suppose we want to mark the last item in a sequence:. <xsl:template match="person"> <xsl:if test="position()>1"> <xsl:text>, </xsl:text> </xsl:if> <xsl:if test="position()=last()"> <xsl:text> and </xsl:text> </xsl:if> <xsl:value-of select="birth"/>. </xsl:template>..

7 but if we sort the <person> elements. <xsl:template match="/"> <xsl:apply-templates select="//person"> <xsl:sort select="birth"/> </xsl:apply-templates> </xsl:template> <xsl:template match="tei:person"> <xsl:value-of select="tei:age"/> <xsl:text>, </xsl:text> <xsl:if test="position()=last()"> <xsl:text> and </xsl:text> </xsl:if>. </xsl:template>.. the position() returns the position of the elements before the sort.

8 What we would like to do. <xsl:template match="/"> <xsl:variable name="sortedpeople"> <people> <xsl:for-each select="//person"> <xsl:sort select="birth"/> <xsl:copy-of select="."/> </xsl:for-each> </people> </xsl:variable> <xsl:applytemplates select="$sortedpeople/people/person"/> </xsl:template> <xsl:template match="person"> <xsl:if test="position()>1"> <xsl:text>, </xsl:text> </xsl:if> <xsl:if test="position()=last()"> <xsl:text> and </xsl:text> </xsl:if> <xsl:value-of select="birth"/>. </xsl:template>.. but that is illegal.

9 Answer using extension. <xsl:stylesheet extension-elementprefixes="exsl" version="1.0"> <xsl:template match="/"> <xsl:variable name="sortedpeople"> <people> <xsl:for-each select="//person"> <xsl:sort select="birth"/> <xsl:copy-of select="."/> </xsl:for-each> </people> </xsl:variable> <xsl:apply-templates select="exsl:nodeset($sortedpeople)/people/person"/> </xsl:template> <xsl:template match="person"> <xsl:if test="position()>1"> <xsl:text>, </xsl:text> </xsl:if> <xsl:if test="position()=last()"> <xsl:text> and </xsl:text> </xsl:if> <xsl:value-of select="birth"/> </xsl:template>

10 A second version was XSLT was approved in January 2007, along with a second version of XPath. This introduced some important new facilities: xsl:function Defining your own functions Formal XPath extension mechanism Extending XPath unparsed-text() and unparsed-text-available() Reading non-xml documents, and checking whether something exists Sequences Processing Numeric iterations Looping a set number of times Regular expressions More sophisticated string expressions Result-document and output More control over output, and multiple output files

11 more facilities Inline control keywords Simplifying language by extending XPath to do some more control Character maps More easily specifying characters in the output Tunnel parameters Automatic passing parameters through a series of called templates Data-types More control over typing Stand-alone processing No longer needs an XML input document

12 xsl:function This element makes it possible to create XSLT functions that can then be placed in special namespaces and invoked from within XPath expressions. This is a huge piece of functionality, as it makes it far easier to modularize XSLT functionality, to turn XSLT into a formal programming language.

13 Formal XPath extension mechanism. now has a formal (and consistent) means of invoking outside methods written in other languages (Java, PHP,.NET, XSLT, XQuery, whatever) from within an XSLT expression. XSLT1 implementations often extended XSLT in this manner, but each did it in their own way.

14 unparsed-text() and unparsed-text-available() The unparsed-text-available() function solves one of the biggest problems involved with working with the document() function, by dealing with situations where the URL is unable to retrieve content. It can check a URL to ensure that it is in fact capable of retrieving something. The unparsed-text() function fixes another issue - being able to load non-xml content into an XSLT transformation. This works on any content. It can handle any type of process that generates text which could be parsed via regexes to retrieve the relevant content (such as CSV files, or position-oriented data files). This function also makes it possible to import HTML into an XML document without that HTML needing to be parsed or otherwise manipulated, which is very useful for user input.

15 Sequences. supports general sequences of objects - lists, in other words - that can be either atomic data types or XML objects. This means that the node-set() extension is not needed.

16 Numeric iterations. You can now do such expressions as for (1 to 10) that will return increasing iterative values, reducing the need for recursive expressions dramatically and consequently simplifying the code base for any number of different operations.

17 Regular expressions. and XPath 2.0 both contain support for regular expressions, as well as a number of string functions for taking advantage of regexes. For instance, the tokenize() function can split a string into a sequence based upon a regular expression (or straight text) making it much easier to split apart lines and fields in CSV files, extract data from irregular phone number formats, performing actions if two words are within a given number of characters of one another and so forth.

18 result-document and output. This element makes it possible to send content (and not necessarily just XML content) to a file or web service, independent of the final output mechanism used by the transformation itself. Simple examples of this include the ability to take a single large XML document and split it up into a large number of smaller XML documents that can be saved to disk, creating a SOAP message that can then be sent asynchronously as a POSTed entity, or writing documents to URL based REST services.

19 Inline control keywords. XML is great for certain things, but there are times where structures such as <for-each> and <apply-templates> were essentially overkill, forcing a lot of excess verbiage in places where simpler structures would have been more useful. XSLT 2 now supports a number of XQuery extensions (not the entire set, but a fair number) for doing things such as iterating with a for loop or performing various actions based upon conditional statements, directly within XPath. This again can reduce file sizes considerably, and generally makes for somewhat easier code to read.

20 Character maps. You can now create character maps that let you map certain character sequences to some output form. This serves a number of purposes. Character maps replace the rather cumbersome (and often poorly used) disable-output-escaping to insure that specific entities (such as the less than < symbol) stays preserved properly in output. This actually proves very useful for creating intermediate XML structures that can nonetheless be processed through other XSLT calls, and even more is useful for generating output files that resemble XML but are not quite identical (eg JSP pages, which might have inline <% %> elements), such as: <jsp:setproperty name="user" property="id" value="<%= "id" + idvalue %>"> </jsp:setproperty>

21 Tunnel parameters. Parameterization has always been at odds with the recursive nature of XSLT, and has often proven an impediment to modularization. In general, if you passed parameters through elements, it would necessitate that the called templates would have to declare those parameters, even if the only reason was to in turn pass the parameters on to some other called template down the recursion descent. Uou can now invoke a with-parameter call with attribute set to yes. When this happens, only the template that actually needs the parameter value specifically needs to declare the parameter - not any of the intervening templates.

22 Data-types. You can specify that certain variables should be considered to be of a specific data-type (with the whole XSD simple type set supported), and the operations done on these will then reflect the data-type in question. Thus. if you declare two variables as being of type xs:integer, then trying to set one to a non-integer value will generate an error. Additionally, if your XSLT processor is schema-aware, then such types are automatically assigned into the infoset and all operations work on the presupposition that the operands have known types. This tends to work best for data-centric processing, and can cause more than a little bit of a headache when trying to debug why a given operation refuses to work in more text-oriented systems, but the option exists nonetheless.

23 Stand-alone processing. It is also now possible to invoke an XSLT transformation without needing an additional XML file on which to operate.