Using Script Extensions in Xalan-Java - Plugging the Scripts into the XSLT Stylesheet
(Page 4 of 8 )
Xalan enables script files to be imported from an external file or inserted in-line into the stylesheet directly. In the examples in this article, all scripts are stored in-line. Xalan supports multiple script types in the same stylesheet. However, each script type must be placed in a separate <component> element. A sample JavaScript component is shown below:
<lxslt:component prefix="javascript" elements="" functions="calculate_surname, calculate_firstname, calculate_bonus">
Function X declared in this script is then accessed via the XSLT fragment:
<xsl:value-of select="javascript:X( param1, param2, … )"/>
Integrating and using Java-based script interpreters (for example, JavaScript and Jython) is relatively straightforward. Integrating Windows ActiveScript script support such as VBScript, Jscript, and PerlScript requires some additional configuration; JavaBean access is also slightly different with ActiveScript.
The following sections describe how JavaScript, Python, VBScript, and PerlScript are used to implement the scripting scenario.
JavaScript
The JavaScript support is based on Rhino version 1.5.
Configuration
Ensure that the js.jar file is in the classpath used by the XSLT processor.
Simple Function without a JavaBean Parameter
The function below shows how JavaScript regular expression support is used to calculate the output surname element using the input name element:
function calculate_surname( name )
{
return name.split( /s/g )[1];
}
The XSLT function call is:
<xsl:value-of select="javascript:calculate_surname( string(name) )"/>
Note that the name element is coerced into a string type before it is passed to the function. This will ensure that a string type rather than a node type is passed to the function.
Function with JavaBean Processing
The function below shows how JavaScript handles JavaBean parameters. This function must perform a table lookup in order to calculate the bonus awarded to a salesperson. Because the JavaScript interpreter is Java-based, the bean instance is passed directly to the script. This is not possible for script interpreters that are not Java-based, as we will see later when we discuss using Windows ActiveScript, which is based on C and C++.
function calculate_bonus( quota, actual, bonusplan, bonus_table )
{
/* find base bonus from lookup table */
var bonus_base = parseFloat( bonus_table.lookUp(bonusplan,1), 10 ) ;
/*calculate multiple, bonus multiple is zero if they underperform */
var multiple = (actual > quota) ? actual/quota : 0 ;
return bonus_base * multiple;
}
The bonus_table.lookup operation returns a string that must be explicitly converted to float, because JavaScript is a strongly typed language. The rest of the script calculates the sales success (the multiple value) and returns the bonus award calculation as the bonus_base (from the table) multiplied by multiple.
The XSLT function call is as follows:
<xsl:value-of select="javascript:calculate_bonus( number(quota), number(actual), string(bonusplan), $bonus_table )"/>
Again, note that parameters are converted to XSLT number and string types, where required, before they are passed to the JavaScript (the XSLT number type is mapped to a Java double type). This is good practice, because it will keep strongly typed scripts from having to coerce values to the correct type before processing them. The bonus_table variable is passed as is.
Next: Python >>
More XML Articles
More By Seamus Donohue
