oj 2.18.5 → 3.0.0

data/test/json_gem/json_string_matching_test.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+#frozen_string_literal: false
+
+require 'json_gem/test_helper'
+
+require 'time'
+
+class JSONStringMatchingTest < Test::Unit::TestCase
+  include Test::Unit::TestCaseOmissionSupport
+
+  class TestTime < ::Time
+    def self.json_create(string)
+      Time.parse(string)
+    end
+
+    def to_json(*)
+      %{"#{strftime('%FT%T%z')}"}
+    end
+
+    def ==(other)
+      to_i == other.to_i
+    end
+  end
+
+  def test_match_date
+    t = TestTime.new
+    t_json = [ t ].to_json
+    time_regexp = /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}[+-]\d{4}\z/
+    assert_equal [ t ],
+      JSON.parse(
+        t_json,
+        :create_additions => true,
+        :match_string => { time_regexp => TestTime }
+      )
+    assert_equal [ t.strftime('%FT%T%z') ],
+      JSON.parse(
+        t_json,
+        :match_string => { time_regexp => TestTime }
+      )
+  end
+end

data/test/json_gem/test_helper.rb

@@ -0,0 +1,18 @@
+$: << File.dirname(__FILE__)
+$oj_dir = File.dirname(File.dirname(File.expand_path(File.dirname(__FILE__))))
+%w(lib ext).each do |dir|
+  $: << File.join($oj_dir, dir)
+end
+
+require 'test/unit'
+REAL_JSON_GEM = !!ENV['REAL_JSON_GEM']
+
+if ENV['REAL_JSON_GEM']
+  require 'json'
+else
+  require 'oj'
+  Oj.mimic_JSON
+end
+
+NaN = JSON::NaN if defined?(JSON::NaN)
+NaN = 0.0/0 unless defined?(NaN)

data/test/perf_compat.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby -wW1
+#!/usr/bin/env ruby
 # encoding: UTF-8
 
 $: << '.'
@@ -12,8 +12,6 @@ require 'oj'
 $verbose = false
 $indent = 0
 $iter = 20000
-$with_bignum = false
-$with_nums = true
 $size = 0
 
 opts = OptionParser.new
@@ -24,25 +22,48 @@ opts.on("-s", "--size [Int]", Integer, "size (~Kbytes)")    { |i| $size = i }
 opts.on("-h", "--help", "Show this display")                { puts opts; Process.exit!(0) }
 files = opts.parse(ARGV)
 
+def capture_error(tag, orig, load_key, dump_key, &blk)
+  begin
+    obj = blk.call(orig)
+    puts obj unless orig == obj
+    raise "#{tag} #{dump_key} and #{load_key} did not return the same object as the original." unless orig == obj
+  rescue Exception => e
+    $failed[tag] = "#{e.class}: #{e.message}"
+  end
+end
+
+# Verify that all packages dump and load correctly and return the same Object as the original.
+capture_error('Oj:compat', $obj, 'load', 'dump') { |o| Oj.compat_load(Oj.dump(o, :mode => :compat)) }
+capture_error('JSON::Ext', $obj, 'generate', 'parse') { |o|
+  require 'json'
+  require 'json/ext'
+  JSON.generator = JSON::Ext::Generator
+  JSON.parser = JSON::Ext::Parser
+  JSON.load(JSON.generate(o))
+}
+
 module One
   module Two
     module Three
       class Empty
 
         def initialize()
+          @a = 1
+          @b = 2
+          @c = 3
         end
 
         def eql?(o)
-          self.class == o.class
+          self.class == o.class && @a == o.a && @b = o.b && @c = o.c
         end
         alias == eql?
 
-        def to_hash()
-          {'json_class' => "#{self.class.name}"}
+        def as_json(*a)
+          {JSON.create_id => self.class.name, 'a' => @a, 'b' => @b, 'c' => @c }
         end
-
+        
         def to_json(*a)
-          %{{"json_class":"#{self.class.name}"}}
+          JSON.generate(as_json())
         end
 
         def self.json_create(h)
@@ -65,7 +86,7 @@ $obj = {
   'i' => [[[[[[[nil]]]]]]]  # deep array, again, not that deep
 }
 
-Oj.default_options = { :indent => $indent, :mode => :compat }
+Oj.default_options = { :indent => $indent, :mode => :compat, :use_to_json => true, :create_additions => true, :create_id => '^o' }
 
 if 0 < $size
   s = Oj.dump($obj).size + 1
