rdf-rdfxml 0.0.2 → 0.0.3

data/lib/rdf/rdfxml/writer.rb

@@ -1,36 +1,84 @@
 require 'nokogiri'  # FIXME: Implement using different modules as in RDF::TriX
+require 'rdf/rdfxml/patches/graph_properties'
 
 module RDF::RDFXML
   ##
   # An RDF/XML serialiser in Ruby
   #
+  # Note that the natural interface is to write a whole graph at a time.
+  # Writing statements or Triples will create a graph to add them to
+  # and then serialize the graph.
+  #
+  # @example Obtaining a RDF/XML writer class
+  #   RDF::Writer.for(:rdf)         #=> RDF::TriX::Writer
+  #   RDF::Writer.for("etc/test.rdf")
+  #   RDF::Writer.for(:file_name      => "etc/test.rdf")
+  #   RDF::Writer.for(:file_extension => "rdf")
+  #   RDF::Writer.for(:content_type   => "application/rdf+xml")
+  #
+  # @example Serializing RDF graph into an RDF/XML file
+  #   RDF::RDFXML::Write.open("etc/test.rdf") do |writer|
+  #     writer.write_graph(graph)
+  #   end
+  #
+  # @example Serializing RDF statements into an RDF/XML file
+  #   RDF::RDFXML::Writer.open("etc/test.rdf") do |writer|
+  #     graph.each_statement do |statement|
+  #       writer << statement
+  #     end
+  #   end
+  #
+  # @example Serializing RDF statements into an RDF/XML string
+  #   RDF::RDFXML::Writer.buffer do |writer|
+  #     graph.each_statement do |statement|
+  #       writer << statement
+  #     end
+  #   end
+  #
   # @author [Gregg Kellogg](http://kellogg-assoc.com/)
   class Writer < RDF::Writer
     format RDF::RDFXML::Format
 
     VALID_ATTRIBUTES = [:none, :untyped, :typed]
 
-    attr_accessor :graph, :base
-    
+    attr_accessor :graph, :base_uri
 
     ##
+    # Initializes the RDF/XML writer instance.
+    #
+    # Opitons:
+    # max_depth:: Maximum depth for recursively defining resources, defaults to 3
+    # base_uri:: Base URI of graph, used to shorting URI references
+    # lang:: Output as root xml:lang attribute, and avoid generation _xml:lang_ where possible
+    # attributes:: How to use XML attributes when serializing, one of :none, :untyped, :typed. The default is :none.
+    # defafult_ns:: URI to use as default namespace
+    #
     # @param  [IO, File]               output
     # @param  [Hash{Symbol => Object}] options
+    #   @option options [Integer]       :max_depth      (nil)
+    #   @option options [String, #to_s] :base_uri (nil)
+    #   @option options [String, #to_s] :lang   (nil)
+    #   @option options [Array]         :attributes   (nil)
+    #   @option options [String]        :default_namespace
     # @yield  [writer]
     # @yieldparam [RDF::Writer] writer
     def initialize(output = $stdout, options = {}, &block)
-      super do
-        @graph = RDF::Graph.new
-        @stream = nil
-        @base = nil
-        @force_RDF_about = {}
-        @max_depth = options[:max_depth] || 3
-        @base = options[:base]
-        @lang = options[:lang]
-        @attributes = options[:attributes] || :none
-        raise "Invalid attribute option '#{@attributes}', should be one of #{VALID_ATTRIBUTES.to_sentence}" unless VALID_ATTRIBUTES.include?(@attributes.to_sym)
-        self.reset
-      end
+      @graph = RDF::Graph.new
+      super
+    end
+
+    ##
+    # @param  [Graph] graph
+    # @return [void]
+    def write_graph(graph)
+      @graph = graph
+    end
+
+    ##
+    # @param  [Statement] statement
+    # @return [void]
+    def write_statement(statement)
+      @graph << statement
     end
 
     ##
@@ -42,7 +90,7 @@ module RDF::RDFXML
     # @return [void]
     # @see    #write_epilogue
     def write_triple(subject, predicate, object)
-      @graph << [subject, predicate, object]
+      @graph << RDF::Statement.new(subject, predicate, object)
     end
 
     ##
@@ -51,64 +99,59 @@ module RDF::RDFXML
     # @return [void]
     # @see    #write_triple
     def write_epilogue
+      @base_uri = nil
+      @force_RDF_about = {}
+      @max_depth = @options[:max_depth] || 3
+      @base_uri = @options[:base_uri]
+      @lang = @options[:lang]
+      @attributes = @options[:attributes] || :none
+      @debug = @options[:debug]
+      @default_namespace = @options[:default_namespace]
+      raise "Invalid attribute option '#{@attributes}', should be one of #{VALID_ATTRIBUTES.to_sentence}" unless VALID_ATTRIBUTES.include?(@attributes.to_sym)
+      self.reset
+
       doc = Nokogiri::XML::Document.new
 
-      puts "\nserialize: graph namespaces: #{@graph.nsbinding.inspect}" if $DEBUG
+      add_debug "\nserialize: graph namespaces: #{@namespaces.inspect}"
+      add_debug "\nserialize: graph: #{@graph.size}"
 
       preprocess
 
       predicates = @graph.predicates.uniq
+      add_debug "\nserialize: predicates #{predicates.inspect}"
       possible = predicates + @graph.objects.uniq
       namespaces = {}
       required_namespaces = {}
       possible.each do |res|
-        next unless res.is_a?(RDF::URI)
-        if res.namespace
-          add_namespace(res.namespace)
-        else
-          required_namespaces[res.base] = true
-        end
-        #puts "possible namespace for #{res}: #{res.namespace || %(<#{res.base}>)}"
+        get_qname(res)
       end
-      add_namespace(RDF_NS)
-      add_namespace(XML_NS) if @base || @lang
+      add_namespace(:rdf, RDF_NS)
+      add_namespace(:xml, RDF::XML) if @base_uri || @lang
       
-      # See if there's a default namespace, and favor it when generating element names.
-      # Lookup an equivalent prefixed namespace for use in generating attributes
-      @default_ns = @graph.namespace("")
-      if @default_ns
-        add_namespace(@default_ns)
-        prefix = @graph.prefix(@default_ns.uri)
-        @prefixed_default_ns = @graph.namespace(prefix)
-        add_namespace(@prefixed_default_ns) if @prefixed_default_ns
+      if @default_namespace
+        add_namespace("", @default_namespace)
+        @default_namespace_prefix = @namespaces.invert[@default_namespace]
+        add_debug("def_namespace: #{@default_namespace}, prefix: #{@default_namespace_prefix}")
       end
       
-      # Add bindings for predicates not already having bindings
-      tmp_ns = "ns0"
-      required_namespaces.keys.each do |uri|
-        puts "create namespace definition for #{uri}" if $DEBUG
-        add_namespace(Namespace.new(uri, tmp_ns))
-        tmp_ns = tmp_ns.succ
-      end
-
       doc.root = Nokogiri::XML::Element.new("rdf:RDF", doc)
-      @namespaces.each_pair do |p, ns|
+      @namespaces.each_pair do |p, uri|
         if p.to_s.empty?
-          doc.root.default_namespace = ns.uri.to_s
+          doc.root.default_namespace = uri.to_s
         else
-          doc.root.add_namespace(p, ns.uri.to_s)
+          doc.root.add_namespace(p.to_s, uri.to_s)
         end
       end
       doc.root["xml:lang"] = @lang if @lang
-      doc.root["xml:base"] = @base if @base
+      doc.root["xml:base"] = @base_uri if @base_uri
       
       # Add statements for each subject
       order_subjects.each do |subject|
-        #puts "subj: #{subject.inspect}"
+        #add_debug "subj: #{subject.inspect}"
         subject(subject, doc.root)
       end
 
-      doc.write_xml_to(stream, :encoding => "UTF-8", :indent => 2)
+      doc.write_xml_to(@output, :encoding => "UTF-8", :indent => 2)
     end
     
     protected
@@ -119,23 +162,25 @@ module RDF::RDFXML
         subject_done(subject)
         properties = @graph.properties(subject)
         prop_list = sort_properties(properties)
