yajl-ruby 1.2.3 → 1.3.1

data/spec/http/http_error_spec.rb

@@ -9,12 +9,11 @@ require 'yajl/deflate'
 require 'yajl/http_stream'
 
 describe "Yajl HTTP error" do
-  before(:all) do
+  before do
+    @uri = 'file://' + File.expand_path(File.dirname(__FILE__) + "/fixtures/http/http.error.dump")
     @request = File.new(File.expand_path(File.dirname(__FILE__) + "/fixtures/http.error.dump"), 'r')
-    @uri = 'file://'+File.expand_path(File.dirname(__FILE__) + "/fixtures/http/http.error.dump")
-    TCPSocket.should_receive(:new).and_return(@request)
-    @request.should_receive(:write)
-
+    allow(TCPSocket).to receive(:new).and_return(@request)
+    allow(@request).to receive(:write)
     begin
       Yajl::HttpStream.get(@uri)
     rescue Yajl::HttpStream::HttpError => e
@@ -23,10 +22,10 @@ describe "Yajl HTTP error" do
   end
 
   it "should contain the error code in the message" do
-    @error.message.should match(/404/)
+    expect(@error.message).to match(/404/)
   end
 
   it "should provide the HTTP response headers" do
-    @error.headers.keys.should include('ETag', 'Content-Length', 'Server')
+    expect(@error.headers.keys).to include('ETag', 'Content-Length', 'Server')
   end
-end
+end

data/spec/http/http_get_spec.rb

@@ -38,72 +38,72 @@ describe "Yajl HTTP GET request" do
   def prepare_mock_request_dump(format=:raw)
     @request = File.new(File.expand_path(File.dirname(__FILE__) + "/fixtures/http.#{format}.dump"), 'r')
     @uri = 'file://'+File.expand_path(File.dirname(__FILE__) + "/fixtures/http/http.#{format}.dump")
-    TCPSocket.should_receive(:new).and_return(@request)
-    @request.should_receive(:write)
+    expect(TCPSocket).to receive(:new).and_return(@request)
+    expect(@request).to receive(:write)
   end
 
   it "should parse a raw response" do
     prepare_mock_request_dump :raw
-    @template_hash.should == Yajl::HttpStream.get(@uri)
+    expect(@template_hash).to eq(Yajl::HttpStream.get(@uri))
   end
 
   it "should parse a raw response and symbolize keys" do
     prepare_mock_request_dump :raw
-    @template_hash_symbolized.should == Yajl::HttpStream.get(@uri, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.get(@uri, :symbolize_keys => true))
   end
 
   it "should parse a raw response using instance method" do
     prepare_mock_request_dump :raw
-    @uri.should_receive(:host)
-    @uri.should_receive(:port)
+    expect(@uri).to receive(:host)
+    expect(@uri).to receive(:port)
     stream = Yajl::HttpStream.new
-    @template_hash.should == stream.get(@uri)
+    expect(@template_hash).to eq(stream.get(@uri))
   end
 
   it "should parse a chunked response using instance method" do
     prepare_mock_request_dump :chunked
-    @uri.should_receive(:host)
-    @uri.should_receive(:port)
+    expect(@uri).to receive(:host)
+    expect(@uri).to receive(:port)
     stream = Yajl::HttpStream.new
     stream.get(@uri) do |obj|
-      obj.should eql(@chunked_body)
+      expect(obj).to eql(@chunked_body)
     end
   end
 
   if defined?(Yajl::Bzip2::StreamReader)
     it "should parse a bzip2 compressed response" do
       prepare_mock_request_dump :bzip2
-      @template_hash.should == Yajl::HttpStream.get(@uri)
+      expect(@template_hash).to eq(Yajl::HttpStream.get(@uri))
     end
 
     it "should parse a bzip2 compressed response and symbolize keys" do
       prepare_mock_request_dump :bzip2
