rdfobjects 0.9.1 → 0.10.0

data/lib/rdf_objects/collection.rb

@@ -40,7 +40,13 @@ module RDFObject
       if uri.could_be_a_safe_curie?
         uri = Curie.parse uri
       end
-      self[uri] = Resource.new(uri) unless self[uri]
+      if BlankNode.is_bnode_id?(uri)
+        bnode = BlankNode.new(uri)
+        self[bnode.uri] = bnode unless self[bnode.uri]
+        return self[bnode.uri]
+      else
+        self[uri] = Resource.new(uri) unless self[uri]        
+      end
       self[uri]
     end  
     

data/lib/rdf_objects/data_types.rb

@@ -55,7 +55,11 @@ class RDFObject::Literal
       value
     end
     if obj.is_a?(Float)
-      raise ArgumentError if obj.to_s.sub(/\.0/,'') != value
+      if obj.to_s == value
+      elsif obj.to_s.sub(/\.0*/,'') == value
+      else
+        raise ArgumentError
+      end
     elsif obj.is_a?(DateTime)
       raise ArgumentError if obj.to_s !~ /^#{Regexp.escape(value)}/
     else

data/lib/rdf_objects/parsers.rb

@@ -64,7 +64,7 @@ module RDFObject
     # Choose the best format parser from an admittedly small group of choices.
     def self.parse(rdf, options={})
       parser = init_parser(rdf, options)
-      parser.parse 
+      parser.parse if parser
     end
     
     def self.init_parser(rdf, options={})
@@ -76,7 +76,16 @@ module RDFObject
         when 'json' then JSONParser.new(rdf)
         end        
       else
-
+        # Check to see if it is a URI being passed
+        begin
+          uri = URI.parse(rdf)
+          if uri.is_a?(URI::HTTP)
+            response =  HTTPClient.fetch(rdf)
+            rdf = response[:content]
+            options[:base_uri] = response[:uri]
+          end
+        rescue URI::InvalidURIError
+        end
         # Check if the format is XML or RDFa
         doc = XMLTestDocument.new
         p = Nokogiri::XML::SAX::Parser.new(doc)
@@ -90,8 +99,9 @@ module RDFObject
             rdf.rewind
           end
           if doc.is_html?
+
             parser = RDFAParser.new(rdf)
-          else              
+          elsif doc.is_rdf?              
             parser = XMLParser.new(rdf)
           end
         else
@@ -111,7 +121,7 @@ module RDFObject
           end
         end
       end
-      if options[:base_uri]
+      if options[:base_uri] && parser
         parser.base_uri = options[:base_uri]
       end
       parser
@@ -155,9 +165,14 @@ module RDFObject
         ntriple.force_encoding("ASCII-8BIT")
       end      
       scanner = StringScanner.new(ntriple)
-      subject = scanner.scan_until(/> /)
-      subject.sub!(/^</,'')
-      subject.sub!(/> $/,'')
+      if ntriple[0,1] == "<"
+        subject = scanner.scan_until(/> /)
+        subject.sub!(/^</,'')
+        subject.sub!(/> $/,'')
+      else
+        subject = scanner.scan_until(/\w /)
+        subject.strip!
+      end
       predicate = scanner.scan_until(/> /)
       predicate.sub!(/^</,'')
       predicate.sub!(/> $/,'')
@@ -167,6 +182,10 @@ module RDFObject
         tmp_object.sub!(/>\s?\.\s*\n?$/,'')
         object = self.sanitize_uri(tmp_object)
         type = "uri"
+      elsif scanner.match?(/_:/)
+        object = scanner.scan_until(/\w\s?\.\s*\n?$/)
+        object.sub!(/\s?\.\s*\n?$/,'')
+        type = "bnode"
       else
         language = nil
         data_type = nil
@@ -213,6 +232,7 @@ module RDFObject
         object = case triple[:type]
         when "literal" then triple[:object]
         when "uri" then @collection.find_or_create(triple[:object])
+        when "bnode" then @collection.find_or_create(triple[:object])
         end
         resource.assert(triple[:predicate],object)
       end
@@ -248,8 +268,14 @@ module RDFObject
       return false
     end
     
