Creating the export filter is a much more difficult task. When we imported a file, a hierarchical structure like this …

<association>
    <club>
        <name />
        <contact />
    </club>
    <club>
        <name />
        <contact />
    </club>
</association>
<association>
    <!-- etc -->
</association>

… was “flattened” into a structure like this:

<text:h text:style-name="Association"/>
<text:h text:style-name="Club Name"/>
<text:p>Contact: <text:span text:style-name="Contact"/></text:p>
<text:h text:style-name="Club Name"/>
<text:p>Contact: <text:span text:style-name="Contact"/></text:p>
<text:h text:style-name="Association"/>
<!-- etc -->

The export filter will have to take this flattened structure and re-create the nesting. The algorithm for this is not particularly difficult:

For each <text:h> element with a text:style-name of Association:

To construct a <club> element:

This is not exactly rocket surgery, but the job is complicated by the fact that XSLT almost exclusively uses recursion, not iteration.^[16] This makes the transformation ugly, so we will present it in parts. [This is file writer_to_club.xsl in directory ch09 in the downloadable example files.]

The first part shows the opening <xsl:stylesheet> element, showing the namespaces that could be used in the OpenOffice.org document. The transformation won’t work without these declarations, but we do not want to see the namespaces in the resulting output file. Thus, we use the exclude-result-prefixes attribute to eliminate namespace delcarations from our ouput.

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:fo="urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0"
  xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0"
  xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0"
  xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0"
  xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0"
  xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0"
  xmlns:xlink="http://www.w3.org/1999/xlink"
  xmlns:number="urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0"
  xmlns:form="urn:oasis:names:tc:opendocument:xmlns:form:1.0"
  xmlns:script="urn:oasis:names:tc:opendocument:xmlns:script:1.0"
  xmlns:svg="urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0"
  exclude-result-prefixes="text xsl fo office style table draw xlink form script config number svg">
<xsl:output method="xml" indent="yes"/>

Almost the only place we can use XSLT’s natural processing style is to grab all the <text:h> elements for the associations. Processing an association creates the <association> element with its ID, and then starts the process of making entries for the constituent clubs. Implicit in this code is the presumption that there is at least one club in an association.

<xsl:template match="/">
    <xsl:apply-templates select="office:document/office:body/
        office:text/text:h[@text:style-name='Association']"/>
</xsl:template>

<xsl:template match="text:h[@text:style-name='Association']">
    <association id="{.}">
        <xsl:call-template name="make-club">
            <xsl:with-param name="clubNode"
             select="following-sibling::text:h[1]"/>
        </xsl:call-template>
    </association>
</xsl:template>

We can now make the club(s) in the association.

<xsl:template name="make-club">
    <xsl:param name="clubNode"/>
    <xsl:if test="$clubNode/@text:style-name = 'Club_20_Name'"> 
        <club>
            <xsl:attribute name="id">
                <xsl:value-of
                    select="$clubNode/text:span[@text:style-name='Club_20_Code']"/>
            </xsl:attribute>      
            <name><xsl:value-of select="$clubNode"/></name>
            <xsl:call-template name="make-content">
                <xsl:with-param name="contentNode"
                    select="$clubNode/following-sibling::*[1]"/> 
            </xsl:call-template>
            
        </club>
        <xsl:if test="$clubNode/following-sibling::text:h[1]"> 
            <xsl:call-template name="make-club">
                <xsl:with-param name="clubNode"
                    select="$clubNode/following-sibling::text:h[1]"/>
            </xsl:call-template>
        </xsl:if>
    </xsl:if>
</xsl:template>

	The node that was passed on to the make-club template could be either a <text:h> for a club name or the next association if this was the last club. Hence, the <xsl:if> to make sure we have a club name.
	When we proceed to gather the club’s content, we have to blindly pass on the first following sibling element—it could be a <text:p> that is part of the club, a <text:h> that starts a new club, or a <text:h> that starts a new association.
	After completing this club, check to see if this node has a following <text:h> node. If so, recursively call this template with that new node, which could be another club or the next association.

