Question

I’m trying to write a template that will grab a mixture of text nodes and elements within a parent element and create a new node. I’ve done a lot of searching and couldn’t find what I was looking for…so hopefully I’m not asking to basic a question.

Here is a sample of xml I want to transform:

<?xml version="1.0"?>
<root>
 <para>Here is some text that will ask users to enter a <rule-line/> [<emph type="it">date</emph>], and maybe their <rule-line/> [<emph type="it">name</emph>]. The text could come in different [<emph type="it">order</emph>] <rule-line/>, and their could be any number of instances.</para>

</root>

I want to group the bracketed text and the rule into a new element like so:

<entry>[<emph type"it">date</emph>]</entry>

I have a template that can identify the text I want to change, and I can change it, but I don’t know how to add the text I want to the result tree and omit the old text.

Here are the relevant templates:

<xsl:template match="para">
 <xsl:for-each select="* | text()">
  <xsl:choose>

   <xsl:when test="self::rule-line and following-sibling::node()[1][starts-with(., ' [')] and string(node-name(following-sibling::node()[2])) = 'emph' and following-sibling::node()[3][starts-with(., ']')]">
    <xsl:comment>made match</xsl:comment>
    <xsl:call-template name="codeEntry">
     <xsl:with-param name="rule" select="."/>
     <xsl:with-param name="openBracket" select="following-sibling::node()[1]"/>
     <xsl:with-param name="emphTag" select="following-sibling::node()[2]"/>
     <xsl:with-param name="closeBracketString" select="following-sibling::node()[3]"/>
    </xsl:call-template>
   </xsl:when>
   <xsl:otherwise>
    <xsl:copy-of select="."/>
   </xsl:otherwise>
  </xsl:choose>
 </xsl:for-each>

</xsl:template>


<xsl:template name="codeEntry">
<xsl:param name="rule"/>
<xsl:param name="openBracket"/>
<xsl:param name="emphTag"/>
<xsl:param name="closeBracketString"/>
<entry>
<xsl:copy-of select="$openBracket"/>
<xsl:copy-of select="$emphTag"/>
<xsl:text>] </xsl:text>
</entry>
<xsl:value-of select="substring-after($closeBracketString, ']')"/>

</xsl:template>

Obviously, the when statement grabs a group of nodes, but when each node goes through the otherwise block it gets copied to the result tree. I’m not really sure how to handle this since the para could have any number of these node groupings in any order, or none. (Once I figure this out I’ll add another when block that deals with the bracketed text before the rule)

I think creating a variable that tells the template to ignore the node is the way to go…but I’m a little foggy on the immutable variables and their scope…

I was also trying to think of a way I could try to do this recursively…but that would require adding a start tag at one point, an end tag in another, or no tag if the node being processed is in the middle of the sequence…and I know that can get weird in xslt.

Anyone run into this type of situation before?
thanks,
jason

any ideas

Answer 1

Just for fun (What a mess of a schema!), this stylesheet:

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:template match="node()|@*" name="identity">
        <xsl:copy>
            <xsl:apply-templates select="node()|@*"/>
        </xsl:copy>
    </xsl:template>
    <xsl:template match="rule-line"/>
    <xsl:template match="emph">
        <entry>
            <xsl:text>[</xsl:text>
            <xsl:call-template name="identity"/>
            <xsl:text>]</xsl:text>
        </entry>
    </xsl:template>
    <xsl:template match="text()[normalize-space()='[']
                               [following-sibling::*[1][self::emph]] |
                         text()[normalize-space()=']']
                               [preceding-sibling::*[1][self::emph]]"
                  priority="1"/>
    <xsl:template match="text()[starts-with(normalize-space(),']')]
                               [preceding-sibling::*[1][self::emph]]">
        <xsl:value-of select="substring-after(.,']')"/>
    </xsl:template>
    <xsl:template match="text()[substring(normalize-space(),
                                          string-length(normalize-space()),
                                          1) = '[']
                               [following-sibling::*[1][self::emph]]">
        <xsl:call-template name="crop-both">
            <xsl:with-param name="pString" select="concat(']',.)"/>
        </xsl:call-template>
    </xsl:template>
    <xsl:template match="text()[starts-with(normalize-space(),']')]
                               [substring(normalize-space(),
                                          string-length(normalize-space()),
                                          1) = '[']
                               [preceding-sibling::*[1][self::emph]]
                               [following-sibling::*[1][self::emph]]"
                  priority="1" name="crop-both">
        <xsl:param name="pString" select="."/>
        <xsl:variable name="vReverse">
            <xsl:call-template name="reverse">
                <xsl:with-param name="pString" 
                                select="substring-after(.,']')"/>
            </xsl:call-template>
        </xsl:variable>
        <xsl:call-template name="reverse">
            <xsl:with-param name="pString"
                            select="substring-after($vReverse,'[')"/>
        </xsl:call-template>
    </xsl:template>
    <xsl:template name="reverse">
        <xsl:param name="pString"/>
        <xsl:if test="$pString!=''">
            <xsl:call-template name="reverse">
                <xsl:with-param name="pString"
                                select="substring($pString,2)"/>
            </xsl:call-template>
            <xsl:value-of select="substring($pString,1,1)"/>
        </xsl:if>
    </xsl:template>
</xsl:stylesheet>

Output:

<root>
<para>Here is some text that will ask users to enter a <entry>[<emph type="it">date</emph>]</entry>, and maybe their <entry>[<emph type="it">name</emph>]</entry>. The text could come in different <entry>[<emph type="it">order</emph>]</entry>, and their could be any number of instances.</para>
</root>