yajl-ruby 1.2.3 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 96b69dbb79f06c9b9167f6a46db45696ceffcba0
-  data.tar.gz: 2d1114946f2aead4371317dac549a662698f66a8
+  metadata.gz: 2211f169082b89b1385a841f79d445cd559b405c
+  data.tar.gz: 9074ca9bab2acf80a0a7069f2a608ee958b2eea8
 SHA512:
-  metadata.gz: be6ae35da914550194edccd71507555b97973592dbb7155f34182d08fcac4a75450eda8cabb083c67d4e6daaee6ba3c0198da6fc3aa854ed54098bc5514a3ff4
-  data.tar.gz: 49a24d166c2adc2aa938bd3c91b3440e02e7bfaa6f9e30cd0c745c17afc6be906721391241f08d6612d3a3044d3bc4b5b1105bddfe42547430a39c2e74829814
+  metadata.gz: 20f296b807da6097dec709b153364def6cae62187223e64027871103261800e8edda82d5d2bfe96a9dbfb3e29a6b84f56e39c09b45d3bafd423335e86aa52186
+  data.tar.gz: 89bee3f6029488f771d15a4ebc9e910a8c1ca7d276ef5ad001bb118e7754397bfb4a4065cf5a8b8cc5edffe222bdb669742b6cbe9c6572d3656b3d683393c2b8

data/.codeclimate.yml

@@ -0,0 +1,40 @@
+# This is a sample .codeclimate.yml configured for Engine analysis on Code
+# Climate Platform. For an overview of the Code Climate Platform, see here:
+# http://docs.codeclimate.com/article/300-the-codeclimate-platform
+
+# Under the engines key, you can configure which engines will analyze your repo.
+# Each key is an engine name. For each value, you need to specify enabled: true
+# to enable the engine as well as any other engines-specific configuration.
+
+# For more details, see here:
+# http://docs.codeclimate.com/article/289-configuring-your-repository-via-codeclimate-yml#platform
+
+# For a list of all available engines, see here:
+# http://docs.codeclimate.com/article/296-engines-available-engines
+
+engines:
+# to turn on an engine, add it here and set enabled to `true`
+# to turn off an engine, set enabled to `false` or remove it
+  rubocop:
+    enabled: true
+
+# Engines can analyze files and report issues on them, but you can separately
+# decide which files will receive ratings based on those issues. This is
+# specified by path patterns under the ratings key.
+
+# For more details see here:
+# http://docs.codeclimate.com/article/289-configuring-your-repository-via-codeclimate-yml#platform
+
+# Note: If the ratings key is not specified, this will result in a 0.0 GPA on your dashboard.
+
+ratings:
+  paths:
+  - ext/**
+  - lib/**
+
+# You can globally exclude files from being analyzed by any engine using the
+# exclude_paths key.
+
+#exclude_paths:
+#- spec/**/*
+#- vendor/**/*

data/.travis.yml

@@ -1,18 +1,9 @@
 language: ruby
 rvm:
-  - 1.8.7
-  - 1.9.2
-  - 1.9.3
   - 2.0.0
-  - 2.1.0
-  - 2.1.1
-  - ree
+  - 2.1
+  - 2.2
+  - 2.3
+  - 2.4.1
   - ruby-head
-  - rbx-18mode
-  - rbx-19mode
 before_install: gem install bundler --no-document
-matrix:
-  allow_failures:
-    - rvm: rbx
-    - rvm: rbx-18mode
-    - rvm: rbx-19mode

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Brian Lopez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/examples/encoding/chunked_encoding.rb

@@ -24,4 +24,4 @@ Yajl::Encoder.encode(obj) do |chunk|
   STDOUT << chunk
 end
 
-puts "\n\nEncoder generated #{total_size} bytes of data, in #{chunks} chunks"
+puts "\n\nEncoder generated #{total_size} bytes of data, in #{chunks} chunks"

data/examples/encoding/one_shot.rb

@@ -10,4 +10,4 @@ obj = {
 }
 
 str = Yajl::Encoder.encode(obj)
