ld4l-works_rdf 0.1.0

data/lib/ld4l/works_rdf/services/conversion_services/marc2bibframe/modules/module.MBIB-Default-2-BF.xqy

@@ -0,0 +1,61 @@
+xquery version "1.0";
+(:
+:   Module Name: MARCXML BIB to bibframe
+:
+:   Module Version: 1.0
+:
+:   Date: 2014 Jan 30
+:
+:   Copyright: Public Domain
+:
+:   Proprietary XQuery Extensions Used: None
+:
+:   Xquery Specification: January 2007
+:
+:   Module Overview:    Transforms special kinds of MARC Bib records
+:       into their bibframe parts.  
+:
+:)
+   
+(:~
+:   This module handles transformations of specific types of marc records, starting with Music (audio and notated)
+:   It is called from MarcxmlBib-2-Bibframe, and calls generic functions from that module. 
+:
+:   Modified to receive $collection, consisting of a bib and it's holdings (optionally)
+:
+:   @author Kevin Ford (kefo@loc.gov)
+:   @author Nate Trail (ntra@loc.gov)
+:   @since December 16, 2014
+:   @version 1.0
+:)
+
+module namespace bfdefault  = "info:lc/id-modules/marcdefault2bf#";
+
+(: MODULES :)
+
+import module namespace marc2bfutils = "info:lc/id-modules/marc2bfutils#" at "module.MARCXMLBIB-BFUtils.xqy";
+import module namespace mbshared  = "info:lc/id-modules/mbib2bibframeshared#" at "module.MBIB-2-BIBFRAME-Shared.xqy";
+
+(: NAMESPACES :)
+declare namespace marcxml       	= "http://www.loc.gov/MARC21/slim";
+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 namespace hld              = "http://www.loc.gov/opacxml/holdings/" ;
+ 
+(:~
+:   This is the function that generates bibframe data from any resource not otherwise handled.
+:
+:   @param  $marcxml        element is the MARCXML  
+:   @return bf:* as element()
+:)
+declare function bfdefault:generate-default-work(
+    $collection as element(marcxml:collection),
+    $workID as xs:string
+    ) as element ()  {
+     mbshared:generate-work($collection, $workID)
+   
+};

data/lib/ld4l/works_rdf/services/conversion_services/marc2bibframe/modules/module.MBIB-NotatedMusic-2-BF.xqy