-      @template_hash_symbolized.should == Yajl::HttpStream.get(@uri, :symbolize_keys => true)
+      expect(@template_hash_symbolized).to eq(Yajl::HttpStream.get(@uri, :symbolize_keys => true))
     end
   end
 
   it "should parse a deflate compressed response" do
     prepare_mock_request_dump :deflate
-    @template_hash.should == Yajl::HttpStream.get(@uri)
+    expect(@template_hash).to eq(Yajl::HttpStream.get(@uri))
   end
 
   it "should parse a deflate compressed response and symbolize keys" do
     prepare_mock_request_dump :deflate
-    @template_hash_symbolized.should == Yajl::HttpStream.get(@uri, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.get(@uri, :symbolize_keys => true))
   end
 
   it "should parse a gzip compressed response" do
     prepare_mock_request_dump :gzip
-    @template_hash.should == Yajl::HttpStream.get(@uri)
+    expect(@template_hash).to eq(Yajl::HttpStream.get(@uri))
   end
 
   it "should parse a gzip compressed response and symbolize keys" do
     prepare_mock_request_dump :gzip
-    @template_hash_symbolized.should == Yajl::HttpStream.get(@uri, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.get(@uri, :symbolize_keys => true))
   end
 
   it "should raise when an HTTP code that isn't 200 is returned" do
     prepare_mock_request_dump :error
-    lambda { Yajl::HttpStream.get(@uri) }.should raise_exception(Yajl::HttpStream::HttpError)
+    expect { Yajl::HttpStream.get(@uri) }.to raise_exception(Yajl::HttpStream::HttpError)
   end
 end

data/spec/http/http_post_spec.rb

@@ -40,84 +40,84 @@ describe "Yajl HTTP POST request" do
   def prepare_mock_request_dump(format=:raw)
     @request = File.new(File.expand_path(File.dirname(__FILE__) + "/fixtures/http.#{format}.dump"), 'r')
     @uri = 'file://'+File.expand_path(File.dirname(__FILE__) + "/fixtures/http/http.#{format}.dump")
-    TCPSocket.should_receive(:new).and_return(@request)
-    @request.should_receive(:write)
+    expect(TCPSocket).to receive(:new).and_return(@request)
+    expect(@request).to receive(:write)
   end
 
   it "should parse a raw response" do
     prepare_mock_request_dump :raw
-    @template_hash.should == Yajl::HttpStream.post(@uri, @body)
+    expect(@template_hash).to eq(Yajl::HttpStream.post(@uri, @body))
   end
 
   it "should parse a raw response using instance method" do
     prepare_mock_request_dump :raw
-    @uri.should_receive(:host)
-    @uri.should_receive(:port)
+    expect(@uri).to receive(:host)
+    expect(@uri).to receive(:port)
     stream = Yajl::HttpStream.new
-    @template_hash.should == stream.post(@uri, @body)
+    expect(@template_hash).to eq(stream.post(@uri, @body))
   end
 
   it "should parse a raw response with hashed body" do
     prepare_mock_request_dump :raw
-    @template_hash.should == Yajl::HttpStream.post(@uri, @hashed_body)
+    expect(@template_hash).to eq(Yajl::HttpStream.post(@uri, @hashed_body))
   end
 
   it "should parse a raw response and symbolize keys" do
     prepare_mock_request_dump :raw
-    @template_hash_symbolized.should == Yajl::HttpStream.post(@uri, @body, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.post(@uri, @body, :symbolize_keys => true))
   end
 
   if defined?(Yajl::Bzip2::StreamReader)
     it "should parse a bzip2 compressed response" do
       prepare_mock_request_dump :bzip2
-      @template_hash.should == Yajl::HttpStream.post(@uri, @body)
+      expect(@template_hash).to eq(Yajl::HttpStream.post(@uri, @body))
     end
 
     it "should parse a bzip2 compressed response and symbolize keys" do
       prepare_mock_request_dump :bzip2
-      @template_hash_symbolized.should == Yajl::HttpStream.post(@uri, @body, :symbolize_keys => true)
+      expect(@template_hash_symbolized).to eq(Yajl::HttpStream.post(@uri, @body, :symbolize_keys => true))
     end
   end
 
   it "should parse a deflate compressed response" do
     prepare_mock_request_dump :deflate
