ffi-yajl 2.2.0-universal-java → 2.2.1-universal-java

data/lib/ffi_yajl/map_library_name.rb

@@ -29,7 +29,6 @@ require 'libyajl2'
 
 module FFI_Yajl
   module MapLibraryName
-
     private
 
     # Stub for tests to override the host_os

data/lib/ffi_yajl/parser.rb

@@ -23,7 +23,8 @@
 module FFI_Yajl
   class ParseError < StandardError; end
   class Parser
-    attr_accessor :stack, :key_stack, :key, :finished
+    attr_writer :stack, :key_stack
+    attr_accessor :key, :finished
 
     attr_accessor :opts
 
@@ -31,14 +32,14 @@ module FFI_Yajl
     # stack used to build up our complex object
     #
     def stack
-      @stack ||= Array.new
+      @stack ||= []
     end
 
     #
     # stack to keep track of keys as we create nested hashes
     #
     def key_stack
-      @key_stack ||= Array.new
+      @key_stack ||= []
     end
 
     def self.parse(obj, *args)
@@ -80,9 +81,7 @@ module FFI_Yajl
       # XXX: bug-compat with ruby-yajl
       return nil if str == ""
 
-      if str.respond_to?(:read)
-        str = str.read()
-      end
+      str = str.read if str.respond_to?(:read)
 
       # call either the ext or ffi hook
       do_yajl_parse(str, yajl_opts)

data/lib/ffi_yajl/version.rb

@@ -21,5 +21,5 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 module FFI_Yajl
-  VERSION = "2.2.0"
+  VERSION = "2.2.1"
 end

data/spec/ffi_yajl/encoder_spec.rb

@@ -25,18 +25,17 @@ require 'spec_helper'
 require 'date'
 
 describe "FFI_Yajl::Encoder" do
-
   let(:options) { {} }
 
   let(:encoder) { FFI_Yajl::Encoder.new(options) }
 
-  it "encodes hashes in keys as strings", :ruby_gte_193 => true do
-    ruby = { {'a' => 'b'} => 2 }
+  it "encodes hashes in keys as strings", ruby_gte_193: true do
+    ruby = { { 'a' => 'b' } => 2 }
     expect(encoder.encode(ruby)).to eq('{"{\"a\"=>\"b\"}":2}')
   end
 
-  it "encodes arrays in keys as strings", :ruby_gte_193 => true do
-    ruby = { [0,1] => 2 }
+  it "encodes arrays in keys as strings", ruby_gte_193: true do
+    ruby = { [0, 1] => 2 }
     expect(encoder.encode(ruby)).to eq('{"[0, 1]":2}')
   end
 
@@ -66,14 +65,14 @@ describe "FFI_Yajl::Encoder" do
   end
 
   it "encodes bignums in keys as strings" do
-    ruby = { 12345678901234567890 => 2 }
+    ruby = { 12_345_678_901_234_567_890 => 2 }
     expect(encoder.encode(ruby)).to eq('{"12345678901234567890":2}')
   end
 
   it "encodes objects in keys as strings" do
     o = Object.new
     ruby = { o => 2 }
-    expect(encoder.encode(ruby)).to eq(%Q{{"#{o.to_s}":2}})
+    expect(encoder.encode(ruby)).to eq(%{{"#{o}":2}})
   end
 
   it "encodes an object in a key which has a #to_json method as strings" do
@@ -84,7 +83,7 @@ describe "FFI_Yajl::Encoder" do
     end
     o = Thing.new
     ruby = { o => 2 }
-    expect(encoder.encode(ruby)).to eq(%Q{{"#{o.to_s}":2}})
+    expect(encoder.encode(ruby)).to eq(%{{"#{o}":2}})
   end
 
   # XXX: 127 == YAJL_MAX_DEPTH hardcodedness, zero control for us, it isn't even a twiddleable #define
@@ -92,18 +91,18 @@ describe "FFI_Yajl::Encoder" do
     root = []
     a = root
     127.times { |_| a << []; a = a[0] }
