rdf-rdfxml 0.2.0 → 0.2.1

data/.gitignore

@@ -1,2 +1,4 @@
 .DS_Store
+/doc
 /pkg
+/.yardoc

data/History.txt

@@ -1,7 +1,13 @@
+=== 0.2.1
+* Update for RDF 0.2.1
+* Writer bug fixes:
+  * RDF::Node#identifier => RDF::Node#id
+  * Vocabulary.new(uri) => Vocabulary(uri)
+
 === 0.2.0
 * Updates for RDF 0.2.0
   * Use URI#intern instead of URI#new
-  * Change use of Graph#predicates and Graph#objects to use as enumberables
+  * Change use of Graph#predicates and Graph#objects to use as enumerables
 
 === 0.0.3
 * Added patches for the following:

data/README.rdoc

@@ -23,7 +23,7 @@ Instantiate a parser and parse source, specifying type and base-URL
   end
 
 == Dependencies
-  * [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.1.6)
+  * [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.2.0)
   * [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.3.3)
 
 == TODO

data/Rakefile

@@ -1,4 +1,5 @@
 require 'rubygems'
+require 'yard'
 
 begin
   gem 'jeweler'
@@ -12,12 +13,13 @@ begin
     gemspec.email = "gregg@kellogg-assoc.com"
     gemspec.homepage = "http://github.com/gkellogg/rdf-rdfxml"
     gemspec.authors = ["Gregg Kellogg"]
-    gemspec.add_dependency('rdf', '>= 0.2.0')
+    gemspec.add_dependency('rdf', '>= 0.2.1')
     gemspec.add_dependency('nokogiri', '>= 1.3.3')
     gemspec.add_development_dependency('rspec')
-    gemspec.add_development_dependency('rdf-spec')
-    gemspec.add_development_dependency('activesupport', '>= 2.3.0')
-    gemspec.extra_rdoc_files     = %w(README.rdoc History.txt AUTHORS)
+    gemspec.add_development_dependency('rdf-spec', '>= 0.2.1')
+    gemspec.add_development_dependency('rdf-isomorphic')
+    gemspec.add_development_dependency('yard')
+    gemspec.extra_rdoc_files     = %w(README.rdoc History.txt AUTHORS CONTRIBUTORS)
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
@@ -44,6 +46,10 @@ Spec::Rake::SpecTask.new("doc:spec") do |spec|
   spec.spec_opts = ["--format", "html:doc/spec.html"]
 end
 
+YARD::Rake::YardocTask.new do |t|
+  t.files   = %w(lib/**/*.rb README.rdoc History.txt AUTHORS CONTRIBUTORS)   # optional
+end
+
 desc "Generate RDF Core Manifest.yml"
 namespace :spec do
   task :prepare do

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.2.1

data/lib/rdf/rdfxml.rb

@@ -32,9 +32,5 @@ module RDF
     autoload :Writer,  'rdf/rdfxml/writer'
     autoload :VERSION, 'rdf/rdfxml/version'
     autoload :XML,     'rdf/rdfxml/vocab'
-    
-    # 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/lib/rdf/rdfxml/patches/literal_hacks.rb

@@ -1,66 +1,147 @@
-module RDF
-  class Literal
-    # Support for XML Literals
-    # Is this an XMLLiteral?
-    def xmlliteral?
-      datatype == RDF['XMLLiteral']
+# Use Nokogiri or LibXML when available, and REXML otherwise:
+begin
+  require 'nokogiri'
+rescue LoadError => e
+  begin
+    require 'libxml'
+  rescue LoadError => e
+    :rexml
+  end
+end
+
+module RDF; class Literal
+  ##
+  # An XML literal.
+  #
+  # @see   http://www.w3.org/TR/rdf-concepts/#section-XMLLiteral
+  # @see   http://www.w3.org/TR/rdfa-core/#s_xml_literals
+  # @since 0.2.1
+  class XML < Literal
+    ##
+    # @param  [Object] value
+    # @option options [String] :lexical (nil)
+    # @option options [Hash] :namespaces (nil)
+    # @option options [Hash] :namespaces ({})
+    # @option options [Symbol] :language (nil)
+    # @option options [Symbol] :library (:nokogiri, :libxml, or :rexml)
+    def initialize(value, options = {})
+      options[:namespaces] ||= {}
+
+      @library = case options[:library]
+        when nil
+          case
+          when defined?(::Nokogiri) then :nokogiri
+          when defined?(::LibXML)   then :libxml
+          else                           :rexml
+          end
+        when :nokogiri, :libxml, :rexml
+          options[:library]
+        else
+          raise ArgumentError.new("expected :rexml, :libxml or :nokogiri, but got #{options[:library].inspect}")
+      end
+
+      @datatype = options[:datatype] || DATATYPE
+      @string   = options[:lexical] if options.has_key?(:lexical)
+      @object   = parse_value(value, options)
+      @string   = serialize_nodeset(@object)
     end