-    @template_hash.should == Yajl::HttpStream.post(@uri, @body)
+    expect(@template_hash).to eq(Yajl::HttpStream.post(@uri, @body))
   end
 
   it "should parse a deflate compressed response and symbolize keys" do
     prepare_mock_request_dump :deflate
-    @template_hash_symbolized.should == Yajl::HttpStream.post(@uri, @body, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.post(@uri, @body, :symbolize_keys => true))
   end
 
   it "should parse a gzip compressed response" do
     prepare_mock_request_dump :gzip
-    @template_hash.should == Yajl::HttpStream.post(@uri, @body)
+    expect(@template_hash).to eq(Yajl::HttpStream.post(@uri, @body))
   end
 
   it "should parse a gzip compressed response and symbolize keys" do
     prepare_mock_request_dump :gzip
-    @template_hash_symbolized.should == Yajl::HttpStream.post(@uri, @body, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.post(@uri, @body, :symbolize_keys => true))
   end
 
   it "should parse a chunked raw response" do
     prepare_mock_request_dump :chunked
     Yajl::HttpStream.post(@uri, @body) do |obj|
-      obj.should eql(@chunked_body)
+      expect(obj).to eql(@chunked_body)
     end
   end
 
   it "should throw Exception if chunked response and no block given" do
     prepare_mock_request_dump :chunked
-    lambda {Yajl::HttpStream.post(@uri, @body)}.should raise_error(Exception)
+    expect {Yajl::HttpStream.post(@uri, @body)}.to raise_error(Exception)
   end
 
   it "should throw InvalidContentType if unable to handle the MIME type" do
     prepare_mock_request_dump :html
-    lambda {Yajl::HttpStream.post(@uri, @body)}.should raise_error(Yajl::HttpStream::InvalidContentType)
+    expect {Yajl::HttpStream.post(@uri, @body)}.to raise_error(Yajl::HttpStream::InvalidContentType)
   end
 
   it "should raise when an HTTP code that isn't 200 is returned" do
     prepare_mock_request_dump :error
-    lambda { Yajl::HttpStream.post(@uri, @body) }.should raise_exception(Yajl::HttpStream::HttpError)
+    expect { Yajl::HttpStream.post(@uri, @body) }.to raise_exception(Yajl::HttpStream::HttpError)
   end
-end
+end

data/spec/http/http_put_spec.rb

@@ -39,67 +39,67 @@ describe "Yajl HTTP PUT request" do
   def prepare_mock_request_dump(format=:raw)
     @request = File.new(File.expand_path(File.dirname(__FILE__) + "/fixtures/http.#{format}.dump"), 'r')
     @uri = 'file://'+File.expand_path(File.dirname(__FILE__) + "/fixtures/http/http.#{format}.dump")
-    TCPSocket.should_receive(:new).and_return(@request)
-    @request.should_receive(:write)
+    expect(TCPSocket).to receive(:new).and_return(@request)
+    expect(@request).to receive(:write)
   end
 
   it "should parse a raw response" do
     prepare_mock_request_dump :raw
-    @template_hash.should == Yajl::HttpStream.put(@uri, @body)
+    expect(@template_hash).to eq(Yajl::HttpStream.put(@uri, @body))
   end
 
   it "should parse a raw response using instance method" do
     prepare_mock_request_dump :raw
-    @uri.should_receive(:host)
-    @uri.should_receive(:port)
+    expect(@uri).to receive(:host)
+    expect(@uri).to receive(:port)
     stream = Yajl::HttpStream.new
-    @template_hash.should == stream.put(@uri, @body)
+    expect(@template_hash).to eq(stream.put(@uri, @body))
   end
 
   it "should parse a raw response with hashed body" do
     prepare_mock_request_dump :raw
-    @template_hash.should == Yajl::HttpStream.post(@uri, @hashed_body)
+    expect(@template_hash).to eq(Yajl::HttpStream.post(@uri, @hashed_body))
   end
 
   it "should parse a raw response and symbolize keys" do
     prepare_mock_request_dump :raw
