oj 2.18.3 → 3.13.14

data/test/bug.rb

@@ -1,51 +1,16 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
+$: << '.'
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
 
-$: << File.dirname(__FILE__)
 
-require 'helper'
+#require 'bundler/setup'
+require 'oj'
+require 'active_support'
+require 'active_support/time_with_zone'
+require 'tzinfo'
 
-class Handler
-  def initialize
-    @state = []
-  end
+puts ActiveSupport::TimeWithZone
 
-  def hash_start
-    @state << {}
-    @state.last
-  end
+json = File.read('./bug.json')
 
-  def hash_end
-    @state.pop
-  end
-
-  def hash_set(h,k,v)
-    h.store(k,v)
-  end
-
-  def array_start
-    @state << []
-    @state.last
-  end
-
-
-  def array_end
-    @state.pop
-  end
-
-  def array_append(a,v)
-    a << v
-  end
-
-  def add_value(v)
-    p v
-  end
-
-  def error(message, line, column); p "ERROR: #{message}" end
-end
-
-$handler = Handler.new
-
-IO.popen("cat tst") { |p| puts Oj.sc_parse($handler, p) }
-
-#File.open('tst', 'r') { |file|  Oj.sc_parse($handler, file) }
+Oj.load(json)

data/test/foo.rb

@@ -1,24 +1,77 @@
 #!/usr/bin/env ruby
-# encoding: UTF-8
 
-$VERBOSE = true
+$: << '.'
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
 
-here = File.expand_path(File.dirname(__FILE__))
-$: << File.dirname(__FILE__)
-$: << File.join(File.dirname(here), 'ext')
-$: << File.join(File.dirname(here), 'lib')
+require "oj"
+require "socket"
+require 'io/nonblock'
 
-require 'oj'
-
-Oj.mimic_JSON()
+#pid = spawn("nc -d 0.1 -l 5000", out: "/dev/null")
+pid = spawn("nc -i 1 -l 7777", out: "/dev/null")
+at_exit { Process.kill 9, pid }
+sleep 0.2
+s = Socket.tcp("localhost", 7777)
+s.nonblock = false
+1_000_000.times do |x|
+  Oj.to_stream(s, { x: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]})
+end
 
-class Foo
-  def as_json
-    { foo: 'bar' }
+=begin
+IO.pipe do |r, w|
+  if fork
+    r.close
+    #w.nonblock = false
+    1_000_000.times do |i|
+      begin
+	Oj.to_stream(w, { x: i})
+      rescue IOError => e
+	puts "*** #{i} raised #{e.class}: #{e}"
+	IO.select(nil, [w])
+	retry
+      end
+      w.puts
+    end
+  else
+    w.close
+    sleep(0.1)
+    r.each_line { |b|
+      #print b
+    }
+    r.close
+    Process.exit(0)
   end
 end
+=end
 
-opts = {}
-
-puts Foo.new.to_json
-puts Foo.new.to_json(opts)
+=begin
+IO.pipe do |r, w|
+  if fork
+    r.close
+    #w.nonblock = false
+    a = []
+    10_000.times do |i|
+      a << i
+    end
+    begin
+      Oj.to_stream(w, a, indent: 2)
+    rescue IOError => e
+      puts "*** raised #{e.class}: #{e}"
+      puts "*** fileno: #{w.fileno}"
+      puts "*** is an IO?: #{w.kind_of?(IO)}"
+      IO.select(nil, [w])
+      retry
+    end
+    w.puts
+  else
+    w.close
+    sleep(0.5)
+    r.each_line { |b|
+      #print b
+    }
+    r.close
+    Process.exit(0)
+  end
+end
+=end

data/test/helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+#
 # Ubuntu does not accept arguments to ruby when called using env. To get warnings to show up the -w options is
 # required. That can be set in the RUBYOPT environment variable.
 # export RUBYOPT=-w
@@ -8,7 +10,6 @@ $VERBOSE = true
   $LOAD_PATH.unshift File.expand_path("../../#{dir}", __FILE__)
 end
 
