oj 3.17.6 → 3.17.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af3a1f2b343eefacdaeb1f82d4b48fe67bece49e4aae63ad46aa878f726ae3de
-  data.tar.gz: 8cd6e1ac300706f39d434cbbba52ea780a96b761ba2090d3d3624185bc021819
+  metadata.gz: 887bd6056f15f0ed95de347bc87d12c00c2de9a071b972f16be14952c408f6a6
+  data.tar.gz: af830ec844053ce4c955ac193260d53f5edf88159038c30e5c047b8fd9b334d7
 SHA512:
-  metadata.gz: e081fafa7bd5af792fef91dc58612d6ea85bdae7b3d709bbd945773a5ad9d1feec4c88e3844aa403098c3fa267814ef61dcbba5fb4d9ee86a239eecf5b3926fa
-  data.tar.gz: 339ba6bedb36fb30a382f8cb5037053a4197d4e9364bb11f50b79ec6ec3002cdd687868e140fec1dacabdc9cfa972a45cfcd6cb8a85e4c4148cd484f56278004
+  metadata.gz: 1aa3a234183cfd1e86b6a2b08f91ec553a6048405042ca887647e43198a08ab06287329389bb0c0d4f6c73a637eff158e29da7f187ae4778ebab7379984c771d
+  data.tar.gz: 6e1604f05a6b48364549b350c9b18c4e9b1c5dd819881d82e172ee466ce9c10ff49fbb60309f56ec951ce99f0c2791ca31b94a12e23ebef2bde40c0d44a0a8c4

data/CHANGELOG.md

@@ -1,5 +1,72 @@
 # CHANGELOG
 