-    @template_hash_symbolized.should == Yajl::HttpStream.put(@uri, @body, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.put(@uri, @body, :symbolize_keys => true))
   end
 
   if defined?(Yajl::Bzip2::StreamReader)
     it "should parse a bzip2 compressed response" do
       prepare_mock_request_dump :bzip2
-      @template_hash.should == Yajl::HttpStream.put(@uri, @body)
+      expect(@template_hash).to eq(Yajl::HttpStream.put(@uri, @body))
     end
 
     it "should parse a bzip2 compressed response and symbolize keys" do
       prepare_mock_request_dump :bzip2
-      @template_hash_symbolized.should == Yajl::HttpStream.put(@uri, @body, :symbolize_keys => true)
+      expect(@template_hash_symbolized).to eq(Yajl::HttpStream.put(@uri, @body, :symbolize_keys => true))
     end
   end
 
   it "should parse a deflate compressed response" do
     prepare_mock_request_dump :deflate
-    @template_hash.should == Yajl::HttpStream.put(@uri, @body)
+    expect(@template_hash).to eq(Yajl::HttpStream.put(@uri, @body))
   end
 
   it "should parse a deflate compressed response and symbolize keys" do
     prepare_mock_request_dump :deflate
-    @template_hash_symbolized.should == Yajl::HttpStream.put(@uri, @body, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.put(@uri, @body, :symbolize_keys => true))
   end
 
   it "should parse a gzip compressed response" do
     prepare_mock_request_dump :gzip
-    @template_hash.should == Yajl::HttpStream.put(@uri, @body)
+    expect(@template_hash).to eq(Yajl::HttpStream.put(@uri, @body))
   end
 
   it "should parse a gzip compressed response and symbolize keys" do
     prepare_mock_request_dump :gzip
-    @template_hash_symbolized.should == Yajl::HttpStream.put(@uri, @body, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.put(@uri, @body, :symbolize_keys => true))
   end
 
   it "should raise when an HTTP code that isn't 200 is returned" do
     prepare_mock_request_dump :error
-    lambda { Yajl::HttpStream.put(@uri, @body) }.should raise_exception(Yajl::HttpStream::HttpError)
+    expect { Yajl::HttpStream.put(@uri, @body) }.to raise_exception(Yajl::HttpStream::HttpError)
   end
-end
+end

data/spec/http/http_stream_options_spec.rb

@@ -8,20 +8,20 @@ describe "Passing options to HttpStream instance methods" do
   end
 
   it "should not create a new socket it one is provided" do
-    TCPSocket.should_not_receive(:new)
+    expect(TCPSocket).not_to receive(:new)
     options = {:socket => :my_provided_socket}
 
     @stream.send(:initialize_socket, URI.parse("http://google.com"), options)
 
-    options[:socket].should == :my_provided_socket
+    expect(options[:socket]).to eq(:my_provided_socket)
   end
 
   it "should create a new socket if one is not provided" do
-    TCPSocket.should_receive(:new).with("google.com", 80).and_return( :tcp_socket )
+    expect(TCPSocket).to receive(:new).with("google.com", 80).and_return( :tcp_socket )
     options = {}
 
     @stream.send(:initialize_socket, URI.parse("http://google.com"), options)
 
-    options[:socket].should == :tcp_socket
+    expect(options[:socket]).to eq(:tcp_socket)
   end
 end

data/spec/json_gem_compatibility/compatibility_spec.rb

@@ -7,109 +7,109 @@ describe "JSON Gem compatability API" do
   it "shoud not mixin #to_json on base objects until compatability has been enabled" do
     d = Dummy.new
 
-    d.respond_to?(:to_json).should_not be_true
-    "".respond_to?(:to_json).should_not be_true
-    1.respond_to?(:to_json).should_not be_true
-    "1.5".to_f.respond_to?(:to_json).should_not be_true
-    [].respond_to?(:to_json).should_not be_true
-    {:foo => "bar"}.respond_to?(:to_json).should_not be_true
-    true.respond_to?(:to_json).should_not be_true
-    false.respond_to?(:to_json).should_not be_true
-    nil.respond_to?(:to_json).should_not be_true
+    expect(d.respond_to?(:to_json)).not_to be_truthy
+    expect("".respond_to?(:to_json)).not_to be_truthy
+    expect(1.respond_to?(:to_json)).not_to be_truthy
+    expect("1.5".to_f.respond_to?(:to_json)).not_to be_truthy
+    expect([].respond_to?(:to_json)).not_to be_truthy
+    expect({:foo => "bar"}.respond_to?(:to_json)).not_to be_truthy
+    expect(true.respond_to?(:to_json)).not_to be_truthy
+    expect(false.respond_to?(:to_json)).not_to be_truthy
+    expect(nil.respond_to?(:to_json)).not_to be_truthy
   end
 
   it "should mixin #to_json on base objects after compatability has been enabled" do
     require 'yajl/json_gem'
     d = Dummy.new
 
-    d.respond_to?(:to_json).should be_true
-    "".respond_to?(:to_json).should be_true
-    1.respond_to?(:to_json).should be_true
-    "1.5".to_f.respond_to?(:to_json).should be_true
-    [].respond_to?(:to_json).should be_true
-    {:foo => "bar"}.respond_to?(:to_json).should be_true
-    true.respond_to?(:to_json).should be_true
-    false.respond_to?(:to_json).should be_true
-    nil.respond_to?(:to_json).should be_true
+    expect(d.respond_to?(:to_json)).to be_truthy
+    expect("".respond_to?(:to_json)).to be_truthy
+    expect(1.respond_to?(:to_json)).to be_truthy
+    expect("1.5".to_f.respond_to?(:to_json)).to be_truthy
+    expect([].respond_to?(:to_json)).to be_truthy
+    expect({:foo => "bar"}.respond_to?(:to_json)).to be_truthy
+    expect(true.respond_to?(:to_json)).to be_truthy
+    expect(false.respond_to?(:to_json)).to be_truthy
+    expect(nil.respond_to?(:to_json)).to be_truthy
   end
 
   it "should require yajl/json_gem to enable the compatability API" do
-    defined?(JSON).should be_true
+    expect(defined?(JSON)).to be_truthy
 
-    JSON.respond_to?(:parse).should be_true
-    JSON.respond_to?(:generate).should be_true
-    JSON.respond_to?(:pretty_generate).should be_true
-    JSON.respond_to?(:load).should be_true
-    JSON.respond_to?(:dump).should be_true
+    expect(JSON.respond_to?(:parse)).to be_truthy
+    expect(JSON.respond_to?(:generate)).to be_truthy
+    expect(JSON.respond_to?(:pretty_generate)).to be_truthy
+    expect(JSON.respond_to?(:load)).to be_truthy
+    expect(JSON.respond_to?(:dump)).to be_truthy
   end
 
   it "should allow default parsing options be set with JSON.default_options" do
     default = JSON.default_options[:symbolize_keys]
-    JSON.parse('{"foo": 1234}').should === {"foo" => 1234}
+    expect(JSON.parse('{"foo": 1234}')).to be === {"foo" => 1234}
     JSON.default_options[:symbolize_keys] = true
-    JSON.parse('{"foo": 1234}').should === {:foo => 1234}
+    expect(JSON.parse('{"foo": 1234}')).to be === {:foo => 1234}
     JSON.default_options[:symbolize_keys] = default # ensure the rest of the test cases expect the default
   end
 
   it "should also allow the json gem's symbolize_names key" do
-    JSON.parse('{"foo": 1234}', :symbolize_names => true).should === {:foo => 1234}
+    expect(JSON.parse('{"foo": 1234}', :symbolize_names => true)).to be === {:foo => 1234}
   end
 
   it "should encode arbitrary classes via their default to_json method" do
     d = Dummy.new
