oj 2.17.3 → 2.17.4

data/README.md

@@ -170,15 +170,10 @@ Oj.default_options = {:mode => :compat }
 
 ## Releases
 
-**Release 2.17.3**
+**Release 2.17.4**
 
-- Updated mimic_JSON to monkey patch OpenStruct, Range, Rational, Regexp, Struct, Symbol,
-  and Time like the JSON gem does. Also added the JSON.create_id accessor.
-
-**Release 2.17.2**
-
- - Worked around a problem with DateTime and ActiveSupport that causes a hang
-   when hour, minute, second, and some other methods are called from C.
+- Added the ascii_only option to JSON.generate when in mimic_JSON mode so that
+  it is consistent with the undocumented feature in the json gem.
 
 [Older release notes](http://www.ohler.com/dev/oj_misc/release_notes.html).
 

data/ext/oj/oj.c

@@ -1760,6 +1760,14 @@ mimic_generate_core(int argc, VALUE *argv, Options copts) {
 	    copts->dump_opts.array_size = (uint8_t)len;
 	    copts->dump_opts.use = true;
 	}
+	if (Qnil != (v = rb_hash_lookup(ropts, ascii_only_sym))) {
+	    // generate seems to assume anything except nil and false are true.
+	    if (Qfalse == v || Qnil == v) {
+		copts->escape_mode = JSONEsc;
+	    } else {
+		copts->escape_mode = ASCIIEsc;
+	    }
+	}
 	// :allow_nan is not supported as Oj always allows_nan
 	// :max_nesting is always set to 100
     }