-require 'rubygems' if RUBY_VERSION.start_with?('1.8.')
 require 'minitest'
 require 'minitest/autorun'
 require 'stringio'
@@ -17,6 +18,14 @@ require 'bigdecimal'
 require 'pp'
 require 'oj'
 
+
+if defined?(GC.verify_compaction_references) == 'method'
+  # This method was added in Ruby 3.0.0. Calling it this way asks the GC to
+  # move objects around, helping to find object movement bugs.
+  GC.verify_compaction_references(double_heap: true, toward: :empty)
+end
+
+
 $ruby = RUBY_DESCRIPTION.split(' ')[0]
 $ruby = 'ree' if 'ruby' == $ruby && RUBY_DESCRIPTION.include?('Ruby Enterprise Edition')
 

data/test/isolated/shared.rb

@@ -36,8 +36,6 @@ class SharedMimicTest < Minitest::Test
     @expected_time_string =
       if defined?(Rails)
         %{"2014-05-13T16:53:20.000Z"}
-      elsif RUBY_VERSION.start_with?('1.8')
-        %{"Tue May 13 16:53:20 UTC 2014"}
       else
         %{"2014-05-13 16:53:20 UTC"}
       end
@@ -145,7 +143,7 @@ class SharedMimicTest < Minitest::Test
     Oj.mimic_JSON
     children = []
     json = %{{"a":1,"b":[true,false]}}
-    if 'rubinius' == $ruby || '1.8.7' == RUBY_VERSION
+    if 'rubinius' == $ruby
       obj = JSON.load(json) {|x| children << x }
     else
       p = Proc.new {|x| children << x }
@@ -164,6 +162,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 +221,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
 
@@ -269,7 +273,7 @@ class SharedMimicTest < Minitest::Test
     children = []
     JSON.recurse_proc({ 'a' => 1, 'b' => [true, false]}) { |x| children << x }
     # JRuby 1.7.0 rb_yield() is broken and converts the [true, false] array into true
-    unless 'jruby' == $ruby && '1.9.3' == RUBY_VERSION
+    unless 'jruby' == $ruby
       assert([1, true, false, [true, false], { 'a' => 1, 'b' => [true, false]}] == children ||
              [true, false, [true, false], 1, { 'b' => [true, false], 'a' => 1}] == children)
     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/json_gem/json_addition_test.rb

