rsinger-rdfobjects 0.1.3 → 0.1.7

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,30 @@
+module RDFObject::Modifiers
+  attr_reader :data_type
+  attr_accessor :language
+  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#int' 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
+    obj.extend(RDFObject::Modifiers)
+    obj.set_data_type(options[:data_type])
+    obj.language = options[:language]
+    obj
+  end
+end

data/lib/rdf_objects/http_client.rb

@@ -0,0 +1,54 @@
+require 'net/http'
+require 'uri'
+require 'cgi'
+
+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

data/lib/rdf_objects/parsers.rb

@@ -0,0 +1,173 @@
+$KCODE = 'u'
+require 'rubygems'
+require 'strscan'
+require 'iconv'
+require 'jcode'
+require 'uri'
+require 'json'
+require 'nokogiri'
+require 'cgi'
+
+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 GeneratorError, "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
+    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?\.\n?$)|("@[A-z])|("\^\^)/)
+      scanner.pos=(scanner.pos-2)
+      object.sub!(/"..$/,'')
+      uscan = UTF8Parser.new(object)
+      object = uscan.parse_string
+      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 |
+      triple = self.new(assertion)
+      resource = Resource.new(triple.subject)
+      resource.assert(triple.predicate, triple.object)
+      collection << resource
+    end
+    collection.uniq!
+  end
+end
+
+class XMLParser
+  def self.parse(doc)
+    xslt = Nokogiri::XSLT(open(File.dirname(__FILE__) + '/../xsl/rdf2nt.xsl'))
+    xformed_doc = xslt.apply_to(doc)
+    ntriples = xformed_doc.split("\n")
+    if ntriples[0] =~ /^\<\?xml/
+      ntriples.delete_at(0)
+    end
+    return NTriplesParser.parse(ntriples)
+  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
+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)
+          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

data/lib/rdf_objects/rdf_resource.rb

