oj 3.12.1 → 3.13.1

data/test/foo.rb

@@ -8,13 +8,6 @@ end
 
 require 'oj'
 
-Oj.default_options = {cache_keys: false, cache_str: 0}
+p = Oj::Parser.new(:debug)
 
-[:compat, :strict, :object].each { |mode|
-  GC.start
-  t = Time.now
-  Oj.load_file('pt_lemma_lookup.json', mode: mode)
-  puts "#{mode}: #{Time.now - t}"
-}
-
-# check saj and scp
+p.parse("[true, false]")

data/test/perf_parser.rb

@@ -0,0 +1,184 @@
+#!/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'
+require 'json'
+
+$verbose = false
+$iter = 50_000
+$with_bignum = false
+$size = 1
+$cache_keys = true
+$symbol_keys = false
+
+opts = OptionParser.new
+opts.on("-v", "verbose")                                  { $verbose = true }
+opts.on("-c", "--count [Int]", Integer, "iterations")     { |i| $iter = i }
+opts.on("-s", "--size [Int]", Integer, "size (~Kbytes)")  { |i| $size = i }
+opts.on("-b", "with bignum")                              { $with_bignum = true }
+opts.on("-k", "no cache")                                 { $cache_keys = false }
+opts.on("-sym", "symbol keys")                            { $symbol_keys = 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, 1, nil], 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
+
+if 0 < $size
+  o = $obj
+  $obj = []
+  (4 * $size).times do
+    $obj << o
+  end
+end
+
+$json = Oj.dump($obj)
+$failed = {} # key is same as String used in tests later
+Oj.default_options = {create_id: '^', create_additions: true, class_cache: true}
+if $cache_keys
+  Oj.default_options = {cache_keys: true, cache_str: 6, symbol_keys: $symbol_keys}
+else
+  Oj.default_options = {cache_keys: false, cache_str: 0, symbol_keys: $symbol_keys}
+end
+JSON.parser = JSON::Ext::Parser
+
+class AllSaj
+  def initialize()
+  end
+
+  def hash_start(key)
+  end
+
+  def hash_end(key)
+  end
+
+  def array_start(key)
+  end
+
+  def array_end(key)
+  end
+
+  def add_value(value, key)
+  end
+end # AllSaj
+
+class NoSaj
+  def initialize()
+  end
+end # NoSaj
+
+no_handler = NoSaj.new()
+all_handler = AllSaj.new()
+
+if $verbose
+  puts "json:\n#{$json}\n"
+end
+
+### Validate ######################
+p_val = Oj::Parser.new(:validate)
+
+puts '-' * 80
+puts "Validate Performance"
+perf = Perf.new()
+perf.add('Oj::Parser.validate', 'none') { p_val.parse($json) }
+perf.add('Oj::Saj.none', 'none') { Oj.saj_parse(no_handler, $json) }
+perf.run($iter)
+
+### SAJ ######################
+p_all = Oj::Parser.new(:saj)
+p_all.handler = all_handler
+p_all.cache_keys = $cache_keys
+p_all.cache_strings = 6
+
+puts '-' * 80
+puts "Parse Callback Performance"
+perf = Perf.new()
+perf.add('Oj::Parser.saj', 'all') { p_all.parse($json) }
+perf.add('Oj::Saj.all', 'all') { Oj.saj_parse(all_handler, $json) }
+perf.run($iter)
+
+### Usual ######################
+p_usual = Oj::Parser.new(:usual)
+p_usual.cache_keys = $cache_keys
+p_usual.cache_strings = ($cache_keys ? 6 : 0)
+p_usual.symbol_keys = $symbol_keys
+
+puts '-' * 80
+puts "Parse Usual Performance"
+perf = Perf.new()
+perf.add('Oj::Parser.usual', '') { p_usual.parse($json) }
+perf.add('Oj::strict_load', '') { Oj.strict_load($json) }
+perf.add('JSON::Ext', 'parse') { JSON.load($json) }
+perf.run($iter)
+
+### Usual Objects ######################
+
+# Original Oj follows the JSON gem for creating objects which uses the class
+# json_create(arg) method. Oj::Parser in usual mode supprts the same but also
+# handles populating the object variables directly which is faster.
+
+class Stuff
+  attr_accessor :alpha, :bravo, :charlie, :delta, :echo, :foxtrot, :golf, :hotel, :india, :juliet
+  def self.json_create(arg)
+    obj = self.new
+    obj.alpha = arg["alpha"]
+    obj.bravo = arg["bravo"]
+    obj.charlie = arg["charlie"]
+    obj.delta = arg["delta"]
+    obj.echo = arg["echo"]
+    obj.foxtrot = arg["foxtrot"]
+    obj.golf = arg["golf"]
+    obj.hotel = arg["hotel"]
+    obj.india = arg["india"]
+    obj.juliet = arg["juliet"]
+    obj
+  end
+end
+
+$obj_json = %|{
+  "alpha": [0, 1,2,3,4,5,6,7,8,9],
+  "bravo": true,
+  "charlie": 123,
+  "delta": "some string",
+  "echo": null,
+  "^": "Stuff",
+  "foxtrot": false,
+  "golf": "gulp",
+  "hotel": {"x": true, "y": false},
+  "india": [null, true, 123],
+  "juliet": "junk"
+}|
+
+p_usual.create_id = '^'
+p_usual.class_cache = true
+p_usual.ignore_json_create = true
+
+JSON.create_id = '^'
+
+puts '-' * 80
+puts "Parse Usual Object Performance"
+perf = Perf.new()
+perf.add('Oj::Parser.usual', '') { p_usual.parse($obj_json) }
+perf.add('Oj::compat_load', '') { Oj.compat_load($obj_json) }
+perf.add('JSON::Ext', 'parse') { JSON.load($obj_json) }
+perf.run($iter)
+
+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_parser.rb

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

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