oj 2.18.3 → 3.13.14

data/test/perf_dump.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+$: << '.'
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+require 'optparse'
+require 'oj'
+
+$verbose = false
+$indent = 2
+$iter = 100_000
+$size = 2
+
+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("-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
+}
+
+Oj.default_options = { :indent => $indent, :mode => :strict }
+
+if 0 < $size
+  o = $obj
+  $obj = []
+  (4 * $size).times do
+    $obj << o
+  end
+end
+
+$json = Oj.dump($obj)
+GC.start
+start = Time.now
+$iter.times { Oj.dump($obj) }
+duration = Time.now - start
+puts "Dumped #{$json.length} byte JSON #{$iter} times in %0.3f seconds or %0.3f iteration/sec." % [duration, $iter / duration]

data/test/perf_object.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby -wW1
+#!/usr/bin/env ruby
 
 $: << '.'
 $: << '../lib'

data/test/perf_once.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+$: << '.'
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+require 'oj'
+
+filename = 'tmp.json'
+File.open(filename, "w") { |f|
+  cnt = 0
+  f.puts('{')
+  ('a'..'z').each { |a|
+    ('a'..'z').each { |b|
+      ('a'..'z').each { |c|
+	('a'..'z').each { |d|
+	  f.puts(%|"#{a}#{b}#{c}#{d}":#{cnt},|)
+	  cnt += 1
+	}
+      }
+    }
+  }
+  f.puts('"_last":0}')
+}
+
+def mem
+  `ps -o rss= -p #{$$}`.to_i
+end
+
+Oj.default_options = { mode: :strict, cache_keys: false, cache_str: -1 }
+start = Time.now
+Oj.load_file('tmp.json')
+dur = Time.now - start
+GC.start
+puts "no cache duration: #{dur} @ #{mem}"
+
+Oj.default_options = { cache_keys: true }
+start = Time.now
+Oj.load_file('tmp.json')
+dur = Time.now - start
+GC.start
+puts "initial cache duration: #{dur} @ #{mem}"
+
+start = Time.now
+Oj.load_file('tmp.json')
+dur = Time.now - start
+GC.start
+puts "second cache duration: #{dur} @ #{mem}"
+
+10.times{ GC.start }
+start = Time.now
+Oj.load_file('tmp.json')
+dur = Time.now - start
+GC.start
+puts "after several GCs cache duration: #{dur} @ #{mem}"
+
+# TBD check memory use

data/test/perf_parser.rb

@@ -0,0 +1,189 @@
+#!/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: -1, 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 = Oj::Parser.new(:usual)
+p_usual.cache_keys = $cache_keys
+p_usual.cache_strings = ($cache_keys ? 6 : 0)
+p_usual.symbol_keys = $symbol_keys
+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/perf_scp.rb

@@ -14,16 +14,16 @@ require 'oj'
 
 $verbose = false
 $indent = 0
-$iter = 50000
+$iter = 50_000
 $with_bignum = false
-$size = 0
+$size = 1
 
 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("-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)
 
@@ -47,7 +47,7 @@ if 0 < $size
   end
 end
 
-Oj.default_options = { :indent => $indent, :mode => :compat }
+Oj.default_options = { :indent => $indent, :mode => :strict, cache_keys: true, cache_str: 5 }
 
 $json = Oj.dump($obj)
 $failed = {} # key is same as String used in tests later
@@ -105,7 +105,7 @@ class AllHandler < Oj::ScHandler
 
   def hash_set(h, key, value)
   end
-  
+
   def array_append(a, value)
   end
 
@@ -137,10 +137,11 @@ end
 puts '-' * 80
 puts "Parse Performance"
 perf = Perf.new()
-perf.add('Oj::Saj', 'all') { Oj.saj_parse(saj_handler, $json) }
-perf.add('Oj::Saj', 'none') { Oj.saj_parse(no_saj, $json) }
-perf.add('Oj::Scp', 'all') { Oj.sc_parse(sc_handler, $json) }
-perf.add('Oj::Scp', 'none') { Oj.sc_parse(no_handler, $json) }
+perf.add('Oj::Saj.all', 'all') { Oj.saj_parse(saj_handler, $json) }
+perf.add('Oj::Saj.none', 'none') { Oj.saj_parse(no_saj, $json) }
+perf.add('Oj::Scp.all', 'all') { Oj.sc_parse(sc_handler, $json) }
+perf.add('Oj::Scp.none', 'none') { Oj.sc_parse(no_handler, $json) }
+perf.add('Oj::load', 'none') { Oj.wab_load($json) }
 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.run($iter)

data/test/perf_strict.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby -wW1
+#!/usr/bin/env ruby
 # encoding: UTF-8
 
 $: << '.'
@@ -15,6 +15,8 @@ $iter = 20000
 $with_bignum = false
 $with_nums = true
 $size = 0
+$symbolize = false
+$cache_keys = true
 
 opts = OptionParser.new
 opts.on("-v", "verbose")                                    { $verbose = true }
@@ -23,6 +25,8 @@ 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("-n", "without numbers")                            { $with_nums = false }
+opts.on("-z", "--symbolize", "symbolize keys")              { $symbolize = true }
+opts.on("-k", "--no-cache", "turn off key caching")         { $cache_keys = false }
 opts.on("-h", "--help", "Show this display")                { puts opts; Process.exit!(0) }
 files = opts.parse(ARGV)
 
@@ -51,7 +55,7 @@ else
   }
 end
 
-Oj.default_options = { :indent => $indent, :mode => :strict }
+Oj.default_options = { :indent => $indent, :mode => :strict, cache_keys: $cache_keys, cache_str: 5 }
 
 if 0 < $size
   o = $obj
@@ -62,9 +66,6 @@ if 0 < $size
 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)
