oj 3.16.6 → 3.16.10

data/test/test_parser.rb

@@ -1,11 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-$LOAD_PATH << __dir__
-@oj_dir = File.dirname(File.expand_path(__dir__))
-%w(lib ext).each do |dir|
-  $LOAD_PATH << File.join(@oj_dir, dir)
-end
-
-require 'test_parser_usual'
-require 'test_parser_saj'

data/test/test_parser_debug.rb

@@ -1,27 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-$LOAD_PATH << __dir__
-@oj_dir = File.dirname(File.expand_path(__dir__))
-%w[lib ext].each do |dir|
-  $LOAD_PATH << File.join(@oj_dir, dir)
-end
-
-require 'minitest'
-require 'minitest/autorun'
-require 'stringio'
-require 'date'
-require 'bigdecimal'
-require 'oj'
-
-class ParserJuice < Minitest::Test
-
-  def test_array
-    p = Oj::Parser.new(:debug)
-    out = p.parse(%|[true, false, null, 123, -1.23, "abc"]|)
-    puts out
-    out = p.parse(%|{"abc": []}|)
-    puts out
-  end
-
-end

data/test/test_parser_saj.rb

@@ -1,337 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-$LOAD_PATH << __dir__
-
-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 = []
-
-    super
-  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, 12_345, 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, 12_345.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((12_345.6789e7 * 10_000).to_i, (handler.calls[0][1] * 10_000).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(-118_999, (handler.calls[0][1] * 10_000).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] * 10_000).to_i)
-    handler.calls[1][1] = 1_923_380
-    assert_equal([[:hash_start, nil, 1, 1],
-                  [:add_value, 1_923_380, '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

@@ -1,251 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-$LOAD_PATH << __dir__
-
-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)
-    refute(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_multi_parse
-    p = Oj::Parser.new(:usual)
-    out = []
-    p.parse('{"a":1}{"b":{"x":2}} {"c":3}') { |j| out.push(j) }
-    assert_equal([{'a'=>1}, {'b'=>{'x'=>2}},{'c'=>3}], out)
-  end
-
-  def test_multi_load
-    p = Oj::Parser.new(:usual)
-    out = []
-    r, w = IO.pipe
-    thread = Thread.new do
-      ['{"a":1}', '{"b":{"x"', ':2}}{"c":', '3}'].each { |seg|
-        w.write(seg)
-        sleep(0.1)
-      }
-      w.close
-    end
-    p.load(r) { |j| out.push(j) }
-    r.close
-    thread.join
-    assert_equal([{'a'=>1}, {'b'=>{'x'=>2}},{'c'=>3}], out)
-  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
-
-  def test_empty
-    p = Oj::Parser.new(:usual)
-    p.raise_on_empty = false
-    doc = p.parse('  ')
-    assert_nil(doc)
-
-    p.raise_on_empty = true
-    assert_raises(Oj::ParseError) { p.parse('  ') }
-  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

@@ -1,35 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-$LOAD_PATH << __dir__
-
-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