oj 3.15.1 → 3.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 257582096951b3c4db4b4979c49afd542ae855ba454bd6d51dcb1a69f68c2405
-  data.tar.gz: d835a958d019f7034e93d3f97ca1829fad74a4e26743f6a8b2b581c03ac9f14a
+  metadata.gz: affe42de16d26dfe301f38df7c0bc8ceee39ab25e5a6bd14bd7af6671cc3b422
+  data.tar.gz: ee1d7227f864b197aca62cb767f9202798b6d3d13cf0b5f89eae3f3a36450dbb
 SHA512:
-  metadata.gz: 374e55547de2db4b2199c05bebe5fa74953021883f7f609e328466c076016817b0cb8a7be03ead9c68b3fe4895eb5de0bcd60e1384ff7f1a5f7cd480824faba0
-  data.tar.gz: ec9cf41116602a51c49ff73ba6fc39ecbb501d51cbab0a6065bb38d2ac15a7f42332dc66f0d97df40bea6da5fafbc15209d06039180829c4c4b299b0e138676e
+  metadata.gz: 8dbf6a0b5fef2b179dba864b595113f73ac27a952307559422bf1feda19fcc008a5e43a142d1bb3eb0cc4125ff18f35730208c7f82b11089ff90690e7b1f17d0
+  data.tar.gz: be09c04fa551288e2708c9151d0c966a09c3768ba15442cc54b8b4dd5850e2228b45608c06c8251c4e2ca32333353713f9c1feff81e4d34a48d1c6bf725014f6

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # CHANGELOG
 
+## 3.16.0 - 2023-08-16
+
+- Added the `float_format` option.
+
+- Expanded the `max_nesting` option to allow integer values as well as
+  the previous boolean (true or nil).
+
+- Skip nesting tests with Truffle Ruby in the json gem tests.
+
 ## 3.15.1 - 2023-07-30
 
 - Add protection against some using `require 'oj/json`, an internal file.

data/ext/oj/dump_compat.c

