oj 3.17.4 → 3.17.5

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,7 +699,9 @@ static void encoder_free(void *ptr) {
     if (NULL != ptr) {
         Encoder e = (Encoder)ptr;
 
-        oj_options_release(&e->opts);
+        if (e->own_opts) {
+            oj_options_release(&e->opts);
+        }
         if (NULL != e->ropts.table) {
             OJ_R_FREE(e->ropts.table);
         }
@@ -636,15 +714,21 @@ static void encoder_mark(void *ptr) {
         Encoder e = (Encoder)ptr;
         int     i;
 
-        oj_options_mark(&e->opts);
+        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.
-        for (i = 0; i < e->ropts.len; i++) {
-            if (Qnil != e->ropts.table[i].clas) {
-                rb_gc_mark(e->ropts.table[i].clas);
+        // 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);
+                }
             }
         }
     }
@@ -670,21 +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;
-    // 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;
-    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);
-    oj_options_take_ownership(&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);
 }
@@ -781,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;
 }
@@ -838,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;
 }
@@ -869,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;
@@ -978,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
@@ -1246,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++) {
@@ -1272,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) {
@@ -1302,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;
         }
@@ -1400,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);

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;

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

@@ -5,7 +5,7 @@ static VALUE max_hash_size_sym, max_array_size_sym, max_depth_sym, max_total_ele
     max_array_size_error_class, max_depth_error_class, max_total_elements_error_class;
 
 static void check_object_size(safe_T safe) {
-    if (NIL_P(safe->max_hash_size)) {
+    if (!safe->max_hash_size_isset) {
         return;
     }
 
@@ -23,7 +23,7 @@ static void check_object_size(safe_T safe) {
 }
 
 static void check_array_size(safe_T safe) {
-    if (NIL_P(safe->max_array_size)) {
+    if (!safe->max_array_size_isset) {
         return;
     }
 
@@ -41,7 +41,7 @@ static void check_array_size(safe_T safe) {
 }
 
 static void check_max_depth(safe_T safe, ojParser p) {
-    if (NIL_P(safe->max_depth) || safe->max_depth >= (p->depth + 1)) {
+    if (!safe->max_depth_isset || safe->max_depth >= (p->depth + 1)) {
         return;
     }
 
@@ -55,7 +55,7 @@ static void check_max_total_elements(safe_T safe) {
     * null, true) are not counted. As a result, `current_elements_count`
     * always holds one less than the actual total.
     */
-    if (NIL_P(safe->max_total_elements) || safe->max_total_elements > safe->current_elements_count) {
+    if (!safe->max_total_elements_isset || safe->max_total_elements > safe->current_elements_count) {
         return;
     }
 
@@ -140,58 +140,72 @@ DEFINE_DELEGATED_OBJECT_FUNCTION(add_float);
 DEFINE_DELEGATED_OBJECT_FUNCTION(add_big);
 DEFINE_DELEGATED_OBJECT_FUNCTION(add_str);
 
+// The counting wrappers live in the parser function table, and the option
+// setters of the usual parser write to the same slots, so an option set after
+// the parser was built puts the unwrapped handler back and the limits stop
+// being applied for that kind of value.
+#define WRAP(funcs, slot, wrapper, saved) \
+    do {                                  \
+        if (wrapper != (funcs)->slot) {   \
+            safe->saved = (funcs)->slot;  \
+        }                                 \
+        (funcs)->slot = wrapper;          \
+    } while (0)
+
+static void wrap_funcs(ojParser p, safe_T safe) {
+    Funcs f = &p->funcs[ARRAY_FUN];
+
+    WRAP(f, open_object, safe_open_object, delegated_open_object_func);
+    WRAP(f, open_array, safe_open_array, delegated_open_array_func);
+    // The following overrides are done for counting objects
+    WRAP(f, add_null, safe_add_null, delegated_add_null_func);
+    WRAP(f, add_true, safe_add_true, delegated_add_true_func);
+    WRAP(f, add_false, safe_add_false, delegated_add_false_func);
+    WRAP(f, add_int, safe_add_int, delegated_add_int_func);
+    WRAP(f, add_float, safe_add_float, delegated_add_float_func);
+    WRAP(f, add_big, safe_add_big, delegated_add_big_func);
+    WRAP(f, add_str, safe_add_str, delegated_add_str_func);
+
+    f = &p->funcs[OBJECT_FUN];
+    WRAP(f, open_object, safe_open_object_key, delegated_open_object_key_func);
+    WRAP(f, open_array, safe_open_array_key, delegated_open_array_key_func);
+    WRAP(f, add_null, safe_add_null_key, delegated_add_null_key_func);
+    WRAP(f, add_true, safe_add_true_key, delegated_add_true_key_func);
+    WRAP(f, add_false, safe_add_false_key, delegated_add_false_key_func);
+    WRAP(f, add_int, safe_add_int_key, delegated_add_int_key_func);
+    WRAP(f, add_float, safe_add_float_key, delegated_add_float_key_func);
+    WRAP(f, add_big, safe_add_big_key, delegated_add_big_key_func);
+    WRAP(f, add_str, safe_add_str_key, delegated_add_str_key_func);
+}
+
+static VALUE safe_option(ojParser p, const char *key, VALUE value) {
+    safe_T safe = (safe_T)p->ctx;
+    VALUE  rv;
+
+    if (0 == strcmp("omit_null", key)) {
+        return safe->omit_null ? Qtrue : Qfalse;
+    }
+    rv = safe->delegated_option_func(p, key, value);
+    if (0 == strcmp("omit_null=", key)) {
+        safe->omit_null = (Qtrue == rv);
+    }
+    wrap_funcs(p, safe);
+
+    return rv;
+}
+
 void oj_init_safe_parser(ojParser p, safe_T safe, VALUE options) {
     // Safe parser inherits all members of usual parser
     oj_init_usual(p, &safe->usual);
 
     safe->delegated_start_func = p->start;
     p->start                   = safe_start;
+    safe->omit_null            = false;
 
-    Funcs f;
+    wrap_funcs(p, safe);
 
-    // Array parser functions
-    f                                = &p->funcs[ARRAY_FUN];
-    safe->delegated_open_object_func = f->open_object;
-    f->open_object                   = safe_open_object;
-    safe->delegated_open_array_func  = f->open_array;
-    f->open_array                    = safe_open_array;
-    // The following overrides are done for counting objects
-    safe->delegated_add_null_func  = f->add_null;
-    f->add_null                    = safe_add_null;
-    safe->delegated_add_true_func  = f->add_true;
-    f->add_true                    = safe_add_true;
-    safe->delegated_add_false_func = f->add_false;
-    f->add_false                   = safe_add_false;
-    safe->delegated_add_int_func   = f->add_int;
-    f->add_int                     = safe_add_int;
-    safe->delegated_add_float_func = f->add_float;
-    f->add_float                   = safe_add_float;
-    safe->delegated_add_big_func   = f->add_big;
-    f->add_big                     = safe_add_big;
-    safe->delegated_add_str_func   = f->add_str;
-    f->add_str                     = safe_add_str;
-
-    // Object parser functions
-    f                                    = &p->funcs[OBJECT_FUN];
-    safe->delegated_open_object_key_func = f->open_object;
-    f->open_object                       = safe_open_object_key;
-    safe->delegated_open_array_key_func  = f->open_array;
-    f->open_array                        = safe_open_array_key;
-    // The following overrides are done for counting objects
-    safe->delegated_add_null_key_func  = f->add_null;
-    f->add_null                        = safe_add_null_key;
-    safe->delegated_add_true_key_func  = f->add_true;
-    f->add_true                        = safe_add_true_key;
-    safe->delegated_add_false_key_func = f->add_false;
-    f->add_false                       = safe_add_false_key;
-    safe->delegated_add_int_key_func   = f->add_int;
-    f->add_int                         = safe_add_int_key;
-    safe->delegated_add_float_key_func = f->add_float;
-    f->add_float                       = safe_add_float_key;
-    safe->delegated_add_big_key_func   = f->add_big;
-    f->add_big                         = safe_add_big_key;
-    safe->delegated_add_str_key_func   = f->add_str;
-    f->add_str                         = safe_add_str_key;
+    safe->delegated_option_func = p->option;
+    p->option                   = safe_option;
 
     SET_CONFIG(max_hash_size);
     SET_CONFIG(max_array_size);

data/ext/oj/safe.h

@@ -8,11 +8,13 @@
         VALUE rb_##config_name = rb_hash_aref(options, config_name##_sym);             \
                                                                                        \
         if (RB_INTEGER_TYPE_P(rb_##config_name)) {                                     \
-            safe->config_name = NUM2LONG(rb_##config_name);                            \
+            safe->config_name         = NUM2LONG(rb_##config_name);                    \
+            safe->config_name##_isset = true;                                          \
         } else if (!NIL_P(rb_##config_name)) {                                         \
             rb_raise(rb_eArgError, "Incorrect value provided for `" #config_name "`"); \
         } else {                                                                       \
-            safe->config_name = Qnil;                                                  \
+            safe->config_name         = 0;                                             \
+            safe->config_name##_isset = false;                                         \
         }                                                                              \
     } while (0);
 
@@ -49,10 +51,20 @@ typedef struct _safe_S {
     long int max_total_elements;
     long int max_json_size_bytes;
 
+    bool max_hash_size_isset;
+    bool max_array_size_isset;
+    bool max_depth_isset;
+    bool max_total_elements_isset;
+
     long int current_hash_size;
     long int current_array_size;
     long int current_elements_count;
 
+    // omit_null is kept here because the usual parser reports it by looking at
+    // the add_null slot, which is one of the slots wrapped below.
+    bool omit_null;
+
+    VALUE (*delegated_option_func)(struct _ojParser *p, const char *key, VALUE value);
     void (*delegated_start_func)(struct _ojParser *p);
 
     // Array functions

data/ext/oj/saj.c

@@ -198,6 +198,12 @@ static void read_hash(ParseInfo pi, const char *key) {
     } else {
         while (1) {
             next_non_white(pi);
+            if ('"' != *pi->s) {
+                if (pi->has_error) {
+                    call_error("invalid format, expected a key", pi, __FILE__, __LINE__);
+                }
+                raise_error("invalid format, expected a key", pi->str, pi->s);
+            }
             ks = read_quoted_value(pi);
             next_non_white(pi);
             if (':' == *pi->s) {