rdf-rdfxml 0.0.2 → 0.0.3

data/History.txt

@@ -1,3 +1,23 @@
+=== 0.0.3
+* Added patches for the following:
+  * RDF::Graph#properties
+  * RDF::Graph#seq (Output rdf:Seq elements in order)
+  * RDF::Graph#type_of
+  * RDF::Literal.xmlliteral (Create literal and normalize XML)
+  * RDF::Literal#xmlliteral?
+  * RDF::Literal#anonymous? (missing from library)
+  * RDF::Literal#to_s (only one of @lang or ^^type, not both)
+  * RDF::URI#join (Don't add trailing '/')
+* Reader fixes
+* Writer complete
+* Spec status
+  * Isomorphic XMLLiteral tests fail due to attribute order variation
+  * Reader parsing multi-line quite in NTriples test file fails due to lack of support in RDF::NTriples
+  * A couple of URI normalizations fail:
+    * should create <http://foo/> from <http://foo#> and ''
+    * should create <http://foo/bar> from <http://foo/bar#> and ''
+  * Writer test needs Turtle reader
+
 === 0.0.2
 * Added specs from RdfContext
 * Added array_hacks, nokogiri_hacks, and rdf_escape

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/lib/rdf/rdfxml/format.rb

@@ -3,8 +3,8 @@ module RDF::RDFXML
   # RDFXML format specification.
   #
   # @example Obtaining an RDFXML format class
-  #   RDF::Format.for(:rdf)        # RDF::RDFXML::Format
-  #   RDF::Format.for(:xml)        # RDF::RDFXML::Format
+  #   RDF::Format.for(:rdf)         # RDF::RDFXML::Format
+  #   RDF::Format.for(:rdfxml)      # RDF::RDFXML::Format
   #   RDF::Format.for("etc/foaf.xml")
   #   RDF::Format.for(:file_name      => "etc/foaf.xml")
   #   RDF::Format.for(:file_extension => "xml")

data/lib/rdf/rdfxml/patches/graph_properties.rb

@@ -0,0 +1,34 @@
+module RDF
+  class Graph
+    # Resource properties
+    #
+    # Properties arranged as a hash with the predicate Term as index to an array of resources or literals
+    #
+    # Example:
+    #   graph.load(':foo a :bar; rdfs:label "An example" .', "http://example.com/")
+    #   graph.resources(URI.new("http://example.com/subject")) =>
+    #   {
+    #     "http://www.w3.org/1999/02/22-rdf-syntax-ns#type" => [<http://example.com/#bar>],
+    #     "http://example.com/#label"                       => ["An example"]
+    #   }
+    def properties(subject, recalc = false)
+      @properties ||= {}
+      @properties.delete(subject.to_s) if recalc
+      @properties[subject.to_s] ||= begin
+        hash = Hash.new
+        self.query(:subject => subject) do |statement|
+          pred = statement.predicate.to_s
+
+          hash[pred] ||= []
+          hash[pred] << statement.object
+        end
+        hash
+      end
+    end
+
+    # Get type(s) of subject, returns a list of symbols
+    def type_of(subject)
+      query(:subject => subject, :predicate => RDF.type).map {|st| st.object}
+    end
+  end
+end

data/lib/rdf/rdfxml/patches/literal_hacks.rb

