Release 1.1.1.

* Updates for RDF.rb v1.1.5.

Author: gkellogg

.gitignore

@@ -4,4 +4,5 @@
 /.yardoc
 /user-test-cases
 /.rbx/
+/spec/w3c-rdf
 Gemfile.lock

.travis.yml

@@ -5,10 +5,10 @@ env:
   - CI=true
 rvm:
   - 1.9.3
-  - 2.0.0
-  - 2.1.0
+  - 2.0
+  - 2.1
   - jruby-19mode
-  - rbx
+  - rbx-2
 env:
   global:
     - CI=true

Gemfile

@@ -18,7 +18,7 @@ group :debug do
   gem "wirble"
   gem "ruby-debug", :platforms => :jruby
   gem "debugger", :platforms => :mri_19
-  gem "byebug", :platforms => :mri_20
+  gem "byebug", :platforms => [:mri_20, :mri_21]
 end
 
 platforms :rbx do

VERSION

@@ -1 +1 @@
-1.1.0.1
+1.1.1

lib/rdf/rdfxml/writer.rb

@@ -230,6 +230,7 @@ def render_property(predicate, objects, options = {}, &block)
 
       # Separate out the objects which are lists and render separately
       lists = objects.
+        select(&:node?).
         map {|o| RDF::List.new(o, @graph)}.
         select {|l| l.valid? && l.none?(&:literal?)}
 

rdf-rdfxml.gemspec

@@ -29,9 +29,11 @@ Gem::Specification.new do |gem|
 
   #gem.add_development_dependency 'nokogiri' ,       '>= 1.6.1' # conditionally done in Gemfile
   gem.add_development_dependency 'equivalent-xml' , '~> 0.2'
+  gem.add_development_dependency 'open-uri-cached', '~> 0.0', '>= 0.0.5'
   gem.add_development_dependency 'spira',           '= 0.0.12'
   gem.add_development_dependency 'json-ld',         '~> 1.1'
-  gem.add_development_dependency 'rspec',           '~> 2.14'
+  gem.add_development_dependency 'rspec',           '~> 3.0'
+  gem.add_development_dependency 'rspec-its',       '~> 1.0'
   gem.add_development_dependency 'rdf-isomorphic',  '~> 1.1'
   gem.add_development_dependency 'rdf-turtle',      '~> 1.1'
   gem.add_development_dependency 'rdf-spec',        '~> 1.1'

spec/format_spec.rb

@@ -18,29 +18,29 @@
       {:content_type   => 'application/rdf+xml'},
     ].each do |arg|
       it "discovers with #{arg.inspect}" do
-        RDF::Format.for(arg).should == @format_class
+        expect(RDF::Format.for(arg)).to eq @format_class
       end
     end
 
     {
       :rdfxml   => '<rdf:RDF about="foo"></rdf:RDF>',
     }.each do |sym, str|
       it "detects #{sym}" do
-        @format_class.for {str}.should == @format_class
+        expect(@format_class.for {str}).to eq @format_class
       end
     end
   end
 
   describe "#to_sym" do
-    specify {@format_class.to_sym.should == :rdfxml}
+    specify {expect(@format_class.to_sym).to eq :rdfxml}
   end
 
   describe ".detect" do
     {
       :rdfxml => '<rdf:RDF about="foo"></rdf:RDF>',
     }.each do |sym, str|
       it "detects #{sym}" do
-        @format_class.detect(str).should be_true
+        expect(@format_class.detect(str)).to be_truthy
       end
     end
 
@@ -59,18 +59,18 @@
       :STRING_LITERAL_LONG2 => %(<a> <b> """\nliteral\n""" .),
     }.each do |sym, str|
       it "does not detect #{sym}" do
-        @format_class.detect(str).should be_false
+        expect(@format_class.detect(str)).to be_falsey
       end
     end
 
     describe RDF::RDFXML::RDFFormat do
       it "discovers with :rdf" do
-        RDF::Format.for(:rdf).should == RDF::RDFXML::RDFFormat
+        expect(RDF::Format.for(:rdf)).to eq RDF::RDFXML::RDFFormat
       end
 
       it "should discover :rdf" do
-        RDF::Format.for(:rdf).reader.should == RDF::RDFXML::Reader
-        RDF::Format.for(:rdf).writer.should == RDF::RDFXML::Writer
+        expect(RDF::Format.for(:rdf).reader).to eq RDF::RDFXML::Reader
+        expect(RDF::Format.for(:rdf).writer).to eq RDF::RDFXML::Writer
       end
     end
   end