-    d.to_json.should == "\"#{d.to_s}\""
+    expect(d.to_json).to eq("\"#{d.to_s}\"")
 
     t = Time.now
-    t.to_json.should == "\"#{t.to_s}\""
+    expect(t.to_json).to eq("\"#{t.to_s}\"")
 
     da = Date.today
-    da.to_json.should == "\"#{da.to_s}\""
+    expect(da.to_json).to eq("\"#{da.to_s}\"")
 
     dt = DateTime.new
-    dt.to_json.should == "\"#{dt.to_s}\""
+    expect(dt.to_json).to eq("\"#{dt.to_s}\"")
   end
 
   it "should have the standard parsing and encoding exceptions mapped" do
-    JSON::JSONError.new.is_a?(StandardError).should be_true
-    JSON::ParserError.new.is_a?(JSON::JSONError).should be_true
-    JSON::GeneratorError.new.is_a?(JSON::JSONError).should be_true
+    expect(JSON::JSONError.new.is_a?(StandardError)).to be_truthy
+    expect(JSON::ParserError.new.is_a?(JSON::JSONError)).to be_truthy
+    expect(JSON::GeneratorError.new.is_a?(JSON::JSONError)).to be_truthy
 
-    lambda {
+    expect {
       JSON.parse("blah")
-    }.should raise_error(JSON::ParserError)
+    }.to raise_error(JSON::ParserError)
 
-    lambda {
+    expect {
       JSON.generate(0.0/0.0)
-    }.should raise_error(JSON::GeneratorError)
+    }.to raise_error(JSON::GeneratorError)
   end
 
   context "ported tests for Unicode" do
     it "should be able to encode and parse unicode" do
-      '""'.should eql(''.to_json)
-      '"\\b"'.should eql("\b".to_json)
-      '"\u0001"'.should eql(0x1.chr.to_json)
-      '"\u001F"'.should eql(0x1f.chr.to_json)
-      '" "'.should eql(' '.to_json)
-      "\"#{0x7f.chr}\"".should eql(0x7f.chr.to_json)
+      expect('""').to eql(''.to_json)
+      expect('"\\b"').to eql("\b".to_json)
+      expect('"\u0001"').to eql(0x1.chr.to_json)
+      expect('"\u001F"').to eql(0x1f.chr.to_json)
+      expect('" "').to eql(' '.to_json)
+      expect("\"#{0x7f.chr}\"").to eql(0x7f.chr.to_json)
       utf8 = [ "© ≠ €! \01" ]
       json = "[\"© ≠ €! \\u0001\"]"
-      json.should eql(utf8.to_json)
-      utf8.should eql(JSON.parse(json))
+      expect(json).to eql(utf8.to_json)
+      expect(utf8).to eql(JSON.parse(json))
       utf8 = ["\343\201\202\343\201\204\343\201\206\343\201\210\343\201\212"]
       json = "[\"あいうえお\"]"
-      json.should eql(utf8.to_json)
-      utf8.should eql(JSON.parse(json))
+      expect(json).to eql(utf8.to_json)
+      expect(utf8).to eql(JSON.parse(json))
       utf8 = ['საქართველო']
       json = "[\"საქართველო\"]"
-      json.should eql(utf8.to_json)
-      utf8.should eql(JSON.parse(json))
-      '["Ã"]'.should eql(JSON.generate(["Ã"]))
-      ["€"].should eql(JSON.parse('["\u20ac"]'))
+      expect(json).to eql(utf8.to_json)
+      expect(utf8).to eql(JSON.parse(json))
+      expect('["Ã"]').to eql(JSON.generate(["Ã"]))
+      expect(["€"]).to eql(JSON.parse('["\u20ac"]'))
       utf8_str = "\xf0\xa0\x80\x81"
       utf8 = [utf8_str]
       json = "[\"#{utf8_str}\"]"
-      json.should eql(JSON.generate(utf8))
-      utf8.should eql(JSON.parse(json))
+      expect(json).to eql(JSON.generate(utf8))
+      expect(utf8).to eql(JSON.parse(json))
     end
   end
 
