xslt named template : how to write a template that creates a string representing the xpath of a given node

Question

I'm trying to write a recursive named template that will show the path of a given node:

<?xml version="1.0"?>

<testfile>
    <section>
        <title>My Section</title>
        <para>Trying to write a recursive function that will return a basic xpath of a given node; in the case of this node, I would want to return testfile/section/para, I don't need /testfile/section[1]/para[1] or anything like that. The issue I'm having is that in the case of a named template, I don't know how to select a different node and apply it to the named template.</para>

    </section>

</testfile>

I'm trying this template :

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

<!-- stylesheet to test a named template trying to build an xpath for a given node -->
<xsl:output method="xml"/>
<xsl:template match="/">
    <result>
        <xsl:apply-templates/>
    </result>
</xsl:template>

<xsl:template match="*">
    <xsl:variable name="xpath">
        <xsl:call-template name="getXpath">
            <xsl:with-param name="pathText" select="''"/>
        </xsl:call-template>
    </xsl:variable>

    <element>element name : <xsl:value-of select="name()"/> path : <xsl:value-of select="$xpath"/></element>
    <xsl:apply-templates/>

</xsl:template>



<xsl:template name="getXpath">
<xsl:param name="pathText"/>

<xsl:message>top of get xpath func path text : <xsl:value-of select="$pathText"/>    </xsl:message>
    <xsl:choose>
        <xsl:when test="ancestor::*">
            <xsl:message><xsl:value-of select="name()"/> has a parent</xsl:message>
            <xsl:call-template name="getXpath">
                <xsl:with-param name="pathText">
                    <xsl:value-of select="name()"/>    <xsl:text>/</xsl:text><xsl:value-of select="$pathText"/>
                    <!-- how to recursively call template with parent node? -->
                </xsl:with-param>   
            </xsl:call-template>
        </xsl:when>
        <xsl:otherwise>
            <xsl:message><xsl:value-of select="name()"/> has no parent!</xsl:message>
            <xsl:value-of select="$pathText"/>
        </xsl:otherwise>
    </xsl:choose>   

</xsl:template>


</xsl:stylesheet>

As per the comment, I'm not sure how to apply a node other than the context node to the named template. The other strategy I tried was to send the node to the template as a param, but I don't know how(or if you can) apply an axis to a param, as in