+## 3.17.8 - 2026-11-03
+
+### Fixed
+
+- Fixed issue #988 by no longer requiring `ostruct` when Oj is loaded, autoloading `JSON::GenericObject` instead. (#1113)
+- Always include `cpuid.h` and fix the cache typedef for older compilers. (#1112)
+- Keep the sign of `-0.0` when dumping in compat and rails modes. (#1115)
+- Fixed big negative integers and big decimals in `Oj::Parser.usual`. (#1116)
+- Reject a value after a number and whitespace in `Oj::Parser`. (#1117)
+- Combine an escaped surrogate pair in `Oj::Parser`. (#1118)
+- Reject an object close after a colon in `Oj::Parser`. (#1119)
+- Accept an exponent right after a zero integer part in `Oj::Parser`. (#1121)
+- Raise for an incomplete top-level number in `Oj::Parser`. (#1122)
+- Reject unescaped control characters in strict and compat mode strings. (#1123)
+- Fixed memory and handle leaks in `Oj.load` with recent winpthreads on Windows. (#1125)
+- Fixed writer state after an excess pop. (#1126)
+- Fixed memory corruption when `^u` names a class that is not a Struct. (#1127)
+- Fixed cached keys and strings containing NUL returning a different value. (#1129)
+- Fixed a segmentation fault on a `create_id` class path through a non-module constant. (#1130)
+- Fixed a segmentation fault with the `Oj::Parser` class cache after GC compaction. (#1131)
+- Fixed a use-after-free of converted non-UTF-8 input in `Oj.load`. (#1132)
+- Fixed a use-after-free of converted non-UTF-8 strings in `Oj.dump`. (#1133)
+- Fixed a segmentation fault when `Oj::Parser#parse` is given a non-String. (#1134)
+- Fixed a segmentation fault when `Oj.safe_load` is given a null StringIO. (#1135)
+- Fixed a segmentation fault and memory leak in `Oj.saj_parse` with IO input. (#1136)
+- Fixed a segmentation fault when `to_json` returns a non-String in custom mode. (#1137)
+- Fixed a segmentation fault when an exception message is not a String in compat mode. (#1138)
+- Fixed a segmentation fault when `raw_json` returns a non-String. (#1139)
+- Fixed a use-after-free of keys in the `Oj::Parser` saj delegate. (#1140)
+- Fixed wrong keys and `IndexError` for `Oj::Parser` saj handlers with only some callbacks. (#1141)
+- Fixed a buffer overflow when dumping nested arrays with a String indent. (#1142)
+- Fixed a segmentation fault when `array_class` is not an Array in compat and custom mode. (#1143)
+- Fixed a double free when closing an `Oj::Doc` inside the open block. (#1144)
+- Fixed buffer leaks and unchecked file sizes when reading special files. (#1145)
+- Fixed reading freed memory when `Oj.load` parses an object through `to_s`. (#1146)
+- Fixed reading a freed buffer when a `StringWriter` is pushed into itself. (#1147)
+- Fixed a segmentation fault and use-after-free when using a closed `Oj::Doc`. (#1148)
+- Fixed reading and writing a different file when a path contains a NUL byte. (#1149)
+- Fixed buffer leaks when a dump to a String, file, or stream raises. (#1152)
+- Fixed unknown class names filling the class cache and loading as a Hash. (#1153)
+- Fixed object mode ranges and exceptions on Ruby 4.1. (#1154)
+- Fixed a segmentation fault after `Oj::Doc#move` fails on a path with `..`. (#1155)
+- Fixed a segmentation fault in wab mode after GC compaction. (#1156)
+- Fixed OpenStruct dumps and loads changing after GC compaction. (#1157)
+- Fixed a segmentation fault when pushing to a writer with `circular: true`. (#1158)
+- Fixed exception loading and Range subclass dumps in custom mode on Ruby 4.1. (#1159)
+
+### Performance
+
+- Speed up parsing of object keys that collide in the key cache by using SipHash. (#1150)
+- Speed up dumping ASCII-only strings that are not UTF-8. (#1160)
+- Speed up dumping objects in object and custom modes. (#1161)
+- Speed up dumping plain objects in custom mode. (#1162)
+
+## 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)

data/ext/oj/cache.c

@@ -25,23 +25,41 @@
 #define CACHE_UNLOCK(c) rb_mutex_unlock((c)->mutex)
 #endif
 
-// almost the Murmur hash algorithm
-#define M 0x5bd1e995
-
-uint64_t oj_hash_seed = 0;
+#define ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b))))
+#define SIPROUND           \
+    do {                   \
+        v0 += v1;          \
+        v1 = ROTL(v1, 13); \
+        v1 ^= v0;          \
+        v0 = ROTL(v0, 32); \
+        v2 += v3;          \
+        v3 = ROTL(v3, 16); \
+        v3 ^= v2;          \
+        v0 += v3;          \
+        v3 = ROTL(v3, 21); \
+        v3 ^= v0;          \
+        v2 += v1;          \
+        v1 = ROTL(v1, 17); \
+        v1 ^= v2;          \
+        v2 = ROTL(v2, 32); \
+    } while (0)
+
+static uint64_t hash_key[2];
 
 void oj_hash_seed_init(void) {
     static bool seeded = false;
+    VALUE       seed;
+    VALUE       mask;
 
     if (seeded) {
         return;
     }
-    seeded = true;
-#if HAVE_RB_HASH_START
-    oj_hash_seed = (uint64_t)rb_hash_start(0);
-#else
-    oj_hash_seed = (uint64_t)NUM2LL(rb_funcall(rb_str_new_cstr("oj"), rb_intern("hash"), 0));
-#endif
+    seed        = rb_funcall(rb_cRandom, rb_intern("new_seed"), 0);
+    mask        = ULL2NUM(UINT64_MAX);
+    hash_key[0] = NUM2ULL(rb_funcall(seed, rb_intern("&"), 1, mask)) ^ (uint64_t)rb_memhash("oj0", 3);
+    hash_key[1] = NUM2ULL(rb_funcall(rb_funcall(seed, rb_intern(">>"), 1, INT2FIX(64)), rb_intern("&"), 1, mask)) ^
+                  (uint64_t)rb_memhash("oj1", 3);
+    seeded      = true;
 }
 
 typedef struct _slot {
@@ -53,7 +71,7 @@ typedef struct _slot {
     char              key[CACHE_MAX_KEY];
 } *Slot;
 
-typedef struct _cache {
+struct _cache {
     volatile Slot  *slots;
     volatile size_t cnt;
     VALUE (*form)(const char *str, size_t len);
@@ -69,44 +87,43 @@ typedef struct _cache {
 #endif
     uint8_t xrate;
     bool    mark;
-} *Cache;
+};
 
 void cache_set_form(Cache c, VALUE (*form)(const char *str, size_t len)) {
     c->form = form;
 }
 
-static uint64_t hash_calc(const uint8_t *key, size_t len) {
-    const uint8_t *end     = key + len;
-    const uint8_t *endless = key + (len & 0xFFFFFFFC);
-    uint64_t       h       = (uint64_t)len ^ oj_hash_seed;
-    uint64_t       k;
-
-    while (key < endless) {
-        k = (uint64_t)*key++;
-        k |= (uint64_t)*key++ << 8;
-        k |= (uint64_t)*key++ << 16;
-        k |= (uint64_t)*key++ << 24;
-
-        k *= M;
-        k ^= k >> 24;
-        h *= M;
-        h ^= k * M;
-    }
-    if (1 < end - key) {
-        uint16_t k16 = (uint16_t)*key++;
-
-        k16 |= (uint16_t)*key++ << 8;
-        h ^= k16 << 8;
+uint64_t oj_hash_calc(const uint8_t *key, size_t len) {
+    const uint8_t *end = key + (len & ~(size_t)7);
+    uint64_t       v0  = 0x736f6d6570736575ULL ^ hash_key[0];
+    uint64_t       v1  = 0x646f72616e646f6dULL ^ hash_key[1];
+    uint64_t       v2  = 0x6c7967656e657261ULL ^ hash_key[0];
+    uint64_t       v3  = 0x7465646279746573ULL ^ hash_key[1];
+    uint64_t       b   = (uint64_t)len << 56;
+    uint64_t       m;
+    size_t         i;
+
+    for (; key < end; key += 8) {
+        m = 0;
+        for (i = 0; i < 8; i++) {
+            m |= (uint64_t)key[i] << (8 * i);
+        }
+        v3 ^= m;
+        SIPROUND;
+        v0 ^= m;
     }
-    if (key < end) {
-        h ^= *key;
+    for (i = 0; i < (len & 7); i++) {
+        b |= (uint64_t)key[i] << (8 * i);
     }
-    h *= M;
-    h ^= h >> 13;
-    h *= M;
-    h ^= h >> 15;
-
-    return h;
+    v3 ^= b;
+    SIPROUND;
+    v0 ^= b;
+    v2 ^= 0xff;
+    SIPROUND;
+    SIPROUND;
+    SIPROUND;
+
+    return v0 ^ v1 ^ v2 ^ v3;
 }
 
 static void rehash(Cache c) {
@@ -137,7 +154,7 @@ static void rehash(Cache c) {
 }
 
 static VALUE lockless_intern(Cache c, const char *key, size_t len) {
-    uint64_t       h      = hash_calc((const uint8_t *)key, len);
+    uint64_t       h      = oj_hash_calc((const uint8_t *)key, len);
     Slot          *bucket = (Slot *)c->slots + (h & c->mask);
     Slot           b;
     volatile VALUE rkey;
@@ -153,7 +170,7 @@ static VALUE lockless_intern(Cache c, const char *key, size_t len) {
         }
     }
     for (b = *bucket; NULL != b; b = b->next) {
-        if ((uint8_t)len == b->klen && 0 == strncmp(b->key, key, len)) {
+        if ((uint8_t)len == b->klen && 0 == memcmp(b->key, key, len)) {
             b->use_cnt += 16;
             return b->val;
         }
@@ -198,10 +215,10 @@ static VALUE locking_intern(Cache c, const char *key, size_t len) {
             c->rcnt = 0;
         }
     }
-    h      = hash_calc((const uint8_t *)key, len);
+    h      = oj_hash_calc((const uint8_t *)key, len);
     bucket = (Slot *)c->slots + (h & c->mask);
     for (b = *bucket; NULL != b; b = b->next) {
-        if ((uint8_t)len == b->klen && 0 == strncmp(b->key, key, len)) {
+        if ((uint8_t)len == b->klen && 0 == memcmp(b->key, key, len)) {
             b->use_cnt += 4;
             CACHE_UNLOCK(c);
 
@@ -230,7 +247,7 @@ static VALUE locking_intern(Cache c, const char *key, size_t len) {
     // Lock again to add the new entry.
     CACHE_LOCK(c);
     if (old_size != c->size) {
-        h      = hash_calc((const uint8_t *)key, len);
+        h      = oj_hash_calc((const uint8_t *)key, len);
         bucket = (Slot *)c->slots + (h & c->mask);
     }
     b->next = *bucket;

data/ext/oj/cache.h

@@ -10,7 +10,7 @@
 
 #define CACHE_MAX_KEY 35
 
-extern uint64_t oj_hash_seed;
+extern uint64_t oj_hash_calc(const uint8_t *key, size_t len);
 
 extern void oj_hash_seed_init(void);
 

data/ext/oj/code.c

@@ -3,6 +3,8 @@
 
 #include "code.h"
 
+#include <string.h>
+
 #include "dump.h"
 
 inline static VALUE resolve_classname(VALUE mod, const char *classname) {
@@ -45,18 +47,44 @@ static VALUE path2class(const char *name) {
     return resolve_classname(clas, class_name);
 }
 
+// Resolves the class lazily and returns Qundef while it is not defined, as
+// OpenStruct is not until ostruct is required. A miss is checked again on
+// every call so a class loaded later is found by whichever dump comes next,
+// through any entry point. For a top-level name that check is a single
+// constant table probe, so it costs about the same as a cached miss would.
+VALUE oj_code_class(Code c) {
+    if (Qnil != c->clas && Qundef != c->clas) {
+        return c->clas;
+    }
+    if (0 == c->id && NULL == strstr(c->name, "::")) {
+        c->id = rb_intern(c->name);
+    }
+    if (0 == c->id) {
+        c->clas = path2class(c->name);
+    } else if (rb_const_defined_at(rb_cObject, c->id)) {
+        c->clas = rb_const_get_at(rb_cObject, c->id);
+    } else {
+        c->clas = Qundef;
+    }
+    if (Qnil != c->clas && Qundef != c->clas) {
+        rb_gc_register_address(&c->clas);
+    }
+    return c->clas;
+}
+
+inline static bool code_is(Code c, VALUE clas) {
+    if (Qnil != c->clas && Qundef != c->clas) {
+        return clas == c->clas;
+    }
+    return clas == oj_code_class(c);
+}
+
 bool oj_code_dump(Code codes, VALUE obj, int depth, Out out) {
     VALUE clas = rb_obj_class(obj);
     Code  c    = codes;
 
     for (; NULL != c->name; c++) {
-        if (Qundef == c->clas) {  // indicates not defined
-            continue;
-        }
-        if (Qnil == c->clas) {
-            c->clas = path2class(c->name);
-        }
-        if (clas == c->clas && c->active) {
+        if (c->active && code_is(c, clas)) {
             c->encode(obj, depth, out);
             return true;
         }
@@ -69,13 +97,7 @@ oj_code_load(Code codes, VALUE clas, VALUE args) {
     Code c = codes;
 
     for (; NULL != c->name; c++) {
-        if (Qundef == c->clas) {  // indicates not defined
-            continue;
-        }
-        if (Qnil == c->clas) {
-            c->clas = path2class(c->name);
-        }
-        if (clas == c->clas) {
+        if (code_is(c, clas)) {
             if (NULL == c->decode) {
                 break;
             }
@@ -89,13 +111,7 @@ void oj_code_set_active(Code codes, VALUE clas, bool active) {
     Code c = codes;
 
     for (; NULL != c->name; c++) {
-        if (Qundef == c->clas) {  // indicates not defined
-            continue;
-        }
-        if (Qnil == c->clas) {
-            c->clas = path2class(c->name);
-        }
-        if (clas == c->clas || Qnil == clas) {
+        if (Qnil == clas || code_is(c, clas)) {
             c->active = active;
             if (Qnil != clas) {
                 break;
@@ -108,13 +124,7 @@ bool oj_code_has(Code codes, VALUE clas, bool encode) {
     Code c = codes;
 
     for (; NULL != c->name; c++) {
-        if (Qundef == c->clas) {  // indicates not defined
-            continue;
-        }
-        if (Qnil == c->clas) {
-            c->clas = path2class(c->name);
-        }
-        if (clas == c->clas) {
+        if (code_is(c, clas)) {
             if (encode) {
                 return c->active && NULL != c->encode;
             } else {

data/ext/oj/code.h

@@ -17,6 +17,7 @@ typedef struct _code {
     EncodeFunc  encode;
     DecodeFunc  decode;
     bool        active;  // For compat mode.
+    ID          id;      // Interned name, set on first lookup of a top-level class.
 } *Code;
 
 // Used by encode functions.
@@ -28,6 +29,7 @@ typedef struct _attr {
     VALUE       time;
 } *Attr;
 
+extern VALUE oj_code_class(Code c);
 extern bool  oj_code_dump(Code codes, VALUE obj, int depth, Out out);
 extern VALUE oj_code_load(Code codes, VALUE clas, VALUE args);
 extern void  oj_code_set_active(Code codes, VALUE clas, bool active);

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
@@ -136,18 +159,21 @@ static VALUE start_array(ParseInfo pi) {
     return rb_ary_new();
 }
 
+void oj_compat_array_append_other(VALUE a, VALUE value) {
+    if (rb_cArray == rb_obj_class(a)) {
+        rb_ary_push(a, value);
+    } else {
+        // The array_class may not be an Array, and the json gem calls << even
+        // for Array subclasses.
+        rb_funcall(a, rb_intern("<<"), 1, value);
+    }
+}
+
 static void array_append_num(ParseInfo pi, NumInfo ni) {
     Val            parent = stack_peek(&pi->stack);
     volatile VALUE rval   = oj_num_as_value(ni);
 
-    if (!oj_use_array_alt && rb_cArray != rb_obj_class(parent->val)) {
-        // The rb_ary_push would still work but the unit tests for the json
-        // gem require the less efficient << method be called to push the
-        // values.
-        rb_funcall(parent->val, rb_intern("<<"), 1, rval);
-    } else {
-        rb_ary_push(parent->val, rval);
-    }
+    oj_compat_array_append(parent->val, rval);
     TRACE_PARSE_CALL(pi->options.trace, "append_number", pi, rval);
 }
 
@@ -158,26 +184,32 @@ static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const c
         VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, len);
 
         if (Qnil != clas) {
-            rb_ary_push(stack_peek(&pi->stack)->val, rb_funcall(clas, oj_json_create_id, 1, rstr));
+            oj_compat_array_append(stack_peek(&pi->stack)->val, rb_funcall(clas, oj_json_create_id, 1, rstr));
             return;
         }
     }
-    rb_ary_push(stack_peek(&pi->stack)->val, rstr);
+    oj_compat_array_append(stack_peek(&pi->stack)->val, rstr);
     TRACE_PARSE_CALL(pi->options.trace, "append_string", pi, rstr);
 }
 
+static void array_append_value(ParseInfo pi, VALUE value) {
+    oj_compat_array_append(stack_peek(&pi->stack)->val, value);
+    TRACE_PARSE_CALL(pi->options.trace, "append_value", pi, value);
+}
+
 void oj_set_compat_callbacks(ParseInfo pi) {
     oj_set_strict_callbacks(pi);
-    pi->start_hash        = start_hash;
-    pi->end_hash          = end_hash;
-    pi->hash_set_cstr     = hash_set_cstr;
-    pi->hash_set_num      = hash_set_num;
-    pi->hash_set_value    = hash_set_value;
-    pi->add_num           = add_num;
-    pi->add_cstr          = add_cstr;
-    pi->array_append_cstr = array_append_cstr;
-    pi->start_array       = start_array;
-    pi->array_append_num  = array_append_num;
+    pi->start_hash         = start_hash;
+    pi->end_hash           = end_hash;
+    pi->hash_set_cstr      = hash_set_cstr;
+    pi->hash_set_num       = hash_set_num;
+    pi->hash_set_value     = hash_set_value;
+    pi->add_num            = add_num;
+    pi->add_cstr           = add_cstr;
+    pi->array_append_cstr  = array_append_cstr;
+    pi->array_append_value = array_append_value;
+    pi->start_array        = start_array;
+    pi->array_append_num   = array_append_num;
 }
 
 VALUE

data/ext/oj/custom.c

@@ -492,6 +492,7 @@ static VALUE dump_common(VALUE obj, int depth, Out out) {
             rs = rb_funcall2(obj, oj_to_json_id, out->argc, out->argv);
         }
         TRACE(out->opts->trace, "to_json", obj, depth + 1, TraceRubyOut);
+        StringValue(rs);
         s   = RSTRING_PTR(rs);
         len = RSTRING_LEN(rs);
 
@@ -565,7 +566,7 @@ static int dump_attr_cb(ID key, VALUE value, VALUE ov) {
     } else if (Yes == out->opts->ignore_under && '@' == *attr && '_' == attr[1]) {
         return ST_CONTINUE;
     }
-    if (0 == strcmp("bt", attr) || 0 == strcmp("mesg", attr)) {
+    if ('@' != *attr && (0 == strcmp("bt", attr) || 0 == strcmp("mesg", attr) || 0 == strcmp("bt_locations", attr))) {
         return ST_CONTINUE;
     }
     assure_size(out, size);
@@ -707,6 +708,7 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
         cnt--;
         for (i = 0; i <= cnt; i++) {
             if (out->opts->dump_opts.use) {
+                assure_size(out, size);
                 if (0 < out->opts->dump_opts.array_size) {
                     APPEND_CHARS(out->cur, out->opts->dump_opts.array_nl, out->opts->dump_opts.array_size);
                 }
@@ -724,7 +726,7 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
                 *out->cur++ = ',';
             }
         }
-        size = depth * out->indent + 1;
+        size = indent_len(out, depth, out->opts->dump_opts.array_size) + 1;
         assure_size(out, size);
         if (out->opts->dump_opts.use) {
             if (0 < out->opts->dump_opts.array_size) {
@@ -816,6 +818,18 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
             oj_dump_custom_val(v, d3, out, true);
             *out->cur++ = ',';
         }
+        if (2 == cnt && rb_obj_is_kind_of(obj, rb_cRange)) {
+            VALUE beg;
+            VALUE end;
+            int   excl;
+
+            rb_range_values(obj, &beg, &end, &excl);
+            assure_size(out, size + 7);
+            fill_indent(out, d3);
+            APPEND_CHARS(out->cur, "\"excl\":", 7);
+            oj_dump_custom_val(excl ? Qtrue : Qfalse, d3, out, true);
+            *out->cur++ = ',';
+        }
         out->cur--;
         *out->cur++ = '}';
         *out->cur   = '\0';
@@ -904,6 +918,9 @@ static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, c
     if (Qundef == kval->key_val && Yes == pi->options.create_ok && NULL != pi->options.create_id &&
         *pi->options.create_id == *key && (size_t)pi->options.create_id_len == klen &&
         0 == strncmp(pi->options.create_id, key, klen)) {
+        if (oj_is_backtrace_name(str, len)) {
+            return;
+        }
         parent->clas = oj_name2class(pi, str, len, false, rb_eArgError);
         if (2 == klen && '^' == *key && 'o' == key[1]) {
             if (Qundef != parent->clas) {
@@ -1014,7 +1031,7 @@ static void array_append_num(ParseInfo pi, NumInfo ni) {
     Val            parent = stack_peek(&pi->stack);
     volatile VALUE rval   = oj_num_as_value(ni);
 
-    rb_ary_push(parent->val, rval);
+    oj_compat_array_append(parent->val, rval);
     TRACE_PARSE_CALL(pi->options.trace, "append_number", pi, rval);
 }
 
@@ -1025,16 +1042,32 @@ static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const c
         VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, len);
 
         if (Qnil != clas) {
-            rb_ary_push(stack_peek(&pi->stack)->val, rb_funcall(clas, oj_json_create_id, 1, rstr));
+            oj_compat_array_append(stack_peek(&pi->stack)->val, rb_funcall(clas, oj_json_create_id, 1, rstr));
             return;
         }
     }
-    rb_ary_push(stack_peek(&pi->stack)->val, rstr);
+    oj_compat_array_append(stack_peek(&pi->stack)->val, rstr);
     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;