Use XSLT to transform XML with conditionals upon node count

Question

I am trying to remove nodes from an XML file. Using just one XSLT for each of my XML I need to make decisions in the XSLT based upon the number of children of the document element.

<root>
  <branch>
    <foo>bar</foo>
  </branch>
<root>

should transform into

  <branch>
  </branch>

but

<root>
  <branch>
    <foo>bar</foo>
  </branch>
  <branch>
    <foo>baz</foo>
<root>

into

<root>
  <branch>
  </branch>
  <branch>
  </branch>
<root>

That is, the root element should be removed if its (only) child can act as the new document root of the result XML after applying XSLT. The <foo> nodes have to be removed in every occurence.

Is there a way to perform this operation with a single XSL?

Answer 1

Try

<xsl:template match="@* | node()">
  <xsl:copy>
    <xsl:apply-templates select="@* | node()"/>
  </xsl:copy>
</xsl:template>

<xsl:template match="root[*[2]]">
  <xsl:copy>
    <xsl:apply-templates/>
  </xsl:copy>
</xsl:template>

<xsl:template match="root[* and not(*[2])]">
  <xsl:apply-templates/>
</xsl:template>

<xsl:template match="branch/foo"/>

Answer 2

A simpler, shorter and more generic (no element names hardcoded) solution:

<xsl:stylesheet version="1.0"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
 <xsl:output omit-xml-declaration="yes" indent="yes"/>

 <xsl:template match="node()|@*">
  <xsl:copy>
   <xsl:apply-templates select="node()|@*"/>
  </xsl:copy>
 </xsl:template>

 <xsl:template match="/*[not(*[2])]">
  <xsl:apply-templates/>
 </xsl:template>

 <xsl:template match="/*/*/node()"/>
</xsl:stylesheet>

when this transformation is applied on the first provided XML document (corrected to be made well-formed):

<root>
    <branch>
        <foo>bar</foo>
    </branch>
</root>

the wanted, correct result is produced:

<branch></branch>

When the same transformation is applied on the second provided XML document (again needed to be corrected for well-formedness):

<root>
    <branch>
        <foo>bar</foo>
    </branch>
    <branch>
        <foo>baz</foo>
    </branch>
</root>

again the wanted, correct output is produced:

<root>
    <branch></branch>
    <branch></branch>
</root>

Explanation:

1. The identity rule copies every node "as-is".

2. There are two templates that override the identity template for specific nodes and process these nodes in different ways.

3. The first overriding template matches a top element that doesn't have a second element child. It doesn't copy the element itself, but processes its children.

4. The second overriding template matches any element that is a grand-child of the top element. This template doesn't have a body, which means that all such matched element are ignored and not included in the output (in other words -- "deleted")

Do note:

This transformation can be applied to any XML document, regardless of the element names in it, and still produces the wanted, correct result.

For example, when applied on this XML document:

<t>
    <b>
        <f>brrr</f>
    </b>
    <b>
        <f>bzzz</f>
    </b>
</t>

the wanted, correct result is produced:

<t>
    <b></b>
    <b></b>
</t>

Contrast this to the result produced by the currently - accepted answer:

<t>
    <b>
        <f>brrr</f>
    </b>
    <b>
        <f>bzzz</f>
    </b>
</t>