-    expect{ encoder.encode(root) }.to raise_error(FFI_Yajl::EncodeError)
+    expect { encoder.encode(root) }.to raise_error(FFI_Yajl::EncodeError)
   end
 
   it "raises an exception for deeply nested hashes" do
     root = {}
     a = root
-    127.times {|_| a["a"] = {}; a = a["a"] }
-    expect{ encoder.encode(root) }.to raise_error(FFI_Yajl::EncodeError)
+    127.times { |_| a["a"] = {}; a = a["a"] }
+    expect { encoder.encode(root) }.to raise_error(FFI_Yajl::EncodeError)
   end
 
   it "encodes symbols in keys as strings" do
-    ruby = { :thing => 1 }
+    ruby = { thing: 1 }
     expect(encoder.encode(ruby)).to eq('{"thing":1}')
   end
 
@@ -113,7 +112,7 @@ describe "FFI_Yajl::Encoder" do
   end
 
   it "can encode 32-bit unsigned ints" do
-    ruby = { "gid"=>4294967294 }
+    ruby = { "gid" => 4_294_967_294 }
     expect(encoder.encode(ruby)).to eq('{"gid":4294967294}')
   end
 
@@ -128,7 +127,7 @@ describe "FFI_Yajl::Encoder" do
 
   it "can encode Date objects" do
     ruby = Date.parse('2001-02-03')
-    expect(encoder.encode(ruby)).to eq( %q{"2001-02-03"} )
+    expect(encoder.encode(ruby)).to eq( '"2001-02-03"' )
   end
 
   it "can encode StringIOs" do
@@ -148,13 +147,13 @@ describe "FFI_Yajl::Encoder" do
 
     it "encodes them correctly" do
       ruby = Time.local(2001, 02, 02, 21, 05, 06)
-      expect(encoder.encode(ruby)).to eq( %q{"2001-02-02 21:05:06 +0000"} )
+      expect(encoder.encode(ruby)).to eq( '"2001-02-02 21:05:06 +0000"' )
     end
   end
 
   it "can encode DateTime objects" do
     ruby = DateTime.parse('2001-02-03T04:05:06.1+07:00')
-    expect(encoder.encode(ruby)).to eq( %q{"2001-02-03T04:05:06+07:00"} )
+    expect(encoder.encode(ruby)).to eq( '"2001-02-03T04:05:06+07:00"' )
   end
 
   describe "testing .to_json for Objects" do