-puts str
+puts str

data/examples/encoding/to_an_io.rb

@@ -9,4 +9,4 @@ obj = {
   :as_easy_as => 123
 }
 
-Yajl::Encoder.encode(obj, STDOUT)
+Yajl::Encoder.encode(obj, STDOUT)

data/examples/http/twitter_search_api.rb

@@ -9,4 +9,4 @@ unless keywords = ARGV[0]
   exit(0)
 end
 
-puts Yajl::HttpStream.get("http://search.twitter.com/search.json?q=#{keywords}").inspect
+puts Yajl::HttpStream.get("http://search.twitter.com/search.json?q=#{keywords}").inspect

data/examples/http/twitter_stream_api.rb

@@ -23,4 +23,4 @@ Yajl::HttpStream.get(uri, :symbolize_keys => true) do |hash|
   STDOUT.putc '.'
   STDOUT.flush
   captured += 1
-end
+end

data/examples/parsing/from_file.rb

@@ -11,4 +11,4 @@ end
 json = File.new(file, 'r')
 
 hash = Yajl::Parser.parse(json)
-puts hash.inspect
+puts hash.inspect

data/examples/parsing/from_stdin.rb

@@ -6,4 +6,4 @@ require 'yajl'
 # Usage: cat benchmark/subjects/item.json | ruby examples/from_stdin.rb
 
 hash = Yajl::Parser.parse(STDIN)
-puts hash.inspect
+puts hash.inspect

data/examples/parsing/from_string.rb

@@ -10,4 +10,4 @@ unless string = ARGV[0]
 end
 
 hash = Yajl::Parser.parse(string)
-puts hash.inspect
+puts hash.inspect

data/lib/yajl/bzip2.rb

@@ -6,6 +6,6 @@ begin
   require 'bzip2' unless defined?(Bzip2)
   require 'yajl/bzip2/stream_reader.rb'
   require 'yajl/bzip2/stream_writer.rb'
-rescue LoadError => e
+rescue LoadError
   raise "Unable to load the bzip2 library. Is the bzip2-ruby gem installed?"
-end
+end

data/lib/yajl/http_stream.rb

@@ -4,6 +4,7 @@ require 'socket'
 require 'yajl'
 require 'yajl/version' unless defined? Yajl::VERSION
 require 'uri'
+require 'cgi'
 
 module Yajl
   # This module is for making HTTP requests to which the response bodies (and possibly requests in the near future)
@@ -101,7 +102,7 @@ module Yajl
           default_headers["Content-Type"] = opts["Content-Type"] || "application/x-www-form-urlencoded"
           body = opts.delete(:body)
           if body.is_a?(Hash)
-            body = body.keys.collect {|param| "#{URI.escape(param.to_s)}=#{URI.escape(body[param].to_s)}"}.join('&')
+            body = body.keys.collect {|param| "#{CGI.escape(param.to_s)}=#{CGI.escape(body[param].to_s)}"}.join('&')
           end
           default_headers["Content-Length"] = body.length
         end
@@ -161,7 +162,7 @@ module Yajl
           if block_given?
             chunkLeft = 0
             while !socket.eof? && (line = socket.gets)
-              break if line.match /^0.*?\r\n/
+              break if line.match(/^0.*?\r\n/)
               next if line == "\r\n"
               size = line.hex
               json = socket.read(size)

data/lib/yajl/version.rb

@@ -1,3 +1,3 @@
 module Yajl
-  VERSION = '1.2.3'
+  VERSION = '1.3.1'
 end

data/lib/yajl.rb

@@ -1,7 +1,7 @@
 require 'yajl/yajl'
 
 # = Extras
-# We're not going to load these auotmatically, because you might not need them ;)
+# We're not going to load these automatically, because you might not need them ;)
 #
 # require 'yajl/http_stream.rb' unless defined?(Yajl::HttpStream)
 # require 'yajl/gzip.rb' unless defined?(Yajl::Gzip)
@@ -73,4 +73,4 @@ module Yajl
       new(options).encode(obj, io, &block)
     end
   end