-    
-    def anonymous?; false; end unless respond_to?(:anonymous?)
-    
+
     ##
-    # Returns a string representation of this literal.
+    # Converts the literal into its canonical lexical representation.
+    #
+    # @return [Literal]
+    # @see    http://www.w3.org/TR/xml-exc-c14n/
+    def canonicalize
+      # This is the opportunity to use exclusive canonicalization library
+      self
+    end
+
+    ##
+    # Returns the value as a string.
     #
     # @return [String]
     def to_s
-      quoted = value # FIXME
-      output = "\"#{quoted}\""
-      output << "@#{language}" if has_language? && !has_datatype?
-      output << "^^<#{datatype}>" if has_datatype?
-      output
+      @string
     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}\""}
+    private
+    
+    def parse_value(value, options)
+      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
+      case @library
+      when :nokogiri  then parse_value_nokogiri(value, ns_strs, options[:language])
+      when :libxml    then parse_value_libxml(value, ns_strs, options[:language])
+      when :rexml     then parse_value_rexml(value, ns_strs, options[:language])
+      else                 value.to_s
+      end
+    end
+    
+    def serialize_nodeset(object)
+      case @library
+      when :nokogiri  then serialize_nodeset_nokogiri(object)
+      when :libxml    then serialize_nodeset_libxml(object)
+      when :rexml     then serialize_nodeset_rexml(object)
+      else                 object
       end
+    end
+    
+    # Nokogiri implementations
+    if defined?(::Nokogiri)
+      def parse_value_nokogiri(value, ns_strs, language)
+        return value if value.is_a?(Nokogiri::XML::NodeSet)
+        # Add inherited namespaces to created root element so that they're inherited to sub-elements
+        elements = Nokogiri::XML::Document.parse("<foo #{ns_strs.join(" ")}>#{value.to_s}</foo>").root.children
 
-      # 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]
+        elements.map do |c|
+          if c.is_a?(Nokogiri::XML::Element)
+            c = Nokogiri::XML.parse(c.dup.to_xml(:save_with => Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS)).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 language && c["lang"].to_s.empty?
+              c["xml:lang"] = language
+            end
           end
+          c
         end
-        c.to_html(:save_with => Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS)
-      end.join("")
-      l
+      end
+    
+      def serialize_nodeset_nokogiri(object)
+        object.map {|c| c.to_xml(:save_with => Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS)}.join("")
+      end
+    end   # Nokogiri
+    
+    if defined?(::LibXML)
+      def parse_value_libxml(value, ns_strs, language)
+        # Fixme
+      end
+
+      def serialize_nodeset_libxml(object)
+        # Fixme
+      end
+    end   # LibXML
+    
+    # REXML
+    def parse_value_rexml(value, ns_strs, language)
+      # Fixme
     end
-  end
-end
+
+    def serialize_nodeset_rexml(object)
+      # Fixme
+    end
+    
+  end # class XML
+end; end

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

@@ -6,7 +6,7 @@ module RDF
       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]}"
+      #puts "seq; #{rdf_type} #{rdf_type - [RDF.Seq, RDF.Bag, RDF.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}.
@@ -15,7 +15,7 @@ module RDF
       elsif !self.query(:subject => subject, :predicate => RDF.first).empty?
         # N3-style first/rest chain
         list = []