@@ -80,25 +101,6 @@ end
 $json = Oj.dump($obj)
 $failed = {} # key is same as String used in tests later
 
-def capture_error(tag, orig, load_key, dump_key, &blk)
-  begin
-    obj = blk.call(orig)
-    raise "#{tag} #{dump_key} and #{load_key} did not return the same object as the original." unless orig == obj
-  rescue Exception => e
-    $failed[tag] = "#{e.class}: #{e.message}"
-  end
-end
-
-# Verify that all packages dump and load correctly and return the same Object as the original.
-capture_error('Oj:compat', $obj, 'load', 'dump') { |o| Oj.compat_load(Oj.dump(o, :mode => :compat)) }
-capture_error('JSON::Ext', $obj, 'generate', 'parse') { |o|
-  require 'json'
-  require 'json/ext'
-  JSON.generator = JSON::Ext::Generator
-  JSON.parser = JSON::Ext::Parser
-  JSON.load(JSON.generate(o))
-}
-
 if $verbose
   puts "size: #{$json.size}"
   puts "json:\n#{$json}\n"

data/test/perf_object.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby -wW1
+#!/usr/bin/env ruby
 
 $: << '.'
 $: << '../lib'

data/test/perf_strict.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby -wW1
+#!/usr/bin/env ruby
 # encoding: UTF-8
 
 $: << '.'
@@ -118,6 +118,23 @@ end
 perf.add('Yajl', 'parse') { Yajl::Parser.parse($json) } unless $failed.has_key?('Yajl')
 perf.run($iter)
 
+puts '-' * 80
+puts "Strict Dump Performance"
+perf = Perf.new()
+unless $failed.has_key?('JSON::Ext')
+  perf.add('JSON::Ext', 'dump') { JSON.generate($obj) }
+  perf.before('JSON::Ext') { JSON.generator = JSON::Ext::Generator }
+end
+unless $failed.has_key?('JSON::Pure')
+  perf.add('JSON::Pure', 'generate') { JSON.generate($obj) }
+  perf.before('JSON::Pure') { JSON.generator = JSON::Pure::Generator }
+end
+unless $failed.has_key?('Oj:strict')
+  perf.add('Oj:strict', 'dump') { Oj.dump($obj, :mode => :strict) }
+end
+perf.add('Yajl', 'encode') { Yajl::Encoder.encode($obj) } unless $failed.has_key?('Yajl')
+perf.run($iter)
+
 puts
 puts '-' * 80
 puts

data/test/sample.rb

@@ -10,7 +10,6 @@ end
 require 'pp'
 require 'sample/doc'
 
-
 def sample_doc(size=3)
   colors = [ :black, :gray, :white, :red, :blue, :yellow, :green, :purple, :orange ]
 

data/test/test_compat.rb

@@ -2,8 +2,17 @@
 # encoding: UTF-8
 
 $: << File.dirname(__FILE__)
+$oj_dir = File.dirname(File.expand_path(File.dirname(__FILE__)))
+%w(lib ext).each do |dir|
+  $: << File.join($oj_dir, dir)
+end
 
-require 'helper'
+require 'minitest'
+require 'minitest/autorun'
+require 'stringio'
+require 'date'
+require 'bigdecimal'
+require 'oj'
 
 class CompatJuice < Minitest::Test
 
@@ -20,8 +29,8 @@ class CompatJuice < Minitest::Test
     end
     alias == eql?
 
-    def as_json()
-      {"json_class" => self.class.to_s,"x" => @x,"y" => @y}
+    def to_json()
+      %|{"json_class":"#{self.class.to_s}","x":#{@x},"y":#{@y}}|
     end
 
     def self.json_create(h)
@@ -42,12 +51,8 @@ class CompatJuice < Minitest::Test
           end
           alias == eql?
 
-          def to_hash()
-            {'json_class' => "#{self.class.name}"}
-          end
-
           def to_json(*a)
-            %{{"json_class":"#{self.class.name}"}}
+            %|{"json_class":"#{self.class.name}"}|
           end
 
           def self.json_create(h)
@@ -60,6 +65,9 @@ class CompatJuice < Minitest::Test
 
   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
@@ -87,6 +95,8 @@ class CompatJuice < Minitest::Test
 
   def test_float
     dump_and_load(0.0, false)
+    dump_and_load(0.56, false)
+    dump_and_load(3.0, false)
     dump_and_load(12345.6789, false)
     dump_and_load(70.35, false)
     dump_and_load(-54321.012, false)
@@ -95,6 +105,19 @@ class CompatJuice < Minitest::Test
     dump_and_load(2.48e16, false)
     dump_and_load(2.48e100 * 1.0e10, false)
     dump_and_load(-2.48e100 * 1.0e10, false)
+    dump_and_load(1405460727.723866, false)
+    dump_and_load(0.5773, false)
+    dump_and_load(0.6768, false)
+    dump_and_load(0.685, false)
+    dump_and_load(0.7032, false)
+    dump_and_load(0.7051, false)
+    dump_and_load(0.8274, false)
+    dump_and_load(0.9149, false)
+    dump_and_load(64.4, false)
+    dump_and_load(71.6, false)
+    dump_and_load(73.4, false)
+    dump_and_load(80.6, false)
+    dump_and_load(-95.640172, false)
   end
 
   def test_string
@@ -139,7 +162,34 @@ class CompatJuice < Minitest::Test
     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_symbol
+    json = Oj.dump(:abc, :mode => :compat)
+    assert_equal('"abc"', json)
+  end
+
+  def test_time
+    t = Time.xmlschema("2012-01-05T23:58:07.123456000+09:00")
+    #t = Time.local(2012, 1, 5, 23, 58, 7, 123456)
+    json = Oj.dump(t, :mode => :compat)
+    assert_equal(%{"2012-01-05 23:58:07 +0900"}, json)
+  end
+
+  def test_class
+    json = Oj.dump(CompatJuice, :mode => :compat)
+    assert_equal(%{"CompatJuice"}, json)
+  end
+
+  def test_module
+    json = Oj.dump(One::Two, :mode => :compat)
+    assert_equal(%{"CompatJuice::One::Two"}, json)
+  end
+
   # Hash
+  def test_non_str_hash
+    json = Oj.dump({ 1 => true, 0 => false }, :mode => :compat)
+    h = Oj.load(json, :mode => :strict)
+    assert_equal({ "1" => true, "0" => false }, h)
+  end
   def test_hash
     dump_and_load({}, false)
     dump_and_load({ 'true' => true, 'false' => false}, false)
@@ -179,79 +229,82 @@ class CompatJuice < Minitest::Test
     dump_and_load(7 ** 55, false)
   end
 
-  # BigDecimal
-  def test_bigdecimal_compat
-    dump_and_load(BigDecimal.new('3.14159265358979323846'), false)
+  def test_json_object
+    obj = Jeez.new(true, 58)
+    json = Oj.to_json(obj)
+    assert(%|{"json_class":"CompatJuice::Jeez","x":true,"y":58}| == json ||
+          %|{"json_class":"CompatJuice::Jeez","y":58,"x":true}| == json)
+    dump_to_json_and_load(obj, 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)
+  def test_json_object_create_id
+    Oj.default_options = { :create_id => 'kson_class', :create_additions => true}
+    expected = Jeez.new(true, 58)
+    json = %{{"kson_class":"CompatJuice::Jeez","x":true,"y":58}}
+    obj = Oj.load(json)
+    assert_equal(expected, obj)
+    Oj.default_options = { :create_id => 'json_class' }
   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)
+  def test_bignum_compat
+    json = Oj.dump(7 ** 55, :mode => :compat)
+    b = Oj.load(json, :mode => :strict)
+    assert_equal(30226801971775055948247051683954096612865741943, b)
   end
-  def test_time_xml
-    if RUBY_VERSION.start_with?('1.8')
-      t = Time.parse('2015-01-05T21:37:07.123456-08:00')
+
+  # BigDecimal
+  def test_bigdecimal
+    # BigDecimals are dumped as strings and can not be restored to the
+    # original value.
+    json = Oj.dump(BigDecimal.new('3.14159265358979323846'))
+    if RUBY_VERSION == '2.4.0'
+      # 2.4.0 changes the exponent to lowercase
+      assert_equal('"0.314159265358979323846e1"', json)
     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)
+      assert_equal('"0.314159265358979323846E1"', 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)
+
+  def test_infinity
+    begin
+      Oj.load('Infinity', :mode => :strict)
+      fail()
+    rescue Oj::ParseError
+      assert(true)
     end
-    json = Oj.dump(t, :mode => :compat, :time_format => :unix, :second_precision => 6)
-    assert_equal('1420522627.123456', json)
+    x = Oj.load('Infinity', :mode => :compat)
+    assert_equal('Infinity', x.to_s)
+
   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