spec/jruby_spec.rb

@@ -8,7 +8,7 @@
 describe Nokogiri::XML do
   describe "parse" do
     it "parses namespaced elements without a namespace" do
-      Nokogiri::XML.parse("<dc:sup>bar</dc:sup>").root.should_not be_nil
+      expect(Nokogiri::XML.parse("<dc:sup>bar</dc:sup>").root).not_to be_nil
     end
   end
 end
@@ -25,7 +25,7 @@
       "/rdf:RDF/rdf:Description/@dc:title" => "foo"
     }.each do |path, value|
       it "returns #{value.inspect} for xpath #{path}" do
-        subject.should have_xpath(path, value, {})
+        expect(subject).to have_xpath(path, value, {})
       end
     end
   end

spec/matchers.rb

@@ -3,27 +3,27 @@
 RSpec::Matchers.define :have_xpath do |xpath, value, namespaces, trace|
   match do |actual|
     @doc = Nokogiri::XML.parse(actual)
-    @doc.should be_a(Nokogiri::XML::Document)
-    @doc.root.should be_a(Nokogiri::XML::Element)
+    return false unless @doc.is_a?(Nokogiri::XML::Document)
+    return false unless @doc.root.is_a?(Nokogiri::XML::Element)
     @namespaces = @doc.namespaces.inject({}) {|memo, (k,v)| memo[k.to_s.sub(/xmlns:?/, '')] = v; memo}.
       merge(namespaces).
       merge("xhtml" => "http://www.w3.org/1999/xhtml", "xml" => "http://www.w3.org/XML/1998/namespace")
     @result = @doc.root.at_xpath(xpath, @namespaces) rescue false
     case value
     when false
-      @result.should be_nil
+      @result.nil?
     when true
-      @result.should_not be_nil
+      !@result.nil?
     when Array
-      @result.to_s.split(" ").should include(*value)
+      @result.to_s.split(" ").include?(*value)
     when Regexp
-      @result.to_s.should =~ value
+      @result.to_s =~ value
     else
-      @result.to_s.should == value
+      @result.to_s. == value
     end
   end
 
-  failure_message_for_should do |actual|
+  failure_message_when_negated do |actual|
     msg = "expected to that #{xpath.inspect} would be #{value.inspect} in:\n" + actual.to_s
     msg += "was: #{@result}"
     msg +=  "\nDebug:#{trace.join("\n")}" if trace
@@ -69,7 +69,7 @@ def normalize(graph)
     @actual.isomorphic_with?(@expected) rescue false
   end
 
-  failure_message_for_should do |actual|
+  failure_message do |actual|
     info = @info.respond_to?(:comment) ? @info.comment : @info.inspect
     if @expected.is_a?(RDF::Graph) && @actual.size != @expected.size
       "Graph entry count differs:\nexpected: #{@expected.size}\nactual:   #{@actual.size}"
@@ -89,10 +89,10 @@ def normalize(graph)
 
 RSpec::Matchers.define :produce do |expected, info|
   match do |actual|
-    actual.should == expected
+    actual == expected
   end
 
-  failure_message_for_should do |actual|
+  failure_message do |actual|
     "Expected: #{[Array, Hash].include?(expected.class) ? expected.to_json(JSON_STATE) : expected.inspect}\n" +
     "Actual  : #{[Array, Hash].include?(actual.class) ? actual.to_json(JSON_STATE) : actual.inspect}\n" +
     #(expected.is_a?(Hash) && actual.is_a?(Hash) ? "Diff: #{expected.diff(actual).to_json(JSON_STATE)}\n" : "") +

spec/reader_spec.rb

@@ -27,7 +27,7 @@
       "application/rdf+xml" => RDF::Reader.for(:content_type   => "application/rdf+xml"),
     }.each_pair do |label, format|
       it "should discover '#{label}'" do
-        format.should == RDF::RDFXML::Reader
+        expect(format).to eq RDF::RDFXML::Reader
       end
     end
   end
@@ -52,27 +52,27 @@
 
     it "should yield reader" do
       inner = double("inner")
-      inner.should_receive(:called).with(RDF::RDFXML::Reader)
+      expect(inner).to receive(:called).with(RDF::RDFXML::Reader)
       RDF::RDFXML::Reader.new(@sampledoc) do |reader|
         inner.called(reader.class)
       end
     end
 
     it "should return reader" do
