ffi-yajl 0.1.7 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a73785d92badd552df56ecd0fd14f53537bc5c5b
-  data.tar.gz: 6c7f329234428cd07ec9fbf73b1040c27d82fab3
+  metadata.gz: ad912796d62ff75534ab7056d42be6ddb3b340bd
+  data.tar.gz: 1368094d6809554303390c8dc38e33b837d6da5d
 SHA512:
-  metadata.gz: 2938f35493a720cfcf72ee73dfcccd88e56ef2cc2b58bcd5859a6ec7dde34100891a69c3b1139edf7a75c0f7c181ade595a0de6cf3d37fb73336c76ee5be631e
-  data.tar.gz: a40243af1ddc3095562a3af781bcf73c2cb04691ce4cb2a090ca85e4987508b0673e8e89f0176364dbed765e0369ba3d4185b3eafcba52f8e4056d41e37da487
+  metadata.gz: 7e7d9eaedc22292ea2817b75cba4fa04c90cf6ca7032675a0d8b400e4b1f7df8bc7120ff3b9a0952c55f8c7c3129d6279f92f5ae97671368979cf9f0af99c024
+  data.tar.gz: 690d495c1fe962fefae46cb73520e8690151ab40424cb2ebca0f162fe2b5bbcf1cac481be5b0ce73f408e4c03eaa676ae7284601e0b992e6b85c8e13449e1919

data/bin/ffi-yajl-bench

@@ -33,4 +33,5 @@ if opts[:profile]
   FFI_Yajl::Benchmark::ParseProfileRubyProf.new().run()
 else
   FFI_Yajl::Benchmark::Parse.new().run()
+  FFI_Yajl::Benchmark::Encode.new().run()
 end

data/ext/ffi_yajl/ext/parser/parser.c