@@ -77,8 +78,13 @@ def capture_error(tag, orig, load_key, dump_key, &blk)
 end
 
 # Verify that all packages dump and load correctly and return the same Object as the original.
-capture_error('Oj:strict', $obj, 'load', 'dump') { |o| Oj.strict_load(Oj.dump(o, :mode => :strict)) }
-capture_error('Yajl', $obj, 'encode', 'parse') { |o| require 'yajl'; Yajl::Parser.parse(Yajl::Encoder.encode(o)) }
+capture_error('Oj:strict', $obj, 'load', 'dump') { |o|
+  Oj.strict_load(Oj.dump(o))
+}
+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'
@@ -86,16 +92,11 @@ capture_error('JSON::Ext', $obj, 'generate', 'parse') { |o|
   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))
-}
+
+Oj.default_options = { symbol_keys: $symbolize }
 
 if $verbose
   puts "json:\n#{$json}\n"
-  puts "object json:\n#{$obj_json}\n"
   puts "Oj loaded object:\n#{Oj.strict_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"
@@ -105,19 +106,29 @@ puts '-' * 80
 puts "Strict Parse Performance"
 perf = Perf.new()
 unless $failed.has_key?('JSON::Ext')
-  perf.add('JSON::Ext', 'parse') { JSON.parse($json) }
+  perf.add('JSON::Ext', 'parse') { JSON.parse($json, symbolize_names: $symbolize) }
   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:strict')
   perf.add('Oj:strict', 'strict_load') { Oj.strict_load($json) }
+  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 "Strict 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?('Oj:strict')
+  perf.add('Oj:strict', 'dump') { Oj.dump($obj) }
+end
+perf.add('Yajl', 'encode') { Yajl::Encoder.encode($obj) } unless $failed.has_key?('Yajl')
+perf.run($iter)
+
 puts
 puts '-' * 80
 puts

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/prec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'oj'
+
+extras = {"locationLng" => -97.14690769100295}
+
+Oj.default_options = {float_precision: 17}
+
+encoded = Oj.dump(extras)
+puts encoded
+puts Oj.load(encoded)
+
+require "active_record"
+
+Oj::Rails.set_encoder()
+Oj::Rails.set_decoder()
+
+Oj.default_options = {float_precision: 17}
+# Using Oj rails encoder, gets the correct value: {"locationLng":-97.14690769100295}
+encoded = ActiveSupport::JSON.encode(extras)
+puts encoded
+puts ActiveSupport::JSON.decode(encoded)
+puts Oj.load(encoded)

data/test/sample.rb

@@ -10,7 +10,6 @@ end
 require 'pp'
 require 'sample/doc'
 
-
 def sample_doc(size=3)
   colors = [ :black, :gray, :white, :red, :blue, :yellow, :green, :purple, :orange ]
 

data/test/sample_json.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby -wW2
+#!/usr/bin/env ruby
 
 if $0 == __FILE__
   $: << '.'