oj 3.17.3 → 3.17.5

data/ext/oj/parser.c

@@ -5,6 +5,7 @@
 #include <fcntl.h>
 
 #include "oj.h"
+#include "simd.h"
 
 #define DEBUG 0
 
@@ -594,9 +595,64 @@ static void big_change(ojParser p) {
     }
 }
 
-static void parse(ojParser p, const byte *json, bool more) {
+// Scan forward over string content, returning the first byte that is not
+// STR_OK in string_map. This is a pure drop-in for the scalar loop
+//
+//     for (; STR_OK == string_map[*b]; b++) {}
+//
+// and must return the exact same stop position. The stop set (bytes whose
+// string_map class is not 'R'/STR_OK) is:
+//
+//     * control bytes  0x00..0x1F  (class '.', also stops at the NUL terminator)
+//     * the quote      0x22 '"'    (class 'z')
+//     * the backslash  0x5C '\'    (class 'A')
+//     * every high byte 0x80..0xFF (UTF-8 lead/continuation, classes M/P/Q/'.')
+//
+// Note this differs from parse.c's string_scan_neon, which stops only on
+// \0 \\ " -- parser.c hands multi-byte UTF-8 to its state machine, so the
+// scanner must stop on the high bytes too. The predictor below is derived from
+// string_map, not copied from parse.c.
+//
+// The NEON path only loads a full 16-byte vector when [b, b+16) stays within
+// [., end), so it never reads past the string's allocation; the sub-16-byte
+// tail (and the whole scan on non-NEON builds) uses the scalar loop, which
+// stops naturally at the guaranteed NUL terminator.
+static inline const byte *oj_scan_str_simd(const byte *b, const byte *end) {
+#ifdef HAVE_SIMD_NEON
+    if (SIMD_NEON == SIMD_Impl) {
+        const uint8x16_t quote  = vdupq_n_u8('"');
+        const uint8x16_t bslash = vdupq_n_u8('\\');
+        const uint8x16_t space  = vdupq_n_u8(0x20);
+        const uint8x16_t high   = vdupq_n_u8(0x80);
+
+        while (b + sizeof(uint8x16_t) <= end) {
+            const uint8x16_t chunk = vld1q_u8((const uint8_t *)b);
+            // special lane == 0xFF for any byte that stops the scan.
+            const uint8x16_t special = vorrq_u8(vorrq_u8(vceqq_u8(chunk, quote), vceqq_u8(chunk, bslash)),
+                                                vorrq_u8(vcltq_u8(chunk, space), vcgeq_u8(chunk, high)));
+            // Reduce to a 64-bit mask with 4 bits per lane (same idiom as
+            // parse.c's string_scan_neon) and locate the first set lane.
+            const uint8x8_t res  = vshrn_n_u16(vreinterpretq_u16_u8(special), 4);
+            uint64_t        mask = vget_lane_u64(vreinterpret_u64_u8(res), 0);
+            if (0 != mask) {
+                mask &= 0x8888888888888888ull;
+                return b + (OJ_CTZ64(mask) >> 2);
+            }
+            b += sizeof(uint8x16_t);
+        }
+    }
+#else
+    (void)end;
+#endif
+    for (; STR_OK == string_map[*b]; b++) {
+    }
+    return b;
+}
+
+static void parse(ojParser p, const byte *json, size_t len, bool more) {
     const byte *start;
-    const byte *b = json;
+    const byte *b   = json;
+    const byte *end = json + len;
     int         i;
 
     p->line = 1;
@@ -629,8 +685,7 @@ static void parse(ojParser p, const byte *json, bool more) {
             b++;
             p->key.tail = p->key.head;
             start       = b;
-            for (; STR_OK == string_map[*b]; b++) {
-            }
+            b           = oj_scan_str_simd(b, end);
             buf_append_string(&p->key, (const char *)start, b - start);
             if ('"' == *b) {
                 p->map = colon_map;
@@ -654,8 +709,7 @@ static void parse(ojParser p, const byte *json, bool more) {
             b++;
             start       = b;
             p->buf.tail = p->buf.head;
-            for (; STR_OK == string_map[*b]; b++) {
-            }
+            b           = oj_scan_str_simd(b, end);
             buf_append_string(&p->buf, (const char *)start, b - start);
             if ('"' == *b) {
                 p->cur = b - json;
@@ -838,10 +892,10 @@ static void parse(ojParser p, const byte *json, bool more) {
         case EXP_DIGIT:
             p->map = exp_map;
             for (; NUM_DIGIT == digit_map[*b]; b++) {
-                int16_t x = p->num.exp * 10 + (int16_t)(*b - '0');
+                int x = p->num.exp * 10 + (*b - '0');
 
                 if (x <= MAX_EXP) {
-                    p->num.exp = x;
+                    p->num.exp = (int16_t)x;
                 } else {
                     big_change(p);
                     p->map = big_exp_map;
@@ -905,8 +959,7 @@ static void parse(ojParser p, const byte *json, bool more) {
             break;
         case STR_OK:
             start = b;
-            for (; STR_OK == string_map[*b]; b++) {
-            }
+            b     = oj_scan_str_simd(b, end);
             if (':' == p->next_map[256]) {
                 buf_append_string(&p->key, (const char *)start, b - start);
             } else {
@@ -1229,7 +1282,8 @@ static int opt_cb(VALUE rkey, VALUE value, VALUE ptr) {
  * Oj::Parser.new(:usual, cache_keys: true).
  */
 static VALUE parser_new(int argc, VALUE *argv, VALUE self) {
-    ojParser p = OJ_R_ALLOC(struct _ojParser);
+    ojParser       p = OJ_R_ALLOC(struct _ojParser);
+    volatile VALUE pv;
 
 #if HAVE_RB_EXT_RACTOR_SAFE
     // This doesn't seem to do anything.
@@ -1239,6 +1293,10 @@ static VALUE parser_new(int argc, VALUE *argv, VALUE self) {
     buf_init(&p->key);
     buf_init(&p->buf);
     p->map = value_map;
+    // Until the parser is wrapped the GC can not free it, so the mode and the
+    // options, both of which raise on a value they do not take, are handled
+    // after the wrap.
+    pv = TypedData_Wrap_Struct(parser_class, &oj_parser_type, p);
 
     if (argc < 1) {
         oj_set_parser_validator(p);
@@ -1279,7 +1337,7 @@ static VALUE parser_new(int argc, VALUE *argv, VALUE self) {
             rb_hash_foreach(ropts, opt_cb, (VALUE)p);
         }
     }
-    return TypedData_Wrap_Struct(parser_class, &oj_parser_type, p);
+    return pv;
 }
 
 // Create a new parser without setting the delegate. The parser is
@@ -1419,7 +1477,7 @@ static VALUE parser_parse(VALUE self, VALUE json) {
 
     parser_reset(p);
     p->start(p);
-    parse(p, ptr, false);
+    parse(p, ptr, (size_t)RSTRING_LEN(json), false);
     validate_document_end(p);
 
     return p->result(p);
@@ -1440,7 +1498,7 @@ static VALUE load(VALUE self) {
     while (true) {
         rb_funcall(p->reader, oj_readpartial_id, 2, INT2NUM(16385), rbuf);
         if (0 < RSTRING_LEN(rbuf)) {
-            parse(p, (byte *)StringValuePtr(rbuf), true);
+            parse(p, (byte *)StringValuePtr(rbuf), (size_t)RSTRING_LEN(rbuf), true);
         }
         if (Qtrue == rb_funcall(p->reader, oj_eofq_id, 0)) {
             if (0 < p->depth) {
@@ -1471,6 +1529,39 @@ static VALUE parser_load(VALUE self, VALUE reader) {
     return p->result(p);
 }
 
+struct _fileParse {
+    ojParser    p;
+    const char *path;
+    int         fd;
+};
+
+static VALUE file_parse(VALUE x) {
+    struct _fileParse *fp = (struct _fileParse *)x;
+    byte               buf[16385];
+    size_t             size = sizeof(buf) - 1;
+    ssize_t            rsize;
+
+    while (true) {
+        if (0 > (rsize = read(fp->fd, buf, size))) {
+            rb_raise(rb_eIOError, "error reading from %s", fp->path);
+        }
+        if (0 == rsize) {
+            break;
+        }
+        buf[rsize] = '\0';
+        parse(fp->p, buf, rsize, true);
+    }
+    validate_document_end(fp->p);
+
+    return fp->p->result(fp->p);
+}
+
+static VALUE file_close(VALUE x) {
+    close(((struct _fileParse *)x)->fd);
+
+    return Qnil;
+}
+
 /* Document-method: file(filename)
  * call-seq: file(filename)
  *
@@ -1479,9 +1570,10 @@ static VALUE parser_load(VALUE self, VALUE reader) {
  * Returns the result according to the delegate of the parser.
  */
 static VALUE parser_file(VALUE self, VALUE filename) {
-    ojParser    p;
-    const char *path;
-    int         fd;
+    struct _fileParse fp;
+    ojParser          p;
+    const char       *path;
+    int               fd;
 
     TypedData_Get_Struct(self, struct _ojParser, &oj_parser_type, p);
 
@@ -1500,26 +1592,15 @@ static VALUE parser_file(VALUE self, VALUE filename) {
         // Use threaded version.
         // TBD only if has pthreads
         // TBD parse_large(p, fd);
+        close(fd);
         return p->result(p);
     }
 #endif
-    byte   buf[16385];
-    size_t size = sizeof(buf) - 1;
-    size_t rsize;
+    fp.p    = p;
+    fp.path = path;
+    fp.fd   = fd;
 
-    while (true) {
-        if (0 < (rsize = read(fd, buf, size))) {
-            buf[rsize] = '\0';
-            parse(p, buf, true);
-        }
-        if (rsize <= 0) {
-            if (0 != rsize) {
-                rb_raise(rb_eIOError, "error reading from %s", path);
-            }
-            break;
-        }
-    }
-    return p->result(p);
+    return rb_ensure(file_parse, (VALUE)&fp, file_close, (VALUE)&fp);
 }
 
 /* Document-method: just_one
@@ -1632,15 +1713,19 @@ static VALUE parser_safe(int argc, VALUE *argv, VALUE self) {
         options = rb_hash_new();
     }
 
-    ojParser p = OJ_R_ALLOC(struct _ojParser);
+    ojParser       p = OJ_R_ALLOC(struct _ojParser);
+    volatile VALUE pv;
 
     memset(p, 0, sizeof(struct _ojParser));
     buf_init(&p->key);
     buf_init(&p->buf);
     p->map = value_map;
+    // The limits raise on a value that is not an Integer, so the parser has to
+    // be wrapped before they are read.
+    pv = TypedData_Wrap_Struct(parser_class, &oj_parser_type, p);
     oj_set_parser_safe(p, options);
 
-    return TypedData_Wrap_Struct(parser_class, &oj_parser_type, p);
+    return pv;
 }
 
 /* Document-class: Oj::Parser

data/ext/oj/rails.c

@@ -16,6 +16,10 @@ typedef struct _encoder {
     struct _rOptTable ropts;
     struct _options   opts;
     VALUE             arg;
+    // Each is false while the matching member is unused and the global it
+    // shadows - ropts or oj_default_options - is read instead.
+    bool own_ropts;
+    bool own_opts;
 } *Encoder;
 
 bool oj_rails_hash_opt  = false;
@@ -83,6 +87,32 @@ static ROptTable copy_opts(ROptTable src, ROptTable dest) {
     return NULL;
 }
 
+// The table an encoder reads from. Until the encoder is asked to optimize or
+// deoptimize a class of its own it has no table and follows the global one.
+// NULL is how oj_rails_get_opt() is told to use the global table, so the NULL
+// has to reach it - handing it &e->ropts with an empty table instead would
+// quietly turn every optimization off for this encoder.
+static ROptTable encoder_ropts(Encoder e) {
+    return e->own_ropts ? &e->ropts : NULL;
+}
+
+// The options an encoder encodes with. See encoder_new() for why an encoder
+// built without options follows the defaults instead of holding a copy.
+static Options encoder_opts(Encoder e) {
+    return e->own_opts ? &e->opts : &oj_default_options;
+}
+
+// The table an encoder writes to. Copying the global table is deferred to here
+// because it is a 6KB allocation and ActiveSupport builds an encoder for every
+// encode call, while almost none of them ever optimize a class of their own.
+static ROptTable encoder_own_ropts(Encoder e) {
+    if (!e->own_ropts) {
+        copy_opts(&ropts, &e->ropts);
+        e->own_ropts = true;
+    }
+    return &e->ropts;
+}
+
 static int dump_attr_cb(ID key, VALUE value, VALUE ov) {
     Out         out   = (Out)ov;
     int         depth = out->depth;
@@ -341,11 +371,16 @@ typedef struct _strLen {
 } *StrLen;
 
 static void dump_actioncontroller_parameters(VALUE obj, int depth, Out out, bool as_ok) {
+    int    saved_argc = out->argc;
+    VALUE *saved_argv = out->argv;
+
     if (0 == parameters_id) {
         parameters_id = rb_intern("@parameters");
     }
     out->argc = 0;
     dump_rails_val(rb_ivar_get(obj, parameters_id), depth, out, true);
+    out->argc = saved_argc;
+    out->argv = saved_argv;
 }
 
 static StrLen columns_array(VALUE rcols, int *ccnt) {
@@ -375,7 +410,7 @@ static void dump_row(VALUE row, StrLen cols, int ccnt, int depth, Out out) {
 
     assure_size(out, 2);
     *out->cur++ = '{';
-    size        = depth * out->indent + 3;
+    size        = indent_len(out, d2, out->opts->dump_opts.array_size) + 3;
     for (i = 0; i < ccnt; i++, cols++) {
         assure_size(out, size);
         if (out->opts->dump_opts.use) {
@@ -398,7 +433,7 @@ static void dump_row(VALUE row, StrLen cols, int ccnt, int depth, Out out) {
             *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) {
@@ -423,7 +458,9 @@ static ID columns_id = 0;
 static void dump_activerecord_result(VALUE obj, int depth, Out out, bool as_ok) {
     volatile VALUE rows;
     StrLen         cols;
-    int            ccnt = 0;
+    int            ccnt       = 0;
+    int            saved_argc = out->argc;
+    VALUE         *saved_argv = out->argv;
     size_t         i;
     size_t         rcnt;
     size_t         size;
@@ -439,11 +476,7 @@ static void dump_activerecord_result(VALUE obj, int depth, Out out, bool as_ok)
     rcnt      = RARRAY_LEN(rows);
     assure_size(out, 2);
     *out->cur++ = '[';
-    if (out->opts->dump_opts.use) {
-        size = d2 * out->opts->dump_opts.indent_size + out->opts->dump_opts.array_size + 1;
-    } else {
-        size = d2 * out->indent + 2;
-    }
+    size        = indent_len(out, d2, out->opts->dump_opts.array_size) + 1;
     assure_size(out, 2);
     for (i = 0; i < rcnt; i++) {
         assure_size(out, size);
@@ -466,7 +499,7 @@ static void dump_activerecord_result(VALUE obj, int depth, Out out, bool as_ok)
         }
     }
     OJ_R_FREE(cols);
-    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) {
@@ -483,6 +516,8 @@ static void dump_activerecord_result(VALUE obj, int depth, Out out, bool as_ok)
         fill_indent(out, depth);
     }
     *out->cur++ = ']';
+    out->argc   = saved_argc;
+    out->argv   = saved_argv;
 }
 
 typedef struct _namedFunc {
@@ -491,8 +526,16 @@ typedef struct _namedFunc {
 } *NamedFunc;
 
 static void dump_as_string(VALUE obj, int depth, Out out, bool as_ok) {
+    int    saved_argc = out->argc;
+    VALUE *saved_argv = out->argv;
+
     if (oj_code_dump(oj_compat_codes, obj, depth, out)) {
-        out->argc = 0;
+        // oj_code_dump() writes the whole value and returns, so there is no
+        // subtree here to keep the options away from. Leave them for the next
+        // sibling. Restore instead of leaving them alone in case the encode
+        // consumed them.
+        out->argc = saved_argc;
+        out->argv = saved_argv;
         return;
     }
     oj_dump_obj_to_s(obj, out);
@@ -500,31 +543,53 @@ static void dump_as_string(VALUE obj, int depth, Out out, bool as_ok) {
 
 static void dump_as_json(VALUE obj, int depth, Out out, bool as_ok) {
     volatile VALUE ja;
+    bool           selected;
+    int            saved_argc = out->argc;
+    VALUE         *saved_argv = out->argv;
 
     TRACE(out->opts->trace, "as_json", obj, depth + 1, TraceRubyIn);
     // Some classes elect to not take an options argument so check the arity
     // of as_json.
     if (0 == rb_obj_method_arity(obj, oj_as_json_id)) {
-        ja = rb_funcall(obj, oj_as_json_id, 0);
+        ja       = rb_funcall(obj, oj_as_json_id, 0);
+        selected = false;  // as_json got no options so it did not do any :only/:except selection
     } else {
-        ja = rb_funcall2(obj, oj_as_json_id, out->argc, out->argv);
+        selected = (0 < out->argc);  // Rails handed the :only/:except options to as_json
+        ja       = rb_funcall2(obj, oj_as_json_id, out->argc, out->argv);
     }
     TRACE(out->opts->trace, "as_json", obj, depth + 1, TraceRubyOut);
 
     out->argc = 0;
-    if (ja == obj || !as_ok) {
-        // Once as_json is called it should never be called again on the same
-        // object with as_ok.
-        dump_rails_val(ja, depth, out, false);
-    } else {
-        int type = rb_type(ja);
+    // When as_json received the options it has already applied the Rails
+    // :only/:except selection at the attribute level (and kept the
+    // include_root_in_json wrapper and any :methods keys), so the Oj dump level
+    // :only/:except key filter must not be applied to the value it returned - a
+    // second pass would drop the wrapper (#1020) and the :methods keys (#1008).
+    // Suppress the filter only for this subtree (save and restore) so sibling
+    // keys outside the as_json result are still filtered. This is a flag on the
+    // dump state, not a change to out->opts: a StringWriter owns its options
+    // struct, so clearing only/except there would leak the buffers and kill the
+    // filter for every later push_value.
+    {
+        bool key_filter_off = out->key_filter_off;
 
-        if (T_HASH == type || T_ARRAY == type) {
-            dump_rails_val(ja, depth, out, true);
+        if (selected) {
+            out->key_filter_off = true;
+        }
+        if (ja == obj || !as_ok) {
+            // Once as_json is called it should never be called again on the same
+            // object with as_ok.
+            dump_rails_val(ja, depth, out, false);
         } else {
             dump_rails_val(ja, depth, out, true);
         }
+        out->key_filter_off = key_filter_off;
     }
+    // The options were consumed for this value only. Restore them so that the
+    // next sibling in a container is handed them too, the way ActiveSupport's
+    // Array#as_json and Hash#as_json pass them to every element.
+    out->argc = saved_argc;
+    out->argv = saved_argv;
 }
 
 static void dump_regexp(VALUE obj, int depth, Out out, bool as_ok) {
@@ -551,11 +616,16 @@ static VALUE activerecord_base = Qundef;
 static ID    attributes_id     = 0;
 
 static void dump_activerecord(VALUE obj, int depth, Out out, bool as_ok) {
+    int    saved_argc = out->argc;
+    VALUE *saved_argv = out->argv;
+
     if (0 == attributes_id) {
         attributes_id = rb_intern("@attributes");
     }
     out->argc = 0;
     dump_rails_val(rb_ivar_get(obj, attributes_id), depth, out, true);
+    out->argc = saved_argc;
+    out->argv = saved_argv;
 }
 
 static ROpt create_opt(ROptTable rot, VALUE clas) {
@@ -591,6 +661,12 @@ static ROpt create_opt(ROptTable rot, VALUE clas) {
     ro->clas = clas;
     ro->on   = true;
     ro->dump = dump_obj_attrs;
+    if (&ropts == rot) {
+        // Nothing marks the global table, so a class that lives only in it has
+        // to be a root. Encoders used to hold a copy of the table and mark it,
+        // which covered this by accident for as long as one was alive.
+        rb_gc_register_mark_object(clas);
+    }
     for (nf = dump_map; NULL != nf->name; nf++) {
         if (0 == strcmp(nf->name, classname)) {
             ro->dump = nf->func;
@@ -623,6 +699,9 @@ static void encoder_free(void *ptr) {
     if (NULL != ptr) {
         Encoder e = (Encoder)ptr;
 
+        if (e->own_opts) {
+            oj_options_release(&e->opts);
+        }
         if (NULL != e->ropts.table) {
             OJ_R_FREE(e->ropts.table);
         }
@@ -633,10 +712,25 @@ static void encoder_free(void *ptr) {
 static void encoder_mark(void *ptr) {
     if (NULL != ptr) {
         Encoder e = (Encoder)ptr;
+        int     i;
 
+        if (e->own_opts) {
+            oj_options_mark(&e->opts);
+        }
         if (Qnil != e->arg) {
             rb_gc_mark(e->arg);
         }
+        // The optimized classes in the encoder table are not reachable from
+        // anywhere else once optimize() is called on the encoder itself. An
+        // encoder that never optimized anything has no table to walk - the
+        // classes in the global table are roots registered by create_opt().
+        if (NULL != e->ropts.table) {
+            for (i = 0; i < e->ropts.len; i++) {
+                if (Qnil != e->ropts.table[i].clas) {
+                    rb_gc_mark(e->ropts.table[i].clas);
+                }
+            }
+        }
     }
 }
 
@@ -660,15 +754,35 @@ static const rb_data_type_t oj_encoder_type = {
 static VALUE encoder_new(int argc, VALUE *argv, VALUE self) {
     Encoder e = OJ_R_ALLOC(struct _encoder);
 
-    e->opts = oj_default_options;
-    copy_opts(&ropts, &e->ropts);
+    e->ropts.len   = 0;
+    e->ropts.alen  = 0;
+    e->ropts.table = NULL;
+    e->own_ropts   = false;
 
     if (1 <= argc && Qnil != *argv) {
         e->arg = *argv;
     } else {
         e->arg = rb_hash_new();
     }
-    oj_parse_options(e->arg, &e->opts);
+    // 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.
+    e->own_opts = T_HASH == rb_type(e->arg) && 0 < RHASH_SIZE(e->arg);
+    if (e->own_opts) {
+        e->opts = oj_default_options;
+        // Detach from the match_string regexps owned by the defaults before the
+        // options are parsed so that a :match_string option builds a chain of
+        // 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);
+        oj_options_take_ownership(&e->opts);
+    } else {
+        memset(&e->opts, 0, sizeof(e->opts));
+    }
 
     return TypedData_Wrap_Struct(encoder_class, &oj_encoder_type, e);
 }
@@ -765,7 +879,7 @@ static VALUE encoder_optimize(int argc, VALUE *argv, VALUE self) {
     Encoder e;
     TypedData_Get_Struct(self, struct _encoder, &oj_encoder_type, e);
 
-    optimize(argc, argv, &e->ropts, true);
+    optimize(argc, argv, encoder_own_ropts(e), true);
 
     return Qnil;
 }
@@ -822,7 +936,7 @@ static VALUE encoder_deoptimize(int argc, VALUE *argv, VALUE self) {
     Encoder e;
     TypedData_Get_Struct(self, struct _encoder, &oj_encoder_type, e);
 
-    optimize(argc, argv, &e->ropts, false);
+    optimize(argc, argv, encoder_own_ropts(e), false);
 
     return Qnil;
 }
@@ -853,7 +967,7 @@ static VALUE encoder_optimized(VALUE self, VALUE clas) {
     ROpt    ro;
 
     TypedData_Get_Struct(self, struct _encoder, &oj_encoder_type, e);
-    ro = oj_rails_get_opt(&e->ropts, clas);
+    ro = oj_rails_get_opt(encoder_ropts(e), clas);
 
     if (NULL == ro) {
         return Qfalse;
@@ -962,11 +1076,22 @@ static VALUE encoder_encode(VALUE self, VALUE obj) {
     TypedData_Get_Struct(self, struct _encoder, &oj_encoder_type, e);
 
     if (Qnil != e->arg) {
-        VALUE argv[1] = {e->arg};
-
-        return encode(obj, &e->ropts, &e->opts, 1, argv);
-    }
-    return encode(obj, &e->ropts, &e->opts, 0, NULL);
+        // as_json is allowed to write into the options hash it is handed, and
+        // the ActiveSupport suite has a test that does exactly that. Handing
+        // out the encoder's own hash lets one such call poison every later
+        // encode by the same encoder, which on ActiveSupport 8.1 is every
+        // option-less to_json in the process because json_encoder= caches one
+        // encoder and keeps it. Rails never exposes a hash it will reuse:
+        // JSONGemEncoder#encode passes options.dup, and only when there are
+        // options at all, so with none as_json writes into its own default.
+        // The copy is not frozen the way Rails 8.0 and later freeze theirs,
+        // because Oj hands as_json the hash even when it is empty and that is
+        // exactly the case Rails leaves writable.
+        VALUE argv[1] = {T_HASH == rb_type(e->arg) ? rb_hash_dup(e->arg) : e->arg};
+
+        return encode(obj, encoder_ropts(e), encoder_opts(e), 1, argv);
+    }
+    return encode(obj, encoder_ropts(e), encoder_opts(e), 0, NULL);
 }
 
 /* Document-method: encode
@@ -1230,11 +1355,7 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
     if (0 == cnt) {
         *out->cur++ = ']';
     } else {
-        if (out->opts->dump_opts.use) {
-            size = d2 * out->opts->dump_opts.indent_size + out->opts->dump_opts.array_size + 1;
-        } else {
-            size = d2 * out->indent + 2;
-        }
+        size = indent_len(out, d2, out->opts->dump_opts.array_size) + 1;
         assure_size(out, size * cnt);
         cnt--;
         for (i = 0; i <= cnt; i++) {
@@ -1256,7 +1377,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) {
@@ -1286,7 +1407,7 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
     if (out->omit_nil && Qnil == value) {
         return ST_CONTINUE;
     }
-    if (NULL != out->opts->dump_opts.only || NULL != out->opts->dump_opts.except) {
+    if (!out->key_filter_off && (NULL != out->opts->dump_opts.only || NULL != out->opts->dump_opts.except)) {
         if (oj_key_skip(key, out->opts->dump_opts.only, out->opts->dump_opts.except)) {
             return ST_CONTINUE;
         }
@@ -1384,10 +1505,15 @@ static void dump_hash(VALUE obj, int depth, Out out, bool as_ok) {
 }
 
 static void dump_obj(VALUE obj, int depth, Out out, bool as_ok) {
-    VALUE clas;
+    VALUE  clas;
+    int    saved_argc = out->argc;
+    VALUE *saved_argv = out->argv;
 
     if (oj_code_dump(oj_compat_codes, obj, depth, out)) {
-        out->argc = 0;
+        // Same as in dump_as_string(): the value is complete, so the options
+        // stay available for the next sibling.
+        out->argc = saved_argc;
+        out->argv = saved_argv;
         return;
     }
     clas = rb_obj_class(obj);