@@ -10,6 +10,7 @@ static VALUE mFFI_Yajl, mExt, mParser, cParseError;
 
 typedef struct {
   VALUE self;
+  int symbolizeKeys;
 } CTX;
 
 void set_value(CTX *ctx, VALUE val) {
@@ -74,7 +75,7 @@ int double_callback(void *ctx, double doubleVal) {
 }
 
 int number_callback(void *ctx, const char *numberVal, size_t numberLen) {
-  char buf[numberLen+1];
+  char *buf = (char *)malloc(numberLen+1);
   buf[numberLen] = 0;
   memcpy(buf, numberVal, numberLen);
   if (memchr(buf, '.', numberLen) ||
@@ -84,21 +85,14 @@ int number_callback(void *ctx, const char *numberVal, size_t numberLen) {
   } else {
     set_value(ctx, rb_cstr2inum(buf, 10));
   }
+  free(buf);
   return 1;
 }
 
 int string_callback(void *ctx, const unsigned char *stringVal, size_t stringLen) {
-  char buf[stringLen+1];
-  VALUE str;
+  VALUE str = rb_str_new((const char *)stringVal, stringLen);
 #ifdef HAVE_RUBY_ENCODING_H
-  rb_encoding *default_internal_enc;
-#endif
-
-  buf[stringLen] = 0;
-  memcpy(buf, stringVal, stringLen);
-  str = rb_str_new2(buf);
-#ifdef HAVE_RUBY_ENCODING_H
-  default_internal_enc = rb_default_internal_encoding();
+  rb_encoding *default_internal_enc = rb_default_internal_encoding();
   rb_enc_associate(str, utf8Encoding);
   if (default_internal_enc) {
     str = rb_str_export_to_enc(str, default_internal_enc);
@@ -114,23 +108,30 @@ int start_map_callback(void *ctx) {
 }
 
 int map_key_callback(void *ctx, const unsigned char *stringVal, size_t stringLen) {
-  char buf[stringLen+1];
-  VALUE str;
+  VALUE key;
 #ifdef HAVE_RUBY_ENCODING_H
   rb_encoding *default_internal_enc;
 #endif
 
-  buf[stringLen] = 0;
-  memcpy(buf, stringVal, stringLen);
-  str = rb_str_new2(buf);
+  if ( ((CTX *)ctx)->symbolizeKeys ) {
 #ifdef HAVE_RUBY_ENCODING_H
-  default_internal_enc = rb_default_internal_encoding();
-  rb_enc_associate(str, utf8Encoding);
-  if (default_internal_enc) {
-    str = rb_str_export_to_enc(str, default_internal_enc);
-  }
+    ID id = rb_intern3((const char *)stringVal, stringLen, utf8Encoding);
+    key = ID2SYM(id);
+#else
+    VALUE str = rb_str_new((const char *)stringVal, stringLen);
+    key = rb_str_intern(str);
+#endif
+  } else {
+    key = rb_str_new((const char *)stringVal, stringLen);
+#ifdef HAVE_RUBY_ENCODING_H
+    default_internal_enc = rb_default_internal_encoding();
+    rb_enc_associate(key, utf8Encoding);
+    if (default_internal_enc) {
+      key = rb_str_export_to_enc(key, default_internal_enc);
+    }
 #endif
-  set_key(ctx,str);
+  }
+  set_key(ctx, key);
   return 1;
 }
 
@@ -163,7 +164,15 @@ static yajl_callbacks callbacks = {
   end_array_callback,
 };
 
-static VALUE mParser_do_yajl_parse(VALUE self, VALUE str, VALUE opts) {
+int get_opts_key(VALUE self, char *key) {
+  VALUE opts = rb_iv_get(self, "@opts");
+  if (TYPE(opts) != T_HASH) {
+    rb_raise(rb_eTypeError, "opts is not a valid hash");
+  }
+  return rb_hash_aref(opts, ID2SYM(rb_intern(key))) == Qtrue;
+}
+
+static VALUE mParser_do_yajl_parse(VALUE self, VALUE str, VALUE yajl_opts) {
   yajl_handle hand;
   yajl_status stat;
   unsigned char *err;
@@ -173,8 +182,26 @@ static VALUE mParser_do_yajl_parse(VALUE self, VALUE str, VALUE opts) {
   rb_ivar_set(self, rb_intern("key_stack"), rb_ary_new());
 
   ctx.self = self;
+  ctx.symbolizeKeys = get_opts_key(self, "symbolize_keys");
 
   hand = yajl_alloc(&callbacks, NULL, (void *)&ctx);
+
+  if (rb_hash_aref(yajl_opts, ID2SYM(rb_intern("yajl_allow_comments"))) == Qtrue) {
+    yajl_config(hand, yajl_allow_comments, 1);
+  }
+  if (rb_hash_aref(yajl_opts, ID2SYM(rb_intern("yajl_dont_validate_strings"))) == Qtrue) {
+    yajl_config(hand, yajl_dont_validate_strings, 1);
+  }
+  if (rb_hash_aref(yajl_opts, ID2SYM(rb_intern("yajl_allow_trailing_garbage"))) == Qtrue) {
+    yajl_config(hand, yajl_allow_trailing_garbage, 1);
+  }
+  if (rb_hash_aref(yajl_opts, ID2SYM(rb_intern("yajl_allow_multiple_values"))) == Qtrue) {
+    yajl_config(hand, yajl_allow_multiple_values, 1);
+  }
+  if (rb_hash_aref(yajl_opts, ID2SYM(rb_intern("yajl_allow_partial_values"))) == Qtrue) {
+    yajl_config(hand, yajl_allow_partial_values, 1);
+  }
+
   if ((stat = yajl_parse(hand, (unsigned char *)RSTRING_PTR(str), RSTRING_LEN(str))) != yajl_status_ok) {
     err = yajl_get_error(hand, 1, (unsigned char *)RSTRING_PTR(str), RSTRING_LEN(str));
     goto raise;

data/lib/ffi_yajl/benchmark/encode.rb

@@ -101,6 +101,11 @@ module FFI_Yajl
                 JSON.generate(hash)
               }
             }
+            x.report("JSON.fast_generate") {
+              times.times {
+                JSON.fast_generate(hash)
+              }
+            }
           end
           if defined?(Psych)
             x.report("Psych.to_json") {
@@ -120,13 +125,13 @@ module FFI_Yajl
               }
             end
           end
-          if defined?(ActiveSupport::JSON)
-            x.report("ActiveSupport::JSON.encode") {
-              times.times {
-                ActiveSupport::JSON.encode(hash)
-              }
-            }
-          end
+#          if defined?(ActiveSupport::JSON)
+#            x.report("ActiveSupport::JSON.encode") {
+#              times.times {
+#                ActiveSupport::JSON.encode(hash)
+#              }
+#            }
+#          end
         }
       end
     end

data/lib/ffi_yajl/benchmark/parse.rb

@@ -28,6 +28,10 @@ begin
   require 'active_support'
 rescue LoadError
 end
+begin
+  require 'oj'
+rescue LoadError
+end
 
 class FFI_Yajl::Benchmark::Parse
 
@@ -79,6 +83,15 @@ class FFI_Yajl::Benchmark::Parse
           }
         }
       end
+      if defined?(Oj)
+        x.report {
+          puts "Oj.load"
+          times.times {
+            json.rewind
+            Oj.load(json.read)
+          }
+        }
+      end
       if defined?(JSON)
         x.report {
           puts "JSON.parse"

data/lib/ffi_yajl/ext.rb

@@ -24,6 +24,7 @@ module FFI_Yajl
   elsif defined?(DL) && DL.respond_to?(:dlopen)
     ::DL.dlopen(libpath)
   else
+    extend ::FFI::Library
     ffi_lib libpath
   end
 

data/lib/ffi_yajl/ffi.rb

@@ -87,7 +87,7 @@ module FFI_Yajl
   attach_function :yajl_free_error, [:yajl_handle, :ustring], :void
 
   #
-  attach_function :yajl_config, [:yajl_handle, :yajl_option, :int], :int
+  attach_function :yajl_config, [:yajl_handle, :yajl_option, :varargs], :int
 
   attach_function :yajl_gen_config, [:yajl_gen, :yajl_gen_option, :varargs], :int
 

data/lib/ffi_yajl/ffi/parser.rb

@@ -51,7 +51,7 @@ module FFI_Yajl
           s = stringval.slice(0,stringlen)
           s.force_encoding('UTF-8') if defined? Encoding
           # XXX: I can't think of a better way to do this right now.  need to call to_f if and only if its a float.
-          v = ( s =~ /\./ ) ? s.to_f : s.to_i
+          v = ( s =~ /[\.eE]/ ) ? s.to_f : s.to_i
           set_value(v)
           1
         end
@@ -73,7 +73,7 @@ module FFI_Yajl
         @map_key_callback = ::FFI::Function.new(:int, [:pointer, :string, :size_t]) do |ctx, key, keylen|
           s = key.slice(0,keylen)
           s.force_encoding('UTF-8') if defined? Encoding
-          self.key = s
+          self.key = @opts[:symbolize_keys] ? s.to_sym : s
           1
         end
         @end_map_callback = ::FFI::Function.new(:int, [:pointer]) do |ctx|
@@ -94,7 +94,7 @@ module FFI_Yajl
       end
 
 
-      def do_yajl_parse(str, opts = {})
+      def do_yajl_parse(str, yajl_opts = {})
         setup_callbacks
         callback_ptr = ::FFI::MemoryPointer.new(::FFI_Yajl::YajlCallbacks)
         callbacks = ::FFI_Yajl::YajlCallbacks.new(callback_ptr)
@@ -110,6 +110,24 @@ module FFI_Yajl
         callbacks[:yajl_start_array] = @start_array_callback
         callbacks[:yajl_end_array] = @end_array_callback
         yajl_handle = ::FFI_Yajl.yajl_alloc(callback_ptr, nil, nil)
+
+        # configure the yajl parser
+        if yajl_opts[:yajl_allow_comments]
+          ::FFI_Yajl.yajl_config(yajl_handle, :yajl_allow_comments, :int, 1)
+        end
+        if yajl_opts[:yajl_dont_validate_strings]
+          ::FFI_Yajl.yajl_config(yajl_handle, :yajl_dont_validate_strings, :int, 1)
+        end
+        if yajl_opts[:yajl_allow_trailing_garbage]
+          ::FFI_Yajl.yajl_config(yajl_handle, :yajl_allow_trailing_garbage, :int, 1)
+        end
+        if yajl_opts[:yajl_allow_multiple_values]
+          ::FFI_Yajl.yajl_config(yajl_handle, :yajl_allow_multiple_values, :int, 1)
+        end
+        if yajl_opts[:yajl_allow_partial_values]
+          ::FFI_Yajl.yajl_config(yajl_handle, :yajl_allow_partial_values, :int, 1)
+        end
+
         if ( stat = ::FFI_Yajl.yajl_parse(yajl_handle, str, str.bytesize) != :yajl_status_ok )
           # FIXME: dup the error and call yajl_free_error?
           error = ::FFI_Yajl.yajl_get_error(yajl_handle, 1, str, str.bytesize)

data/lib/ffi_yajl/json_gem.rb

@@ -37,8 +37,7 @@ module JSON
   end
 
   def self.default_options
-    #@default_options ||= {:symbolize_keys => false}
-    @default_options ||= {}
+    @default_options ||= {:symbolize_keys => false}
   end
 
   def self.parse(str, opts=JSON.default_options)

data/lib/ffi_yajl/parser.rb

@@ -25,16 +25,35 @@ module FFI_Yajl
     end
 
     def initialize(opts = {})
-      @opts = opts
+      @opts = opts ? opts.dup : {}
+      # JSON gem uses 'symbolize_names' and ruby-yajl supports this as well
+      @opts[:symbolize_keys] = true if @opts[:symbolize_names]
     end
 
     def parse(str)
       # initialization that we can do in pure ruby
       yajl_opts = {}
 
+      if @opts[:check_utf8] == false && @opts[:dont_validate_strings] == false
+        raise ArgumentError, "options check_utf8 and dont_validate_strings are both false which conflict"
+      end
+      if @opts[:check_utf8] == true && @opts[:dont_validate_strings] == true
+        raise ArgumentError, "options check_utf8 and dont_validate_strings are both true which conflict"
+      end
+
+      yajl_opts[:yajl_allow_comments]         = @opts[:allow_comments]
+      yajl_opts[:yajl_dont_validate_strings]  = (@opts[:check_utf8] == false || @opts[:dont_validate_strings])
+      yajl_opts[:yajl_allow_trailing_garbage] = @opts[:allow_trailing_garbage]
+      yajl_opts[:yajl_allow_multiple_values]  = @opts[:allow_multiple_values]
+      yajl_opts[:yajl_allow_partial_values]   = @opts[:allow_partial_values]
+
       # XXX: bug-compat with ruby-yajl
       return nil if str == ""
 
+      if str.respond_to?(:read)
+        str = str.read()
+      end
+
       # call either the ext or ffi hook
       do_yajl_parse(str, yajl_opts)
     end

data/lib/ffi_yajl/version.rb

@@ -1,3 +1,3 @@
 module FFI_Yajl
-  VERSION = "0.1.7"
+  VERSION = "0.2.0"
 end

data/spec/ffi_yajl/json_gem_spec.rb

@@ -11,7 +11,7 @@ describe "JSON Gem Compat API" do
 
   # Magic to make the before loading tests actually run before loading
   RSpec.configure do |config|
-    config.order_groups_and_examples do |list|
+    config.register_ordering(:global) do |list|
       list.sort_by { |item| item.description }
     end
   end
@@ -19,39 +19,39 @@ describe "JSON Gem Compat API" do
   context "A: before loading the compat library" do
     it "should not mixin #to_json on random objects" do
       d = Dummy.new
-      expect(d.respond_to?(:to_json)).to be_false
+      expect(d.respond_to?(:to_json)).to be false
     end
 
     it "should not mixin #to_json to a string" do
-      expect("".respond_to?(:to_json)).to be_false
+      expect("".respond_to?(:to_json)).to be false
     end
 
     it "should not mixin #to_json to a fixnum" do
-      expect(1.respond_to?(:to_json)).to be_false
+      expect(1.respond_to?(:to_json)).to be false
     end
 
     it "should not mixin #to_json on a float" do
-      expect("1.5".to_f.respond_to?(:to_json)).to be_false
+      expect("1.5".to_f.respond_to?(:to_json)).to be false
     end
 
     it "should not mixin #to_json on an array" do
-      expect([].respond_to?(:to_json)).to be_false
+      expect([].respond_to?(:to_json)).to be false
     end
 
     it "should not mixin #to_json on a hash" do
-      expect({ :foo => "bar" }.respond_to?(:to_json)).to be_false
+      expect({ :foo => "bar" }.respond_to?(:to_json)).to be false
     end
 
     it "should not mixin #to_json on a trueclass" do
-      expect(true.respond_to?(:to_json)).to be_false
+      expect(true.respond_to?(:to_json)).to be false
     end
 
     it "should not mixin #to_json on a falseclass" do
-      expect(false.respond_to?(:to_json)).to be_false
+      expect(false.respond_to?(:to_json)).to be false
     end
 
     it "should not mixin #to_json on a nilclass" do
-      expect(nil.respond_to?(:to_json)).to be_false
+      expect(nil.respond_to?(:to_json)).to be false
     end
   end
 
@@ -62,66 +62,60 @@ describe "JSON Gem Compat API" do
     end
 
     it "should define JSON class" do
-      expect(defined?(JSON)).to be_true
+      expect(defined?(JSON)).to be_truthy
     end
 
     it "should implement JSON#parse" do
-      expect(JSON.respond_to?(:parse)).to be_true
+      expect(JSON.respond_to?(:parse)).to be true
     end
 
     it "should implement JSON#generate" do
-      expect(JSON.respond_to?(:generate)).to be_true
+      expect(JSON.respond_to?(:generate)).to be true
     end
 
     it "should implement JSON#pretty_generate" do
-      expect(JSON.respond_to?(:pretty_generate)).to be_true
+      expect(JSON.respond_to?(:pretty_generate)).to be true
     end
 
     it "should implement JSON#load" do
-      expect(JSON.respond_to?(:load)).to be_true
+      expect(JSON.respond_to?(:load)).to be true
     end
 
     it "should implement JSON#dump" do
-      expect(JSON.respond_to?(:dump)).to be_true
+      expect(JSON.respond_to?(:dump)).to be true
     end
 
     context "when setting symbolize_keys via JSON.default_options" do
-      before(:all) { @saved_default = JSON.default_options[:symbolize_keys] }
-      after(:all) { JSON.default_options[:symbolize_keys] = @saved_default }
+      after(:each) { JSON.default_options[:symbolize_keys] = false }
 
       it "the default behavior should be to not symbolize keys" do
         expect(JSON.parse('{"foo": 1234}')).to eq( "foo" => 1234 )
       end
 
       it "changing the default_options should change the behavior to true" do
-        skip("implement symbolize keys")
         JSON.default_options[:symbolize_keys] = true
         expect(JSON.parse('{"foo": 1234}')).to eq( :foo => 1234 )
       end
     end
 
     context "when setting symbolize_names via JSON.default_options" do
-      before(:all) { @saved_default = JSON.default_options[:symbolize_names] }
-      after(:all) { JSON.default_options[:symbolize_names] = @saved_default }
+      after { JSON.default_options.delete(:symbolize_names)}
 
       it "the default behavior should be to not symbolize keys" do
         expect(JSON.parse('{"foo": 1234}')).to eq( "foo" => 1234 )
       end
 
       it "changing the default_options should change the behavior to true" do
-        skip("implement symbolize keys")
         JSON.default_options[:symbolize_names] = true
         expect(JSON.parse('{"foo": 1234}')).to eq( :foo => 1234 )
       end
     end
 
     it "should support passing symbolize_names to JSON.parse" do
-      skip("implement symbolize keys")
       expect(JSON.parse('{"foo": 1234}', :symbolize_names => true)).to eq( :foo => 1234 )
     end
 
     it "should support passing symbolize_keys to JSON.parse" do
-      skip("implement symbolize keys")
       expect(JSON.parse('{"foo": 1234}', :symbolize_keys => true)).to eq( :foo => 1234 )
     end
 
@@ -149,13 +143,13 @@ describe "JSON Gem Compat API" do
 
     context "JSON exception classes" do
       it "should define JSON::JSONError as a StandardError" do
-        expect(JSON::JSONError.new.is_a?(StandardError)).to be_true
+        expect(JSON::JSONError.new.is_a?(StandardError)).to be true
       end
       it "should define JSON::ParserError as a JSON::JSONError" do
-        expect(JSON::ParserError.new.is_a?(JSON::JSONError)).to be_true
+        expect(JSON::ParserError.new.is_a?(JSON::JSONError)).to be true
       end
       it "should define JSON::GeneratorError as a JSON::JSONError" do
-        expect(JSON::GeneratorError.new.is_a?(JSON::JSONError)).to be_true
+        expect(JSON::GeneratorError.new.is_a?(JSON::JSONError)).to be true
       end
       it "should raise JSON::ParserError on a bad parse" do
         expect{ JSON.parse("blah") }.to raise_error(JSON::ParserError)

data/spec/ffi_yajl/parser_spec.rb

@@ -4,79 +4,473 @@ require 'spec_helper'
 
 describe "FFI_Yajl::Parser" do
 
-  let(:parser) { FFI_Yajl::Parser.new }
+  shared_examples_for "correct json parsing" do
+    context "when json has 23456789012E666" do
+      let(:json) {  '{"key": 23456789012E666}' }
 
-  it "returns nil for an empty string (compatibility with yajl-ruby)" do
-    json = ''
-    expect( parser.parse(json) ).to be_nil
-  end
+      it "should return infinity" do
+        infinity = (1.0/0)
+        expect(parser).to eq({"key" => infinity})
+      end
+    end
 
-  it "throws an exception when trailing braces are missing" do
-     json = '{{"foo": 1234}'
-     expect { parser.parse(json) }.to raise_error(FFI_Yajl::ParseError)
-  end
+    context "when json has comments" do
+      let(:json) { '{"key": /* this is a comment */ "value"}' }
 
-  it "throws an exception when trailing brackets are missing" do
-     json = '[["foo", "bar"]'
-     expect { parser.parse(json) }.to raise_error(FFI_Yajl::ParseError)
-  end
+      context "when allow_comments is false" do
+        let(:options) { { :allow_comments => false } }
 
-  it "throws an exception when it has an extra brace" do
-     json = '{{"foo": 1234}}}'
-     expect { parser.parse(json) }.to raise_error(FFI_Yajl::ParseError)
-  end
+        it "should not parse" do
+          expect{parser}.to raise_error(FFI_Yajl::ParseError)
+        end
+      end
 
-  it "throws an exception when it has an extra bracket" do
-     json = '[["foo", "bar"]]]'
-     expect { parser.parse(json) }.to raise_error(FFI_Yajl::ParseError)
-  end
+      context "when allow_comments is true" do
+        let(:options) { { :allow_comments => true } }
+
+        it "should parse" do
+          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"}} }
+
+      context "when allow_comments is false" do
+        let(:options) { { :allow_comments => false } }
+
+        it "should not parse" do
+          expect{parser}.to raise_error(FFI_Yajl::ParseError)
+        end
+      end
+
+      context "when allow_comments is true" do
+        let(:options) { { :allow_comments => true } }
+
+        it "should parse" do
+          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"}} }
+
+      context "when allow_comments is false" do
+        let(:options) { { :allow_comments => false } }
+
+        it "should not parse" do
+          expect{parser}.to raise_error(FFI_Yajl::ParseError)
+        end
+      end
+
+      context "when allow_comments is true" do
+        let(:options) { { :allow_comments => true } }
+
+        it "should parse" do
+          expect(parser).to eq({"key"=>"value"})
+        end
+      end
+    end
+
+    context "when json is invalid UTF8" do
+      let(:json) { "[\"#{"\201\203"}\"]" }
+
+      it "should not parse by default" do
+        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 } }
+
+        it "should parse" do
+          expect(parser).to eq(["\x81\x83"])
+        end
+      end
+
+      context "when :dont_validate_strings is set to false" do
+        let(:options) { { :dont_validate_strings => false } }
+
+        it "should not parse" do
+          expect{parser}.to raise_error(FFI_Yajl::ParseError)
+        end
+      end
+
+      context "when :check_utf8 is set to true" do
+        let(:options) { { :check_utf8 => true } }
+
+        it "should not parse" do
+          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 } }
+
+          it "should raise an ArgumentError" do
+            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 } }
+
+          it "should not parse" do
+            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 } }
+
+        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 } }
+
+          it "should parse" do
+            expect(parser).to eq(["\x81\x83"])
+          end
+        end
+
+        context "when :dont_validate_strings is set to false" do
+          let(:options) { { :check_utf8 => false, :dont_validate_strings => false } }
+
+          it "should raise an ArgumentError" do
+            expect{parser}.to raise_error(ArgumentError)
+          end
+        end
+      end
+    end
+
+    context "when JSON is a StringIO" do
+      let(:json) { StringIO.new('{"key": 1234}') }
+
+      it "should parse" do
+        expect(parser).to eq({"key" => 1234})
+      end
+    end
+
+    context "when parsing a JSON string" do
+      let(:json) { '{"key": 1234}' }
+
+      it "should parse correctly" do
+        expect(parser).to eq({"key" => 1234})
+      end
+
+      context "when symbolize_keys is true" do
+        let(:options) { { :symbolize_keys => true } }
+
+        it "should symbolize keys correctly" do
+          expect(parser).to eq({:key => 1234})
+        end
+      end
+
+      context "when passing a block" do
+        it "should parse correctly" do
+          skip "handle blocks"
+          output = nil
+          parser do |obj|
+            output = obj
+          end
+          expect(output).to eq({"key" => 1234})
+        end
+      end
+    end
+
+    context "when parsing a JSON hash with only strings" do
+      let(:json) { '{"key": "value"}' }
+
+      if RUBY_VERSION.to_f >= 1.9
+        context "when Encoding.default_internal is nil" do
+          before do
+            @saved_encoding = Encoding.default_internal
+            Encoding.default_internal = nil
+          end
+          after do
+            Encoding.default_internal = @saved_encoding
+          end
+          it "encodes keys to UTF-8" do
+            expect(parser.keys.first.encoding).to eql(Encoding.find('utf-8'))
+          end
+          it "encodes values to UTF-8" do
+            expect(parser.values.first.encoding).to eql(Encoding.find('utf-8'))
+          end
+        end
+
+        %w{utf-8 us-ascii}.each do |encoding|
+          context "when Encoding.default_internal is #{encoding}" do
+            before do
+              @saved_encoding = Encoding.default_internal
+              Encoding.default_internal = nil
+            end
+            after do
+              Encoding.default_internal = @saved_encoding
+            end
+            it "encodes keys to #{encoding}" do
+              skip "fix us-ascii" if encoding == "us-ascii"
+              expect(parser.keys.first.encoding).to eql(Encoding.find(encoding))
+            end
+            it "encodes values to #{encoding}" do
+              skip "fix us-ascii" if encoding == "us-ascii"
+              expect(parser.values.first.encoding).to eql(Encoding.find(encoding))
+            end
+          end
+        end
+      end
+    end
+
+    context "when a parsed key has utf-8 multibyte characters" do
+      let(:json) { '{"日本語": 1234}' }
+
+      it "should parse correctly" do
+        expect(parser).to eq({"日本語" => 1234})
+      end
+
+      context "when symbolize_keys is true" do
+        let(:options) { { :symbolize_keys => true } }
+
+        it "should symbolize keys correctly" do
+          expect(parser).to eq({:"日本語" => 1234})
+        end
 
