oj 3.17.5 → 3.17.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62e3d04685cbc7e063801fd45fc2e9c86a3695ac1fff9235d49944fb19a1ba50
-  data.tar.gz: 98cd36664b62b1d774998a5c39d4ea1610fbeb5a4d789de2bd80894bf9121fbe
+  metadata.gz: 6d8e7bd60ca653140f1d101a88ded37ad5b6fe2af3d5e01ae6787435238c75eb
+  data.tar.gz: 9ef057d4e77c5b2ba30f9a34b2fc3621875c902ca05da25495a4abf657f0bbdb
 SHA512:
-  metadata.gz: '029e6458460f15ae5bcbf26bb25ff959b5c3a0b70cf04b5eded0b2ff50930bbd3470b51410590fbf6621640590257360e0d20b290af8c28efbb31ee0a602998b'
-  data.tar.gz: c2442be3533074487f3fa7b7e84fac719748cd3f99c40217dc6f6dbc09600e491b2925905f400e2ac7de5639d78d15f76f01f5865a41dda2f963e6ccfd59223c
+  metadata.gz: b9654f35d338c316388534ee7d7143165dd2aab82960324f7fd313771445a2dc2d2b22964408b533735dab30e4fd554b5f8abe272a7b3beb5352720cd039fb16
+  data.tar.gz: 4ffc5a78fc866f6824564d34e2db316c56454999bdcb0f91068b40e4dd28f04f23acfb9ce819364bb6a33c3aa5c2e3be0979982220552a1ec3a5eceedfd6f320

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # CHANGELOG
 
+## 3.17.7 - 2026-09-29
+
+### Fixed
+ - issue #1104, where `Oj.dump` in compat and custom mode forwarded its whole options hash to the `to_json` methods it calls, so with json 3.0, whose generator raises `ArgumentError` on options it does not know, dumping a `Time` or any other object whose `to_json` comes from the json gem failed with `unknown keywords: mode, use_to_json`. Nested values reach `to_json` even without `use_to_json`, so `Oj.dump(data, mode: :compat)` failed the same way for data holding a `BigDecimal` or `Time`. The options Oj acts on are now dropped from the hash `to_json` receives, except `:only` and `:except`, which ActiveSupport's `as_json` reads. Keys Oj does not know are passed through untouched.
+ - Speed up hash-heavy documents: skip the 11KB per-parse memset and bulk-insert hashes (#1096)
+ - Preserve decimal placement for large parser numbers (#1099)
+ - Keep zero digits in oversized parser exponents (#1100)
+ - Parse very small usual-mode numbers correctly (#1101)
+ - Speed up symbol keys by interning without a temporary String (#1102)
+ - Keep Oj's own options out of the hash passed to to_json (#1106)
+ - Ensure class-cache mutex is released on exceptions (#1108)
+ - Guard __has_include with an #ifdef to support older GCC versions (4.4.7 etc.) (#1111)
+
+## 3.17.6 - 2026-08-10
+
+- Fixed issue #1092, where the encoder ActiveSupport 8.1 caches with `escape: false` froze the options as they stood before `set_encoder` wrote `time_precision` into them, so `to_json(escape: false)` emitted 9 fractional digits. An options hash that names no option Oj knows no longer detaches an encoder from the defaults. (#1093)
+
 ## 3.17.5 - 2026-07-31
 
 Most of this release comes out of a security review of the C extension. There are no API changes.

data/ext/oj/compat.c

@@ -33,7 +33,10 @@ static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, c
                 rstr = rb_funcall(clas, oj_json_create_id, 1, rstr);
             }
         }
-        if (rb_cHash != rb_obj_class(parent->val)) {
+        if (Qnil == pi->options.hash_class) {
+            stack_pair_push(&pi->stack, rkey, rstr);
+            parent->pcnt += 2;
+        } else if (rb_cHash != rb_obj_class(parent->val)) {
             // The rb_hash_set would still work but the unit tests for the
             // json gem require the less efficient []= method be called to set
             // values. Even using the store method to set the values will fail
@@ -47,20 +50,34 @@ static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, c
 }
 
 static VALUE start_hash(ParseInfo pi) {
-    volatile VALUE h;
-
     if (Qnil != pi->options.hash_class) {
-        h = rb_class_new_instance(0, NULL, pi->options.hash_class);
-    } else {
-        h = rb_hash_new();
+        return rb_class_new_instance(0, NULL, pi->options.hash_class);
     }
     TRACE_PARSE_IN(pi->options.trace, "start_hash", pi);
-    return h;
+    // The Hash is built at end_hash from the buffered pairs.
+    return Qundef;
 }
 
 static void end_hash(struct _parseInfo *pi) {
     Val parent = stack_peek(&pi->stack);
 
+    if (Qnil == pi->options.hash_class) {
+        ValStack       stack = &pi->stack;
+        size_t         cnt   = parent->pcnt;
+        volatile VALUE h;
+
+#if HAVE_RB_HASH_NEW_CAPA
+        h = rb_hash_new_capa((long)(cnt / 2));
+#else
+        h = rb_hash_new();
+#endif
+        if (0 < cnt) {
+            rb_hash_bulk_insert((long)cnt, stack->pairs + stack->pcnt - cnt, h);
+            stack->pcnt -= cnt;
+            parent->pcnt = 0;
+        }
+        parent->val = h;
+    }
     if (0 != parent->classname) {
         volatile VALUE clas;
 
@@ -103,7 +120,10 @@ static void add_num(ParseInfo pi, NumInfo ni) {
 static void hash_set_num(struct _parseInfo *pi, Val parent, NumInfo ni) {
     volatile VALUE rval = oj_num_as_value(ni);
 
-    if (rb_cHash != rb_obj_class(parent->val)) {
+    if (Qnil == pi->options.hash_class) {
+        stack_pair_push(&pi->stack, oj_calc_hash_key(pi, parent), rval);
+        parent->pcnt += 2;
+    } else if (rb_cHash != rb_obj_class(parent->val)) {
         // The rb_hash_set would still work but the unit tests for the
         // json gem require the less efficient []= method be called to set
         // values. Even using the store method to set the values will fail
@@ -116,7 +136,10 @@ static void hash_set_num(struct _parseInfo *pi, Val parent, NumInfo ni) {
 }
 
 static void hash_set_value(ParseInfo pi, Val parent, VALUE value) {
-    if (rb_cHash != rb_obj_class(parent->val)) {
+    if (Qnil == pi->options.hash_class) {
+        stack_pair_push(&pi->stack, oj_calc_hash_key(pi, parent), value);
+        parent->pcnt += 2;
+    } else if (rb_cHash != rb_obj_class(parent->val)) {
         // The rb_hash_set would still work but the unit tests for the
         // json gem require the less efficient []= method be called to set
         // values. Even using the store method to set the values will fail

data/ext/oj/custom.c

@@ -1033,8 +1033,24 @@ static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const c
     TRACE_PARSE_CALL(pi->options.trace, "append_string", pi, rstr);
 }
 
+// Compat mode defers Hash creation to its end_hash (bulk insert from the
+// buffered pairs) but the custom callbacks below fill the Hash as they go,
+// so hashes must exist from the opening brace here.
+static VALUE start_hash(ParseInfo pi) {
+    volatile VALUE h;
+
+    if (Qnil != pi->options.hash_class) {
+        h = rb_class_new_instance(0, NULL, pi->options.hash_class);
+    } else {
+        h = rb_hash_new();
+    }
+    TRACE_PARSE_IN(pi->options.trace, "start_hash", pi);
+    return h;
+}
+
 void oj_set_custom_callbacks(ParseInfo pi) {
     oj_set_compat_callbacks(pi);
+    pi->start_hash        = start_hash;
     pi->hash_set_cstr     = hash_set_cstr;
     pi->end_hash          = end_hash;
     pi->hash_set_num      = hash_set_num;

data/ext/oj/extconf.rb

@@ -31,6 +31,7 @@ have_func('stpcpy')
 have_func('pthread_mutex_init')
 have_func('getrlimit', 'sys/resource.h')
 have_func('rb_enc_interned_str')
+have_func('rb_hash_new_capa', 'ruby.h')
 have_func('rb_ext_ractor_safe', 'ruby.h')
 have_func('rb_hash_start', 'ruby.h')
 
@@ -48,6 +49,12 @@ if try_cflags('-msse2')
   $CPPFLAGS += ' -msse2'
 end
 
+# Ensure C99 mode for compilers that default to C90 (e.g. GCC 4.x).
+# simd.h uses C99 for-loop declarations that fail under -std=gnu90.
+if !$CFLAGS.include?('-std=') && try_cflags('-std=gnu99')
+  $CFLAGS += ' -std=gnu99'
+end
+
 if enable_config('trace-log', false)
   dflags['OJ_ENABLE_TRACE_LOG'] = 1
 end

data/ext/oj/intern.c

@@ -50,7 +50,12 @@ static VALUE form_str(const char *str, size_t len) {
 }
 
 static VALUE form_sym(const char *str, size_t len) {
-    return rb_to_symbol(rb_str_intern(rb_utf8_str_new(str, len)));
+    VALUE sym = rb_check_symbol_cstr(str, (long)len, oj_utf8_encoding);
+
+    if (Qnil == sym) {
+        sym = rb_str_intern(rb_utf8_str_new(str, len));
+    }
+    return sym;
 }
 
 static VALUE form_attr(const char *str, size_t len) {
@@ -243,61 +248,83 @@ static VALUE resolve_classpath(ParseInfo pi, const char *name, size_t len, int a
     return clas;
 }
 
+typedef struct _internArgs {
+    KeyVal      bucket;  // last bucket in the chain for the key's slot
+    const char *key;
+    size_t      len;
+    ParseInfo   pi;
+    int         auto_define;
+    VALUE       error_class;
+} *InternArgs;
+
+// Resolves the class and only then adds it to the cache so a raise while
+// resolving does not leave a key cached with no value.
+static VALUE intern_new_class(VALUE a) {
+    InternArgs args   = (InternArgs)a;
+    KeyVal     bucket = args->bucket;
+    VALUE      clas   = resolve_classpath(args->pi, args->key, args->len, args->auto_define, args->error_class);
+
+    if (NULL != bucket->key) {  // not the top slot
+        KeyVal b = OJ_R_ALLOC(struct _keyVal);
+
+        b->next      = NULL;
+        bucket->next = b;
+        bucket       = b;
+    }
+    bucket->key = oj_strndup(args->key, args->len);
+    bucket->len = args->len;
+    bucket->val = clas;
+
+    return clas;
+}
+
+static KeyVal find_class(KeyVal bucket, const char *key, size_t len, VALUE *clas) {
+    if (NULL != bucket->key) {  // not the top slot
+        for (KeyVal b = bucket; 0 != b; b = b->next) {
+            if (len == b->len && 0 == strncmp(b->key, key, len)) {
+                *clas = b->val;
+                return NULL;
+            }
+            bucket = b;
+        }
+    }
+    return bucket;
+}
+
 VALUE oj_class_intern(const char *key, size_t len, bool safe, ParseInfo pi, int auto_define, VALUE error_class) {
-    uint64_t h      = hash_calc((const uint8_t *)key, len) & HASH_MASK;
-    KeyVal   bucket = class_hash.slots + h;
-    KeyVal   b;
+    uint64_t           h    = hash_calc((const uint8_t *)key, len) & HASH_MASK;
+    struct _internArgs args = {NULL, key, len, pi, auto_define, error_class};
+    VALUE              clas = Qundef;
 
     if (safe) {
+        int state = 0;
+
 #if HAVE_PTHREAD_MUTEX_INIT
         pthread_mutex_lock(&class_hash.mutex);
 #else
         rb_mutex_lock(class_hash.mutex);
 #endif
-        if (NULL != bucket->key) {  // not the top slot
-            for (b = bucket; 0 != b; b = b->next) {
-                if (len == b->len && 0 == strncmp(b->key, key, len)) {
-#if HAVE_PTHREAD_MUTEX_INIT
-                    pthread_mutex_unlock(&class_hash.mutex);
-#else
-                    rb_mutex_unlock(class_hash.mutex);
-#endif
-                    return b->val;
-                }
-                bucket = b;
-            }
-            b            = OJ_R_ALLOC(struct _keyVal);
-            b->next      = NULL;
-            bucket->next = b;
-            bucket       = b;
+        // Resolving calls into Ruby and allocating, either of which can
+        // raise and unwind past the unlock, so the work is protected and any
+        // exception rethrown after the mutex is released.
+        if (NULL != (args.bucket = find_class(class_hash.slots + h, key, len, &clas))) {
+            clas = rb_protect(intern_new_class, (VALUE)&args, &state);
         }
-        bucket->key = oj_strndup(key, len);
-        bucket->len = len;
-        bucket->val = resolve_classpath(pi, key, len, auto_define, error_class);
 #if HAVE_PTHREAD_MUTEX_INIT
         pthread_mutex_unlock(&class_hash.mutex);
 #else
         rb_mutex_unlock(class_hash.mutex);
 #endif
-    } else {
-        if (NULL != bucket->key) {
-            for (b = bucket; 0 != b; b = b->next) {
-                if (len == b->len && 0 == strncmp(b->key, key, len)) {
-                    return (ID)b->val;
-                }
-                bucket = b;
-            }
-            b            = OJ_R_ALLOC(struct _keyVal);
-            b->next      = NULL;
-            bucket->next = b;
-            bucket       = b;
+        if (0 != state) {
+            rb_jump_tag(state);
         }
-        bucket->key = oj_strndup(key, len);
-        bucket->len = len;
-        bucket->val = resolve_classpath(pi, key, len, auto_define, error_class);
+    } else if (NULL != (args.bucket = find_class(class_hash.slots + h, key, len, &clas))) {
+        clas = intern_new_class((VALUE)&args);
     }
-    rb_gc_register_mark_object(bucket->val);
-    return bucket->val;
+    if (NULL != args.bucket) {  // newly added to the cache
+        rb_gc_register_mark_object(clas);
+    }
+    return clas;
 }
 
 char *oj_strndup(const char *s, size_t len) {

data/ext/oj/mimic_json.c

@@ -461,7 +461,7 @@ oj_mimic_pretty_generate(int argc, VALUE *argv, VALUE self) {
     if (1 == argc || Qnil == argv[1]) {
         h = rb_hash_new();
     } else {
-        h = argv[1];
+        h = rb_hash_dup(argv[1]);
     }
     if (!oj_hash_has_key(h, oj_indent_sym)) {
         rb_hash_aset(h, oj_indent_sym, rb_str_new2("  "));

data/ext/oj/oj.c

@@ -836,12 +836,14 @@ static const char *make_only_value(VALUE v) {
     return NULL;
 }
 
-static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
-    Options copts = (Options)opts;
-    size_t  len;
+// Apply one key and value to copts. Returns true if the key named an option Oj
+// knows and false if it did not. An unrecognized key is still ignored rather
+// than an error; the return only lets a caller tell the two cases apart.
+static bool parse_one_option(VALUE k, VALUE v, Options copts) {
+    size_t len;
 
     if (set_yesno_options(k, v, copts)) {
-        return ST_CONTINUE;
+        return true;
     }
     if (oj_indent_sym == k) {
         switch (rb_type(v)) {
@@ -967,7 +969,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (bigdecimal_load_sym == k) {
         if (Qnil == v) {
-            return ST_CONTINUE;
+            return true;
         }
 
         if (bigdecimal_sym == v || Qtrue == v) {
@@ -983,7 +985,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (compat_bigdecimal_sym == k) {
         if (Qnil == v) {
-            return ST_CONTINUE;
+            return true;
         }
         copts->compat_bigdec = (Qtrue == v);
     } else if (oj_decimal_class_sym == k) {
@@ -1078,7 +1080,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (nan_sym == k) {
         if (Qnil == v) {
-            return ST_CONTINUE;
+            return true;
         }
         if (null_sym == v) {
             copts->dump_opts.nan_dump = NullNan;
@@ -1095,7 +1097,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (omit_nil_sym == k) {
         if (Qnil == v) {
-            return ST_CONTINUE;
+            return true;
         }
         if (Qtrue == v) {
             copts->dump_opts.omit_nil = true;
@@ -1106,7 +1108,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (omit_null_byte_sym == k) {
         if (Qnil == v) {
-            return ST_CONTINUE;
+            return true;
         }
         if (Qtrue == v) {
             copts->dump_opts.omit_null_byte = true;
@@ -1167,7 +1169,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (integer_range_sym == k) {
         if (Qnil == v) {
-            return ST_CONTINUE;
+            return true;
         }
         if (rb_obj_class(v) == rb_cRange) {
             VALUE min = rb_funcall(v, oj_begin_id, 0);
@@ -1198,7 +1200,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (symbol_keys_sym == k || oj_symbolize_names_sym == k) {
         if (Qnil == v) {
-            return ST_CONTINUE;
+            return true;
         }
         copts->sym_key = (Qtrue == v) ? Yes : No;
 
@@ -1233,21 +1235,90 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
             OJ_R_FREE((void *)copts->dump_opts.except);
         }
         copts->dump_opts.except = make_only_value(v);
+    } else {
+        return false;
+    }
+    return true;
+}
+
+// Collects the results of parse_one_option() over every key in a hash.
+struct _optsParse {
+    Options copts;
+    bool    consumed;  // some key was an Oj option
+    VALUE   orig;      // the caller's hash, never modified
+    VALUE   rest;      // orig, or a copy of it without the Oj options
+};
+
+static void drop_from_rest(struct _optsParse *op, VALUE k) {
+    if (op->rest == op->orig) {
+        op->rest = rb_hash_dup(op->orig);
+    }
+    rb_hash_delete(op->rest, k);
+}
+
+static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
+    struct _optsParse *op = (struct _optsParse *)opts;
+
+    if (parse_one_option(k, v, op->copts)) {
+        op->consumed = true;
+        // :only and :except are also read by ActiveSupport's as_json, which
+        // compat mode reaches through to_json, so they are left in.
+        if (only_sym != k && except_sym != k) {
+            drop_from_rest(op, k);
+        }
     }
     return ST_CONTINUE;
 }
 
-void oj_parse_options(VALUE ropts, Options copts) {
+static void parse_options(VALUE ropts, Options copts, struct _optsParse *op) {
+    op->copts    = copts;
+    op->consumed = false;
+    op->orig     = ropts;
+    op->rest     = ropts;
+
     if (T_HASH != rb_type(ropts)) {
         return;
     }
-    rb_hash_foreach(ropts, parse_options_cb, (VALUE)copts);
+    rb_hash_foreach(ropts, parse_options_cb, (VALUE)op);
+    if (Qnil != rb_hash_lookup(ropts, match_string_sym)) {
+        op->consumed = true;
+        drop_from_rest(op, match_string_sym);
+    }
     oj_parse_opt_match_string(&copts->str_rx, ropts);
 
     copts->dump_opts.use = (0 < copts->dump_opts.indent_size || 0 < copts->dump_opts.after_size ||
                             0 < copts->dump_opts.before_size || 0 < copts->dump_opts.hash_size ||
                             0 < copts->dump_opts.array_size);
-    return;
+}
+
+// Apply the options in ropts to copts and report whether any key was
+// recognized. A hash of nothing but unknown keys leaves copts untouched and
+// returns false.
+bool oj_parse_options_consumed(VALUE ropts, Options copts) {
+    struct _optsParse op;
+
+    parse_options(ropts, copts, &op);
+
+    return op.consumed;
+}
+
+// Apply the options in ropts to copts and return what is left for the
+// to_json and as_json methods that Oj.dump() calls: ropts itself when it
+// holds no Oj option, otherwise a copy without them. The json gem's
+// generator raises on options it does not know as of json 3.0, so Oj's own
+// must not reach it. ropts is never modified.
+VALUE oj_parse_options_rest(VALUE ropts, Options copts) {
+    struct _optsParse op;
+
+    parse_options(ropts, copts, &op);
+
+    return op.rest;
+}
+
+void oj_parse_options(VALUE ropts, Options copts) {
+    struct _optsParse op;
+
+    parse_options(ropts, copts, &op);
 }
 
 // Free the option buffers that oj_parse_options() allocated for a single call.
@@ -1671,6 +1742,7 @@ static VALUE dump(int argc, VALUE *argv, VALUE self) {
     struct dump_arg arg;
     struct _out     out;
     struct _options copts = oj_default_options;
+    VALUE           to_json_argv[2];
 
     if (1 > argc) {
         rb_raise(rb_eArgError, "wrong number of arguments (0 for 1).");
@@ -1679,7 +1751,11 @@ static VALUE dump(int argc, VALUE *argv, VALUE self) {
         copts.dump_opts.nan_dump = WordNan;
     }
     if (2 == argc) {
-        oj_parse_options(argv[1], &copts);
+        // The options hash is also what to_json and as_json receive, so
+        // hand them the hash without the options Oj itself acted on.
+        to_json_argv[0] = argv[0];
+        to_json_argv[1] = oj_parse_options_rest(argv[1], &copts);
+        argv            = to_json_argv;
     }
     if (CompatMode == copts.mode && copts.escape_mode != ASCIIEsc) {
         copts.escape_mode = JSONEsc;

data/ext/oj/oj.h

@@ -255,12 +255,14 @@ extern VALUE oj_compat_parse_cstr(int argc, VALUE *argv, char *json, size_t len)
 extern VALUE oj_object_parse_cstr(int argc, VALUE *argv, char *json, size_t len);
 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_free_call_options(Options copts);
-extern void oj_options_take_ownership(Options copts);
-extern void oj_options_release(Options copts);
-extern void oj_options_mark(Options copts);
+extern bool  oj_hash_has_key(VALUE hash, VALUE key);
+extern void  oj_parse_options(VALUE ropts, Options copts);
+extern bool  oj_parse_options_consumed(VALUE ropts, Options copts);
+extern VALUE oj_parse_options_rest(VALUE ropts, Options copts);
+extern void  oj_free_call_options(Options copts);
+extern void  oj_options_take_ownership(Options copts);
+extern void  oj_options_release(Options copts);
+extern void  oj_options_mark(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);

data/ext/oj/parse.c

@@ -1261,7 +1261,11 @@ oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yie
     // value stack (while it is in scope).
     wrapped_stack = oj_stack_init(&pi->stack);
     rb_protect(protect_parse, (VALUE)pi, &line);
-    if (Qundef == pi->stack.head->val && !empty_ok(&pi->options)) {
+    // Only when nothing is on the stack was the input actually empty. A
+    // deferred hash (built at its closing brace from buffered pairs) leaves
+    // head->val Qundef while its entry is still on the stack, e.g. when a
+    // parse error cut the document short; the real error is already set.
+    if (Qundef == pi->stack.head->val && stack_empty(&pi->stack) && !empty_ok(&pi->options)) {
         if (No == pi->options.nilnil || (CompatMode == pi->options.mode && 0 < pi->cur - pi->json)) {
             oj_set_error_at(pi, oj_json_parser_error_class, __FILE__, __LINE__, "Empty input");
         }

data/ext/oj/parse.h

@@ -5,6 +5,7 @@
 #define OJ_PARSE_H
 
 #include <stdarg.h>
+#include <stddef.h>
 #include <stdio.h>
 #include <string.h>
 
@@ -90,7 +91,19 @@ extern VALUE oj_cstr_to_value(const char *str, size_t len, size_t cache_str);
 extern VALUE oj_calc_hash_key(ParseInfo pi, Val parent);
 
 static inline void parse_info_init(ParseInfo pi) {
-    memset(pi, 0, sizeof(struct _parseInfo));
+    // Zeroing the whole struct costs more than parsing a small document: the
+    // embedded reader buffer (rd.base, 4KB) and value stack entries
+    // (stack.base, 6.5KB) dominate its 11KB. Both are fully initialized
+    // before use — oj_reader_init() for stream parses, oj_stack_init() and
+    // stack_push() for the value stack — so zero only the scalars around
+    // them.
+    memset(pi, 0, offsetof(struct _parseInfo, rd));
+    memset((char *)pi + offsetof(struct _parseInfo, rd) + offsetof(struct _reader, head),
+           0,
+           offsetof(struct _parseInfo, stack) - offsetof(struct _parseInfo, rd) - offsetof(struct _reader, head));
+    memset((char *)pi + offsetof(struct _parseInfo, stack) + offsetof(struct _valStack, head),
+           0,
+           sizeof(struct _parseInfo) - offsetof(struct _parseInfo, stack) - offsetof(struct _valStack, head));
 }
 
 extern void oj_scanner_init(void);

data/ext/oj/parser.c

@@ -509,20 +509,29 @@ static void calc_num(ojParser p) {
             d = -d;
         }
         if (0 < p->num.shift) {
-            d /= pow_map[p->num.shift];
-        }
-        if (0 < p->num.exp) {
-            long double x;
+            uint32_t shift = p->num.shift;
 
-            if (MAX_POW < p->num.exp) {
-                x = powl(10.0L, (long double)p->num.exp);
-            } else {
-                x = pow_map[p->num.exp];
+            while (MAX_POW < shift) {
+                d /= pow_map[MAX_POW];
+                shift -= MAX_POW;
             }
+            d /= pow_map[shift];
+        }
+        if (0 < p->num.exp) {
             if (p->num.exp_neg) {
-                d /= x;
+                int exp = p->num.exp;
+
+                while (MAX_POW < exp) {
+                    d /= pow_map[MAX_POW];
+                    exp -= MAX_POW;
+                }
+                d /= pow_map[exp];
             } else {
-                d *= x;
+                if (MAX_POW < p->num.exp) {
+                    d *= powl(10.0L, (long double)p->num.exp);
+                } else {
+                    d *= pow_map[p->num.exp];
+                }
             }
         }
         p->num.dub = d;
@@ -559,19 +568,31 @@ static void big_change(ojParser p) {
         break;
     case OJ_DECIMAL: {
         int shift = p->num.shift;
+        int end   = sizeof(buf) - 1;
 
-        for (len = sizeof(buf) - 1; 0 < i; len--, i /= 10, shift--) {
-            if (0 == shift) {
-                buf[len] = '.';
-                len--;
-            }
-            buf[len] = '0' + (i % 10);
-        }
+        len = end;
+        do {
+            buf[--len] = '0' + (i % 10);
+            i /= 10;
+        } while (0 < i);
         if (p->num.neg) {
-            buf[len] = '-';
-            len--;
+            buf_append(&p->buf, '-');
+        }
+        if (end - len <= shift) {
+            buf_append_string(&p->buf, "0.", 2);
+            for (int cnt = shift - (end - len); 0 < cnt; cnt--) {
+                buf_append(&p->buf, '0');
+            }
+            buf_append_string(&p->buf, buf + len, end - len);
+        } else {
+            int decimal = end - shift;
+
+            buf_append_string(&p->buf, buf + len, decimal - len);
+            if (0 < shift) {
+                buf_append(&p->buf, '.');
+                buf_append_string(&p->buf, buf + decimal, shift);
+            }
         }
-        buf_append_string(&p->buf, buf + len + 1, sizeof(buf) - len - 1);
         if (0 < p->num.exp) {
             int  x = p->num.exp;
             int  d, div;
@@ -585,6 +606,7 @@ static void big_change(ojParser p) {
                 d = x / div % 10;
                 if (started || 0 < d) {
                     buf_append(&p->buf, '0' + d);
+                    started = true;
                 }
             }
         }

data/ext/oj/parser.h

@@ -34,7 +34,7 @@ typedef struct _num {
     uint32_t    len;
     int16_t     div;  // 10^div
     int16_t     exp;
-    uint8_t     shift;  // shift of fixnum to get decimal
+    uint32_t    shift;  // shift of fixnum to get decimal
     bool        neg;
     bool        exp_neg;
     // for numbers as strings, reuse buf

data/ext/oj/rails.c

@@ -765,11 +765,15 @@ static VALUE encoder_new(int argc, VALUE *argv, VALUE self) {
         e->arg = rb_hash_new();
     }
     // An encoder given no options of its own reads oj_default_options at encode
-    // time rather than copying it here. ActiveSupport keeps one option-less
-    // encoder for the life of the process, so a copy taken now would freeze
-    // every later Oj.default_options and ActiveSupport::JSON::Encoding change
-    // out of it - including the time_precision that set_encoder itself writes
-    // after ActiveSupport has already built and cached that encoder.
+    // time rather than copying it here. ActiveSupport keeps such an encoder for
+    // the life of the process, so a copy taken now would freeze every later
+    // Oj.default_options and ActiveSupport::JSON::Encoding change out of it -
+    // including the time_precision that set_encoder itself writes after
+    // ActiveSupport has already built and cached that encoder.
+    //
+    // A hash counts as options only if at least one key names an option Oj
+    // knows. Non-empty is not enough: ActiveSupport 8.1 caches a second encoder
+    // built with {escape: false}, a key Oj has never had.
     e->own_opts = T_HASH == rb_type(e->arg) && 0 < RHASH_SIZE(e->arg);
     if (e->own_opts) {
         e->opts = oj_default_options;
@@ -778,9 +782,13 @@ static VALUE encoder_new(int argc, VALUE *argv, VALUE self) {
         // its own that is freed with the encoder.
         e->opts.str_rx.head = NULL;
         e->opts.str_rx.tail = NULL;
-        oj_parse_options(e->arg, &e->opts);
+        e->own_opts         = oj_parse_options_consumed(e->arg, &e->opts);
+    }
+    if (e->own_opts) {
         oj_options_take_ownership(&e->opts);
     } else {
+        // Nothing to free: every option that allocates is reached through a
+        // recognized key, and ownership is not taken until after that check.
         memset(&e->opts, 0, sizeof(e->opts));
     }
 
@@ -1176,8 +1184,6 @@ static VALUE rails_set_encoder(VALUE self) {
     } else {
         rb_raise(rb_eStandardError, "ActiveSupport not loaded.");
     }
-    rb_funcall(active, rb_intern("json_encoder="), 1, encoder_class);
-
     json     = rb_const_get_at(active, rb_intern("JSON"));
     encoding = rb_const_get_at(json, rb_intern("Encoding"));
 
@@ -1204,6 +1210,12 @@ static VALUE rails_set_encoder(VALUE self) {
     rb_define_module_function(encoding, "time_precision=", rails_time_precision, 1);
     rb_gv_set("$VERBOSE", verbose);
 
+    // Last, because ActiveSupport builds and caches encoders inside
+    // json_encoder= and they should see the settings above already in the
+    // defaults. escape_html and xml_time are read ahead of it for the same
+    // reason.
+    rb_funcall(active, rb_intern("json_encoder="), 1, encoder_class);
+
     return Qnil;
 }
 

data/ext/oj/simd.h

@@ -99,9 +99,11 @@ static inline int oj_ctz64_fallback(uint64_t x) {
 // GCC/Clang: check for header availability and include them
 // We include headers but use target attributes to enable instructions per-function
 // Include cpuid.h for __get_cpuid fallback when __builtin_cpu_supports is unavailable
+#ifdef __has_include
 #if __has_include(<cpuid.h>)
 #include <cpuid.h>
 #endif
+#endif
 #if defined(__SSE4_2__) || defined(__SSE2__)
 // If any SSE is enabled globally, x86intrin.h should be available
 #include <x86intrin.h>
@@ -109,6 +111,7 @@ static inline int oj_ctz64_fallback(uint64_t x) {
 #define HAVE_SIMD_SSE2 1
 #else
 // Try to include headers anyway for target attribute functions
+#ifdef __has_include
 #if __has_include(<x86intrin.h>)
 #include <x86intrin.h>
 #define HAVE_SIMD_SSE4_2 1
@@ -123,6 +126,7 @@ static inline int oj_ctz64_fallback(uint64_t x) {
 #endif
 #endif
 #endif
+#endif
 
 // Target attribute macros for function-level SIMD enabling
 #if defined(__clang__) || defined(__GNUC__)

data/ext/oj/strict.c

@@ -47,7 +47,29 @@ VALUE oj_calc_hash_key(ParseInfo pi, Val parent) {
     return rkey;
 }
 
+// With the default Hash class the pairs of the just closed hash sit on top
+// of the pair buffer; build the Hash in one bulk insert with the final size
+// known instead of one rb_hash_aset per pair (which converts the small
+// ar_table to an st_table mid-insertion for hashes above 8 entries).
 static void hash_end(ParseInfo pi) {
+    if (Qnil == pi->options.hash_class) {
+        ValStack       stack = &pi->stack;
+        Val            hash  = stack_peek(stack);
+        size_t         cnt   = hash->pcnt;
+        volatile VALUE h;
+
+#if HAVE_RB_HASH_NEW_CAPA
+        h = rb_hash_new_capa((long)(cnt / 2));
+#else
+        h = rb_hash_new();
+#endif
+        if (0 < cnt) {
+            rb_hash_bulk_insert((long)cnt, stack->pairs + stack->pcnt - cnt, h);
+            stack->pcnt -= cnt;
+            hash->pcnt = 0;
+        }
+        hash->val = h;
+    }
     TRACE_PARSE_HASH_END(pi->options.trace, pi);
 }
 
@@ -84,13 +106,19 @@ static VALUE start_hash(ParseInfo pi) {
         return rb_class_new_instance(0, NULL, pi->options.hash_class);
     }
     TRACE_PARSE_IN(pi->options.trace, "start_hash", pi);
-    return rb_hash_new();
+    // The Hash is built at hash_end from the buffered pairs.
+    return Qundef;
 }
 
 static void hash_set_cstr(ParseInfo pi, Val parent, const char *str, size_t len, const char *orig) {
     volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 
-    rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), rstr);
+    if (Qnil == pi->options.hash_class) {
+        stack_pair_push(&pi->stack, oj_calc_hash_key(pi, parent), rstr);
+        parent->pcnt += 2;
+    } else {
+        rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), rstr);
+    }
     TRACE_PARSE_CALL(pi->options.trace, "set_string", pi, rstr);
 }
 
@@ -101,12 +129,22 @@ static void hash_set_num(ParseInfo pi, Val parent, NumInfo ni) {
         oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
     }
     v = oj_num_as_value(ni);
-    rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), v);
+    if (Qnil == pi->options.hash_class) {
+        stack_pair_push(&pi->stack, oj_calc_hash_key(pi, parent), v);
+        parent->pcnt += 2;
+    } else {
+        rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), v);
+    }
     TRACE_PARSE_CALL(pi->options.trace, "set_number", pi, v);
 }
 
 static void hash_set_value(ParseInfo pi, Val parent, VALUE value) {
-    rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), value);
+    if (Qnil == pi->options.hash_class) {
+        stack_pair_push(&pi->stack, oj_calc_hash_key(pi, parent), value);
+        parent->pcnt += 2;
+    } else {
+        rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), value);
+    }
     TRACE_PARSE_CALL(pi->options.trace, "set_value", pi, value);
 }
 

data/ext/oj/usual.c

@@ -49,7 +49,12 @@ static VALUE form_str(const char *str, size_t len) {
 }
 
 static VALUE form_sym(const char *str, size_t len) {
-    return rb_str_intern(rb_utf8_str_new(str, len));
+    VALUE sym = rb_check_symbol_cstr(str, (long)len, oj_utf8_encoding);
+
+    if (Qnil == sym) {
+        sym = rb_str_intern(rb_utf8_str_new(str, len));
+    }
+    return sym;
 }
 
 static VALUE form_attr(const char *str, size_t len) {
@@ -172,9 +177,9 @@ static VALUE str_key(ojParser p, Key kp) {
 
 static VALUE sym_key(ojParser p, Key kp) {
     if ((size_t)kp->len < sizeof(kp->buf)) {
-        return rb_str_freeze(rb_str_intern(rb_utf8_str_new(kp->buf, kp->len)));
+        return form_sym(kp->buf, kp->len);
     }
-    return rb_str_freeze(rb_str_intern(rb_utf8_str_new(kp->key, kp->len)));
+    return form_sym(kp->key, kp->len);
 }
 
 static ID get_attr_id(ojParser p, Key kp) {

data/ext/oj/val_stack.c

@@ -21,6 +21,13 @@ static void stack_mark(void *ptr) {
     rb_mutex_lock(stack->mutex);
     rb_gc_mark(stack->mutex);
 #endif
+    {
+        size_t i;
+
+        for (i = 0; i < stack->pcnt; i++) {
+            rb_gc_mark(stack->pairs[i]);
+        }
+    }
     for (v = stack->head; v < stack->tail; v++) {
         if (Qnil != v->val && Qundef != v->val) {
             rb_gc_mark(v->val);
@@ -71,6 +78,9 @@ oj_stack_init(ValStack stack) {
     stack->head            = stack->base;
     stack->end             = stack->base + sizeof(stack->base) / sizeof(struct _val);
     stack->tail            = stack->head;
+    stack->pairs           = stack->pbase;
+    stack->pcnt            = 0;
+    stack->pend            = sizeof(stack->pbase) / sizeof(VALUE);
     stack->head->val       = Qundef;
     stack->head->key       = NULL;
     stack->head->key_val   = Qundef;
@@ -79,6 +89,7 @@ oj_stack_init(ValStack stack) {
     stack->head->clas      = Qundef;
     stack->head->klen      = 0;
     stack->head->clen      = 0;
+    stack->head->pcnt      = 0;
     stack->head->next      = NEXT_NONE;
 
     return TypedData_Wrap_Struct(oj_cstack_class, &oj_stack_type, stack);

data/ext/oj/val_stack.h

@@ -37,16 +37,27 @@ typedef struct _val {
     OddArgs        odd_args;
     size_t         klen;
     size_t         clen;
+    size_t         pcnt;  // VALUEs this open hash holds in the stack pair buffer
     char           next;  // ValNext
     char           k1;    // first original character in the key
     char           kalloc;
 } *Val;
 
+#define PAIR_BASE_CNT 64
+
 typedef struct _valStack {
     struct _val base[STACK_INC];
-    Val         head;  // current stack
-    Val         end;   // stack end
-    Val         tail;  // pointer to one past last element name on stack
+    VALUE       pbase[PAIR_BASE_CNT];  // initial buffer for pairs
+    // Flat key/value pair buffer for hash modes that build each Hash in one
+    // rb_hash_bulk_insert at the closing brace instead of one rb_hash_aset
+    // per pair. Nesting is strictly LIFO so each open hash's pairs occupy
+    // the top of the buffer; the per-hash count lives in its Val's clen.
+    VALUE *pairs;
+    size_t pcnt;  // number of live VALUEs in pairs
+    size_t pend;  // capacity of pairs in VALUEs
+    Val    head;  // current stack
+    Val    end;   // stack end
+    Val    tail;  // pointer to one past last element name on stack
 #ifdef HAVE_PTHREAD_MUTEX_INIT
     pthread_mutex_t mutex;
 #else
@@ -76,6 +87,11 @@ inline static void stack_cleanup(ValStack stack) {
         OJ_R_FREE(stack->head);
         stack->head = NULL;
     }
+    if (stack->pbase != stack->pairs) {
+        OJ_R_FREE(stack->pairs);
+        stack->pairs = NULL;
+    }
+    stack->pcnt = 0;
 }
 
 inline static void stack_push(ValStack stack, VALUE val, ValNext next) {
@@ -124,6 +140,7 @@ inline static void stack_push(ValStack stack, VALUE val, ValNext next) {
     stack->tail->key_val   = Qundef;
     stack->tail->clen      = 0;
     stack->tail->klen      = 0;
+    stack->tail->pcnt      = 0;
     stack->tail->kalloc    = 0;
     stack->tail++;
 }
@@ -165,6 +182,40 @@ inline static Val stack_pop(ValStack stack) {
     return 0;
 }
 
+// Append one key/value pair to the pair buffer. The same GC discipline as
+// stack_push: the allocation happens outside the mutex (it can trigger a GC
+// which takes the mutex in stack_mark) and the buffer pointer only changes
+// under the mutex.
+inline static void stack_pair_push(ValStack stack, VALUE key, VALUE value) {
+    if (stack->pend <= stack->pcnt + 2) {
+        size_t cnt = stack->pend * 2;
+        VALUE *pairs;
+
+        if (stack->pbase == stack->pairs) {
+            pairs = OJ_R_ALLOC_N(VALUE, cnt);
+            memcpy(pairs, stack->pairs, sizeof(VALUE) * stack->pcnt);
+        } else {
+            pairs = stack->pairs;
+            OJ_R_REALLOC_N(pairs, VALUE, cnt);
+        }
+#ifdef HAVE_PTHREAD_MUTEX_INIT
+        pthread_mutex_lock(&stack->mutex);
+#else
+        rb_mutex_lock(stack->mutex);
+#endif
+        stack->pairs = pairs;
+        stack->pend  = cnt;
+#ifdef HAVE_PTHREAD_MUTEX_INIT
+        pthread_mutex_unlock(&stack->mutex);
+#else
+        rb_mutex_unlock(stack->mutex);
+#endif
+    }
+    stack->pairs[stack->pcnt]     = key;
+    stack->pairs[stack->pcnt + 1] = value;
+    stack->pcnt += 2;
+}
+
 extern const char *oj_stack_next_string(ValNext n);
 
 #endif /* OJ_VAL_STACK_H */

data/lib/oj/version.rb

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

data/pages/Rails.md

@@ -91,6 +91,10 @@ The classes that can be put in optimized mode and are optimized when
 
 Both `Oj::Rails` and each `Oj::Rails::Encoder` have `optimize()`, `deoptimize()`, and `optimized?()` methods. The module level methods change the setting for the whole process. An encoder follows those process wide settings until `optimize()` or `deoptimize()` is called on the encoder itself. From then on the encoder keeps a set of its own and later module level changes do not reach it.
 
+Options work the same way. An encoder reads `Oj.default_options` when it encodes, so later changes to the defaults reach it, unless it was given options of its own, in which case it keeps the copy it took when it was created. An encoder counts as having options of its own only if the hash it was built with names at least one option Oj knows. A hash of nothing but keys Oj does not have, such as the `escape: false` ActiveSupport 8.1 builds one of its cached encoders with, leaves the encoder on the defaults.
+
+Once a class is optimized its `as_json()` method is no longer called, so an application that defines its own `as_json()` on an optimized class, `BigDecimal` for example, will not see it used. Call `Oj::Rails.deoptimize(BigDecimal)` after `Oj.optimize_rails` to put that one class back on the `as_json()` path and leave the rest optimized.
+
 The ActiveSupport decoder is the `JSON.parse()` method. Calling the
 `Oj::Rails.set_decoder()` method replaces that method with the Oj equivalent.
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oj
 version: !ruby/object:Gem::Version
-  version: 3.17.5
+  version: 3.17.7
 platform: ruby
 authors:
 - Peter Ohler