oj 3.7.4 → 3.13.21

data/test/test_parser_saj.rb

@@ -0,0 +1,335 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+$: << File.dirname(__FILE__)
+
+require 'helper'
+
+$json = %|{
+  "array": [
+    {
+      "num"   : 3,
+      "string": "message",
+      "hash"  : {
+        "h2"  : {
+          "a" : [ 1, 2, 3 ]
+        }
+      }
+    }
+  ],
+  "boolean" : true
+}|
+
+class AllSaj < Oj::Saj
+  attr_accessor :calls
+
+  def initialize()
+    @calls = []
+  end
+
+  def hash_start(key)
+    @calls << [:hash_start, key]
+  end
+
+  def hash_end(key)
+    @calls << [:hash_end, key]
+  end
+
+  def array_start(key)
+    @calls << [:array_start, key]
+  end
+
+  def array_end(key)
+    @calls << [:array_end, key]
+  end
+
+  def add_value(value, key)
+    @calls << [:add_value, value, key]
+  end
+
+  def error(message, line, column)
+    @calls << [:error, message, line, column]
+  end
+
+end # AllSaj
+
+class LocSaj
+  attr_accessor :calls
+
+  def initialize()
+    @calls = []
+  end
+
+  def hash_start(key, line, column)
+    @calls << [:hash_start, key, line, column]
+  end
+
+  def hash_end(key, line, column)
+    @calls << [:hash_end, key, line, column]
+  end
+
+  def array_start(key, line, column)
+    @calls << [:array_start, key, line, column]
+  end
+
+  def array_end(key, line, column)
+    @calls << [:array_end, key, line, column]
+  end
+
+  def add_value(value, key, line, column)
+    @calls << [:add_value, value, key, line, column]
+  end
+
+end # LocSaj
+
+class SajTest < Minitest::Test
+
+  def test_nil
+    handler = AllSaj.new()
+    json = %{null}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([[:add_value, nil, nil]], handler.calls)
+  end
+
+  def test_true
+    handler = AllSaj.new()
+    json = %{true}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([[:add_value, true, nil]], handler.calls)
+  end
+
+  def test_false
+    handler = AllSaj.new()
+    json = %{false}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([[:add_value, false, nil]], handler.calls)
+  end
+
+  def test_string
+    handler = AllSaj.new()
+    json = %{"a string"}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([[:add_value, 'a string', nil]], handler.calls)
+  end
+
+  def test_fixnum
+    handler = AllSaj.new()
+    json = %{12345}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([[:add_value, 12345, nil]], handler.calls)
+  end
+
+  def test_float
+    handler = AllSaj.new()
+    json = %{12345.6789}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([[:add_value, 12345.6789, nil]], handler.calls)
+  end
+
+  def test_float_exp
+    handler = AllSaj.new()
+    json = %{12345.6789e7}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal(1, handler.calls.size)
+    assert_equal(:add_value, handler.calls[0][0])
+    assert_equal((12345.6789e7 * 10000).to_i, (handler.calls[0][1] * 10000).to_i)
+  end
+
+  def test_bignum
+    handler = AllSaj.new()
+    json = %{-11.899999999999999}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal(1, handler.calls.size)
+    assert_equal(:add_value, handler.calls[0][0])
+    assert_equal(-118999, (handler.calls[0][1] * 10000).to_i)
+  end
+
+  def test_bignum_loc
+    handler = LocSaj.new()
+    json = <<~JSON
+      {
+        "width": 192.33800000000002,
+        "xaxis": {
+          "anchor": "y"
+        }
+      }
+    JSON
+
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal(6, handler.calls.size)
+    assert_equal(1_923_380, (handler.calls[1][1] * 10000).to_i)
+    handler.calls[1][1] = 1_923_380
+    assert_equal([[:hash_start, nil, 1, 1],
+                  [:add_value, 1923380, 'width', 2, 30],
+                  [:hash_start, 'xaxis', 3, 12],
+                  [:add_value, 'y', 'anchor', 4, 17],
+                  [:hash_end, 'xaxis', 5, 3],
+                  [:hash_end, nil, 6, 1]],
+                 handler.calls)
+  end
+
+  def test_array_empty
+    handler = AllSaj.new()
+    json = %{[]}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([[:array_start, nil],
+                  [:array_end, nil]], handler.calls)
+  end
+
+  def test_array
+    handler = AllSaj.new()
+    json = %{[true,false]}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([[:array_start, nil],
+                  [:add_value, true, nil],
+                  [:add_value, false, nil],
+                  [:array_end, nil]], handler.calls)
+  end
+
+  def test_hash_empty
+    handler = AllSaj.new()
+    json = %{{}}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([[:hash_start, nil],
+                  [:hash_end, nil]], handler.calls)
+  end
+
+  def test_hash
+    handler = AllSaj.new()
+    json = %{{"one":true,"two":false}}
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([[:hash_start, nil],
+                  [:add_value, true, 'one'],
+                  [:add_value, false, 'two'],
+                  [:hash_end, nil]], handler.calls)
+  end
+
+  def test_full
+    handler = AllSaj.new()
+    Oj.saj_parse(handler, $json)
+    assert_equal([[:hash_start, nil],
+                  [:array_start, 'array'],
+                  [:hash_start, nil],
+                  [:add_value, 3, 'num'],
+                  [:add_value, 'message', 'string'],
+                  [:hash_start, 'hash'],
+                  [:hash_start, 'h2'],
+                  [:array_start, 'a'],
+                  [:add_value, 1, nil],
+                  [:add_value, 2, nil],
+                  [:add_value, 3, nil],
+                  [:array_end, 'a'],
+                  [:hash_end, 'h2'],
+                  [:hash_end, 'hash'],
+                  [:hash_end, nil],
+                  [:array_end, 'array'],
+                  [:add_value, true, 'boolean'],
+                  [:hash_end, nil]], handler.calls)
+  end
+
+  def test_multiple
+    handler = AllSaj.new()
+    json = %|[true][false]|
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.parse(json)
+    assert_equal([
+		   [:array_start, nil],
+                   [:add_value, true, nil],
+                   [:array_end, nil],
+		   [:array_start, nil],
+                   [:add_value, false, nil],
+                   [:array_end, nil],
+		 ], handler.calls)
+  end
+
+  def test_io
+    handler = AllSaj.new()
+    json = %| [true,false]  |
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.load(StringIO.new(json))
+    assert_equal([
+		   [:array_start, nil],
+		   [:add_value, true, nil],
+		   [:add_value, false, nil],
+		   [:array_end, nil],
+		 ], handler.calls)
+  end
+
+  def test_file
+    handler = AllSaj.new()
+    p = Oj::Parser.new(:saj)
+    p.handler = handler
+    p.file('saj_test.json')
+    assert_equal([
+		   [:array_start, nil],
+		   [:add_value, true, nil],
+		   [:add_value, false, nil],
+		   [:array_end, nil],
+		 ], handler.calls)
+  end
+
+  def test_default
+    handler = AllSaj.new()
+    json = %|[true]|
+    Oj::Parser.saj.handler = handler
+    Oj::Parser.saj.parse(json)
+    assert_equal([
+		   [:array_start, nil],
+                   [:add_value, true, nil],
+                   [:array_end, nil],
+		 ], handler.calls)
+  end
+
+  def test_loc
+    handler = LocSaj.new()
+    Oj::Parser.saj.handler = handler
+    Oj::Parser.saj.parse($json)
+    assert_equal([[:hash_start, nil, 1, 1],
+                  [:array_start, 'array', 2, 12],
+                  [:hash_start, nil, 3, 5],
+                  [:add_value, 3, 'num', 4, 18],
+                  [:add_value, 'message', 'string', 5, 25],
+                  [:hash_start, 'hash', 6, 17],
+                  [:hash_start, 'h2', 7, 17],
+                  [:array_start, 'a', 8, 17],
+                  [:add_value, 1, nil, 8, 20],
+                  [:add_value, 2, nil, 8, 23],
+                  [:add_value, 3, nil, 8, 26],
+                  [:array_end, 'a', 8, 27],
+                  [:hash_end, 'h2', 9, 9],
+                  [:hash_end, 'hash', 10, 7],
+                  [:hash_end, nil, 11, 5],
+                  [:array_end, 'array', 12, 3],
+                  [:add_value, true, 'boolean', 13, 18],
+                  [:hash_end, nil, 14, 1]], handler.calls)
+  end
+
+end