@@ -2379,6 +2387,9 @@ void Init_oj() {
  * @param [String] :space_before String placed before a : delimiter
  * @param [String] :object_nl String placed after a JSON object
  * @param [String] :array_nl String placed after a JSON array
+ * @param [true|false] :ascii_only if not nil or false then use only ascii
+ *                      characters in the output. Note JSON.generate does
+ *                      support this even if it is not documented.
  */
 /* Document-method: fast_generate
  *   call-seq: fast_generate(obj, opts=nil) -> String

data/lib/oj/mimic.rb

@@ -7,6 +7,28 @@ end
 
 module Oj
 
+  # A bit hack-ish but does the trick. The JSON.dump_default_options is a Hash
+  # but in mimic we use a C struct to store defaults. This class creates a view
+  # onto that struct.
+  class MimicDumpOption < Hash
+    def initialize()
+      oo = Oj.default_options
+      self.store(:max_nesting, false)
+      self.store(:allow_nan, true)
+      self.store(:quirks_mode, oo[:quirks_mode])
+      self.store(:ascii_only, (:ascii == oo[:escape_mode]))
+    end
+
+    def []=(key, value)
+      case key
+      when :quirks_mode
+        Oj.default_options = {:quirks_mode => value}
+      when :ascii_only
+        Oj.default_options = {:ascii_only => value}
+      end
+    end
+  end
+
   def self.mimic_loaded(mimic_paths=[])
     $LOAD_PATH.each do |d|
       next unless File.exist?(d)
@@ -122,5 +144,19 @@ module Oj
       end
     end
 
-  end
-end
+    JSON.module_eval do
+      def self.dump_default_options
+        Oj::MimicDumpOption.new
+      end
+
+      def self.dump_default_options=(h)
+        m = Oj::MimicDumpOption.new
+        h.each do |k,v|
+          m[k] = v
+        end
+      end
+    end
+
+  end # self.mimic_loaded
+
+end # Oj

data/lib/oj/version.rb

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

data/test/aaa.rb

@@ -0,0 +1,21 @@
+#!/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 'json'
+require 'oj'
+Oj.mimic_JSON
+
+JSON.dump_default_options[:ascii_only]=true
+puts JSON.dump_default_options
+
+puts JSON.dump(["a😬sdf"])
+
+JSON.dump_default_options = {:ascii_only=>false}
+
+puts JSON.dump_default_options

data/test/bug.rb

@@ -5,47 +5,60 @@ $: << File.dirname(__FILE__)
 
 require 'helper'
 
-class Handler
-  def initialize
-    @state = []
-  end
+require 'oj'
+require 'securerandom'
 
-  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
+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)
   end
+end
 
+json = Oj.dump({"this"=>"object"})
 
-  def array_end
-    @state.pop
-  end
-
-  def array_append(a,v)
-    a << v
+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
   end
-
-  def add_value(v)
-    p v
+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
   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/pact.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+$: << File.dirname(__FILE__)
+['ext', 'lib'].each do |dir|
+  $: << File.join(File.dirname(File.expand_path(File.dirname(__FILE__))), dir)
+end
+
+#require 'json'
+require 'oj'
+
+Oj.mimic_JSON()
+require 'pact'
+
+puts "*** responds? #{Regexp.respond_to?(:json_create)}"
+
+j = /1/.to_json
+
+puts "json: #{j}"
+
+puts "regexp: #{JSON.load(j)}"

data/test/perf1.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby -wW1
+# encoding: UTF-8
+
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+#require 'test/unit'
+require 'optparse'
+require 'oj'
+require 'ox'
+
+$indent = 2
+
+opts = OptionParser.new
+opts.on("-h", "--help", "Show this display")                { puts opts; Process.exit!(0) }
+files = opts.parse(ARGV)
+
+iter = 100000
+s = %{
+{ "class": "Foo::Bar",
+  "attr1": [ true, [false, [12345, null], 3.967, ["something", false], null]],
+  "attr2": { "one": 1 }
+}
+}
+#s = File.read('sample.json')
+
+Oj.default_options = { :indent => 0 }
+
+obj = Oj.load(s)
+xml = Ox.dump(obj, :indent => 0)
+
+puts xml
+
+start = Time.now
+iter.times do
+  Oj.load(s)
+end
+dt = Time.now - start
+puts "%d Oj.load()s in %0.3f seconds or %0.1f loads/msec" % [iter, dt, iter/dt/1000.0]
+
+start = Time.now
+iter.times do
+  Ox.load(xml)
+end
+dt = Time.now - start
+puts "%d Ox.load()s in %0.3f seconds or %0.1f loads/msec" % [iter, dt, iter/dt/1000.0]
+
+puts
+
+start = Time.now
+iter.times do
+  Oj.dump(obj)
+end
+dt = Time.now - start
+puts "%d Oj.dump()s in %0.3f seconds or %0.1f dumps/msec" % [iter, dt, iter/dt/1000.0]
+
+start = Time.now
+iter.times do
+  Ox.dump(obj)
+end
+dt = Time.now - start
+puts "%d Ox.dump()s in %0.3f seconds or %0.1f dumps/msec" % [iter, dt, iter/dt/1000.0]
+
+puts

data/test/perf2.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby -wW1
+# encoding: UTF-8
+
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+#require 'test/unit'
+require 'optparse'
+require 'yajl'
+require 'oj'
+
+$indent = 2
+
+opts = OptionParser.new
+opts.on("-h", "--help", "Show this display")                { puts opts; Process.exit!(0) }
+files = opts.parse(ARGV)
+
+class Foo
+  def initialize()
+    @x = true
+    @y = 58
+  end
+  def to_json()
+    %{{"x":#{@x},"y":#{@y}}}
+  end
+  def to_hash()
+    { 'x' => @x, 'y' => @y }
+  end
+end
+
+iter = 100000
+s = %{
+{ "class": "Foo::Bar",
+  "attr1": [ true, [false, [12345, null], 3.967, ["something", false], null]],
+  "attr2": { "one": 1 }
+}
+}
+
+obj = Oj.load(s)
+obj["foo"] = Foo.new()
+
+Oj.default_options = { :indent => 0, :effort => :internal }
+
+puts
+
+start = Time.now
+iter.times do
+  Oj.load(s)
+end
+dt = Time.now - start
+puts "%d Oj.load()s in %0.3f seconds or %0.1f loads/msec" % [iter, dt, iter/dt/1000.0]
+
+start = Time.now
+iter.times do
+  Yajl::Parser.parse(s)
+end
+dt = Time.now - start
+puts "%d Yajl::Parser.parse()s in %0.3f seconds or %0.1f parses/msec" % [iter, dt, iter/dt/1000.0]
+
+puts
+
+start = Time.now
+iter.times do
+  Oj.dump(obj)
+end
+dt = Time.now - start
+puts "%d Oj.dump()s in %0.3f seconds or %0.1f dumps/msec" % [iter, dt, iter/dt/1000.0]
+
+start = Time.now
+iter.times do
+  Yajl::Encoder.encode(obj)
+end
+dt = Time.now - start
+puts "%d Yajl::Encoder.encode()s in %0.3f seconds or %0.1f encodes/msec" % [iter, dt, iter/dt/1000.0]
+
+puts

data/test/perf_obj_old.rb

@@ -0,0 +1,213 @@
+#!/usr/bin/env ruby -wW1
+
+$: << '.'
+$: << '..'
+$: << '../lib'
+$: << '../ext'
+
+if __FILE__ == $0
+  if (i = ARGV.index('-I'))
+    x,path = ARGV.slice!(i, 2)
+    $: << path
+  end
+end
+
+require 'optparse'
+require 'ox'
+require 'oj'
+require 'perf'
+require 'sample'
+require 'files'
+
+$verbose = 0
+$circular = false
+$indent = 0
+
+do_sample = false
+do_files = false
+
+do_load = false
+do_dump = false
+do_read = false
+do_write = false
+$iter = 1000
+
+opts = OptionParser.new
+opts.on("-v", "increase verbosity")                         { $verbose += 1 }
+
+opts.on("-c", "circular options")                           { $circular = true }
+
+opts.on("-s", "load and dump as sample Ruby object")        { do_sample = true }
+opts.on("-f", "load and dump as files Ruby object")         { do_files = true }
+
+opts.on("-l", "load")                                       { do_load = true }
+opts.on("-d", "dump")                                       { do_dump = true }
+opts.on("-r", "read")                                       { do_read = true }
+opts.on("-w", "write")                                      { do_write = true }
+opts.on("-a", "load, dump, read and write")                 { do_load = true; do_dump = true; do_read = true; do_write = true }
+
+opts.on("-i", "--iterations [Int]", Integer, "iterations")  { |i| $iter = i }
+
+opts.on("-h", "--help", "Show this display")                { puts opts; Process.exit!(0) }
+files = opts.parse(ARGV)
+
+if files.empty?
+  data = []
+  obj = do_sample ? sample_doc(2) : files('..')
+  mars = Marshal.dump(obj)
+  xml = Ox.dump(obj, :indent => $indent, circular: $circular)
+  json = Oj.dump(obj, :indent => $indent, circular: $circular)
+  File.open('sample.xml', 'w') { |f| f.write(xml) }
+  File.open('sample.json', 'w') { |f| f.write(json) }
+  File.open('sample.marshal', 'w') { |f| f.write(mars) }
+  data << { :file => 'sample.xml', :obj => obj, :xml => xml, :marshal => mars, :json => json }
+else
+  puts "loading and parsing #{files}\n\n"
+  # TBD change to allow xml and json
+  data = files.map do |f|
+    xml = File.read(f)
+    obj = Ox.load(xml);
+    mars = Marshal.dump(obj)
+    json = Oj.dump(obj, :indent => $indent, circular: $circular)
+    { :file => f, :obj => obj, :xml => xml, :marshal => mars, :json => json }
+  end
+end
+
+$ox_load_time = 0
+$mars_load_time = 0
+$ox_dump_time = 0
+$oj_dump_time = 0
+$mars_dump_time = 0
+
+def perf_load(d)
+  filename = d[:file]
+  marshal_filename = 'sample.marshal'
+  xml = d[:xml]
+  mars = d[:marshal]
+  json = d[:json]
+
+  if 0 < $verbose
+    obj = Ox.load(xml, :mode => :object, :trace => $verbose)
+    return
+  end
+  start = Time.now
+  (1..$iter).each do
+    obj = Ox.load(xml, :mode => :object)
+  end
+  $ox_load_time = Time.now - start
+  puts "Parsing #{$iter} times with Ox took #{$ox_load_time} seconds."
+
+  start = Time.now
+  (1..$iter).each do
+    obj = Oj.load(json, :mode => :object)
+  end
+  $oj_load_time = Time.now - start
+  puts "Parsing #{$iter} times with Oj took #{$oj_load_time} seconds."
+  
+  start = Time.now
+  (1..$iter).each do
+    obj = Marshal.load(mars)
+  end
+  $mars_load_time = Time.now - start
+  puts "Marshalling #{$iter} times took #{$mars_load_time} seconds."
+  puts ">>> Ox is %0.1f faster than Marshal loading.\n\n" % [$mars_load_time/$ox_load_time]
+end
+
+def perf_dump(d)
+  obj = d[:obj]
+
+  start = Time.now
+  (1..$iter).each do
+    xml = Ox.dump(obj, :indent => $indent, :circular => $circular)
+    #puts "*** ox:\n#{xml}"
+  end
+  $ox_dump_time = Time.now - start
+  puts "Ox dumping #{$iter} times with ox took #{$ox_dump_time} seconds."
+
+  Oj.default_options = {:indent => $indent}
+  start = Time.now
+  (1..$iter).each do
+    json = Oj.dump(obj)
+  end
+  $oj_dump_time = Time.now - start
+  puts "Oj dumping #{$iter} times with oj took #{$oj_dump_time} seconds."
+
+  obj = d[:obj]
+  start = Time.now
+  (1..$iter).each do
+    m = Marshal.dump(obj)
+  end
+  $mars_dump_time = Time.now - start
+  puts "Marshal dumping #{$iter} times took #{$mars_dump_time} seconds."
+  puts ">>> Ox is %0.1f faster than Marshal dumping.\n\n" % [$mars_dump_time/$ox_dump_time]
+end
+
+def perf_read(d)
+  ox_read_time = 0
+  mars_read_time = 0
+
+  filename = d[:file]
+  marshal_filename = 'sample.marshal'
+  xml = d[:xml]
+  mars = d[:marshal]
+
+  # now load from the file
+  start = Time.now
+  (1..$iter).each do
+    obj = Ox.load_file(filename, :mode => :object)
+  end
+  ox_read_time = Time.now - start
+  puts "Loading and parsing #{$iter} times with ox took #{ox_read_time} seconds."
+
+  start = Time.now
+  (1..$iter).each do
+    m = File.read(marshal_filename)
+    obj = Marshal.load(m)
+  end
+  mars_read_time = Time.now - start
+  puts "Reading and marshalling #{$iter} times took #{mars_read_time} seconds."
+  puts ">>> Ox is %0.1f faster than Marshal loading and parsing.\n\n" % [mars_read_time/ox_read_time]
+
+end
+
+def perf_write(d)
+  ox_write_time = 0
+  mars_write_time = 0
+  
+  ox_filename = 'out.xml'
+  marshal_filename = 'out.marshal'
+  obj = d[:obj]
+
+  start = Time.now
+  (1..$iter).each do
+    xml = Ox.to_file(ox_filename, obj, :indent => $indent)
+  end
+  ox_write_time = Time.now - start
+  puts "Ox dumping #{$iter} times with ox took #{ox_write_time} seconds."
+
+  start = Time.now
+  (1..$iter).each do
+    m = Marshal.dump(obj, circular: $circular)
+    File.open(marshal_filename, "w") { |f| f.write(m) }
+  end
+  mars_write_time = Time.now - start
+  puts "Marshal dumping and writing #{$iter} times took #{mars_write_time} seconds."
+  puts ">>> Ox is %0.1f faster than Marshal dumping.\n\n" % [mars_write_time/ox_write_time]
+
+end
+
+#if do_sample or do_files
+  data.each do |d|
+    puts "Using file #{d[:file]}."
+    
+    perf_load(d) if do_load
+    perf_dump(d) if do_dump
+    if do_load and do_dump
+      puts ">>> Ox is %0.1f faster than Marshal dumping and loading.\n\n" % [($mars_load_time + $mars_dump_time)/($ox_load_time + $ox_dump_time)] unless 0 == $mars_load_time
+    end
+
+    perf_read(d) if do_read
+    perf_write(d) if do_write
+
+  end
+#end