-        puts "subject: #{subject.to_n3}, props: #{properties.inspect}" if $DEBUG
+        add_debug "subject: #{subject.inspect}, props: #{properties.inspect}"
 
-        rdf_type, *rest = properties.fetch(RDF_TYPE.to_s, [])
+        rdf_type, *rest = properties.fetch(RDF.type.to_s, [])
         if rdf_type.is_a?(RDF::URI)
           element = get_qname(rdf_type)
-          properties[RDF_TYPE.to_s] = rest
-          type_ns = rdf_type.namespace rescue nil
-          if type_ns && @default_ns && type_ns.uri == @default_ns.uri
-            properties[RDF_TYPE.to_s] = rest
-            element = rdf_type.short_name
+          properties[RDF.type.to_s] = rest
+          
+          # FIXME: different namespace logic
+          type_ns = rdf_type.vocab rescue nil
+          if type_ns && @default_namespace && type_ns.to_s == @default_namespace.to_s
+            properties[RDF.type.to_s] = rest
+            element = rdf_type.qname.last
           end
         end
         element ||= "rdf:Description"
 
         node = Nokogiri::XML::Element.new(element, parent_node.document)
       
-        if subject.is_a?(BNode)
+        if subject.is_a?(RDF::Node)
           # Only need nodeID if it's referenced elsewhere
           node["rdf:nodeID"] = subject.to_s if ref_count(subject) > (@depth == 0 ? 0 : 1)
         else
@@ -152,7 +197,7 @@ module RDF::RDFXML
           end
         end
       elsif @force_RDF_about.include?(subject)
-        puts "subject: #{subject.to_n3}, force about" if $DEBUG
+        add_debug "subject: #{subject.inspect}, force about"
         node = Nokogiri::XML::Element.new("rdf:Description", parent_node.document)
         node["rdf:about"] = relativize(subject)
         @force_RDF_about.delete(subject)
@@ -165,7 +210,7 @@ module RDF::RDFXML
     #
     # If _is_unique_ is true, this predicate may be able to be serialized as an attribute
     def predicate(prop, object, node, is_unique)
-      qname = prop.to_qname(uri_binding)
+      qname = get_qname(prop)
       raise RdfException, "No qname generated for <#{prop}>" unless qname
 
       # See if we can serialize as attribute.
@@ -173,72 +218,77 @@ module RDF::RDFXML
       # * typed attributes that aren't duplicated if @dt_as_attr is true
       # * rdf:type
       as_attr = false
-      as_attr ||= true if [:untyped, :typed].include?(@attributes) && prop == RDF_TYPE
+      as_attr ||= true if [:untyped, :typed].include?(@attributes) && prop == RDF.type
 
-      # Untyped attribute with no lang, or whos lang is the same as the default and RDF_TYPE
+      # Untyped attribute with no lang, or whos lang is the same as the default and RDF.type
+      add_debug("as_attr? #{@attributes}, plain? #{object.plain?}, lang #{@lang || 'nil'}:#{object.language || 'nil'}") if object.is_a?(RDF::Literal)
       as_attr ||= true if [:untyped, :typed].include?(@attributes) &&
-        (object.is_a?(Literal) && object.untyped? && (object.lang.nil? || object.lang == @lang))
+        object.is_a?(RDF::Literal) && (object.plain? || (@lang && object.language.to_s == @lang.to_s))
       
-      as_attr ||= true if [:typed].include?(@attributes) && object.is_a?(Literal) && object.typed?
+      as_attr ||= true if [:typed].include?(@attributes) && object.is_a?(RDF::Literal) && object.typed?
 
       as_attr = false unless is_unique
       
       # Can't do as an attr if the qname has no prefix and there is no prefixed version
-      if @default_ns && prop.namespace.uri == @default_ns.uri
+      if @default_namespace && prop.vocab.to_s == @default_namespace.to_s
         if as_attr
-          if @prefixed_default_ns
-            qname = "#{@prefixed_default_ns.prefix}:#{prop.short_name}"
+          if @default_namespace_prefix
+            qname = "#{@default_namespace_prefix}:#{prop.qname.last}"
           else
             as_attr = false
           end
         else
-          qname = prop.short_name
+          qname = prop.qname.last
         end
       end
 