@@ -851,13 +851,18 @@ static DumpFunc compat_funcs[] = {
 };
 
 static void set_state_depth(VALUE state, int depth) {
-    VALUE json_module = rb_const_get_at(rb_cObject, rb_intern("JSON"));
-    VALUE ext         = rb_const_get(json_module, rb_intern("Ext"));
-    VALUE generator   = rb_const_get(ext, rb_intern("Generator"));
-    VALUE state_class = rb_const_get(generator, rb_intern("State"));
+    if (0 == rb_const_defined(rb_cObject, rb_intern("JSON"))) {
+        rb_require("oj/json");
+    }
+    {
+        VALUE json_module = rb_const_get_at(rb_cObject, rb_intern("JSON"));
+        VALUE ext         = rb_const_get(json_module, rb_intern("Ext"));
+        VALUE generator   = rb_const_get(ext, rb_intern("Generator"));
+        VALUE state_class = rb_const_get(generator, rb_intern("State"));
 
-    if (state_class == rb_obj_class(state)) {
-        rb_funcall(state, rb_intern("depth="), 1, INT2NUM(depth));
+        if (state_class == rb_obj_class(state)) {
+            rb_funcall(state, rb_intern("depth="), 1, INT2NUM(depth));
+        }
     }
 }
 
@@ -865,20 +870,15 @@ void oj_dump_compat_val(VALUE obj, int depth, Out out, bool as_ok) {
     int type = rb_type(obj);
 
     TRACE(out->opts->trace, "dump", obj, depth, TraceIn);
+    // The max_nesting logic is that an empty Array or Hash is assumed to have
+    // content so the max_nesting should fail but a non-collection value is
+    // okay. That means a check for a collectable value is needed before
+    // raising.
     if (out->opts->dump_opts.max_depth <= depth) {
-        // When JSON.dump is called then an ArgumentError is expected and the
-        // limit is the depth inclusive. If JSON.generate is called then a
-        // NestingError is expected and the limit is inclusive. Worse than
-        // that there are unit tests for both.
-        if (CALLER_DUMP == out->caller) {
+        if (RUBY_T_ARRAY == type || RUBY_T_HASH == type) {
             if (0 < out->argc) {
                 set_state_depth(*out->argv, depth);
             }
-            rb_raise(rb_eArgError, "Too deeply nested.");
-        } else if (out->opts->dump_opts.max_depth < depth) {
-            if (0 < out->argc) {
-                set_state_depth(*out->argv, depth - 1);
-            }
             raise_json_err("Too deeply nested", "NestingError");
         }
     }

data/ext/oj/mimic_json.c

@@ -209,7 +209,6 @@ static VALUE mimic_dump(int argc, VALUE *argv, VALUE self) {
 
     oj_out_init(&out);
 
-    out.caller        = CALLER_DUMP;
     copts.escape_mode = JXEsc;
     copts.mode        = CompatMode;
 
@@ -368,7 +367,6 @@ static VALUE mimic_generate_core(int argc, VALUE *argv, Options copts) {
     oj_out_init(&out);
 
     out.omit_nil = copts->dump_opts.omit_nil;
-    out.caller   = CALLER_GENERATE;
     // For obj.to_json or generate nan is not allowed but if called from dump
     // it is.
     copts->dump_opts.nan_dump = RaiseNan;

data/ext/oj/oj.c

@@ -123,6 +123,7 @@ static VALUE escape_mode_sym;
 static VALUE integer_range_sym;
 static VALUE fast_sym;
 static VALUE float_prec_sym;
+static VALUE float_format_sym;
 static VALUE float_sym;
 static VALUE huge_sym;
 static VALUE ignore_sym;
@@ -232,7 +233,7 @@ struct _options oj_default_options = {
         NULL,    // tail
         {'\0'},  // err
     },
-    NULL,        // ignore
+    NULL,
 };
 
 /* Document-method: default_options()
@@ -267,6 +268,8 @@ struct _options oj_default_options = {
  *seconds portion of time
  * - *:float_precision* [_Fixnum_|_nil_] number of digits of precision when dumping floats, 0
  *indicates use Ruby
+ * - *:float_format* [_String_] the C printf format string for printing floats. Default follows
+ * the float_precision and will be changed if float_precision is changed. The string can be no more than 6 bytes.
  * - *:use_to_json* [_Boolean_|_nil_] call to_json() methods on dump, default is false
  * - *:use_as_json* [_Boolean_|_nil_] call as_json() methods on dump, default is false
  * - *:use_raw_json* [_Boolean_|_nil_] call raw_json() methods on dump, default is false
@@ -378,6 +381,7 @@ static VALUE get_def_opts(VALUE self) {
                  oj_safe_sym,
                  (Yes == oj_default_options.safe) ? Qtrue : ((No == oj_default_options.safe) ? Qfalse : Qnil));
     rb_hash_aset(opts, float_prec_sym, INT2FIX(oj_default_options.float_prec));
+    rb_hash_aset(opts, float_format_sym, rb_str_new_cstr(oj_default_options.float_fmt));
     rb_hash_aset(opts, cache_str_sym, INT2FIX(oj_default_options.cache_str));
     rb_hash_aset(
         opts,
@@ -519,6 +523,8 @@ static VALUE get_def_opts(VALUE self) {
  *load.
  *   - *:second_precision* [_Fixnum_|_nil_] number of digits after the decimal when dumping the
  *seconds portion of time.
+ *   - *:float_format* [_String_] the C printf format string for printing floats. Default follows
+ * the float_precision and will be changed if float_precision is changed. The string can be no more than 6 bytes.
  *   - *:float_precision* [_Fixnum_|_nil_] number of digits of precision when dumping floats, 0
  *indicates use Ruby.
  *   - *:use_to_json* [_Boolean_|_nil_] call to_json() methods on dump, default is false.
@@ -617,7 +623,6 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
     if (set_yesno_options(k, v, copts)) {
         return ST_CONTINUE;
     }
-
     if (oj_indent_sym == k) {
         switch (rb_type(v)) {
         case T_NIL:
@@ -757,7 +762,6 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         if (Qnil == v) {
             return ST_CONTINUE;
         }
-
         copts->compat_bigdec = (Qtrue == v);
     } else if (oj_decimal_class_sym == k) {
         if (rb_cFloat == v) {
@@ -949,6 +953,25 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
             return ST_CONTINUE;
         }
         copts->sym_key = (Qtrue == v) ? Yes : No;
+
+    } else if (oj_max_nesting_sym == k) {
+        if (Qtrue == v) {
+            copts->dump_opts.max_depth = 100;
+        } else if (Qfalse == v || Qnil == v) {
+            copts->dump_opts.max_depth = MAX_DEPTH;
+        } else if (T_FIXNUM == rb_type(v)) {
+            copts->dump_opts.max_depth = NUM2INT(v);
+            if (0 >= copts->dump_opts.max_depth) {
+                copts->dump_opts.max_depth = MAX_DEPTH;
+            }
+        }
+    } else if (float_format_sym == k) {
+        rb_check_type(v, T_STRING);
+        if (6 < (int)RSTRING_LEN(v)) {
+            rb_raise(rb_eArgError, ":float_format must be 6 bytes or less.");
+        }
+        strncpy(copts->float_fmt, RSTRING_PTR(v), (size_t)RSTRING_LEN(v));
+        copts->float_fmt[RSTRING_LEN(v)] = '\0';
     }
     return ST_CONTINUE;
 }
@@ -957,7 +980,6 @@ void oj_parse_options(VALUE ropts, Options copts) {
     if (T_HASH != rb_type(ropts)) {
         return;
     }
-
     rb_hash_foreach(ropts, parse_options_cb, (VALUE)copts);
     oj_parse_opt_match_string(&copts->str_rx, ropts);
 
@@ -1296,7 +1318,6 @@ static VALUE dump(int argc, VALUE *argv, VALUE self) {
 
     arg.out->omit_nil       = copts.dump_opts.omit_nil;
     arg.out->omit_null_byte = copts.dump_opts.omit_null_byte;
-    arg.out->caller         = CALLER_DUMP;
 
     return rb_ensure(dump_body, (VALUE)&arg, dump_ensure, (VALUE)&arg);
 }
@@ -1308,8 +1329,9 @@ static VALUE dump(int argc, VALUE *argv, VALUE self) {
  * will be called. The mode is set to :compat.
  * - *obj* [_Object_] Object to serialize as an JSON document String
  * - *options* [_Hash_]
- *   - *:max_nesting* [_boolean_] It true nesting is limited to 100. The option to detect circular
- * references is available but is not compatible with the json gem., default is false
+ *   - *:max_nesting* [_Fixnum_|_boolean_] It true nesting is limited to 100. If a Fixnum nesting
+ * is set to the provided value. The option to detect circular references is available but is not
+ * compatible with the json gem., default is false or unlimited.
  *   - *:allow_nan* [_boolean_] If true non JSON compliant words such as Nan and Infinity will be
  * used as appropriate, default is true.
  *   - *:quirks_mode* [_boolean_] Allow single JSON values instead of documents, default is true
@@ -1929,6 +1951,8 @@ void Init_oj(void) {
     rb_gc_register_address(&integer_range_sym);
     fast_sym = ID2SYM(rb_intern("fast"));
     rb_gc_register_address(&fast_sym);
+    float_format_sym = ID2SYM(rb_intern("float_format"));
+    rb_gc_register_address(&float_format_sym);
     float_prec_sym = ID2SYM(rb_intern("float_precision"));
     rb_gc_register_address(&float_prec_sym);
     float_sym = ID2SYM(rb_intern("float"));

data/ext/oj/oj.h

@@ -103,13 +103,6 @@ typedef enum {
     FILE_IO   = 'f',
 } StreamWriterType;
 
-typedef enum {
-    CALLER_DUMP     = 'd',
-    CALLER_TO_JSON  = 't',
-    CALLER_GENERATE = 'g',
-    // Add the fast versions if necessary. Maybe unparse as well if needed.
-} DumpCaller;
-
 typedef struct _dumpOpts {
     bool    use;
     char    indent_str[16];
@@ -188,23 +181,22 @@ typedef struct _rOptTable {
 } *ROptTable;
 
 typedef struct _out {
-    char       stack_buffer[4096];
-    char      *buf;
-    char      *end;
-    char      *cur;
-    Cache8     circ_cache;
-    slot_t     circ_cnt;
-    int        indent;
-    int        depth;  // used by dump_hash
-    Options    opts;
-    uint32_t   hash_cnt;
-    bool       allocated;
-    bool       omit_nil;
-    bool       omit_null_byte;
-    int        argc;
-    VALUE     *argv;
-    DumpCaller caller;  // used for the mimic json only
-    ROptTable  ropts;
+    char      stack_buffer[4096];
+    char     *buf;
+    char     *end;
+    char     *cur;
+    Cache8    circ_cache;
+    slot_t    circ_cnt;
+    int       indent;
+    int       depth;  // used by dump_hash
+    Options   opts;
+    uint32_t  hash_cnt;
+    bool      allocated;
+    bool      omit_nil;
+    bool      omit_null_byte;
+    int       argc;
+    VALUE    *argv;
+    ROptTable ropts;
 } *Out;
 
 typedef struct _strWriter {

data/ext/oj/rails.c

@@ -890,7 +890,6 @@ static VALUE encode(VALUE obj, ROptTable ropts, Options opts, int argc, VALUE *a
     oj_out_init(&out);
 
     out.omit_nil = copts.dump_opts.omit_nil;
-    out.caller   = 0;
     out.cur      = out.buf;
     out.circ_cnt = 0;
     out.opts     = &copts;

data/ext/oj/string_writer.c

@@ -70,7 +70,6 @@ void oj_str_writer_init(StrWriter sw, int buf_size) {
     sw->out.depth      = 0;
     sw->out.argc       = 0;
     sw->out.argv       = NULL;
-    sw->out.caller     = 0;
     sw->out.ropts      = NULL;
     sw->out.omit_nil   = oj_default_options.dump_opts.omit_nil;
 }

data/lib/oj/json.rb

@@ -2,7 +2,10 @@ require 'ostruct'
 require 'oj/state'
 
 if defined?(JSON::PRETTY_STATE_PROTOTYPE)
-  warn "WARNING: oj/json is a compatability shim used by Oj. Requiring the file explicitly is no recommended."
+  # There are enough people that try to use both the json gen and oj in mimic
+  # mode so don't display the warning.
+
+  # warn "WARNING: oj/json is a compatability shim used by Oj. Requiring the file explicitly is not recommended."
 end
 
 unless defined?(JSON::PRETTY_STATE_PROTOTYPE)

data/lib/oj/version.rb

@@ -1,4 +1,4 @@
 module Oj
   # Current version of the module.
-  VERSION = '3.15.1'
+  VERSION = '3.16.0'
 end

data/test/foo.rb

@@ -5,16 +5,10 @@ $LOAD_PATH << '.'
 $LOAD_PATH << File.join(__dir__, '../lib')
 $LOAD_PATH << File.join(__dir__, '../ext')
 
-require 'active_support'
 require 'json'
 require 'oj'
+require 'oj/json'
 
-Oj.mimic_JSON()
-# Oj::Rails.mimic_JSON()
+Oj.mimic_JSON
 
-begin
-  ::JSON.parse('{ "foo": 84e }')
-  #::JSON.parse('{ "foo": 84eb234 }')
-rescue Exception => e
-  puts "#{e.class}: #{e.message}"
-end
+JSON.parse("[]")

data/test/json_gem/json_common_interface_test.rb

@@ -128,8 +128,10 @@ class JSONCommonInterfaceTest < Test::Unit::TestCase
     too_deep = '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]'
     assert_equal too_deep, JSON.dump(eval(too_deep))
     assert_kind_of String, Marshal.dump(eval(too_deep))
-    assert_raise(ArgumentError) { JSON.dump(eval(too_deep), 100) }
-    assert_raise(ArgumentError) { Marshal.dump(eval(too_deep), 100) }
+    if RUBY_ENGINE != 'truffleruby'
+      assert_raise(ArgumentError) { JSON.dump(eval(too_deep), 100) }
+      assert_raise(ArgumentError) { Marshal.dump(eval(too_deep), 100) }
+    end
     assert_equal too_deep, JSON.dump(eval(too_deep), 101)
     assert_kind_of String, Marshal.dump(eval(too_deep), 101)
     output = StringIO.new

data/test/json_gem/json_generator_test.rb

@@ -352,7 +352,7 @@ class JSONGeneratorTest < Test::Unit::TestCase
     too_deep_ary = eval too_deep
     assert_raise(JSON::NestingError) { JSON.generate too_deep_ary }
     assert_raise(JSON::NestingError) { JSON.generate too_deep_ary, :max_nesting => 100 }
-    ok = JSON.generate too_deep_ary, :max_nesting => 101
+    ok = JSON.generate too_deep_ary, :max_nesting => 102
     assert_equal too_deep, ok
     ok = JSON.generate too_deep_ary, :max_nesting => nil
     assert_equal too_deep, ok

data/test/perf_dump.rb

@@ -28,7 +28,7 @@ opts.parse(ARGV)
   'd' => [ true, [false, [-123_456_789, 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
+  'h' => { 'a' => { 'b' => { 'c' => { 'd' => { 'e' => { 'f' => { 'g' => nil }}}}}}}, # deep hash, not that deep
   'i' => [[[[[[[nil]]]]]]]  # deep array, again, not that deep
 }
 

data/test/prec.rb

@@ -2,9 +2,9 @@
 
 require 'oj'
 
-extras = {'locationLng' => -97.14690769100295}
+extras = { 'locationLng' => -97.14690769100295 }
 
-Oj.default_options = {float_precision: 17}
+Oj.default_options = { float_precision: 17 }
 
 encoded = Oj.dump(extras)
 puts encoded
@@ -15,8 +15,8 @@ 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}
+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)

data/test/test_compat.rb

@@ -467,10 +467,28 @@ class CompatJuice < Minitest::Test
   end
 
   def test_arg_passing
-    json = Oj.to_json(Argy.new(), :max_nesting=> 40)
+    json = Oj.to_json(Argy.new(), :max_nesting => 40)
     assert_equal(%|{"args":"[{:max_nesting=>40}]"}|, json)
   end
 
+  def test_max_nesting
+    assert_raises() { Oj.to_json([[[[[]]]]], :max_nesting => 3) }
+    assert_raises() { Oj.dump([[[[[]]]]], :max_nesting => 3, :mode=>:compat) }
+
+    assert_raises() { Oj.to_json([[]], :max_nesting => 1) }
+    assert_equal('[[]]', Oj.to_json([[]], :max_nesting => 2))
+
+    assert_raises() { Oj.dump([[]], :max_nesting => 1, :mode=>:compat) }
+    assert_equal('[[]]', Oj.dump([[]], :max_nesting => 2, :mode=>:compat))
+
+    assert_raises() { Oj.to_json([[3]], :max_nesting => 1) }
+    assert_equal('[[3]]', Oj.to_json([[3]], :max_nesting => 2))
+
+    assert_raises() { Oj.dump([[3]], :max_nesting => 1, :mode=>:compat) }
+    assert_equal('[[3]]', Oj.dump([[3]], :max_nesting => 2, :mode=>:compat))
+
+  end
+
   def test_bad_unicode
     assert_raises() { Oj.to_json("\xE4xy") }
   end

data/test/test_parser_debug.rb

@@ -3,7 +3,7 @@
 
 $LOAD_PATH << __dir__
 @oj_dir = File.dirname(File.expand_path(__dir__))
-%w(lib ext).each do |dir|
+%w[lib ext].each do |dir|
   $LOAD_PATH << File.join(@oj_dir, dir)
 end
 

data/test/test_various.rb

@@ -105,6 +105,7 @@ class Juice < Minitest::Test
       allow_gc: false,
       quirks_mode: false,
       allow_invalid_unicode: true,
+      float_format: '%0.13g',
       float_precision: 13,
       mode: :strict,
       escape_mode: :ascii,
@@ -416,6 +417,11 @@ class Juice < Minitest::Test
     }
   end
 
+  def test_dump_float
+    json = Oj.dump(1.23e-2, :mode => :null, :float_format => '%0.4f')
+    assert_equal('0.0123', json)
+  end
+
   # Class
   def test_class_null
     json = Oj.dump(Juice, :mode => :null)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oj
 version: !ruby/object:Gem::Version
-  version: 3.15.1
+  version: 3.16.0
 platform: ruby
 authors:
 - Peter Ohler
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-07-31 00:00:00.000000000 Z
+date: 2023-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest