oj 1.0.6 → 1.1.0

data/ext/oj/oj.h

@@ -64,6 +64,12 @@ extern "C" {
 #define IVAR_HELPERS 0
 #endif
 
+#if IVAR_HELPERS
+#include "ruby/st.h"
+#else
+#include "st.h"
+#endif
+
 #define raise_error(msg, xml, current) _oj_raise_error(msg, xml, current, __FILE__, __LINE__)
 
 typedef enum {
@@ -79,6 +85,19 @@ typedef enum {
     CompatMode  = 'c'
 } Mode;
 
+typedef struct _DumpOpts {
+    const char	*indent;
+    const char	*before_sep;
+    const char	*after_sep;
+    const char	*hash_nl;
+    const char	*array_nl;
+    uint8_t	indent_size;
+    uint8_t	before_size;
+    uint8_t	after_size;
+    uint8_t	hash_size;
+    uint8_t	array_size;
+} *DumpOpts;
+
 typedef struct _Options {
     char        encoding[64];	// encoding, stored in the option to avoid GC invalidation in default values
     int         indent;		// indention for dump, default 2
@@ -87,6 +106,7 @@ typedef struct _Options {
     char        sym_key;	// YesNo
     char        ascii_only;	// YesNo
     char        mode;		// Mode
+    DumpOpts	dump_opts;
 } *Options;
 
 enum {

data/lib/oj/version.rb

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

data/test/perf.rb

@@ -91,6 +91,7 @@ class Perf
 
     def run(iter, base)
       begin
+        GC.start
         @before.call unless @before.nil?
         start = Time.now
         iter.times { @blk.call }

data/test/perf_fast.rb

@@ -18,6 +18,7 @@ $iter = 10000
 $gets = 0
 $fetch = false
 $write = false
+$read = false
 
 opts = OptionParser.new
 opts.on("-v", "verbose")                                  { $verbose = true }
@@ -26,6 +27,7 @@ opts.on("-i", "--indent [Int]", Integer, "indentation")   { |i| $indent = i }
 opts.on("-g", "--gets [Int]", Integer, "number of gets")  { |i| $gets = i }
 opts.on("-f", "fetch")                                    { $fetch = true }
 opts.on("-w", "write")                                    { $write = true }
+opts.on("-r", "read")                                     { $read = true }
 opts.on("-h", "--help", "Show this display")              { puts opts; Process.exit!(0) }
 files = opts.parse(ARGV)
 
@@ -139,6 +141,23 @@ if $write
   end
 end
 
+if $read
+  puts '-' * 80
+  puts "JSON read from file Performance"
+  Oj::Doc.open($json) { |doc| doc.dump(nil, 'oj.json') }
+  File.open('yajl.json', 'w') { |f| Yajl::Encoder.encode($obj, f) }
+  JSON.generator = JSON::Ext::Generator
+  File.open('json_ext.json', 'w') { |f| f.write(JSON.fast_generate($obj)) }
+  Oj::Doc.open($json) do |doc|
+    perf = Perf.new()
+    perf.add('Oj::Doc', 'open_file') { ::Oj::Doc.open_file('oj.json') }
+    perf.add('Yajl', 'decode') { Yajl::decoder.decode(File.read('yajl.json')) }
+    perf.add('JSON::Ext', '') { JSON.parse(File.read('json_ext.json')) }
+    perf.before('JSON::Ext') { JSON.parser = JSON::Ext::Parser }
+    perf.run($iter)
+  end
+end
+
 unless $failed.empty?
   puts "The following packages were not included for the reason listed"
   $failed.each { |tag,msg| puts "***** #{tag}: #{msg}" }

data/test/perf_strict.rb

@@ -65,7 +65,7 @@ end
 
 $verbose = false
 $indent = 0
-$iter = 100000
+$iter = 10000
 $with_object = true
 $with_bignum = true
 $with_nums = true
@@ -130,8 +130,16 @@ capture_error('Oj', $obj, 'load', 'dump') { |o| Oj.load(Oj.dump(o, :mode => :com
 capture_error('Ox', $obj, 'load', 'dump') { |o| Ox.load(Ox.dump(o, :mode => :object), :mode => :object) }
 capture_error('MessagePack', $obj, 'unpack', 'pack') { |o| MessagePack.unpack(MessagePack.pack($obj)) }
 capture_error('Yajl', $obj, 'encode', 'parse') { |o| Yajl::Parser.parse(Yajl::Encoder.encode(o)) }
-capture_error('JSON::Ext', $obj, 'generate', 'parse') { |o| JSON.generator = JSON::Ext::Generator; JSON::Ext::Parser.new(JSON.generate(o)).parse }
-capture_error('JSON::Pure', $obj, 'generate', 'parse') { |o| JSON.generator = JSON::Pure::Generator; JSON::Pure::Parser.new(JSON.generate(o)).parse }
+capture_error('JSON::Ext', $obj, 'generate', 'parse') { |o|
+  JSON.generator = JSON::Ext::Generator
+  JSON.parser = JSON::Ext::Parser
+  JSON.parse(JSON.generate(o))
+}
+capture_error('JSON::Pure', $obj, 'generate', 'parse') { |o|
+  JSON.generator = JSON::Pure::Generator
+  JSON.parser = JSON::Pure::Parser
+  JSON.parse(JSON.generate(o))
+}
 
 begin
   $msgpack = MessagePack.pack($obj)
@@ -150,6 +158,14 @@ end
 puts '-' * 80
 puts "Load/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:compat')
   perf.add('Oj:compat', 'load') { Oj.load($json) }
   perf.before('Oj:compat') { Oj.default_options = { :mode => :compat} }
@@ -159,8 +175,6 @@ unless $failed.has_key?('Oj')
   perf.before('Oj') { Oj.default_options = { :mode => :object} }
 end
 perf.add('Yajl', 'parse') { Yajl::Parser.parse($json) } unless $failed.has_key?('Yajl')
-perf.add('JSON::Ext', 'parse') { JSON::Ext::Parser.new($json).parse } unless $failed.has_key?('JSON::Ext')
-perf.add('JSON::Pure', 'parse') { JSON::Pure::Parser.new($json).parse } unless $failed.has_key?('JSON::Ext')
 perf.add('Ox', 'load') { Ox.load($xml) } unless $failed.has_key?('Ox')
 perf.add('MessagePack', 'unpack') { MessagePack.unpack($msgpack) } unless $failed.has_key?('MessagePack')
 perf.run($iter)
@@ -169,15 +183,6 @@ puts
 puts '-' * 80
 puts "Dump/Encode/Generate Performance"
 perf = Perf.new()
-unless $failed.has_key?('Oj:compat')
-  perf.add('Oj:compat', 'dump') { Oj.dump($obj) }
-  perf.before('Oj:compat') { Oj.default_options = { :mode => :compat} }
-end
-unless $failed.has_key?('Oj')
-  perf.add('Oj', 'dump') { Oj.dump($obj) }
-  perf.before('Oj') { Oj.default_options = { :mode => :object} }
-end
-perf.add('Yajl', 'encode') { Yajl::Encoder.encode($obj) } unless $failed.has_key?('Yajl')
 unless $failed.has_key?('JSON::Ext')
   if 0 == $indent
     perf.add('JSON::Ext', 'generate') { JSON.generate($obj) }
@@ -194,6 +199,15 @@ unless $failed.has_key?('JSON::Pure')
   end
   perf.before('JSON::Pure') { JSON.generator = JSON::Pure::Generator }
 end
+unless $failed.has_key?('Oj')
+  perf.add('Oj', 'dump') { Oj.dump($obj) }
+  perf.before('Oj') { Oj.default_options = { :mode => :object} }
+end
+unless $failed.has_key?('Oj:compat')
+  perf.add('Oj:compat', 'dump') { Oj.dump($obj) }
+  perf.before('Oj:compat') { Oj.default_options = { :mode => :compat} }
+end
+perf.add('Yajl', 'encode') { Yajl::Encoder.encode($obj) } unless $failed.has_key?('Yajl')
 perf.add('Ox', 'dump') { Ox.dump($obj) } unless $failed.has_key?('Ox')
 perf.add('MessagePack', 'pack') { MessagePack.pack($obj) } unless $failed.has_key?('MessagePack')
 perf.run($iter)

data/test/test_fast.rb

@@ -310,6 +310,43 @@ class DocTest < ::Test::Unit::TestCase
     end
   end
 
+  def test_open_close
+    json = %{{"a":[1,2,3]}}
+    doc = Oj::Doc.open(json)
+    assert_equal(Oj::Doc, doc.class)
+    assert_equal(5, doc.size)
+    assert_equal('/', doc.where?)
+    doc.move('a/1')
+    doc.home()
+    assert_equal(2, doc.fetch('/a/2'))
+    assert_equal(2, doc.fetch('a/2'))
+    doc.close()
+    begin
+      doc.home()
+    rescue Exception => e
+      assert(true)
+    end
+  end
+
+  def test_file_open_close
+    filename = 'open_file_test.json'
+    File.open(filename, 'w') { |f| f.write('{"a":[1,2,3]}') }
+    doc = Oj::Doc.open_file(filename)
+    assert_equal(Oj::Doc, doc.class)
+    assert_equal(5, doc.size)
+    assert_equal('/', doc.where?)
+    doc.move('a/1')
+    doc.home()
+    assert_equal(2, doc.fetch('/a/2'))
+    assert_equal(2, doc.fetch('a/2'))
+    doc.close()
+    begin
+      doc.home()
+    rescue Exception => e
+      assert(true)
+    end
+  end
+
   def test_dump
     Oj::Doc.open('[1,[2,3]]') do |doc|
       assert_equal('[1,[2,3]]', doc.dump())
@@ -328,4 +365,21 @@ class DocTest < ::Test::Unit::TestCase
     assert_equal({'/1' => 1, '/2/1' => 2, '/2/2' => 3}, results)
   end
 
+  def test_comment
+    json = %{{
+  "x"/*one*/:/*two*/true,//three
+  "y":58/*four*/,
+  "z": [1,2/*five*/,
+3 // six
+]
+}
+}
+    results = Oj::Doc.open(json) do |doc|
+      h = {}
+      doc.each_leaf() { |d| h[d.where?] = d.fetch() }
+      h
+    end
+    assert_equal({'/x' => true, '/y' => 58, '/z/1' => 1, '/z/2' => 2, '/z/3' => 3}, results)
+  end
+
 end # DocTest

data/test/test_mimic.rb

@@ -0,0 +1,164 @@
+#!/usr/bin/env ruby -wW1
+# encoding: UTF-8
+
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+require 'test/unit'
+require 'stringio'
+require 'oj'
+
+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 to_json()
+    %{{"json_class":"#{self.class}","x":#{@x},"y":#{@y}}}
+  end
+
+  def self.json_create(h)
+    self.new(h['x'], h['y'])
+  end
+
+end # Jam
+
+class Mimic < ::Test::Unit::TestCase
+
+  def test0_mimic_json
+    assert(defined?(JSON).nil?)
+    Oj.mimic_JSON
+    assert(!defined?(JSON).nil?)
+  end
+
+# dump
+  def test_dump_string
+    json = JSON.dump([1, true, nil])
+    assert_equal(%{[1,true,null]}, json)
+  end
+
+  def test_dump_io
+    s = StringIO.new()
+    json = JSON.dump([1, true, nil], s)
+    assert_equal(s, json)
+    assert_equal(%{[1,true,null]}, s.string)
+  end
+  # TBD options
+
+# 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
+    children = []
+    json = %{{"a":1,"b":[true,false]}}
+    p = Proc.new {|x| children << x }
+    obj = JSON.load(json, p)
+    assert_equal({ 'a' => 1, 'b' => [true, false]}, obj)
+    assert_equal([1, true, false, [true, false], { 'a' => 1, 'b' => [true, false]}], children)
+  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_equal(%{{"a":1,"b":[true,false]}}, 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_equal(%{{#
+--"a"~:*1,#
+--"b"~:*[
+----true,
+----false
+--]#
+}}, json)
+  end
+
+# fast_generate
+  def test_fast_generate
+    json = JSON.generate({ 'a' => 1, 'b' => [true, false]})
+    assert_equal(%{{"a":1,"b":[true,false]}}, json)
+  end
+
+# pretty_generate
+  def test_pretty_generate
+    json = JSON.pretty_generate({ 'a' => 1, 'b' => [true, false]})
+    assert_equal(%{{
+  "a" : 1,
+  "b" : [
+    true,
+    false
+  ]
+}}, json)
+  end
+  # TBD with options
+
+# 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)
+    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' => 'Jam', 'x' => true, 'y' => 58}, 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 = []
+    obj = JSON.recurse_proc({ 'a' => 1, 'b' => [true, false]}) { |x| children << x }
+    assert_equal([1, true, false, [true, false], { 'a' => 1, 'b' => [true, false]}], children)
+  end
+
+end # Mimic

data/test/tests.rb

@@ -129,6 +129,8 @@ class Juice < ::Test::Unit::TestCase
     dump_and_load(12345.6789, false)
     dump_and_load(-54321.012, false)
     dump_and_load(2.48e16, false)
+    dump_and_load(2.48e1000, false)
+    dump_and_load(-2.48e1000, false)
   end
 
   def test_string
@@ -481,7 +483,7 @@ class Juice < ::Test::Unit::TestCase
   end
 
 # Stream IO
-  def test_string_io
+  def test_io_string
     json = %{{
   "x":true,
   "y":58,
@@ -493,6 +495,21 @@ class Juice < ::Test::Unit::TestCase
     assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
   end
 
+  def test_io_file
+    filename = '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.load(f, :mode => :strict)
+    f.close()
+    assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
+  end
+
+# symbol_keys option
   def test_symbol_keys
     json = %{{
   "x":true,
@@ -504,6 +521,42 @@ class Juice < ::Test::Unit::TestCase
     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.load(json, :mode => :strict)
+    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.load(json, :mode => :strict)
+    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.load(json, :mode => :strict)
+    assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
+  end
+
   def dump_and_load(obj, trace=false)
     json = Oj.dump(obj, :indent => 2)
     puts json if trace