@@ -176,25 +175,25 @@ describe "FFI_Yajl::Encoder" do
 
   context "when encoding invalid utf-8" do
     ruby = {
-      "automatic"=>{
-        "etc"=>{
-          "passwd"=>{
-            "root"=>{"dir"=>"/root", "gid"=>0, "uid"=>0, "shell"=>"/bin/sh", "gecos"=>"Elan Ruusam\xc3\xa4e"},
-            "glen"=>{"dir"=>"/home/glen", "gid"=>500, "uid"=>500, "shell"=>"/bin/bash", "gecos"=>"Elan Ruusam\xE4e"},
-          }
+      "automatic" => {
+        "etc" => {
+          "passwd" => {
+            "root" => { "dir" => "/root", "gid" => 0, "uid" => 0, "shell" => "/bin/sh", "gecos" => "Elan Ruusam\xc3\xa4e" },
+            "glen" => { "dir" => "/home/glen", "gid" => 500, "uid" => 500, "shell" => "/bin/bash", "gecos" => "Elan Ruusam\xE4e" },
+          },
         },
       },
     }
 
     it "raises an error on invalid json" do
-      expect{ encoder.encode(ruby) }.to raise_error(FFI_Yajl::EncodeError, /Invalid UTF-8 string 'Elan Ruusam.e': cannot encode to UTF-8/)
+      expect { encoder.encode(ruby) }.to raise_error(FFI_Yajl::EncodeError, /Invalid UTF-8 string 'Elan Ruusam.e': cannot encode to UTF-8/)
     end
 
     context "when validate_utf8 is off" do
-      let(:options) {  { :validate_utf8 => false } }
+      let(:options) {  { validate_utf8: false } }
 
       it "does not raise an error" do
-        expect{ encoder.encode(ruby) }.not_to raise_error
+        expect { encoder.encode(ruby) }.not_to raise_error
       end
 
       it "returns utf8" do

data/spec/ffi_yajl/map_library_name_spec.rb

@@ -47,7 +47,6 @@ describe "FFI_Yajl::MapLibraryName" do
   end
 
   host_os_library_name_mapping.each do |host_os, library_names|
-
     context "#library_names" do
       it "maps #{host_os} correctly" do
         allow(Test).to receive(:host_os).and_return(host_os)
@@ -112,6 +111,5 @@ describe "FFI_Yajl::MapLibraryName" do
         Test.send(:ffi_open_yajl_library)
       end
     end
-
   end
 end

data/spec/ffi_yajl/parser_spec.rb

@@ -24,21 +24,20 @@
 require 'spec_helper'
 
 describe "FFI_Yajl::Parser" do
-
   shared_examples_for "correct json parsing" do
     context "when json has 23456789012E666" do
       let(:json) {  '{"key": 23456789012E666}' }
 
       it "should return infinity" do
-        infinity = (1.0/0)
-        expect(parser).to eq({"key" => infinity})
+        infinity = (1.0 / 0)
+        expect(parser).to eq("key" => infinity)
       end
     end
 
     context "when parsing nil" do
       let(:json) { nil }
       it "should not coredump ruby" do
-        expect{ parser }.to raise_error(FFI_Yajl::ParseError)
+        expect { parser }.to raise_error(FFI_Yajl::ParseError)
       end
     end
 
@@ -88,79 +87,79 @@ describe "FFI_Yajl::Parser" do
       let(:json) { '{"key": /* this is a comment */ "value"}' }
 
       context "when allow_comments is false" do
-        let(:options) { { :allow_comments => false } }
+        let(:options) { { allow_comments: false } }
 
         it "should not parse" do
-          expect{parser}.to raise_error(FFI_Yajl::ParseError)
+          expect { parser }.to raise_error(FFI_Yajl::ParseError)
         end
       end
 
       context "when allow_comments is true" do
-        let(:options) { { :allow_comments => true } }
+        let(:options) { { allow_comments: true } }
 
         it "should parse" do
-          expect(parser).to eq({"key"=>"value"})
+          expect(parser).to eq("key" => "value")
         end
       end
 
       context "by default" do
-        let(:options) { }
+        let(:options) {}
 
         it "should parse" do
-          expect(parser).to eq({"key"=>"value"})
+          expect(parser).to eq("key" => "value")
         end
       end
     end
 
     context "when json has multiline comments" do
-      let(:json) { %Q{{"key": \n/*\n this is a multiline comment \n*/\n "value"}} }
+      let(:json) { %{{"key": \n/*\n this is a multiline comment \n*/\n "value"}} }
 
       context "when allow_comments is false" do
-        let(:options) { { :allow_comments => false } }
+        let(:options) { { allow_comments: false } }
 
         it "should not parse" do
-          expect{parser}.to raise_error(FFI_Yajl::ParseError)
+          expect { parser }.to raise_error(FFI_Yajl::ParseError)
         end
       end
 
       context "when allow_comments is true" do
-        let(:options) { { :allow_comments => true } }
+        let(:options) { { allow_comments: true } }
 
         it "should parse" do
-          expect(parser).to eq({"key"=>"value"})
+          expect(parser).to eq("key" => "value")
         end
       end
     end
 
     context "when json has inline comments" do
-      let(:json) { %Q{{"key": \n// this is an inline comment\n "value"}} }
+      let(:json) { %{{"key": \n// this is an inline comment\n "value"}} }
 
       context "when allow_comments is false" do
-        let(:options) { { :allow_comments => false } }
+        let(:options) { { allow_comments: false } }
 
         it "should not parse" do
-          expect{parser}.to raise_error(FFI_Yajl::ParseError)
+          expect { parser }.to raise_error(FFI_Yajl::ParseError)
         end
       end
 
       context "when allow_comments is true" do
-        let(:options) { { :allow_comments => true } }
+        let(:options) { { allow_comments: true } }
 
         it "should parse" do
-          expect(parser).to eq({"key"=>"value"})
+          expect(parser).to eq("key" => "value")
         end
       end
     end
 
     context "when json is invalid UTF8" do
-      let(:json) { "[\"#{"\201\203"}\"]" }
+      let(:json) { "[\"\201\203\"]" }
 
       it "should not parse by default" do
-        expect{parser}.to raise_error(FFI_Yajl::ParseError)
+        expect { parser }.to raise_error(FFI_Yajl::ParseError)
       end
 
       context "when :dont_validate_strings is set to true" do
-        let(:options) { { :dont_validate_strings => true } }
+        let(:options) { { dont_validate_strings: true } }
 
         it "should parse" do
           expect(parser).to eq(["\x81\x83"])
@@ -168,46 +167,46 @@ describe "FFI_Yajl::Parser" do
       end
 
       context "when :dont_validate_strings is set to false" do
-        let(:options) { { :dont_validate_strings => false } }
+        let(:options) { { dont_validate_strings: false } }
 
         it "should not parse" do
-          expect{parser}.to raise_error(FFI_Yajl::ParseError)
+          expect { parser }.to raise_error(FFI_Yajl::ParseError)
         end
       end
 
       context "when :check_utf8 is set to true" do
-        let(:options) { { :check_utf8 => true } }
+        let(:options) { { check_utf8: true } }
 
         it "should not parse" do
-          expect{parser}.to raise_error(FFI_Yajl::ParseError)
+          expect { parser }.to raise_error(FFI_Yajl::ParseError)
         end
 
         context "when :dont_validate_strings is set to true" do
-          let(:options) { { :check_utf8 => true, :dont_validate_strings => true } }
+          let(:options) { { check_utf8: true, dont_validate_strings: true } }
 
           it "should raise an ArgumentError" do
-            expect{parser}.to raise_error(ArgumentError)
+            expect { parser }.to raise_error(ArgumentError)
           end
         end
 
         context "when :dont_validate_strings is set to false" do
-          let(:options) { { :check_utf8 => true, :dont_validate_strings => false } }
+          let(:options) { { check_utf8: true, dont_validate_strings: false } }
 
           it "should not parse" do
-            expect{parser}.to raise_error(FFI_Yajl::ParseError)
+            expect { parser }.to raise_error(FFI_Yajl::ParseError)
           end
         end
       end
 
       context "when :check_utf8 is set to false" do
-        let(:options) { { :check_utf8 => false } }
+        let(:options) { { check_utf8: false } }
 
         it "should parse" do
           expect(parser).to eq(["\x81\x83"])
         end
 
         context "when :dont_validate_strings is set to true" do
-          let(:options) { { :check_utf8 => false, :dont_validate_strings => true } }
+          let(:options) { { check_utf8: false, dont_validate_strings: true } }
 
           it "should parse" do
             expect(parser).to eq(["\x81\x83"])
@@ -215,10 +214,10 @@ describe "FFI_Yajl::Parser" do
         end
 
         context "when :dont_validate_strings is set to false" do
-          let(:options) { { :check_utf8 => false, :dont_validate_strings => false } }
+          let(:options) { { check_utf8: false, dont_validate_strings: false } }
 
           it "should raise an ArgumentError" do
-            expect{parser}.to raise_error(ArgumentError)
+            expect { parser }.to raise_error(ArgumentError)
           end
         end
       end
@@ -228,7 +227,7 @@ describe "FFI_Yajl::Parser" do
       let(:json) { StringIO.new('{"key": 1234}') }
 
       it "should parse" do
-        expect(parser).to eq({"key" => 1234})
+        expect(parser).to eq("key" => 1234)
       end
     end
 
@@ -236,14 +235,14 @@ describe "FFI_Yajl::Parser" do
       let(:json) { '{"key": 1234}' }
 
       it "should parse correctly" do
-        expect(parser).to eq({"key" => 1234})
+        expect(parser).to eq("key" => 1234)
       end
 
       context "when symbolize_keys is true" do
-        let(:options) { { :symbolize_keys => true } }
+        let(:options) { { symbolize_keys: true } }
 
         it "should symbolize keys correctly" do
-          expect(parser).to eq({:key => 1234})
+          expect(parser).to eq(key: 1234)
         end
       end
 
@@ -254,7 +253,7 @@ describe "FFI_Yajl::Parser" do
           parser do |obj|
             output = obj
           end
-          expect(output).to eq({"key" => 1234})
+          expect(output).to eq("key" => 1234)
         end
       end
     end
@@ -305,14 +304,14 @@ describe "FFI_Yajl::Parser" do
       let(:json) { '{"日本語": 1234}' }
 
       it "should parse correctly" do
-        expect(parser).to eq({"日本語" => 1234})
+        expect(parser).to eq("日本語" => 1234)
       end
 
       context "when symbolize_keys is true" do
-        let(:options) { { :symbolize_keys => true } }
+        let(:options) { { symbolize_keys: true } }
 
         it "should symbolize keys correctly" do
-          expect(parser).to eq({:"日本語" => 1234})
+          expect(parser).to eq(:"日本語" => 1234) # rubocop:disable Style/HashSyntax
         end
 
         if RUBY_VERSION.to_f >= 1.9
@@ -327,7 +326,7 @@ describe "FFI_Yajl::Parser" do
       let(:json) { "{\"id\": 2147483649}" }
 
       it "should parse corectly" do
-        expect(parser).to eql({"id" => 2147483649})
+        expect(parser).to eql("id" => 2_147_483_649)
       end
     end
 
@@ -335,7 +334,7 @@ describe "FFI_Yajl::Parser" do
       let(:json) { "{\"id\": 5687389800}" }
 
       it "should parse corectly" do
-        expect(parser).to eql({"id" => 5687389800})
+        expect(parser).to eql("id" => 5_687_389_800)
       end
     end
 
@@ -343,7 +342,7 @@ describe "FFI_Yajl::Parser" do
       let(:json) { "{\"id\": 1046289770033519442869495707521600000000}" }
 
       it "should parse corectly" do
-        expect(parser).to eql({"id" => 1046289770033519442869495707521600000000})
+        expect(parser).to eql("id" => 1_046_289_770_033_519_442_869_495_707_521_600_000_000)
       end
     end
 
@@ -383,12 +382,11 @@ describe "FFI_Yajl::Parser" do
         end
 
         context "with allow_trailing_garbage" do
-          let(:options) { { :allow_trailing_garbage => true } }
+          let(:options) { { allow_trailing_garbage: true } }
           it "parses" do
-            expect(parser).to eq({"foo"=>{"foo"=>1234}})
+            expect(parser).to eq("foo" => { "foo" => 1234 })
           end
         end
-
       end
 
       context "when an extra bracket is present" do
@@ -476,20 +474,20 @@ describe "FFI_Yajl::Parser" do
 
     # NOTE: parsing floats with 8 million digits on windows has some kind of huge
     #       perf issues likely in ruby and/or the underlying windows libs
-    context "when parsing big floats", :ruby_gte_193 => true, :unix_only => true do
+    context "when parsing big floats", ruby_gte_193: true, unix_only: true do
       let(:json) { '[0.' + '1' * 2**23 + ']' }
 
       it "parses" do
-        expect{ parser }.not_to raise_error
+        expect { parser }.not_to raise_error
       end
     end
 
-    context "when parsing long hash keys with symbolize_keys option", :ruby_gte_193 => true do
+    context "when parsing long hash keys with symbolize_keys option", ruby_gte_193: true do
       let(:json) { '{"' + 'a' * 2**23 + '": 0}' }
-      let(:options) { { :symbolize_keys => true } }
+      let(:options) { { symbolize_keys: true } }
 
       it "parses" do
-        expect{ parser }.not_to raise_error
+        expect { parser }.not_to raise_error
       end
     end
 
@@ -502,9 +500,9 @@ describe "FFI_Yajl::Parser" do
 
     context "should raise an exception for repeated keys" do
       let(:json) { '{"foo":"bar","foo":"baz"}' }
-      let(:options) { { :unique_key_checking => true } }
+      let(:options) { { unique_key_checking: true } }
       it "should raise" do
-        expect{ parser }.to raise_error(FFI_Yajl::ParseError)
+        expect { parser }.to raise_error(FFI_Yajl::ParseError)
       end
     end
   end