data/test/test_parser_usual.rb

@@ -0,0 +1,217 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+$: << File.dirname(__FILE__)
+
+require 'helper'
+
+class UsualTest < Minitest::Test
+
+  def test_nil
+    p = Oj::Parser.new(:usual)
+    doc = p.parse('nil')
+    assert_nil(doc)
+  end
+
+  def test_primitive
+    p = Oj::Parser.new(:usual)
+    [
+      ['true', true],
+      ['false', false],
+      ['123', 123],
+      ['1.25', 1.25],
+      ['"abc"', 'abc'],
+    ].each { |x|
+      doc = p.parse(x[0])
+      assert_equal(x[1], doc)
+    }
+  end
+
+  def test_big
+    p = Oj::Parser.new(:usual)
+    doc = p.parse('12345678901234567890123456789')
+    assert_equal(BigDecimal, doc.class)
+    doc = p.parse('1234567890.1234567890123456789')
+    assert_equal(BigDecimal, doc.class)
+  end
+
+  def test_array
+    p = Oj::Parser.new(:usual)
+    [
+      ['[]', []],
+      ['[false]', [false]],
+      ['[true,false]', [true,false]],
+      ['[[]]', [[]]],
+      ['[true,[],false]', [true,[],false]],
+      ['[true,[true],false]', [true,[true],false]],
+    ].each { |x|
+      doc = p.parse(x[0])
+      assert_equal(x[1], doc)
+    }
+  end
+
+  def test_hash
+    p = Oj::Parser.new(:usual)
+    [
+      ['{}', {}],
+      ['{"a": null}', {'a' => nil}],
+      ['{"t": true, "f": false, "s": "abc"}', {'t' => true, 'f' => false, 's' => 'abc'}],
+      ['{"a": {}}', {'a' => {}}],
+      ['{"a": {"b": 2}}', {'a' => {'b' => 2}}],
+      ['{"a": [true]}', {'a' => [true]}],
+    ].each { |x|
+      doc = p.parse(x[0])
+      assert_equal(x[1], doc)
+    }
+  end
+
+  def test_symbol_keys
+    p = Oj::Parser.new(:usual)
+    assert_equal(false, p.symbol_keys)
+    p.symbol_keys = true
+    doc = p.parse('{"a": true, "b": false}')
+    assert_equal({a: true, b: false}, doc)
+  end
+
+  def test_strings
+    p = Oj::Parser.new(:usual)
+    doc = p.parse('{"ぴ": "", "ぴ ": "x", "c": "ぴーたー", "d": " ぴーたー "}')
+    assert_equal({'ぴ' => '', 'ぴ ' => 'x', 'c' => 'ぴーたー', 'd' => ' ぴーたー '}, doc)
+  end
+
+  def test_capacity
+    p = Oj::Parser.new(:usual, capacity: 1000)
+    assert_equal(4096, p.capacity)
+    p.capacity = 5000
+    assert_equal(5000, p.capacity)
+  end
+
+  def test_decimal
+    p = Oj::Parser.new(:usual)
+    assert_equal(:auto, p.decimal)
+    doc = p.parse('1.234567890123456789')
+    assert_equal(BigDecimal, doc.class)
+    assert_equal('0.1234567890123456789e1', doc.to_s)
+    doc = p.parse('1.25')
+    assert_equal(Float, doc.class)
+
+    p.decimal = :float
+    assert_equal(:float, p.decimal)
+    doc = p.parse('1.234567890123456789')
+    assert_equal(Float, doc.class)
+
+    p.decimal = :bigdecimal
+    assert_equal(:bigdecimal, p.decimal)
+    doc = p.parse('1.234567890123456789')
+    assert_equal(BigDecimal, doc.class)
+    doc = p.parse('1.25')
+    assert_equal(BigDecimal, doc.class)
+    assert_equal('0.125e1', doc.to_s)
+
+    p.decimal = :ruby
+    assert_equal(:ruby, p.decimal)
+    doc = p.parse('1.234567890123456789')
+    assert_equal(Float, doc.class)
+  end
+
+  def test_omit_null
+    p = Oj::Parser.new(:usual)
+    p.omit_null = true
+    doc = p.parse('{"a":true,"b":null}')
+    assert_equal({'a'=>true}, doc)
+
+    p.omit_null = false
+    doc = p.parse('{"a":true,"b":null}')
+    assert_equal({'a'=>true, 'b'=>nil}, doc)
+  end
+
+  class MyArray < Array
+  end
+
+  def test_array_class
+    p = Oj::Parser.new(:usual)
+    p.array_class = MyArray
+    assert_equal(MyArray, p.array_class)
+    doc = p.parse('[true]')
+    assert_equal(MyArray, doc.class)
+  end
+
+  class MyHash < Hash
+  end
+
+  def test_hash_class
+    p = Oj::Parser.new(:usual)
+    p.hash_class = MyHash
+    assert_equal(MyHash, p.hash_class)
+    doc = p.parse('{"a":true}')
+    assert_equal(MyHash, doc.class)
+  end
+
+  class MyClass
+    attr_accessor :a
+    attr_accessor :b
+
+    def to_s
+      "#{self.class}{a: #{@a} b: #{b}}"
+    end
+  end
+
+  class MyClass2 < MyClass
+    def self.json_create(arg)
+      obj = new
+      obj.a = arg['a']
+      obj.b = arg['b']
+      obj
+    end
+  end
+
+  def test_create_id
+    p = Oj::Parser.new(:usual)
+    p.create_id = '^'
+    doc = p.parse('{"a":true}')
+    assert_equal(Hash, doc.class)
+    doc = p.parse('{"a":true,"^":"UsualTest::MyClass","b":false}')
+    assert_equal('UsualTest::MyClass{a: true b: false}', doc.to_s)
+
+    doc = p.parse('{"a":true,"^":"UsualTest::MyClass2","b":false}')
+    assert_equal('UsualTest::MyClass2{a: true b: false}', doc.to_s)
+
+    p.hash_class = MyHash
+    assert_equal(MyHash, p.hash_class)
+    doc = p.parse('{"a":true}')
+    assert_equal(MyHash, doc.class)
+
+    doc = p.parse('{"a":true,"^":"UsualTest::MyClass","b":false}')
+    assert_equal('UsualTest::MyClass{a: true b: false}', doc.to_s)
+  end
+
+  def test_missing_class
+    p = Oj::Parser.new(:usual, create_id: '^')
+    json = '{"a":true,"^":"Auto","b":false}'
+    doc = p.parse(json)
+    assert_equal(Hash, doc.class)
+
+    p.missing_class = :auto
+    doc = p.parse(json)
+    # Auto should be defined after parsing
+    assert_equal(Auto, doc.class)
+  end
+
+  def test_class_cache
+    p = Oj::Parser.new(:usual)
+    p.create_id = '^'
+    p.class_cache = true
+    p.missing_class = :auto
+    json = '{"a":true,"^":"Auto2","b":false}'
+    doc = p.parse(json)
+    assert_equal(Auto2, doc.class)
+
+    doc = p.parse(json)
+    assert_equal(Auto2, doc.class)
+  end
+
+  def test_default_parser
+    doc = Oj::Parser.usual.parse('{"a":true,"b":null}')
+    assert_equal({'a'=>true, 'b'=>nil}, doc)
+  end
+end

data/test/test_rails.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+$: << File.dirname(__FILE__)
+
+require 'helper'
+
+class RailsJuice < Minitest::Test
+
+  def test_bigdecimal_dump
+    orig = Oj.default_options
+    Oj.default_options = { mode: :rails, bigdecimal_as_decimal: true }
+    bd = BigDecimal('123')
+    json = Oj.dump(bd)
+    Oj.default_options = orig
+
+    assert_equal('0.123e3', json.downcase)
+
+    json = Oj.dump(bd, mode: :rails, bigdecimal_as_decimal: false)
+    assert_equal('"0.123e3"', json.downcase)
+
+    json = Oj.dump(bd, mode: :rails, bigdecimal_as_decimal: true)
+    assert_equal('0.123e3', json.downcase)
+  end
+
+  def test_invalid_encoding
+    assert_raises(EncodingError) {
+      Oj.dump("\"\xf3j", mode: :rails)
+    }
+    assert_raises(EncodingError) {
+      Oj.dump("\xf3j", mode: :rails)
+    }
+  end
+
+end

data/test/test_saj.rb

@@ -180,7 +180,7 @@ class SajTest < Minitest::Test
     assert_equal([:add_value, 12345, nil], handler.calls.first)
     type, message, line, column = handler.calls.last
     assert_equal([:error, 1, 6], [type, line, column])
-    assert_match(%r{invalid format, extra characters at line 1, column 6 \[(?:[a-z\.]+/)*saj\.c:\d+\]}, message)
+    assert_match(%r{invalid format, extra characters at line 1, column 6 \[(?:[A-Za-z]:\/)?(?:[a-z\.]+/)*saj\.c:\d+\]}, message)
   end
 
 end

data/test/test_scp.rb

@@ -320,15 +320,15 @@ class ScpTest < Minitest::Test
   end
 
   def test_pipe
-    # Windows does not support fork
-    return if RbConfig::CONFIG['host_os'] =~ /(mingw|mswin)/
+    skip ' Windows does not support fork' if RbConfig::CONFIG['host_os'] =~ /(mingw|mswin)/
+    skip 'TruffleRuby fails this spec with `NotImplementedError: fork is not available`' if RUBY_ENGINE == 'truffleruby'
 
     handler = AllHandler.new()
     json = %{{"one":true,"two":false}}
     IO.pipe do |read_io, write_io|
       if fork
         write_io.close
-        Oj.sc_parse(handler, read_io) {|v| p v}
+        Oj.sc_parse(handler, read_io)
         read_io.close
         assert_equal([[:hash_start],
                       [:hash_key, 'one'],
@@ -357,8 +357,8 @@ class ScpTest < Minitest::Test
   end
 
   def test_pipe_close
-    # Windows does not support fork
-    return if RbConfig::CONFIG['host_os'] =~ /(mingw|mswin)/
+    skip 'Windows does not support fork' if RbConfig::CONFIG['host_os'] =~ /(mingw|mswin)/
+    skip 'TruffleRuby fails this spec with `NotImplementedError: fork is not available`' if RUBY_ENGINE == 'truffleruby'
 
     json = %{{"one":true,"two":false}}
     IO.pipe do |read_io, write_io|

data/test/test_strict.rb

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-# encoding: UTF-8
+# encoding: utf-8
 
 $: << File.dirname(__FILE__)
 $oj_dir = File.dirname(File.expand_path(File.dirname(__FILE__)))
@@ -156,6 +156,8 @@ class StrictJuice < Minitest::Test
   end
 
   def test_deep_nest
+    skip 'TruffleRuby causes SEGV' if RUBY_ENGINE == 'truffleruby'
+
     begin
       n = 10000
       Oj.strict_load('[' * n + ']' * n)
@@ -379,6 +381,29 @@ class StrictJuice < Minitest::Test
     assert_equal([{ 'x' => 1 }, { 'y' => 2 }], results)
   end
 
+  def test_invalid_decimal_dot_start
+    assert_raises(Oj::ParseError) {
+      Oj.load('.123', mode: :strict)
+    }
+    assert_raises(Oj::ParseError) {
+      Oj.load('-.123', mode: :strict)
+    }
+  end
+
+  def test_invalid_decimal_dot_end
+    json = '123.'
+    assert_raises(Oj::ParseError) {
+      Oj.load(json, mode: :strict)
+    }
+  end
+
+  def test_invalid_decimal_plus
+    json = '+12'
+    assert_raises(Oj::ParseError) {
+      Oj.load(json, mode: :strict)
+    }
+  end
+
   def test_circular_hash
     h = { 'a' => 7 }
     h['b'] = h