@@ -0,0 +1,216 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+#frozen_string_literal: false
+
+require 'json_gem/test_helper'
+require 'date'
+
+if REAL_JSON_GEM
+  require 'json/add/core'
+  require 'json/add/complex'
+  require 'json/add/rational'
+  require 'json/add/bigdecimal'
+  require 'json/add/ostruct'
+else
+  #Oj.add_to_json()
+  Oj.add_to_json(Array, BigDecimal, Complex, Date, DateTime, Exception, Hash, Integer, OpenStruct, Range, Rational, Regexp, Struct, Time)
+end
+
+class JSONAdditionTest < Test::Unit::TestCase
+  include Test::Unit::TestCaseOmissionSupport
+  include Test::Unit::TestCasePendingSupport
+
+  class A
+    def self.json_creatable?
+      true
+    end
+
+    def initialize(a)
+      @a = a
+    end
+
+    attr_reader :a
+
+    def ==(other)
+      a == other.a
+    end
+
+    def self.json_create(object)
+      new(*object['args'])
+    end
+
+    def to_json(*args)
+      {
+        'json_class'  => self.class.name,
+        'args'        => [ @a ],
+      }.to_json(*args)
+    end
+  end
+
+  class A2 < A
+    def to_json(*args)
+      {
+        'json_class'  => self.class.name,
+        'args'        => [ @a ],
+      }.to_json(*args)
+    end
+  end
+
+  class B
+    def self.json_creatable?
+      false
+    end
+
+    def to_json(*args)
+      {
+        'json_class'  => self.class.name,
+      }.to_json(*args)
+    end
+  end
+
+  class C
+    def self.json_creatable?
+      false
+    end
+
+    def to_json(*args)
+      {
+        'json_class'  => 'JSONAdditionTest::Nix',
+      }.to_json(*args)
+    end
+  end
+
+  def test_extended_json
+    a = A.new(666)
+    assert A.json_creatable?
+    json = JSON.generate(a)
+    a_again = JSON.parse(json, :create_additions => true)
+    assert_kind_of a.class, a_again
+    assert_equal a, a_again
+  end
+
+  def test_extended_json_default
+    a = A.new(666)
+    assert A.json_creatable?
+    json = JSON.generate(a)
+    a_hash = JSON.parse(json)
+    assert_kind_of Hash, a_hash
+  end
+
+  def test_extended_json_disabled
+    a = A.new(666)
+    assert A.json_creatable?
+    json = JSON.generate(a)
+    a_again = JSON.parse(json, :create_additions => true)
+    assert_kind_of a.class, a_again
+    assert_equal a, a_again
+    a_hash = JSON.parse(json, :create_additions => false)
+    assert_kind_of Hash, a_hash
+    assert_equal(
+      {"args"=>[666], "json_class"=>"JSONAdditionTest::A"}.sort_by { |k,| k },
+      a_hash.sort_by { |k,| k }
+    )
+  end
+
+  def test_extended_json_fail1
+    b = B.new
+    assert !B.json_creatable?
+    json = JSON.generate(b)
+    assert_equal({ "json_class"=>"JSONAdditionTest::B" }, JSON.parse(json))
+  end
+
+  def test_extended_json_fail2
+    c = C.new
+    assert !C.json_creatable?
+    json = JSON.generate(c)
+    assert_raise(ArgumentError, NameError) { JSON.parse(json, :create_additions => true) }
+  end
+
+  def test_raw_strings
+    raw = ''
+    raw.respond_to?(:encode!) and raw.encode!(Encoding::ASCII_8BIT)
+    raw_array = []
+    for i in 0..255
+      raw << i
+      raw_array << i
+    end
+    json = raw.to_json_raw
+    json_raw_object = raw.to_json_raw_object
+    hash = { 'json_class' => 'String', 'raw'=> raw_array }
+    assert_equal hash, json_raw_object
+    assert_match(/\A\{.*\}\z/, json)
+    assert_match(/"json_class":"String"/, json)
+    assert_match(/"raw":\[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255\]/, json)
+
+    raw_again = JSON.parse(json, :create_additions => true)
+    assert_equal raw, raw_again
+  end
+
+  MyJsonStruct = Struct.new 'MyJsonStruct', :foo, :bar
+
+  def test_core
+    t = Time.now
+    assert_equal t, JSON(JSON(t), :create_additions => true)
+
+    d = Date.today
+    assert_equal d, JSON(JSON(d), :create_additions => true)
+
+    d = DateTime.civil(2007, 6, 14, 14, 57, 10, Rational(1, 12), 2299161)
+    assert_equal d, JSON(JSON(d), :create_additions => true)
+
+    assert_equal 1..10, JSON(JSON(1..10), :create_additions => true)
+    assert_equal 1...10, JSON(JSON(1...10), :create_additions => true)
+    assert_equal "a".."c", JSON(JSON("a".."c"), :create_additions => true)
+    assert_equal "a"..."c", JSON(JSON("a"..."c"), :create_additions => true)
+
+    s = MyJsonStruct.new 4711, 'foot'
+    assert_equal s, JSON(JSON(s), :create_additions => true)
+
+    struct = Struct.new :foo, :bar
+    s = struct.new 4711, 'foot'
+    assert_raise(JSON::JSONError) { JSON(s) }
+
+    begin
+      raise TypeError, "test me"
+    rescue TypeError => e
+      e_json = JSON.generate e
+      e_again = JSON e_json, :create_additions => true
+      assert_kind_of TypeError, e_again
+      assert_equal e.message, e_again.message
+      assert_equal e.backtrace, e_again.backtrace
+    end
+
+    assert_equal(/foo/, JSON(JSON(/foo/), :create_additions => true))
+    assert_equal(/foo/i, JSON(JSON(/foo/i), :create_additions => true))
+  end
+
+  def test_utc_datetime
+    now = Time.now
+    d = DateTime.parse(now.to_s, :create_additions => true) # usual case
+    assert_equal d, JSON.parse(d.to_json, :create_additions => true)
+    d = DateTime.parse(now.utc.to_s) # of = 0
+    assert_equal d, JSON.parse(d.to_json, :create_additions => true)
+    d = DateTime.civil(2008, 6, 17, 11, 48, 32, Rational(1,24))
+    assert_equal d, JSON.parse(d.to_json, :create_additions => true)
+    d = DateTime.civil(2008, 6, 17, 11, 48, 32, Rational(12,24))
+    assert_equal d, JSON.parse(d.to_json, :create_additions => true)
+  end
+
+  def test_rational_complex
+    assert_equal Rational(2, 9), JSON.parse(JSON(Rational(2, 9)), :create_additions => true)
+    assert_equal Complex(2, 9), JSON.parse(JSON(Complex(2, 9)), :create_additions => true)
+  end
+
+  def test_bigdecimal
+    assert_equal BigDecimal('3.141', 23), JSON(JSON(BigDecimal('3.141', 23)), :create_additions => true)
+    assert_equal BigDecimal('3.141', 666), JSON(JSON(BigDecimal('3.141', 666)), :create_additions => true)
+  end
+
+  def test_ostruct
+    o = OpenStruct.new
+    # XXX this won't work; o.foo = { :bar => true }
+    o.foo = { 'bar' => true }
+    assert_equal o, JSON.parse(JSON(o), :create_additions => true)
+  end
+end

data/test/json_gem/json_common_interface_test.rb

@@ -0,0 +1,153 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+#frozen_string_literal: false
+
+require 'json_gem/test_helper'
+
+require 'stringio'
+require 'tempfile'
+
+class JSONCommonInterfaceTest < Test::Unit::TestCase
+  include Test::Unit::TestCaseOmissionSupport
+  include Test::Unit::TestCasePendingSupport
+
+  def setup
+    @hash = {
+      'a' => 2,
+      #'b' => 5.23683071,
+      'c' => 'c',
+      'd' => [ 1, "b", 3.14 ],
+      'e' => { 'foo' => 'bar' },
+      'g' => "\"\0\037",
+      'h' => 1000.0,
+      'i' => 0.001
+    }
+    # Tired of chasing floating point rounding and precision. Oj now uses the
+    # Ruby float parser in compat mode yet on i386 machines there are issues
+    # with this test when the float is included.
+    #@json = '{"a":2,"b":5.23683071,"c":"c","d":[1,"b",3.14],"e":{"foo":"bar"},'\
+    #'"g":"\\"\\u0000\\u001f","h":1000.0,"i":0.001}'
+    @json = '{"a":2,"c":"c","d":[1,"b",3.14],"e":{"foo":"bar"},'\
+	    '"g":"\\"\\u0000\\u001f","h":1000.0,"i":0.001}'
+  end
+
+  def test_index
+    assert_equal @json, JSON[@hash]
+    assert_equal @hash, JSON[@json]
+  end
+
+  ##############################################################################
+  # The next tests are omitted as implementing them and using them is a
+  # performance hit. Use of the JSON.parse() and similar provide the same
+  # functionality and perform better.
+
+  def test_parser
+    assert_match /::Parser\z/, JSON.parser.name
+  end
+
+  def test_generator
+    assert_match /::Generator\z/, JSON.generator.name
+  end
+
+  def test_state
+    assert_match /::Generator::State\z/, JSON.state.name
+  end
+
+  # This doesn't have anything to do with JSON parsing or generation. It seems
+  # to be more of an internal tool that is exposed to users.
+  def test_deep_const_get
+    omit("mimic_JSON") unless REAL_JSON_GEM
+    assert_raise(ArgumentError) { JSON.deep_const_get('Nix::Da') }
+    assert_equal File::SEPARATOR, JSON.deep_const_get('File::SEPARATOR')
+  end
+  ##############################################################################
+
+  def test_create_id
+    assert_equal 'json_class', JSON.create_id
+    JSON.create_id = 'foo_bar'
+    assert_equal 'foo_bar', JSON.create_id
+  ensure
+    JSON.create_id = 'json_class'
+  end
+
+  def test_parse
+    assert_equal [ 1, 2, 3, ], JSON.parse('[ 1, 2, 3 ]')
+  end
+
+  def test_parse_bang
+    # Modified this test to compare strings since NaN comparison fails if NaN
+    # was defined in different places even if it represents the same value.
+    assert_equal [ 1, NaN, 3, ].to_s, JSON.parse!('[ 1, NaN, 3 ]').to_s
+  end
+
+  def test_generate
+    assert_equal '[1,2,3]', JSON.generate([ 1, 2, 3 ])
+  end
+
+  def test_fast_generate
+    assert_equal '[1,2,3]', JSON.generate([ 1, 2, 3 ])
+  end
+
+  def test_pretty_generate
+    assert_equal "[\n  1,\n  2,\n  3\n]", JSON.pretty_generate([ 1, 2, 3 ])
+  end
+
+  def test_load
+    assert_equal @hash, JSON.load(@json)
+    tempfile = Tempfile.open('@json')
+    tempfile.write @json
+    tempfile.rewind
+    assert_equal @hash, JSON.load(tempfile)
+    stringio = StringIO.new(@json)
+    stringio.rewind
+    assert_equal @hash, JSON.load(stringio)
+    assert_equal nil, JSON.load(nil)
+    assert_equal nil, JSON.load('')
+  ensure
+    tempfile.close!
+  end
+
+  def test_load_with_options
+    json  = '{ "foo": NaN }'
+    assert JSON.load(json, nil, :allow_nan => true)['foo'].nan?
+  end
+
+  def test_load_null
+    assert_equal nil, JSON.load(nil, nil, :allow_blank => true)
+    assert_raise(TypeError) { JSON.load(nil, nil, :allow_blank => false) }
+    assert_raise(JSON::ParserError) { JSON.load('', nil, :allow_blank => false) }
+    # The next tests are added by Oj to catch additional cases.
+    assert_equal nil, JSON.load('', nil, :allow_blank => true)
+    assert_raise(JSON::ParserError) { JSON.load('', nil, :allow_blank => false) }
+    assert_raise(JSON::ParserError) { JSON.load(' ', nil, :allow_blank => true) }
+    assert_raise(JSON::ParserError) { JSON.load(' ', nil, :allow_blank => false) }
+  end
+
+  def test_dump
+    too_deep = '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]'
+    assert_equal too_deep, JSON.dump(eval(too_deep))
+    assert_kind_of String, Marshal.dump(eval(too_deep))
+    assert_raise(ArgumentError) { JSON.dump(eval(too_deep), 100) }
+    assert_raise(ArgumentError) { Marshal.dump(eval(too_deep), 100) }
+    assert_equal too_deep, JSON.dump(eval(too_deep), 101)
+    assert_kind_of String, Marshal.dump(eval(too_deep), 101)
+    output = StringIO.new
+    JSON.dump(eval(too_deep), output)
+    assert_equal too_deep, output.string
+    output = StringIO.new
+    JSON.dump(eval(too_deep), output, 101)
+    assert_equal too_deep, output.string
+  end
+
+  def test_dump_should_modify_defaults
+    max_nesting = JSON.dump_default_options[:max_nesting]
+    JSON.dump([], StringIO.new, 10)
+    assert_equal max_nesting, JSON.dump_default_options[:max_nesting]
+  end
+
+  def test_JSON
+    assert_equal @json, JSON(@hash)
+    assert_equal @hash, JSON(@json)
+  end
+end