@@ -144,25 +144,25 @@ describe "JSON Gem compatability API" do
 
     it "should be able to unparse" do
       json = JSON.generate(@hash)
-      JSON.parse(@json2).should == JSON.parse(json)
+      expect(JSON.parse(@json2)).to eq(JSON.parse(json))
       parsed_json = JSON.parse(json)
-      @hash.should == parsed_json
+      expect(@hash).to eq(parsed_json)
       json = JSON.generate({1=>2})
-      '{"1":2}'.should eql(json)
+      expect('{"1":2}').to eql(json)
       parsed_json = JSON.parse(json)
-      {"1"=>2}.should == parsed_json
+      expect({"1"=>2}).to eq(parsed_json)
     end
 
     it "should be able to unparse pretty" do
       json = JSON.pretty_generate(@hash)
-      JSON.parse(@json3).should == JSON.parse(json)
+      expect(JSON.parse(@json3)).to eq(JSON.parse(json))
       parsed_json = JSON.parse(json)
-      @hash.should == parsed_json
+      expect(@hash).to eq(parsed_json)
       json = JSON.pretty_generate({1=>2})
       test = "{\n  \"1\": 2\n}".chomp
-      test.should == json
+      expect(test).to eq(json)
       parsed_json = JSON.parse(json)
-      {"1"=>2}.should == parsed_json
+      expect({"1"=>2}).to eq(parsed_json)
     end
   end
 
@@ -174,33 +174,33 @@ describe "JSON Gem compatability API" do
 
     JSON_FAILED.each do |name, source|
       it "should not be able to parse #{File.basename(name)} as an IO" do
-          lambda {
+          expect {
             JSON.parse(StringIO.new(source))
-          }.should raise_error(JSON::ParserError)
+          }.to raise_error(JSON::ParserError)
       end
     end
 
     JSON_FAILED.each do |name, source|
       it "should not be able to parse #{File.basename(name)} as a string" do
-          lambda {
+          expect {
             JSON.parse(source)
-          }.should raise_error(JSON::ParserError)
+          }.to raise_error(JSON::ParserError)
       end
     end
 
     JSON_PASSED.each do |name, source|
       it "should be able to parse #{File.basename(name)} as an IO" do
-          lambda {
+          expect {
             JSON.parse(StringIO.new(source))
-          }.should_not raise_error
+          }.not_to raise_error
       end
     end
 
     JSON_PASSED.each do |name, source|
       it "should be able to parse #{File.basename(name)} as a string" do
-          lambda {
+          expect {
             JSON.parse(source)
-          }.should_not raise_error
+          }.not_to raise_error
       end
     end
   end

data/spec/parsing/active_support_spec.rb

@@ -36,29 +36,29 @@ describe "ActiveSupport test cases" do
 
   TESTS.each do |json, expected|
     it "should be able to parse #{json} as an IO" do
-      lambda {
-        Yajl::Parser.parse(StringIO.new(json)).should == expected
-      }.should_not raise_error
+      expect {
+        expect(Yajl::Parser.parse(StringIO.new(json))).to eq(expected)
+      }.not_to raise_error
     end
   end
 
   TESTS.each do |json, expected|
     it "should be able to parse #{json} as a string" do
-      lambda {
-        Yajl::Parser.parse(json).should == expected
-      }.should_not raise_error
+      expect {
+        expect(Yajl::Parser.parse(json)).to eq(expected)
+      }.not_to raise_error
     end
   end
 
   it "should fail parsing {: 1} as an IO" do
-    lambda {
+    expect {
       Yajl::Parser.parse(StringIO.new("{: 1}"))
-    }.should raise_error(Yajl::ParseError)
+    }.to raise_error(Yajl::ParseError)
   end
 
   it "should fail parsing {: 1} as a string" do
-    lambda {
+    expect {
       Yajl::Parser.parse("{: 1}")
-    }.should raise_error(Yajl::ParseError)
+    }.to raise_error(Yajl::ParseError)
   end
 end