-      puts "predicate: #{qname}, as_attr: #{as_attr}, object: #{object.inspect}, done: #{is_done?(object)}, sub: #{@subjects.include?(object)}" if $DEBUG
+      add_debug "predicate: #{qname}, as_attr: #{as_attr}, object: #{object.inspect}, done: #{is_done?(object)}, sub: #{@subjects.include?(object)}"
       qname = "rdf:li" if qname.match(/rdf:_\d+/)
       pred_node = Nokogiri::XML::Element.new(qname, node.document)
       
-      if object.is_a?(Literal) || is_done?(object) || !@subjects.include?(object)
+      if object.is_a?(RDF::Literal) || is_done?(object) || !@subjects.include?(object)
         # Literals or references to objects that aren't subjects, or that have already been serialized
         
-        args = object.xml_args
-        puts "predicate: args=#{args.inspect}" if $DEBUG
+        args = xml_args(object)
+        add_debug "predicate: args=#{args.inspect}"
         attrs = args.pop
         
         if as_attr
           # Serialize as attribute
           pred_node.unlink
           pred_node = nil
-          node[qname] = object.is_a?(RDF::URI) ? relativize(object) : object.to_s
+          node[qname] = object.is_a?(RDF::URI) ? relativize(object) : object.value
+          add_debug("node[#{qname}]=#{node[qname]}, #{object.class}")
         else
           # Serialize as element
+          add_debug("serialize as element: #{attrs.inspect}")
           attrs.each_pair do |a, av|
-            next if a == "xml:lang" && av == @lang # Lang already specified, don't repeat
-            av = relativize(object) if a == "#{RDF_NS.prefix}:resource"
-            puts "  elt attr #{a}=#{av}" if $DEBUG
+            next if a.to_s == "xml:lang" && av.to_s == @lang # Lang already specified, don't repeat
+            av = relativize(object) if a == "rdf:resource"
+            add_debug "  elt attr #{a}=#{av}"
             pred_node[a] = av.to_s
           end
-          puts "  elt #{'xmllit ' if object.is_a?(Literal) && object.xmlliteral?}content=#{args.first}" if $DEBUG && !args.empty?
-          if object.is_a?(Literal) && object.xmlliteral?
+          add_debug "  elt #{'xmllit ' if object.is_a?(RDF::Literal) && object.xmlliteral?}content=#{args.first}" if !args.empty?
+          if object.is_a?(RDF::Literal) && object.xmlliteral?
             pred_node.add_child(Nokogiri::XML::CharacterData.new(args.first, node.document))
           elsif args.first
             pred_node.content = args.first unless args.empty?
           end
         end
       else
+        require 'rdf/rdfxml/patches/seq' unless RDF::Graph.respond_to?(:seq)
+        
         # Check to see if it can be serialized as a collection
         col = @graph.seq(object)
-        conformant_list = col.all? {|item| !item.is_a?(Literal)}
+        conformant_list = col.all? {|item| !item.is_a?(RDF::Literal)}
         o_props = @graph.properties(object)
-        if conformant_list && o_props[RDF_NS.first.to_s]
+        if conformant_list && o_props[RDF.first.to_s]
           # Serialize list as parseType="Collection"
           pred_node["rdf:parseType"] = "Collection"
           col.each do |item|
             # Mark the BNode subject of each item as being complete, so that it is not serialized
-            @graph.triples(Triple.new(nil, RDF_NS.first, item)) do |triple, ctx|
-              subject_done(triple.subject)
+            @graph.query(:predicate => RDF.first, :object => item) do |statement|
+              subject_done(statement.subject)
             end
             @force_RDF_about[item] = true
             subject(item, pred_node)
@@ -248,7 +298,7 @@ module RDF::RDFXML
             @depth += 1
             subject(object, pred_node)
             @depth -= 1
-          elsif object.is_a?(BNode)
+          elsif object.is_a?(RDF::Node)
             pred_node["rdf:nodeID"] = object.identifier
           else
             pred_node["rdf:resource"] = relativize(object)
@@ -260,7 +310,7 @@ module RDF::RDFXML
 
     def relativize(uri)
       uri = uri.to_s
