source: CMDI-Interoperability/CMD2RDF/trunk/xsl/CMDRecord2RDF.xsl @ 3817

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE rdf:RDF [
    <!ENTITY rdf 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'>
    <!ENTITY rdfs 'http://www.w3.org/TR/WD-rdf-schema#'>
    <!ENTITY xsd 'http://www.w3.org/2001/XMLSchema#'>
    <!ENTITY cmdm 'http://www.clarin.eu/cmd/general.rdf#'>
    <!ENTITY oa 'http://www.w3.org/ns/oa#'>
]>
<xsl:stylesheet
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="2.0"
    xmlns:dcr="http://www.isocat.org/ns/dcr.rdf#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:cmd="http://www.clarin.eu/cmd/"
    xmlns:cmdm="http://www.clarin.eu/cmd/general.rdf"
    xmlns:ore="http://www.openarchives.org/ore/terms/"
    xmlns:oa="http://www.w3.org/ns/oa#"
    xmlns:dcterms="http://purl.org/dc/terms/"
>
    
    <xsl:output method="xml" encoding="UTF-8"/>
    
    <xsl:param name="base" select="base-uri()"/>
    
    <xsl:include href="CMD2RDF.xsl"/>
    
    <xsl:template match="text()"/>
    
    <!-- let's create some RDF -->
    <xsl:template match="/cmd:CMD">
        <rdf:RDF xml:base="{replace($base,'([./])(xml|cmdi)$','$1rdf')}">
            <oa:Annotation rdf:about="#{generate-id()}">
                <xsl:apply-templates select="cmd:Header"/>
                <xsl:apply-templates select="cmd:Resources"/>
                <oa:hasBody>
                    <xsl:apply-templates select="cmd:Components">
                        <xsl:with-param name="context" tunnel="yes" select="''"/>
                    </xsl:apply-templates>
                </oa:hasBody>
                <oa:motivatedBy rdf:resource="&oa;describing"/>
            </oa:Annotation>
        </rdf:RDF>
    </xsl:template>
    
    <xsl:template match="cmd:MdCreator">
        <dcterms:creator>
            <xsl:value-of select="."/>
        </dcterms:creator>
    </xsl:template>

    <xsl:template match="cmd:MdCreationDate">
        <dcterms:created>
            <xsl:value-of select="."/>
        </dcterms:created>
    </xsl:template>
    
    <xsl:template match="cmd:MdSelfLink">
        <dcterms:identifier>
            <xsl:value-of select="."/>
        </dcterms:identifier>
    </xsl:template>
    
    <xsl:template match="cmd:MdProfile">
        <!-- TODO? -->
    </xsl:template>
    
    <xsl:template match="cmd:MdCollectionDisplayName">
        <!-- TODO -->
    </xsl:template>
    
    <xsl:template match="cmd:ResourceProxy">
        <oa:hasTarget rdf:resource="{ResourceRef}"/>
        <cmdm:Resource rdf:about="{ResourceRef}">
            <cmdm:hasResourceType rdf:resource="&cmdm;{ResourceType}"/>
            <xsl:if test="normalize-space(ResourceType/@mimetype)!=''">
                <cmdm:hasMimeType>
                    <xsl:value-of select="ResourceType/@mimetype"/>
                </cmdm:hasMimeType>
            </xsl:if>
        </cmdm:Resource>
    </xsl:template>
    
    <!-- the CMD body -->
    <xsl:template match="/cmd:CMD/cmd:Components">
        <!-- get the profile id -->
        <xsl:variable name="id" select="/cmd:CMD/cmd:Header/cmd:MdProfile"/>
        <!-- load the profile -->
        <xsl:variable name="profile" select="cmd:profile($id)"/>
        <!-- the base URL (the namespace in RDF/XML) of the RDF resources will change during traversal to the URL of the active profile/component -->
        <xsl:variable name="ns" select="concat(cmd:ppath($id,'rdf'),'#')"/>
        <!-- we traverse the profile/component scheme and find the matching instances -->
        <xsl:apply-templates select="$profile/CMD_ComponentSpec/CMD_Component">
            <xsl:with-param name="context" tunnel="yes" select="''"/>
            <xsl:with-param name="ns" tunnel="yes" select="$ns"/>
            <xsl:with-param name="instance" tunnel="yes" select="."/>
        </xsl:apply-templates>
    </xsl:template>
    
    <!-- a CMD component -->
    <xsl:template match="CMD_Component">
        <xsl:param name="context" tunnel="yes"/>
        <xsl:param name="ns" tunnel="yes"/>
        <xsl:param name="instance" tunnel="yes"/>
        <!-- if the component has its own id its something that can be shared by multiple profiles/components and has its own base RDF (namespace) -->
        <xsl:variable name="local-ns">
            <xsl:choose>
                <xsl:when test="exists(@ComponentId)">
                    <xsl:sequence select="concat(cmd:cpath(@ComponentId,'rdf'),'#')"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:sequence select="$ns"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>
        <!-- if the component has its own id its something that can be shared by multiple profiles/components a new context is started -->
        <xsl:variable name="local-context">
            <xsl:choose>
                <xsl:when test="exists(@ComponentId)">
                    <xsl:sequence select="''"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:sequence select="$context"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>
        <xsl:variable name="profile" select="."/>
        <xsl:variable name="name" select="@name"/>
        <!-- extend the context with this component -->
        <xsl:variable name="id" select="cmd:path($local-context,$name)"/>
        <!-- find the matching instances -->
        <xsl:for-each select="$instance/*[local-name()=$name]">
            <!-- create a class -->
            <xsl:variable name="class">
                <xsl:element name="{$id}" namespace="{$local-ns}">
                    <xsl:attribute name="rdf:about" select="concat('#',generate-id(.))"/>
                    <xsl:for-each select="tokenize(@ref,'\s+')">
                        <xsl:variable name="res"/>
                        <cmdm:describesResource rdf:resource="/cmd:CMD/cmd:Resources/cmd:ResourceProxyList/cmd:ResourceProxy[@id=$ref]/ResourceRef"/>
                    </xsl:for-each>
                    <!-- switch back from the instance to the profile -->
                    <xsl:apply-templates select="$profile/*">
                        <xsl:with-param name="context" tunnel="yes" select="$id"/>
                        <xsl:with-param name="ns" tunnel="yes" select="$local-ns"/>
                        <xsl:with-param name="instance" tunnel="yes" select="."/>
                    </xsl:apply-templates>
                </xsl:element>
            </xsl:variable>
            <!-- is this the root or not -->
            <xsl:choose>
                <xsl:when test="exists(parent::cmd:Components)">
                    <xsl:copy-of select="$class"/>
                </xsl:when>
                <xsl:otherwise>
                    <!-- use the generic RELcat related relationship for the nesting of components -->
                    <cmdm:contains>
                        <xsl:copy-of select="$class"/>
                    </cmdm:contains>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:for-each>
    </xsl:template>

    <!-- a CMD element --> 
    <xsl:template match="CMD_Element">
        <xsl:param name="context" tunnel="yes"/>
        <xsl:param name="ns" tunnel="yes"/>
        <xsl:param name="instance" tunnel="yes"/>
        <xsl:variable name="profile" select="."/>
        <xsl:variable name="name" select="@name"/>
        <!-- extend the context with this element -->
        <xsl:variable name="id" select="cmd:path($context,$name)"/>
        <xsl:variable name="has" select="cmd:path($context,concat('has',@name))"/>
        <!-- find the matching instances -->
        <xsl:for-each select="$instance/*[local-name()=$name]">
            <!-- use the generic RELcat related relationship for the nesting of the element in its component -->
            <cmdm:contains>
                <!-- a CMD element is a RDF class -->
                <xsl:element name="{$id}" namespace="{$ns}">
                    <xsl:attribute name="rdf:about" select="concat('#',generate-id(.))"/>
                    <!-- the value is assigned to a propery of the CMD element RDF class -->
                    <xsl:element name="{$has}ElementValue" namespace="{$ns}">
                        <!-- map the CMD XSD datatype to a datatype supported by RDF -->
                        <xsl:attribute name="rdf:datatype" select="concat('&xsd;',cmd:datatype($profile/@ValueScheme))"/>
                        <!-- copy @xml:lang -->
                        <xsl:copy-of select="@xml:lang"/>
                        <!-- copy the literal -->
                        <xsl:value-of select="."/>
                    </xsl:element>
                    <!-- if there is enum we also have an entity property -->
                    <xsl:if test="exists($profile/ValueScheme/enumeration)">
                        <xsl:element name="{$id}ElementEntity" namespace="{$ns}">
                            <xsl:attribute name="rdf:resource" select="concat($ns,$id,'ValueScheme',$STEP,replace(.,'\s',''))"/>
                        </xsl:element>
                    </xsl:if>
                    <!-- switch back from the instance to the profile to handle the attributes -->
                    <xsl:apply-templates select="$profile/AttributeList/Attribute">
                        <xsl:with-param name="context" tunnel="yes" select="$id"/>
                        <xsl:with-param name="ns" tunnel="yes" select="$ns"/>
                        <xsl:with-param name="instance" tunnel="yes" select="."/>
                    </xsl:apply-templates>
                </xsl:element>
            </cmdm:contains>
        </xsl:for-each>
    </xsl:template>
    
    <!-- a CMD attribute -->
    <xsl:template match="Attribute">
        <xsl:param name="context" tunnel="yes"/>
        <xsl:param name="ns" tunnel="yes"/>
        <xsl:param name="instance" tunnel="yes"/>
        <xsl:variable name="profile" select="."/>
        <xsl:variable name="name" select="Name"/>
        <!-- extend the context with this attribute -->
        <xsl:variable name="id" select="concat(cmd:path($context,$name),'Attribute')"/>
        <xsl:variable name="has" select="concat(cmd:path($context,concat('has',$name)),'Attribute')"/>
        <!-- find the matching instances -->
        <xsl:for-each select="$instance/@*[local-name()=$name]">
            <cmdm:containsAttribute>
                <xsl:element name="{$id}" namespace="{$ns}">
                    <xsl:attribute name="rdf:about" select="concat('#',generate-id(.))"/>
                    <xsl:element name="{$has}Value" namespace="{$ns}">
                        <!-- map the CMD XSD datatype to a datatype supported by RDF -->
                        <xsl:attribute name="rdf:datatype" select="concat('&xsd;',cmd:datatype($profile/Type))"/>
                        <!-- copy the literal -->
                        <xsl:value-of select="."/>
                    </xsl:element>
                    <xsl:if test="exists($profile/ValueScheme/enumeration)">
                        <xsl:element name="{$has}Entity" namespace="{$ns}">
                            <xsl:attribute name="rdf:resource" select="concat($ns,$id,'ValueScheme',$STEP,replace(.,'\s',''))"/>
                        </xsl:element>
                    </xsl:if>
                </xsl:element>
            </cmdm:containsAttribute>
        </xsl:for-each>
    </xsl:template>

</xsl:stylesheet>