@@ -0,0 +1,216 @@
+require 'uri'
+require 'builder'
+require 'date'
+require 'curies'
+
+module RDFObject
+  class Resource < OpenStruct
+    class << self
+      attr_reader :instances
+
+      def instances
+        @instances ||= {}
+        @instances
+      end
+
+      def reset!
+        @instances = {}
+      end
+
+      def register(resource)
+        instances
+        @instances[resource.uri] = resource
+      end
+
+      def remove(resource)
+        instances      
+        @instances.delete(resource.uri)
+      end
+    
+      def exists?(uri)
+        instances
+        if @instances.has_key?(uri)
+          true
+        else
+          false
+        end
+      end
+    end
+
+    def initialize(uri)        
+      if uri.could_be_a_safe_curie?
+        uri = Curie.parse uri
+      end
+      super(:uri=>uri)
+      self.class.register(self)
+    end
+  
+    def assert(predicate, object)
+      curied_predicate = case
+      when predicate.could_be_a_safe_curie? then Curie.new_from_curie(predicate)
+      when Curie.curie_from_uri(predicate) then Curie.curie_from_uri(predicate)
+      else Curie.create_from_uri(predicate)
+      end
+      self.register_vocabulary(curied_predicate.prefix)
+      pred_attr = self.send(curied_predicate.prefix.to_sym)
+      return if assertion_exists?(predicate, object)
+      if pred_attr[curied_predicate.reference]
+        unless pred_attr[curied_predicate.reference].is_a?(Array)
+          pred_attr[curied_predicate.reference] = [pred_attr[curied_predicate.reference]]
+        end
+        pred_attr[curied_predicate.reference] << object
+      else
+        pred_attr[curied_predicate.reference] = object
+      end
+    end
+    
+    def assertion_exists?(predicate, object)
+      return false unless self[predicate]
+      if self[predicate].is_a?(Array)
+        return true if self[predicate].index(object)
+      else
+        return true if self[predicate] == object
+      end
+      return false
+    end
+  
+    def [](uri)
+      curie = case
+      when uri.could_be_a_safe_curie? then Curie.new_from_curie(uri)
+      when Curie.curie_from_uri(uri) then Curie.curie_from_uri(uri)
+      else 
+        return nil
+      end
+      vocab = self.send(curie.prefix.to_sym)
+      return nil unless vocab
+      return vocab if curie.reference.empty?
+      return vocab[curie.reference]
+    end
+  
+    def prefix_for(uri)
+      Curie.prefix_for(uri)
+    end
+  
+    def register_vocabulary(name)
+      return if self.respond_to?(name.to_sym)
+      self.new_ostruct_member(name)
+      self.send("#{name}=".to_sym, {})
+    end
+  
+    def relate(predicate, resource)
+      unless resource.is_a?(self.class)
+        resource = self.class.new(resource)
+      end
+      self.assert(predicate, resource)
+    end
+  
+    def describe
+      rdf = HTTPClient.fetch(self.uri)
+      Parser.parse(rdf)
+    end
+  
+    def empty_graph?
+      Curie.get_mappings.each do | prefix, uri |
+        return false if self.respond_to?(prefix.to_sym)
+      end
+      return true
+    end
+  
+    def to_xml
+      doc = Builder::XmlMarkup.new
+      xmlns = {}
+      i = 1
+      @namespaces.each do | ns |
+        next if ns == 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'
+        xmlns["xmlns:n#{i}"] = ns
+        i += 1
+      end
+      doc.rdf :Description,xmlns.merge({:about=>uri}) do | rdf |
+        self.instance_variables.each do | ivar |
+          next unless ivar =~ /^@n[0-9]*_/
+          prefix, tag = ivar.split('_',2)
+          attrs = {}
+          curr_attr = self.instance_variable_get("#{ivar}")
+          prefix.sub!(/^@/,'')
+          prefix = 'rdf' if prefix == 'n0'
+          unless curr_attr.is_a?(Array)
+            curr_attr = [curr_attr]
+          end
+          curr_attr.each do | val |
+            if val.is_a?(RDFResource)
+              attrs['rdf:resource'] = val.uri
+            end
+            if @modifiers[val.object_id]
+              if @modifiers[val.object_id][:language]
+                attrs['xml:lang'] = @modifiers[val.object_id][:language]
+              end
+              if @modifiers[val.object_id][:type]
+                attrs['rdf:datatype'] = @modifiers[val.object_id][:type]
+              end          
+            end
+            unless attrs['rdf:resource']
+              rdf.tag!("#{prefix}:#{tag}", attrs, val)
+            else
+              rdf.tag!("#{prefix}:#{tag}", attrs)
+            end
+          end
+        end
+      end
+      doc.target!
+    end
+  
+    def to_rss
+      doc = Builder::XmlMarkup.new
+      xmlns = {}
+      i = 1
+      @namespaces.each do | ns |
+        next if ns == 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'
+        xmlns["xmlns:n#{i}"] = ns
+        i += 1
+      end
+      xmlns["xmlns:rss"] = "http://purl.org/rss/1.0/"
+      doc.rdf :RDF, xmlns do | rdf |
+        rdf.item :about=>uri do | item |
+          self.instance_variables.each do | ivar |
+            next unless ivar =~ /^@n[0-9]*_/
+            prefix, tag = ivar.split('_',2)
+            attrs = {}
+            curr_attr = self.instance_variable_get("#{ivar}")
+            prefix.sub!(/^@/,'')
+            prefix = 'rdf' if prefix == 'n0'
+            unless curr_attr.is_a?(Array)
+              curr_attr = [curr_attr]
+            end
+            curr_attr.each do | val |
+              if val.is_a?(RDFResource)
+                attrs['rdf:resource'] = val.uri
+              end
+              if @modifiers[val.object_id]
+                if @modifiers[val.object_id][:language]
+                  attrs['xml:lang'] = @modifiers[val.object_id][:language]
+                end
+                if @modifiers[val.object_id][:type]
+                  attrs['rdf:datatype'] = @modifiers[val.object_id][:type]
+                end          
+              end
+              unless attrs['rdf:resource']
+                item.tag!("#{prefix}:#{tag}", attrs, val)
+              else
+                item.tag!("#{prefix}:#{tag}", attrs)
+              end
+            end
+          end
+        end
+      end
+      doc.target!
+    end    
+    def self.new(uri)
+      if self.exists?(uri)
+        return self.instances[uri]
+      end
+      super(uri)
+    end
+  
+   
+  end
+end

data/lib/rdf_objects/serializers.rb

@@ -0,0 +1,7 @@
+require 'nokogiri'
+module RDFObject
+  class XMLSerializer
+    def self.write(resources)
+    end
+  end
+end

data/lib/rdf_objects.rb

@@ -0,0 +1,11 @@
+module RDFObject
+  require 'rubygems'
+  require 'ostruct'
+  require 'curies'
+  require File.dirname(__FILE__) + '/rdf_objects/parsers'
+  require File.dirname(__FILE__) + '/rdf_objects/rdf_resource'
+  require File.dirname(__FILE__) + '/rdf_objects/curies'
+  require File.dirname(__FILE__) + '/rdf_objects/data_types'
+  require File.dirname(__FILE__) + '/rdf_objects/http_client'    
+  Curie.remove_prefixes!(:http)
+end