+    def is_rdf?
+      return true if @namespaces.index("http://www.w3.org/1999/02/22-rdf-syntax-ns#")
+      return false
+    end
+    
     def is_html?
       return true if @namespaces.index("http://www.w3.org/1999/xhtml")
+      return true if @xml_start =~ /html/i
       return false
     end
   end
@@ -294,35 +320,12 @@ module RDFObject
       hash
     end
     
-    #def add_layer(element_uri, resource_uri)
-    #  if @uris.length > 0 && @current_predicate
-    #    @collection[@uris.last].relate(@current_predicate, @collection.find_or_create(resource_uri))
-    #    @current_predicate = nil
-    #  end
-    #  @uris << resource_uri
-    #  @tags[resource_uri] = element_uri              
-    #end
-    
-    #def remove_layer(element_uri)
-    #  uris = []
-    #  @tags.each do |uri, el|
-    #    uris << uri if el == element_uri
-    #  end
-    #  uris.each do | uri |  
-    #    if @uris.last == uri
-    #      @uris.pop
-    #      @tags.delete(uri)
-    #      break
-    #    end
-    #  end
-    #  @current_resource = @collection[@uris.last]
-    #end
-    
-    
     def add_layer name, attributes, prefix, uri, ns
       layer = {:name=>"#{uri}#{name}"}
-      if attributes['about']
-        layer[:resource] = @collection.find_or_create(sanitize_uri(attributes['about']))
+      if attributes['about'] or attributes['nodeID']
+        id = attributes['about'] || attributes['nodeID']
+        id = sanitize_uri(id) if attributes['about']
+        layer[:resource] = @collection.find_or_create(id)
         unless "#{uri}#{name}" == "http://www.w3.org/1999/02/22-rdf-syntax-ns#Description"
           layer[:resource].relate("http://www.w3.org/1999/02/22-rdf-syntax-ns#type", @collection.find_or_create("#{uri}#{name}"))
         end 

data/lib/rdf_objects/rdf_resource.rb

@@ -3,15 +3,7 @@ require 'date'
 require 'curies'
 
 module RDFObject
-  class Resource < OpenStruct
-    attr_reader :table
-    def initialize(uri)        
-      if uri.could_be_a_safe_curie?
-        uri = Curie.parse uri
-      end
-      super(:uri=>uri)
-    end
-  
+  module Node
     def assert(predicate, object)
       curied_predicate = case
       when predicate.could_be_a_safe_curie? then Curie.new_from_curie(predicate)
@@ -68,8 +60,12 @@ module RDFObject
     end
   
     def relate(predicate, resource)
-      unless resource.is_a?(self.class)
-        resource = self.class.new(resource)
+      unless resource.is_a?(Resource) or resource.is_a?(BlankNode) or resource.is_a?(ResourceReference)
+        if BlankNode.is_bnode_id?(resource)
+          resource = BlankNode.new(resource)
+        else
+          resource = Resource.new(resource)
+        end
       end
       self.assert(predicate, resource)
     end
@@ -77,7 +73,7 @@ module RDFObject
     def describe
       response = HTTPClient.fetch(self.uri)
       local_collection = Parser.parse(response[:content], {:base_uri=>response[:uri]})
-      return unless local_collection[self.uri]
+      return unless local_collection && local_collection[self.uri]
       local_collection[self.uri].assertions.each do | predicate, object |
         [*object].each do | obj |
           self.assert(predicate, obj) unless self.assertion_exists?(predicate, obj)
@@ -115,9 +111,9 @@ module RDFObject
               objects = [self[uri][pred]]
             end
             objects.each do | object |           
-              line = "<#{self.uri}> <#{uri}#{pred}> "
-              if (object.is_a?(Resource) or object.is_a?(ResourceReference))
-                line << "<#{object.uri}>"
+              line = "#{ntriples_format} <#{uri}#{pred}> "
+              if object.is_a?(ResourceReference)
+                line << object.ntriples_format
               else
                 line << "#{object.to_json}"
                 if (object.respond_to?(:data_type) || object.respond_to?(:language))
@@ -155,8 +151,8 @@ module RDFObject
       rdf      
     end
     
-    def rdf_description_block(depth)
-      rdf = "<rdf:Description rdf:about=\"#{CGI.escapeHTML(self.uri)}\">"
+    def rdf_description_block(depth=0)
+      rdf = "<rdf:Description #{xml_subject_attribute}>"
       namespaces = {}
       Curie.get_mappings.each_pair do |key, value|
         if self.respond_to?(key.to_sym)