-  context "when parsing floats" do
-    it "parses simple floating point values" do
-      json = '{"foo": 3.14159265358979}'
-      expect(parser.parse(json)).to eql( "foo" => 3.14159265358979 )
+        if RUBY_VERSION.to_f >= 1.9
+          it "should parse non-ascii symbols in UTF-8" do
+            expect(parser.keys.fetch(0).encoding).to eq(Encoding::UTF_8)
+          end
+        end
+      end
     end
 
-    it "parses simple negative floating point values" do
-      json = '{"foo":-2.00231930436153}'
-      expect(parser.parse(json)).to eql( "foo" => -2.00231930436153 )
+    context "when parsing 2147483649" do
+      let(:json) { "{\"id\": 2147483649}" }
+
+      it "should parse corectly" do
+        expect(parser).to eql({"id" => 2147483649})
+      end
+    end
+
+    context "when parsing 5687389800" do
+      let(:json) { "{\"id\": 5687389800}" }
+
+      it "should parse corectly" do
+        expect(parser).to eql({"id" => 5687389800})
+      end
+    end
+
+    context "when parsing 1046289770033519442869495707521600000000" do
+      let(:json) { "{\"id\": 1046289770033519442869495707521600000000}" }
+
+      it "should parse corectly" do
+        expect(parser).to eql({"id" => 1046289770033519442869495707521600000000})
+      end
+    end
+
+    # NOTE: we are choosing to be compatible with yajl-ruby here vs. JSON
+    # gem and libyajl C behavior (which is to throw an exception in this case)
+    context "when the JSON is empty string" do
+      let(:json) { '' }
+
+      it "returns nil" do
+        expect(parser).to be_nil
+      end
+    end
+
+    # NOTE: this fixes yajl-ruby being too permissive
+    context "when dealing with too much or too little input" do
+      context "when trailing braces are missing" do
+        let(:json) { '{"foo":{"foo": 1234}' }
+
+        it "raises an exception" do
+          expect { parser }.to raise_error(FFI_Yajl::ParseError)
+        end
+      end
+
+      context "when trailing brackets are missing" do
+        let(:json) { '[["foo", "bar"]' }
+
+        it "raises an exception" do
+          expect { parser }.to raise_error(FFI_Yajl::ParseError)
+        end
+      end
+
+      context "when an extra brace is present" do
+        let(:json) { '{"foo":{"foo": 1234}}}' }
+
+        it "raises an exception" do
+          expect { parser }.to raise_error(FFI_Yajl::ParseError)
+        end
+
+        context "with allow_trailing_garbage" do
+          let(:options) { { :allow_trailing_garbage => true } }
+          it "parses" do
+            expect(parser).to eq({"foo"=>{"foo"=>1234}})
+          end
+        end
+
+      end
+
+      context "when an extra bracket is present" do
+        let(:json) { '[["foo", "bar"]]]' }
+
+        it "raises an exception" do
+          expect { parser }.to raise_error(FFI_Yajl::ParseError)
+        end
+      end
+    end
+
+    context "when parsing heavy metal umlauts in keys" do
+      let(:json) { '{"München": "Bayern"}' }
+
+      it "correctly parses" do
+        expect(parser).to eql( "München" => "Bayern" )
+      end
+    end
+
+    context "when parsing floats" do
+      context "parses simple floating point values" do
+        let(:json) { '{"foo": 3.14159265358979}' }
+
+        it "correctly parses" do
+          expect(parser).to eql( "foo" => 3.14159265358979 )
+        end
+      end
+
+      context "parses simple negative floating point values" do
+        let(:json) { '{"foo":-2.00231930436153}' }
+
+        it "correctly parses" do
+          expect(parser).to eql( "foo" => -2.00231930436153 )
+        end
+      end
+
+      context "parses floats with negative exponents and a large E" do
+        let(:json) { '{"foo": 1.602176565E-19}' }
+
+        it "correctly parses" do
+          expect(parser).to eql( "foo" => 1.602176565e-19 )
+        end
+      end
+
+      context "parses floats with negative exponents and a small e" do
+        let(:json) { '{"foo": 6.6260689633e-34 }' }
+
+        it "correctly parses" do
+          expect(parser).to eql( "foo" => 6.6260689633e-34 )
+        end
+      end
+
+      context "parses floats with positive exponents and a large E" do
+        let(:json) { '{"foo": 6.0221413E+23}' }
+
+        it "correctly parses" do
+          expect(parser).to eql( "foo" => 6.0221413e+23 )
+        end
+      end
+
+      context "parses floats with positive exponents and a small e" do
+        let(:json) { '{"foo": 8.9875517873681764e+9 }' }
+
+        it "correctly parses" do
+          expect(parser).to eql( "foo" => 8.9875517873681764e+9 )
+        end
+      end
+
+      context "parses floats with an exponent without a sign and a large E" do
+        let(:json) { '{"foo": 2.99792458E8  }' }
+
+        it "correctly parses" do
+          expect(parser).to eql( "foo" => 2.99792458e+8 )
+        end
+      end
+
+      context "parses floats with an exponent without a sign and a small e" do
+        let(:json) { '{"foo": 1.0973731568539e7 }' }
+
+        it "correctly parses" do
+          expect(parser).to eql( "foo" => 1.0973731568539e+7 )
+        end
+      end
     end
 
-    it "parses floats with negative exponents and a large E" do
-      json = '{"foo": 1.602176565E-19}'
-      expect(parser.parse(json)).to eql( "foo" => 1.602176565e-19 )
+    context "when parsing big floats", :ruby_gte_193 => true do
+      let(:json) { '[0.' + '1' * 2**23 + ']' }
+
+      it "parses" do
+        expect{ parser }.not_to raise_error
+      end
     end
 
-    it "parses floats with negative exponents and a small e" do
-      json = '{"foo": 6.6260689633e-34 }'
-      expect(parser.parse(json)).to eql( "foo" => 6.6260689633e-34 )
+    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 } }
+
+      it "parses" do
+        expect{ parser }.not_to raise_error
+      end
     end
+  end
+
+  context "when options are set to empty hash" do
+    let(:options) { {} }
+
+    context "when using a parsing object" do
+      let(:parser) { FFI_Yajl::Parser.new(options).parse(json) }
 
-    it "parses floats with positive exponents and a large E" do
-      json = '{"foo": 6.0221413E+23}'
-      expect(parser.parse(json)).to eql( "foo" => 6.0221413e+23 )
+      it_behaves_like "correct json parsing"
     end
 
-    it "parses floats with positive exponents and a small e" do
-      json = '{"foo": 8.9875517873681764e+9 }'
-      expect(parser.parse(json)).to eql( "foo" => 8.9875517873681764e+9 )
+    context "when using the class method" do
+      let(:parser) { FFI_Yajl::Parser.parse(json, options) }
+
+      it_behaves_like "correct json parsing"
     end
