Update lambda {}.should raise_error to expect {}.to raise_error

Also should_not => not_to
Also not_to raise_error(Specific) => not_to raise_error
Change stub! to just stub.
Remove any_number_of_times expectation in Writer, which is deprecated.

Author: gkellogg

lib/rdf/spec/enumerable.rb

@@ -422,7 +422,7 @@ module RDF_Enumerable
       end
 
       it "raises error on unknown format" do
-        lambda {subject.dump(:foobar)}.should raise_error(RDF::WriterError, /No writer found/)
+        expect {subject.dump(:foobar)}.to raise_error(RDF::WriterError, /No writer found/)
       end
     end
   end

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

lib/rdf/spec/matchers.rb

@@ -125,7 +125,7 @@ module Matchers
           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
+          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}"

lib/rdf/spec/mutable.rb

@@ -49,18 +49,18 @@ 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
 
@@ -83,7 +83,7 @@ module RDF_Mutable
 
     context "#from_{reader}" do
       it "should instantiate a reader" do
-        reader = mock("reader")
+        reader = double("reader")
         reader.should_receive(:new).and_return(RDF::NTriples::Reader.new(""))
         RDF::Reader.should_receive(:for).with(:a_reader).and_return(reader)
         subject.send(:from_a_reader)
@@ -98,7 +98,7 @@ 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
 

lib/rdf/spec/queryable.rb

@@ -30,28 +30,28 @@ 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 "does not alter a given hash argument" do
@@ -62,7 +62,7 @@ module RDF_Queryable
         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
@@ -158,7 +158,7 @@ module RDF_Queryable
 
       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
@@ -243,7 +243,7 @@ module RDF_Queryable
       end
 
       it "returns enumerator without a pattern" do
-        lambda { subject.first }.should_not raise_error(ArgumentError)
+        expect { subject.first }.not_to raise_error
         subject.first.should == subject.each.first # uses an Enumerator
       end
 
@@ -275,7 +275,7 @@ module RDF_Queryable
       end
 
       it "returns enumerator without a pattern", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
-        lambda { subject.first_subject }.should_not raise_error(ArgumentError)
+        expect { subject.first_subject }.not_to raise_error
         subject.first_subject.should == subject.first.subject
       end
 
@@ -306,7 +306,7 @@ 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)
+        expect { subject.first_predicate }.not_to raise_error
         subject.first_predicate.should == subject.first.predicate
       end
 
@@ -336,7 +336,7 @@ 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)
+        expect { subject.first_object }.not_to raise_error
         subject.first_object.should == subject.first.object
       end
 
@@ -374,7 +374,7 @@ 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)
+        expect { subject.first_literal }.not_to raise_error
         subject.first_literal.should == literal
       end
 
@@ -404,7 +404,7 @@ 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)
+        expect { subject.first_value }.not_to raise_error
         subject.first_value.should == subject.first_literal.value
       end
 

lib/rdf/spec/reader.rb

@@ -20,14 +20,14 @@ module RDF_Reader
 
     describe ".open" do
       before(:each) do
-        RDF::Util::File.stub!(:open_file).and_yield(StringIO.new("foo"))
+        RDF::Util::File.stub(:open_file).and_yield(StringIO.new("foo"))
       end
 
       it "yields reader given file_name" do
         @reader_class.format.each do |f|
-          RDF::Util::File.stub!(:open_file).and_yield(StringIO.new("foo"))
+          RDF::Util::File.stub(:open_file).and_yield(StringIO.new("foo"))
           f.file_extensions.each_pair do |sym, content_type|
-            reader_mock = mock("reader")
+            reader_mock = double("reader")
             reader_mock.should_receive(:got_here)
             @reader_class.should_receive(:for).with(:file_name => "foo.#{sym}").and_return(@reader_class)
             @reader_class.open("foo.#{sym}") do |r|
@@ -40,9 +40,9 @@ module RDF_Reader
 
       it "yields reader given symbol" do
         @reader_class.format.each do |f|
-          RDF::Util::File.stub!(:open_file).and_yield(StringIO.new("foo"))
+          RDF::Util::File.stub(:open_file).and_yield(StringIO.new("foo"))
           sym = f.to_sym  # Like RDF::NTriples::Format => :ntriples
-          reader_mock = mock("reader")
+          reader_mock = double("reader")
           reader_mock.should_receive(:got_here)
           @reader_class.should_receive(:for).with(sym).and_return(@reader_class)
           @reader_class.open("foo.#{sym}", :format => sym) do |r|
