rdf-spec 1.0.7 → 1.0.9

data/lib/rdf/spec/indexable.rb

@@ -15,11 +15,11 @@ module RDF_Indexable
     it {should respond_to(:index!)}
   
     it "does not raise error on #index! if #indexed?" do
-      lambda {subject.index!}.should_not raise_error if subject.indexed?
+      expect {subject.index!}.not_to raise_error if subject.indexed?
     end
   
     it "raises error on #index! if not #indexed?" do
-      lambda {subject.index!}.should raise_error unless subject.indexed?
+      expect {subject.index!}.to raise_error unless subject.indexed?
     end
   end
 end

data/lib/rdf/spec/matchers.rb

@@ -8,113 +8,113 @@ module RDF; module Spec
   module Matchers
     RSpec::Matchers.define :be_countable do
       match do |countable|
-        countable.should be_a_kind_of(RDF::Countable)
+        expect(countable).to be_a_kind_of(RDF::Countable)
         true
       end
     end
 
     RSpec::Matchers.define :be_enumerable do
       match do |enumerable|
-        enumerable.should be_a_kind_of(RDF::Enumerable)
+        expect(enumerable).to be_a_kind_of(RDF::Enumerable)
         true
       end
     end
 
     RSpec::Matchers.define :be_an_enumerator do
       match do |enumerator|
-        enumerator.should be_a_kind_of(RDF::Enumerator)
+        expect(enumerator).to be_a_kind_of(RDF::Enumerator)
         true
       end
     end
 
     RSpec::Matchers.define :be_queryable do
       match do |enumerable|
-        enumerable.should be_a_kind_of(RDF::Queryable)
+        expect(enumerable).to be_a_kind_of(RDF::Queryable)
         true
       end
     end
 
     RSpec::Matchers.define :be_mutable do
       match do |enumerable|
-        enumerable.should be_a_kind_of(RDF::Mutable)
+        expect(enumerable).to be_a_kind_of(RDF::Mutable)
         true
       end
     end
 
     RSpec::Matchers.define :be_a_statement do
       match do |statement|
-        statement.should be_instance_of(RDF::Statement)
-        statement.subject.should be_a_kind_of(RDF::Resource)
-        statement.predicate.should be_a_kind_of(RDF::URI)
-        statement.object.should be_a_kind_of(RDF::Value)
+        expect(statement).to be_instance_of(RDF::Statement)
+        expect(statement.subject).to be_a_kind_of(RDF::Resource)
+        expect(statement.predicate).to be_a_kind_of(RDF::URI)
+        expect(statement.object).to be_a_kind_of(RDF::Value)
         true
       end
     end
 
     RSpec::Matchers.define :be_a_triple do
       match do |triple|
-        triple.should be_instance_of(Array)
-        triple.size.should == 3
-        triple[0].should be_a_kind_of(RDF::Resource)
-        triple[1].should be_a_kind_of(RDF::URI)
-        triple[2].should be_a_kind_of(RDF::Value)
+        expect(triple).to be_instance_of(Array)
+        expect(triple.size).to eq 3
+        expect(triple[0]).to be_a_kind_of(RDF::Resource)
+        expect(triple[1]).to be_a_kind_of(RDF::URI)
+        expect(triple[2]).to be_a_kind_of(RDF::Value)
         true
       end
     end
 
     RSpec::Matchers.define :be_a_quad do
       match do |quad|
-        quad.should be_instance_of(Array)
-        quad.size.should == 4
-        quad[0].should be_a_kind_of(RDF::Resource)
-        quad[1].should be_a_kind_of(RDF::URI)
-        quad[2].should be_a_kind_of(RDF::Value)
-        quad[3].should be_a_kind_of(RDF::Resource) unless quad[3].nil?
+        expect(quad).to be_instance_of(Array)
+        expect(quad.size).to eq 4
+        expect(quad[0]).to be_a_kind_of(RDF::Resource)
+        expect(quad[1]).to be_a_kind_of(RDF::URI)
+        expect(quad[2]).to be_a_kind_of(RDF::Value)
+        expect(quad[3]).to be_a_kind_of(RDF::Resource) unless quad[3].nil?
         true
       end
     end
 
     RSpec::Matchers.define :be_a_resource do
       match do |value|
