oj 2.18.3 → 2.18.4

data/ext/oj/oj.c

@@ -130,6 +130,7 @@ static VALUE	mode_sym;
 static VALUE	nan_sym;
 static VALUE	newline_sym;
 static VALUE	nilnil_sym;
+static VALUE	empty_string_sym;
 static VALUE	null_sym;
 static VALUE	object_sym;
 static VALUE	omit_nil_sym;
@@ -184,6 +185,7 @@ struct _Options	oj_default_options = {
     No,		// to_json
     No,		// as_json
     No,		// nilnil
+    Yes,	// empty_string
     Yes,	// allow_gc
     Yes,	// quirks_mode
     No,		// allow_invalid    
@@ -231,6 +233,7 @@ static VALUE	define_mimic_json(int argc, VALUE *argv, VALUE self);
  * - use_to_json: [true|false|nil] call to_json() methods on dump, default is false
  * - use_as_json: [true|false|nil] call as_json() methods on dump, default is false
  * - nilnil: [true|false|nil] if true a nil input to load will return nil and not raise an Exception
+ * - empty_string: [true|false|nil] if true an empty input will not raise an Exception
  * - allow_gc: [true|false|nil] allow or prohibit GC during parsing, default is true (allow)
  * - quirks_mode: [true,|false|nil] Allow single JSON values instead of documents, default is true (allow)
  * - allow_invalid_unicode: [true,|false|nil] Allow invalid unicode, default is false (don't allow)
@@ -262,6 +265,7 @@ get_def_opts(VALUE self) {
     rb_hash_aset(opts, use_to_json_sym, (Yes == oj_default_options.to_json) ? Qtrue : ((No == oj_default_options.to_json) ? Qfalse : Qnil));
     rb_hash_aset(opts, use_as_json_sym, (Yes == oj_default_options.as_json) ? Qtrue : ((No == oj_default_options.as_json) ? Qfalse : Qnil));
     rb_hash_aset(opts, nilnil_sym, (Yes == oj_default_options.nilnil) ? Qtrue : ((No == oj_default_options.nilnil) ? Qfalse : Qnil));
+    rb_hash_aset(opts, empty_string_sym, (Yes == oj_default_options.empty_string) ? Qtrue : ((No == oj_default_options.empty_string) ? Qfalse : Qnil));
     rb_hash_aset(opts, allow_gc_sym, (Yes == oj_default_options.allow_gc) ? Qtrue : ((No == oj_default_options.allow_gc) ? Qfalse : Qnil));
     rb_hash_aset(opts, quirks_mode_sym, (Yes == oj_default_options.quirks_mode) ? Qtrue : ((No == oj_default_options.quirks_mode) ? Qfalse : Qnil));
     rb_hash_aset(opts, allow_invalid_unicode_sym, (Yes == oj_default_options.allow_invalid) ? Qtrue : ((No == oj_default_options.allow_invalid) ? Qfalse : Qnil));
@@ -378,6 +382,7 @@ oj_parse_options(VALUE ropts, Options copts) {
 	{ use_to_json_sym, &copts->to_json },
 	{ use_as_json_sym, &copts->as_json },
 	{ nilnil_sym, &copts->nilnil },
+	{ empty_string_sym, &copts->empty_string },
 	{ allow_gc_sym, &copts->allow_gc },
 	{ quirks_mode_sym, &copts->quirks_mode },
 	{ allow_invalid_unicode_sym, &copts->allow_invalid },
@@ -1525,7 +1530,7 @@ stream_writer_push_value(int argc, VALUE *argv, VALUE self) {
 	oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, 0);
 	break;
     case 2:
-	if (Qnil == argv[0]) {
+	if (Qnil == argv[1]) {
 	    oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, 0);
 	} else {
 	    rb_check_type(argv[1], T_STRING);
@@ -1805,7 +1810,7 @@ mimic_pretty_generate(int argc, VALUE *argv, VALUE self) {
 
     strcpy(copts.dump_opts.indent_str, "  ");
     copts.dump_opts.indent_size = (uint8_t)strlen(copts.dump_opts.indent_str);
-    strcpy(copts.dump_opts.before_sep, " ");
+    strcpy(copts.dump_opts.before_sep, "");
     copts.dump_opts.before_size = (uint8_t)strlen(copts.dump_opts.before_sep);
     strcpy(copts.dump_opts.after_sep, " ");
     copts.dump_opts.after_size = (uint8_t)strlen(copts.dump_opts.after_sep);
@@ -1832,6 +1837,7 @@ mimic_parse(int argc, VALUE *argv, VALUE self) {
     pi.options.auto_define = No;
     pi.options.quirks_mode = No;
     pi.options.allow_invalid = No;
+    pi.options.empty_string = No;
 
     if (2 <= argc) {
 	VALUE	ropts = argv[1];
@@ -1919,6 +1925,7 @@ static struct _Options	mimic_object_to_json_options = {
     No,		// to_json
     Yes,	// as_json
     Yes,	// nilnil
+    Yes,	// empty_string
     Yes,	// allow_gc
     Yes,	// quirks_mode
     No,		// allow_invalid
@@ -2258,6 +2265,7 @@ void Init_oj() {
     nan_sym = ID2SYM(rb_intern("nan"));			rb_gc_register_address(&nan_sym);
     newline_sym = ID2SYM(rb_intern("newline"));		rb_gc_register_address(&newline_sym);
     nilnil_sym = ID2SYM(rb_intern("nilnil"));		rb_gc_register_address(&nilnil_sym);
+    empty_string_sym = ID2SYM(rb_intern("empty_string"));rb_gc_register_address(&empty_string_sym);
     null_sym = ID2SYM(rb_intern("null"));		rb_gc_register_address(&null_sym);
     object_nl_sym = ID2SYM(rb_intern("object_nl"));	rb_gc_register_address(&object_nl_sym);
     object_sym = ID2SYM(rb_intern("object"));		rb_gc_register_address(&object_sym);

data/ext/oj/oj.h

@@ -156,6 +156,7 @@ typedef struct _Options {
     char		to_json;	// YesNo
     char		as_json;	// YesNo
     char		nilnil;		// YesNo
+    char		empty_string;	// YesNo
     char		allow_gc;	// allow GC during parse
     char		quirks_mode;	// allow single JSON values instead of documents
     char		allow_invalid;	// YesNo - allow invalid unicode

data/ext/oj/parse.c

@@ -598,6 +598,13 @@ oj_parse2(ParseInfo pi) {
 	if (!first && '\0' != *pi->cur) {
 	    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected characters after the JSON document");
 	}
+
+	// if no tokens are consumed (i.e. empty string), throw a parse error
+	// this is the behavior of JSON.parse in both Ruby and JS
+	if (No == pi->options.empty_string && 1 == first && '\0' == *pi->cur) {
+	    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected character");
+	}
+
 	switch (*pi->cur++) {
 	case '{':
 	    hash_start(pi);

data/lib/oj/version.rb

@@ -1,5 +1,5 @@
 
 module Oj
   # Current version of the module. 
-  VERSION = '2.18.3'
+  VERSION = '2.18.4'
 end

data/test/foo.rb

@@ -1,24 +1,7 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-$VERBOSE = true
-
-here = File.expand_path(File.dirname(__FILE__))
 $: << File.dirname(__FILE__)
-$: << File.join(File.dirname(here), 'ext')
-$: << File.join(File.dirname(here), 'lib')
-
-require 'oj'
-
-Oj.mimic_JSON()
-
-class Foo
-  def as_json
-    { foo: 'bar' }
-  end
-end
-
-opts = {}
 
-puts Foo.new.to_json
-puts Foo.new.to_json(opts)
+require 'test_strict'
+require 'test_compat'

data/test/isolated/shared.rb

@@ -164,6 +164,12 @@ class SharedMimicTest < Minitest::Test
     assert_raises(JSON::ParserError) { JSON.parse(json) }
   end
 
+  def test_parse_with_empty_string
+    Oj.mimic_JSON
+    assert_raises(JSON::ParserError) { JSON.parse(' ') }
+    assert_raises(JSON::ParserError) { JSON.parse("\t\t\n   ") }
+  end
+
 # []
   def test_bracket_load
     json = %{{"a":1,"b":[true,false]}}
@@ -217,18 +223,18 @@ class SharedMimicTest < Minitest::Test
   def test_pretty_generate
     json = JSON.pretty_generate({ 'a' => 1, 'b' => [true, false]})
     assert(%{{
-  "a" : 1,
-  "b" : [
+  "a": 1,
+  "b": [
     true,
     false
   ]
 }} == json ||
 %{{
-  "b" : [
+  "b": [
     true,
     false
   ],
-  "a" : 1
+  "a": 1
 }} == json)
   end
 

data/test/isolated/test_mimic_rails_after.rb

@@ -7,9 +7,9 @@ require 'helper'
 
 begin
   require 'rails/all'
-rescue Exception => e
-  puts "*** #{e.class}: #{e.message}"
-  Process.exit!(false)
+rescue LoadError => e
+  puts "Rails are not in the gemfile, skipping tests"
+  Process.exit
 end
 
 Oj.mimic_JSON

data/test/isolated/test_mimic_rails_before.rb

@@ -8,9 +8,9 @@ require 'helper'
 Oj.mimic_JSON
 begin
   require 'rails/all'
-rescue Exception
-  puts "*** require of rails failed"
-  Process.exit!(true)
+rescue LoadError => e
+  puts "Rails are not in the gemfile, skipping tests"
+  Process.exit
 end
 
 require 'isolated/shared'

data/test/mem.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+require 'oj'
+
+h = {
+  'a' => 1,
+  'b' => 2,
+  'c' => 3,
+  'd' => 4,
+  'e' => 5,
+}
+
+10000.times do
+  GC.start
+  Oj.dump(h)
+end

data/test/omit.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+require 'oj'
+require 'stringio'
+require 'parallel'
+
+h = { a: 1, b: nil, c: 3 }
+outputs = Parallel.map((0...30).to_a, in_process: 30) do |i|
+  io = StringIO.new('wb+')
+  Oj.to_stream(io, h, omit_nil: false)
+  io.string
+end
+
+outputs.each do |output|
+  puts output
+end

data/test/rails_datetime_test.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+$: << File.dirname(__FILE__)
+
+%w(lib ext test).each do |dir|
+  $LOAD_PATH.unshift File.expand_path("../../#{dir}", __FILE__)
+end
+
+require 'sqlite3'
+require "rails/all"
+require "active_model"
+
+date = DateTime.now
+
+puts date.to_json
+
+require "oj"
+
+puts "OJ.dump(DateTime.now)"
+puts
+puts Oj.dump(DateTime.now)
+puts
+

data/test/test_custom.rb

@@ -0,0 +1,399 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+$: << File.dirname(__FILE__)
+
+=begin
+require 'helper'
+
+class CompatJuice < Minitest::Test
+
+  class Jeez
+    attr_accessor :x, :y
+
+    def initialize(x, y)
+      @x = x
+      @y = y
+    end
+
+    def eql?(o)
+      self.class == o.class && @x == o.x && @y == o.y
+    end
+    alias == eql?
+
+    def to_json()
+      {"json_class" => self.class.to_s,"x" => @x,"y" => @y}.to_s
+    end
+
+    def self.json_create(h)
+      self.new(h['x'], h['y'])
+    end
+  end # Jeez
+
+  module One
+    module Two
+      module Three
+        class Deep
+
+          def initialize()
+          end
+
+          def eql?(o)
+            self.class == o.class
+          end
+          alias == eql?
+
+          def to_json(*a)
+            %{{"json_class":"#{self.class.name}"}}
+          end
+
+          def self.json_create(h)
+            self.new()
+          end
+        end # Deep
+      end # Three
+    end # Two
+  end # One
+
+  def setup
+    @default_options = Oj.default_options
+    # in compat mode other options other than the JSON gem globals and options
+    # are not used.
+    Oj.default_options = { :mode => :compat }
+  end
+
+  def teardown
+    Oj.default_options = @default_options
+  end
+
+  def test_nil
+    dump_and_load(nil, false)
+  end
+
+  def test_true
+    dump_and_load(true, false)
+  end
+
+  def test_false
+    dump_and_load(false, false)
+  end
+
+  def test_fixnum
+    dump_and_load(0, false)
+    dump_and_load(12345, false)
+    dump_and_load(-54321, false)
+    dump_and_load(1, false)
+  end
+
+  def test_float
+    dump_and_load(0.0, false)
+    dump_and_load(12345.6789, false)
+    dump_and_load(70.35, false)
+    dump_and_load(-54321.012, false)
+    dump_and_load(1.7775, false)
+    dump_and_load(2.5024, false)
+    dump_and_load(2.48e16, false)
+    dump_and_load(2.48e100 * 1.0e10, false)
+    dump_and_load(-2.48e100 * 1.0e10, false)
+  end
+
+  def test_string
+    dump_and_load('', false)
+    dump_and_load('abc', false)
+    dump_and_load("abc\ndef", false)
+    dump_and_load("a\u0041", false)
+  end
+
+  def test_encode
+    opts = Oj.default_options
+    Oj.default_options = { :ascii_only => false }
+    unless 'jruby' == $ruby
+      dump_and_load("ぴーたー", false)
+    end
+    Oj.default_options = { :ascii_only => true }
+    json = Oj.dump("ぴーたー")
+    assert_equal(%{"\\u3074\\u30fc\\u305f\\u30fc"}, json)
+    unless 'jruby' == $ruby
+      dump_and_load("ぴーたー", false)
+    end
+    Oj.default_options = opts
+  end
+
+  def test_unicode
+    # hits the 3 normal ranges and one extended surrogate pair
+    json = %{"\\u019f\\u05e9\\u3074\\ud834\\udd1e"}
+    obj = Oj.load(json)
+    json2 = Oj.dump(obj, :ascii_only => true)
+    assert_equal(json, json2)
+  end
+
+  def test_array
+    dump_and_load([], false)
+    dump_and_load([true, false], false)
+    dump_and_load(['a', 1, nil], false)
+    dump_and_load([[nil]], false)
+    dump_and_load([[nil], 58], false)
+  end
+
+  def test_array_deep
+    dump_and_load([1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12,[13,[14,[15,[16,[17,[18,[19,[20]]]]]]]]]]]]]]]]]]]], false)
+  end
+
+  # Hash
+  def test_hash
+    dump_and_load({}, false)
+    dump_and_load({ 'true' => true, 'false' => false}, false)
+    dump_and_load({ 'true' => true, 'array' => [], 'hash' => { }}, false)
+  end
+
+  def test_hash_deep
+    dump_and_load({'1' => {
+                      '2' => {
+                        '3' => {
+                          '4' => {
+                            '5' => {
+                              '6' => {
+                                '7' => {
+                                  '8' => {
+                                    '9' => {
+                                      '10' => {
+                                        '11' => {
+                                          '12' => {
+                                            '13' => {
+                                              '14' => {
+                                                '15' => {
+                                                  '16' => {
+                                                    '17' => {
+                                                      '18' => {
+                                                        '19' => {
+                                                          '20' => {}}}}}}}}}}}}}}}}}}}}}, false)
+  end
+
+  def test_hash_escaped_key
+    json = %{{"a\nb":true,"c\td":false}}
+    obj = Oj.compat_load(json)
+    assert_equal({"a\nb" => true, "c\td" => false}, obj)
+  end
+
+  def test_bignum_object
+    dump_and_load(7 ** 55, false)
+  end
+
+  # BigDecimal
+  def test_bigdecimal_compat
+    dump_and_load(BigDecimal.new('3.14159265358979323846'), false)
+  end
+
+  def test_bigdecimal_load
+    orig = BigDecimal.new('80.51')
+    json = Oj.dump(orig, :mode => :compat, :bigdecimal_as_decimal => true)
+    bg = Oj.load(json, :mode => :compat, :bigdecimal_load => true)
+    assert_equal(BigDecimal, bg.class)
+    assert_equal(orig, bg)
+  end
+
+  # Time
+  def test_time_ruby
+    if RUBY_VERSION.start_with?('1.8')
+      t = Time.parse('2015-01-05T21:37:07.123456-08:00')
+    else
+      t = Time.new(2015, 1, 5, 21, 37, 7.123456, -8 * 3600)
+    end
+    expect = '"' + t.to_s + '"'
+    json = Oj.dump(t, :mode => :compat, :time_format => :ruby)
+    assert_equal(expect, json)
+  end
+  def test_time_xml
+    if RUBY_VERSION.start_with?('1.8')
+      t = Time.parse('2015-01-05T21:37:07.123456-08:00')
+    else
+      t = Time.new(2015, 1, 5, 21, 37, 7.123456, -8 * 3600)
+    end
+    json = Oj.dump(t, :mode => :compat, :time_format => :xmlschema, :second_precision => 6)
+    assert_equal('"2015-01-05T21:37:07.123456-08:00"', json)
+  end
+  unless RUBY_VERSION.start_with?('1.8')
+    def test_time_xml_12345
+      t = Time.new(2015, 1, 5, 21, 37, 7.123456, 12345)
+      json = Oj.dump(t, :mode => :compat, :time_format => :xmlschema, :second_precision => 6)
+      assert_equal('"2015-01-05T21:37:07.123456+03:25"', json)
+    end
+  end
+  def test_time_unix
+    if RUBY_VERSION.start_with?('1.8')
+      t = Time.parse('2015-01-05T21:37:07.123456-08:00')
+    else
+      t = Time.new(2015, 1, 5, 21, 37, 7.123456, -8 * 3600)
+    end
+    json = Oj.dump(t, :mode => :compat, :time_format => :unix, :second_precision => 6)
+    assert_equal('1420522627.123456', json)
+  end
+  def test_time_unix_zone
+    if RUBY_VERSION.start_with?('1.8')
+      t = Time.parse('2015-01-05T21:37:07.123456-08:00')
+    else
+      t = Time.new(2015, 1, 5, 21, 37, 7.123456, -8 * 3600)
+    end
+    json = Oj.dump(t, :mode => :compat, :time_format => :unix_zone, :second_precision => 6)
+    assert_equal('1420522627.123456e-28800', json)
+  end
+  unless RUBY_VERSION.start_with?('1.8')
+    def test_time_unix_zone_12345
+      t = Time.new(2015, 1, 5, 21, 37, 7.123456, 12345)
+      json = Oj.dump(t, :mode => :compat, :time_format => :unix_zone, :second_precision => 6)
+      assert_equal('1420481482.123456e12345', json)
+    end
+  end
+  def test_time_unix_zone_early
+    if RUBY_VERSION.start_with?('1.8')
+      t = Time.parse('1954-01-05T21:37:07.123456-08:00')
+    else
+      t = Time.new(1954, 1, 5, 21, 37, 7.123456, -8 * 3600)
+    end
+    json = Oj.dump(t, :mode => :compat, :time_format => :unix_zone, :second_precision => 6)
+    assert_equal('-504469372.876544e-28800', json)
+  end
+
+  # Stream IO
+  def test_io_string
+    json = %{{
+  "x":true,
+  "y":58,
+  "z": [1,2,3]
+}
+}
+    input = StringIO.new(json)
+    obj = Oj.compat_load(input)
+    assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
+  end
+
+  def test_io_file
+    filename = File.join(File.dirname(__FILE__), 'open_file_test.json')
+    File.open(filename, 'w') { |f| f.write(%{{
+  "x":true,
+  "y":58,
+  "z": [1,2,3]
+}
+}) }
+    f = File.new(filename)
+    obj = Oj.compat_load(f)
+    f.close()
+    assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
+  end
+
+  # symbol_keys option
+  def test_symbol_keys
+    json = %{{
+  "x":true,
+  "y":58,
+  "z": [1,2,3]
+}
+}
+    obj = Oj.compat_load(json, :symbol_keys => true)
+    assert_equal({ :x => true, :y => 58, :z => [1, 2, 3]}, obj)
+  end
+
+  # comments
+  def test_comment_slash
+    json = %{{
+  "x":true,//three
+  "y":58,
+  "z": [1,2,
+3 // six
+]}
+}
+    obj = Oj.compat_load(json)
+    assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
+  end
+
+  def test_comment_c
+    json = %{{
+  "x"/*one*/:/*two*/true,
+  "y":58,
+  "z": [1,2,3]}
+}
+    obj = Oj.compat_load(json)
+    assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
+  end
+
+  def test_comment
+    json = %{{
+  "x"/*one*/:/*two*/true,//three
+  "y":58/*four*/,
+  "z": [1,2/*five*/,
+3 // six
+]
+}
+}
+    obj = Oj.compat_load(json)
+    assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
+  end
+
+  def test_json_object_compat
+    obj = Jeez.new(true, 58)
+    Oj.default_options = { :mode => :compat, :use_as_json => true, :use_to_json => true }
+    dump_and_load(obj, false)
+  end
+
+  def test_json_module_object
+    Oj.default_options = { :mode => :compat, :use_as_json => true, :use_to_json => true }
+    obj = One::Two::Three::Deep.new()
+    dump_and_load(obj, false)
+  end
+
+  def test_json_object_create_id
+    Oj.default_options = { :mode => :compat, :use_as_json => false, :use_to_json => false }
+    expected = Jeez.new(true, 58)
+    json = Oj.dump(expected, :indent => 2, :mode => :compat, :use_to_json => true, :use_as_json => true)
+    obj = Oj.compat_load(json)
+    assert_equal(expected, obj)
+  end
+
+  def test_json_object_bad
+    json = %{{"json_class":"CompatJuice::Junk","x":true}}
+    begin
+      Oj.compat_load(json)
+    rescue Exception => e
+      assert_equal("Oj::ParseError", e.class().name)
+      return
+    end
+    assert(false, "*** expected an exception")
+  end
+
+  def test_json_object_create_cache
+    Oj.default_options = { :mode => :compat, :use_as_json => true, :use_to_json => true }
+    expected = Jeez.new(true, 58)
+    json = Oj.dump(expected, :indent => 2, :mode => :compat, :use_to_json => true)
+    obj = Oj.compat_load(json, :class_cache => true)
+    assert_equal(expected, obj)
+    obj = Oj.compat_load(json, :class_cache => false)
+    assert_equal(expected, obj)
+  end
+
+  def test_json_object_create_id_other
+    Oj.default_options = { :mode => :compat, :use_as_json => false, :use_to_json => false }
+    expected = Jeez.new(true, 58)
+    json = Oj.dump(expected, :indent => 2, :mode => :compat, :use_as_json => true)
+    json.gsub!('json_class', '_class_')
+    obj = Oj.compat_load(json, :create_id => "_class_")
+    assert_equal(expected, obj)
+  end
+
+  def test_json_object_create_deep
+    Oj.default_options = { :mode => :compat, :use_as_json => true, :use_to_json => true }
+    expected = One::Two::Three::Deep.new()
+    json = Oj.dump(expected, :indent => 2, :mode => :compat)
+    obj = Oj.compat_load(json)
+    assert_equal(expected, obj)
+  end
+
+  def dump_and_load(obj, trace=false)
+    json = Oj.dump(obj, :indent => 2, :mode => :compat)
+    puts json if trace
+    loaded = Oj.compat_load(json);
+    assert_equal(obj, loaded)
+    loaded
+  end
+
+end
+=end