-end
+end

data/spec/encoding/encoding_spec.rb

@@ -37,7 +37,7 @@ describe "Yajl JSON encoder" do
          hash2 = Yajl::Parser.parse(io)
          io.close
          input.close
-         hash.should == hash2
+         expect(hash).to eq(hash2)
        end
      end
    end
@@ -58,7 +58,7 @@ describe "Yajl JSON encoder" do
                Yajl::Parser.parse(reader.read)
             end
          end
-         hash.should == hash2
+         expect(hash).to eq(hash2)
       end
      end
    end
@@ -73,7 +73,7 @@ describe "Yajl JSON encoder" do
          output = encoder.encode(hash)
          hash2 = Yajl::Parser.parse(output)
          input.close
-         hash.should == hash2
+         expect(hash).to eq(hash2)
        end
      end
    end
@@ -91,7 +91,7 @@ describe "Yajl JSON encoder" do
          end
          hash2 = Yajl::Parser.parse(output)
          input.close
-         hash.should == hash2
+         expect(hash).to eq(hash2)
        end
      end
    end
@@ -103,7 +103,7 @@ describe "Yajl JSON encoder" do
     encoder = Yajl::Encoder.new(:pretty => true, :indent => ' ')
     encoder.encode(obj, io)
     io.rewind
-    io.read.should == output
+    expect(io.read).to eq(output)
   end
 
   it "should encode with :pretty turned on and a single space indent, and return a String" do
@@ -111,7 +111,7 @@ describe "Yajl JSON encoder" do
     obj = {:foo => 1234}
     encoder = Yajl::Encoder.new(:pretty => true, :indent => ' ')
     output = encoder.encode(obj)
-    output.should == output
+    expect(output).to eq(output)
   end
 
   it "should encode with :pretty turned on and a tab character indent, to an IO" do
@@ -121,7 +121,7 @@ describe "Yajl JSON encoder" do
     encoder = Yajl::Encoder.new(:pretty => true, :indent => "\t")
     encoder.encode(obj, io)
     io.rewind
-    io.read.should == output
+    expect(io.read).to eq(output)
   end
 
   it "should encode with :pretty turned on and a tab character indent, and return a String" do
@@ -129,7 +129,7 @@ describe "Yajl JSON encoder" do
     obj = {:foo => 1234}
     encoder = Yajl::Encoder.new(:pretty => true, :indent => "\t")
     output = encoder.encode(obj)
-    output.should == output
+    expect(output).to eq(output)
   end
 
   it "should encode with it's class method with :pretty and a tab character indent options set, to an IO" do
@@ -138,14 +138,14 @@ describe "Yajl JSON encoder" do
     io = StringIO.new
     Yajl::Encoder.encode(obj, io, :pretty => true, :indent => "\t")
     io.rewind
-    io.read.should == output
+    expect(io.read).to eq(output)
   end
 
   it "should encode with it's class method with :pretty and a tab character indent options set, and return a String" do
     output = "{\n\t\"foo\": 1234\n}"
     obj = {:foo => 1234}
     output = Yajl::Encoder.encode(obj, :pretty => true, :indent => "\t")
-    output.should == output
+    expect(output).to eq(output)
   end
 
   it "should encode with it's class method with :pretty and a tab character indent options set, to a block" do
@@ -155,7 +155,7 @@ describe "Yajl JSON encoder" do
     Yajl::Encoder.encode(obj, :pretty => true, :indent => "\t") do |json_str|
       output = json_str
     end
-    output.should == output
+    expect(output).to eq(output)
   end
 
   it "should encode multiple objects into a single stream, to an IO" do
@@ -167,7 +167,7 @@ describe "Yajl JSON encoder" do
     end
     io.rewind
     output = "{\"foo\":1234}{\"foo\":1234}{\"foo\":1234}{\"foo\":1234}{\"foo\":1234}"
-    io.read.should == output
+    expect(io.read).to eq(output)
   end
 
   it "should encode multiple objects into a single stream, and return a String" do