Assembling the content for a club works very much along the same lines.

<xsl:template name="make-content">
    <xsl:param name="contentNode"/>
    <xsl:if test="name($contentNode) = 'text:p'"> 
        <xsl:choose>
            <xsl:when test="$contentNode/text:span"> 
                <xsl:call-template name="add-item">
                    <xsl:with-param name="spanNode"
                        select="$contentNode/text:span"/>
                </xsl:call-template>
            </xsl:when>
            <xsl:when test="name($contentNode/following-sibling::*[1]) = 
                'text:list'"> 
                <xsl:call-template name="email-list">
                    <xsl:with-param name="emailList"
                        select="$contentNode/following-sibling::text:list[1]"/>
                </xsl:call-template>
            </xsl:when>
            <xsl:when test="$contentNode/@text:style-name = 'Club_20_Info'"> 
                <info>
                    <xsl:apply-templates select="$contentNode"/>
                </info>
            </xsl:when>
        </xsl:choose>
        <xsl:call-template name="make-content"> 
            <xsl:with-param name="contentNode"
                select="$contentNode/following-sibling::*[1]"/>
        </xsl:call-template>
    </xsl:if>
</xsl:template>

	If this isn’t a paragraph, then it’s not part of the club content. (This stops recursion when we hit the end of the file or the next club/association.)
	If this paragraph has a <text:span> child, then it’s a charter, location, contact, phone, single email, or age group specification. Hand it off to another template.
	If there’s an unordered list following this paragraph, then it must be a club with multiple emails. Again, hand the list off to another template.
	Club information is just straight text with embedded links, so use <apply-templates> to handle the text (with the default template) and the links with a soon-to-be-described template.
	In any case, keep gathering content by recursively calling this template with the next node in the document.

Here’s the template that adds individual elements as children of a club. The styleAttr variable is for convenience, to make the source easier to read. All the elements except <age-groups> are handled by adding the span’s contents. Age groups are special, and, rather than trying to split up a list of keywords and recursively handle them, we cheat. The call to the translate function eliminates all lowercase letters and blanks, leaving the uppercase abbreviations for the age groups. For example, Kids Cadets Open is instantly reduced to KCO.

<xsl:template name="add-item">
    <xsl:param name="spanNode"/>
    <xsl:variable name="styleAttr" select="$spanNode/@text:style-name"/>
    
    <xsl:choose>
        <xsl:when test="$styleAttr = 'Charter'">
            <charter><xsl:value-of select="$spanNode"/></charter>
        </xsl:when>
        <xsl:when test="$styleAttr = 'Contact'">
            <contact><xsl:value-of select="$spanNode"/></contact>
        </xsl:when>
        <xsl:when test="$styleAttr = 'Phone'">
            <phone><xsl:value-of select="$spanNode"/></phone>
        </xsl:when>
        <xsl:when test="$styleAttr = 'Location'">
            <location><xsl:value-of select="$spanNode"/></location>
        </xsl:when>
        <xsl:when test="$styleAttr = 'Email'">
            <email><xsl:value-of select="$spanNode"/></email>
        </xsl:when>
        <xsl:when test="$styleAttr = 'Age_20_Groups'">
            <age-groups>
                <xsl:attribute name="type">
                    <xsl:value-of select="translate($spanNode,
                    ' abcdefghijklmnopqrstuvwxyz', '')"/>
                </xsl:attribute>
            </age-groups>
        </xsl:when>
    </xsl:choose>
</xsl:template>

Rounding out the XSLT stylesheet are the templates that handle a list of email addresses within a <text:unordered-list> and the <text:a> element inside the club information.

<xsl:template name="email-list">
    <xsl:param name="emailList"/>
    <xsl:for-each select="$emailList/descendant::text:span[@text:style-name='Email']">
        <email><xsl:value-of select="."/></email>
    </xsl:for-each>
</xsl:template>

<xsl:template match="text:a">
<a href="{@xlink:href}"><xsl:apply-templates/></a>
</xsl:template>

</xsl:stylesheet>