-        while subject != RDF_NS.nil
+        while subject != RDF.nil
           props = properties(subject)
           f = props[RDF.first.to_s]
           if f.to_s.empty? || f.first == RDF.nil

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

@@ -10,7 +10,6 @@ module 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)

data/lib/rdf/rdfxml/reader.rb

@@ -113,11 +113,11 @@ module RDF::RDFXML
     ##
     # Initializes the RDF/XML reader instance.
     #
-    # @param  [IO, File, String]::       input
-    # @param  [Hash{Symbol => Object}]:: options
-    # <em>options[:debug]</em>:: Array to place debug messages
-    # <em>options[:strict]</em>:: Raise Error if true, continue with lax parsing, otherwise
-    # <em>options[:base_uri]</em>:: Base URI to use for relative URIs.
+    # @param  [IO, File, String]       input
+    # @option options [Array] :debug (nil) Array to place debug messages
+    # @option options [Boolean] :strict (false) Raise Error if true, continue with lax parsing, otherwise
+    # @option options [Boolean] :base_uri (nil) Base URI to use for relative URIs.
+    # @return [reader]
     # @yield  [reader]
     # @yieldparam [Reader] reader
     # @raise [Error]:: Raises RDF::ReaderError if _strict_
@@ -141,7 +141,6 @@ module RDF::RDFXML
       end
     end
 
-    # XXX Invoke the parser, and allow add_triple to make the callback?
     ##
     # Iterates the given block for each RDF statement in the input.
     #
@@ -156,7 +155,7 @@ module RDF::RDFXML
 
       add_debug(root, "base_uri: #{@base_uri || 'nil'}")
       
-      rdf_nodes = root.xpath("//rdf:RDF", "rdf" => RDF_NS)
+      rdf_nodes = root.xpath("//rdf:RDF", "rdf" => RDF.to_uri.to_s)
       if rdf_nodes.length == 0
         # If none found, root element may be processed as an RDF Node
 
@@ -196,12 +195,8 @@ module RDF::RDFXML
 
     # Keep track of allocated BNodes
     def bnode(value = nil)
-      if value
-        @bnode_cache ||= {}
-        @bnode_cache[value.to_s] ||= RDF::Node.new(value)
-      else
-        RDF::Node.new
-      end
+      @bnode_cache ||= {}
+      @bnode_cache[value.to_s] ||= RDF::Node.new(value)
     end
     
     # Figure out the document path, if it is a Nokogiri::XML::Element or Attribute
@@ -314,7 +309,7 @@ module RDF::RDFXML
             #attrs[attr.to_s] = attr.value unless attr.to_s.match?(/^xml/)
           elsif attr.namespace.href == RDF::XML.to_s
             # No production. Lang and base elements already extracted
-          elsif attr.namespace.href == RDF_NS
+          elsif attr.namespace.href == RDF.to_uri.to_s
             case attr.name
             when "ID"         then id = attr.value
             when "datatype"   then datatype = attr.value
@@ -377,7 +372,7 @@ module RDF::RDFXML
           end
 
           # For element e with possibly empty element content c.
-          n = bnode
+          n = RDF::Node.new
           add_triple(child, subject, predicate, n)
 
           # Reification
@@ -442,7 +437,7 @@ module RDF::RDFXML
             raise RDF::ReaderError.new(warn) if @strict
           end
 
-          object = RDF::Literal.xmlliteral(child.children, :namespaces => child_ec.uri_mappings)
+          object = RDF::Literal.new(child.children, :datatype => RDF.XMLLiteral, :namespaces => child_ec.uri_mappings, :language => ec.language)
           add_triple(child, subject, predicate, object)
         elsif text_nodes.length == 0 && element_nodes.length == 0
           # Production emptyPropertyElt
@@ -460,7 +455,7 @@ module RDF::RDFXML
             elsif nodeID
               resource = bnode(nodeID)
             else
-              resource = bnode
+              resource = RDF::Node.new
             end
 
             # produce triples for attributes
@@ -533,7 +528,7 @@ module RDF::RDFXML
         ec.base.join(about)
       else
         add_debug(el, "parse_subject, BNode")