@@ -54,9 +54,9 @@ module RDF_Reader
 
       it "yields reader given {:file_name => file_name}" do
         @reader_class.format.each do |f|
-          RDF::Util::File.stub!(:open_file).and_yield(StringIO.new("foo"))
+          RDF::Util::File.stub(:open_file).and_yield(StringIO.new("foo"))
           f.file_extensions.each_pair do |sym, content_type|
-            reader_mock = mock("reader")
+            reader_mock = double("reader")
             reader_mock.should_receive(:got_here)
             @reader_class.should_receive(:for).with(:file_name => "foo.#{sym}").and_return(@reader_class)
             @reader_class.open("foo.#{sym}", :file_name => "foo.#{sym}") do |r|
@@ -69,9 +69,9 @@ module RDF_Reader
 
       it "yields reader given {:content_type => 'a/b'}" do
         @reader_class.format.each do |f|
-          RDF::Util::File.stub!(:open_file).and_yield(StringIO.new("foo"))
+          RDF::Util::File.stub(:open_file).and_yield(StringIO.new("foo"))
           f.content_types.each_pair do |content_type, formats|
-            reader_mock = mock("reader")
+            reader_mock = double("reader")
             reader_mock.should_receive(:got_here)
             @reader_class.should_receive(:for).with(:content_type => content_type, :file_name => "foo").and_return(@reader_class)
             @reader_class.open("foo", :content_type => content_type) do |r|
@@ -92,7 +92,7 @@ module RDF_Reader
 
     describe ".new" do
       it "sets @input to StringIO given a string" do
-        reader_mock = mock("reader")
+        reader_mock = double("reader")
         reader_mock.should_receive(:got_here)
         @reader_class.new("string") do |r|
           reader_mock.got_here
@@ -101,7 +101,7 @@ module RDF_Reader
       end
 
       it "sets @input to input given something other than a string" do
-        reader_mock = mock("reader")
+        reader_mock = double("reader")
         reader_mock.should_receive(:got_here)
         file = StringIO.new("")
         @reader_class.new(file) do |r|
@@ -122,7 +122,7 @@ module RDF_Reader
       end
 
       it "sets canonicalize given :canonicalize => true" do
-        reader_mock = mock("reader")
+        reader_mock = double("reader")
         reader_mock.should_receive(:got_here)
         @reader_class.new("string", :canonicalize => true) do |r|
           reader_mock.got_here
@@ -131,7 +131,7 @@ module RDF_Reader
       end
 
       it "sets intern given :intern => true" do
-        reader_mock = mock("reader")
+        reader_mock = double("reader")
         reader_mock.should_receive(:got_here)
         @reader_class.new("string", :intern => true) do |r|
           reader_mock.got_here
@@ -140,7 +140,7 @@ module RDF_Reader
       end
 
       it "sets prefixes given :prefixes => {}" do
-        reader_mock = mock("reader")
+        reader_mock = double("reader")
         reader_mock.should_receive(:got_here)
         @reader_class.new("string", :prefixes => {:a => "b"}) do |r|
           reader_mock.got_here

lib/rdf/spec/transaction.rb

@@ -12,13 +12,13 @@
     describe "#initialize" do
       subject {klass}
       it "accepts a graph" do
-        g = mock("graph")
+        g = double("graph")
         this = subject.new(:graph => g)
         this.graph.should == g
       end
 
       it "accepts a context" do
-        c = mock("context")
+        c = double("context")
         this = subject.new(:graph => c)
         this.graph.should == c
         this.context.should == c
@@ -29,13 +29,13 @@
       end
 
       it "accepts inserts" do
-        g = mock("inserts")
+        g = double("inserts")
         this = subject.new(:insert => g)
         this.inserts.should == g
       end
 
       it "accepts deletes" do
-        g = mock("deletes")
+        g = double("deletes")
         this = subject.new(:delete => g)
         this.deletes.should == g
       end
@@ -60,7 +60,7 @@
 
     describe "#execute" do
       let(:s) {RDF::Statement.new(RDF::URI("s"), RDF::URI("p"), RDF::URI("o"))}
-      let(:r) {mock("repository")}
+      let(:r) {double("repository")}
 
       it "deletes statements" do
         r.should_receive(:delete).with(s)

lib/rdf/spec/writable.rb

@@ -86,7 +86,7 @@ module RDF_Writable
 
       it "should not raise errors" do
         pending("writability", :unless => subject.writable?) do
-          lambda { subject.insert(statement) }.should_not raise_error
+          expect { subject.insert(statement) }.not_to raise_error
         end
       end