-        value.should be_a_kind_of(RDF::Resource)
+        expect(value).to be_a_kind_of(RDF::Resource)
         true
       end
     end
 
     RSpec::Matchers.define :be_a_node do
       match do |value|
-        value.should be_a_kind_of(RDF::Node)
+        expect(value).to be_a_kind_of(RDF::Node)
         true
       end
     end
 
     RSpec::Matchers.define :be_a_uri do
       match do |value|
-        value.should be_a_kind_of(RDF::URI)
+        expect(value).to be_a_kind_of(RDF::URI)
         true
       end
     end
 
     RSpec::Matchers.define :be_a_value do
       match do |value|
-        value.should be_a_kind_of(RDF::Value)
+        expect(value).to be_a_kind_of(RDF::Value)
         true
       end
     end
 
     RSpec::Matchers.define :be_a_list do
       match do |value|
-        value.should be_an(RDF::List)
+        expect(value).to be_an(RDF::List)
         true
       end
     end
 
     RSpec::Matchers.define :be_a_vocabulary do |base_uri|
       match do |vocabulary|
-        vocabulary.should be_a_kind_of(Module)
-        vocabulary.should respond_to(:to_uri)
-        vocabulary.to_uri.to_s.should == base_uri
-        vocabulary.should respond_to(:[])
+        expect(vocabulary).to be_a_kind_of(Module)
+        expect(vocabulary).to respond_to(:to_uri)
+        expect(vocabulary.to_uri.to_s).to eq base_uri
+        expect(vocabulary).to respond_to(:[])
         true
       end
     end
@@ -122,13 +122,13 @@ module RDF; module Spec
     RSpec::Matchers.define :have_properties do |base_uri, properties|
       match do |vocabulary|
         properties.map { |p| p.to_sym }.each do |property|
-          vocabulary[property].should be_a_uri
-          vocabulary[property].to_s.should == "#{base_uri}#{property}"
-          vocabulary.should respond_to(property)
-          lambda { vocabulary.send(property) }.should_not raise_error
-          vocabulary.send(property).should be_a_uri
-          vocabulary.send(property.to_s).should be_a_uri
-          vocabulary.send(property).to_s.should == "#{base_uri}#{property}"
+          expect(vocabulary[property]).to be_a_uri
+          expect(vocabulary[property].to_s).to eq "#{base_uri}#{property}"
+          expect(vocabulary).to respond_to(property)
+          expect { vocabulary.send(property) }.not_to raise_error
+          expect(vocabulary.send(property)).to be_a_uri
+          expect(vocabulary.send(property.to_s)).to be_a_uri
+          expect(vocabulary.send(property).to_s).to eq "#{base_uri}#{property}"
         end
         true
       end
@@ -145,14 +145,14 @@ module RDF; module Spec
 
     RSpec::Matchers.define :be_a_repository do
       match do |repository|
-        repository.should be_a_kind_of(RDF::Repository)
+        expect(repository).to be_a_kind_of(RDF::Repository)
         true
       end
     end
 
     RSpec::Matchers.define :be_a_repository_of_size do |size|
       match do |repository|
-        repository.should be_a_repository
+        expect(repository).to be_a_repository
         repository.size == size
       end
     end

data/lib/rdf/spec/mutable.rb

@@ -49,43 +49,43 @@ module RDF_Mutable
 
     context "#load" do
       it "should require an argument" do
-        lambda { subject.load }.should raise_error(ArgumentError)
+        expect { subject.load }.to raise_error(ArgumentError)
       end
 
       it "should accept a string filename argument" do
         pending("mutability", :unless => subject.mutable?) do
-          lambda { subject.load(RDF::Spec::TRIPLES_FILE) }.should_not raise_error(ArgumentError)
+          expect { subject.load(RDF::Spec::TRIPLES_FILE) }.not_to raise_error
         end
       end
 
       it "should accept an optional hash argument" do
         pending("mutability", :unless => subject.mutable?) do
-          lambda { subject.load(RDF::Spec::TRIPLES_FILE, {}) }.should_not raise_error(ArgumentError)
+          expect { subject.load(RDF::Spec::TRIPLES_FILE, {}) }.not_to raise_error
         end
       end
 
       it "should load statements" do
         pending("mutability", :unless => subject.mutable?) do
           subject.load RDF::Spec::TRIPLES_FILE