@@ -0,0 +1,105 @@
+xquery version "1.0";
+(:
+:   Module Name: MARCXML BIB to bibframe
+:
+:   Module Version: 1.0
+:
+:   Date: 2014 Jan 30
+:
+:   Copyright: Public Domain
+:
+:   Proprietary XQuery Extensions Used: None
+:
+:   Xquery Specification: January 2007
+:
+:   Module Overview:    Transforms special kinds of MARC Bib records
+:       into their bibframe parts.  
+:
+:)
+   
+(:~
+:   This module handles transformations of specific types of marc records, starting with Music (audio and notated)
+:   It is called from MarcxmlBib-2-Bibframe, and calls generic functions from that module. 
+:	
+:   Modified to receive $collection, consisting of a bib and it's holdings (optionally)
+:
+:   @author Kevin Ford (kefo@loc.gov)
+:   @author Nate Trail (ntra@loc.gov)
+:   @since December 16, 2014
+:   @version 1.0
+:)
+
+module namespace music  = "info:lc/id-modules/marcnotatedmusic2bf#";
+
+(: MODULES :)
+
+import module namespace marc2bfutils = "info:lc/id-modules/marc2bfutils#" at "module.MARCXMLBIB-BFUtils.xqy";
+import module namespace mbshared  = 'info:lc/id-modules/mbib2bibframeshared#' at "module.MBIB-2-BIBFRAME-Shared.xqy";
+
+(: NAMESPACES :)
+declare namespace marcxml       	= "http://www.loc.gov/MARC21/slim";
+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 namespace hld              = "http://www.loc.gov/opacxml/holdings/" ;
+ 
+(:~
+:   This is the function that generates a notated music work resource.
+:   For now, just call the main function.
+:
+:   @param  $marcxml        element is the MARCXML  
+:   @return bf:* as element()
+:)
+declare function music:generate-notatedmusic-work(
+    $collection as element(marcxml:collection),
+    $workID as xs:string
+    ) as element ()  {
+    mbshared:generate-work(  $collection,    $workID    )
+}; 
+ 
+(:~
+:   This is the function that generates a notated music work resource.
+:
+:   @param  $marcxml        element is the MARCXML  
+:   @return bf:* as element()
+:)
+
+(:declare function music:generate-notatedmusic-work(
+    $marcxml as element(marcxml:record),
+    $workID as xs:string
+    ) as element ()  {
+    let $instances := mbshared:generate-instances($marcxml, $workID)
+   
+    let $types := mbshared:get-resourceTypes($marcxml)
+        
+    let $mainType := "Work" 
+    let $biblink:=fn:concat(                  
+                    $workID,
+                    fn:normalize-space(fn:string($marcxml/marcxml:controlfield[@tag eq "001"]))                   
+                 )
+    let $derivedFrom := 
+        element bf:derivedFrom {
+            attribute rdf:resource {
+                fn:concat($biblink,    ".marcxml.xml")                 
+            }
+        }
+        let $subjects:= 		 
+ 		for $d in $marcxml/marcxml:datafield[fn:matches(fn:string-join($marc2bfutils:subject-types//@tag," "),fn:string(@tag))]		
+        			return mbshared:get-subject($d)
+    return    
+        element {fn:concat("bf:" , $mainType)} {
+                    attribute rdf:about {$workID},            
+         for $t in fn:distinct-values($types)
+            return            
+                  element rdf:type {
+                    attribute rdf:resource {fn:concat("http://bibframe.org/vocab/", $t)}
+                },
+                $subjects,
+                $derivedFrom,
+            for $i in $instances 
+                return element  bf:hasInstance{$i}
+         }
+};:)

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

@@ -0,0 +1,119 @@
+xquery version "1.0";
+
+(:
+:   Module Name: BIBFRAME RDF/XML 2 JSON for Exhibit
+:
+:   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 and converts
+:       to JSON serialization to be used with MIT Exhibit.
+:       This may be a tortured train wreck.  We'll see.
+:
+:)
+   
+(:~
+:   Takes BIBFRAME RDF/XML and converts
+:   to JSON serialization to be used with MIT Exhibit.
+:
+:   @author Kevin Ford (kefo@loc.gov)
+:   @since January 10, 2013
+:   @version 1.0
+:)
+
+module namespace bfRDFXML2exhibitJSON = 'info:lc/bf-modules/bfRDFXML2exhibitJSON#';
+
+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 namespace identifiers   = "http://id.loc.gov/vocabulary/identifiers/";
+declare namespace notes         = "http://id.loc.gov/vocabulary/notes/";
+
+
+(:~
+:   This is the main function.  It converts BIBFRAME RDF/XML 
+:   to JSON serialization to be used with MIT Exhibit.
+:
+:   @param  $rdfxml         node() is the RDF/XML
+:   @param  $baseuri        xs:string is the base uri for identifiers
+:   @param  $hash           xs:string a unique hash for the identifier
+:                           it is designed to be used when this script
+:                           is run as part of a larger environment.   
+:   @return xs:string       javascript
+:)
+declare function bfRDFXML2exhibitJSON:bfRDFXML2exhibitJSON
+        (
+            $rdfxml as element(rdf:RDF),
+            $baseuri as xs:string
+        ) 
+        as xs:string
+{
+    
+    let $resources := 
+        for $c in $rdfxml/*[fn:name()]
+        let $type := fn:local-name($c)
+        let $uri := xs:string($c/@rdf:about)
+        let $id := fn:replace($uri, $baseuri, "")
+        let $l := ($c/bf:authorizedAccessPoint|$c/bf:label|$c/bf:title|$c/madsrdf:authoritativeLabel|$c/rdfs:label)[1]
+        let $l := fn:replace(xs:string($l), '"', '\\"')
+        let $props-names := 
+            for $p in $c/*[fn:name()]
+            return fn:name($p)
+        let $props-distinct := fn:distinct-values($props-names) 
+        let $props := 
+            for $name in $props-distinct
+            let $ps := 
+                for $p in $c/*[fn:name()=$name]
+                return
+                    if ($p/@rdf:resource) then
+                        fn:concat('"', fn:replace(xs:string($p/@rdf:resource), $baseuri, "") , '"')
+                    else if ($p/madsrdf:authoritativeLabel or $p/bf:label or $p/rdfs:label) then
+                        let $label := ($p/madsrdf:authoritativeLabel|$p/bf:label|$p/rdfs:label|$p/bf:title)[1]
+                        return fn:concat('"', fn:replace(xs:string($label), '"', '\\"') , '"')
+                    (: else if (xs:string($p/@rdf:parseType)="Collection") then :)
+                    else if ($p/child::node()[fn:name()]/child::node()[fn:name()]) then
+                        let $list-items := 
+                            for $i in $p/*[fn:name()]
+                            let $t := fn:local-name($i)
+                            let $els := 
+                                for $e in $i/*[fn:name()]
+                                let $n := fn:replace(fn:name($e), ":", "-")
+                                return fn:concat('"', $n , '": "', fn:normalize-space(fn:replace(xs:string($e), '"', '\\"')), '"')
+                            return
+                                fn:concat('{ 
+                                    "type": ', fn:concat('"', $t , '"'), ', 
+                                    ', fn:string-join($els, ", 
"), '
+                                    }')
+                        return fn:concat('[', fn:string-join($list-items, ', '), ']')
+                    else
+                        fn:concat('"', fn:normalize-space(fn:replace(xs:string($p), '"', '\\"')) , '"')
+            let $ps := 
+                if ( fn:count($ps) eq 1 ) then
+                    fn:concat('"', fn:replace($name, ":", "-") , '": ', $ps)
+                else
+                    fn:concat('"', fn:replace($name, ":", "-") , '": [', fn:string-join($ps, ', '), ']' )
+            where xs:string($name) ne "rdf:type"
+            return $ps
+        return 
+            fn:concat('{ 
+                "type": ', fn:concat('"', $type , '"'), ', 
+                "id": ', fn:concat('"', $id , '"'), ',
+                "bf-id": ', fn:concat('"', $id , '"'), ',
+                "uri": ', fn:concat('"', $uri , '"'), ',
+                "label": ', fn:concat('"', $l , '"'), ',
+                ', fn:string-join($props, ", 
"), '
+                }')
+
+    return fn:concat('{"items": [' , fn:string-join($resources, ", 
"), ']}')
+
+};

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

@@ -0,0 +1,193 @@
+xquery version "1.0";
+
+(:
+:   Module Name: RDF 2 JSON
+:
+:   Module Version: 1.0
+:
+:   Date: 2011 June 13
+:
+:   Copyright: Public Domain
+:
+:   Proprietary XQuery Extensions Used: none
+:
+:   Xquery Specification: January 2007
+:
+:   Module Overview:    Takes NTriples and converts  
+:       to JSON serialization.
+:
+:)
+   
+(:~
+:   Takes NTriples and converts  
+:   to JSON serialization.
+:
+:   @author Kevin Ford (kefo@loc.gov)
+:   @since June 13, 2011
+:   @version 1.0
+:)
+
+module namespace rdfxml2json = 'info:lc/id-modules/rdfxml2json#';
+
+(: Imported Modules :)
+import module namespace rdfxml2nt   = "info:lc/id-modules/rdfxml2nt#" at "module.RDFXML-2-Ntriples.xqy";
+
+(: Namespace(s) :)
+declare namespace   rdf             = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+declare namespace   madsrdf         = "http://www.loc.gov/mads/rdf/v1#";
+
+
+(:~
+:   This is the main function.  It converts full RDF/XML to 
+:   Protovis's Javascript for a force-directed graph. 
+:
+:   @param  $rdfxml         node() is the RDF/XML  
+:   @return xs:string       javascript
+:)
+declare function rdfxml2json:rdfxml2json
+        ($rdfxml) 
+        as xs:string
+{
+    let $ntriples := rdfxml2nt:rdfxml2ntriples($rdfxml)
+    let $lines := fn:tokenize($ntriples , "\n")[fn:normalize-space(.) ne ""]
+    let $uri := fn:replace( fn:substring-before($ntriples, "&#x20;"), '[<>]' , '' )      
+    let $xml :=
+        element xml {
+            for $l in $lines
+            order by $l
+            return
+                element spo {
+                    element s { 
+                        let $s := fn:substring-before($l, "&#x20;")
+                        return 
+                            (
+                                attribute sclean { fn:replace($s , '[<>]' , '') },
+                                text { $s }
+                            )
+                    },
+                    element p { 
+                        let $p := fn:substring-before(fn:substring-after($l, "&#x20;"), "&#x20;")
+                        return 
+                            (
+                                attribute pclean { fn:replace($p , '[<>]' , '') },
+                                text { $p }
+                            )
+                    },
+                    element o { 
+                        let $o := fn:replace(fn:substring-after(fn:substring-after($l, "&#x20;"), "&#x20;") , " \. " , "")
+                        return 
+                            (
+                                attribute oclean { fn:replace($o , '[<>]' , '') },
+                                text { $o }
+                            )
+                    }
+                }
+        }
+        
+    let $distinctSubjects := fn:distinct-values($xml/spo/s)
+    let $nodes :=
+        for $y in $distinctSubjects
+        return
+            let $distinctPredicates := fn:distinct-values($xml/spo[s = $y]/p)  
+            let $predicatesANDobjects :=
+                for $z in $distinctPredicates
+                return     
+                    for $x in $xml/spo[s = $y and p = $z]  
+                        let $pANDo := 
+                            fn:concat('"' , xs:string($z) , '": 
+                                [
+                                    ',
+                                    fn:string-join(
+                                        for $o in $x/o
+                                        return rdfxml2json:compute-value-block(xs:string($o)),
+                                        (: return fn:concat('{ "value" : "' , xs:string($o/@oclean) , '" }'), :)
+                                    ', '),
+                                    '
+                                ]')
+                        return $pANDo
+                return
+                    fn:concat('"' , xs:string($y) , '" : {
+                        ',
+                        fn:string-join(
+                            for $po in $predicatesANDobjects
+                            return ($po),
+                            ', 
+                            '),
+                        '
+                        }')
+
+    return fn:concat(
+        "   {
+            ",
+            fn:string-join($nodes , ',
+            
+            '),
+        "
+    }")
+
+};
+
+
+(:~
+:   This is the main function.  It converts full RDF/XML to 
+:   Protovis's Javascript for a force-directed graph. 
+:
+:   @param  $rdfxml         node() is the RDF/XML  
+:   @return xs:string       javascript
+:)
+declare function rdfxml2json:compute-value-block($o as xs:string)
+{
+    let $o := fn:normalize-space($o)
+    let $firstChar := fn:substring($o, 1, 1)
+    
+    let $value := 
+        if ($firstChar eq '"') then
+            if (fn:substring-before($o, '"^^')) then
+                fn:substring( fn:substring-before($o, '"^^') , 2)
+            
+            else if (fn:substring-before($o, '"@')) then
+                fn:substring( fn:substring-before($o, '"@') , 2)
+            
+            else
+                fn:substring($o, 2, ( fn:string-length($o)-2 ))
+        else if ($firstChar eq '<') then
+            fn:substring( fn:substring-before($o, '>') , 2)        
+        else
+            $o
+                            
+    let $type := 
+        if ($firstChar eq "<") then
+            "uri"
+        else if ($firstChar eq "_") then
+            "bnode"
+        else 
+            "literal"
+    
+    let $dtype := fn:substring-after($o, "^^")
+    let $datatype := 
+        if ($type eq "literal" and $dtype) then
+            $dtype
+        else ()
+        
+    let $lang := fn:substring-after($o, "@")
+    let $langvalue := 
+        if ($type eq "literal" and $lang) then
+            $lang
+        else ()
+
+    return 
+        fn:concat('{ 
+                                        "value" : "' , $value , '",
+                                        "type" : "' , $type , '"',
+                if ($datatype) then
+                    fn:concat(',
+                                        "datatype" : "' , $datatype , '"')
+                else "",
+                if ($langvalue) then
+                    fn:concat(',
+                                        "lang" : "' , $langvalue , '"')
+                else "",
+                '
+                                    }')
+
+};