oj 3.8.0

data/test/activesupport5/encoding_test_cases.rb

@@ -0,0 +1,90 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,25 @@
+#!/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

@@ -0,0 +1,29 @@
+#!/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

@@ -0,0 +1,167 @@
+#!/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 'json'
+require 'oj'
+
+Oj.mimic_JSON
+
+obj = {
+  ab: {
+    cbbb: {
+      tilbeb: [
+        {
+          coob: {
+            uijwts: [
+              {
+                prrrrr: {
+                  yakj: "pvebbx",
+                  lbhqy: {
+                    uhyw: {
+                      uijwts: [
+                        {
+                          jangi: {
+                            ubentg7haineued8atnr8w: {
+                              abc: "uejdncbncnamnasdasdasdasd",
+                              cde: "skfjskdfjskdfjsdkfjsdkfjs"
+                            }
+                          }
+                        }
+                      ]
+                    }
+                  }
+                }
+              },
+              {
+                kdncg: {
+                  lvbnt8b9ounv: {
+                    qk: 9
+                  }
+                }
+              }
+            ],
+            jenfjbhe: {}
+          }
+        }
+      ]
+    }
+  },
+  ijbh: {
+    jsnbrpbnunt: {
+      b88dibalbvp: {
+        mnbvd: "9uhbqlpiev"
+      }
+    },
+    ncnwkl: {
+      ksdfsf: {
+        mjln: "mnklkn"
+      },
+      kbrh: {
+        sdfn83nnalbmgnansdd: {
+          uijwts: {
+            ibha: {
+              uijwts: [
+                {
+                  lnrbf: {
+                    nbvtmqbhap9ebeb7btnnaw: {
+                      ksb: "sdfksdfjsdfsb39242dnasddd",
+                      mnm: "1293dsfnsdmfnsdfsd,fmnsd,"
+                    }
+                  }
+                }
+              ]
+            }
+          },
+          kbrh: {
+            bo8libts: {
+              nag40n: {
+                kyen: "sdfasnc92nsn"
+              },
+              kbrh: {
+                nbwyu26snfcbajsdkj8: {
+                  uijwts: {
+                    mdfnkjsdd: {}
+                  },
+                  kbrh: {
+                    kneahce: {
+                      uijwts: {
+                        kwnb: {
+                          uijwts: [
+                            {
+                              fhfd: {
+                                sfasdnfmasndfamsdnfajsmdf: false
+                              }
+                            }
+                          ],
+                          asdfsdff: [
+                            {
+                              cwdf: {
+                                sddlkfajsdkfjabskdfjalsdkfjansdkfjf: ""
+                              }
+                            },
+                            {
+                              bsdj: {
+                                sdfsjdlfkasy8kljsfsdf83jlkjfals: true
+                              }
+                            }
+                          ]
+                        }
+                      },
+                      kbrh: {
+                        sdfsdfsddfk: {
+                          uijwts: {
+                            sdfsd: {
+                              sdfsadf89mnlrrrqurqwvdnff: {
+                                "kj": 8
+                              }
+                            }
+                          },
+                          kbrh: {
+                            dkdjd: {
+                              dfeteu: {
+                                sdfd: "sdfasdfjlkjslrsdbb"
+                              },
+                              kbrh: {
+                                sdfskjdfldk: {
+                                  buqpen: {
+                                    kjlkj: {
+                                      sdflskdjfalsdkrjalwkjfsrlfjasdf: {
+                                        sd: 0
+                                      }
+                                    }
+                                  },
+                                  kbrh: {
+                                    sdfksljdlfksdfl: {
+                                      sdfsdkfjssd: {
+                                        ksdjf: "sdflsdkfjasdkaufs;ldkfjsdlf",
+                                        sdfsdfsl: [5]
+                                      }
+                                    }
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+#Oj.dump(obj)
+JSON.pretty_generate(obj)
+#JSON.generate(obj)

data/test/helper.rb

@@ -0,0 +1,26 @@
+# 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

@@ -0,0 +1,308 @@
+# 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