-          subject.size.should ==  File.readlines(RDF::Spec::TRIPLES_FILE).size
-          subject.should have_subject(resource)
+          expect(subject.size).to eq  File.readlines(RDF::Spec::TRIPLES_FILE).size
+          expect(subject).to have_subject(resource)
         end
       end
 
       it "should load statements with a context override" do
         pending("mutability and contextuality", :unless => (subject.mutable? && @supports_context)) do
           subject.load RDF::Spec::TRIPLES_FILE, :context => context
-          subject.should have_context(context)
-          subject.query(:context => context).size.should == subject.size
+          expect(subject).to have_context(context)
+          expect(subject.query(:context => context).size).to eq subject.size
         end
       end
     end
 
     context "#from_{reader}" do
       it "should instantiate a reader" do
-        reader = mock("reader")
-        reader.should_receive(:new).and_return(RDF::NTriples::Reader.new(""))
-        RDF::Reader.should_receive(:for).with(:a_reader).and_return(reader)
+        reader = double("reader")
+        expect(reader).to receive(:new).and_return(RDF::NTriples::Reader.new(""))
+        expect(RDF::Reader).to receive(:for).with(:a_reader).and_return(reader)
         subject.send(:from_a_reader)
       end
     end
@@ -98,21 +98,21 @@ module RDF_Mutable
 
       it "should not raise errors" do
         pending("mutability", :unless => subject.mutable?) do
-          lambda { subject.delete(@statements.first) }.should_not raise_error
+          expect { subject.delete(@statements.first) }.not_to raise_error
         end
       end
 
       it "should support deleting one statement at a time" do
         pending("mutability", :unless => subject.mutable?) do
           subject.delete(@statements.first)
-          subject.should_not have_statement(@statements.first)
+          expect(subject).not_to  have_statement(@statements.first)
         end
       end
 
       it "should support deleting multiple statements at a time" do
         pending("mutability", :unless => subject.mutable?) do
           subject.delete(*@statements)
-          subject.find { |s| subject.has_statement?(s) }.should be_false
+          expect(subject.find { |s| subject.has_statement?(s) }).to be_false
         end
       end
 
@@ -122,12 +122,12 @@ module RDF_Mutable
           require 'digest/sha1'
           count = subject.count
           subject.delete([nil, nil, random = Digest::SHA1.hexdigest(File.read(__FILE__))])
-          subject.should_not be_empty
-          subject.count.should == count
+          expect(subject).not_to  be_empty
+          expect(subject.count).to eq count
 
           # everything deleted
           subject.delete([nil, nil, nil])
-          subject.should be_empty
+          expect(subject).to be_empty
         end
       end
 
@@ -143,15 +143,15 @@ module RDF_Mutable
           subject.insert(s1)
           subject.insert(s2)
           subject.insert(s3)
-          subject.count.should == count
+          expect(subject.count).to eq count
 
           # Delete one by one
           subject.delete(s1)
-          subject.count.should == count - (@supports_context ? 1 : 1)
+          expect(subject.count).to eq count - (@supports_context ? 1 : 1)
           subject.delete(s2)
-          subject.count.should == count - (@supports_context ? 2 : 1)
+          expect(subject.count).to eq count - (@supports_context ? 2 : 1)
           subject.delete(s3)
-          subject.count.should == count - (@supports_context ? 3 : 1)
+          expect(subject.count).to eq count - (@supports_context ? 3 : 1)
         end
       end
     end

data/lib/rdf/spec/queryable.rb

@@ -23,6 +23,8 @@ module RDF_Queryable
 
   describe RDF::Queryable do
     subject {@queryable}
+    let(:query) {RDF::Query.new {pattern [:s, :p, :o]}}
+
     ##
     # @see RDF::Queryable#query
     describe "#query" do
@@ -30,94 +32,135 @@ module RDF_Queryable
 
       context "when called" do
         it "requires an argument" do
-          lambda { subject.query }.should raise_error(ArgumentError)
+          expect { subject.query }.to raise_error(ArgumentError)
         end
 
         it "accepts a pattern argument" do
-          lambda { subject.query(RDF::Query::Pattern.new(nil, nil, nil)) }.should_not raise_error(ArgumentError)
-          lambda { subject.query(RDF::Query::Pattern.new(:s, :p, :o)) }.should_not raise_error(ArgumentError)
+          expect { subject.query(RDF::Query::Pattern.new(nil, nil, nil)) }.not_to raise_error
+          expect { subject.query(RDF::Query::Pattern.new(:s, :p, :o)) }.not_to raise_error
         end
 
         it "accepts a statement argument" do
-          lambda { subject.query(RDF::Statement.new(nil, nil, nil)) }.should_not raise_error(ArgumentError)
+          expect { subject.query(RDF::Statement.new(nil, nil, nil)) }.not_to raise_error
         end
 
         it "accepts a triple argument" do
-          lambda { subject.query([nil, nil, nil]) }.should_not raise_error(ArgumentError)
+          expect { subject.query([nil, nil, nil]) }.not_to raise_error
         end
 
         it "accepts a quad argument" do
-          lambda { subject.query([nil, nil, nil, nil]) }.should_not raise_error(ArgumentError)
+          expect { subject.query([nil, nil, nil, nil]) }.not_to raise_error
         end
 
         it "accepts a hash argument" do
-          lambda { subject.query({}) }.should_not raise_error(ArgumentError)
+          expect { subject.query({}) }.not_to raise_error
+        end
+
+        it "accepts an RDF::Query argument" do
+          expect { subject.query(RDF::Query.new) }.not_to raise_error
         end
 
         it "does not alter a given hash argument" do
           query = {:subject => resource, :predicate => RDF::DOAP.name, :object => RDF::FOAF.Person}
           original_query = query.dup
           subject.query(query)
-          query.should == original_query
+          expect(query).to eq original_query
         end
 
         it "rejects other kinds of arguments" do
-          lambda { subject.query(nil) }.should raise_error(ArgumentError)
+          expect { subject.query(nil) }.to raise_error(ArgumentError)
         end
 
         context "with a block" do
-          it "yields statements" do
-            subject.query([nil, nil, nil]) do |statement|
-              statement.should be_a_statement
+          context "with a triple argument" do
+            it "yields statements" do
+              subject.query([nil, nil, nil]) do |statement|
+                expect(statement).to be_a_statement
+                expect(statement).not_to  be_a RDF::Query::Solution
+              end
+            end
+
+            it "calls #query_pattern" do
+              expect(subject).to receive(:query_pattern)
+              expect(subject).not_to receive(:query_execute)
+              subject.query([:s, :p, :o]) {}
+            end
+          end
+          context "with a Query argument" do
+            it "yields statements" do
+              subject.query(query) do |solution|
+                expect(solution).not_to  be_a_statement
+                expect(solution).to be_a RDF::Query::Solution
+              end
+            end
+
+            it "calls #query_execute" do
+              expect(subject).to receive(:query_execute)
+              expect(subject).not_to receive(:query_pattern)
+              subject.query(query) {}
             end
           end
         end
 
         context "without a block" do
           it "returns an enumerator" do
-            subject.query([nil, nil, nil]).should be_an_enumerator
+            expect(subject.query([nil, nil, nil])).to be_an_enumerator
           end
 
           it "returns an enumerable enumerator" do
-            subject.query([nil, nil, nil]).should be_enumerable
+            expect(subject.query([nil, nil, nil])).to be_enumerable
           end
 
           it "returns a queryable enumerator" do
-            subject.query([nil, nil, nil]).should be_queryable
+            expect(subject.query([nil, nil, nil])).to be_queryable
           end
 
-          it "returns statements" do
+          it "returns statements given a triple" do
             subject.query([nil, nil, nil]).each do |statement|
-              statement.should be_a_statement
+              expect(statement).to be_a_statement
+              expect(statement).not_to  be_a RDF::Query::Solution
+            end
+          end
+
+          it "returns solutions given a query" do
+            subject.query(query).each do |solution|
+              expect(solution).not_to  be_a_statement
+              expect(solution).to be_a RDF::Query::Solution
             end
           end
 
           it "returns the correct number of results for array queries" do
-            subject.query([nil, nil, nil]).size.should == @statements.size
-            subject.query([resource, nil, nil]).size.should == File.readlines(@doap).grep(/^<http:\/\/rubygems\.org\/gems\/rdf>/).size
-            subject.query([RDF::URI("http://ar.to/#self"), nil, nil]).size.should == File.readlines(@doap).grep(/^<http:\/\/ar.to\/\#self>/).size
-            subject.query([resource, RDF::DOAP.name, nil]).size.should == 1
-            subject.query([nil, nil, RDF::DOAP.Project]).size.should == 1
+            expect(subject.query([nil, nil, nil]).size).to eq @statements.size
+            expect(subject.query([resource, nil, nil]).size).to eq File.readlines(@doap).grep(/^<http:\/\/rubygems\.org\/gems\/rdf>/).size
+            expect(subject.query([RDF::URI("http://ar.to/#self"), nil, nil]).size).to eq File.readlines(@doap).grep(/^<http:\/\/ar.to\/\#self>/).size
+            expect(subject.query([resource, RDF::DOAP.name, nil]).size).to eq 1
+            expect(subject.query([nil, nil, RDF::DOAP.Project]).size).to eq 1
           end
 
           it "returns the correct number of results for hash queries" do
-            subject.query({}).size.should == @statements.size
-            subject.query(:subject => resource) .size.should == File.readlines(@doap).grep(/^<http:\/\/rubygems\.org\/gems\/rdf>/).size
-            subject.query(:subject => resource, :predicate => RDF::DOAP.name).size.should == 1
-            subject.query(:object => RDF::DOAP.Project).size.should == 1
+            expect(subject.query({}).size).to eq @statements.size
+            expect(subject.query(:subject => resource).size).to eq File.readlines(@doap).grep(/^<http:\/\/rubygems\.org\/gems\/rdf>/).size
+            expect(subject.query(:subject => resource, :predicate => RDF::DOAP.name).size).to eq 1
+            expect(subject.query(:object => RDF::DOAP.Project).size).to eq 1
+          end
+
+          it "returns the correct number of results for query queries" do
+            expect(subject.query(query).size).to eq @statements.size
           end
         end
 
         context "with specific patterns from SPARQL" do
           context "triple pattern combinations" do
             it "?s p o" do
-              subject.query(:predicate => RDF::URI("http://example.org/p"), :object => RDF::Literal.new(1)).to_a.should ==
-                [RDF::Statement.new(RDF::URI("http://example.org/xi1"), RDF::URI("http://example.org/p"), 1), RDF::Statement.new(RDF::URI("http://example.org/xi2"), RDF::URI("http://example.org/p"), 1)]
+              expect(subject.query(:predicate => RDF::URI("http://example.org/p"), :object => RDF::Literal.new(1)).to_a).to(
+                include *[RDF::Statement.new(RDF::URI("http://example.org/xi1"), RDF::URI("http://example.org/p"), 1), RDF::Statement.new(RDF::URI("http://example.org/xi2"), RDF::URI("http://example.org/p"), 1)]
+              )
             end
 
             it "s ?p o" do
-              subject.query(:subject => RDF::URI("http://example.org/xi2"), :object => RDF::Literal.new(1)).to_a.should ==
-                [RDF::Statement.new(RDF::URI("http://example.org/xi2"), RDF::URI("http://example.org/p"), 1)]
+              expect(subject.query(:subject => RDF::URI("http://example.org/xi2"), :object => RDF::Literal.new(1)).to_a).to(
+                include *[RDF::Statement.new(RDF::URI("http://example.org/xi2"), RDF::URI("http://example.org/p"), 1)]
+              )
             end
           end
 
@@ -128,11 +171,11 @@ module RDF_Queryable
               its(:count) {should == 2}
 
               it "has two solutions" do
-                subject.any? {|s| s.subject == RDF::URI("http://example.org/xi1")}.should be_true
+                expect(subject.any? {|s| s.subject == RDF::URI("http://example.org/xi1")}).to be_true
               end
 
               it "has xi2 as a solution" do
-                subject.any? {|s| s.subject == RDF::URI("http://example.org/xi2")}.should be_true
+                expect(subject.any? {|s| s.subject == RDF::URI("http://example.org/xi2")}).to be_true
               end
             end
 
@@ -141,7 +184,7 @@ module RDF_Queryable
               its(:count) {should == 1}
 
               it "has xd1 as a solution" do
-                subject.any? {|s| s.subject == RDF::URI("http://example.org/xd1")}.should be_true
+                expect(subject.any? {|s| s.subject == RDF::URI("http://example.org/xd1")}).to be_true
               end
             end
           end
@@ -149,30 +192,49 @@ module RDF_Queryable
       end
     end
 
+    ##
+    # @see RDF::Queryable#query_execute
+    describe "#query_execute" do
+      it "defines a protected #query_execute method" do
+        expect(subject.class.protected_method_defined?(:query_execute)).to be_true
+      end
+
+      context "when called" do
+        it "requires an argument" do
+          expect { subject.send(:query_execute) }.to raise_error(ArgumentError)
+        end
+
+        it "yields to the given block" do
+          expect {|b| subject.send(:query_execute, query, &b)}.to yield_control.exactly(@queryable.count).times
+        end
+
+        it "yields solutions" do
+          subject.send(:query_execute, query) do |solution|
+            expect(solution).to be_a RDF::Query::Solution
+          end
+        end
+      end
+    end
+
     ##
     # @see RDF::Queryable#query_pattern
     describe "#query_pattern" do
       it "defines a protected #query_pattern method" do
-        subject.class.protected_method_defined?(:query_pattern).should be_true
+        expect(subject.class.protected_method_defined?(:query_pattern)).to be_true
       end
 
       context "when called" do
         it "requires an argument" do
-          lambda { subject.send(:query_pattern) }.should raise_error(ArgumentError)
+          expect { subject.send(:query_pattern) }.to raise_error(ArgumentError)
         end
 
         it "yields to the given block" do
-          called = false
-          subject.send(:query_pattern, RDF::Query::Pattern.new) do |statement|
-            called = true
-            break
-          end
-          called.should be_true
+          expect {|b| subject.send(:query_pattern, RDF::Query::Pattern.new, &b)}.to yield_control.exactly(@queryable.count).times
         end
 
         it "yields statements" do
           subject.send(:query_pattern, RDF::Query::Pattern.new) do |statement|
-            statement.should be_a_statement
+            expect(statement).to be_a_statement
           end
         end
     
@@ -190,7 +252,7 @@ module RDF_Queryable
             it "returns #{result.inspect} given #{pattern.inspect}" do
               solutions = []
               subject.send(:query_pattern, pattern) {|s| solutions << s}
-              solutions.should == result
+              expect(solutions).to eq result
             end
           end
         end
@@ -200,7 +262,7 @@ module RDF_Queryable
             pattern = RDF::Query::Pattern.new(nil, nil, nil, :context => nil)
             solutions = []
             subject.send(:query_pattern, pattern) {|s| solutions << s}
-            solutions.size.should == @statements.size
+            expect(solutions.size).to eq @statements.size
           end
 
           it "returns statements from unnamed contexts with false context" do
@@ -208,7 +270,7 @@ module RDF_Queryable
             solutions = []
             subject.send(:query_pattern, pattern) {|s| solutions << s}
             context_statements = subject.statements.reject {|st| st.has_context?}.length
-            solutions.size.should == context_statements
+            expect(solutions.size).to eq context_statements
           end
 
           it "returns statements from named contexts with variable context" do
@@ -217,7 +279,7 @@ module RDF_Queryable
               solutions = []
               subject.send(:query_pattern, pattern) {|s| solutions << s}
               context_statements = subject.statements.select {|st| st.has_context?}.length
-              solutions.size.should == context_statements
+              expect(solutions.size).to eq context_statements
             end
           end
 
@@ -226,7 +288,7 @@ module RDF_Queryable
               pattern = RDF::Query::Pattern.new(nil, nil, nil, :context => RDF::URI("http://ar.to/#self"))
               solutions = []
               subject.send(:query_pattern, pattern) {|s| solutions << s}
-              solutions.size.should == File.readlines(@doap).grep(/^<http:\/\/ar.to\/\#self>/).size
+              expect(solutions.size).to eq File.readlines(@doap).grep(/^<http:\/\/ar.to\/\#self>/).size
             end
           end
         end
@@ -239,29 +301,29 @@ module RDF_Queryable
       let(:failing_pattern) {[RDF::Node.new] * 3}
 
       it "should respond to #first" do
-        subject.should respond_to(:first)
+        expect(subject).to respond_to(:first)
       end
 
       it "returns enumerator without a pattern" do
-        lambda { subject.first }.should_not raise_error(ArgumentError)
-        subject.first.should == subject.each.first # uses an Enumerator
+        expect { subject.first }.not_to raise_error
+        expect(subject.first).to eq subject.each.first # uses an Enumerator
       end
 
       it "returns the correct value when the pattern matches", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
         matching_patterns = [[nil, nil, nil], subject.each.first]
         matching_patterns.each do |matching_pattern|
-          subject.first(matching_pattern).should == subject.query(matching_pattern).each.first
+          expect(subject.first(matching_pattern)).to eq subject.query(matching_pattern).each.first
         end
       end
 
       it "returns nil when the pattern fails to match anything" do
-        subject.first(failing_pattern).should be_nil
+        expect(subject.first(failing_pattern)).to be_nil
       end
 
       it "returns nil when self is empty" do
         queryable = [].extend(RDF::Queryable)
-        queryable.first.should be_nil
-        queryable.first(failing_pattern).should be_nil
+        expect(queryable.first).to be_nil
+        expect(queryable.first(failing_pattern)).to be_nil
       end
     end
 
@@ -271,29 +333,29 @@ module RDF_Queryable
       let(:failing_pattern) {[RDF::Node.new, nil, nil]}
 
       it "should respond to #first_subject" do
-        subject.should respond_to(:first_subject)
+        expect(subject).to respond_to(:first_subject)
       end
 
       it "returns enumerator without a pattern", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
-        lambda { subject.first_subject }.should_not raise_error(ArgumentError)
-        subject.first_subject.should == subject.first.subject
+        expect { subject.first_subject }.not_to raise_error
+        expect(subject.first_subject).to eq subject.first.subject
       end
 
       it "returns the correct value when the pattern matches", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
         matching_patterns = [[nil, nil, nil], [subject.first.subject, nil, nil]]
         matching_patterns.each do |matching_pattern|
-          subject.first_subject(matching_pattern).should == subject.query(matching_pattern).first.subject
+          expect(subject.first_subject(matching_pattern)).to eq subject.query(matching_pattern).first.subject
         end
       end
 
       it "returns nil when the pattern fails to match anything" do
-        subject.first_subject(failing_pattern).should be_nil
+        expect(subject.first_subject(failing_pattern)).to be_nil
       end
 
       it "returns nil when self is empty" do
         queryable = [].extend(RDF::Queryable)
-        queryable.first_subject.should be_nil
-        queryable.first_subject(failing_pattern).should be_nil
+        expect(queryable.first_subject).to be_nil
+        expect(queryable.first_subject(failing_pattern)).to be_nil
       end
     end
 
@@ -306,25 +368,25 @@ module RDF_Queryable
       it {should respond_to(:first_predicate)}
 
       it "returns enumerator without a pattern", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
-        lambda { subject.first_predicate }.should_not raise_error(ArgumentError)
-        subject.first_predicate.should == subject.first.predicate
+        expect { subject.first_predicate }.not_to raise_error
+        expect(subject.first_predicate).to eq subject.first.predicate
       end
 
       it "returns the correct value when the pattern matches", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
         matching_patterns = [[nil, nil, nil], [nil, subject.first.predicate, nil]]
         matching_patterns.each do |matching_pattern|
-          subject.first_predicate(matching_pattern).should == subject.query(matching_pattern).first.predicate
+          expect(subject.first_predicate(matching_pattern)).to eq subject.query(matching_pattern).first.predicate
         end
       end
 
       it "returns nil when the pattern fails to match anything" do
-        subject.first_predicate(failing_pattern).should be_nil
+        expect(subject.first_predicate(failing_pattern)).to be_nil
       end
 
       it "returns nil when self is empty" do
         queryable = [].extend(RDF::Queryable)
-        queryable.first_predicate.should be_nil
-        queryable.first_predicate(failing_pattern).should be_nil
+        expect(queryable.first_predicate).to be_nil
+        expect(queryable.first_predicate(failing_pattern)).to be_nil
       end
     end
 
@@ -336,25 +398,25 @@ module RDF_Queryable
       it {should respond_to(:first_object)}
 
       it "returns enurator without a pattern", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
-        lambda { subject.first_object }.should_not raise_error(ArgumentError)
-        subject.first_object.should == subject.first.object
+        expect { subject.first_object }.not_to raise_error
+        expect(subject.first_object).to eq subject.first.object
       end
 
       it "returns the correct value when the pattern matches", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
         matching_patterns = [[nil, nil, nil], [nil, nil, subject.first.object]]
         matching_patterns.each do |matching_pattern|
-          subject.first_object(matching_pattern).should == subject.query(matching_pattern).first.object
+          expect(subject.first_object(matching_pattern)).to eq subject.query(matching_pattern).first.object
         end
       end
 
       it "returns nil when the pattern fails to match anything" do
-        subject.first_object(failing_pattern).should be_nil
+        expect(subject.first_object(failing_pattern)).to be_nil
       end
 
       it "returns nil when self is empty" do
         queryable = [].extend(RDF::Queryable)
-        queryable.first_object.should be_nil
-        queryable.first_object(failing_pattern).should be_nil
+        expect(queryable.first_object).to be_nil
+        expect(queryable.first_object(failing_pattern)).to be_nil
       end
     end
 
@@ -374,25 +436,25 @@ module RDF_Queryable
       it {should respond_to(:first_literal)}
 
       it "returns a literal without a pattern" do
-        lambda { subject.first_literal }.should_not raise_error(ArgumentError)
-        subject.first_literal.should == literal
+        expect { subject.first_literal }.not_to raise_error
+        expect(subject.first_literal).to eq literal
       end
 
       it "returns the correct value when the pattern matches" do
         matching_patterns = [[nil, nil, nil], [resource, nil, nil], [nil, RDF::DC.creator, nil], [nil, nil, literal]]
         matching_patterns.each do |matching_pattern|
-          subject.first_literal(matching_pattern).should == literal
+          expect(subject.first_literal(matching_pattern)).to eq literal
         end
       end
 
       it "returns nil when the pattern fails to match anything" do
-        subject.first_literal(failing_pattern).should be_nil
+        expect(subject.first_literal(failing_pattern)).to be_nil
       end
 
       it "returns nil when self is empty" do
         queryable = [].extend(RDF::Queryable)
-        queryable.first_literal.should be_nil
-        queryable.first_literal(failing_pattern).should be_nil
+        expect(queryable.first_literal).to be_nil
+        expect(queryable.first_literal(failing_pattern)).to be_nil
       end
     end
 
@@ -404,8 +466,8 @@ module RDF_Queryable
       it {should respond_to(:first_value)}
 
       it "returns first literal without a pattern" do
-        lambda { subject.first_value }.should_not raise_error(ArgumentError)
-        subject.first_value.should == subject.first_literal.value
+        expect { subject.first_value }.not_to raise_error
+        expect(subject.first_value).to eq subject.first_literal.value
       end
 
       it "returns the correct value when the pattern matches" do
@@ -415,20 +477,20 @@ module RDF_Queryable
             matching_pattern = [statement.subject, statement.predicate, nil]
             unless matching_patterns.include?(matching_pattern)
               matching_patterns << matching_pattern
-              subject.first_value(matching_pattern).should == subject.first_literal(matching_pattern).value
+              expect(subject.first_value(matching_pattern)).to eq subject.first_literal(matching_pattern).value
             end
           end
         end
       end
 
       it "returns nil when the pattern fails to match anything" do
-        subject.first_value(failing_pattern).should be_nil
+        expect(subject.first_value(failing_pattern)).to be_nil
       end
 
       it "returns nil when self is empty" do
         queryable = [].extend(RDF::Queryable)
-        queryable.first_value.should be_nil
-        queryable.first_value(failing_pattern).should be_nil
+        expect(queryable.first_value).to be_nil
+        expect(queryable.first_value(failing_pattern)).to be_nil
       end
     end
   end