oj 2.10.4 → 2.11.0

data/test/bug.rb

@@ -1,3 +1,5 @@
+#!/usr/bin/env ruby
+
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
@@ -5,60 +7,47 @@ $: << File.dirname(__FILE__)
 
 require 'helper'
 
-require 'oj'
-require 'securerandom'
-
 class Handler
-  def hash_start()      {} end
-  def hash_set(h,k,v)   h.store(k,v) end
-  def array_start()     [] end
-  def array_append(a,v) a << v end
-  def error(message, line, column)
-    raise Exception.new(message, line, column)
+  def initialize
+    @state = []
+  end
+
+  def hash_start
+    @state << {}
+    @state.last
+  end
+
+  def hash_end
+    @state.pop
+  end
+
+  def hash_set(h,k,v)
+    h.store(k,v)
   end
-end
 
-json = Oj.dump({"this"=>"object"})
-
-if true
-  name = "/tmp/#{SecureRandom.uuid}"
-  `mkfifo #{name}`
-  if fork
-    open(name, 'r+') do |read_io|
-      p "start reading #{read_io.stat.ftype}"
-      Oj.sc_parse(Handler.new, read_io) {|v| p v}
-      p "stop reading"
-    end
-  else
-    open(name, 'w+') do |write_io|
-      p "start writing #{write_io.stat.ftype}  autoclose: #{write_io.autoclose?}"
-      write_io.write json
-      write_io.write json
-      p "stop writing"
-    end
-    sleep(1) # make it obvious that there are two threads
-    open(name, 'w+') do |write_io|
-      p "start writing #{write_io.stat.ftype}"
-      write_io.write json
-      write_io.write json
-      p "stop writing"
-    end
+  def array_start
+    @state << []
+    @state.last
   end
-else
-  IO.pipe do |read_io, write_io|
-    if fork
-      write_io.close
-      p "start reading #{read_io.stat.ftype}"
-      Oj.sc_parse(Handler.new, read_io) {|v| p v}
-      p "stop reading"
-      read_io.close
-    else
-      read_io.close
-      p "start writing #{write_io.stat.ftype}"
-      write_io.write json
-      write_io.write json
-      p "stop writing"
-      write_io.close
-    end
+
+
+  def array_end
+    @state.pop
+  end
+
+  def array_append(a,v)
+    a << v
+  end
+
+  def add_value(v)
+    p v
   end
+
+  def error(message, line, column); p "ERROR: #{message}" end
 end
+
+$handler = Handler.new
+
+IO.popen("cat tst") { |p| puts Oj.sc_parse($handler, p) }
+
+#File.open('tst', 'r') { |file|  Oj.sc_parse($handler, file) }

data/test/bug2.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+$: << File.dirname(__FILE__)
+
+require 'helper'
+
+

data/test/io.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+$: << File.dirname(__FILE__)
+
+require 'helper'
+
+class Handler
+  def initialize
+    @state = []
+  end
+
+  def hash_start
+    @state << {}
+    @state.last
+  end
+
+  def hash_end
+    @state.pop
+  end
+
+  def hash_set(h,k,v)
+    h.store(k,v)
+  end
+
+  def array_start
+    @state << []
+    @state.last
+  end
+
+
+  def array_end
+    @state.pop
+  end
+
+  def array_append(a,v)
+    a << v
+  end
+
+  def error(message, line, column); p "ERROR: #{message}" end
+end
+
+handler = Handler.new
+def handler.add_value(v)
+  p v
+end
+
+Oj.sc_parse(handler, StringIO.new('{"a":"b","c":[1,2,{"d":"e"}]}[4,5,6]'))

data/test/{test_range.rb → mod.rb}

@@ -1,19 +1,16 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-$VERBOSE = true
-
 %w(lib ext test).each do |dir|
   $LOAD_PATH.unshift File.expand_path("../../#{dir}", __FILE__)
 end
 
-require 'rubygems' if RUBY_VERSION.start_with?('1.8.')
 require 'oj'
 
-Oj.mimic_JSON
-
-#puts Oj.default_options
-
-range = ("01".."12")
 