@@ -0,0 +1,66 @@
+module RDF
+  class Literal
+    # Support for XML Literals
+    # Is this an XMLLiteral?
+    def xmlliteral?
+      datatype == RDF['XMLLiteral']
+    end
+    
+    def anonymous?; false; end unless respond_to?(:anonymous?)
+    
+    ##
+    # Returns a string representation of this literal.
+    #
+    # @return [String]
+    def to_s
+      quoted = value # FIXME
+      output = "\"#{quoted}\""
+      output << "@#{language}" if has_language? && !has_datatype?
+      output << "^^<#{datatype}>" if has_datatype?
+      output
+    end
+    
+    # Normalize an XML Literal, by adding necessary namespaces.
+    # This should be done as part of initialize
+    #
+    # namespaces is a hash of prefix => URIs
+    def self.xmlliteral(contents, options = {})
+      options[:namespaces] ||= {}
+      l = new("", :datatype => RDF["XMLLiteral"])
+
+      if contents.is_a?(String)
+        ns_hash = {}
+        options[:namespaces].each_pair do |prefix, uri|
+          attr = prefix.to_s.empty? ? "xmlns" : "xmlns:#{prefix}"
+          ns_hash[attr] = uri.to_s
+        end
+        ns_strs = []
+        ns_hash.each_pair {|a, u| ns_strs << "#{a}=\"#{u}\""}
+
+        # Add inherited namespaces to created root element so that they're inherited to sub-elements
+        contents = Nokogiri::XML::Document.parse("<foo #{ns_strs.join(" ")}>#{contents}</foo>").root.children
+      end
+
+      # Add already mapped namespaces and language
+      l.value = contents.map do |c|
+        if c.is_a?(Nokogiri::XML::Element)
+          c = Nokogiri::XML.parse(c.dup.to_s).root
+          # Gather namespaces from self and decendant nodes
+          c.traverse do |n|
+            ns = n.namespace
+            next unless ns
+            prefix = ns.prefix ? "xmlns:#{ns.prefix}" : "xmlns"
+            c[prefix] = ns.href.to_s unless c.namespaces[prefix]
+          end
+          
+          # Add lanuage
+          if options[:language] && c["lang"].to_s.empty?
+            c["xml:lang"] = options[:language]
+          end
+        end
+        c.to_html(:save_with => Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS)
+      end.join("")
+      l
+    end
+  end
+end

data/lib/rdf/rdfxml/patches/qname_hacks.rb

@@ -0,0 +1,57 @@
+module RDF
+  class URI
+    #unless defined?(:vocab)
+      def vocab
+        # Find vocabulary if not assigned
+        return @vocab if @vocab
+        
+        Vocabulary.each do |vocab|
+          return self.vocab = vocab if to_s.index(vocab.to_uri.to_s) == 0
+        end
+        nil
+      end
+    
+      def vocab=(value)
+        raise "Vocab #{value.inspect} is not a Vocabulary!" if value.is_a?(Array)
+        @vocab = value
+      end
+      
+      def qname
+        @qname ||= if vocab
+          raise "Vocab #{vocab.inspect} is not a Vocabulary!" if vocab.is_a?(Array)
+          vocab_name = vocab.__name__.to_s.split('::').last.downcase
+          local_name = to_s[vocab.to_uri.to_s.size..-1]
+          vocab_name && local_name && [vocab_name.to_sym, local_name.to_sym]
+        end
+      end
+    #end
+  end
+  
+  class Vocabulary
+    def self.[](property)
+      @prop_uri ||= {}
+      @prop_uri[property] ||= begin
+        uri = RDF::URI.new([to_s, property.to_s].join(''))
+        uri.vocab = self
+        uri
+      end
+    end
+
+    def [](property)
+      @prop_uri ||= {}
+      @prop_uri[property] ||= begin
+        uri = RDF::URI.new([to_s, property.to_s].join(''))
+        uri.vocab = self
+        uri
+      end
+    end
+    
+    def to_uri
+      @uri ||= begin
+        uri = RDF::URI.new(to_s)
+        uri.vocab = self
+        uri
+      end
+    end
+  end
+end

data/lib/rdf/rdfxml/patches/seq.rb

@@ -0,0 +1,34 @@
+require 'rdf/rdfxml/patches/graph_properties'
+module RDF
+  class Graph
+    # Returns ordered rdf:_n objects or rdf:first, rdf:rest for a given subject
+    def seq(subject)
+      props = properties(subject)
+      rdf_type = (props[RDF.type.to_s] || []).map {|t| t.to_s}
+
+      #puts "seq; #{rdf_type} #{rdf_type - [RDF_NS.Seq, RDF_NS.Bag, RDF_NS.Alt]}"
+      if !(rdf_type - [RDF.Seq, RDF.Bag, RDF.Alt]).empty?
+        props.keys.select {|k| k.match(/#{RDF.to_s}_(\d)$/)}.
+          sort_by {|i| i.sub(RDF._.to_s, "").to_i}.
+          map {|key| props[key]}.
+          flatten
+      elsif !self.query(:subject => subject, :predicate => RDF.first).empty?
+        # N3-style first/rest chain
+        list = []
+        while subject != RDF_NS.nil
+          props = properties(subject)
+          f = props[RDF.first.to_s]
+          if f.to_s.empty? || f.first == RDF.nil
+            subject = RDF.nil
+          else
+            list += f
+            subject = props[RDF.rest.to_s].first
+          end
+        end
+        list
+      else
+        []
+      end
+    end
+  end
+end

data/lib/rdf/rdfxml/patches/uri_hacks.rb

@@ -0,0 +1,19 @@
+module RDF
+  class URI
+    ##
+    # Joins several URIs together.
+    #
+    # @param  [Array<String, URI, #to_str>] uris
+    # @return [URI]
+    #
+    # GK -- don't add a "/" at the end of URIs, due to rdfcore/xmlbase/test002.rdf
+    def join(*uris)
+      result = @uri
+      uris.each do |uri|
+#        result.path += '/' unless result.path.match(/[\#\/]$/) || uri.to_s[0..0] == "#"
+        result = result.join(uri)
+      end
+      self.class.new(result)
+    end
+  end
+end

data/lib/rdf/rdfxml/reader.rb

@@ -24,8 +24,6 @@ module RDF::RDFXML
       $},
       Regexp::EXTENDED)
   
-    XML_LITERAL = RDF['XMLLiteral']
-    
     # The Recursive Baggage
     class EvaluationContext # :nodoc:
       attr_reader :base
@@ -42,7 +40,6 @@ module RDF::RDFXML
         @language = nil
         @graph = graph
         @li_counter = 0
-        @uri_mappings = {}
 
         extract_from_element(element) if element
       end
@@ -128,7 +125,7 @@ module RDF::RDFXML
       super do
         @debug = options[:debug]
         @strict = options[:strict]
-        @base_uri = RDF::URI.parse(options[:base_uri]) if options[:base_uri]
+        @base_uri = RDF::URI.new(options[:base_uri])
             
         @id_mapping = Hash.new
 
@@ -360,7 +357,13 @@ module RDF::RDFXML
           # Production literalPropertyElt
           add_debug(child, "literalPropertyElt")
           
-          literal = RDF::Literal.new(child.inner_html, :datatype => datatype, :language => child_ec.language)
+          literal_opts = {}
+          if datatype
+            literal_opts[:datatype] = datatype
+          else
+            literal_opts[:language] = child_ec.language
+          end
+          literal = RDF::Literal.new(child.inner_html, literal_opts)
           add_triple(child, subject, predicate, literal)
           reify(id, child, subject, predicate, literal, ec) if id
         elsif parseType == "Resource"
@@ -439,7 +442,7 @@ module RDF::RDFXML
             raise RDF::ReaderError.new(warn) if @strict
           end
 
-          object = RDF::Literal.new(child.children, :datatype => XML_LITERAL, :namespaces => child_ec.uri_mappings)
+          object = RDF::Literal.xmlliteral(child.children, :namespaces => child_ec.uri_mappings)
           add_triple(child, subject, predicate, object)
         elsif text_nodes.length == 0 && element_nodes.length == 0
           # Production emptyPropertyElt
@@ -472,7 +475,7 @@ module RDF::RDFXML
 
                 # Attributes not in RDF.type
                 lit = RDF::Literal.new(val, :language => child_ec.language)
-                add_triple(child, resource, attr.uri.to_s, lit)
+                add_triple(child, resource, attr.uri, lit)
               end
             end
             add_triple(child, subject, predicate, resource)