yajl-ruby 1.2.3 → 1.3.1

data/spec/parsing/chunked_spec.rb

@@ -14,25 +14,25 @@ describe "Chunked parser" do
   end
 
   it "should parse a single chunk" do
-    @callback.should_receive(:call).with(@final)
+    expect(@callback).to receive(:call).with(@final)
     @parser << '[{"abc": 123},{"def": 456}]'
   end
 
   it "should parse a single chunk, 3 times" do
-    @callback.should_receive(:call).with(@final).exactly(3).times
+    expect(@callback).to receive(:call).with(@final).exactly(3).times
     @parser << '[{"abc": 123},{"def": 456}]'
     @parser << '[{"abc": 123},{"def": 456}]'
     @parser << '[{"abc": 123},{"def": 456}]'
   end
 
   it "should parse in two chunks" do
-    @callback.should_receive(:call).with(@final)
+    expect(@callback).to receive(:call).with(@final)
     @parser << '[{"abc": 123},'
     @parser << '{"def": 456}]'
   end
 
   it "should parse in 2 chunks, twice" do
-    @callback.should_receive(:call).with(@final).exactly(2).times
+    expect(@callback).to receive(:call).with(@final).exactly(2).times
     @parser << '[{"abc": 123},'
     @parser << '{"def": 456}]'
     @parser << '[{"abc": 123},'
@@ -40,57 +40,57 @@ describe "Chunked parser" do
   end
 
   it "should parse 2 JSON strings, in 3 chunks" do
-    @callback.should_receive(:call).with(@final).exactly(2).times
+    expect(@callback).to receive(:call).with(@final).exactly(2).times
     @parser << '[{"abc": 123},'
     @parser << '{"def": 456}][{"abc": 123},{"def":'
     @parser << ' 456}]'
   end
 
   it "should parse 2 JSON strings in 1 chunk" do
-    @callback.should_receive(:call).with(@final).exactly(2).times
+    expect(@callback).to receive(:call).with(@final).exactly(2).times
     @parser << '[{"abc": 123},{"def": 456}][{"abc": 123},{"def": 456}]'
   end
 
   it "should parse 2 JSON strings from an IO" do
-    @callback.should_receive(:call).with(@final).exactly(2).times
+    expect(@callback).to receive(:call).with(@final).exactly(2).times
     @parser.parse(StringIO.new('[{"abc": 123},{"def": 456}][{"abc": 123},{"def": 456}]'))
   end
 
   it "should parse a JSON string an IO and fire callback once" do
-    @callback.should_receive(:call).with(@final)
+    expect(@callback).to receive(:call).with(@final)
     @parser.parse(StringIO.new('[{"abc": 123},{"def": 456}]'))
   end
 
   it "should parse twitter_stream.json and fire callback 430 times" do
     path = File.expand_path(File.dirname(__FILE__) + '/../../benchmark/subjects/twitter_stream.json')
     json = File.new(path, 'r')
-    @callback.should_receive(:call).exactly(430).times
-    lambda {
+    expect(@callback).to receive(:call).exactly(430).times
+    expect {
       @parser.parse(json)
-    }.should_not raise_error
+    }.not_to raise_error
   end
 
   it "should parse twitter_stream.json and fire callback 430 times, with a block as the callback" do
     path = File.expand_path(File.dirname(__FILE__) + '/../../benchmark/subjects/twitter_stream.json')
     json = File.new(path, 'r')
-    @callback.should_receive(:call).exactly(0).times
+    expect(@callback).to receive(:call).exactly(0).times
     @parser.on_parse_complete = nil
-    lambda {
+    expect {
       times = 0
       @parser.parse(json) do |hsh|
         times += 1
       end
-      times.should eql(430)
-    }.should_not raise_error
+      expect(times).to eql(430)
+    }.not_to raise_error
   end
 
   it "should raise a Yajl::ParseError error if multiple JSON strings were found when no on_parse_complete callback assigned" do
     path = File.expand_path(File.dirname(__FILE__) + '/../../benchmark/subjects/twitter_stream.json')
     json = File.new(path, 'r')
     @parser.on_parse_complete = nil
-    @callback.should_receive(:call).exactly(0).times
-    lambda {
+    expect(@callback).to receive(:call).exactly(0).times
+    expect {
       @parser.parse(json)
-    }.should raise_error(Yajl::ParseError)
+    }.to raise_error(Yajl::ParseError)
   end
 end

data/spec/parsing/fixtures_spec.rb

@@ -8,33 +8,33 @@ describe "Parsing JSON Fixtures" do
 
   FAILED.each do |name, source|
     it "should not be able to parse #{File.basename(name)} as an IO" do