+  end
+
+  context "when options are set to nil" do
+    let(:options) { nil }
 
-    it "parses floats with an exponent without a sign and a large E" do
-      json = '{"foo": 2.99792458E8  }'
-      expect(parser.parse(json)).to eql( "foo" => 2.99792458e+8 )
+    context "when using a parsing object" do
+      let(:parser) { FFI_Yajl::Parser.new(options).parse(json) }
+
+      it_behaves_like "correct json parsing"
     end
 
-    it "parses floats with an exponent without a sign and a small e" do
-      json = '{"foo": 1.0973731568539e7 }'
-      expect(parser.parse(json)).to eql( "foo" => 1.0973731568539e+7 )
+    context "when using the class method" do
+      let(:parser) { FFI_Yajl::Parser.parse(json, options) }
+
+      it_behaves_like "correct json parsing"
     end
   end
 
-  context "when parsing unicode in hash keys" do
-    it "handles heavy metal umlauts in keys" do
-      json = '{"München": "Bayern"}'
-      expect(parser.parse(json)).to eql( "München" => "Bayern" )
+  context "when options default to nothing" do
+    let(:options) { nil }
+
+    context "when using a parsing object" do
+      let(:parser) do
+        if options.nil?
+          FFI_Yajl::Parser.new.parse(json)
+        else
+          FFI_Yajl::Parser.new(options).parse(json)
+        end
+      end
+
+      it_behaves_like "correct json parsing"
+    end
+
+    context "when using the class method" do
+      let(:parser) do
+        if options.nil?
+          FFI_Yajl::Parser.parse(json)
+        else
+          FFI_Yajl::Parser.parse(json, options)
+        end
+      end
+
+      it_behaves_like "correct json parsing"
     end
   end
 end

data/spec/spec_helper.rb

@@ -4,6 +4,7 @@ require 'ffi_yajl'
 
 RSpec.configure do |c|
   c.filter_run_excluding :ruby_gte_19 => true unless RUBY_VERSION.to_f >= 1.9
+  c.filter_run_excluding :ruby_gte_193 => true unless RUBY_VERSION.to_f >= 2.0 || RUBY_VERSION =~ /^1\.9\.3/
 
   c.order = 'random'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffi-yajl
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.0
 platform: ruby
 authors:
 - Lamont Granquist
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-14 00:00:00.000000000 Z
+date: 2014-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake