Update to use expect syntax.

Author: gkellogg

lib/rdf/spec/countable.rb

@@ -38,7 +38,7 @@ module RDF_Countable
     its(:to_enum) {should be_countable}
     its(:enum_for) {should be_countable}
     it "#enum_for(:each)" do
-      subject.enum_for(:each).should be_countable
+      expect(subject.enum_for(:each)).to be_countable
     end
   end
 end

lib/rdf/spec/durable.rb

@@ -29,19 +29,19 @@ module RDF_Durable
     subject {@load_durable.call}
     it {should respond_to(:durable?)}
     it "should support #durable?" do
-      [true,false].member?(subject.durable?).should be_true
+      expect([true,false]).to be_member(subject.durable?)
     end
 
     it {should respond_to(:nondurable?)}
     it "should support #nondurable?" do
-      [true,false].member?(@load_durable.call.nondurable?).should be_true
+      expect([true,false]).to be_member(@load_durable.call.nondurable?)
     end
     its(:nondurable?) {should_not == subject.durable?}
 
     it "should save contents between instantiations" do
       if subject.durable?
        subject.load(RDF::Spec::TRIPLES_FILE)
-       subject.count.should == File.readlines(RDF::Spec::TRIPLES_FILE).size
+       expect(subject.count).to eq File.readlines(RDF::Spec::TRIPLES_FILE).size
       end
     end
   end

lib/rdf/spec/enumerable.rb

@@ -13,29 +13,29 @@ module RDF_Format
     describe ".for" do
       RDF::Format.file_extensions.each do |ext, formats|
         it "detects #{formats.first} using file path foo.#{ext}" do
-          RDF::Format.for("foo.#{ext}").should == formats.first
+          expect(RDF::Format.for("foo.#{ext}")).to eq formats.first
         end
 
         it "detects #{formats.first} using file_name foo.#{ext}" do
-          RDF::Format.for(:file_name => "foo.#{ext}").should == formats.first
+          expect(RDF::Format.for(:file_name => "foo.#{ext}")).to eq formats.first
         end
 
         it "detects #{formats.first} using file_extension #{ext}" do
-          RDF::Format.for(:file_extension => ext).should == formats.first
+          expect(RDF::Format.for(:file_extension => ext)).to eq formats.first
         end
       end
 
       RDF::Format.content_types.each do |content_type, formats|
         it "detects #{formats.first} using content_type #{content_type}" do
-          RDF::Format.for(:content_type => content_type).should == formats.first
+          expect(RDF::Format.for(:content_type => content_type)).to eq formats.first
         end
       end
     end
 
     describe ".reader" do
       it "returns a reader" do
         subject.each do |f|
-          f.reader.should_not be_nil
+          expect(f.reader).not_to  be_nil
         end
       end
     end
@@ -46,7 +46,7 @@ module RDF_Format
       it "returns a writer" do
         subject.each do |f|
           format_namespace = f.name.split('::')[0..-2].inject(Kernel) {|base, const| base.const_get(const)}
-          f.writer.should_not be_nil if format_namespace.const_defined?(:Writer)
+          expect(f.writer).not_to  be_nil if format_namespace.const_defined?(:Writer)
         end
       end
     end

lib/rdf/spec/format.rb

@@ -8,127 +8,127 @@ 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
 
     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)
+          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
-          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.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 Matchers
 
     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

lib/rdf/spec/matchers.rb

@@ -67,25 +67,25 @@ module RDF_Mutable
       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 = double("reader")
-        reader.should_receive(:new).and_return(RDF::NTriples::Reader.new(""))
-        RDF::Reader.should_receive(:for).with(:a_reader).and_return(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
@@ -105,14 +105,14 @@ module RDF_Mutable
       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