$thisNode../*

etc.

I'm sure it's something simple that I'm missing...thanks.

Answer 1

For what it's worth, I wrote a simple XPath generation template about a decade ago, in part 2 of my "styling stylesheets" article on DeveloperWorks:

Listing 4. Template that generates a Pseudo XPath in XSLT

<xsl:template name="pseudo-xpath-to-current-node">
   <!-- Special-case for the root node, which otherwise
       wouldn't generate any path at all. A bit of a kluge,
       but it's simple and efficient. -->
   <xsl:if test="not(parent::node())">
            <xsl:text>/</xsl:text>
   </xsl:if>

   <xsl:for-each select="ancestor-or-self::node()">
     <xsl:choose>
       <xsl:when test="not(parent::node())">
            <!-- This clause recognizes the root node, which doesn't need
                 to be explicitly represented in the XPath. -->
       </xsl:when>
       <xsl:when test="self::text()">
            <xsl:text>/text()[</xsl:text>
            <xsl:number level="single"/>
            <xsl:text>]</xsl:text>
       </xsl:when>
       <xsl:when test="self::comment()">
            <xsl:text>/comment()[</xsl:text>
            <xsl:number level="single"/>
            <xsl:text>]</xsl:text>
       </xsl:when>
       <xsl:when test="self::processing-instruction()">
            <xsl:text>/processing-instruction()[</xsl:text>
            <xsl:number level="single"/>
            <xsl:text>]</xsl:text>
       </xsl:when>
       <xsl:when test="self::*">
            <!-- This test for Elements works because the Principal
                 Node Type of the self:: axis happens to be Element.
                         -->
            <xsl:text>/</xsl:text>
            <xsl:value-of select="name(.)"/>
            <xsl:text>[</xsl:text>
            <xsl:number level="single"/>
            <xsl:text>]</xsl:text>
       </xsl:when>
       <xsl:when test="self::node()[name()='xmlns' | starts-with(name(),'xmlns:')]">
            <!-- This recognizes namespace nodes, though it's a bit
                 ugly.  XSLT 1.0 doesn't seem to have a more elegant
                 test. XSLT 2.0 is expected to deprecate the whole
                 concept of namespace nodes, so it may become a moot
                 point.

                 NS nodes are unique; a count isn't required.  -->
            <xsl:text>/namespace::</xsl:text>
            <xsl:value-of select="local-name(.)"/>
       </xsl:when>
       <xsl:otherwise>
            <!-- If I've reached this clause, the node must be an
                 attribute.  Attributes are unique; a count is not
                 required.  -->
            <xsl:text>/@</xsl:text>
            <xsl:value-of select="name(.)"/>
       </xsl:otherwise>
     </xsl:choose>
   </xsl:for-each>
</xsl:template>

That was an XSLT 1.0 solution, structured for clarity. It's probably possible to simplify it, especially if you're using XSLT and XPath 2.0.

As I explained there, this "pseudo-XPath" version ignores the namespace issue, since I didn't need it for that proof-of-concept tool and since it was intended for human-readable messages rather than for execution. It could be corrected to manage namespaces properly by changing it to write out paths that specify node type with a predicate explicitly testing localname and namespace URI. The resulting paths would be bulkier and harder for humans to process. Exercise for the reader, if you're so inclined.

You might also be able to replace the positional index with something more expressive... but knowing what's going to be meaningful is not easy.

Hope that helps. Have fun.

(Oh, almost forgot: I wouldn't be surprised if there are other solutions on the XSLT FAQ site.)

Answer 2

You shouldn't have to pass a node as a param if you just do an xsl:for-each.

Here's a modified example of your XSLT. (Notice that the positional predicates are only output in the path if they are needed.)

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

    <!-- stylesheet to test a named template trying to build an xpath for a given node -->
    <xsl:output method="xml" indent="yes"/>
    <xsl:template match="/">
        <result>
            <xsl:apply-templates/>
        </result>
    </xsl:template>

    <xsl:template match="*">
        <xsl:variable name="xpath">
            <xsl:call-template name="getXpath"/>            
        </xsl:variable>        
        <element>element name : <xsl:value-of select="name()"/> path : <xsl:value-of select="$xpath"/></element>
        <xsl:apply-templates/>        
    </xsl:template>    

    <xsl:template name="getXpath"> 
        <xsl:for-each select="ancestor-or-self::*">
            <xsl:value-of select="concat('/',local-name())"/>
            <!--Predicate is only output when needed.-->
            <xsl:if test="(preceding-sibling::*|following-sibling::*)[local-name()=local-name(current())]">
                <xsl:value-of select="concat('[',count(preceding-sibling::*[local-name()=local-name(current())])+1,']')"/>
            </xsl:if>
        </xsl:for-each>
    </xsl:template>

    <xsl:template match="text()"/>

</xsl:stylesheet>

Output (using the input from the question)

<result>
   <element>element name : testfile path : /testfile</element>
   <element>element name : section path : /testfile/section</element>
   <element>element name : title path : /testfile/section/title</element>
   <element>element name : para path : /testfile/section/para</element>
</result>

Answer 3

You can indeed pass in the node as a param to the template....

<xsl:template name="getXpath">
<xsl:param name="pathText"/>
<xsl:param name="node" select="." />

To apply an axis to it, for example to test for ancestors, you would do this....

<xsl:when test="$node/ancestor::*">

And to pass its parent element to the template when you recursively call it, do this:

<xsl:with-param name="node" select="$node/parent::*" />

Try this XSLT

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml"/>
<xsl:template match="/">
    <result>
        <xsl:apply-templates/>
    </result>
</xsl:template>

<xsl:template match="*">
    <xsl:variable name="xpath">
        <xsl:call-template name="getXpath">
            <xsl:with-param name="pathText" select="''"/>
        </xsl:call-template>
    </xsl:variable>

    <element>element name : <xsl:value-of select="name()"/> path : <xsl:value-of select="$xpath"/></element>
    <xsl:apply-templates/>
</xsl:template>

<xsl:template name="getXpath">
<xsl:param name="pathText"/>
<xsl:param name="node" select="." />

<xsl:message>top of get xpath func path text : <xsl:value-of select="$pathText"/>    </xsl:message>
    <xsl:choose>
        <xsl:when test="$node/ancestor::*">
            <xsl:message><xsl:value-of select="name($node)"/> has a parent</xsl:message>
            <xsl:call-template name="getXpath">
                <xsl:with-param name="pathText">
                    <xsl:value-of select="name($node)"/>    <xsl:text>/</xsl:text><xsl:value-of select="$pathText"/>
                </xsl:with-param>   
                <xsl:with-param name="node" select="$node/parent::*" />
            </xsl:call-template>
        </xsl:when>
        <xsl:otherwise>
            <xsl:message><xsl:value-of select="name($node)"/> has no parent!</xsl:message>
            <xsl:value-of select="$pathText"/>
        </xsl:otherwise>
    </xsl:choose>   
</xsl:template>
</xsl:stylesheet>

An alternate approach is to use xsl:apply-templates, but with the mode parameter to keep it separate from other template matches. Try this XSLT

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml"/>
<xsl:template match="/">
    <result>
        <xsl:apply-templates/>
    </result>
</xsl:template>

<xsl:template match="*">
    <xsl:variable name="xpath">
        <xsl:apply-templates select="." mode="getXpath">
            <xsl:with-param name="pathText" select="''"/>
        </xsl:apply-templates>
    </xsl:variable>

    <element>element name : <xsl:value-of select="name()"/> path : <xsl:value-of select="$xpath"/></element>
    <xsl:apply-templates/>
</xsl:template>

<xsl:template match="*" mode="getXpath">
<xsl:param name="pathText"/>
<xsl:message>top of get xpath func path text : <xsl:value-of select="$pathText"/>    </xsl:message>
    <xsl:choose>
        <xsl:when test="ancestor::*">
            <xsl:message><xsl:value-of select="name()"/> has a parent</xsl:message>
            <xsl:apply-templates select=".." mode="getXpath">
                <xsl:with-param name="pathText">
                    <xsl:value-of select="name()"/>    <xsl:text>/</xsl:text><xsl:value-of select="$pathText"/>
                </xsl:with-param>   
            </xsl:apply-templates>
        </xsl:when>
        <xsl:otherwise>
            <xsl:message><xsl:value-of select="name()"/> has no parent!</xsl:message>
            <xsl:value-of select="$pathText"/>
        </xsl:otherwise>
    </xsl:choose>   
</xsl:template>
</xsl:stylesheet>

Answer 4

I think you want something like this:

<xsl:variable name="get.path">
    <xsl:text> /</xsl:text>
    <xsl:for-each select="ancestor-or-self::*">
        <xsl:variable name="get.current.node" select="name(.)"/>
        <xsl:value-of select="name()"/>
        <xsl:text>[</xsl:text>
        <xsl:value-of select="count(preceding-sibling::*[name(.) = $get.current.node]) + 1"/>
        <xsl:text>]</xsl:text>
        <xsl:if test="position() != last()">
            <xsl:text>/</xsl:text>
        </xsl:if>
    </xsl:for-each>
</xsl:variable>