rdfobjects 0.3.1

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2007 Ross Singer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,103 @@
+RDFObjects are intended to simplify working with RDF data by providing a (more) Ruby-like interface to resources (thanks to OpenStruct).
+
+Installation:
+  sudo gem install rsinger-rdfobjects
+
+Requirements:
+  * Nokogiri (the idea is for more options in the future)
+  * rsinger-curies
+  * Builder (although, ideally, this will be deprecated)
+  * json (or json_pure)
+  
+Usage:
+  >> require 'rdf_objects'
+  
+  >> include RDFObject
+  
+  >> Curie.add_prefixes! :skos=>"http://www.w3.org/2004/02/skos/core#"
+  
+  >> resource = Resource.new('http://id.loc.gov/authorities/sh2002000569#concept')
+  >> resource.describe
+  >> resource.skos
+  
+  => {"inScheme"=>[#<RDFObject::Resource uri="http://id.loc.gov/authorities#topicalTerms">, #<RDFObject::Resource uri="http://id.loc.gov/authorities#conceptScheme">], "broader"=>[#<RDFObject::Resource skos={"prefLabel"=>"Semantic networks (Information theory)"}, uri="http://id.loc.gov/authorities/sh92004914#concept">, #<RDFObject::Resource skos={"prefLabel"=>"World Wide Web"}, uri="http://id.loc.gov/authorities/sh95000541#concept">, #<RDFObject::Resource skos={"prefLabel"=>"Semantic integration (Computer systems)"}, uri="http://id.loc.gov/authorities/sh2004000479#concept">], "closeMatch"=>#<RDFObject::Resource uri="http://stitch.cs.vu.nl/vocabularies/rameau/ark:/12148/cb14521343b">, "prefLabel"=>"Semantic Web"}
+  
+  >> resource["[skos:prefLabel]"]
+  
+  => "Semantic Web"
+  
+  >> resource.skos["prefLabel"]
+  
+  => "Semantic Web"
+  
+  >> resource["http://www.w3.org/2004/02/skos/core#prefLabel"]
+  
+  => "Semantic Web"
+  (etc.)
+  
+  >> resource.skos["broader"].first.skos["prefLabel"]
+  
+  => "Semantic networks (Information theory)"
+  
+  Unnecessary, but helpful, way to define typed literals
+  >> source = Literal.new("Library of Congress Authorities", {:language=>"en"})
+  
+  And assert them
+  
+  >> resource.assert("http://purl.org/dc/terms/source", source)
+  
+  => ["Work cat.: 2002070545: The Semantic Web--ISWC 20002, 2002.", "ASTI on FirstSearch, May 6, 2002: in titles (semantic Web)", "Engr. index online, May 6, 2002 (identifier: Semantic Web)", "Library of Congress Authorities"]
+  
+  >> resource["http://purl.org/dc/terms/source"].last.language
+  
+  => "en"
+  
+  To relate a resource to another URI you can use #.resource - it will accept full uri strings, safe curies or other RDFObject::Resource objects
+  
+  >> resource.relate("[skos:closeMatch]", "http://dbpedia.org/resource/Category:Semantic_Web")
+  
+  => [#<RDFObject::Resource uri="http://stitch.cs.vu.nl/vocabularies/rameau/ark:/12148/cb14521343b">, #<RDFObject::Resource uri="http://dbpedia.org/resource/Category:Semantic_Web">]
+  
+  RDFObject::Resources sort of act as singletons
+  
+  >> r1 = Resource.new('http://ex.org/ex/1234')
+  
+  => #<RDFObject::Resource uri="http://ex.org/ex/1234">
+  
+  >> r1.object_id
+  
+  => 8996290
+  
+  >> r2 = Resource.new('http://ex.org/ex/1234')
+  
+  => #<RDFObject::Resource uri="http://ex.org/ex/1234">  
+  
+  >> r2.object_id
+  
+  => 8996290  
+  
+  So relationships and assertions are always applied to the same object.  These are managed in the RDFObject::Resource class:
+  
+  >> Resource.instances
+  
+  => {"http://ex.org/ex/1234"=>#<RDFObject::Resource uri="http://ex.org/ex/1234">}
+  
+  You can delete a single resource:
+  
+  >> Resource.remove(r1)
+  
+  >> Resource.instances
+  => {}
+
+  Or clear the entire hash:
+  
+  >> Resource.reset!
+  
+  There are also very crude parsers for ntriples and rdf/xml
+  
+  >> resources = Parser.parse(open('lcsh.nt').read)
+  
+  >> resources.first
+  
+  => #<RDFObject::Resource n0={"altLabel"=>"Lichen ruber planus", "inScheme"=>[#<RDFObject::Resource uri="http://id.loc.gov/authorities#conceptScheme">, #<RDFObject::Resource uri="http://id.loc.gov/authorities#topicalTerms">], "prefLabel"=>"Lichen planus"}, n1={"sameAs"=>#<RDFObject::Resource uri="info:lc/authorities/sh85076767">}, uri="http://id.loc.gov/authorities/sh85076767#concept", n2={"modified"=>#<DateTime: 211644344801/86400,-1/6,2299161>}, rdf={"type"=>#<RDFObject::Resource uri="http://www.w3.org/2004/02/skos/core#Concept">}>
+  

data/lib/rdf_objects/curies.rb

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'curies'
+class Curie
+  @@namespace_counter = 0
+  
+  # Returns a Curie object from a fully qualified uri (assuming it is registered)
+  def self.curie_from_uri(uri_string)
+    @@mappings.each do | prefix, uri |
+      if m = uri_string.match(/^#{uri}(.*)/)
+        return self.new(prefix, m[1]) if m[1]
+      end
+    end
+    false
+  end
+  
+  # Returns the Curie prefix for a URI
+  def self.prefix_for(uri_string)
+    @@mappings.each do | prefix, uri |
+      if m = uri_string.match(/^#{uri}(.*)/)
+        return prefix
+      end
+    end
+    false
+  end
+  
+  # Automatically tries to build a safe curie from a uri string.
+  # Assumes an RDF Schema and a flat hierarchy.
+  def self.create_from_uri(uri_string, prefix=nil)
+    if curie = self.curie_from_uri(uri_string)
+      return curie
+    end
+    uri = URI.parse(uri_string)
+    ns = nil
+    elem = nil    
+    if uri.fragment
+      ns, elem = uri.to_s.split('#')
+      ns << '#'
+    else
+      elem = uri.path.split('/').last
+      ns = uri.to_s.sub(/#{elem}$/, '')
+    end  
+    unless prefix
+      prefix = "n#{@@namespace_counter}"
+      @@namespace_counter += 1
+    end
+    Curie.add_prefixes!  prefix.to_s => ns
+    self.curie_from_uri(uri_string)
+  end
+  
+  def self.get_mappings
+    return @@mappings
+  end
+  
+  # Return a Curie object from a safe curie string.
+  def self.new_from_curie(curie_string)
+    unless curie_string.could_be_a_safe_curie?
+      raise "not a real curie"
+    end
+    prefix, resource = curie_string.curie_parts
+    return Curie.new(prefix, resource)
+  end
+end

data/lib/rdf_objects/data_types.rb

@@ -0,0 +1,57 @@
+class Integer
+  attr_accessor :language, :data_type
+  def set_data_type(uri)
+    @data_type = uri
+  end
+end
+class Date
+  attr_accessor :language, :data_type
+  def set_data_type(uri)
+    @data_type = uri
+  end
+end
+class String
+  attr_accessor :language, :data_type
+  def set_data_type(uri)
+    @data_type = uri
+  end
+end
+class TrueClass
+  attr_accessor :language, :data_type
+  def set_data_type(uri)
+    @data_type = uri
+  end
+end
+class FalseClass
+  attr_accessor :language, :data_type
+  def set_data_type(uri)
+    @data_type = uri
+  end
+end
+
+
+
+class RDFObject::Literal
+  def self.new(value, options={})
+    obj = case options[:data_type]
+    when 'http://www.w3.org/2001/XMLSchema#dateTime' then DateTime.parse(value)
+    when 'http://www.w3.org/2001/XMLSchema#date' then Date.parse(value)
+    when 'http://www.w3.org/2001/XMLSchema#integer' then value.to_i
+    when 'http://www.w3.org/2001/XMLSchema#string' then value.to_s
+    when 'http://www.w3.org/2001/XMLSchema#boolean'
+      if value.downcase == 'true' || value == '1'
+        true
+      else
+        false
+      end
+    else
+      value
+    end
+    if obj.to_s != value
+      raise ArgumentError 
+    end
+    obj.set_data_type(options[:data_type])
+    obj.language = options[:language]
+    obj
+  end
+end

data/lib/rdf_objects/http_client.rb

@@ -0,0 +1,55 @@
+require 'net/http'
+require 'uri'
+require 'cgi'
+module RDFObject
+  class HTTPClient
+    @@proxies = {}
+    def self.fetch(uri)
+      @@proxies.each do | key, proxy |
+        if uri.match(key)
+          uri = proxy.proxy_uri(uri, ['ntriples','rdf'])
+        end
+      end
+      u = URI.parse(uri)
+      request = Net::HTTP::Get.new(u.request_uri)
+      request['accept'] = nil
+      request['accept'] = ['application/rdf+xml']
+      response = Net::HTTP.start(u.host, u.port) do | http |
+        http.request(request)
+      end
+      if response.code != "200"
+        raise response.message
+      end
+      response.body
+    end
+  
+    def self.register_proxy(uri,proxy)
+      @@proxies[uri] = proxy
+    end
+  end
+
+
+  class TalisPlatformProxy
+    attr_reader :store
+    @@formats = ['rdf','ntriples','turtle','json']
+    def initialize(store_name)
+      @store = store_name
+    end
+  
+    def proxy_uri(uri, format=['rdf'])
+      idx = 0
+      best_format = nil
+      while !best_format
+        @@formats.each do | fmt |
+          if format[idx] == fmt
+            best_format = fmt
+            break
+          end
+        end
+        idx += 1
+      end
+      raise "No compatible response format!" if !best_format
+      "http://api.talis.com/stores/#{@store}/meta?about=#{CGI.escape(uri)}&output=#{best_format}"
+    end
+  end
+end

data/lib/rdf_objects/parsers.rb

@@ -0,0 +1,274 @@
+# encoding: utf-8
+require 'rubygems'
+require 'strscan'
+require 'iconv'
+require 'uri'
+require 'json'
+require 'nokogiri'
+require 'cgi'
+if RUBY_VERSION < '1.9.0'
+  $KCODE = 'u'
+  require 'jcode'
+end
+
+class UTF8Parser < StringScanner
+  STRING = /(([\x0-\x1f]|[\\\/bfnrt]|\\u[0-9a-fA-F]{4}|[\x20-\xff])*)/nx
+  UNPARSED = Object.new      
+  UNESCAPE_MAP = Hash.new { |h, k| h[k] = k.chr }
+  UNESCAPE_MAP.update({
+    ?"  => '"',
+    ?\\ => '\\',
+    ?/  => '/',
+    ?b  => "\b",
+    ?f  => "\f",
+    ?n  => "\n",
+    ?r  => "\r",
+    ?t  => "\t",
+    ?u  => nil, 
+  })        
+  UTF16toUTF8 = Iconv.new('utf-8', 'utf-16be')                
+  def initialize(str)
+    super(str)
+    @string = str
+  end
+  def parse_string
+    if scan(STRING)
+      return '' if self[1].empty?
+      string = self[1].gsub(%r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n) do |c|
+        if u = UNESCAPE_MAP[$&[1]]
+          u
+        else # \uXXXX
+          bytes = ''
+          i = 0
+          while c[6 * i] == ?\\ && c[6 * i + 1] == ?u
+            bytes << c[6 * i + 2, 2].to_i(16) << c[6 * i + 4, 2].to_i(16)
+            i += 1
+          end
+          UTF16toUTF8.iconv(bytes)
+        end
+      end
+      if string.respond_to?(:force_encoding)
+        string.force_encoding(Encoding::UTF_8)
+      end
+      string
+    else
+      UNPARSED
+    end
+  rescue Iconv::Failure => e
+    raise StandardError, "Caught #{e.class}: #{e}"
+  end  
+end
+module RDFObject
+class NTriplesParser
+  attr_reader :ntriple, :subject, :predicate, :data_type, :language, :literal
+  attr_accessor :object
+  def initialize(line)
+    @ntriple = line
+    if @ntriple.respond_to?(:force_encoding)
+      @ntriple.force_encoding("ASCII-8BIT")
+    end
+    parse_ntriple
+  end
+  
+  def parse_ntriple
+    scanner = StringScanner.new(@ntriple)
+    @subject = scanner.scan_until(/> /)
+    @subject.sub!(/^</,'')
+    @subject.sub!(/> $/,'')
+    @predicate = scanner.scan_until(/> /)
+    @predicate.sub!(/^</,'')
+    @predicate.sub!(/> $/,'')
+    if scanner.match?(/</)
+      object = scanner.scan_until(/>\s?\.\s*\n?$/)
+      object.sub!(/^</,'')
+      object.sub!(/>\s?\.\s*\n?$/,'')
+      @object = Resource.new(object)
+    else
+      @literal = true
+      scanner.getch
+      object = scanner.scan_until(/("\s?\.\s*\n?$)|("@[A-z])|("\^\^)/)
+      scanner.pos=(scanner.pos-2)
+      object.sub!(/"..$/,'')
+      if object.respond_to?(:force_encoding)
+        object.force_encoding('utf-8').chomp!
+      else
+        uscan = UTF8Parser.new(object)
+        object = uscan.parse_string.chomp
+      end
+      if scanner.match?(/@/)
+        scanner.getch
+        @language = scanner.scan_until(/\s?\.\n?$/)
+        @language.sub!(/\s?\.\n?$/,'')
+      elsif scanner.match?(/\^\^/)
+        scanner.skip_until(/</)
+        @data_type = scanner.scan_until(/>/)
+        @data_type.sub!(/>$/,'')
+      end
+      @object = Literal.new(object,{:data_type=>@data_type,:language=>@language})      
+    end
+  end
+  
+  def self.parse(resources)
+    collection = []
+    if resources.is_a?(String)
+      assertions = resources.split("\n")
+    elsif resources.is_a?(Array)
+      assertions = resources
+    elsif resources.respond_to?(:read)
+      assertions = resources.readlines
+    end
+    assertions.each do | assertion |
+      next if assertion[0, 1] == "#" # Ignore comments
+      triple = self.new(assertion)
+      resource = Resource.new(triple.subject)
+      resource.assert(triple.predicate, triple.object)
+      collection << resource
+    end
+    collection.uniq!
+  end
+end
+
+class XMLParser
+  #
+  # A very unsophisticated RDF/XML Parser -- currently only parses RDF/XML that conforms to 
+  # the SimpleRdfXml convention:  http://esw.w3.org/topic/SimpleRdfXml.  This is a pragmatic
+  # rather than dogmatic decision.  If it is not working with your RDF/XML let me know and we
+  # can probably fix it.
+  #
+  def self.parse(doc)
+    namespaces = doc.namespaces
+    if namespaces.index("http://purl.org/rss/1.0/")
+      collection = parse_rss10(doc)
+    elsif namespaces.index("http://www.w3.org/2005/sparql-results#")
+      raise "Sorry, SPARQL not yet supported"
+    else
+      collection = parse_rdfxml(doc)
+    end
+    collection.uniq
+  end
+  
+  def self.parse_resource_node(resource_node, collection)
+    resource = Resource.new(resource_node.attribute_with_ns('about', "http://www.w3.org/1999/02/22-rdf-syntax-ns#").value)
+    unless (resource_node.name == "Description" and resource_node.namespace.href == "http://www.w3.org/1999/02/22-rdf-syntax-ns#") or
+      (resource_node.name == "item" and resource_node.namespace.href == "http://purl.org/rss/1.0/")
+      resource.assert("[rdf:type]","#{resource_node.namespace.href}#{resource_node.name}")
+    end
+    resource_node.children.each do | child |
+      next if child.text?
+      predicate = "#{child.namespace.href}#{child.name}"
+      if object_uri = child.attribute_with_ns("resource", "http://www.w3.org/1999/02/22-rdf-syntax-ns#")
+        obj_resource = Resource.new(object_uri.value)
+        resource.assert(predicate, obj_resource)
+        collection << obj_resource
+      elsif child.content
+
+        opts = {}
+        if lang = child.attribute_with_ns("lang", "http://www.w3.org/XML/1998/namespace")
+          opts[:language] = lang.value
+        end
+        if datatype = child.attribute_with_ns("datatype", "http://www.w3.org/1999/02/22-rdf-syntax-ns#")
+          opts[:data_type] = datatype.value
+        end
+        resource.assert(predicate, Literal.new(child.content,opts))
+      end
+      child.xpath("./*[@rdf:about]").each do | grandchild |
+        gc_resource = Resource.new(grandchild.attribute_with_ns('about', "http://www.w3.org/1999/02/22-rdf-syntax-ns#").value)
+        resource.assert(predicate, gc_resource)
+        collection << gc_resource
+        parse_resource_node(grandchild, collection)
+      end
+    end
+    collection << resource        
+  end
+  
+  def self.parse_rdfxml(doc)
+    collection = []
+    doc.root.xpath("./*[@rdf:about]").each do | resource_node |
+      parse_resource_node(resource_node, collection)
+    end
+    collection
+  end    
+  
+  def self.parse_rss10(doc)
+    collection = []
+    doc.root.xpath("./rss:item","rss"=>"http://purl.org/rss/1.0/").each do | resource_node |
+      parse_resource_node(resource_node, collection)
+    end
+    collection
+  end
+end
+
+class RDFAParser
+  def self.parse(doc)
+    xslt = Nokogiri::XSLT(open(File.dirname(__FILE__) + '/../xsl/RDFa2RDFXML.xsl'))
+    rdf_doc = xslt.apply_to(doc)  
+    XMLParser.parse(Nokogiri.parse(rdf_doc))  
+  end
+end
+
+class JSONParser
+  def self.parse(json)
+    collection = []
+    json.each_pair do |subject, assertions|
+      resource = Resource.new(subject)
+      collection << resource
+      assertions.each_pair do |predicate, objects|
+        objects.each do | object |
+          if object['type'] == 'literal'
+            opts = {}
+            if object['lang']
+              opts[:language] = object['lang']
+            end
+            if object['datatype']
+              opts[:data_type] = object['datatype']
+            end
+            literal = Literal.new(object['value'],opts)
+            resource.assert(predicate, literal)
+          elsif object['type'] == 'uri'
+            o = Resource.new(object['value'])
+            resource.assert(predicate, o)
+            collection << o
+          elsif object['type'] == 'bnode' # For now, we're going to treat a blank node like a URI resource.
+            o = Resource.new(object['value'])
+            resource.assert(predicate, o)
+            collection << o            
+          end
+        end
+      end
+    end
+    collection.uniq
+  end
+end
+
+class Parser
+  # Choose the best format parser from an admittedly small group of choices.
+  def self.parse(rdf)
+    begin
+      # Check if the format is XML or RDFa
+      doc = Nokogiri::XML.parse(rdf, nil, nil, Nokogiri::XML::ParseOptions::PEDANTIC)
+      raise "Unable to parse XML/HTML document -- no namespace declared" unless doc.root.namespaces
+      if doc.root.namespaces.values.index("http://www.w3.org/1999/xhtml")
+        collection = RDFAParser.parse(doc)
+      else
+        collection = XMLParser.parse(doc)
+      end
+    rescue Nokogiri::XML::SyntaxError
+      begin
+        if rdf.respond_to?(:read)
+          rdf.rewind
+          json = JSON.parse(rdf.read)
+        else
+          json = JSON.parse(rdf)
+        end
+        collection = JSONParser.parse(json)
+      rescue JSON::ParserError
+        if rdf.respond_to?(:read)
+          rdf.rewind
+        end
+        collection = NTriplesParser.parse(rdf)
+      end
+    end
+    collection  
+  end
+end
+end