+
+  # Time
+  def test_time
+    t = Time.new(2015, 1, 5, 21, 37, 7.123456, -8 * 3600)
+    expect = '"' + t.to_s + '"'
+    json = Oj.dump(t)
+    assert_equal(expect, json)
   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)
+
+  def test_date_compat
+    orig = Date.new(2012, 6, 19)
+    json = Oj.dump(orig, :mode => :compat)
+    x = Oj.load(json, :mode => :compat)
+    # Some Rubies implement Date as data and some as a real Object. Either are
+    # okay for the test.
+    if x.is_a?(String)
+      assert_equal(orig.to_s, x)
+    else # better be a Hash
+      assert_equal({"year" => orig.year, "month" => orig.month, "day" => orig.day, "start" => orig.start}, x)
     end
-    json = Oj.dump(t, :mode => :compat, :time_format => :unix_zone, :second_precision => 6)
-    assert_equal('-504469372.876544e-28800', json)
+  end
+
+  def test_datetime_compat
+    orig = DateTime.new(2012, 6, 19, 20, 19, 27)
+    json = Oj.dump(orig, :mode => :compat)
+    x = Oj.load(json, :mode => :compat)
+    # Some Rubies implement Date as data and some as a real Object. Either are
+    # okay for the test.
+    assert_equal(orig.to_s, x)
   end
 
   # Stream IO
@@ -329,69 +382,92 @@ class CompatJuice < Minitest::Test
     assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
   end
 
-  def test_json_object_compat
+  # If mimic_JSON has not been called then Oj.dump will call to_json on the
+  # top level object only.
+  def test_json_object_top
     obj = Jeez.new(true, 58)
-    Oj.default_options = { :mode => :compat, :use_as_json => true, :use_to_json => true }
-    dump_and_load(obj, false)
+    dump_to_json_and_load(obj, false)
+  end
+
+  # A child to_json should not be called.
+  def test_json_object_child
+    obj = { "child" => Jeez.new(true, 58) }
+    assert_equal('{"child":{"json_class":"CompatJuice::Jeez","x":true,"y":58}}', Oj.dump(obj))
   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)
+    dump_to_json_and_load(obj, false)
   end
 
-  def test_json_object_create_id
-    Oj.default_options = { :mode => :compat, :use_as_json => false, :use_to_json => false }
+  def test_json_object_dump_create_id
     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)
+    json = Oj.to_json(expected)
+    obj = Oj.compat_load(json, :create_additions => true)
     assert_equal(expected, obj)
   end
 
   def test_json_object_bad
     json = %{{"json_class":"CompatJuice::Junk","x":true}}
     begin
-      Oj.compat_load(json)
+      Oj.compat_load(json, :create_additions => true)
     rescue Exception => e
-      assert_equal("Oj::ParseError", e.class().name)
+      assert_equal("ArgumentError", 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)
+    json = Oj.to_json(expected)
+    obj = Oj.compat_load(json, :class_cache => true, :create_additions => true)
     assert_equal(expected, obj)
-    obj = Oj.compat_load(json, :class_cache => false)
+    obj = Oj.compat_load(json, :class_cache => false, :create_additions => true)
     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 = Oj.to_json(expected)
     json.gsub!('json_class', '_class_')
-    obj = Oj.compat_load(json, :create_id => "_class_")
+    obj = Oj.compat_load(json, :create_id => "_class_", :create_additions => true)
     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)
+    json = Oj.to_json(expected)
+    obj = Oj.compat_load(json, :create_additions => true)
     assert_equal(expected, obj)
   end
 
+  def test_range
+    json = Oj.dump(1..7)
+    assert_equal('"1..7"', json)
+  end
+
   def dump_and_load(obj, trace=false)
-    json = Oj.dump(obj, :indent => 2, :mode => :compat)
+    json = Oj.dump(obj)
+    puts json if trace
+    loaded = Oj.compat_load(json, :create_additions => true);
+    if obj.nil?
+      assert_nil(loaded)
+    else
+      assert_equal(obj, loaded)
+    end
+    loaded
+  end
+
+  def dump_to_json_and_load(obj, trace=false)
+    json = Oj.to_json(obj, :indent => '  ')
     puts json if trace
-    loaded = Oj.compat_load(json);
-    assert_equal(obj, loaded)
+    loaded = Oj.compat_load(json, :create_additions => true);
+    if obj.nil?
+      assert_nil(loaded)
+    else
+      assert_equal(obj, loaded)
+    end
     loaded
   end