@@ -178,37 +178,37 @@ describe "Yajl JSON encoder" do
       json_output << encoder.encode(obj)
     end
     output = "{\"foo\":1234}{\"foo\":1234}{\"foo\":1234}{\"foo\":1234}{\"foo\":1234}"
-    json_output.should == output
+    expect(json_output).to eq(output)
   end
 
   it "should encode all map keys as strings" do
-    Yajl::Encoder.encode({1=>1}).should eql("{\"1\":1}")
+    expect(Yajl::Encoder.encode({1=>1})).to eql("{\"1\":1}")
   end
 
   it "should check for and call #to_json if it exists on custom objects" do
     d = Dummy2.new
-    Yajl::Encoder.encode({:foo => d}).should eql('{"foo":{"hawtness":true}}')
+    expect(Yajl::Encoder.encode({:foo => d})).to eql('{"foo":{"hawtness":true}}')
   end
 
   it "should encode a hash where the key and value can be symbols" do
-    Yajl::Encoder.encode({:foo => :bar}).should eql('{"foo":"bar"}')
+    expect(Yajl::Encoder.encode({:foo => :bar})).to eql('{"foo":"bar"}')
   end
 
   it "should encode using a newline or nil terminator" do
-    Yajl::Encoder.new(:terminator => "\n").encode({:foo => :bar}).should eql("{\"foo\":\"bar\"}\n")
-    Yajl::Encoder.new(:terminator => nil).encode({:foo => :bar}).should eql("{\"foo\":\"bar\"}")
+    expect(Yajl::Encoder.new(:terminator => "\n").encode({:foo => :bar})).to eql("{\"foo\":\"bar\"}\n")
+    expect(Yajl::Encoder.new(:terminator => nil).encode({:foo => :bar})).to eql("{\"foo\":\"bar\"}")
   end
 
   it "should encode using a newline or nil terminator, to an IO" do
     s = StringIO.new
     Yajl::Encoder.new(:terminator => "\n").encode({:foo => :bar}, s)
     s.rewind
-    s.read.should eql("{\"foo\":\"bar\"}\n")
+    expect(s.read).to eql("{\"foo\":\"bar\"}\n")
 
     s = StringIO.new
     Yajl::Encoder.new(:terminator => nil).encode({:foo => :bar}, s)
     s.rewind
-    s.read.should eql("{\"foo\":\"bar\"}")
+    expect(s.read).to eql("{\"foo\":\"bar\"}")
   end
 
   it "should encode using a newline or nil terminator, using a block" do
@@ -217,7 +217,7 @@ describe "Yajl JSON encoder" do
       s << chunk
     end
     s.rewind
-    s.read.should eql("{\"foo\":\"bar\"}\n")
+    expect(s.read).to eql("{\"foo\":\"bar\"}\n")
 
     s = StringIO.new
     nilpassed = false
@@ -225,45 +225,45 @@ describe "Yajl JSON encoder" do
       nilpassed = true if chunk.nil?
       s << chunk
     end
-    nilpassed.should be_true
+    expect(nilpassed).to be_truthy
     s.rewind
-    s.read.should eql("{\"foo\":\"bar\"}")
+    expect(s.read).to eql("{\"foo\":\"bar\"}")
   end
 
   it "should not encode NaN" do
-    lambda {
+    expect {
       Yajl::Encoder.encode(0.0/0.0)
-    }.should raise_error(Yajl::EncodeError)
+    }.to raise_error(Yajl::EncodeError)
   end
 
   it "should not encode Infinity or -Infinity" do
-    lambda {
+    expect {
       Yajl::Encoder.encode(1.0/0.0)
-    }.should raise_error(Yajl::EncodeError)
-    lambda {
+    }.to raise_error(Yajl::EncodeError)
+    expect {
       Yajl::Encoder.encode(-1.0/0.0)
-    }.should raise_error(Yajl::EncodeError)
+    }.to raise_error(Yajl::EncodeError)
   end
 
   it "should encode with unicode chars in the key" do
     hash = {"浅草" => "<- those are unicode"}