-        bnode
+        RDF::Node.new
       end
     end
     

data/lib/rdf/rdfxml/version.rb

@@ -1,7 +1,7 @@
 module RDF::RDFXML::VERSION
   MAJOR = 0
   MINOR = 2
-  TINY  = 0
+  TINY  = 1
   EXTRA = nil
 
   STRING = [MAJOR, MINOR, TINY].join('.')

data/lib/rdf/rdfxml/writer.rb

@@ -10,7 +10,7 @@ module RDF::RDFXML
   # and then serialize the graph.
   #
   # @example Obtaining a RDF/XML writer class
-  #   RDF::Writer.for(:rdf)         #=> RDF::TriX::Writer
+  #   RDF::Writer.for(:rdf)         #=> RDF::RDFXML::Writer
   #   RDF::Writer.for("etc/test.rdf")
   #   RDF::Writer.for(:file_name      => "etc/test.rdf")
   #   RDF::Writer.for(:file_extension => "rdf")
@@ -51,7 +51,7 @@ module RDF::RDFXML
     # 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
+    # default_namespace:: URI to use as default namespace
     #
     # @param  [IO, File]               output
     # @param  [Hash{Symbol => Object}] options
@@ -119,7 +119,7 @@ module RDF::RDFXML
       # Get QNames and necessary namespaces from predicates and objects
       @graph.predicates.each {|pred| add_debug("serialize pred: #{pred.inspect}"); get_qname(pred)}
       @graph.objects.each {|obj| add_debug("serialize obj: #{obj.inspect}"); get_qname(obj)}
-      add_namespace(:rdf, RDF_NS)
+      add_namespace(:rdf, RDF.to_uri)
       add_namespace(:xml, RDF::XML) if @base_uri || @lang
       
       if @default_namespace
@@ -174,7 +174,7 @@ module RDF::RDFXML
         end
         element ||= "rdf:Description"
 
-        node = Nokogiri::XML::Element.new(element, parent_node.document)
+        node = Nokogiri::XML::Element.new(element.to_s, parent_node.document)
       
         if subject.is_a?(RDF::Node)
           # Only need nodeID if it's referenced elsewhere
@@ -234,7 +234,7 @@ module RDF::RDFXML
             as_attr = false
           end
         else
-          qname = prop.qname.last
+          qname = prop.qname.last.to_s
         end
       end
 
@@ -264,8 +264,8 @@ module RDF::RDFXML
             add_debug "  elt attr #{a}=#{av}"
             pred_node[a] = av.to_s
           end
-          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?
+          add_debug "  elt #{'xmllit ' if object.is_a?(RDF::Literal) && object.datatype == RDF.XMLLiteral}content=#{args.first}" if !args.empty?
+          if object.is_a?(RDF::Literal) && object.datatype == RDF.XMLLiteral
             pred_node.add_child(Nokogiri::XML::CharacterData.new(args.first, node.document))
           elsif args.first
             pred_node.content = args.first unless args.empty?
@@ -295,7 +295,7 @@ module RDF::RDFXML
             subject(object, pred_node)
             @depth -= 1
           elsif object.is_a?(RDF::Node)
-            pred_node["rdf:nodeID"] = object.identifier
+            pred_node["rdf:nodeID"] = object.id
           else
             pred_node["rdf:resource"] = relativize(object)
           end
@@ -410,7 +410,7 @@ module RDF::RDFXML
         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)
+        uri.vocab = RDF::Vocabulary(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}"
@@ -419,7 +419,7 @@ module RDF::RDFXML
     
     def add_namespace(prefix, ns)
       add_debug "add_namespace: '#{prefix}', <#{ns}>"
-      @namespaces[prefix.to_sym] = ns.to_s
+      @namespaces[prefix.to_s] = ns.to_s
     end
 
     def reset
@@ -470,7 +470,7 @@ module RDF::RDFXML
           [object.value, {}]
         elsif object.has_language?
           [object.value, {"xml:lang" => object.language}]
-        elsif object.xmlliteral?
+        elsif object.datatype == RDF.XMLLiteral
           [object.value, {"rdf:parseType" => "Literal"}]
         else
           [object.value, {"rdf:datatype" => object.datatype.to_s}]

