oj 3.17.3 → 3.17.6

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,43 @@ 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 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;
+        // 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;
+        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));
+    }
 
     return TypedData_Wrap_Struct(encoder_class, &oj_encoder_type, e);
 }
@@ -765,7 +887,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 +944,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 +975,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 +1084,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
@@ -1051,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"));
 
@@ -1079,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;
 }
 
@@ -1230,11 +1367,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 +1389,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 +1419,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 +1517,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);

data/ext/oj/reader.c

@@ -88,8 +88,8 @@ void oj_reader_init(Reader reader, VALUE io, int fd, bool to_s) {
 }
 
 int oj_reader_read(Reader reader) {
-    int    err;
-    size_t shift = 0;
+    int       err;
+    ptrdiff_t shift = 0;
 
     if (0 == reader->read_func) {
         return -1;
@@ -164,8 +164,14 @@ static VALUE partial_io_cb(VALUE rbuf) {
     }
     str = StringValuePtr(rstr);
     cnt = RSTRING_LEN(rstr);
-    strcpy(reader->tail, str);
-    reader->read_end = reader->tail + cnt;
+    if (cnt > (size_t)(reader->end - reader->tail)) {
+        // A misbehaving IO returned more than the requested number of bytes.
+        // Copying it in with strcpy() would overflow the reader buffer.
+        rb_raise(rb_eIOError, "read returned more than the requested number of bytes");
+    }
+    memcpy(reader->tail, str, cnt);
+    reader->tail[cnt] = '\0';
+    reader->read_end  = reader->tail + cnt;
 
     return Qtrue;
 }
@@ -184,8 +190,14 @@ static VALUE io_cb(VALUE rbuf) {
     }
     str = StringValuePtr(rstr);
     cnt = RSTRING_LEN(rstr);
-    strcpy(reader->tail, str);
-    reader->read_end = reader->tail + cnt;
+    if (cnt > (size_t)(reader->end - reader->tail)) {
+        // A misbehaving IO returned more than the requested number of bytes.
+        // Copying it in with strcpy() would overflow the reader buffer.
+        rb_raise(rb_eIOError, "read returned more than the requested number of bytes");
+    }
+    memcpy(reader->tail, str, cnt);
+    reader->tail[cnt] = '\0';
+    reader->read_end  = reader->tail + cnt;
 
     return Qtrue;
 }

data/ext/oj/resolve.c

@@ -19,6 +19,9 @@ inline static VALUE resolve_classname(VALUE mod, const char *classname, int auto
 
     if (rb_const_defined_at(mod, ci)) {
         clas = rb_const_get_at(mod, ci);
+        if (!RB_TYPE_P(clas, T_CLASS) && !RB_TYPE_P(clas, T_MODULE)) {
+            clas = Qundef;
+        }
     } else if (auto_define) {
         clas = rb_define_class_under(mod, classname, oj_bag_class);
     } else {
@@ -32,7 +35,8 @@ static VALUE resolve_classpath(ParseInfo pi, const char *name, size_t len, int a
     VALUE       clas;
     char       *end = class_name + sizeof(class_name) - 1;
     char       *s;
-    const char *n = name;
+    const char *n    = name;
+    size_t      nlen = len;
 
     clas = rb_cObject;
     for (s = class_name; 0 < len; n++, len--) {
@@ -55,7 +59,12 @@ static VALUE resolve_classpath(ParseInfo pi, const char *name, size_t len, int a
     }
     *s = '\0';
     if (Qundef == (clas = resolve_classname(clas, class_name, auto_define))) {
-        oj_set_error_at(pi, error_class, __FILE__, __LINE__, "class %s is not defined", name);
+        if (sizeof(class_name) <= nlen) {
+            nlen = sizeof(class_name) - 1;
+        }
+        memcpy(class_name, name, nlen);
+        class_name[nlen] = '\0';
+        oj_set_error_at(pi, error_class, __FILE__, __LINE__, "class '%s' is not defined", class_name);
         if (Qnil != error_class) {
             pi->err_class = error_class;
         }

data/ext/oj/rxclass.c

@@ -142,3 +142,19 @@ void oj_rxclass_copy(RxClass src, RxClass dest) {
         }
     }
 }
+
+// Add the Ruby objects in the chain to an array. The regexps and the classes
+// can be referenced from nowhere else, as with a default match_string option,
+// and are collected unless something holds onto them.
+void oj_rxclass_keep(RxClass rc, VALUE keep) {
+    RxC rxc;
+
+    for (rxc = rc->head; NULL != rxc; rxc = rxc->next) {
+        if (Qnil != rxc->rrx) {
+            rb_ary_push(keep, rxc->rrx);
+        }
+        if (Qnil != rxc->clas) {
+            rb_ary_push(keep, rxc->clas);
+        }
+    }
+}

data/ext/oj/rxclass.h

@@ -22,5 +22,6 @@ extern int   oj_rxclass_append(RxClass rc, const char *expr, VALUE clas);
 extern VALUE oj_rxclass_match(RxClass rc, const char *str, size_t len);
 extern void  oj_rxclass_copy(RxClass src, RxClass dest);
 extern void  oj_rxclass_rappend(RxClass rc, VALUE rx, VALUE clas);
+extern void  oj_rxclass_keep(RxClass rc, VALUE keep);
 
 #endif /* OJ_RXCLASS_H */