-        lambda {
+        expect {
           Yajl::Parser.parse(StringIO.new(source))
-        }.should raise_error(Yajl::ParseError)
+        }.to raise_error(Yajl::ParseError)
     end
   end
 
   FAILED.each do |name, source|
     it "should not be able to parse #{File.basename(name)} as a string" do
-        lambda {
+        expect {
           Yajl::Parser.parse(source)
-        }.should raise_error(Yajl::ParseError)
+        }.to raise_error(Yajl::ParseError)
     end
   end
 
   PASSED.each do |name, source|
     it "should be able to parse #{File.basename(name)} as an IO" do
-        lambda {
+        expect {
           Yajl::Parser.parse(StringIO.new(source))
-        }.should_not raise_error
+        }.not_to raise_error
     end
   end
 
   PASSED.each do |name, source|
     it "should be able to parse #{File.basename(name)} as a string" do
-        lambda {
+        expect {
           Yajl::Parser.parse(source)
-        }.should_not raise_error
+        }.not_to raise_error
     end
   end
 end

data/spec/parsing/large_number_spec.rb

@@ -40,7 +40,7 @@ describe 'Parsing very long text' do
 
     it 'runs successfully' do
       out, err, status = capture('ruby', script)
-      [err, status.exitstatus].should eq(['', 0])
+      expect([err, status.exitstatus]).to eq(['', 0])
     end
   end
 

data/spec/parsing/one_off_spec.rb

@@ -12,29 +12,29 @@ describe "One-off JSON examples" do
   it "should parse 23456789012E666 and return Infinity" do
     infinity = (1.0/0)
     silence_warnings do
-      Yajl::Parser.parse(StringIO.new('{"key": 23456789012E666}')).should == {"key" => infinity}
+      expect(Yajl::Parser.parse(StringIO.new('{"key": 23456789012E666}'))).to eq({"key" => infinity})
     end
   end
 
   it "should not parse JSON with a comment, with :allow_comments set to false" do
     json = StringIO.new('{"key": /* this is a comment */ "value"}')
-    lambda {
+    expect {
       Yajl::Parser.parse(json, :allow_comments => false)
-    }.should raise_error(Yajl::ParseError)
+    }.to raise_error(Yajl::ParseError)
   end
 
   it "should parse JSON with a comment, with :allow_comments set to true" do
     json = StringIO.new('{"key": /* this is a comment */ "value"}')
-    lambda {
+    expect {
       Yajl::Parser.parse(json, :allow_comments => true)
-    }.should_not raise_error
+    }.not_to raise_error
   end
 
   it "should not parse invalid UTF8 with :check_utf8 set to true" do
     parser = Yajl::Parser.new(:check_utf8 => true)
-    lambda {
+    expect {
       parser.parse("[\"#{"\201\203"}\"]")
-    }.should raise_error(Yajl::ParseError)
+    }.to raise_error(Yajl::ParseError)
   end
 
   it "should parse invalid UTF8 with :check_utf8 set to false" do
@@ -44,19 +44,19 @@ describe "One-off JSON examples" do
 
   it "should parse using it's class method, from an IO" do
     io = StringIO.new('{"key": 1234}')
-    Yajl::Parser.parse(io).should == {"key" => 1234}
+    expect(Yajl::Parser.parse(io)).to eq({"key" => 1234})
   end
 
   it "should parse using it's class method, from a string with symbolized keys" do
-    Yajl::Parser.parse('{"key": 1234}', :symbolize_keys => true).should == {:key => 1234}
+    expect(Yajl::Parser.parse('{"key": 1234}', :symbolize_keys => true)).to eq({:key => 1234})
   end
 
   it "should parse using it's class method, from a utf-8 string with multibyte characters, with symbolized keys" do
-    Yajl::Parser.parse('{"日本語": 1234}', :symbolize_keys => true).should == {:"日本語" => 1234}
+    expect(Yajl::Parser.parse('{"日本語": 1234}', :symbolize_keys => true)).to eq({:"日本語" => 1234})
   end
 
   it "should parse using it's class method, from a string" do
-    Yajl::Parser.parse('{"key": 1234}').should == {"key" => 1234}
+    expect(Yajl::Parser.parse('{"key": 1234}')).to eq({"key" => 1234})
   end
 
   it "should parse using it's class method, from a string with a block" do
@@ -64,34 +64,34 @@ describe "One-off JSON examples" do
     Yajl::Parser.parse('{"key": 1234}') do |obj|
       output = obj
     end