-      self.base ? uri.sub(/^#{self.base}/, "") : uri
+      self.base_uri ? uri.sub(/^#{self.base_uri}/, "") : uri
     end
 
     def preprocess_triple(triple)
@@ -268,7 +318,7 @@ module RDF::RDFXML
       
       # Pre-fetch qnames, to fill namespaces
       get_qname(triple.predicate)
-      get_qname(triple.object) if triple.predicate == RDF_TYPE
+      get_qname(triple.object) if triple.predicate == RDF.type
 
       @references[triple.predicate] = ref_count(triple.predicate) + 1
     end
@@ -276,8 +326,8 @@ module RDF::RDFXML
     MAX_DEPTH = 10
     INDENT_STRING = " "
     
-    def top_classes; [RDFS_NS.Class]; end
-    def predicate_order; [RDF_TYPE, RDFS_NS.label, DC_NS.title]; end
+    def top_classes; [RDF::RDFS.Class]; end
+    def predicate_order; [RDF.type, RDF::RDFS.label, RDF::DC.title]; end
     
     def is_done?(subject)
       @serialized.include?(subject)
@@ -293,8 +343,8 @@ module RDF::RDFXML
       subjects = []
       
       top_classes.each do |class_uri|
-        graph.triples(Triple.new(nil, RDF_TYPE, class_uri)).map {|t| t.subject}.sort.uniq.each do |subject|
-          #puts "order_subjects: #{subject.inspect}"
+        graph.query(:predicate => RDF.type, :object => class_uri).map {|st| st.subject}.sort.uniq.each do |subject|
+          #add_debug "order_subjects: #{subject.inspect}"
           subjects << subject
           seen[subject] = @top_levels[subject] = true
         end
@@ -303,21 +353,21 @@ module RDF::RDFXML
       # Sort subjects by resources over bnodes, ref_counts and the subject URI itself
       recursable = @subjects.keys.
         select {|s| !seen.include?(s)}.
-        map {|r| [r.is_a?(BNode) ? 1 : 0, ref_count(r), r]}.
+        map {|r| [r.is_a?(RDF::Node) ? 1 : 0, ref_count(r), r]}.
         sort
       
       subjects += recursable.map{|r| r.last}
     end
     
     def preprocess
-      @graph.triples.each {|t| preprocess_triple(t)}
+      @graph.each {|statement| preprocess_statement(statement)}
     end
     
-    def preprocess_triple(triple)
-      #puts "preprocess: #{triple.inspect}"
-      references = ref_count(triple.object) + 1
-      @references[triple.object] = references
-      @subjects[triple.subject] = true
+    def preprocess_statement(statement)
+      #add_debug "preprocess: #{statement.inspect}"
+      references = ref_count(statement.object) + 1
+      @references[statement.object] = references
+      @subjects[statement.subject] = true
     end
     
     # Return the number of times this node has been referenced in the object position
@@ -328,22 +378,51 @@ module RDF::RDFXML
     # Return a QName for the URI, or nil. Adds namespace of QName to defined namespaces
     def get_qname(uri)
       if uri.is_a?(RDF::URI)
-        qn = @graph.qname(uri)
-        # Local parts with . will mess up serialization
-        return false if qn.nil? || qn.index('.')
+        # Duplicate logic from URI#qname to remember namespace assigned
+        if uri.qname
+          add_namespace(uri.qname.first, uri.vocab)
+          add_debug "get_qname(uri.qname): #{uri.qname.join(':')}"
+          return uri.qname.join(":") 
+        end
         
-        add_namespace(uri.namespace)
-        qn
+        # No vocabulary assigned, find one from cache of created namespace URIs
+        @namespaces.each_pair do |prefix, vocab|
+          if uri.to_s.index(vocab.to_s) == 0
+            uri.vocab = vocab
+            local_name = uri.to_s[(vocab.to_s.length)..-1]
+            add_debug "get_qname(ns): #{prefix}:#{local_name}"
+            return "#{prefix}:#{local_name}"
+          end
+        end
+        
+        # No vocabulary found, invent one
+        # Add bindings for predicates not already having bindings
+        # short_name of URI for creating QNames.
+        #   "#{base_uri]{#short_name}}" == uri
+        local_name = uri.fragment
+        local_name ||= begin
+          path = uri.path.split("/")
+          unless path &&
+              path.length > 1 &&
+              path.last.class == String &&
+              path.last.length > 0 &&
+              path.last.index("/") != 0
+            return false
+          end
+          path.last
+        end
+        base_uri = uri.to_s[0..-(local_name.length + 1)]
+        @tmp_ns = @tmp_ns ? @tmp_ns.succ : "ns0"
+        add_debug "create namespace definition for #{uri}"
+        uri.vocab = RDF::Vocabulary.new(base_uri)
+        add_namespace(@tmp_ns.to_sym, uri.vocab)
+        add_debug "get_qname(tmp_ns): #{@tmp_ns}:#{local_name}"
+        return "#{@tmp_ns}:#{local_name}"
       end
     end
     
-    def add_namespace(ns)
-      @namespaces[ns.prefix.to_s] = ns
-    end
-
-    # URI -> Namespace bindings (similar to graph) for looking up qnames
-    def uri_binding
-      @uri_binding ||= @namespaces.values.inject({}) {|hash, ns| hash[ns.uri.to_s] = ns; hash}
+    def add_namespace(prefix, ns)
+      @namespaces[prefix.to_sym] = ns.to_s
     end
 
     def reset
@@ -361,8 +440,8 @@ module RDF::RDFXML
     def sort_properties(properties)
       properties.keys.each do |k|
         properties[k] = properties[k].sort do |a, b|
-          a_li = a.is_a?(RDF::URI) && a.short_name =~ /^_\d+$/ ? a.to_i : a.to_s
-          b_li = b.is_a?(RDF::URI) && b.short_name =~ /^_\d+$/ ? b.to_i : b.to_s
+          a_li = a.is_a?(RDF::URI) && a.qname.last =~ /^_\d+$/ ? a.to_i : a.to_s
+          b_li = b.is_a?(RDF::URI) && b.qname.last =~ /^_\d+$/ ? b.to_i : b.to_s
           
           a_li <=> b_li
         end
@@ -381,19 +460,41 @@ module RDF::RDFXML
         prop_list << prop.to_s
       end
       
-      puts "sort_properties: #{prop_list.to_sentence}" if $DEBUG
+      add_debug "sort_properties: #{prop_list.to_sentence}"
       prop_list
     end
 
-    # Returns indent string multiplied by the depth
-    def indent(modifier = 0)
-      INDENT_STRING * (@depth + modifier)
+    # XML content and arguments for serialization
+    #  Encoding.the_null_encoding.xml_args("foo", "en-US") => ["foo", {"xml:lang" => "en-US"}]
+    def xml_args(object)
+      case object
+      when RDF::Literal
+        if object.plain?
+          [object.value, {}]
+        elsif object.has_language?
+          [object.value, {"xml:lang" => object.language}]
+        elsif object.xmlliteral?
+          [object.value, {"rdf:parseType" => "Literal"}]
+        else
+          [object.value, {"rdf:datatype" => object.datatype.to_s}]
+        end
+      when RDF::Node
+        [{"rdf:nodeID" => object.id}]
+      when RDF::URI
+        [{"rdf:resource" => object.to_s}]
+      end
     end
     
-    # Write text
-    def write(text)
-      @stream.write(text)
+    # Add debug event to debug array, if specified
+    #
+    # @param [String] message::
+    def add_debug(message)
+      @debug << message if @debug.is_a?(Array)
     end
 
+    # Returns indent string multiplied by the depth
+    def indent(modifier = 0)
+      INDENT_STRING * (@depth + modifier)
+    end
   end
 end

data/lib/rdf/rdfxml.rb

@@ -23,8 +23,11 @@ module RDF
     require 'rdf/rdfxml/format'
     require 'rdf/rdfxml/vocab'
     require 'rdf/rdfxml/patches/array_hacks'
+    require 'rdf/rdfxml/patches/literal_hacks'
     require 'rdf/rdfxml/patches/nokogiri_hacks'
+    require 'rdf/rdfxml/patches/qname_hacks'
     require 'rdf/rdfxml/patches/rdf_escape'
+    require 'rdf/rdfxml/patches/uri_hacks'
     autoload :Reader,  'rdf/rdfxml/reader'
     autoload :Writer,  'rdf/rdfxml/writer'
     autoload :VERSION, 'rdf/rdfxml/version'
@@ -32,5 +35,6 @@ module RDF
     
     # Fixme: RDF.to_s should generate this, but it doesn't
     RDF_NS = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+    XML_LITERAL = RDF['XMLLiteral']
   end
 end

data/rdf-rdfxml.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rdf-rdfxml}
-  s.version = "0.0.2"
+  s.version = "0.0.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Gregg Kellogg"]
-  s.date = %q{2010-06-07}
+  s.date = %q{2010-06-12}
   s.description = %q{    RDF::RDFXML is an RDF/XML reader and writer for Ruby using the RDF.rb library suite.
 }
   s.email = %q{gregg@kellogg-assoc.com}
