ld4l-works_rdf 0.1.0

data/lib/ld4l/works_rdf/services/conversion_services/marc2bibframe/modules/module.RDFXML-2-Ntriples.xqy

@@ -0,0 +1,276 @@
+xquery version "1.0";
+
+(:
+:   Module Name: RDFXML 2 ntriples
+:
+:   Module Version: 1.0
+:
+:   Date: 2010 Oct 18
+:
+:   Copyright: Public Domain
+:
+:   Proprietary XQuery Extensions Used: none
+:
+:   Xquery Specification: January 2007
+:
+:   Module Overview:    Takes RDF/XML converts to ntriples.
+:       xdmp extension used in order to quote/escape otherwise valid
+:       XML.
+:
+:   NB: This file has been modified to remove a ML dependency at
+:   around line 126 (xdmp:quote).  Could be a problem for Literal types.  
+:)
+   
+(:~
+:   Takes RDF/XML and transforms to ntriples.  xdmp extension 
+:   used in order to quote/escape otherwise valid XML.
+:
+:   @author Kevin Ford (kefo@loc.gov)
+:   @since October 18, 2010
+:   @version 1.0
+:)
+module namespace    rdfxml2nt   = "info:lc/id-modules/rdfxml2nt#";
+declare namespace   rdf         = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+
+(:~
+:   This is the main function.  Input RDF/XML, output ntiples.
+:   All other functions are local.
+:
+:   @param  $rdfxml        node() is the RDF/XML  
+:   @return ntripes as xs:string
+:)
+declare function rdfxml2nt:rdfxml2ntriples($rdfxml as node()) as xs:string {
+    if( $rdfxml[1][fn:local-name() eq "RDF"] ) then
+        let $resources := 
+            for $i in $rdfxml/child::node()[fn:name()]
+            return rdfxml2nt:parse_class($i, "")
+        return fn:string-join($resources, "
")
+    else ("Invalid source: RDF/XML should have a root node of RDF.") 
+};
+
+(:~
+:   This function parses a RDF Class.
+:
+:   @param  $node        node()
+:   @param  $uri_pass   xs:string, is the URI passed 
+:                       from the property evaluation and to be
+:                       used in the absence of a rdf:about or rdf:nodeID  
+:   @return ntripes as xs:string
+:)
+declare function rdfxml2nt:parse_class(
+    $node as node(), 
+    $uri_pass as xs:string
+    ) as item()* {
+    
+    let $uri :=
+        if ($node/@rdf:about ne "") then
+            fn:concat( "<", fn:data($node/@rdf:about), ">")
+        else if ($node/@rdf:about eq "") then
+            fn:concat( "<", fn:data($node/ancestor::rdf:RDF[1]/@xml:base), ">")
+        else if ($node/@rdf:ID ne "" and $node/ancestor::rdf:RDF[1]/@xml:base) then
+            fn:concat( "<", fn:data($node/ancestor::rdf:RDF[1]/@xml:base), $node/@rdf:ID, ">")
+        else if ($node/@rdf:nodeID) then
+            fn:concat( "_:", fn:data($node/@rdf:nodeID))
+        else if ($uri_pass ne "") then
+            $uri_pass
+        else
+            rdfxml2nt:return_bnode($node)
+    let $triple := 
+        if (fn:local-name($node) eq "Description") then
+            (: fn:concat( $uri, " <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <" , $node/child::node()[fn:name(.) eq "rdf:type"]/@rdf:resource , "> . " , fn:codepoints-to-string(10)) :)
+            ""
+        else if (fn:namespace-uri($node) and fn:local-name($node)) then
+            fn:concat( $uri, " <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <" , fn:namespace-uri($node) , fn:local-name($node) , "> . " , fn:codepoints-to-string(10))
+        else if (fn:namespace-uri($node/parent::node()) and fn:local-name($node)) then
+            (: this is hardly sound, but seems to fix the issue :)
+            fn:concat( $uri, " <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <" , fn:namespace-uri($node/parent::node()) , fn:local-name($node) , "> . " , fn:codepoints-to-string(10))
+        else ""
+    return
+        if ($node/child::node()[fn:not(rdf:type)]) then
+            let $properties := 
+                for $i at $pos in $node/child::node()[fn:not(rdf:type) and fn:name()]
+                    return rdfxml2nt:parse_property($i , $uri)
+            return fn:concat($triple , fn:string-join($properties , ""))
+        else
+            $triple
+};
+
+(:~
+:   This function parses a RDF Property
+:
+:   @param  $node       node()
+:   @param  $uri        xs:string, is the URI passed 
+:                       from the Class evaluation
+:   @return ntripes as xs:string
+:)
+declare function rdfxml2nt:parse_property(
+    $node as node(), 
+    $uri as xs:string
+    ) as item()* {
+    
+    let $resource_string := 
+        if ($node/@rdf:resource) then
+            fn:concat("<" , fn:data($node/@rdf:resource) , ">")
+        else if ($node[@rdf:parseType eq "Collection"] and fn:not($node/@rdf:nodeID)) then
+            rdfxml2nt:return_bnode($node/child::node()[1])
+        else if ($node/child::node()[1]/@rdf:nodeID) then
+            fn:concat("_:" , fn:data($node/child::node()[1]/@rdf:nodeID))
+        else if ($node/child::node()[1]/@rdf:about) then
+            fn:concat("<" , fn:data($node/child::node()[1]/@rdf:about) , ">")
+        else if ($node[@rdf:parseType eq "Literal"]) then
+            fn:concat('"' , 
+                fn:replace(
+                    fn:replace(
+                        fn:replace(
+                             $node/child::node()/text(), 
+                            '&quot;',
+                            '\\"'
+                        ),
+                        '\n',
+                        '\\r\\n'
+                    ),
+                    "\t",
+                    '\\t'
+                ),
+            '"^^<http://www.w3.org/2000/01/rdf-schema#Literal>')
+            (: '"Comment"' :)
+        else if (fn:local-name($node/child::node()[fn:name()][1]) ne "") then
+            rdfxml2nt:return_bnode($node/child::node()[fn:name()][1])
+        else
+            fn:concat('"' , rdfxml2nt:clean_string(xs:string($node)) , '"',
+                if ($node/@xml:lang) then
+                    fn:concat('@' , xs:string($node/@xml:lang) )
+                else if ($node/@rdf:datatype) then
+                    fn:concat('^^<' , xs:string($node/@rdf:datatype) , '>' )
+                else ()
+            )
+            
+    let $triple := fn:concat( $uri , " <" , fn:namespace-uri($node) , fn:local-name($node) , "> " , $resource_string , " . ", fn:codepoints-to-string(10) )
+    return
+        if ($node/child::node()[fn:name()] and $node[@rdf:parseType eq "Collection"]) then
+            let $classes := rdfxml2nt:parse_collection($node/child::node()[fn:name()][1] , $resource_string)
+            return fn:concat($triple , fn:string-join($classes,''))
+            
+        else if ($node/child::node()[fn:name()] and fn:not($node/@rdf:parseType)) then
+            (:  is this the correct "if statement"?  Could there be a parseType 
+                *and* a desire to traverse the tree at this point? :)
+            let $classes := 
+                for $i in $node/child::node()[fn:name()]
+                return rdfxml2nt:parse_class($i , $resource_string)
+            return fn:concat($triple , fn:string-join($classes,""))
+        else
+            $triple
+            
+};
+
+(:~
+:   Parse a rdf:parseType="Collection" element
+:
+:   @param  $node       node()
+:   @param  $uri        xs:string, is the URI passed 
+:                       from the Property evaluation
+:   @return ntripes as xs:string
+:)
+declare function rdfxml2nt:parse_collection(
+    $node as node(), 
+    $uri as xs:string
+    ) as item()* {
+    
+    let $resource_string := 
+        if ($node/@rdf:resource) then
+            fn:concat("<" , fn:data($node/@rdf:resource) , ">")
+        else if ($node/@rdf:about) then
+            fn:concat( "<", fn:data($node/@rdf:about), ">")
+        else if ($node/@rdf:nodeID) then
+            fn:concat( "_:", fn:data($node/@rdf:nodeID))
+        else
+            rdfxml2nt:return_bnode($node/child::node()[fn:name()][1])
+            
+    let $triple := fn:concat( $uri , " <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> " , $resource_string , " . " , fn:codepoints-to-string(10))
+    let $following_bnode :=
+        if ($node/following-sibling::node()[fn:name()][1]) then 
+            rdfxml2nt:return_bnode_collection($node/following-sibling::node()[fn:name()][1])
+        else 
+            fn:false()
+    let $rest := 
+        if ($following_bnode) then
+            fn:concat( $uri , " <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> " , $following_bnode , " . " , fn:codepoints-to-string(10))
+        else
+            fn:concat( $uri , " <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> . " , fn:codepoints-to-string(10))
+
+    let $uri := $resource_string
+    let $class := rdfxml2nt:parse_class($node, $uri)
+        
+    return
+        if ($following_bnode) then
+            let $sibling :=  rdfxml2nt:parse_collection($node/following-sibling::node()[fn:name()][1] , $following_bnode)
+            return fn:concat($triple, $rest, $class, fn:string-join( $sibling, "" ) )
+        else
+            fn:concat($triple, $rest, $class)
+
+};
+
+(:~
+:   Helper funtion, to return a _bnode
+:
+:   @param  $node       node()
+:   @return _bnode as xs:string
+:)
+declare function rdfxml2nt:return_bnode($node as node()) as xs:string
+ {
+    let $uri4bnode := rdfxml2nt:return_uri4bnode($node/ancestor-or-self::node()[fn:name()='rdf:RDF']/child::node()[1]/@rdf:about)
+    let $unique_num := xs:integer( fn:count($node/ancestor-or-self::node()) + fn:count($node/preceding::node()) )
+    return fn:concat("_:bnode" , xs:string($unique_num) , $uri4bnode)
+};
+
+(:~
+:   Helper funtion, to return a _bnode for a collection
+:
+:   @param  $node       node()
+:   @return _bnode as xs:string
+:)
+declare function rdfxml2nt:return_bnode_collection($node as node()) as xs:string {
+    let $uri4bnode := rdfxml2nt:return_uri4bnode($node/ancestor-or-self::node()[fn:name()='rdf:RDF']/child::node()[1]/@rdf:about)
+    let $unique_num := xs:integer( fn:count($node/ancestor-or-self::node()) + fn:count($node/preceding::node()) )
+    return fn:concat("_:bnode" , "0" , xs:string($unique_num))
+};
+
+(:~
+:   bnode distinction - munges the URI in an attempt to 
+:   create a better probability for bnode uniqueness
+:
+:   @param  $uri        xs:string
+:   @return _bnode      as xs:string
+:)
+declare function rdfxml2nt:return_uri4bnode($uri as xs:string) as xs:string {
+    let $uriparts := fn:tokenize($uri, '/')
+    let $uriparts4bnode := 
+            for $u in $uriparts
+            let $str := 
+                if ( fn:matches($u , '\.|:|#') eq fn:false() ) then
+                    $u
+                else ()
+            return $str
+    return fn:string-join( $uriparts4bnode , '')
+};
+
+
+(:~
+:   Clean string of odd characters.
+:
+:   @param  $string       string to clean
+:   @return xs:string
+:)
+declare function rdfxml2nt:clean_string($str as xs:string) as xs:string
+ {
+    let $str := fn:replace( $str, '\\', '\\\\')
+    let $str := fn:replace( $str , '&quot;' , '\\"')
+    let $str := fn:replace( $str, "\n", "\\r\\n")
+    let $str := fn:replace( $str, "’", "'")
+    let $str := fn:replace( $str, '“|”', '\\"')
+    let $str := fn:replace( $str, 'ā', '\\u0101')
+    return $str
+};
+
+
+

data/lib/ld4l/works_rdf/services/conversion_services/marc2bibframe/modules/module.RDFXMLnested-2-flat.xqy

@@ -0,0 +1,380 @@
+xquery version "1.0";
+
+(:
+:   Module Name: BIBFRAME RDF/XML Nested (RAW) 2 RDF/XML Flat (Condensed) 
+:
+:   Module Version: 1.0
+:
+:   Date: 2013 10 Jan
+:
+:   Copyright: Public Domain
+:
+:   Proprietary XQuery Extensions Used: none
+:
+:   Xquery Specification: January 2007
+:
+:   Module Overview:    Takes BIBFRAME RDF/XML, which can be
+:       deeply nested, and flattens it by assigning each resource
+:       a URI. This should really be generalized to RDF, i.e. 
+:       not BF specific.
+:
+:)
+   
+(:~
+:   Takes BIBFRAME RDF/XML, which can be
+:   deeply nested, and flattens it by assigning each resource
+:   a URI.
+:
+:   @author Kevin Ford (kefo@loc.gov)
+:   @since January 10, 2013
+:   @update May 23, 2013
+:   @version 1.0
+:)
+
+
+module namespace RDFXMLnested2flat = 'info:lc/bf-modules/RDFXMLnested2flat#';
+
+declare namespace rdf           = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+declare namespace rdfs          = "http://www.w3.org/2000/01/rdf-schema#";
+
+declare namespace bf            = "http://bibframe.org/vocab/";
+declare namespace madsrdf       = "http://www.loc.gov/mads/rdf/v1#";
+declare namespace relators      = "http://id.loc.gov/vocabulary/relators/";
+
+
+declare variable $RDFXMLnested2flat:resourcesToIgnore := 
+    <ignore>
+        <class>Provider</class>
+        <class>Identifier</class>
+        <class>Authority</class>
+    </ignore>;
+   
+declare variable $RDFXMLnested2flat:inverses := 
+    <inverses>
+        <inverse sourceResource="bf:Work" targetResource="bf:Annotation">
+            <replace lookForOnSource="bf:hasAnnotation" enterOnTarget="bf:annotates" />
+        </inverse>        
+        <inverse sourceResource="bf:Work" targetResource="bf:Description">
+            <replace lookForOnSource="bf:describedIn" enterOnTarget="bf:descriptionOf" />
+        </inverse>            
+        <inverse sourceResource="bf:Work" targetResource="bf:Description">
+            <replace lookForOnSource="bf:hasAnnotation" enterOnTarget="bf:annotates" />
+        </inverse>
+        <inverse sourceResource="bf:Work" targetResource="bf:Summary">
+            <replace lookForOnSource="bf:hasAnnotation" enterOnTarget="bf:summaryOf" />
+        </inverse>
+         <inverse sourceResource="bf:Work" targetResource="bf:Review">
+            <replace lookForOnSource="bf:hasAnnotation" enterOnTarget="bf:annotates" />
+        </inverse>
+          <inverse sourceResource="bf:Work" targetResource="bf:Review">
+            <replace lookForOnSource="bf:reviewedIn" enterOnTarget="bf:reviews" />
+        </inverse>
+         <inverse sourceResource="bf:Work" targetResource="bf:TableOfContents">
+            <replace lookForOnSource="bf:hasAnnotation" enterOnTarget="bf:tableOfContentsFor" />
+        </inverse>
+        <inverse sourceResource="bf:Instance" targetResource="bf:HeldMaterial">
+            <replace lookForOnSource="bf:heldMaterial" enterOnTarget="bf:holdingFor" />
+        </inverse>
+          
+        <inverse sourceResource="bf:HeldMaterial" targetResource="bf:HeldItem">
+            <replace lookForOnSource="bf:heldItem" enterOnTarget="bf:componentOf" />
+        </inverse>
+        <inverse sourceResource="bf:Instance" targetResource="bf:HeldItem">
+            <replace lookForOnSource="bf:heldItem" enterOnTarget="bf:holdingFor" />
+        </inverse>
+        
+        <!--old :-->
+        <inverse sourceResource="bf:Instance" targetResource="bf:Holding">        
+            <replace lookForOnSource="bf:hasHolding" enterOnTarget="bf:holds" />
+        </inverse>
+        <inverse sourceResource="bf:Instance" targetResource="bf:Annotation">
+            <replace lookForOnSource="bf:hasAnnotation" enterOnTarget="bf:annotates" />
+        </inverse>
+        <inverse sourceResource="bf:Person" targetResource="bf:Annotation">
+            <replace lookForOnSource="bf:hasAnnotation" enterOnTarget="bf:annotates" />
+        </inverse>
+        <inverse sourceResource="bf:Work" targetResource="bf:Instance">
+            <replace lookForOnSource="bf:hasInstance" enterOnTarget="bf:instanceOf" />
+        </inverse>
+    </inverses>;
+
+(:~
+:   This is the main function.  Takes BIBFRAME RDF/XML, which can be
+:   deeply nested, and flattens it by assigning each resource
+:   a URI.  This should really be generalized to RDF, 
+:   i.e. not BF specific.
+:
+:   @param  $rdfxml         node() is the RDF/XML
+:   @param  $baseuri        xs:string is the base uri for identifiers  
+:   @return element         rdf:RDF
+:)
+declare function RDFXMLnested2flat:RDFXMLnested2flat
+        (
+            $rdfxml as element(rdf:RDF),
+            $baseuri as xs:string,
+            $usebnodes as xs:string
+        ) 
+        as element(rdf:RDF)
+{
+    
+    let $resources := RDFXMLnested2flat:identifyClasses($rdfxml, $baseuri, $usebnodes, 0)
+    let $resources := RDFXMLnested2flat:flatten($resources)
+    let $resources := RDFXMLnested2flat:removeNesting($resources)
+    let $resources := RDFXMLnested2flat:insertInverses($resources, $usebnodes)
+    return
+        (: ntra changed this to an inline element from constructed, so I control the namespaces added.
+       
+        :)
+      
+      <rdf:RDF
+            xmlns:rdf           = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+            xmlns:rdfs          = "http://www.w3.org/2000/01/rdf-schema#"
+            xmlns:bf            = "http://bibframe.org/vocab/"
+            xmlns:madsrdf       = "http://www.loc.gov/mads/rdf/v1#"
+            xmlns:relators      = "http://id.loc.gov/vocabulary/relators/"                              
+            >
+
+        {
+     
+            $rdfxml/@*,
+            for $w in    $resources/self::bf:Work
+            order by $w/@rdf:about
+            return $w,
+             
+        
+            $resources/self::bf:Instance,
+            $resources/self::bf:Authority,
+            $resources/self::bf:Annotation,
+            $resources/self::bf:HeldMaterial,
+            $resources/self::bf:HeldItem,
+            $resources/self::bf:Holding,
+            $resources/self::bf:Summary,
+            $resources/self::bf:Review,
+            $resources/self::bf:TableOfContents,
+            $resources/self::bf:*[fn:not(fn:matches(fn:local-name(), "(Work|Instance|Authority|Annotation|Holding|HeldMaterial|HeldItem|Summary|Review|TableOfContents)"))]
+          
+            }
+        </rdf:RDF>
+};
+
+
+(:~
+:   Flattens the RDF/XML.  Extract all identified resources.
+:
+:   @param  $resources      element()* are the resources.   
+:   @return element()       resources
+:)
+declare function RDFXMLnested2flat:flatten($resources as element()*)
+        as element()*
+{
+    
+    (:
+    let $resources := ($resources[@rdf:about],$resources//child::node()[@rdf:about])
+    return $resources
+    :)
+    for $r in $resources//@rdf:about|$resources//@rdf:nodeID
+    return $r/parent::node()[1]
+
+};
+
+
+(:~
+:   Identify resources.
+:   This maintains the nested structure.  It
+:   is called recursively.
+:
+:   @param  $rdfxml         node() is the RDF/XML
+:   @param  $baseuri        xs:string is the base uri for identifiers
+:   @param  $place          xs:integer is passed on to ensure unique ID assignment  
+:   @return element()       resources
+:)
+declare function RDFXMLnested2flat:identifyClasses
+        (
+            $rdfxml as element(rdf:RDF),
+            $baseuri as xs:string,
+            $usebnodes as xs:string,
+            $place as xs:integer
+        )
+        as element()*
+{
+    
+    let $ignore := fn:string-join($RDFXMLnested2flat:resourcesToIgnore/class, " ")
+    
+    let $resources := $rdfxml/child::node()[fn:matches(fn:local-name(), "^([A-Z])([a-z]+)")]
+    let $identified-resources :=
+        for $r at $pos in $resources
+        let $n := fn:lower-case(fn:local-name($r))
+        let $baseuri-new := 
+            if  ($r/@rdf:about) then
+                xs:string($r/@rdf:about)                
+            else if ($usebnodes eq "true") then
+                "b"
+            else
+                $baseuri
+        where fn:not(fn:contains($ignore, fn:local-name($r)))
+        return
+            element {fn:name($r)} { 
+                if  ($r/@rdf:about) then
+                    $r/@rdf:about                
+                else if ($usebnodes eq "true") then
+                    attribute rdf:nodeID { fn:concat($baseuri-new, $n, ($pos + $place)) }
+                else
+                    attribute rdf:about { fn:concat($baseuri-new, $n, ($pos + $place)) },
+                
+                for $p at $spot in $r/*
+                return
+                    if ($p/child::node()[fn:matches(fn:local-name(), "^([A-Z])([a-z]+)")]) then
+                        let $classes := $p/child::node()[fn:matches(fn:local-name(), "^([A-Z])([a-z]+)")]
+                        return
+                            element { fn:name($p) } {
+                                $p/@*,
+                                RDFXMLnested2flat:identifyClasses(<rdf:RDF>{$classes}</rdf:RDF>, $baseuri-new, $usebnodes, ($pos + $spot + $place))
+                            }
+                    else
+                        $p
+            }
+    let $skipped-resources :=
+        for $r at $pos in $resources
+        let $n := fn:lower-case(fn:local-name($r))
+        where fn:contains($ignore, fn:local-name($r))
+        return $r
+        
+    return ($identified-resources, $skipped-resources) 
+
+};
+
+
+(:
+declare variable $RDFXMLnested2flat:inverses := 
+    <inverses>
+        <inverse sourceResource="bf:Work" targetResource="bf:Annotation">
+            <replace lookForOnSource="bf:hasAnnotation" enterOnTarget="bf:annotates" />
+        </inverse>
+        <inverse sourceResource="bf:Instance" targetResource="bf:Holding">
+            <replace lookForOnSource="bf:hasHolding" enterOnTarget="bf:holds" />
+        </inverse>
+        <inverse sourceResource="bf:Instance" targetResource="bf:Annotation">
+            <replace lookForOnSource="bf:hasAnnotation" enterOnTarget="bf:annotates" />
+        </inverse>
+        <inverse sourceResource="bf:Person" targetResource="bf:Annotation">
+            <replace lookForOnSource="bf:hasAnnotation" enterOnTarget="bf:annotates" />
+        </inverse>
+        <inverse sourceResource="bf:Work" targetResource="bf:Instance">
+            <replace lookForOnSource="bf:hasInstance" enterOnTarget="bf:instanceOf" />
+        </inverse>
+    </inverses>;
+:)
+(:~
+:   Insert inverse relations.
+:
+:   @param  $resources      element()* are the resources.   
+:   @return element()       resources
+:)
+declare function RDFXMLnested2flat:insertInverses(
+    $resources as element()*,
+    $usebnodes as xs:string)
+    as element()*
+{
+    
+    let $targets := fn:string-join($RDFXMLnested2flat:inverses/inverse/@targetResource, " ")
+    (:nate: this won't work because bf:tableOfContents is part of bf:tableOfContentsFor, etc:)
+  (:  let $remove-props := fn:concat(
+            fn:string-join($RDFXMLnested2flat:inverses/inverse/replace/@enterOnTarget, " "),
+            " ",
+            fn:string-join($RDFXMLnested2flat:inverses/inverse/replace/@lookForOnSource, " ")
+        ):)
+    let $remove-props := fn:concat(    
+            fn:string-join($RDFXMLnested2flat:inverses/inverse/replace/@enterOnTarget, "|"),
+            "|",
+            fn:string-join($RDFXMLnested2flat:inverses/inverse/replace/@lookForOnSource, "|")    
+        )
+    let $modified-targets :=
+        for $r in $resources
+        let $uri := xs:string(($r/@rdf:about|$r/@rdf:nodeID)[1])
+        let $n := xs:string(fn:name($r))
+        let $lookFors := $RDFXMLnested2flat:inverses/inverse[@targetResource = $n]
+        where fn:contains($targets, $n)
+        return
+            element {fn:name($r)} { 
+                $r/@*,
+                
+                $r/*[fn:not( fn:matches( fn:name(),$remove-props ))],                
+                     
+                for $lf in $lookFors
+                let $replace := $lf/replace
+                let $related-resources := $resources[fn:name() = $lf/@sourceResource and child::node()[fn:name() = $replace/@lookForOnSource and xs:string(@rdf:resource) eq $uri]]
+                let $distinct-abouts := fn:distinct-values($related-resources/@rdf:about)
+                return
+                    for $rr in $distinct-abouts
+                    return
+                        element { xs:string($replace/@enterOnTarget) } {
+                            if ($usebnodes eq "false") then
+                                attribute rdf:resource { xs:string($rr) }
+                            else
+                                attribute rdf:nodeID { xs:string($rr) }
+                        }
+            }
+
+    (:
+        Need to figure out which resources were not processed as
+        targets in the above.
+        
+        Some "targets" may be sources in other situations, but
+        they will have already been processed and must be 
+        bypassed.
+    :)
+    let $unmodified-resources :=
+        for $r in $resources
+        let $uri := xs:string($r/@rdf:about)
+        let $n := xs:string(fn:name($r))
+        where fn:not(fn:contains($targets, $n))
+        return
+            element {fn:name($r)} { 
+                $r/@*,                
+                $r/*[fn:not( fn:matches( fn:name(),$remove-props ))]               
+            }
+
+    return ($modified-targets, $unmodified-resources)
+  
+
+};
+
+(:~
+:   Remove nesting from extracted, identified resources.
+:
+:   @param  $resources      element()* are the resources.   
+:   @return element()       resources
+:)
+declare function RDFXMLnested2flat:removeNesting(
+        $resources as element()*
+    ) as element()*
+{
+    
+    let $simplified-resources :=
+        for $r in $resources
+        let $n := fn:lower-case(fn:local-name($r))
+        return
+            element {fn:name($r)} { 
+                $r/@*,
+                
+                for $p in $r/*
+                return
+                    if ($p/child::node()[@rdf:about]) then
+                        let $classes := $p/child::node()[fn:matches(fn:local-name(), "^([A-Z])([a-z]+)")]
+                        return
+                            element { fn:name($p) } {
+                                attribute rdf:resource { xs:string($p/child::node()[@rdf:about]/@rdf:about) }
+                            }
+                    else if ($p/child::node()[@rdf:nodeID]) then
+                        let $classes := $p/child::node()[fn:matches(fn:local-name(), "^([A-Z])([a-z]+)")]
+                        return
+                            element { fn:name($p) } {
+                                attribute rdf:nodeID { xs:string($p/child::node()[@rdf:nodeID]/@rdf:nodeID) }
+                            }
+                    else
+                        $p
+            }
+
+    return $simplified-resources 
+
+};