-    output.should == {"key" => 1234}
+    expect(output).to eq({"key" => 1234})
   end
 
   it "should parse numbers greater than 2,147,483,648" do
-    Yajl::Parser.parse("{\"id\": 2147483649}").should eql({"id" => 2147483649})
-    Yajl::Parser.parse("{\"id\": 5687389800}").should eql({"id" => 5687389800})
-    Yajl::Parser.parse("{\"id\": 1046289770033519442869495707521600000000}").should eql({"id" => 1046289770033519442869495707521600000000})
+    expect(Yajl::Parser.parse("{\"id\": 2147483649}")).to eql({"id" => 2147483649})
+    expect(Yajl::Parser.parse("{\"id\": 5687389800}")).to eql({"id" => 5687389800})
+    expect(Yajl::Parser.parse("{\"id\": 1046289770033519442869495707521600000000}")).to eql({"id" => 1046289770033519442869495707521600000000})
   end
 
   if RUBY_VERSION =~ /^1.9/
     it "should encode non-ascii symbols in utf-8" do
       parsed = Yajl::Parser.parse('{"曦": 1234}', :symbolize_keys => true)
-      parsed.keys.fetch(0).encoding.should eq(Encoding::UTF_8)
+      expect(parsed.keys.fetch(0).encoding).to eq(Encoding::UTF_8)
     end
 
     it "should return strings and hash keys in utf-8 if Encoding.default_internal is nil" do
       Encoding.default_internal = nil
-      Yajl::Parser.parse('{"key": "value"}').keys.first.encoding.should eql(Encoding.find('utf-8'))
-      Yajl::Parser.parse('{"key": "value"}').values.first.encoding.should eql(Encoding.find('utf-8'))
+      expect(Yajl::Parser.parse('{"key": "value"}').keys.first.encoding).to eql(Encoding.find('utf-8'))
+      expect(Yajl::Parser.parse('{"key": "value"}').values.first.encoding).to eql(Encoding.find('utf-8'))
     end
 
     it "should return strings and hash keys encoded as specified in Encoding.default_internal if it's set" do
       Encoding.default_internal = Encoding.find('utf-8')
-      Yajl::Parser.parse('{"key": "value"}').keys.first.encoding.should eql(Encoding.default_internal)
-      Yajl::Parser.parse('{"key": "value"}').values.first.encoding.should eql(Encoding.default_internal)
+      expect(Yajl::Parser.parse('{"key": "value"}').keys.first.encoding).to eql(Encoding.default_internal)
+      expect(Yajl::Parser.parse('{"key": "value"}').values.first.encoding).to eql(Encoding.default_internal)
       Encoding.default_internal = Encoding.find('us-ascii')
-      Yajl::Parser.parse('{"key": "value"}').keys.first.encoding.should eql(Encoding.default_internal)
-      Yajl::Parser.parse('{"key": "value"}').values.first.encoding.should eql(Encoding.default_internal)
+      expect(Yajl::Parser.parse('{"key": "value"}').keys.first.encoding).to eql(Encoding.default_internal)
+      expect(Yajl::Parser.parse('{"key": "value"}').values.first.encoding).to eql(Encoding.default_internal)
     end
   end
 end

data/tasks/rspec.rake

@@ -13,4 +13,4 @@ begin
   task :default => :spec
 rescue LoadError
   puts "rspec, or one of its dependencies, is not available. Install it with: sudo gem install rspec"
-end
+end

data/yajl-ruby.gemspec

@@ -17,8 +17,8 @@ Gem::Specification.new do |s|
   s.required_ruby_version = ">= 1.8.6"
 
   # tests
-  s.add_development_dependency 'rake-compiler', ">= 0.7.5"
-  s.add_development_dependency 'rspec', "~> 2.14"
+  s.add_development_dependency 'rake-compiler', '>= 0.7.5'
+  s.add_development_dependency 'rspec', '~> 3.0'
   # benchmarks
   s.add_development_dependency 'activesupport', '~> 3.1.2'
   s.add_development_dependency 'json'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yajl-ruby
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.3.1
 platform: ruby
 authors:
 - Brian Lopez
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-29 00:00:00.000000000 Z
+date: 2017-11-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -31,14 +31,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -74,12 +74,13 @@ extensions:
 - ext/yajl/extconf.rb
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
 - CHANGELOG.md
 - Gemfile
-- MIT-LICENSE
+- LICENSE
 - README.md
 - Rakefile
 - benchmark/encode.rb

data/MIT-LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2008-2011 Brian Lopez - http://github.com/brianmario
-
-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.