oj 3.15.0 → 3.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 929e5766d8a556ed9590574901fe8268979fd6c165d10e1a2a8601a594dd6897
-  data.tar.gz: 966fedee6a16f73c004b56050474377ae48521f5858da962f0f0416b5636a4c3
+  metadata.gz: affe42de16d26dfe301f38df7c0bc8ceee39ab25e5a6bd14bd7af6671cc3b422
+  data.tar.gz: ee1d7227f864b197aca62cb767f9202798b6d3d13cf0b5f89eae3f3a36450dbb
 SHA512:
-  metadata.gz: f458f616c33c48d84cb0e1d2c1c45e8b677609c19251345328721fe3b7b6c4c5aa1fd4906da2234b60889a6e3bb45ee0371e7de7565bb6d1aa7d924e231e36dd
-  data.tar.gz: fbbf233fc1ce57739d2fe538c179a24282e4c043740c2b47cce29745e3847712afa7828d321b877a3c29ab7d2216e7185af9a85bb9c8eb96b6036f9e3e49c1d1
+  metadata.gz: 8dbf6a0b5fef2b179dba864b595113f73ac27a952307559422bf1feda19fcc008a5e43a142d1bb3eb0cc4125ff18f35730208c7f82b11089ff90690e7b1f17d0
+  data.tar.gz: be09c04fa551288e2708c9151d0c966a09c3768ba15442cc54b8b4dd5850e2228b45608c06c8251c4e2ca32333353713f9c1feff81e4d34a48d1c6bf725014f6

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # 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.
+
+- Fixed non-json errors when in compat mode.
+
 ## 3.15.0 - 2023-06-02
 
 - Added `omit_null_byte` option when dumping.

data/ext/oj/code.c

