oj 3.9.1 → 3.16.11

data/test/activesupport5/encoding_test_cases.rb

@@ -1,90 +0,0 @@
-require 'bigdecimal'
-require 'date'
-require 'time'
-
-module JSONTest
-  class Foo
-    def initialize(a, b)
-      @a, @b = a, b
-    end
-  end
-
-  class Hashlike
-    def to_hash
-      { :foo => "hello", :bar => "world" }
-    end
-  end
-
-  class Custom
-    def initialize(serialized)
-      @serialized = serialized
-    end
-
-    def as_json(options = nil)
-      @serialized
-    end
-  end
-
-  class MyStruct < Struct.new(:name, :value)
-    def initialize(*)
-      @unused = "unused instance variable"
-      super
-    end
-  end
-
-  module EncodingTestCases
-    TrueTests     = [[ true,  %(true)  ]]
-    FalseTests    = [[ false, %(false) ]]
-    NilTests      = [[ nil,   %(null)  ]]
-    NumericTests  = [[ 1,     %(1)     ],
-                     [ 2.5,   %(2.5)   ],
-                     [ 0.0/0.0,   %(null) ],
-                     [ 1.0/0.0,   %(null) ],
-                     [ -1.0/0.0,  %(null) ],
-                     [ BigDecimal('0.0')/BigDecimal('0.0'),  %(null) ],
-                     [ BigDecimal('2.5'), %("#{BigDecimal('2.5')}") ]]
-
-    StringTests   = [[ 'this is the <string>',     %("this is the \\u003cstring\\u003e")],
-                     [ 'a "string" with quotes & an ampersand', %("a \\"string\\" with quotes \\u0026 an ampersand") ],
-                     [ 'http://test.host/posts/1', %("http://test.host/posts/1")],
-                     [ "Control characters: \x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\u2028\u2029",
-                       %("Control characters: \\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\\b\\t\\n\\u000b\\f\\r\\u000e\\u000f\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\\u0018\\u0019\\u001a\\u001b\\u001c\\u001d\\u001e\\u001f\\u2028\\u2029") ]]
-
-    ArrayTests    = [[ ['a', 'b', 'c'],          %([\"a\",\"b\",\"c\"])        ],
-                     [ [1, 'a', :b, nil, false], %([1,\"a\",\"b\",null,false]) ]]
-
-    HashTests     = [[ {foo: "bar"}, %({\"foo\":\"bar\"}) ],
-                     [ {1 => 1, 2 => 'a', 3 => :b, 4 => nil, 5 => false}, %({\"1\":1,\"2\":\"a\",\"3\":\"b\",\"4\":null,\"5\":false}) ]]
-
-    RangeTests    = [[ 1..2,     %("1..2")],
-                     [ 1...2,    %("1...2")],
-                     [ 1.5..2.5, %("1.5..2.5")]]
-
-    SymbolTests   = [[ :a,     %("a")    ],
-                     [ :this,  %("this") ],
-                     [ :"a b", %("a b")  ]]
-
-    ObjectTests   = [[ Foo.new(1, 2), %({\"a\":1,\"b\":2}) ]]
-    HashlikeTests = [[ Hashlike.new, %({\"bar\":\"world\",\"foo\":\"hello\"}) ]]
-    StructTests   = [[ MyStruct.new(:foo, "bar"), %({\"name\":\"foo\",\"value\":\"bar\"}) ],
-                     [ MyStruct.new(nil, nil), %({\"name\":null,\"value\":null}) ]]
-    CustomTests   = [[ Custom.new("custom"), '"custom"' ],
-                     [ Custom.new(nil), 'null' ],
-                     [ Custom.new(:a), '"a"' ],
-                     [ Custom.new([ :foo, "bar" ]), '["foo","bar"]' ],
-                     [ Custom.new({ :foo => "hello", :bar => "world" }), '{"bar":"world","foo":"hello"}' ],
-                     [ Custom.new(Hashlike.new), '{"bar":"world","foo":"hello"}' ],
-                     [ Custom.new(Custom.new(Custom.new(:a))), '"a"' ]]
-
-    RegexpTests   = [[ /^a/, '"(?-mix:^a)"' ], [/^\w{1,2}[a-z]+/ix, '"(?ix-m:^\\\\w{1,2}[a-z]+)"']]
-
-    DateTests     = [[ Date.new(2005,2,1), %("2005/02/01") ]]
-    TimeTests     = [[ Time.utc(2005,2,1,15,15,10), %("2005/02/01 15:15:10 +0000") ]]
-    DateTimeTests = [[ DateTime.civil(2005,2,1,15,15,10), %("2005/02/01 15:15:10 +0000") ]]
-
-    StandardDateTests     = [[ Date.new(2005,2,1), %("2005-02-01") ]]
-    StandardTimeTests     = [[ Time.utc(2005,2,1,15,15,10), %("2005-02-01T15:15:10.000Z") ]]
-    StandardDateTimeTests = [[ DateTime.civil(2005,2,1,15,15,10), %("2005-02-01T15:15:10.000+00:00") ]]
-    StandardStringTests   = [[ 'this is the <string>', %("this is the <string>")]]
-  end
-end

data/test/activesupport5/test_helper.rb

@@ -1,50 +0,0 @@
-require 'active_support/testing/assertions'
-require 'active_support/testing/deprecation'
-require 'active_support/testing/declarative'
-require 'minitest/autorun'
-
-module ActiveSupport
-  class TestCase < ::Minitest::Test
-    # Skips the current run on Rubinius using Minitest::Assertions#skip
-    private def rubinius_skip(message = "")
-      skip message if RUBY_ENGINE == "rbx"
-    end
-    # Skips the current run on JRuby using Minitest::Assertions#skip
-    private def jruby_skip(message = "")
-      skip message if defined?(JRUBY_VERSION)
-    end
-
-    Assertion = Minitest::Assertion
-
-    alias_method :method_name, :name
-
-    include ActiveSupport::Testing::Assertions
-    include ActiveSupport::Testing::Deprecation
-    extend ActiveSupport::Testing::Declarative
-
-    # test/unit backwards compatibility methods
-    alias :assert_raise :assert_raises
-    alias :assert_not_empty :refute_empty
-    alias :assert_not_equal :refute_equal
-    alias :assert_not_in_delta :refute_in_delta
-    alias :assert_not_in_epsilon :refute_in_epsilon
-    alias :assert_not_includes :refute_includes
-    alias :assert_not_instance_of :refute_instance_of
-    alias :assert_not_kind_of :refute_kind_of
-    alias :assert_no_match :refute_match
-    alias :assert_not_nil :refute_nil
-    alias :assert_not_operator :refute_operator
-    alias :assert_not_predicate :refute_predicate
-    alias :assert_not_respond_to :refute_respond_to
-    alias :assert_not_same :refute_same
-
-    # Fails if the block raises an exception.
-    #
-    #   assert_nothing_raised do
-    #     ...
-    #   end
-    def assert_nothing_raised(*args)
-      yield
-    end
-  end
-end

data/test/activesupport5/time_zone_test_helpers.rb

@@ -1,24 +0,0 @@
-module TimeZoneTestHelpers
-  def with_tz_default(tz = nil)
-    old_tz = Time.zone
-    Time.zone = tz
-    yield
-  ensure
-    Time.zone = old_tz
-  end
-
-  def with_env_tz(new_tz = 'US/Eastern')
-    old_tz, ENV['TZ'] = ENV['TZ'], new_tz
-    yield
-  ensure
-    old_tz ? ENV['TZ'] = old_tz : ENV.delete('TZ')
-  end
-
-  def with_preserve_timezone(value)
-    old_preserve_tz = ActiveSupport.to_time_preserves_timezone
-    ActiveSupport.to_time_preserves_timezone = value
-    yield
-  ensure
-    ActiveSupport.to_time_preserves_timezone = old_preserve_tz
-  end
-end

data/test/bar.rb

@@ -1,25 +0,0 @@
-#!/usr/bin/env ruby
-# 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 'oj'
-
-#Oj.load_file(ARGV[0], mode: :strict) { |obj|
-#  puts Oj.dump(obj, indent: 2)
-#}
-
-data = open('invalid_unicode.data').read
-
-puts data
-
-puts Oj.dump(data)
-
-Oj.mimic_JSON
-puts Oj.dump(data, escape_mode: :json)
-
-puts Oj.default_options

data/test/files.rb

@@ -1,29 +0,0 @@
-#!/usr/bin/env ruby -wW2
-
-if $0 == __FILE__
-  $: << '.'
-  $: << '..'
-  $: << '../lib'
-  $: << '../ext'
-end
-
-require 'pp'
-require 'sample/file'
-require 'sample/dir'
-
-def files(dir)
-  d = ::Sample::Dir.new(dir)
-  Dir.new(dir).each do |fn|
-    next if fn.start_with?('.')
-    filename = File.join(dir, fn)
-    #filename = '.' == dir ? fn : File.join(dir, fn)
-    if File.directory?(filename)
-      d << files(filename)
-    else
-      d << ::Sample::File.new(filename)
-    end
-  end
-  #pp d
-  d
-end
-

data/test/foo.rb

@@ -1,21 +0,0 @@
-#!/usr/bin/env ruby
-# 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 'oj'
-require 'active_support'
-require 'active_support/json'
-#require 'tracer'
-
-Oj::Rails.set_encoder()
-Oj::Rails.set_decoder()
-Oj::Rails.optimize()
-
-#Oj::mimic_JSON
-
-puts JSON.parse('{"a":1}', symbolize_names: true)

data/test/helper.rb

@@ -1,26 +0,0 @@
-# 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
-
-$VERBOSE = true
-
-%w(lib ext test).each do |dir|
-  $LOAD_PATH.unshift File.expand_path("../../#{dir}", __FILE__)
-end
-
-require 'minitest'
-require 'minitest/autorun'
-require 'stringio'
-require 'date'
-require 'bigdecimal'
-require 'pp'
-require 'oj'
-
-$ruby = RUBY_DESCRIPTION.split(' ')[0]
-$ruby = 'ree' if 'ruby' == $ruby && RUBY_DESCRIPTION.include?('Ruby Enterprise Edition')
-
-class Range
-  def to_hash()
-    { 'begin' => self.begin, 'end' => self.end, 'exclude_end' => self.exclude_end? }
-  end
-end

data/test/isolated/shared.rb

@@ -1,308 +0,0 @@
-# encoding: UTF-8
-
-# The rails tests set this to true. Both Rails and the JSON gem monkey patch the
-# as_json methods on several base classes. Depending on which one replaces the
-# method last the behavior will be different. Oj.mimic_JSON abides by the same
-# conflicting behavior and the tests reflect that.
-$rails_monkey = false unless defined?($rails_monkey)
-
-class SharedMimicTest < Minitest::Test
-  class Jam
-    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 as_json()
-      {"json_class" => self.class.to_s,"x" => @x,"y" => @y}
-    end
-
-    def self.json_create(h)
-      self.new(h['x'], h['y'])
-    end
-
-  end # Jam
-
-  def setup
-    @default_options = Oj.default_options
-    @time = Time.at(1400000000).utc
-    @expected_time_string =
-      if defined?(Rails)
-        %{"2014-05-13T16:53:20.000Z"}
-      else
-        %{"2014-05-13 16:53:20 UTC"}
-      end
-  end
-
-  def teardown
-    Oj.default_options = @default_options
-  end
-
-# exception
-  def test_exception
-    begin
-      JSON.parse("{")
-      puts "Failed"
-    rescue JSON::ParserError
-      assert(true)
-    rescue Exception
-      assert(false, 'Expected a JSON::ParserError')
-    end
-  end
-
-# dump
-  def test_dump_string
-    json = JSON.dump([1, true, nil, @time])
-    if $rails_monkey
-      assert_equal(%{[1,true,null,#{@expected_time_string}]}, json)
-    else
-      assert_equal(%{[1,true,null,{"json_class":"Time","s":1400000000,"n":0}]}, json)
-    end
-  end
-
-  def test_dump_with_options
-    Oj.default_options= {:indent => 2} # JSON this will not change anything
-    json = JSON.dump([1, true, nil, @time])
-    if $rails_monkey
-      assert_equal(%{[
-  1,
-  true,
-  null,
-  #{@expected_time_string}
-]
-}, json)
-    else
-      assert_equal(%{[
-  1,
-  true,
-  null,
-  {
-    "json_class":"Time",
-    "s":1400000000,
-    "n\":0
-  }
-]
-}, json)
-    end
-  end
-
-  def test_dump_io
-    s = StringIO.new()
-    json = JSON.dump([1, true, nil, @time], s)
-    assert_equal(s, json)
-    if $rails_monkey
-      assert_equal(%{[1,true,null,#{@expected_time_string}]}, s.string)
-    else
-      assert_equal(%{[1,true,null,{"json_class":"Time","s":1400000000,"n":0}]}, s.string)
-    end
-  end
-  # TBD options
-
-  def test_dump_struct
-    # anonymous Struct not supported by json so name it
-    if Object.const_defined?("Struct::Abc")
-      s = Struct::Abc
-    else
-      s = Struct.new("Abc", :a, :b, :c)
-    end
-    o = s.new(1, 'two', [true, false])
-    json = JSON.dump(o)
-    if o.respond_to?(:as_json)
-      if $rails_monkey
-        assert_equal(%|{"a":1,"b":"two","c":[true,false]}|, json)
-      else
-        assert_equal(%|{"json_class":"Struct::Abc","v":[1,"two",[true,false]]}|, json)
-      end
-    else
-      j = '"' + o.to_s.gsub('"', '\\"') + '"'
-      assert_equal(j, json)
-    end
-  end
-
-# load
-  def test_load_string
-    json = %{{"a":1,"b":[true,false]}}
-    obj = JSON.load(json)
-    assert_equal({ 'a' => 1, 'b' => [true, false]}, obj)
-  end
-
-  def test_load_io
-    json = %{{"a":1,"b":[true,false]}}
-    obj = JSON.load(StringIO.new(json))
-    assert_equal({ 'a' => 1, 'b' => [true, false]}, obj)
-  end
-
-  def test_load_proc
-    Oj.mimic_JSON
-    children = []
-    json = %{{"a":1,"b":[true,false]}}
-    if 'rubinius' == $ruby
-      obj = JSON.load(json) {|x| children << x }
-    else
-      p = Proc.new {|x| children << x }
-      obj = JSON.load(json, p)
-    end
-    assert_equal({ 'a' => 1, 'b' => [true, false]}, obj)
-    assert([1, true, false, [true, false], { 'a' => 1, 'b' => [true, false]}] == children ||
-           [true, false, [true, false], 1, { 'a' => 1, 'b' => [true, false]}] == children,
-           "children don't match")
-  end
-
-  def test_parse_with_quirks_mode
-    json = %{null}
-    assert_equal(nil, JSON.parse(json, :quirks_mode => true))
-    assert_raises(JSON::ParserError) { JSON.parse(json, :quirks_mode => false) }
-    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]}}
-    obj = JSON[json]
-    assert_equal({ 'a' => 1, 'b' => [true, false]}, obj)
-  end
-
-  def test_bracket_dump
-    json = JSON[[1, true, nil]]
-    assert_equal(%{[1,true,null]}, json)
-  end
-
-# generate
-  def test_generate
-    json = JSON.generate({ 'a' => 1, 'b' => [true, false]})
-    assert(%{{"a":1,"b":[true,false]}} == json ||
-           %{{"b":[true,false],"a":1}} == json)
-  end
-  def test_generate_options
-    json = JSON.generate({ 'a' => 1, 'b' => [true, false]},
-                         :indent => "--",
-                         :array_nl => "\n",
-                         :object_nl => "#\n",
-                         :space => "*",
-                         :space_before => "~")
-    assert(%{{#
---"a"~:*1,#
---"b"~:*[
-----true,
-----false
---]#
-}} == json ||
-%{{#
---"b"~:*[
-----true,
-----false
---],#
---"a"~:*1#
-}} == json)
-
-  end
-
-# fast_generate
-  def test_fast_generate
-    json = JSON.generate({ 'a' => 1, 'b' => [true, false]})
-    assert(%{{"a":1,"b":[true,false]}} == json ||
-           %{{"b":[true,false],"a":1}} == json)
-  end
-
-# pretty_generate
-  def test_pretty_generate
-    json = JSON.pretty_generate({ 'a' => 1, 'b' => [true, false]})
-    assert(%{{
-  "a": 1,
-  "b": [
-    true,
-    false
-  ]
-}} == json ||
-%{{
-  "b": [
-    true,
-    false
-  ],
-  "a": 1
-}} == json)
-  end
-
-# parse
-  def test_parse
-    json = %{{"a":1,"b":[true,false]}}
-    obj = JSON.parse(json)
-    assert_equal({ 'a' => 1, 'b' => [true, false]}, obj)
-  end
-  def test_parse_sym_names
-    json = %{{"a":1,"b":[true,false]}}
-    obj = JSON.parse(json, :symbolize_names => true)
-    assert_equal({ :a => 1, :b => [true, false]}, obj)
-  end
-  def test_parse_additions
-    jam = Jam.new(true, 58)
-    json = Oj.dump(jam, :mode => :compat, :use_to_json => true)
-    obj = JSON.parse(json)
-    assert_equal(jam, obj)
-    obj = JSON.parse(json, :create_additions => true)
-    assert_equal(jam, obj)
-    obj = JSON.parse(json, :create_additions => false)
-    assert_equal({'json_class' => 'SharedMimicTest::Jam', 'x' => true, 'y' => 58}, obj)
-    json.gsub!('json_class', 'kson_class')
-    JSON.create_id = 'kson_class'
-    obj = JSON.parse(json, :create_additions => true)
-    JSON.create_id = 'json_class'
-    assert_equal(jam, obj)
-  end
-  def test_parse_bang
-    json = %{{"a":1,"b":[true,false]}}
-    obj = JSON.parse!(json)
-    assert_equal({ 'a' => 1, 'b' => [true, false]}, obj)
-  end
-
-# recurse_proc
-  def test_recurse_proc
-    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
-      assert([1, true, false, [true, false], { 'a' => 1, 'b' => [true, false]}] == children ||
-             [true, false, [true, false], 1, { 'b' => [true, false], 'a' => 1}] == children)
-    end
-  end
-
-# make sure to_json is defined for object.
-  def test_mimic_to_json
-    {'a' => 1}.to_json()
-    Object.new().to_json()
-  end
-end # SharedMimicTest
-
-if defined?(ActiveSupport)
-  class SharedMimicRailsTest < SharedMimicTest
-    def test_activesupport_exception
-      begin
-        ActiveSupport::JSON.decode("{")
-        puts "Failed"
-      rescue ActiveSupport::JSON.parse_error
-        assert(true)
-      rescue Exception
-        assert(false, 'Expected a JSON::ParserError')
-      end
-    end
-
-    def test_activesupport_encode
-      Oj.default_options= {:indent => 0}
-      json = ActiveSupport::JSON.encode([1, true, nil])
-      assert_equal(%{[1,true,null]}, json)
-    end
-  end # SharedMimicRailsTest
-end

data/test/isolated/test_mimic_after.rb

@@ -1,13 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-$: << File.join(File.dirname(__FILE__), '..')
-
-require 'helper'
-require 'isolated/shared'
-
-require 'json'
-Oj.mimic_JSON
-
-class MimicAfter < SharedMimicTest
-end # MimicAfter

data/test/isolated/test_mimic_alone.rb

@@ -1,12 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-$: << File.join(File.dirname(__FILE__), '..')
-
-require 'helper'
-require 'isolated/shared'
-
-Oj.mimic_JSON
-
-class MimicAlone < SharedMimicTest
-end # MimicAlone

data/test/isolated/test_mimic_as_json.rb

@@ -1,45 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-$: << File.dirname(__FILE__)
-
-require 'helper'
-require 'oj'
-
-class ObjectFolder < Minitest::Test
-  class Raccoon
-    attr_accessor :name
-
-    def initialize(name)
-      @name = name
-    end
-
-    def as_json(options={})
-      {:name => @name}.merge(options)
-    end
-  end
-
-  def setup
-    @default_options = Oj.default_options
-  end
-
-  def teardown
-    Oj.default_options = @default_options
-  end
-
-  def test_as_json_options
-    Oj.mimic_JSON()
-    raccoon = Raccoon.new('Rocket')
-    json = raccoon.to_json()
-    assert_equal(json, '{"name":"Rocket"}')
-
-    json = raccoon.to_json(:occupation => 'bounty hunter')
-    # depending on the ruby version the order of the hash members maybe different.
-    if (json.start_with?('{"name'))
-        assert_equal(json, '{"name":"Rocket","occupation":"bounty hunter"}')
-    else
-        assert_equal(json, '{"occupation":"bounty hunter","name":"Rocket"}')
-    end
-  end
-
-end

data/test/isolated/test_mimic_before.rb

@@ -1,13 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-$: << File.join(File.dirname(__FILE__), '..')
-
-require 'helper'
-require 'isolated/shared'
-
-Oj.mimic_JSON
-require 'json'
-
-class MimicBefore < SharedMimicTest
-end # MimicBefore

data/test/isolated/test_mimic_define.rb

@@ -1,28 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-$: << File.join(File.dirname(__FILE__), '..')
-
-require 'helper'
-
-class MimicDefine < Minitest::Test
-  def test_mimic_define
-    assert(defined?(JSON).nil?)
-    Oj.mimic_JSON
-
-    # Test constants
-    assert(!defined?(JSON).nil?)
-    assert(!defined?(JSON::ParserError).nil?)
-    assert(Object.respond_to?(:to_json))
-
-    # Test loaded features
-    assert(!require('json'))
-
-    begin
-      require('json_spec')
-      assert(false, '** should raise LoadError')
-    rescue LoadError
-      assert(true)
-    end
-  end
-end # MimicSingle