data/rdf-rdfxml.gemspec

@@ -5,16 +5,17 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rdf-rdfxml}
-  s.version = "0.2.0"
+  s.version = "0.2.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Gregg Kellogg"]
-  s.date = %q{2010-06-17}
+  s.date = %q{2010-06-28}
   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}
   s.extra_rdoc_files = [
     "AUTHORS",
+     "CONTRIBUTORS",
      "History.txt",
      "README.rdoc"
   ]
@@ -418,7 +419,7 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/gkellogg/rdf-rdfxml}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
+  s.rubygems_version = %q{1.3.6}
   s.summary = %q{RDF/XML reader/writer for RDF.rb.}
   s.test_files = [
     "spec/format_spec.rb",
@@ -437,25 +438,28 @@ Gem::Specification.new do |s|
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<rdf>, [">= 0.2.0"])
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rdf>, [">= 0.2.1"])
       s.add_runtime_dependency(%q<nokogiri>, [">= 1.3.3"])
       s.add_development_dependency(%q<rspec>, [">= 0"])
-      s.add_development_dependency(%q<rdf-spec>, [">= 0"])
-      s.add_development_dependency(%q<activesupport>, [">= 2.3.0"])
+      s.add_development_dependency(%q<rdf-spec>, [">= 0.2.1"])
+      s.add_development_dependency(%q<rdf-isomorphic>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
     else
-      s.add_dependency(%q<rdf>, [">= 0.2.0"])
+      s.add_dependency(%q<rdf>, [">= 0.2.1"])
       s.add_dependency(%q<nokogiri>, [">= 1.3.3"])
       s.add_dependency(%q<rspec>, [">= 0"])
-      s.add_dependency(%q<rdf-spec>, [">= 0"])
-      s.add_dependency(%q<activesupport>, [">= 2.3.0"])
+      s.add_dependency(%q<rdf-spec>, [">= 0.2.1"])
+      s.add_dependency(%q<rdf-isomorphic>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
     end
   else
-    s.add_dependency(%q<rdf>, [">= 0.2.0"])
+    s.add_dependency(%q<rdf>, [">= 0.2.1"])
     s.add_dependency(%q<nokogiri>, [">= 1.3.3"])
     s.add_dependency(%q<rspec>, [">= 0"])
-    s.add_dependency(%q<rdf-spec>, [">= 0"])
-    s.add_dependency(%q<activesupport>, [">= 2.3.0"])
+    s.add_dependency(%q<rdf-spec>, [">= 0.2.1"])
+    s.add_dependency(%q<rdf-isomorphic>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
   end
 end
 

data/spec/format_spec.rb

@@ -1,7 +1,7 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
 describe RDF::RDFXML::Format do
-  context "descovery" do
+  context "discovery" do
     {
       "rdf" => RDF::Format.for(:rdf),
       "rdfxml" => RDF::Format.for(:rdfxml),

data/spec/literal_spec.rb

@@ -1,86 +1,61 @@
+# coding: utf-8
 require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'nokogiri'
 
 describe RDF::Literal do
+  require 'nokogiri' rescue nil
+
+  before :each do 
+    @new = Proc.new { |*args| RDF::Literal.new(*args) }
+  end
+
   describe "XML Literal" do
     describe "with no namespace" do
-      subject { RDF::Literal.new("foo <sup>bar</sup> baz!", :datatype => RDF["XMLLiteral"]) }
-      it "should indicate xmlliteral?" do
-        subject.xmlliteral?.should == true
+      subject { @new.call("foo <sup>bar</sup> baz!", :datatype => RDF.XMLLiteral) }
+      it "should return input" do subject.to_s.should == "foo <sup>bar</sup> baz!" end
+
+      it "should be equal if they have the same contents" do
+        should == @new.call("foo <sup>bar</sup> baz!", :datatype => RDF.XMLLiteral)
       end
-      
-      it "should return normalized literal" do subject.value.should == "foo <sup>bar</sup> baz!" end
     end
-      
+
     describe "with a namespace" do
       subject {
-        RDF::Literal.xmlliteral("foo <sup>bar</sup> baz!", :namespaces => {"dc" => "http://purl.org/dc/terms/"})
+        @new.call("foo <dc:sup>bar</dc:sup> baz!", :datatype => RDF.XMLLiteral,
+                      :namespaces => {"dc" => RDF::DC.to_s})
       }
-    
-      it "should return normalized literal" do subject.value.should == "foo <sup>bar</sup> baz!" end
-      
+
+      it "should add namespaces" do subject.to_s.should == "foo <dc:sup xmlns:dc=\"http://purl.org/dc/terms/\">bar</dc:sup> baz!" end
+
       describe "and language" do
         subject {
-          RDF::Literal.xmlliteral("foo <sup>bar</sup> baz!", :namespaces => {"dc" => "http://purl.org/dc/terms/"}, :language => "fr")
+          @new.call("foo <dc:sup>bar</dc:sup> baz!", :datatype => RDF.XMLLiteral,
+                        :namespaces => {"dc" => RDF::DC.to_s},
+                        :language => :fr)
         }
 
-        it "should return normalized literal" do subject.value.should == "foo <sup xml:lang=\"fr\">bar</sup> baz!" end
+        it "should add namespaces and language" do subject.to_s.should == "foo <dc:sup xmlns:dc=\"http://purl.org/dc/terms/\" xml:lang=\"fr\">bar</dc:sup> baz!" end
       end
-      
+
       describe "and language with an existing language embedded" do
         subject {
-          RDF::Literal.xmlliteral("foo <sup>bar</sup><sub xml:lang=\"en\">baz</sub>", :namespaces => {}, :language => "fr")
+          @new.call("foo <dc:sup>bar</dc:sup><dc:sub xml:lang=\"en\">baz</dc:sub>",
+                        :datatype => RDF.XMLLiteral,
+                        :namespaces => {"dc" => RDF::DC.to_s},
+                        :language => :fr)
         }
 
-        it "should return normalized literal" do subject.value.should == "foo <sup xml:lang=\"fr\">bar</sup><sub xml:lang=\"en\">baz</sub>" end
-      end
-      
-      describe "and namespaced element" do
-        subject {
-          root = Nokogiri::XML.parse(%(
-          <?xml version="1.0" encoding="UTF-8"?>
-          <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.0//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd">
-          <html xmlns="http://www.w3.org/1999/xhtml"
-                xmlns:dc="http://purl.org/dc/terms/"
-          	  xmlns:ex="http://example.org/rdf/"
-          	  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-          	  xmlns:svg="http://www.w3.org/2000/svg">
-          	<head profile="http://www.w3.org/1999/xhtml/vocab http://www.w3.org/2005/10/profile">
-          		<title>Test 0100</title>
-          	</head>
-            <body>
-            	<div about="http://www.example.org">
-                <h2 property="ex:example" datatype="rdf:XMLLiteral"><svg:svg/></h2>
-          	</div>
-            </body>
-          </html>
-          ), nil, nil, Nokogiri::XML::ParseOptions::DEFAULT_XML).root
-          content = root.css("h2").children
-          RDF::Literal.xmlliteral(content, :namespaces => {:svg => "http://www.w3.org/2000/svg", :dc => "http://purl.org/dc/terms"})
-        }
-        it "should add namespace" do subject.value.should == "<svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\"></svg:svg>" end
-      end
-      
-      describe "and existing namespace definition" do
-        subject {
-          RDF::Literal.xmlliteral("<svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\"/>", :namespaces => {"svg" => "http://www.w3.org/2000/svg"})
-        }
-        it "should add namespace" do subject.value.should == "<svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\"></svg:svg>" end
+        it "should add namespaces and language" do subject.to_s.should == "foo <dc:sup xmlns:dc=\"http://purl.org/dc/terms/\" xml:lang=\"fr\">bar</dc:sup><dc:sub xmlns:dc=\"http://purl.org/dc/terms/\" xml:lang=\"en\">baz</dc:sub>" end
       end
     end
-      
+
     describe "with a default namespace" do
       subject {
-        RDF::Literal.xmlliteral("foo <sup>bar</sup> baz!", :namespaces => {"" => "http://purl.org/dc/terms/"})
+        @new.call("foo <sup>bar</sup> baz!", :datatype => RDF.XMLLiteral,
+                      :namespaces => {"" => RDF::DC.to_s})
       }
-    
-      it "should return normalized literal foo" do subject.value.should == "foo <sup xmlns=\"http://purl.org/dc/terms/\">bar</sup> baz!" end
-    end
-    
-    describe "with <br/>" do
-      subject {
-        RDF::Literal.xmlliteral("<br/>")
-      }
-      it "should add namespace" do subject.value.should == "<br></br>" end
+
+      it "should add namespace" do subject.to_s.should == "foo <sup xmlns=\"http://purl.org/dc/terms/\">bar</sup> baz!" end
     end
-  end
-end
+  end if defined?(::Nokogiri)
+end

data/spec/matchers.rb

@@ -58,64 +58,4 @@ module Matchers
   def be_equivalent_graph(expected, info = nil)
     BeEquivalentGraph.new(expected, info)
   end
-
-  class BeValidXML
-    def initialize(info)
-      @info = info
-    end
-    def matches?(actual)
-      @actual = actual
-      @doc = Nokogiri::XML.parse(actual)
-      @results = @doc.validate
-      @results.nil?
-    rescue
-      false
-    end
-    def failure_message_for_should
-      "#{@info + "\n" unless @info.empty?}" +
-      if @doc.nil?
-        "did not parse"
-      else
-        "\n#{@results}" +
-        "\nParsed:\n#{@doc}"
-      end   +
-        "\nActual:\n#{@actual}"
-    end
-  end
-  
-  def be_valid_xml(info = "")
-    BeValidXML.new(info)
-  end
-
-  class BeEquivalentXML
-    def initialize(expected, info)
-      @expected = expected
-      @info = info
-    end
-    
-    def matches?(actual)
-      @actual = actual
-
-      a = @actual.index("<") == 0 ? @actual : "<foo>#{@actual}</foo>"
-      e = @expected.index("<") == 0 ? @expected : "<foo>#{@expected}</foo>"
-      a_hash = ActiveSupport::XmlMini.parse(a)
-      e_hash = ActiveSupport::XmlMini.parse(e)
-      a_hash == e_hash
-    rescue
-      puts $!
-      @fault = $!.message
-      false
-    end
-
-    def failure_message_for_should
-      "#{@info + "\n" unless @info.empty?}" +
-      "Fault: #{@fault + "\n" if @fault}" +
-      "Expected:#{@expected}\n" +
-      "Actual:#{@actual}"
-    end
-  end
-  
-  def be_equivalent_xml(expected, info = "")
-    BeEquivalentXML.new(expected, info)
-  end
 end

data/spec/rdf_helper.rb

@@ -119,9 +119,7 @@ module RdfHelper
       @negative_entailment_tests = []
 
       unless File.file?(File.join(test_dir, test.sub("rdf", "yml")))
-        puts "parse #{File.join(test_dir, test)} @#{Time.now}"
         graph = RDF::Graph.load(File.join(test_dir, test), :base_uri => test_uri)
-        puts "parsed #{graph.size} statements @#{Time.now}"
         uri_base = Addressable::URI.join(test_uri, ".").to_s
 
         # One of:
@@ -140,18 +138,16 @@ module RdfHelper
         self.from_yaml(File.join(test_dir, test.sub("rdf", "yml")))
       end
 
-      puts "identified #{@test_cases.size} test cases @#{Time.now}"
-
-     @test_cases.each do |tc|
-       next if tc.status && tc.status != "APPROVED"
-       case tc.rdf_type
-       when "PositiveParserTest" then @positive_parser_tests << tc
-       when "NegativeParserTest" then @negative_parser_tests << tc
-       when "PositiveEntailmentTest" then @positive_entailment_tests << tc
-       when "NegativeEntailmentTest" then @negative_entailment_tests << tc
-       else puts "Unknown test type: #{tc.rdf_type}"
-       end
-     end
+      @test_cases.each do |tc|
+        next if tc.status && tc.status != "APPROVED"
+        case tc.rdf_type
+        when "PositiveParserTest" then @positive_parser_tests << tc
+        when "NegativeParserTest" then @negative_parser_tests << tc
+        when "PositiveEntailmentTest" then @positive_entailment_tests << tc
+        when "NegativeEntailmentTest" then @negative_entailment_tests << tc
+        else puts "Unknown test type: #{tc.rdf_type}"
+        end
+      end
     end
     def self.test_cases(test_uri = nil, test_dir = nil);                parse_test_cases(test_uri, test_dir); @test_cases; end
     def self.positive_parser_tests(test_uri = nil, test_dir = nil);     parse_test_cases(test_uri, test_dir); @positive_parser_tests; end

data/spec/reader_spec.rb

@@ -329,7 +329,7 @@ EOF
     end
 
     def self.negative_tests
-      [] #RdfHelper::TestCase.negative_parser_tests(RDFCORE_TEST, RDFCORE_DIR) rescue []
+      RdfHelper::TestCase.negative_parser_tests(RDFCORE_TEST, RDFCORE_DIR) rescue []
     end
     
     it "should parse testcase" do
@@ -387,7 +387,10 @@ EOF
           t.run_test do |rdf_string|
             t.debug = []
             g = RDF::Graph.new
-            RDF::RDFXML::Reader.new(rdf_string, :base_uri => t.about, :strict => true, :debug => t.debug).each do |statement|
+            RDF::RDFXML::Reader.new(rdf_string,
+                :base_uri => t.about,
+                :strict => true,
+                :debug => t.debug).each do |statement|
               g << statement
             end
             g
@@ -404,8 +407,13 @@ EOF
         specify "test #{t.name}: " + (t.description || t.inputDocument) do
           t.run_test do |rdf_string, parser|
             lambda do
-              parser.parse(rdf_string, :base_uri => t.about, :strict => true, :debug => [])
-              parser.graph.should be_empty
+              g = RDF::Graph.new
+              RDF::RDFXML::Reader.new(rdf_string,
+                  :base_uri => t.about,
+                  :strict => true).each do |statement|
+                g << statement
+              end
+              g.should be_empty
             end.should raise_error(RDF::ReaderError)
           end
         end

data/spec/spec_helper.rb

@@ -4,6 +4,7 @@ $:.unshift File.dirname(__FILE__)
 require 'rubygems'
 require 'spec'
 require 'matchers'
+require 'bigdecimal'  # XXX Remove Me
 require 'rdf/rdfxml'
 require 'rdf/ntriples'
 require 'rdf/spec'

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: rdf-rdfxml
 version: !ruby/object:Gem::Version 
-  hash: 23
   prerelease: false
   segments: 
   - 0
   - 2
-  - 0
-  version: 0.2.0
+  - 1
+  version: 0.2.1
 platform: ruby
 authors: 
 - Gregg Kellogg
@@ -15,34 +14,30 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-17 00:00:00 -07:00
+date: 2010-06-28 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rdf
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 23
         segments: 
         - 0
         - 2
-        - 0
-        version: 0.2.0
+        - 1
+        version: 0.2.1
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: nokogiri
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 29
         segments: 
         - 1
         - 3
@@ -54,11 +49,9 @@ dependencies:
   name: rspec
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
@@ -68,32 +61,40 @@ dependencies:
   name: rdf-spec
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
-        version: "0"
+        - 2
+        - 1
+        version: 0.2.1
   type: :development
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: activesupport
+  name: rdf-isomorphic
   prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
-        - 2
-        - 3
         - 0
-        version: 2.3.0
+        version: "0"
   type: :development
   version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
 description: "    RDF::RDFXML is an RDF/XML reader and writer for Ruby using the RDF.rb library suite.\n"
 email: gregg@kellogg-assoc.com
 executables: []
@@ -102,6 +103,7 @@ extensions: []
 
 extra_rdoc_files: 
 - AUTHORS
+- CONTRIBUTORS
 - History.txt
 - README.rdoc
 files: 
@@ -510,27 +512,23 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: RDF/XML reader/writer for RDF.rb.