-    Yajl::Encoder.encode(hash).should eql("{\"浅草\":\"<- those are unicode\"}")
+    expect(Yajl::Encoder.encode(hash)).to eql("{\"浅草\":\"<- those are unicode\"}")
   end
 
   if RUBY_VERSION =~ /^1.9/
     it "should return a string encoded in utf-8 if Encoding.default_internal is nil" do
       Encoding.default_internal = nil
       hash = {"浅草" => "<- those are unicode"}
-      Yajl::Encoder.encode(hash).encoding.should eql(Encoding.find('utf-8'))
+      expect(Yajl::Encoder.encode(hash).encoding).to eql(Encoding.find('utf-8'))
     end
 
     it "should return a string encoded in utf-8 even if Encoding.default_internal *is* set" do
       Encoding.default_internal = Encoding.find('utf-8')
       hash = {"浅草" => "<- those are unicode"}
-      Yajl::Encoder.encode(hash).encoding.should eql(Encoding.default_internal)
+      expect(Yajl::Encoder.encode(hash).encoding).to eql(Encoding.default_internal)
       Encoding.default_internal = Encoding.find('us-ascii')
       hash = {"浅草" => "<- those are unicode"}
-      Yajl::Encoder.encode(hash).encoding.should eql(Encoding.find('utf-8'))
+      expect(Yajl::Encoder.encode(hash).encoding).to eql(Encoding.find('utf-8'))
     end
   end
 
@@ -271,45 +271,45 @@ describe "Yajl JSON encoder" do
     unsafe_encoder = Yajl::Encoder.new(:html_safe => false)
     safe_encoder   = Yajl::Encoder.new(:html_safe => true)
 
-    unsafe_encoder.encode("</script>").should_not eql("\"<\\/script>\"")
-    safe_encoder.encode("</script>").should eql("\"<\\/script>\"")
+    expect(unsafe_encoder.encode("</script>")).not_to eql("\"<\\/script>\"")
+    expect(safe_encoder.encode("</script>")).to eql("\"<\\/script>\"")
   end
 
   it "should default to *not* escaping / characters" do
     unsafe_encoder = Yajl::Encoder.new
-    unsafe_encoder.encode("</script>").should_not eql("\"<\\/script>\"")
+    expect(unsafe_encoder.encode("</script>")).not_to eql("\"<\\/script>\"")
   end
 
   it "return value of #to_json must be a string" do
-    lambda {
+    expect {
       Yajl::Encoder.encode(TheMindKiller.new)
-    }.should raise_error(TypeError)
+    }.to raise_error(TypeError)
   end
 
   it "return value of #to_s must be a string" do
-    lambda {
+    expect {
       if TheMindKillerDuce.send(:method_defined?, :to_json)
         TheMindKillerDuce.send(:undef_method, :to_json)
       end
       Yajl::Encoder.encode(TheMindKillerDuce.new)
-    }.should raise_error(TypeError)
+    }.to raise_error(TypeError)
   end
 
   it "should raise an exception for deeply nested arrays" do
     root = []
     a = root
     (Yajl::MAX_DEPTH + 1).times { |_| a << []; a = a[0] }
-    lambda {
+    expect {
       Yajl::Encoder.encode(root)
-    }.should raise_error(Yajl::EncodeError)
+    }.to raise_error(Yajl::EncodeError)
   end
 
   it "should raise an exception for deeply nested hashes" do
     root = {}
     a = root
     (Yajl::MAX_DEPTH + 1).times { |_| a["a"] = {}; a = a["a"] }
-    lambda {
+    expect {
       Yajl::Encoder.encode(root)
-    }.should raise_error(Yajl::EncodeError)
+    }.to raise_error(Yajl::EncodeError)
   end
-end
+end

data/spec/global/global_spec.rb

@@ -3,52 +3,52 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
 describe "Yajl" do
   context "dump" do
     it "should exist as a class-method" do
-      Yajl.should respond_to(:dump)
+      expect(Yajl).to respond_to(:dump)
     end
 
     it "should be able to encode to a string" do