-puts Oj.dump(range)
+Thread.new do
+  string_io = StringIO.new('{"foo":"bar"}')
+  Oj.load(string_io)
+  string_io.rewind
+  puts string_io.read
+end.join

data/test/struct.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+# 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
+
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+require 'oj'
+
+A = Struct.new(:a,:b,:c,:d)
+B = Struct.new(:e,:f)
+
+obj = [A.new(55, B.new(1, 'X'), B.new(2, 'Y'), 3)]
+
+s = Oj.dump(obj, :mode => :object)
+
+100000.times do
+  Oj.load(s, :mode => :object)
+  # ds = Oj.dump(o, :mode => :object)
+  # if ds != s
+  #   puts ds
+  #   raise "holy crap"
+  # end
+end

data/test/test_serializer.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+$: << File.dirname(__FILE__)
+
+%w(lib ext test).each do |dir|
+  $LOAD_PATH.unshift File.expand_path("../../#{dir}", __FILE__)
+end
+
+require 'minitest'
+require 'minitest/autorun'
+require 'oj'
+
+Oj.mimic_JSON
+
+require 'rails/all'
+require 'active_model'
+require 'active_model_serializers'
+require 'active_support/json'
+
+#Oj.mimic_JSON
+
+class Category
+  include ActiveModel::Model
+  include ActiveModel::SerializerSupport
+
+  attr_accessor :id, :name
+
+  def initialize(id, name)
+    @id   = id
+    @name = name
+  end
+end
+
+class CategorySerializer < ActiveModel::Serializer
+  attributes :id, :name
+end
+
+class MimicRails < Minitest::Test
+
+  def test_dump_object
+    Oj.default_options= {:indent => 0}
+    category = Category.new(1, 'test')
+    serializer = CategorySerializer.new(category)
+
+    json = serializer.to_json()
+    puts "*** serializer.to_json() #{serializer.to_json()}"
+    assert_equal(%|{"category":{"id":1,"name":"test"}}|, json)
+
+    json = serializer.as_json()
+    puts "*** serializer.as_json() #{serializer.as_json()}"
+    assert_equal({"category" => {:id => 1, :name => "test"}}, json)
+
+    json = JSON.dump(serializer)
+    puts "*** JSON.dump(serializer) #{JSON.dump(serializer)}"
+    assert_equal(%|{"category":{"id":1,"name":"test"}}|, json)
+  end
+
+end # MimicRails

data/test/test_various.rb

@@ -7,6 +7,9 @@ require 'helper'
 
 class Juice < Minitest::Test
 
+  module TestModule
+  end
+
   class Jam
     attr_accessor :x, :y
 
@@ -87,57 +90,67 @@ class Juice < Minitest::Test
     Oj.default_options = @default_options
   end
 
-  def test0_get_options
+=begin
+  # Depending on the order the values may have changed. The set_options sets
+  # should cover the function itself.
+  def test_get_options
     opts = Oj.default_options()
     assert_equal({ :indent=>0,
                    :second_precision=>9,
                    :circular=>false,
+                   :class_cache=>true,
                    :auto_define=>false,
                    :symbol_keys=>false,
-                   :class_cache=>true,
-                   :escape_mode=>:json,
-                   :mode=>:object,
-                   :time_format=>:unix,
                    :bigdecimal_as_decimal=>true,
-                   :bigdecimal_load=>:auto,
-                   :use_to_json=>false,
+                   :use_to_json=>true,
                    :nilnil=>false,
                    :allow_gc=>true,
+                   :quirks_mode=>true,
+                   :float_precision=>15,
+                   :mode=>:object,
+                   :escape_mode=>:json,
+                   :time_format=>:unix,
+                   :bigdecimal_load=>:auto,
                    :create_id=>'json_class'}, opts)
   end
+=end
 
-  def test0_set_options
-    orig = {
+  def test_set_options
+    orig ={
       :indent=>0,
       :second_precision=>9,
       :circular=>false,
+      :class_cache=>true,
       :auto_define=>false,
       :symbol_keys=>false,
-      :class_cache=>true,
-      :escape_mode=>:ascii,
-      :mode=>:object,
-      :time_format=>:unix,
       :bigdecimal_as_decimal=>true,
-      :bigdecimal_load=>:auto,
       :use_to_json=>true,
       :nilnil=>false,
       :allow_gc=>true,
+      :quirks_mode=>true,
+      :float_precision=>15,
+      :mode=>:object,
+      :escape_mode=>:json,
+      :time_format=>:unix,
+      :bigdecimal_load=>:auto,
       :create_id=>'json_class'}
     o2 = {
       :indent=>4,
       :second_precision=>7,
       :circular=>true,
+      :class_cache=>false,
       :auto_define=>true,
       :symbol_keys=>true,
-      :class_cache=>false,
-      :escape_mode=>:json,
-      :mode=>:compat,
-      :time_format=>:ruby,
       :bigdecimal_as_decimal=>false,
-      :bigdecimal_load=>:bigdecimal,
       :use_to_json=>false,
       :nilnil=>true,
       :allow_gc=>false,
+      :quirks_mode=>true,
+      :float_precision=>15,
+      :mode=>:compat,
+      :escape_mode=>:json,
+      :time_format=>:ruby,
+      :bigdecimal_load=>:bigdecimal,
       :create_id=>nil}
     o3 = { :indent => 4 }
     Oj.default_options = o2
@@ -166,6 +179,33 @@ class Juice < Minitest::Test
     dump_and_load(1, false)
   end
 
+  def test_float_dump
+    Oj.default_options = { :float_precision => 16 }
+    assert_equal('1405460727.723866', Oj.dump(1405460727.723866))
+    Oj.default_options = { :float_precision => 5 }
+    assert_equal('1.4055', Oj.dump(1.405460727))
+    Oj.default_options = { :float_precision => 0 }
+    if RUBY_VERSION.start_with?('1.8')
+      assert_equal('1405460727.72387', Oj.dump(1405460727.723866))
+    else
+      assert_equal('1405460727.723866', Oj.dump(1405460727.723866))
+    end
+    Oj.default_options = { :float_precision => 15 }
+    assert_equal('0.56', Oj.dump(0.56))
+    assert_equal('0.5773', Oj.dump(0.5773))
+    assert_equal('0.6768', Oj.dump(0.6768))
+    assert_equal('0.685', Oj.dump(0.685))
+    assert_equal('0.7032', Oj.dump(0.7032))
+    assert_equal('0.7051', Oj.dump(0.7051))
+    assert_equal('0.8274', Oj.dump(0.8274))
+    assert_equal('0.9149', Oj.dump(0.9149))
+    assert_equal('64.4', Oj.dump(64.4))
+    assert_equal('71.6', Oj.dump(71.6))
+    assert_equal('73.4', Oj.dump(73.4))
+    assert_equal('80.6', Oj.dump(80.6))
+    assert_equal('-95.640172', Oj.dump(-95.640172))
+  end
+
   def test_float
     mode = Oj.default_options()[:mode]
     Oj.default_options = {:mode => :object}
@@ -486,6 +526,29 @@ class Juice < Minitest::Test
     dump_and_load(Juice, false)
   end
 
+  # Module
+  def test_module_strict
+    begin
+      Oj.dump(TestModule, :mode => :strict)
+    rescue Exception
+      assert(true)
+      return
+    end
+    assert(false, "*** expected an exception")
+  end
+  def test_module_null
+    json = Oj.dump(TestModule, :mode => :null)
+    assert_equal('null', json)
+  end
+  def test_module_compat
+    json = Oj.dump(TestModule, :mode => :compat)
+    assert_equal(%{"Juice::TestModule"}, json)
+  end
+  def test_module_object
+    Oj.default_options = { :mode => :object }
+    dump_and_load(TestModule, false)
+  end
+
   # Hash
   def test_hash
     Oj.default_options = { :mode => :strict }
@@ -880,7 +943,7 @@ class Juice < Minitest::Test
     BigDecimal.send(:define_method, :as_json) do
       %{this is big}
     end
-    json = Oj.dump(orig, :mode => :compat)
+    json = Oj.dump(orig, :mode => :compat, :bigdecimal_as_decimal => false)
     bg = Oj.load(json, :mode => :compat)
     assert_equal("this is big", bg)
     BigDecimal.send(:remove_method, :as_json) # cleanup