-      RDF::RDFXML::Reader.new(@sampledoc).should be_a(RDF::RDFXML::Reader)
+      expect(RDF::RDFXML::Reader.new(@sampledoc)).to be_a(RDF::RDFXML::Reader)
     end
 
     it "should yield statements" do
       inner = double("inner")
-      inner.should_receive(:called).with(RDF::Statement).twice
+      expect(inner).to receive(:called).with(RDF::Statement).twice
       RDF::RDFXML::Reader.new(@sampledoc).each_statement do |statement|
         inner.called(statement.class)
       end
     end
 
     it "should yield triples" do
       inner = double("inner")
-      inner.should_receive(:called).with(RDF::URI, RDF::URI, RDF::Literal).twice
+      expect(inner).to receive(:called).with(RDF::URI, RDF::URI, RDF::Literal).twice
       RDF::RDFXML::Reader.new(@sampledoc).each_triple do |subject, predicate, object|
         inner.called(subject.class, predicate.class, object.class)
       end
@@ -88,11 +88,11 @@
           sampledoc = %(<?xml version="1.0" ?>
             <NotRDF />)
           graph = parse(sampledoc, :base_uri => "http://example.com", :validate => true)
-          graph.size.should == 1
+          expect(graph.size).to eq 1
           statement = graph.statements.first
-          statement.subject.class.should == RDF::Node
-          statement.predicate.should == RDF.type
-          statement.object.should == RDF::XML.NotRDF
+          expect(statement.subject.class).to eq RDF::Node
+          expect(statement.predicate).to eq RDF.type
+          expect(statement.object).to eq RDF::XML.NotRDF
         end
 
         it "should parse on XML documents with multiple RDF nodes" do
@@ -112,7 +112,7 @@
             </GenericXML>)
           graph = parse(sampledoc, :base_uri => "http://example.com", :validate => true)
           objects = graph.statements.map {|s| s.object.value}.sort
-          objects.should == ["Bar", "Foo"]
+          expect(objects).to include("Bar", "Foo")
         end
 
         it "should be able to parse a simple single-triple document" do
@@ -156,7 +156,7 @@
                  <http://www.example.org/name> "Tom"@en] .
           )
           graph = parse(sampledoc, :base_uri => "http://example.com/", :validate => true)
-          graph.should be_equivalent_graph(expected, :about => "http://example.com/", :trace => @debug)
+          expect(graph).to be_equivalent_graph(expected, :about => "http://example.com/", :trace => @debug)
         end
 
         it "should be able to handle Bags/Alts etc." do
@@ -168,7 +168,7 @@
               </rdf:Bag>
             </rdf:RDF>)
           graph = parse(sampledoc, :base_uri => "http://example.com", :validate => true)
-          graph.predicates.map(&:to_s).should include("http://www.w3.org/1999/02/22-rdf-syntax-ns#_1", "http://www.w3.org/1999/02/22-rdf-syntax-ns#_2")
+          expect(graph.predicates.map(&:to_s)).to include("http://www.w3.org/1999/02/22-rdf-syntax-ns#_1", "http://www.w3.org/1999/02/22-rdf-syntax-ns#_2")
         end
       end
 
@@ -199,7 +199,7 @@
         	<http://example.net/> <http://purl.org/dc/terms/title> "Test 0304"@fr .
         )
         graph = parse(svg, :base_uri => "http://example.com/", :validate => true)
-        graph.should be_equivalent_graph(expected, :trace => @debug)
+        expect(graph).to be_equivalent_graph(expected, :trace => @debug)
       end
 
       context :exceptions do
@@ -316,7 +316,7 @@
           )
 
           graph = parse(sampledoc, :base_uri => "http://example.com", :validate => true)
-          graph.should be_equivalent_graph(expected, :about => "http://example.com/", :trace => @debug)
+          expect(graph).to be_equivalent_graph(expected, :about => "http://example.com/", :trace => @debug)
         end
       end
 
@@ -343,7 +343,7 @@
           )
 
           graph = parse(sampledoc, :base_uri => "http://example.com", :validate => true)
-          graph.should be_equivalent_graph(expected, :about => "http://example.com/", :trace => @debug)
+          expect(graph).to be_equivalent_graph(expected, :about => "http://example.com/", :trace => @debug)
         end
 
         it "decodes element content" do
@@ -362,7 +362,7 @@
           )
 
           graph = parse(sampledoc, :base_uri => "http://example.com", :validate => true)
-          graph.should be_equivalent_graph(expected, :about => "http://example.com/", :trace => @debug)
+          expect(graph).to be_equivalent_graph(expected, :about => "http://example.com/", :trace => @debug)
         end
       end
     end