oj 3.2.1 → 3.3.0

data/lib/oj/version.rb

@@ -1,5 +1,5 @@
 
 module Oj
   # Current version of the module. 
-  VERSION = '3.2.1'
+  VERSION = '3.3.0'
 end

data/pages/Modes.md

@@ -70,6 +70,13 @@ mimic the json gem including methods called for encoding and inconsistencies
 between `JSON.dump()`, `JSON.generate()`, and `JSON()`. More details on the
 [{file:Custom.md}](Custom.md) page.
 
+## :wab Mode
+
+WAB mode ignores all options except the indent option. Performance of this
+mode is on slightly better than the :strict and :null modes. It is included to
+support the [WABuR](https://github.com/ohler55/wabur) project. More details on
+the [{file:WAB.md}](WAB.md) page.
+
 ## Options Matrix
 
 Not all options are available in all modes. The options matrix identifies the
@@ -77,46 +84,46 @@ options available in each mode. An `x` in the matrix indicates the option is
 supported in that mode. A number indicates the footnotes describe additional
 information.
 
-    | Option                 | type    | :null   | :strict | :compat | :rails  | :object | :custom |
-    | ---------------------- | ------- | ------- | ------- | ------- | ------- | ------- | ------- |
-    | :allow_blank           | Boolean |         |         |       1 |       1 |         |       x |
-    | :allow_gc              | Boolean |       x |       x |       x |       x |       x |       x |
-    | :allow_invalid_unicode | Boolean |         |         |         |         |       x |       x |
-    | :allow_nan             | Boolean |         |         |       x |         |       x |       x |
-    | :array_class           | Class   |         |         |       x |       x |         |       x |
-    | :array_nl              | String  |         |         |         |         |         |       x |
-    | :ascii_only            | Boolean |       x |       x |       2 |       2 |       x |       x |
-    | :auto_define           | Boolean |         |         |         |         |       x |       x |
-    | :bigdecimal_as_decimal | Boolean |         |         |         |         |       x |       x |
-    | :bigdecimal_load       | Boolean |         |         |         |         |         |       x |
-    | :circular              | Boolean |       x |       x |       x |       x |       x |       x |
-    | :class_cache           | Boolean |         |         |         |         |       x |       x |
-    | :create_additions      | Boolean |         |         |       x |       x |         |       x |
-    | :create_id             | String  |         |         |       x |       x |         |       x |
-    | :empty_string          | Boolean |         |         |         |         |         |       x |
-    | :escape_mode           | Symbol  |         |         |         |         |         |       x |
-    | :float_precision       | Fixnum  |       x |       x |         |         |         |       x |
-    | :hash_class            | Class   |         |         |       x |       x |         |       x |
-    | :indent                | Integer |       x |       x |       3 |       3 |       x |       x |
-    | :indent_str            | String  |         |         |       x |       x |         |       x |
-    | :match_string          | Hash    |         |         |       x |       x |         |       x |
-    | :max_nesting           | Fixnum  |       4 |       4 |       x |         |       4 |       4 |
-    | :mode                  | Symbol  |       - |       - |       - |       - |       - |       - |
-    | :nan                   | Symbol  |         |         |         |         |         |       x |
-    | :nilnil                | Boolean |         |         |         |         |         |       x |
-    | :object_class          | Class   |         |         |       x |         |         |       x |
-    | :object_nl             | String  |         |         |       x |       x |         |       x |
-    | :omit_nil              | Boolean |       x |       x |       x |       x |       x |       x |
-    | :quirks_mode           | Boolean |         |         |       5 |         |         |       x |
-    | :second_precision      | Fixnum  |         |         |         |         |       x |       x |
-    | :space                 | String  |         |         |       x |       x |         |       x |
-    | :space_before          | String  |         |         |       x |       x |         |       x |
-    | :symbol_keys           | Boolean |       x |       x |       x |       x |       x |       x |
-    | :time_format           | Symbol  |         |         |         |         |       x |       x |
-    | :use_as_json           | Boolean |         |         |         |         |         |       x |
-    | :use_to_hash           | Boolean |         |         |         |         |         |       x |
-    | :use_to_json           | Boolean |         |         |         |         |         |       x |
-     ----------------------------------------------------------------------------------------------
+    | Option                 | type    | :null   | :strict | :compat | :rails  | :object | :custom |  :wab   |
+    | ---------------------- | ------- | ------- | ------- | ------- | ------- | ------- | ------- | ------- |
+    | :allow_blank           | Boolean |         |         |       1 |       1 |         |       x |         |
+    | :allow_gc              | Boolean |       x |       x |       x |       x |       x |       x |         |
+    | :allow_invalid_unicode | Boolean |         |         |         |         |       x |       x |         |
+    | :allow_nan             | Boolean |         |         |       x |         |       x |       x |         |
+    | :array_class           | Class   |         |         |       x |       x |         |       x |         |
+    | :array_nl              | String  |         |         |         |         |         |       x |         |
+    | :ascii_only            | Boolean |       x |       x |       2 |       2 |       x |       x |         |
+    | :auto_define           | Boolean |         |         |         |         |       x |       x |         |
+    | :bigdecimal_as_decimal | Boolean |         |         |         |         |       x |       x |         |
+    | :bigdecimal_load       | Boolean |         |         |         |         |         |       x |         |
+    | :circular              | Boolean |       x |       x |       x |       x |       x |       x |         |
+    | :class_cache           | Boolean |         |         |         |         |       x |       x |         |
+    | :create_additions      | Boolean |         |         |       x |       x |         |       x |         |
+    | :create_id             | String  |         |         |       x |       x |         |       x |         |
+    | :empty_string          | Boolean |         |         |         |         |         |       x |         |
+    | :escape_mode           | Symbol  |         |         |         |         |         |       x |         |
+    | :float_precision       | Fixnum  |       x |       x |         |         |         |       x |         |
+    | :hash_class            | Class   |         |         |       x |       x |         |       x |         |
+    | :indent                | Integer |       x |       x |       3 |       3 |       x |       x |       x |
+    | :indent_str            | String  |         |         |       x |       x |         |       x |         |
+    | :match_string          | Hash    |         |         |       x |       x |         |       x |         |
+    | :max_nesting           | Fixnum  |       4 |       4 |       x |         |       4 |       4 |         |
+    | :mode                  | Symbol  |       - |       - |       - |       - |       - |       - |         |
+    | :nan                   | Symbol  |         |         |         |         |         |       x |         |
+    | :nilnil                | Boolean |         |         |         |         |         |       x |         |
+    | :object_class          | Class   |         |         |       x |         |         |       x |         |
+    | :object_nl             | String  |         |         |       x |       x |         |       x |         |
+    | :omit_nil              | Boolean |       x |       x |       x |       x |       x |       x |         |
+    | :quirks_mode           | Boolean |         |         |       5 |         |         |       x |         |
+    | :second_precision      | Fixnum  |         |         |         |         |       x |       x |         |
+    | :space                 | String  |         |         |       x |       x |         |       x |         |
+    | :space_before          | String  |         |         |       x |       x |         |       x |         |
+    | :symbol_keys           | Boolean |       x |       x |       x |       x |       x |       x |         |
+    | :time_format           | Symbol  |         |         |         |         |       x |       x |         |
+    | :use_as_json           | Boolean |         |         |         |         |         |       x |         |
+    | :use_to_hash           | Boolean |         |         |         |         |         |       x |         |
+    | :use_to_json           | Boolean |         |         |         |         |         |       x |         |
+     --------------------------------------------------------------------------------------------------------
 
  1. :allow_blank an alias for :nilnil.
 

data/pages/WAB.md

@@ -0,0 +1,13 @@
+# WAB mode
+
+The `:wab` mode ignores all options except the indent option. Performance of
+this mode is slightly faster than the :strict and :null modes. It is included
+to support the [WABuR](https://github.com/ohler55/wabur) project.
+
+Options other than the indentation are not supported since the encoding and
+formats are defined by the API that is used to encode data being passed from
+one components in a WAB system and allowing an option that would break the
+data exchange is best not supported.
+
+The mode encodes like the strict mode except the URI, Time, WAB::UUID, and
+BigDecimal are supported.

data/test/perf_wab.rb

@@ -0,0 +1,131 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+$: << '.'
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+require 'optparse'
+require 'perf'
+require 'oj'
+
+$verbose = false
+$indent = 0
+$iter = 20000
+$with_bignum = false
+$with_nums = true
+$size = 0
+
+opts = OptionParser.new
+opts.on("-v", "verbose")                                    { $verbose = true }
+opts.on("-c", "--count [Int]", Integer, "iterations")       { |i| $iter = i }
+opts.on("-i", "--indent [Int]", Integer, "indentation")     { |i| $indent = i }
+opts.on("-s", "--size [Int]", Integer, "size (~Kbytes)")    { |i| $size = i }
+opts.on("-b", "with bignum")                                { $with_bignum = true }
+opts.on("-h", "--help", "Show this display")                { puts opts; Process.exit!(0) }
+files = opts.parse(ARGV)
+
+$obj = {
+  a: 'Alpha', # string
+  b: true,    # boolean
+  c: 12345,   # number
+  d: [ true, [false, [-123456789, nil], 3.9676, ['Something else.', false], nil]], # mix it up array
+  e: { zero: nil, one: 1, two: 2, three: [3], four: [0, 1, 2, 3, 4] }, # hash
+  f: nil,     # nil
+  h: { a: { b: { c: { d: {e: { f: { g: nil }}}}}}}, # deep hash, not that deep
+  i: [[[[[[[nil]]]]]]]  # deep array, again, not that deep
+}
+$obj[:g] = 12345678901234567890123456789 if $with_bignum
+
+Oj.default_options = { :indent => $indent, :mode => :wab }
+
+if 0 < $size
+  o = $obj
+  $obj = []
+  (4 * $size).times do
+    $obj << o
+  end
+end
+
+$json = Oj.dump($obj)
+$obj_json = Oj.dump($obj, :mode => :object)
+#puts "*** size: #{$obj_json.size}"
+#puts "*** #{$obj_json}"
+$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:wab', $obj, 'load', 'dump') { |o| Oj.wab_load(Oj.dump(o, :mode => :wab)) }
+capture_error('Yajl', $obj, 'encode', 'parse') { |o| require 'yajl'; Yajl::Parser.parse(Yajl::Encoder.encode(o)) }
+capture_error('JSON::Ext', $obj, 'generate', 'parse') { |o|
+  require 'json'
+  require 'json/ext'
+  JSON.generator = JSON::Ext::Generator
+  JSON.parser = JSON::Ext::Parser
+  JSON.parse(JSON.generate(o))
+}
+capture_error('JSON::Pure', $obj, 'generate', 'parse') { |o|
+  require 'json/pure'
+  JSON.generator = JSON::Pure::Generator
+  JSON.parser = JSON::Pure::Parser
+  JSON.parse(JSON.generate(o))
+}
+
+if $verbose
+  puts "json:\n#{$json}\n"
+  puts "object json:\n#{$obj_json}\n"
+  puts "Oj loaded object:\n#{Oj.wab_load($json)}\n"
+  puts "Yajl loaded object:\n#{Yajl::Parser.parse($json)}\n"
+  puts "JSON loaded object:\n#{JSON::Ext::Parser.new($json).parse}\n"
+end
+
+puts '-' * 80
+puts "Wab Parse Performance"
+perf = Perf.new()
+unless $failed.has_key?('JSON::Ext')
+  perf.add('JSON::Ext', 'parse') { JSON.parse($json) }
+  perf.before('JSON::Ext') { JSON.parser = JSON::Ext::Parser }
+end
+unless $failed.has_key?('JSON::Pure')
+  perf.add('JSON::Pure', 'parse') { JSON.parse($json) }
+  perf.before('JSON::Pure') { JSON.parser = JSON::Pure::Parser }
+end
+unless $failed.has_key?('Oj:wab')
+  perf.add('Oj:wab', 'wab_load') { Oj.wab_load($json) }
+end
+perf.add('Yajl', 'parse') { Yajl::Parser.parse($json) } unless $failed.has_key?('Yajl')
+perf.run($iter)
+
+puts '-' * 80
+puts "Wab 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:wab')
+  perf.add('Oj:wab', 'dump') { Oj.dump($obj, :mode => :wab) }
+end
+perf.add('Yajl', 'encode') { Yajl::Encoder.encode($obj) } unless $failed.has_key?('Yajl')
+perf.run($iter)
+
+puts
+puts '-' * 80
+puts
+
+unless $failed.empty?
+  puts "The following packages were not included for the reason listed"
+  $failed.each { |tag,msg| puts "***** #{tag}: #{msg}" }
+end

data/test/test_wab.rb

@@ -0,0 +1,307 @@
+#!/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 'minitest'
+require 'minitest/autorun'
+require 'stringio'
+require 'date'
+require 'bigdecimal'
+require 'uri'
+require 'oj'
+
+# Simple version of WAB::UUID for testing.
+module WAB
+  class UUID
+    attr_reader :id
+    def initialize(id)
+      @id = id.downcase
+      raise Exception.new("Invalid UUID format.") if /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.match(@id).nil?
+    end
+    def to_s
+      @id
+    end
+    def ==(other)
+      other.is_a?(self.class) && @id == other.id
+    end
+  end # UUID
+end # WAB
+
+
+class WabJuice < Minitest::Test
+
+  module TestModule
+  end
+
+  def test_nil
+    dump_and_load(nil, false)
+  end
+
+  def test_true
+    dump_and_load(true, false)
+  end
+
+  def test_false
+    dump_and_load(false, false)
+  end
+
+  def test_fixnum
+    dump_and_load(0, false)
+    dump_and_load(12345, false)
+    dump_and_load(-54321, false)
+    dump_and_load(1, false)
+  end
+
+  def test_float
+    dump_and_load(0.0, false)
+    dump_and_load(12345.6789, false)
+    dump_and_load(70.35, false)
+    dump_and_load(-54321.012, false)
+    dump_and_load(1.7775, false)
+    dump_and_load(2.5024, false)
+    dump_and_load(2.48e16, false)
+    dump_and_load(2.48e100 * 1.0e10, false)
+    dump_and_load(-2.48e100 * 1.0e10, false)
+  end
+
+  def test_nan_dump
+    assert_raises() { Oj.dump(0/0.0, mode: :wab) }
+  end
+
+  def test_infinity_dump
+    assert_raises() { Oj.dump(1/0.0, mode: :wab) }
+  end
+
+  def test_neg_infinity_dump
+    assert_raises() { Oj.dump(-1/0.0, mode: :wab) }
+  end
+
+  def test_string
+    dump_and_load('', false)
+    dump_and_load('abc', false)
+    dump_and_load("abc\ndef", false)
+    dump_and_load("a\u0041", false)
+  end
+
+  def test_encode
+    dump_and_load("ぴーたー", false)
+  end
+
+  def test_array
+    dump_and_load([], false)
+    dump_and_load([true, false], false)
+    dump_and_load(['a', 1, nil], false)
+    dump_and_load([[nil]], false)
+    dump_and_load([[nil], 58], false)
+  end
+
+  def test_array_deep
+    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_deep_nest
+    begin
+      n = 10000
+      Oj.wab_load('[' * n + ']' * n)
+    rescue Exception => e
+      assert(false, e.message)
+    end
+  end
+
+  # Hash
+  def test_hash
+    dump_and_load({}, false)
+    dump_and_load({ true: true, false: false}, false)
+    dump_and_load({ true: true, array: [], hash: { }}, false)
+  end
+
+  def test_hash_non_sym_keys
+    assert_raises() { Oj.dump({ 'true' => true}, mode: :wab) }
+  end
+
+  def test_hash_deep
+    dump_and_load({x1: {
+                      x2: {
+                        x3: {
+                          x4: {
+                            x5: {
+                              x6: {
+                                x7: {
+                                  x8: {
+                                    x9: {
+                                      x10: {
+                                        x11: {
+                                          x12: {
+                                            x13: {
+                                              x14: {
+                                                x15: {
+                                                  x16: {
+                                                    x17: {
+                                                      x18: {
+                                                        x19: {
+                                                          x20: {}}}}}}}}}}}}}}}}}}}}}, false)
+  end
+
+  def test_non_str_hash
+    assert_raises() { Oj.dump({ 1 => true, 0 => false }, mode: :wab) }
+  end
+
+  def test_bignum_object
+    dump_and_load(7 ** 55, false)
+  end
+
+  # BigDecimal
+  def test_bigdecimal_wab
+    dump_and_load(BigDecimal.new('3.14159265358979323846'), false)
+  end
+
+  def test_bigdecimal_load
+    orig = BigDecimal.new('80.51')
+    json = Oj.dump(orig, mode: :wab)
+    bg = Oj.load(json, :mode => :wab, :bigdecimal_load => true)
+    assert_equal(BigDecimal, bg.class)
+    assert_equal(orig, bg)
+  end
+
+  def test_range
+    assert_raises() { Oj.dump(1..7, mode: :wab) }
+  end
+
+  # Stream IO
+  def test_io_string
+    json = %{{
+  "x":true,
+  "y":58,
+  "z": [1,2,3]
+}
+}
+    input = StringIO.new(json)
+    obj = Oj.wab_load(input)
+    assert_equal({ x: true, y: 58, z: [1, 2, 3]}, obj)
+  end
+
+  def test_io_file
+    filename = File.join(File.dirname(__FILE__), 'open_file_test.json')
+    File.open(filename, 'w') { |f| f.write(%{{
+  "x":true,
+  "y":58,
+  "z": [1,2,3]
+}
+}) }
+    f = File.new(filename)
+    obj = Oj.wab_load(f)
+    f.close()
+    assert_equal({ x: true, y: 58, z: [1, 2, 3]}, obj)
+  end
+
+  def test_symbol
+    json = Oj.dump(:abc, mode: :wab)
+    assert_equal('"abc"', json)
+  end
+
+  def test_time
+    t = Time.gm(2017, 1, 5, 23, 58, 7, 123456.789)
+    json = Oj.dump(t, mode: :wab)
+    assert_equal('"2017-01-05T23:58:07.123456789Z"', json)
+    # must load and convert to json as the Time#== does not match identical
+    # times due to the way it tracks fractional seconds.
+    loaded = Oj.wab_load(json);
+    assert_equal(json, Oj.dump(loaded, mode: :wab), "json mismatch after load")
+  end
+
+  def test_uuid
+    u = ::WAB::UUID.new('123e4567-e89b-12d3-a456-426655440000')
+    json = Oj.dump(u, mode: :wab)
+    assert_equal('"123e4567-e89b-12d3-a456-426655440000"', json)
+    dump_and_load(u, false)
+  end
+
+  def test_uri
+    u = URI('http://opo.technology/sample')
+    json = Oj.dump(u, mode: :wab)
+    assert_equal('"http://opo.technology/sample"', json)
+    dump_and_load(u, false)
+  end
+
+  def test_class
+    assert_raises() { Oj.dump(WabJuice, mode: :wab) }
+  end
+
+  def test_module
+    assert_raises() { Oj.dump(TestModule, mode: :wab) }
+  end
+
+  # symbol_keys option
+  def test_symbol_keys
+    json = %{{
+  "x":true,
+  "y":58,
+  "z": [1,2,3]
+}
+}
+    obj = Oj.wab_load(json, :symbol_keys => true)
+    assert_equal({ x: true, y: 58, z: [1, 2, 3]}, obj)
+  end
+
+  # comments
+  def test_comment_slash
+    json = %{{
+  "x":true,//three
+  "y":58,
+  "z": [1,2,
+3 // six
+]}
+}
+    obj = Oj.wab_load(json)
+    assert_equal({ x: true, y: 58, z: [1, 2, 3]}, obj)
+  end
+
+  def test_comment_c
+    json = %{{
+  "x"/*one*/:/*two*/true,
+  "y":58,
+  "z": [1,2,3]}
+}
+    obj = Oj.wab_load(json)
+    assert_equal({ x: true, y: 58, z: [1, 2, 3]}, obj)
+  end
+
+  def test_comment
+    json = %{{
+  "x"/*one*/:/*two*/true,//three
+  "y":58/*four*/,
+  "z": [1,2/*five*/,
+3 // six
+]
+}
+}
+    obj = Oj.wab_load(json)
+    assert_equal({ x: true, y: 58, z: [1, 2, 3]}, obj)
+  end
+
+  def test_double
+    json = %{{ "x": 1}{ "y": 2}}
+    results = []
+    Oj.load(json, :mode => :wab) { |x| results << x }
+
+    assert_equal([{ x: 1 }, { y: 2 }], results)
+  end
+
+  def dump_and_load(obj, trace=false)
+    json = Oj.dump(obj, mode: :wab, indent: 2)
+    puts json if trace
+    loaded = Oj.wab_load(json);
+    if obj.nil?
+      assert_nil(loaded)
+    else
+      assert_equal(obj, loaded)
+    end
+    loaded
+  end
+
+end