-      Yajl.dump({:a => 1234}).should eql('{"a":1234}')
+      expect(Yajl.dump({:a => 1234})).to eql('{"a":1234}')
     end
 
     it "should be able to encode to an IO" do
       io = StringIO.new
       Yajl.dump({:a => 1234}, io)
       io.rewind
-      io.read.should eql('{"a":1234}')
+      expect(io.read).to eql('{"a":1234}')
     end
 
     it "should be able to encode with a block supplied" do
       Yajl.dump({:a => 1234}) do |chunk|
-        chunk.should eql('{"a":1234}')
+        expect(chunk).to eql('{"a":1234}')
       end
     end
   end
 
   context "load" do
     it "should exist as a class-method" do
-      Yajl.should respond_to(:load)
+      expect(Yajl).to respond_to(:load)
     end
 
     it "should be able to parse from a string" do
-      Yajl.load('{"a":1234}').should eql({"a" => 1234})
+      expect(Yajl.load('{"a":1234}')).to eql({"a" => 1234})
     end
 
     it "should be able to parse from an IO" do
       io = StringIO.new('{"a":1234}')
-      Yajl.load(io).should eql({"a" => 1234})
+      expect(Yajl.load(io)).to eql({"a" => 1234})
     end
 
     it "should be able to parse from a string with a block supplied" do
       Yajl.load('{"a":1234}') do |h|
-        h.should eql({"a" => 1234})
+        expect(h).to eql({"a" => 1234})
       end
     end
 
     it "should be able to parse from an IO with a block supplied" do
       io = StringIO.new('{"a":1234}')
       Yajl.load(io) do |h|
-        h.should eql({"a" => 1234})
+        expect(h).to eql({"a" => 1234})
       end
     end
   end
-end
+end

data/spec/http/http_delete_spec.rb

@@ -37,62 +37,62 @@ describe "Yajl HTTP DELETE 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.delete(@uri)
+    expect(@template_hash).to eq(Yajl::HttpStream.delete(@uri))
   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.delete(@uri)
+    expect(@template_hash).to eq(stream.delete(@uri))
   end
 
   it "should parse a raw response and symbolize keys" do
     prepare_mock_request_dump :raw
-    @template_hash_symbolized.should == Yajl::HttpStream.delete(@uri, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.delete(@uri, :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.delete(@uri)
+      expect(@template_hash).to eq(Yajl::HttpStream.delete(@uri))
     end
 
     it "should parse a bzip2 compressed response and symbolize keys" do
       prepare_mock_request_dump :bzip2
-      @template_hash_symbolized.should == Yajl::HttpStream.delete(@uri, :symbolize_keys => true)
+      expect(@template_hash_symbolized).to eq(Yajl::HttpStream.delete(@uri, :symbolize_keys => true))
     end
   end
 
   it "should parse a deflate compressed response" do
     prepare_mock_request_dump :deflate
-    @template_hash.should == Yajl::HttpStream.delete(@uri)
+    expect(@template_hash).to eq(Yajl::HttpStream.delete(@uri))
   end
 
   it "should parse a deflate compressed response and symbolize keys" do
     prepare_mock_request_dump :deflate
-    @template_hash_symbolized.should == Yajl::HttpStream.delete(@uri, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.delete(@uri, :symbolize_keys => true))
   end
 
   it "should parse a gzip compressed response" do
     prepare_mock_request_dump :gzip
-    @template_hash.should == Yajl::HttpStream.delete(@uri)
+    expect(@template_hash).to eq(Yajl::HttpStream.delete(@uri))
   end
 
   it "should parse a gzip compressed response and symbolize keys" do
     prepare_mock_request_dump :gzip
-    @template_hash_symbolized.should == Yajl::HttpStream.delete(@uri, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.delete(@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.delete(@uri) }.should raise_exception(Yajl::HttpStream::HttpError)
+    expect { Yajl::HttpStream.delete(@uri) }.to raise_exception(Yajl::HttpStream::HttpError)
   end
-end
+end