@@ -185,24 +185,17 @@ void oj_code_attrs(VALUE obj, Attr attrs, int depth, Out out, bool with_class) {
             } else {
                 char   buf[32];
                 char  *b   = buf + sizeof(buf) - 1;
-                int    neg = 0;
+                bool   neg = false;
                 long   num = attrs->num;
                 size_t cnt = 0;
 
                 if (0 > num) {
-                    neg = 1;
+                    neg = true;
                     num = -num;
                 }
                 *b-- = '\0';
                 if (0 < num) {
-                    for (; 0 < num; num /= 10, b--) {
-                        *b = (num % 10) + '0';
-                    }
-                    if (neg) {
-                        *b = '-';
-                    } else {
-                        b++;
-                    }
+                    b = oj_longlong_to_string(num, neg, b);
                 } else {
                     *b = '0';
                 }

data/ext/oj/compat.c

@@ -13,32 +13,19 @@
 #include "trace.h"
 
 static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, const char *orig) {
-    const char    *key    = kval->key;
-    int            klen   = kval->klen;
-    Val            parent = stack_peek(&pi->stack);
-    volatile VALUE rkey   = kval->key_val;
+    const char *key    = kval->key;
+    int         klen   = kval->klen;
+    Val         parent = stack_peek(&pi->stack);
 
-    if (Qundef == rkey && Yes == pi->options.create_ok && NULL != pi->options.create_id &&
+    if (Qundef == kval->key_val && Yes == pi->options.create_ok && NULL != pi->options.create_id &&
         *pi->options.create_id == *key && (int)pi->options.create_id_len == klen &&
         0 == strncmp(pi->options.create_id, key, klen)) {
         parent->classname = oj_strndup(str, len);
         parent->clen      = len;
     } else {
         volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
+        volatile VALUE rkey = oj_calc_hash_key(pi, kval);
 
-        if (Qundef == rkey) {
-            if (Yes != pi->options.cache_keys) {
-                if (Yes == pi->options.sym_key) {
-                    rkey = ID2SYM(rb_intern3(key, klen, oj_utf8_encoding));
-                } else {
-                    rkey = rb_utf8_str_new(key, klen);
-                }
-            } else if (Yes == pi->options.sym_key) {
-                rkey = oj_sym_intern(key, klen);
-            } else {
-                rkey = oj_str_intern(key, klen);
-            }
-        }
         if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
             VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, (int)len);
 

data/ext/oj/custom.c

@@ -889,12 +889,11 @@ void oj_dump_custom_val(VALUE obj, int depth, Out out, bool as_ok) {
 ///// load functions /////
 
 static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, const char *orig) {
-    const char    *key    = kval->key;
-    int            klen   = kval->klen;
-    Val            parent = stack_peek(&pi->stack);
-    volatile VALUE rkey   = kval->key_val;
+    const char *key    = kval->key;
+    int         klen   = kval->klen;
+    Val         parent = stack_peek(&pi->stack);
 
-    if (Qundef == rkey && Yes == pi->options.create_ok && NULL != pi->options.create_id &&
+    if (Qundef == kval->key_val && Yes == pi->options.create_ok && NULL != pi->options.create_id &&
         *pi->options.create_id == *key && (int)pi->options.create_id_len == klen &&
         0 == strncmp(pi->options.create_id, key, klen)) {
         parent->clas = oj_name2class(pi, str, len, false, rb_eArgError);
@@ -907,15 +906,8 @@ static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, c
         }
     } else {
         volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
-        // volatile VALUE rstr = rb_utf8_str_new(str, len);
+        volatile VALUE rkey = oj_calc_hash_key(pi, kval);
 
-        if (Qundef == rkey) {
-            if (Yes == pi->options.sym_key) {
-                rkey = ID2SYM(rb_intern3(key, klen, oj_utf8_encoding));
-            } else {
-                rkey = rb_utf8_str_new(key, klen);
-            }
-        }
         if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
             VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, (int)len);
 

data/ext/oj/dump.c

@@ -1010,11 +1010,33 @@ static const char digits_table[] = "\
 80818283848586878889\
 90919293949596979899";
 
+char *oj_longlong_to_string(long long num, bool negative, char *buf) {
+    while (100 <= num) {
+        unsigned idx = num % 100 * 2;
+        *buf--       = digits_table[idx + 1];
+        *buf--       = digits_table[idx];
+        num /= 100;
+    }
+    if (num < 10) {
+        *buf-- = num + '0';
+    } else {
+        *buf-- = digits_table[num * 2 + 1];
+        *buf-- = digits_table[num * 2];
+    }
+
+    if (negative) {
+        *buf = '-';
+    } else {
+        buf++;
+    }
+    return buf;
+}
+
 void oj_dump_fixnum(VALUE obj, int depth, Out out, bool as_ok) {
     char      buf[32];
     char     *b              = buf + sizeof(buf) - 1;
     long long num            = NUM2LL(obj);
-    int       neg            = 0;
+    bool      neg            = false;
     size_t    cnt            = 0;
     bool      dump_as_string = false;
 
@@ -1023,7 +1045,7 @@ void oj_dump_fixnum(VALUE obj, int depth, Out out, bool as_ok) {
         dump_as_string = true;
     }
     if (0 > num) {
-        neg = 1;
+        neg = true;
         num = -num;
     }
     *b-- = '\0';
@@ -1032,24 +1054,7 @@ void oj_dump_fixnum(VALUE obj, int depth, Out out, bool as_ok) {
         *b-- = '"';
     }
     if (0 < num) {
-        while (100 <= num) {
-            unsigned idx = num % 100 * 2;
-            *b--         = digits_table[idx + 1];
-            *b--         = digits_table[idx];
-            num /= 100;
-        }
-        if (num < 10) {
-            *b-- = num + '0';
-        } else {
-            *b-- = digits_table[num * 2 + 1];
-            *b-- = digits_table[num * 2];
-        }
-
-        if (neg) {
-            *b = '-';
-        } else {
-            b++;
-        }
+        b = oj_longlong_to_string(num, neg, b);
     } else {
         *b = '0';
     }

data/ext/oj/dump.h

@@ -93,10 +93,7 @@ inline static void dump_ulong(unsigned long num, Out out) {
 
     *b-- = '\0';
     if (0 < num) {
-        for (; 0 < num; num /= 10, b--) {
-            *b = (num % 10) + '0';
-        }
-        b++;
+        b = oj_longlong_to_string((long long)num, false, b);
     } else {
         *b = '0';
     }

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'mkmf'
 require 'rbconfig'
 
@@ -6,7 +8,7 @@ dir_config(extension_name)
 
 parts = RUBY_DESCRIPTION.split(' ')
 type = parts[0]
-type = type[4..-1] if type.start_with?('tcs-')
+type = type[4..] if type.start_with?('tcs-')
 is_windows = RbConfig::CONFIG['host_os'] =~ /(mingw|mswin)/
 platform = RUBY_PLATFORM
 version = RUBY_VERSION.split('.')
@@ -56,7 +58,7 @@ dflags.each do |k, v|
 end
 
 $CPPFLAGS += ' -Wall'
-#puts "*** $CPPFLAGS: #{$CPPFLAGS}"
+# puts "*** $CPPFLAGS: #{$CPPFLAGS}"
 # Adding the __attribute__ flag only works with gcc compilers and even then it
 # does not work to check args with varargs so just remove the check.
 CONFIG['warnflags'].slice!(/ -Wsuggest-attribute=format/)

data/ext/oj/fast.c

@@ -40,7 +40,7 @@ typedef struct _doc {
     Leaf         *where;                  // points to current location
     Leaf          where_path[MAX_STACK];  // points to head of path
     char         *json;
-    unsigned long size;  // number of leaves/branches in the doc
+    unsigned long size;                   // number of leaves/branches in the doc
     VALUE         self;
     Batch         batches;
     struct _batch batch0;
@@ -114,10 +114,7 @@ inline static char *ulong_fill(char *s, size_t num) {
     char *b = buf + sizeof(buf) - 1;
 
     *b-- = '\0';
-    for (; 0 < num; num /= 10, b--) {
-        *b = (num % 10) + '0';
-    }
-    b++;
+    b    = oj_longlong_to_string((long long)num, false, b);
     if ('\0' == *b) {
         b--;
         *b = '0';
@@ -576,7 +573,7 @@ static char *read_quoted_value(ParseInfo pi) {
     char *h     = pi->s;  // head
     char *t     = h;      // tail
 
-    h++;  // skip quote character
+    h++;                  // skip quote character
     t++;
     value = h;
     for (; '"' != *h; h++, t++) {

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;
@@ -574,7 +572,6 @@ static VALUE mimic_parse_core(int argc, VALUE *argv, VALUE self, bool bang) {
         if (T_HASH != rb_type(ropts)) {
             rb_raise(rb_eArgError, "options must be a hash.");
         }
-
         rb_hash_foreach(ropts, parse_options_cb, (VALUE)&pi);
         v = rb_hash_lookup(ropts, oj_max_nesting_sym);
         if (Qtrue == v) {

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);
 
@@ -1294,9 +1316,8 @@ static VALUE dump(int argc, VALUE *argv, VALUE self) {
 
     oj_out_init(arg.out);
 
-    arg.out->omit_nil = copts.dump_opts.omit_nil;
+    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
@@ -1343,7 +1365,7 @@ static VALUE to_json(int argc, VALUE *argv, VALUE self) {
 
     oj_out_init(&out);
 
-    out.omit_nil = copts.dump_opts.omit_nil;
+    out.omit_nil       = copts.dump_opts.omit_nil;
     out.omit_null_byte = copts.dump_opts.omit_null_byte;
     // For obj.to_json or generate nan is not allowed but if called from dump
     // it is.
@@ -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 {
@@ -262,12 +254,13 @@ extern VALUE oj_custom_parse_cstr(int argc, VALUE *argv, char *json, size_t len)
 extern bool oj_hash_has_key(VALUE hash, VALUE key);
 extern void oj_parse_options(VALUE ropts, Options copts);
 
-extern void oj_dump_obj_to_json(VALUE obj, Options copts, Out out);
-extern void oj_dump_obj_to_json_using_params(VALUE obj, Options copts, Out out, int argc, VALUE *argv);
-extern void oj_write_obj_to_file(VALUE obj, const char *path, Options copts);
-extern void oj_write_obj_to_stream(VALUE obj, VALUE stream, Options copts);
-extern void oj_dump_leaf_to_json(Leaf leaf, Options copts, Out out);
-extern void oj_write_leaf_to_file(Leaf leaf, const char *path, Options copts);
+extern void  oj_dump_obj_to_json(VALUE obj, Options copts, Out out);
+extern void  oj_dump_obj_to_json_using_params(VALUE obj, Options copts, Out out, int argc, VALUE *argv);
+extern void  oj_write_obj_to_file(VALUE obj, const char *path, Options copts);
+extern void  oj_write_obj_to_stream(VALUE obj, VALUE stream, Options copts);
+extern void  oj_dump_leaf_to_json(Leaf leaf, Options copts, Out out);
+extern void  oj_write_leaf_to_file(Leaf leaf, const char *path, Options copts);
+extern char *oj_longlong_to_string(long long num, bool negative, char *buf);
 
 extern void oj_str_writer_push_key(StrWriter sw, const char *key);
 extern void oj_str_writer_push_object(StrWriter sw, const char *key);

data/ext/oj/parse.c

@@ -426,6 +426,7 @@ static void read_num(ParseInfo pi) {
     struct _numInfo ni;
     Val             parent = stack_peek(&pi->stack);
 
+    ni.pi       = pi;
     ni.str      = pi->cur;
     ni.i        = 0;
     ni.num      = 0;
@@ -709,10 +710,7 @@ void oj_parse2(ParseInfo pi) {
         case '[': array_start(pi); break;
         case ']': array_end(pi); break;
         case ',': comma(pi); break;
-        case '"':
-            read_str(pi);
-            break;
-            // case '+':
+        case '"': read_str(pi); break;
         case '+':
             if (CompatMode == pi->options.mode) {
                 oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected character");
@@ -877,7 +875,7 @@ oj_num_as_value(NumInfo ni) {
             double d = strtod(ni->str, &end);
 
             if ((long)ni->len != (long)(end - ni->str)) {
-                rb_raise(oj_parse_error_class, "Invalid float");
+                rb_raise(ni->pi->err_class, "Invalid float");
             }
             rnum = rb_float_new(d);
         }

data/ext/oj/parse.h

@@ -16,22 +16,24 @@
 #include "val_stack.h"
 
 struct _rxClass;
+struct _parseInfo;
 
 typedef struct _numInfo {
-    int64_t     i;
-    int64_t     num;
-    int64_t     div;
-    int64_t     di;
-    const char *str;
-    size_t      len;
-    long        exp;
-    int         big;
-    int         infinity;
-    int         nan;
-    int         neg;
-    int         has_exp;
-    int         no_big;
-    int         bigdec_load;
+    int64_t            i;
+    int64_t            num;
+    int64_t            div;
+    int64_t            di;
+    const char        *str;
+    size_t             len;
+    long               exp;
+    struct _parseInfo *pi;
+    int                big;
+    int                infinity;
+    int                nan;
+    int                neg;
+    int                has_exp;
+    int                no_big;
+    int                bigdec_load;
 } *NumInfo;
 
 typedef struct _parseInfo {

data/ext/oj/parser.h

@@ -32,9 +32,9 @@ typedef struct _num {
     long double dub;
     int64_t     fixnum;  // holds all digits
     uint32_t    len;
-    int16_t     div;  // 10^div
+    int16_t     div;     // 10^div
     int16_t     exp;
-    uint8_t     shift;  // shift of fixnum to get decimal
+    uint8_t     shift;   // shift of fixnum to get decimal
     bool        neg;
     bool        exp_neg;
     // for numbers as strings, reuse buf

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/reader.c

@@ -101,7 +101,7 @@ int oj_reader_read(Reader reader) {
         } else {
             shift = reader->pro - reader->head - 1;  // leave one character so we can backup one
         }
-        if (0 >= shift) { /* no space left so allocate more */
+        if (0 >= shift) {                            /* no space left so allocate more */
             const char *old  = reader->head;
             size_t      size = reader->end - reader->head + BUF_PAD;
 
@@ -164,7 +164,6 @@ static VALUE partial_io_cb(VALUE rbuf) {
     }
     str = StringValuePtr(rstr);
     cnt = RSTRING_LEN(rstr);
-    // printf("*** partial read %lu bytes, str: '%s'\n", cnt, str);
     strcpy(reader->tail, str);
     reader->read_end = reader->tail + cnt;
 
@@ -185,7 +184,6 @@ static VALUE io_cb(VALUE rbuf) {
     }
     str = StringValuePtr(rstr);
     cnt = RSTRING_LEN(rstr);
-    // printf("*** read %lu bytes, str: '%s'\n", cnt, str);
     strcpy(reader->tail, str);
     reader->read_end = reader->tail + cnt;
 

data/ext/oj/saj.c

@@ -587,7 +587,7 @@ static void saj_parse(VALUE handler, char *json) {
         if (0 == getrlimit(RLIMIT_STACK, &lim) && RLIM_INFINITY != lim.rlim_cur) {
             pi.stack_min = (void *)((char *)&obj - (lim.rlim_cur / 4 * 3)); /* let 3/4ths of the stack be used only */
         } else {
-            pi.stack_min = 0; /* indicates not to check stack limit */
+            pi.stack_min = 0;                                               /* indicates not to check stack limit */
         }
     }
 #endif

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

@@ -1,15 +1,14 @@
+# frozen_string_literal: true
+
 require 'active_support/time'
 
 module Oj
-
   # Exists only to handle the ActiveSupport::TimeWithZone.
   class ActiveSupportHelper
-
     def self.createTimeWithZone(utc, zone)
       ActiveSupport::TimeWithZone.new(utc - utc.gmt_offset, ActiveSupport::TimeZone[zone])
     end
   end
-
 end
 
 Oj.register_odd(ActiveSupport::TimeWithZone, Oj::ActiveSupportHelper, :createTimeWithZone, :utc, 'time_zone.name')

data/lib/oj/json.rb

@@ -1,178 +1,188 @@
 require 'ostruct'
 require 'oj/state'
 
-module JSON
-  NaN = 0.0/0.0 unless defined?(::JSON::NaN)
-  Infinity = 1.0/0.0 unless defined?(::JSON::Infinity)
-  MinusInfinity = -1.0/0.0 unless defined?(::JSON::MinusInfinity)
-  # Taken from the unit test. Note that items like check_circular? are not
-  # present.
-  PRETTY_STATE_PROTOTYPE = Ext::Generator::State.from_state({
-                                              :allow_nan             => false,
-                                              :array_nl              => "\n",
-                                              :ascii_only            => false,
-                                              :buffer_initial_length => 1024,
-                                              :depth                 => 0,
-                                              :indent                => "  ",
-                                              :max_nesting           => 100,
-                                              :object_nl             => "\n",
-                                              :space                 => " ",
-                                              :space_before          => "",
-                                            }) unless defined?(::JSON::PRETTY_STATE_PROTOTYPE)
-  SAFE_STATE_PROTOTYPE = Ext::Generator::State.from_state({
-                                            :allow_nan             => false,
-                                            :array_nl              => "",
-                                            :ascii_only            => false,
-                                            :buffer_initial_length => 1024,
-                                            :depth                 => 0,
-                                            :indent                => "",
-                                            :max_nesting           => 100,
-                                            :object_nl             => "",
-                                            :space                 => "",
-                                            :space_before          => "",
-                                            }) unless defined?(::JSON::SAFE_STATE_PROTOTYPE)
-  FAST_STATE_PROTOTYPE = Ext::Generator::State.from_state({
-                                            :allow_nan             => false,
-                                            :array_nl              => "",
-                                            :ascii_only            => false,
-                                            :buffer_initial_length => 1024,
-                                            :depth                 => 0,
-                                            :indent                => "",
-                                            :max_nesting           => 0,
-                                            :object_nl             => "",
-                                            :space                 => "",
-                                            :space_before          => "",
-                                            }) unless defined?(::JSON::FAST_STATE_PROTOTYPE)
-
-  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
+if defined?(JSON::PRETTY_STATE_PROTOTYPE)
+  # 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)
+  module JSON
+    NaN = 0.0/0.0 unless defined?(::JSON::NaN)
+    Infinity = 1.0/0.0 unless defined?(::JSON::Infinity)
+    MinusInfinity = -1.0/0.0 unless defined?(::JSON::MinusInfinity)
+    # Taken from the unit test. Note that items like check_circular? are not
+    # present.
+    PRETTY_STATE_PROTOTYPE = Ext::Generator::State.from_state({
+                                                                :allow_nan             => false,
+                                                                :array_nl              => "\n",
+                                                                :ascii_only            => false,
+                                                                :buffer_initial_length => 1024,
+                                                                :depth                 => 0,
+                                                                :indent                => "  ",
+                                                                :max_nesting           => 100,
+                                                                :object_nl             => "\n",
+                                                                :space                 => " ",
+                                                                :space_before          => "",
+                                                              }) unless defined?(::JSON::PRETTY_STATE_PROTOTYPE)
+    SAFE_STATE_PROTOTYPE = Ext::Generator::State.from_state({
+                                                              :allow_nan             => false,
+                                                              :array_nl              => "",
+                                                              :ascii_only            => false,
+                                                              :buffer_initial_length => 1024,
+                                                              :depth                 => 0,
+                                                              :indent                => "",
+                                                              :max_nesting           => 100,
+                                                              :object_nl             => "",
+                                                              :space                 => "",
+                                                              :space_before          => "",
+                                                            }) unless defined?(::JSON::SAFE_STATE_PROTOTYPE)
+    FAST_STATE_PROTOTYPE = Ext::Generator::State.from_state({
+                                                              :allow_nan             => false,
+                                                              :array_nl              => "",
+                                                              :ascii_only            => false,
+                                                              :buffer_initial_length => 1024,
+                                                              :depth                 => 0,
+                                                              :indent                => "",
+                                                              :max_nesting           => 0,
+                                                              :object_nl             => "",
+                                                              :space                 => "",
+                                                              :space_before          => "",
+                                                            }) unless defined?(::JSON::FAST_STATE_PROTOTYPE)
+
+    def self.dump_default_options
+      Oj::MimicDumpOption.new
     end
-  end
 
-  def self.parser=(p)
-    @@parser = p
-  end
+    def self.dump_default_options=(h)
+      m = Oj::MimicDumpOption.new
+      h.each do |k, v|
+        m[k] = v
+      end
+    end
 
-  def self.parser()
-    @@parser
-  end
+    def self.parser=(p)
+      @@parser = p
+    end
 
-  def self.generator=(g)
-    @@generator = g
-  end
+    def self.parser()
+      @@parser
+    end
 
-  def self.generator()
-    @@generator
-  end
+    def self.generator=(g)
+      @@generator = g
+    end
 
-  module Ext
-    class Parser
-      def initialize(src)
-        raise TypeError.new("already initialized") unless @source.nil?
+    def self.generator()
+      @@generator
+    end
 
-        @source = src
-      end
+    module Ext
+      class Parser
+        def initialize(src)
+          raise TypeError.new("already initialized") unless @source.nil?
 
-      def source()
-        raise TypeError.new("already initialized") if @source.nil?
+          @source = src
+        end
 
-        @source
-      end
-      
-      def parse()
-        raise TypeError.new("already initialized") if @source.nil?
+        def source()
+          raise TypeError.new("already initialized") if @source.nil?
 
-        JSON.parse(@source)
-      end
-      
-    end # Parser
-  end # Ext
-  
-  State = ::JSON::Ext::Generator::State unless defined?(::JSON::State)
-
-  begin
-    send(:remove_const, :Parser)
-  rescue
-  end
-  Parser = ::JSON::Ext::Parser unless defined?(::JSON::Parser)
-  self.parser = ::JSON::Ext::Parser
-  self.generator = ::JSON::Ext::Generator
-
-  # Taken directly from the json gem. Shamelessly copied. It is similar in
-  # some ways to the Oj::Bag class or the Oj::EasyHash class.
-  class GenericObject < OpenStruct
-    class << self
-      alias [] new
-      
-      def json_creatable?
-        @json_creatable
-      end
+          @source
+        end
 
-      attr_writer :json_creatable
+        def parse()
+          raise TypeError.new("already initialized") if @source.nil?
 
-      def json_create(data)
-        data = data.dup
-        data.delete JSON.create_id
-        self[data]
-      end
+          JSON.parse(@source)
+        end
 
-      def from_hash(object)
-        case
-        when object.respond_to?(:to_hash)
-          result = new
-          object.to_hash.each do |key, value|
-            result[key] = from_hash(value)
+      end # Parser
+    end # Ext
+
+    State = ::JSON::Ext::Generator::State unless defined?(::JSON::State)
+
+    begin
+      send(:remove_const, :Parser)
+    rescue
+      # ignore and move on
+    end
+    Parser = ::JSON::Ext::Parser unless defined?(::JSON::Parser)
+    self.parser = ::JSON::Ext::Parser
+    self.generator = ::JSON::Ext::Generator
+
+    # Taken directly from the json gem. Shamelessly copied. It is similar in
+    # some ways to the Oj::Bag class or the Oj::EasyHash class.
+    class GenericObject < OpenStruct
+      class << self
+        alias [] new
+
+        def json_creatable?
+          @json_creatable
+        end
+
+        attr_writer :json_creatable
+
+        def json_create(data)
+          data = data.dup
+          data.delete JSON.create_id
+          self[data]
+        end
+
+        def from_hash(object)
+          case
+          when object.respond_to?(:to_hash)
+            result = new
+            object.to_hash.each do |key, value|
+              result[key] = from_hash(value)
+            end
+            result
+          when object.respond_to?(:to_ary)
+            object.to_ary.map { |a| from_hash(a) }
+          else
+            object
           end
-          result
-        when object.respond_to?(:to_ary)
-          object.to_ary.map { |a| from_hash(a) }
-        else
-          object
         end
-      end
 
-      def load(source, proc = nil, opts = {})
-        result = ::JSON.load(source, proc, opts.merge(:object_class => self))
-        result.nil? ? new : result
-      end
+        def load(source, proc = nil, opts = {})
+          result = ::JSON.load(source, proc, opts.merge(:object_class => self))
+          result.nil? ? new : result
+        end
 
-      def dump(obj, *args)
-        ::JSON.dump(obj, *args)
-      end
+        def dump(obj, *args)
+          ::JSON.dump(obj, *args)
+        end
 
-    end # self
+      end # self
 
-    self.json_creatable = false
+      self.json_creatable = false
 
-    def to_hash
-      table
-    end
+      def to_hash
+        table
+      end
 
-    def [](name)
-      __send__(name)
-    end unless method_defined?(:[])
+      def [](name)
+        __send__(name)
+      end unless method_defined?(:[])
 
-    def []=(name, value)
-      __send__("#{name}=", value)
-    end unless method_defined?(:[]=)
+      def []=(name, value)
+        __send__("#{name}=", value)
+      end unless method_defined?(:[]=)
 
-    def |(other)
-      self.class[other.to_hash.merge(to_hash)]
-    end
+      def |(other)
+        self.class[other.to_hash.merge(to_hash)]
+      end
 
-    def as_json(*)
-      { JSON.create_id => self.class.name }.merge to_hash
-    end
+      def as_json(*)
+        { JSON.create_id => self.class.name }.merge to_hash
+      end
 
-    def to_json(*a)
-      as_json.to_json(*a)
+      def to_json(*a)
+        as_json.to_json(*a)
+      end
     end
-  end
-  
-end # JSON
+
+  end # JSON
+end

data/lib/oj/mimic.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: false
+
 require 'bigdecimal'
 begin
   require 'ostruct'
@@ -266,7 +268,7 @@ module Oj
         end
       end
       def self.json_create(h)
-        if usec = h.delete('u')
+        if (usec = h.delete('u'))
           h['n'] = usec * 1000
         end
         if instance_methods.include?(:tv_nsec)

data/lib/oj/version.rb

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

data/test/foo.rb

@@ -5,11 +5,10 @@ $LOAD_PATH << '.'
 $LOAD_PATH << File.join(__dir__, '../lib')
 $LOAD_PATH << File.join(__dir__, '../ext')
 
+require 'json'
 require 'oj'
-
-GC.stress = true
+require 'oj/json'
 
 Oj.mimic_JSON
 
-Oj.add_to_json(Hash)
-pp JSON('{ "a": 1, "b": 2 }', :object_class => JSON::GenericObject)
+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

@@ -24,11 +24,11 @@ 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
+  'c' => 12_345,   # number
+  '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.0
+  version: 3.16.0
 platform: ruby
 authors:
 - Peter Ohler
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-03 00:00:00.000000000 Z
+date: 2023-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest