json 2.10.1 → 2.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc08bd5e3c83c4e731d37e18b5a32f9bf0049d896c483f1beb96af96f2daad18
-  data.tar.gz: ff215943fdccc5a5ed3f7390719aa5c43a18664e19f86d94226ff14c154cc354
+  metadata.gz: 6415f9d9c30cadde9c59fe7b2c1b6279dfe990c84184572a9d8134d52e334780
+  data.tar.gz: e071f46d8d893429c83b2aac3e531d28c9c332b672e9ea024de9b1a8a935e4d0
 SHA512:
-  metadata.gz: e3bc85653be385e76842fa3f69671fccdc4235a32806f554cf8ec4a9ad697996be97d3aef52823b3c1f8839e1cd9a7893ab87360ca76d59b4ff704c75fcb655e
-  data.tar.gz: f2f09188afd38972e15e1c80c2c8c4efd14aee954d18ff83d4a6a993bd0f9d9c84362232c17abbc9bf3ffdfce062c79c75a6fccf124bdbd3345a202b76d50a26
+  metadata.gz: de12cb0f01d32d4003f251b63b5a4303a199548b0510dc1e4a4d29eb2cf5efc2cf1af2689bc5cd3bb3f5e86eb7b312b4bb011b718e9149050d5f2a46dd153290
+  data.tar.gz: 11b34643b6857bec8cca28d4fcb7f60072371227aac1b5e2f324f90f69e54f2463a8c1714ce5713e286318933433b8947d3ddf532178765f4be3375b9835eeea

data/CHANGES.md

@@ -1,5 +1,34 @@
 # Changes
 
+### 2025-04-24 (2.11.0)
+
+* Optimize Integer generation to be ~1.8x faster.
+* Optimize Float generation to be ~10x faster.
+* Fix `JSON.load` proc argument to substitute the parsed object with the return value.
+  This better match `Marshal.load` behavior.
+* Deprecate `JSON.fast_generate` (it's not any faster, so pointless).
+* Deprecate `JSON.load_default_options`.
+* Deprecate `JSON.unsafe_load_default_options`.
+* Deprecate `JSON.dump_default_options`.
+* Deprecate `Kernel#j`
+* Deprecate `Kernel#jj`
+* Remove outdated `JSON.iconv`.
+* Remove `Class#json_creatable?` monkey patch.
+* Remove deprecated `JSON.restore` method.
+* Remove deprecated `JSON.unparse` method.
+* Remove deprecated `JSON.fast_unparse` method.
+* Remove deprecated `JSON.pretty_unparse` method.
+* Remove deprecated `JSON::UnparserError` constant.
+* Remove outdated `JSON::MissingUnicodeSupport` constant.
+
+### 2025-03-12 (2.10.2)
+
+* Fix a potential crash in the C extension parser.
+* Raise a ParserError on all incomplete unicode escape sequence. This was the behavior until `2.10.0` unadvertently changed it.
+* Ensure document snippets that are included in parser errors don't include truncated multibyte characters.
+* Ensure parser error snippets are valid UTF-8.
+* Fix `JSON::GeneratorError#detailed_message` on Ruby < 3.2
+
 ### 2025-02-10 (2.10.1)
 
 * Fix a compatibility issue with `MultiJson.dump(obj, pretty: true)`: `no implicit conversion of false into Proc (TypeError)`.

data/ext/json/ext/fbuffer/fbuffer.h

@@ -3,6 +3,7 @@
 
 #include "ruby.h"
 #include "ruby/encoding.h"
+#include "../vendor/jeaiii-ltoa.h"
 
 /* shims */
 /* This is the fallback definition from Ruby 3.4 */
@@ -150,6 +151,13 @@ static void fbuffer_append(FBuffer *fb, const char *newstr, unsigned long len)
     }
 }
 
+/* Appends a character into a buffer. The buffer needs to have sufficient capacity, via fbuffer_inc_capa(...). */
+static inline void fbuffer_append_reserved_char(FBuffer *fb, char chr)
+{
+    fb->ptr[fb->len] = chr;
+    fb->len += 1;
+}
+
 static void fbuffer_append_str(FBuffer *fb, VALUE str)
 {
     const char *newstr = StringValuePtr(str);
@@ -167,25 +175,48 @@ static inline void fbuffer_append_char(FBuffer *fb, char newchr)
     fb->len++;
 }
 
-static long fltoa(long number, char *buf)
+static inline char *fbuffer_cursor(FBuffer *fb)
+{
+    return fb->ptr + fb->len;
+}
+
+static inline void fbuffer_advance_to(FBuffer *fb, char *end)
 {
-    static const char digits[] = "0123456789";
-    long sign = number;
-    char* tmp = buf;
-
-    if (sign < 0) number = -number;
-    do *tmp-- = digits[number % 10]; while (number /= 10);
-    if (sign < 0) *tmp-- = '-';
-    return buf - tmp;
+    fb->len = end - fb->ptr;
 }
 
-#define LONG_BUFFER_SIZE 20
+/*
+ * Appends the decimal string representation of \a number into the buffer.
+ */
 static void fbuffer_append_long(FBuffer *fb, long number)
 {
-    char buf[LONG_BUFFER_SIZE];
-    char *buffer_end = buf + LONG_BUFFER_SIZE;
-    long len = fltoa(number, buffer_end - 1);
-    fbuffer_append(fb, buffer_end - len, len);
+    /*
+     * The jeaiii_ultoa() function produces digits left-to-right,
+     * allowing us to write directly into the buffer, but we don't know
+     * the number of resulting characters.
+     *
+     * We do know, however, that the `number` argument is always in the
+     * range 0xc000000000000000 to 0x3fffffffffffffff, or, in decimal,
+     * -4611686018427387904 to 4611686018427387903. The max number of chars
+     * generated is therefore 20 (including a potential sign character).
+     */
+
+    static const int MAX_CHARS_FOR_LONG = 20;
+
+    fbuffer_inc_capa(fb, MAX_CHARS_FOR_LONG);
+
+    if (number < 0) {
+        fbuffer_append_reserved_char(fb, '-');
+
+        /*
+         * Since number is always > LONG_MIN, `-number` will not overflow
+         * and is always the positive abs() value.
+         */
+        number = -number;
+    }
+
+    char *end = jeaiii_ultoa(fbuffer_cursor(fb), number);
+    fbuffer_advance_to(fb, end);
 }
 
 static VALUE fbuffer_finalize(FBuffer *fb)

data/ext/json/ext/generator/generator.c

@@ -1,5 +1,6 @@
 #include "ruby.h"
 #include "../fbuffer/fbuffer.h"
+#include "../vendor/fpconv.c"
 
 #include <math.h>
 #include <ctype.h>
@@ -1054,8 +1055,9 @@ static void generate_json_float(FBuffer *buffer, struct generate_json_data *data
 {
     double value = RFLOAT_VALUE(obj);
     char allow_nan = state->allow_nan;
-    if (!allow_nan) {
-        if (isinf(value) || isnan(value)) {
+    if (isinf(value) || isnan(value)) {
+        /* for NaN and Infinity values we either raise an error or rely on Float#to_s. */
+        if (!allow_nan) {
             if (state->strict && state->as_json) {
                 VALUE casted_obj = rb_proc_call_with_block(state->as_json, 1, &obj, Qnil);
                 if (casted_obj != obj) {
@@ -1067,8 +1069,24 @@ static void generate_json_float(FBuffer *buffer, struct generate_json_data *data
             }
             raise_generator_error(obj, "%"PRIsVALUE" not allowed in JSON", rb_funcall(obj, i_to_s, 0));
         }
+
+        VALUE tmp = rb_funcall(obj, i_to_s, 0);
+        fbuffer_append_str(buffer, tmp);
+        return;
     }
-    fbuffer_append_str(buffer, rb_funcall(obj, i_to_s, 0));
+
+    /* This implementation writes directly into the buffer. We reserve
+     * the 24 characters that fpconv_dtoa states as its maximum, plus
+     * 2 more characters for the potential ".0" suffix.
+     */
+    fbuffer_inc_capa(buffer, 26);
+    char* d = buffer->ptr + buffer->len;
+    int len = fpconv_dtoa(value, d);
+
+    /* fpconv_dtoa converts a float to its shortest string representation,
+     * but it adds a ".0" if this is a plain integer.
+     */
+    buffer->len += len;
 }
 
 static void generate_json_fragment(FBuffer *buffer, struct generate_json_data *data, JSON_Generator_State *state, VALUE obj)

data/ext/json/ext/parser/extconf.rb

@@ -4,7 +4,6 @@ require 'mkmf'
 have_func("rb_enc_interned_str", "ruby.h") # RUBY_VERSION >= 3.0
 have_func("rb_hash_new_capa", "ruby.h") # RUBY_VERSION >= 3.2
 have_func("rb_hash_bulk_insert", "ruby.h") # Missing on TruffleRuby
-have_func("rb_category_warn", "ruby.h") # Missing on TruffleRuby
 have_func("strnlen", "string.h") # Missing on Solaris 10
 
 append_cflags("-std=c99")

data/ext/json/ext/parser/parser.c

@@ -31,28 +31,15 @@ typedef unsigned char _Bool;
 static VALUE mJSON, eNestingError, Encoding_UTF_8;
 static VALUE CNaN, CInfinity, CMinusInfinity;
 
-static ID i_json_creatable_p, i_json_create, i_create_id,
-          i_chr, i_deep_const_get, i_match, i_aset, i_aref,
+static ID i_chr, i_aset, i_aref,
           i_leftshift, i_new, i_try_convert, i_uminus, i_encode;
 
 static VALUE sym_max_nesting, sym_allow_nan, sym_allow_trailing_comma, sym_symbolize_names, sym_freeze,
-             sym_create_additions, sym_create_id, sym_object_class, sym_array_class,
-             sym_decimal_class, sym_match_string;
+             sym_decimal_class, sym_on_load;
 
 static int binary_encindex;
 static int utf8_encindex;
 
-#ifdef HAVE_RB_CATEGORY_WARN
-# define json_deprecated(message) rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, message)
-#else
-# define json_deprecated(message) rb_warn(message)
-#endif
-
-static const char deprecated_create_additions_warning[] =
-    "JSON.load implicit support for `create_additions: true` is deprecated "
-    "and will be removed in 3.0, use JSON.unsafe_load or explicitly "
-    "pass `create_additions: true`";
-
 #ifndef HAVE_RB_HASH_BULK_INSERT
 // For TruffleRuby
 void
@@ -341,6 +328,44 @@ static void rvalue_stack_eagerly_release(VALUE handle)
     }
 }
 
+
+#ifndef HAVE_STRNLEN
+static size_t strnlen(const char *s, size_t maxlen)
+{
+    char *p;
+    return ((p = memchr(s, '\0', maxlen)) ? p - s : maxlen);
+}
+#endif
+
+#define PARSE_ERROR_FRAGMENT_LEN 32
+#ifdef RBIMPL_ATTR_NORETURN
+RBIMPL_ATTR_NORETURN()
+#endif
+static void raise_parse_error(const char *format, const char *start)
+{
+    unsigned char buffer[PARSE_ERROR_FRAGMENT_LEN + 1];
+
+    size_t len = start ? strnlen(start, PARSE_ERROR_FRAGMENT_LEN) : 0;
+    const char *ptr = start;
+
+    if (len == PARSE_ERROR_FRAGMENT_LEN) {
+        MEMCPY(buffer, start, char, PARSE_ERROR_FRAGMENT_LEN);
+
+        while (buffer[len - 1] >= 0x80 && buffer[len - 1] < 0xC0) { // Is continuation byte
+            len--;
+        }
+
+        if (buffer[len - 1] >= 0xC0) { // multibyte character start
+            len--;
+        }
+
+        buffer[len] = '\0';
+        ptr = (const char *)buffer;
+    }
+
+    rb_enc_raise(enc_utf8, rb_path2class("JSON::ParserError"), format, ptr);
+}
+
 /* unicode */
 
 static const signed char digit_values[256] = {
@@ -362,21 +387,19 @@ static const signed char digit_values[256] = {
 
 static uint32_t unescape_unicode(const unsigned char *p)
 {
-    const uint32_t replacement_char = 0xFFFD;
-
     signed char b;
     uint32_t result = 0;
     b = digit_values[p[0]];
-    if (b < 0) return replacement_char;
+    if (b < 0) raise_parse_error("incomplete unicode character escape sequence at '%s'", (char *)p - 2);
     result = (result << 4) | (unsigned char)b;
     b = digit_values[p[1]];
-    if (b < 0) return replacement_char;
+    if (b < 0) raise_parse_error("incomplete unicode character escape sequence at '%s'", (char *)p - 2);
     result = (result << 4) | (unsigned char)b;
     b = digit_values[p[2]];
-    if (b < 0) return replacement_char;
+    if (b < 0) raise_parse_error("incomplete unicode character escape sequence at '%s'", (char *)p - 2);
     result = (result << 4) | (unsigned char)b;
     b = digit_values[p[3]];
-    if (b < 0) return replacement_char;
+    if (b < 0) raise_parse_error("incomplete unicode character escape sequence at '%s'", (char *)p - 2);
     result = (result << 4) | (unsigned char)b;
     return result;
 }
@@ -408,20 +431,15 @@ static int convert_UTF32_to_UTF8(char *buf, uint32_t ch)
 }
 
 typedef struct JSON_ParserStruct {
-    VALUE create_id;
-    VALUE object_class;
-    VALUE array_class;
+    VALUE on_load_proc;
     VALUE decimal_class;
     ID decimal_method_id;
-    VALUE match_string;
     int max_nesting;
     bool allow_nan;
     bool allow_trailing_comma;
     bool parsing_name;
     bool symbolize_names;
     bool freeze;
-    bool create_additions;
-    bool deprecated_create_additions;
 } JSON_ParserConfig;
 
 typedef struct JSON_ParserStateStruct {
@@ -440,34 +458,6 @@ typedef struct JSON_ParserStateStruct {
 
 static const rb_data_type_t JSON_ParserConfig_type;
 
-#ifndef HAVE_STRNLEN
-static size_t strnlen(const char *s, size_t maxlen)
-{
-    char *p;
-    return ((p = memchr(s, '\0', maxlen)) ? p - s : maxlen);
-}
-#endif
-
-#define PARSE_ERROR_FRAGMENT_LEN 32
-#ifdef RBIMPL_ATTR_NORETURN
-RBIMPL_ATTR_NORETURN()
-#endif
-static void raise_parse_error(const char *format, const char *start)
-{
-    char buffer[PARSE_ERROR_FRAGMENT_LEN + 1];
-
-    size_t len = start ? strnlen(start, PARSE_ERROR_FRAGMENT_LEN) : 0;
-    const char *ptr = start;
-
-    if (len == PARSE_ERROR_FRAGMENT_LEN) {
-        MEMCPY(buffer, start, char, PARSE_ERROR_FRAGMENT_LEN);
-        buffer[PARSE_ERROR_FRAGMENT_LEN] = '\0';
-        ptr = buffer;
-    }
-
-    rb_enc_raise(enc_utf8, rb_path2class("JSON::ParserError"), format, ptr);
-}
-
 static const bool whitespace[256] = {
     [' '] = 1,
     ['\t'] = 1,
@@ -600,7 +590,7 @@ static VALUE json_string_unescape(JSON_ParserState *state, const char *string, c
     buffer = RSTRING_PTR(result);
     bufferStart = buffer;
 
-    while ((pe = memchr(pe, '\\', stringEnd - pe))) {
+    while (pe < stringEnd && (pe = memchr(pe, '\\', stringEnd - pe))) {
         unescape = (char *) "?";
         unescape_len = 1;
         if (pe > p) {
@@ -761,18 +751,7 @@ static VALUE json_decode_float(JSON_ParserConfig *config, const char *start, con
 
 static inline VALUE json_decode_array(JSON_ParserState *state, JSON_ParserConfig *config, long count)
 {
-    VALUE array;
-    if (RB_UNLIKELY(config->array_class)) {
-        array = rb_class_new_instance(0, 0, config->array_class);
-        VALUE *items = rvalue_stack_peek(state->stack, count);
-        long index;
-        for (index = 0; index < count; index++) {
-            rb_funcall(array, i_leftshift, 1, items[index]);
-        }
-    } else {
-        array = rb_ary_new_from_values(count, rvalue_stack_peek(state->stack, count));
-    }
-
+    VALUE array = rb_ary_new_from_values(count, rvalue_stack_peek(state->stack, count));
     rvalue_stack_pop(state->stack, count);
 
     if (config->freeze) {
@@ -784,41 +763,11 @@ static inline VALUE json_decode_array(JSON_ParserState *state, JSON_ParserConfig
 
 static inline VALUE json_decode_object(JSON_ParserState *state, JSON_ParserConfig *config, long count)
 {
-    VALUE object;
-    if (RB_UNLIKELY(config->object_class)) {
-        object = rb_class_new_instance(0, 0, config->object_class);
-        long index = 0;
-        VALUE *items = rvalue_stack_peek(state->stack, count);
-        while (index < count) {
-            VALUE name = items[index++];
-            VALUE value = items[index++];
-            rb_funcall(object, i_aset, 2, name, value);
-        }
-    } else {
-        object = rb_hash_new_capa(count);
-        rb_hash_bulk_insert(count, rvalue_stack_peek(state->stack, count), object);
-    }
+    VALUE object = rb_hash_new_capa(count);
+    rb_hash_bulk_insert(count, rvalue_stack_peek(state->stack, count), object);
 
     rvalue_stack_pop(state->stack, count);
 
-    if (RB_UNLIKELY(config->create_additions)) {
-        VALUE klassname;
-        if (config->object_class) {
-            klassname = rb_funcall(object, i_aref, 1, config->create_id);
-        } else {
-            klassname = rb_hash_aref(object, config->create_id);
-        }
-        if (!NIL_P(klassname)) {
-            VALUE klass = rb_funcall(mJSON, i_deep_const_get, 1, klassname);
-            if (RTEST(rb_funcall(klass, i_json_creatable_p, 0))) {
-                if (config->deprecated_create_additions) {
-                    json_deprecated(deprecated_create_additions_warning);
-                }
-                object = rb_funcall(klass, i_json_create, 1, object);
-            }
-        }
-    }
-
     if (config->freeze) {
         RB_OBJ_FREEZE(object);
     }
@@ -826,17 +775,6 @@ static inline VALUE json_decode_object(JSON_ParserState *state, JSON_ParserConfi
     return object;
 }
 
-static int match_i(VALUE regexp, VALUE klass, VALUE memo)
-{
-    if (regexp == Qundef) return ST_STOP;
-    if (RTEST(rb_funcall(klass, i_json_creatable_p, 0)) &&
-      RTEST(rb_funcall(regexp, i_match, 1, rb_ary_entry(memo, 0)))) {
-        rb_ary_push(memo, klass);
-        return ST_STOP;
-    }
-    return ST_CONTINUE;
-}
-
 static inline VALUE json_decode_string(JSON_ParserState *state, JSON_ParserConfig *config, const char *start, const char *end, bool escaped, bool is_name)
 {
     VALUE string;
@@ -848,21 +786,17 @@ static inline VALUE json_decode_string(JSON_ParserState *state, JSON_ParserConfi
         string = json_string_fastpath(state, start, end, is_name, intern, symbolize);
     }
 
-    if (RB_UNLIKELY(config->create_additions && RTEST(config->match_string))) {
-          VALUE klass;
-          VALUE memo = rb_ary_new2(2);
-          rb_ary_push(memo, string);
-          rb_hash_foreach(config->match_string, match_i, memo);
-          klass = rb_ary_entry(memo, 1);
-          if (RTEST(klass)) {
-              string = rb_funcall(klass, i_json_create, 1, string);
-          }
-    }
-
     return string;
 }
 
-#define PUSH(result) rvalue_stack_push(state->stack, result, &state->stack_handle, &state->stack)
+static inline VALUE json_push_value(JSON_ParserState *state, JSON_ParserConfig *config, VALUE value)
+{
+    if (RB_UNLIKELY(config->on_load_proc)) {
+        value = rb_proc_call_with_block(config->on_load_proc, 1, &value, Qnil);
+    }
+    rvalue_stack_push(state->stack, value, &state->stack_handle, &state->stack);
+    return value;
+}
 
 static const bool string_scan[256] = {
     // ASCII Control Characters
@@ -889,7 +823,7 @@ static inline VALUE json_parse_string(JSON_ParserState *state, JSON_ParserConfig
                 case '"': {
                     VALUE string = json_decode_string(state, config, start, state->cursor, escaped, is_name);
                     state->cursor++;
-                    return PUSH(string);
+                    return json_push_value(state, config, string);
                 }
                 case '\\': {
                     state->cursor++;
@@ -923,7 +857,7 @@ static VALUE json_parse_any(JSON_ParserState *state, JSON_ParserConfig *config)
         case 'n':
             if ((state->end - state->cursor >= 4) && (memcmp(state->cursor, "null", 4) == 0)) {
                 state->cursor += 4;
-                return PUSH(Qnil);
+                return json_push_value(state, config, Qnil);
             }
 
             raise_parse_error("unexpected token at '%s'", state->cursor);
@@ -931,7 +865,7 @@ static VALUE json_parse_any(JSON_ParserState *state, JSON_ParserConfig *config)
         case 't':
             if ((state->end - state->cursor >= 4) && (memcmp(state->cursor, "true", 4) == 0)) {
                 state->cursor += 4;
-                return PUSH(Qtrue);
+                return json_push_value(state, config, Qtrue);
             }
 
             raise_parse_error("unexpected token at '%s'", state->cursor);
@@ -940,7 +874,7 @@ static VALUE json_parse_any(JSON_ParserState *state, JSON_ParserConfig *config)
             // Note: memcmp with a small power of two compile to an integer comparison
             if ((state->end - state->cursor >= 5) && (memcmp(state->cursor + 1, "alse", 4) == 0)) {
                 state->cursor += 5;
-                return PUSH(Qfalse);
+                return json_push_value(state, config, Qfalse);
             }
 
             raise_parse_error("unexpected token at '%s'", state->cursor);
@@ -949,7 +883,7 @@ static VALUE json_parse_any(JSON_ParserState *state, JSON_ParserConfig *config)
             // Note: memcmp with a small power of two compile to an integer comparison
             if (config->allow_nan && (state->end - state->cursor >= 3) && (memcmp(state->cursor + 1, "aN", 2) == 0)) {
                 state->cursor += 3;
-                return PUSH(CNaN);
+                return json_push_value(state, config, CNaN);
             }
 
             raise_parse_error("unexpected token at '%s'", state->cursor);
@@ -957,7 +891,7 @@ static VALUE json_parse_any(JSON_ParserState *state, JSON_ParserConfig *config)
         case 'I':
             if (config->allow_nan && (state->end - state->cursor >= 8) && (memcmp(state->cursor, "Infinity", 8) == 0)) {
                 state->cursor += 8;
-                return PUSH(CInfinity);
+                return json_push_value(state, config, CInfinity);
             }
 
             raise_parse_error("unexpected token at '%s'", state->cursor);
@@ -967,7 +901,7 @@ static VALUE json_parse_any(JSON_ParserState *state, JSON_ParserConfig *config)
             if ((state->end - state->cursor >= 9) && (memcmp(state->cursor + 1, "Infinity", 8) == 0)) {
                 if (config->allow_nan) {
                     state->cursor += 9;
-                    return PUSH(CMinusInfinity);
+                    return json_push_value(state, config, CMinusInfinity);
                 } else {
                     raise_parse_error("unexpected token at '%s'", state->cursor);
                 }
@@ -1024,9 +958,9 @@ static VALUE json_parse_any(JSON_ParserState *state, JSON_ParserConfig *config)
             }
 
             if (integer) {
-                return PUSH(json_decode_integer(start, state->cursor));
+                return json_push_value(state, config, json_decode_integer(start, state->cursor));
             }
-            return PUSH(json_decode_float(config, start, state->cursor));
+            return json_push_value(state, config, json_decode_float(config, start, state->cursor));
         }
         case '"': {
             // %r{\A"[^"\\\t\n\x00]*(?:\\[bfnrtu\\/"][^"\\]*)*"}
@@ -1040,7 +974,7 @@ static VALUE json_parse_any(JSON_ParserState *state, JSON_ParserConfig *config)
 
             if ((state->cursor < state->end) && (*state->cursor == ']')) {
                 state->cursor++;
-                return PUSH(json_decode_array(state, config, 0));
+                return json_push_value(state, config, json_decode_array(state, config, 0));
             } else {
                 state->current_nesting++;
                 if (RB_UNLIKELY(config->max_nesting && (config->max_nesting < state->current_nesting))) {
@@ -1059,7 +993,7 @@ static VALUE json_parse_any(JSON_ParserState *state, JSON_ParserConfig *config)
                         long count = state->stack->head - stack_head;
                         state->current_nesting--;
                         state->in_array--;
-                        return PUSH(json_decode_array(state, config, count));
+                        return json_push_value(state, config, json_decode_array(state, config, count));
                     }
 
                     if (*state->cursor == ',') {
@@ -1086,7 +1020,7 @@ static VALUE json_parse_any(JSON_ParserState *state, JSON_ParserConfig *config)
 
             if ((state->cursor < state->end) && (*state->cursor == '}')) {
                 state->cursor++;
-                return PUSH(json_decode_object(state, config, 0));
+                return json_push_value(state, config, json_decode_object(state, config, 0));
             } else {
                 state->current_nesting++;
                 if (RB_UNLIKELY(config->max_nesting && (config->max_nesting < state->current_nesting))) {
@@ -1115,7 +1049,7 @@ static VALUE json_parse_any(JSON_ParserState *state, JSON_ParserConfig *config)
                         state->cursor++;
                         state->current_nesting--;
                         long count = state->stack->head - stack_head;
-                        return PUSH(json_decode_object(state, config, count));
+                        return json_push_value(state, config, json_decode_object(state, config, count));
                     }
 
                     if (*state->cursor == ',') {
@@ -1203,10 +1137,7 @@ static int parser_config_init_i(VALUE key, VALUE val, VALUE data)
     else if (key == sym_allow_trailing_comma) { config->allow_trailing_comma = RTEST(val); }
     else if (key == sym_symbolize_names)      { config->symbolize_names = RTEST(val); }
     else if (key == sym_freeze)               { config->freeze = RTEST(val); }
-    else if (key == sym_create_id)            { config->create_id = RTEST(val) ? val : Qfalse; }
-    else if (key == sym_object_class)         { config->object_class = RTEST(val) ? val : Qfalse; }
-    else if (key == sym_array_class)          { config->array_class = RTEST(val) ? val : Qfalse; }
-    else if (key == sym_match_string)         { config->match_string = RTEST(val) ? val : Qfalse; }
+    else if (key == sym_on_load)              { config->on_load_proc = RTEST(val) ? val : Qfalse; }
     else if (key == sym_decimal_class)        {
         if (RTEST(val)) {
             if (rb_respond_to(val, i_try_convert)) {
@@ -1236,15 +1167,6 @@ static int parser_config_init_i(VALUE key, VALUE val, VALUE data)
             }
         }
     }
-    else if (key == sym_create_additions)     {
-        if (NIL_P(val)) {
-            config->create_additions = true;
-            config->deprecated_create_additions = true;
-        } else {
-            config->create_additions = RTEST(val);
-            config->deprecated_create_additions = false;
-        }
-    }
 
     return ST_CONTINUE;
 }
@@ -1259,16 +1181,6 @@ static void parser_config_init(JSON_ParserConfig *config, VALUE opts)
             // We assume in most cases few keys are set so it's faster to go over
             // the provided keys than to check all possible keys.
             rb_hash_foreach(opts, parser_config_init_i, (VALUE)config);
-
-            if (config->symbolize_names && config->create_additions) {
-                rb_raise(rb_eArgError,
-                    "options :symbolize_names and :create_additions cannot be "
-                    " used in conjunction");
-            }
-
-            if (config->create_additions && !config->create_id) {
-                config->create_id = rb_funcall(mJSON, i_create_id, 0);
-            }
         }
 
     }
@@ -1293,15 +1205,6 @@ static void parser_config_init(JSON_ParserConfig *config, VALUE opts)
  *   (keys) in a JSON object. Otherwise strings are returned, which is
  *   also the default. It's not possible to use this option in
  *   conjunction with the *create_additions* option.
- * * *create_additions*: If set to false, the Parser doesn't create
- *   additions even if a matching class and create_id was found. This option
- *   defaults to false.
- * * *object_class*: Defaults to Hash. If another type is provided, it will be used
- *   instead of Hash to represent JSON objects. The type must respond to
- *   +new+ without arguments, and return an object that respond to +[]=+.
- * * *array_class*: Defaults to Array If another type is provided, it will be used
- *   instead of Hash to represent JSON arrays. The type must respond to
- *   +new+ without arguments, and return an object that respond to +<<+.
  * * *decimal_class*: Specifies which class to use instead of the default
  *    (Float) when parsing decimal numbers. This class must accept a single
  *    string argument in its constructor.
@@ -1312,11 +1215,7 @@ static VALUE cParserConfig_initialize(VALUE self, VALUE opts)
 
     parser_config_init(config, opts);
 
-    RB_OBJ_WRITTEN(self, Qundef, config->create_id);
-    RB_OBJ_WRITTEN(self, Qundef, config->object_class);
-    RB_OBJ_WRITTEN(self, Qundef, config->array_class);
     RB_OBJ_WRITTEN(self, Qundef, config->decimal_class);
-    RB_OBJ_WRITTEN(self, Qundef, config->match_string);
 
     return self;
 }
@@ -1379,11 +1278,8 @@ static VALUE cParser_m_parse(VALUE klass, VALUE Vsource, VALUE opts)
 static void JSON_ParserConfig_mark(void *ptr)
 {
     JSON_ParserConfig *config = ptr;
-    rb_gc_mark(config->create_id);
-    rb_gc_mark(config->object_class);
-    rb_gc_mark(config->array_class);
+    rb_gc_mark(config->on_load_proc);
     rb_gc_mark(config->decimal_class);
-    rb_gc_mark(config->match_string);
 }
 
 static void JSON_ParserConfig_free(void *ptr)
@@ -1451,19 +1347,10 @@ void Init_parser(void)
     sym_allow_trailing_comma = ID2SYM(rb_intern("allow_trailing_comma"));
     sym_symbolize_names = ID2SYM(rb_intern("symbolize_names"));
     sym_freeze = ID2SYM(rb_intern("freeze"));
-    sym_create_additions = ID2SYM(rb_intern("create_additions"));
-    sym_create_id = ID2SYM(rb_intern("create_id"));
-    sym_object_class = ID2SYM(rb_intern("object_class"));
-    sym_array_class = ID2SYM(rb_intern("array_class"));
+    sym_on_load = ID2SYM(rb_intern("on_load"));
     sym_decimal_class = ID2SYM(rb_intern("decimal_class"));
-    sym_match_string = ID2SYM(rb_intern("match_string"));
 
-    i_create_id = rb_intern("create_id");
-    i_json_creatable_p = rb_intern("json_creatable?");
-    i_json_create = rb_intern("json_create");
     i_chr = rb_intern("chr");
-    i_match = rb_intern("match");
-    i_deep_const_get = rb_intern("deep_const_get");
     i_aset = rb_intern("[]=");
     i_aref = rb_intern("[]");
     i_leftshift = rb_intern("<<");