@@ -165,11 +161,11 @@ module RDFObject
               rdf << "<#{key}:#{predicate}"
               namespaces["xmlns:#{key}"] = "#{Curie.parse("[#{key}:]")}"
               if object.is_a?(RDFObject::ResourceReference)
-                if depth > 0
-                  rdf << " rdf:resource=\"#{CGI.escapeHTML(object.uri)}\" />"
+                if depth == 0
+                  rdf << " #{object.xml_object_attribute} />"
                 else
                   rdf << ">"
-                  ns, rdf_data = object.resource.rdf_description_block(depth+1)
+                  ns, rdf_data = object.resource.rdf_description_block(depth-1)
                   namespaces.merge!(ns)
                   rdf << rdf_data
                   rdf << "</#{key}:#{predicate}>"
@@ -192,7 +188,7 @@ module RDFObject
     end    
     
     def ==(other)
-      return false unless other.is_a?(Resource) or other.is_a?(ResourceReference)
+      return false unless other.is_a?(self.class) or other.is_a?(ResourceReference)
       return false unless self.uri == other.uri
       Curie.get_mappings.each do | prefix, uri |
         next unless self[uri] or other[uri]
@@ -212,8 +208,8 @@ module RDFObject
                   return false unless self[uri][pred].index(idx)
                 end
               else
-                if self[uri][pred].is_a?(Resource) or self[uri][pred].is_a?(ResourceReference)
-                  return false unless other[uri][pred].is_a?(Resource) or other[uri][pred].is_a?(ResourceReference)
+                if self[uri][pred].is_a?(Resource) or self[uri][pred].is_a?(BlankNode) or self[uri][pred].is_a?(ResourceReference)
+                  return false unless other[uri][pred].is_a?(Resource) or self[uri][pred].is_a?(BlankNode) or other[uri][pred].is_a?(ResourceReference)
                   return false unless self[uri][pred].uri == other[uri][pred].uri
                 else
                   return false unless self[uri][pred] == other[uri][pred]
@@ -227,6 +223,73 @@ module RDFObject
       end
       true
     end
+  end    
+  
+  class Resource < OpenStruct
+    include RDFObject::Node
+    attr_reader :table
+    def initialize(uri)        
+      if uri.could_be_a_safe_curie?
+        uri = Curie.parse uri
+      end
+      super(:uri=>uri)
+    end
+
+    def xml_subject_attribute
+      "rdf:about=\"#{CGI.escapeHTML(self.uri)}\""
+    end
+    
+    def xml_object_attribute
+      "rdf:resource=\"#{CGI.escapeHTML(self.uri)}\""
+    end   
+    
+    def ntriples_format
+      "<#{uri}>" 
+    end  
+  end
+  
+  class BlankNode < OpenStruct
+    include RDFObject::Node
+    require 'md5'
+    def initialize(node_id = nil)        
+      super(:node_id=>sanitize_bnode_id(node_id||MD5.md5(self.object_id.to_s + "/" + DateTime.now.to_s).to_s))
+    end    
+    
+    def describe; end
+    
+    def uri
+      "_:#{self.node_id}"
+    end
+    
+    def xml_subject_attribute
+      "rdf:nodeID=\"#{self.node_id}\""
+    end
+    
+    def xml_object_attribute
+      xml_subject_attribute
+    end
+    
+    def ntriples_format
+      uri
+    end
+    
+    def self.is_bnode_id?(str)
+      return true if str =~ /^_\:/
+      if str.could_be_a_safe_curie?
+        str = Curie.parse str
+      end
+      begin
+        uri = URI.parse(str)
+        return true unless uri.scheme
+      rescue URI::InvalidURIError
+        return true
+      end
+      return false  
+    end
+    
+    def sanitize_bnode_id(str)
+      str.sub(/^_\:/,"")
+    end    
   end
   
   class ResourceReference

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rdfobjects
 version: !ruby/object:Gem::Version 
-  version: 0.9.1
+  version: 0.10.0
 platform: ruby
 authors: 
 - Ross Singer
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-09 00:00:00 -05:00
+date: 2010-02-10 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency