source: main/trunk/ibisph-view/src/main/webapp/xslt/_ibis-include.xslt @ 19893

<?xml version="1.0" encoding="ISO-8859-1"?>

<xsl:stylesheet version="3.0" 
        xmlns:xsl ="http://www.w3.org/1999/XSL/Transform" 
        xmlns:xs  ="http://www.w3.org/2001/XMLSchema"
        xmlns:ibis="http://www.ibisph.org"

        exclude-result-prefixes="ibis xs xsl"
>

        <ibis:doc>
                <name>ibis.include</name>
                <summary>Library of generic/common ibis include related functions</summary>
        </ibis:doc>



        <!-- ===================================== M A T C H   C O P Y   M O D E -->
        <xsl:template match="*" mode="ibis.copy"
                ibis:doc="Provides the ability to do an apply-templates to a copy-of of
                        an element (some call this an 'identity transformation').  This 
                        allows for a deep copy with processing (which also allows ibis.include 
                        to be processed)."
        >
                <!-- Used the new element and copied the attributes, text, and sub 
                        elements so that any namespace attributes would not be copied.
                        <xsl:apply-templates select="@*" mode="ibis.copy"/>
<xsl:message>IBIS.COPY</xsl:message>
                -->
                <xsl:element name="{local-name()}">
                        <xsl:apply-templates select="current()/@* | current()/text() | current()/*"  mode="ibis.copy"/>
                </xsl:element>
        </xsl:template>


        <xsl:template match="text()" mode="ibis.copy" ibis:doc="copies the text.">
<!-- trims the text - not really needed for wiki - biggest issue with weird text
        was page indent on and extra line spacing etc.
                <xsl:value-of select="replace(., '^\s+|\s+$', '')"/>
-->
                <xsl:value-of select="."/>
        </xsl:template>

        <!-- Match Copy Mode was lifted from the page.xslt in 4/2007.  That code has a note
                about 4-18-06: removed template code and replaced with the mode="ibis.copy"
                templates above because the namespace was being copied into some HTML elements.
                See: http://www.stylusstudio.com/xsllist/200008/post50850.html
        -->

        <!-- The following templates are used to help page developers avoid having to 
                hard code the deployment specific context into the URL path of IBIS related
                web pages.  Example: If the app is deployed into a context called "ibisph-view"
                and your page is "http://localhost/ibisph-view/about/welcome.html" and it 
                references an image that is under the "webapps/ibisph-view/image" directory
                it would need a url like "src='/ibisph-view/image/the_image.gif'" to properly
                get the correct resource.  A relative path of "src='image/the_image.gif'" 
                would cause the browser to request "http://localhost/ibisph-view/about/image/the_image.gif",
                while a path of "src='/image/the_image.gif'" would request this resource
                "http://localhost/image/the_image.gif" both of which are wrong.  If the context
                path is coded so that the resource's URL is explicitly defined then a dependency
                exists between the web pages and the context which makes the deployment not
                as portable.  Since the web app context path is needed by the XSLTs to build
                the correct HTML code it is implemented here to help static page development.
                Relative links work fine if the resource it within the same directory e.g. 
                if the "about/welcome.html" page contains a relative link to the "about/content_usage.html" 
                page then all is well.  The "about/welcome.html" page can NOT contains a relative 
                link to the "indicator/introduction.html" as it will not find the correct
                directory.
        -->

        <xsl:template match="@*" mode="ibis.copy" ibis:doc="Inner '@*' template that copies the non ibis: namespace attributes">
                <xsl:copy-of select="."/>
        </xsl:template>

        <xsl:template match="@ibis:doc" mode="ibis.copy" ibis:doc="Eats ibis:doc attribute"/>
        <xsl:template match="ibis:doc"  mode="ibis.copy" ibis:doc="Eats ibis:doc element"/>


        <!-- Local IBIS URL adjustment templates.  These templates simply add the 
                web application's context path as a prefix to the link reference attribute.

                NOTE: The remoteRequestPath_ technique could be applied but these are left
                as is so adopters do not have to redo their content pages - for now...
GARTH TODO: at some future point convert everything to the more explicit 
ibis:baseRequstPath_  ibis:baseRequstPath_src, ibis:baseRequstPath_href
        -->
        <xsl:template match="@ibis:href" mode="ibis.copy" ibis:doc="Inner 'ibis:href' template that adds the 'WebAppURLContextPrefix' to the 'href' attribute.">
                <xsl:attribute name="href" select="concat($ibis.baseRequestPath, .)"/>
        </xsl:template>
        <xsl:template match="@ibis:src" mode="ibis.copy" ibis:doc="Inner 'ibis:src' template that adds the 'WebAppURLContextPrefix' to the 'src' attribute.">
                <xsl:attribute name="src" select="concat($ibis.baseRequestPath, .)"/>
        </xsl:template>
        <xsl:template match="@ibis:action" mode="ibis.copy" ibis:doc="Inner 'ibis:action' template that adds the 'WebAppURLContextPrefix' to the 'action' attribute.">
                <xsl:attribute name="action" select="concat($ibis.baseRequestPath, .)"/>
        </xsl:template>
        <xsl:template match="@ibis:poster" mode="ibis.copy" ibis:doc="Inner 'ibis:poster' template that adds the 'WebAppURLContextPrefix' to the 'poster' attribute.">
                <xsl:attribute name="poster" select="concat($ibis.baseRequestPath, .)"/>
        </xsl:template>

        <xsl:template match="@ibis:*[starts-with(name(), 'ibis:baseRequstPath_')]" mode="ibis.copy" 
                ibis:doc="Adds the 'WebAppBaseRequestPath' as a prefix to the attribute value with the attribute named the suffix following 'ibis:baseRequstPath_'."
        >
                <xsl:attribute name="{substring(name(), 18)}" select="concat($ibis.baseRequestPath, .)"/>
        </xsl:template>

        <xsl:template match="ibis:baseRequestPath" mode="ibis.copy" 
                ibis:doc="Mechanism that allows any ibis.copy processed XML CONTENT to
                        to get the ibis.baseRequesttPath value.  This is useful for pages 
                        that have javascript that need this value.
                        Usage: within the CONTENT have an [ibis:baseRequestPath/] element.
                "
        >
                <xsl:value-of select="$ibis.baseRequestPath"/>
        </xsl:template>


        <!-- =============================== I B I S   I N C L U D E   M A T C H -->
        <xsl:template match="ibis:include" mode="#all"
                ibis:doc="
                        'ibis:' namespace specific match template which opens 
                        the document via the 'href' attribute and does an 'apply-template'
                        operation on its contents to process sub 'ibis:include' statements
                        and to copy its text, attributes, and processing instructions.

                        Provides the IBISPH system the ability to do simple xinclude 
                        type operations.  As of 6-2004 the xerces parser 2.6.x has xinclude support 
                        but it must be configured when starting the Java JVM or with Java system
                        properties.  Since this might not be an option for some deployments (like 
                        Utah's state wide ITS app server) the system wide property solution is not
                        an option.  To handle being able to deploy into environments where we don't 
                        know which XSL engine is being used this two step xinclude processing 
                        was developed.  This option is not nearly as seamless and requires that 
                        the java controller do 2 transformations - the first being this xinclude
                        type transformation with the second being the normal desired page type
                        transformation.  Another option was to do the xinclude template inside the 
                        XSLT as a variable then use that variable for all XML nodes.  This option 
                        appears to be somewhat slow but it is seamless.

                        See: http://www.sagehill.net/docbookxsl/Xinclude.html

                        This page simply copies the contents of the base document and when it 
                        hits the ibis:include element it opens the document with an XSLT document 
                        call based on the href attribute of the xi:include element.  These 
                        elements are then copied into the source document.

                        NOTE: the included document MUST be a valid XML file e.g. well 
                        formed with a root/master/parent element.

                        If a children-only-flag attribute exists in the element then only
                        only the sub elements and child text are included and processed.
                        This is useful for including an element's text without having to 
                        include its root element.
                "
        >
<!-- this only copies child content - skips container element.
                <xsl:copy>
                        <xsl:apply-templates select="document(@href, /)" mode="ibis.include"/>
                </xsl:copy>
<xsl:message select="document(@href, /)"/>
<xsl:message select="concat('FOUND IBIS INCLUDE: ', @href)"/>

<xsl:message select="@children-only-flag"/>
<xsl:message select="document(@href, /)

                <xsl:choose>
                        <xsl:when test="exists(@include-children-only)">
                                <xsl:apply-templates select="document(@href, /)/(text() | *)" mode="ibis.copy"/>
                        </xsl:when>
                        <xsl:otherwise>
                                <xsl:apply-templates select="document(@href, /)" mode="ibis.copy"/>
                        </xsl:otherwise>
                </xsl:choose>

OLD CODE:   then document(@href, /)/(text() | *)
had an issue seen with topic HTML_CONTENT pages including textual blocks with 
child specified.  What happened was that the root container element was copied 
into the doc - not just the children element(s) and text.  So it looked okay but 
was wrong HTML as it contained the XML container element.  
-->

                <xsl:variable name="url" select="if(0 != string-length(@use-prefix)) then concat($ibis.baseRequestPath, @href) else @href"/>
                <xsl:apply-templates select=
                        "if(exists(@children-only-flag)) 
                                then document($url, /)/(*/text() | */*)
                                else document($url, /)
                        "
                        mode="ibis.copy"
                />
        </xsl:template>


        <xsl:template match="ibis:include[boolean(@child-name)]" mode="#all"
                ibis:doc="
                        Provides the ability to limit includes to a given child element that
                        has a NAME that matches the supplied child-name attribute.  
                "
        >
<xsl:variable name="url" select="if(0 != string-length(@use-prefix)) then concat($ibis.baseRequestPath, @href) else @href"/>
<xsl:variable name="childNameElementValue" select="@child-name"/>
<xsl:message select="concat('********* @child-name: ', $childNameElementValue, ', url: ', $url)"/>
<xsl:message select="document($url, /)/*/*[NAME=$childNameElementValue]"/>
<xsl:message select="'*************** END'"/>

                <xsl:apply-templates select="document($url, /)/*/*[NAME=$childNameElementValue]" mode="ibis.copy"/>
        </xsl:template>


        <xsl:template match="ibis:include[boolean(@child-name-list)]" mode="#all"
                ibis:doc="
                        Provides the ability to limit includes to a given child element that
                        has a NAME that matches the supplied child-name attribute.  
                "
        >
                <xsl:variable name="childNames" select="tokenize(normalize-space(replace(@child-name-list, ',', ' ')), '\s+')"/>
                <xsl:variable name="url" select="if(0 != string-length(@use-prefix)) then concat($ibis.baseRequestPath, @href) else @href"/>
                <xsl:variable name="doc" select="document($url, /)"/>
<xsl:message select="concat('********* name: ', name($doc/*), ', url: ', $url)"/>

                <xsl:if test="not(@children-only-flag)">
                        <xsl:element name="{name($doc/*)}">
                                <xsl:apply-templates select="$doc/*/*[NAME=$childNames]" mode="ibis.copy"/>
                        </xsl:element>
                </xsl:if>
                <xsl:if test="boolean(@children-only-flag)">
                        <xsl:apply-templates select="$doc/*/*[NAME=$childNames]" mode="ibis.copy"/>
                </xsl:if>
        </xsl:template>

</xsl:stylesheet>



<!-- left here for posterity - a way to totally replace an element...
        <xsl:template match="ibis:a">
                <xsl:element name="a">
                        <xsl:attribute name="href"><xsl:value-of select="concat($ibis.baseRequestPath, @href)"/></xsl:attribute>
                        <xsl:copy-of select="attribute::*[name() != 'href']"/>
                        <xsl:apply-templates select="current()/text() | current()/*"/>
                </xsl:element>
        </xsl:template>
-->
<!-- img elements do not contain any text or other elements so it doesn't need
                to process/worry about anything other than it's attributes.
        <xsl:template match="ibis:img">
                <img>
                        <xsl:attribute name="src"><xsl:value-of select="concat($ibis.baseRequestPath, @src)"/></xsl:attribute>
                        <xsl:copy-of select="attribute::*[name() != 'src']"/>
                </img>
        </xsl:template>
-->
<!-- Since the a element can contain images, divs etc need to process text
                and elements contained within.
        <xsl:template match="ibis:form">
                <xsl:element name="form">
                        <xsl:attribute name="action"><xsl:value-of select="concat($ibis.baseRequestPath, @action)"/></xsl:attribute>
                        <xsl:copy-of select="attribute::*[name() != 'action']"/>
                        <xsl:apply-templates select="current()/text() | current()/*"/>
                </xsl:element>
        </xsl:template>
-->

<!-- ============================= End of File ============================= -->