@@ -31,8 +31,13 @@ Gem::Specification.new do |s|
      "lib/rdf/rdfxml.rb",
      "lib/rdf/rdfxml/format.rb",
      "lib/rdf/rdfxml/patches/array_hacks.rb",
+     "lib/rdf/rdfxml/patches/graph_properties.rb",
+     "lib/rdf/rdfxml/patches/literal_hacks.rb",
      "lib/rdf/rdfxml/patches/nokogiri_hacks.rb",
+     "lib/rdf/rdfxml/patches/qname_hacks.rb",
      "lib/rdf/rdfxml/patches/rdf_escape.rb",
+     "lib/rdf/rdfxml/patches/seq.rb",
+     "lib/rdf/rdfxml/patches/uri_hacks.rb",
      "lib/rdf/rdfxml/reader.rb",
      "lib/rdf/rdfxml/version.rb",
      "lib/rdf/rdfxml/vocab.rb",
@@ -40,7 +45,10 @@ Gem::Specification.new do |s|
      "rdf-rdfxml.gemspec",
      "script/console",
      "spec/format_spec.rb",
+     "spec/graph_spec.rb",
+     "spec/literal_spec.rb",
      "spec/matchers.rb",
+     "spec/rdf_escape_spec.rb",
      "spec/rdf_helper.rb",
      "spec/rdf_tests/cc197bad-dc9c-440d-a5b5-d52ba2e14234.nt",
      "spec/rdf_tests/cc197bad-dc9c-440d-a5b5-d52ba2e14234.rdf",
