CODEWITHSUNDEEP
xsltxslt-2.0
Pankaj
Pankaj

Reputation: 177

finding preceding-sibling and processing in same node

Need to transform following XML snippet into DITA using XSLT. My requirements are: 1. All the tags comes before "orderedlist" should be wrapped under "context" node. 2. All the tags comes after "orderedlist" should be in "result". 3. All the "include" tags should be wrapped under their preceding sibling nodes.

XML:

        <?xml version="1.0" encoding="UTF-8"?>
        <procedure>
            <para>This is first para</para>
            <para>This is second para</para>
            <include>This is include</include>
            <orderedlist>
                <listitem>this is list item</listitem>
                <include>This is include</include>
                <listitem>this is list item <include>this is include</include></listitem>
            </orderedlist>
            <observation>this is observation</observation>
            <para>this is result para <include>this is include</include></para>
            <include>This is include</include>
        </procedure>

Output:

     <?xml version="1.0" encoding="UTF-8"?>
    <task>
        <context>
            <p>This is first para</p>
            <p>This is second para <included type='tag'>This is include</included>
            </p>
        </context>
        <ol>
            <li>this is list item <included type='tag'>This is include</included>
            </li>
            <li>this is list item <included type='tag'>this is include</included></li>
        </ol>
        <result>
            <observation>this is observation</observation>
            <p>this is result para <included type='tag'>this is include</included><included type='tag'>this is include</included>
            </p>
        </result>
    </task>

My XSL:

        <?xml version="1.0" encoding="UTF-8"?>
        <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="2.0">
            <xsl:template match="procedure">
                <task>
                    <context>
                        <xsl:apply-templates select="*[parent::procedure][following-sibling::orderedlist]"/>
                    </context>
                    <xsl:apply-templates select="orderedlist"/>
                    <result>
                        <xsl:apply-templates select="*[parent::procedure][preceding-sibling::orderedlist]"/>
                    </result>
                </task>
            </xsl:template>
            <xsl:template match="para">
                <p>
                    <xsl:apply-templates/>
                    <include>
                        <xsl:apply-templates select="following-sibling::include"/>
                    </include>
                </p>
            </xsl:template>
            <!-- rest of the template goes here   -->
            <xsl:template match="listitem">
                <li>
                    <xsl:apply-templates/>
                    <include>
                        <xsl:apply-templates select="following-sibling::include"/>
                    </include>
                </li>
            </xsl:template>
        </xsl:stylesheet>

Any pointer will be a great help. Thanks.

Upvotes: 0

Views: 919

Answers (2)

JLRishe
JLRishe

Reputation: 101680

Give this a try:

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="2.0">
  <xsl:output indent="yes" />
  <xsl:strip-space elements="*"/>

  <xsl:template match="@* | node()" name="Copy">
    <xsl:copy>
      <xsl:apply-templates select="@* | node()" />
      <xsl:call-template name="Include" />
    </xsl:copy>
  </xsl:template>
  <xsl:template match="procedure">
    <task>
      <context>
        <xsl:apply-templates select="*[following-sibling::orderedlist]"/>
      </context>
      <xsl:apply-templates select="orderedlist"/>
      <result>
        <xsl:apply-templates select="*[preceding-sibling::orderedlist]"/>
      </result>
    </task>
  </xsl:template>
  <xsl:template match="para">
    <p>
      <xsl:apply-templates/>
      <xsl:call-template name="Include" />
    </p>
  </xsl:template>
  <!-- rest of the template goes here   -->
  <xsl:template match="listitem">
    <li>
      <xsl:apply-templates/>
      <xsl:call-template name="Include" />
    </li>
  </xsl:template>

  <xsl:template name="Include">
    <xsl:apply-templates
      select="following-sibling::include[
                       generate-id(preceding-sibling::*[not(self::include)][1]) =
                       generate-id(current())]"
      mode="performIncludes"/>
  </xsl:template>

  <xsl:template match="include" />
  <xsl:template match="include" mode="performIncludes">
    <xsl:call-template name="Copy" />
  </xsl:template>
</xsl:stylesheet>

Output when run on your sample input:

<task>
  <context>
    <p>This is first para</p>
    <p>This is second para<include>This is include</include></p>
  </context>
  <orderedlist>
    <li>this is list item<include>This is include</include></li>
    <li>this is list item</li>
  </orderedlist>
  <result>
    <observation>this is observation</observation>
    <p>this is result para<include>This is include</include></p>
  </result>
</task>

Upvotes: 1

Tim C
Tim C

Reputation: 70618

The first thing to note is you can simplify the following expression:

<xsl:apply-templates select="*[parent::procedure][following-sibling::orderedlist]"/>

You don't need the [parent::procedure] here, because you are already positioned on a procedure element, so so you know if you select any child element, it will have that as a parent! 

<xsl:apply-templates select="*[following-sibling::orderedlist]"/>

However, you might need to add an clause to ensure you don't output the include elements at this point, as you will need special code to handle them being included later

<xsl:template match="include" />

To handle the include elements, it might be worth defining a key, so you can group them by the first most proceding non-include element, like so

  <xsl:key name="include" match="include" use="generate-id(preceding-sibling::*[not(self::include)][1])"/>

Then, when matching an element such as para or listitem, you can then get the include elements to include, just like this:

<xsl:copy-of select="key('include', generate-id())"/>

Note I am not sure how you want to handle multipe include elements for a single element, but in my example, it will output them separately as opposing to merging them:

Here is the full XSLT

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
  <xsl:output method="xml" indent="yes"/>
  <xsl:key name="include" match="include" use="generate-id(preceding-sibling::*[not(self::include)][1])"/>

  <xsl:template match="procedure">
    <task>
      <context>
        <xsl:apply-templates select="*[following-sibling::orderedlist]"/>
      </context>
      <xsl:apply-templates select="orderedlist"/>
      <result>
        <xsl:apply-templates select="*[preceding-sibling::orderedlist]"/>
      </result>
    </task>
  </xsl:template>

  <xsl:template match="orderedlist">
    <ol>
      <xsl:apply-templates />
    </ol>
  </xsl:template>

  <xsl:template match="para">
    <p>
      <xsl:apply-templates/>
      <xsl:copy-of select="key('include', generate-id())" />
     </p>
  </xsl:template>

  <xsl:template match="listitem">
    <li>
      <xsl:apply-templates/>
      <xsl:copy-of select="key('include', generate-id())" />
    </li>
  </xsl:template>

  <xsl:template match="include" />

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

When applied to your sample XML, the following is output

<task>
  <context>
    <p>This is first para</p>
    <p>This is second para<include>This is include</include></p>
  </context>
  <ol>
    <li>this is list item<include>This is include</include></li>
    <li>this is list item</li>
  </ol>
  <result>
    <observation>this is observation</observation>
    <p>this is result para<include>This is include</include></p>
  </result>
</task>

Upvotes: 2

Related Questions