@@ -404,7 +412,8 @@ Gem::Specification.new do |s|
      "spec/reader_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb",
-     "spec/xml_serializer_spec.rb"
+     "spec/uri_spec.rb",
+     "spec/writer_spec.rb"
   ]
   s.homepage = %q{http://github.com/gkellogg/rdf-rdfxml}
   s.rdoc_options = ["--charset=UTF-8"]
@@ -413,11 +422,15 @@ Gem::Specification.new do |s|
   s.summary = %q{RDF/XML reader/writer for RDF.rb.}
   s.test_files = [
     "spec/format_spec.rb",
+     "spec/graph_spec.rb",
+     "spec/literal_spec.rb",
      "spec/matchers.rb",
+     "spec/rdf_escape_spec.rb",
      "spec/rdf_helper.rb",
      "spec/reader_spec.rb",
      "spec/spec_helper.rb",
-     "spec/xml_serializer_spec.rb"
+     "spec/uri_spec.rb",
+     "spec/writer_spec.rb"
   ]
 
   if s.respond_to? :specification_version then

data/spec/format_spec.rb

@@ -4,7 +4,7 @@ describe RDF::RDFXML::Format do
   context "descovery" do
     {
       "rdf" => RDF::Format.for(:rdf),
-      "xml" => RDF::Format.for(:xml),
+      "rdfxml" => RDF::Format.for(:rdfxml),
       "etc/foaf.xml" => RDF::Format.for("etc/foaf.xml"),
       "etc/foaf.rdf" => RDF::Format.for("etc/foaf.rdf"),
       "foaf.xml" => RDF::Format.for(:file_name      => "foaf.xml"),