json 3.0.1 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4963523aa43ad467929b9530b04f5c27a37dbbb1891186251d1495f3fac1f5ee
-  data.tar.gz: caf3f18bf24b587b0832f911b692f1e1149c1bfc5d14b5c5e1b255f6f95689f9
+  metadata.gz: f2c5d1d2dfae6ea305b69988b2f277305a0b52f02a7a047c2a5d0602a54546f8
+  data.tar.gz: 3840fd11930f94e94b1ddbe6fede6831662192b93c0e1e5bf8296c858e93cf4e
 SHA512:
-  metadata.gz: 78c8ac1a917008d3724b2a2e708d96c929de3924e4d7e1d85eb87e02a0e0a0c827bbe320464b8bb2ab8f6816ba0e5d48a8d57d3d5f00b15093aad8b9f12ce66b
-  data.tar.gz: '03867f4f7fef6bd2c14e5bfc1e426b710ad662807306c3475b63a6464e20ed10cb59646b1d6ff2b8b9b88ecb74150d7619133d8e0993c1b9666c7a7e6dd9315b'
+  metadata.gz: 26e58633051da64fee887463df8df3b11ec934557726e9affbd96c04115f393ca05e164e9b1bfbcaa73ba7431ce0951d48b1f6214ad05b9ef13ab98e160b9f65
+  data.tar.gz: 6b83a6ff45819906f284a4851cad7b33c214dcc2794d74aa5a8a27ef80b8ed0c34ca853957a444ef1188a92480a2eaa92ca188dcedef4cbf37c1ea271ea0d551

data/CHANGES.md

@@ -2,6 +2,19 @@
 
 ### Unreleased
 
+### 2026-10-13 (3.1.0)
+
+* Added `rfc8785` generator option to canonicalize the output. Replaces the `json-canonicalization` with numerous correctness fixes.
+* Use the `rb_len_t` type introduced in Ruby 4.1 to allow for proper 64bit support on LP64 platforms (Windows).
+* JRuby: parser errors now include the position (`line`, `column` and the message suffix) as well as `json_path`, matching the C extension.
+* Improved the accuracy of parser error's `line`, `column` and snipets in presence of multibyte characters.
+* Fix `JSON.load` to work correctly when provided a `Zlib::GzipReader` as IO source.
+* Reject non-ASCII BINARY strings during JSON generation. This was deprecated since a long time and scheduled to be removed for 3.0.
+
+### 2026-09-09 (3.0.2)
+
+* Fix `JSON.load_file` and `JSON.load_file!` to load on Ruby 2.7.0 through 2.7.2, which cannot parse a leading parameter before `...`.
+
 ### 2026-09-08 (3.0.1)
 
 * Restore the `limit` positional argument of `JSON.dump`.

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

@@ -169,6 +169,10 @@ static inline void fbuffer_append_reserved_char(FBuffer *fb, char chr)
 
 static void fbuffer_append_str(FBuffer *fb, VALUE str)
 {
+    if (RB_UNLIKELY(fb->io)) {
+        // Growing the buffer may flush it and invoke arbitrary Ruby code.
+        str = rb_str_new_frozen(str);
+    }
     const char *ptr;
     size_t len;
     RSTRING_GETMEM(str, ptr, len);

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

@@ -27,14 +27,16 @@ typedef struct JSON_Generator_StateStruct {
     bool ascii_only;
     bool script_safe;
     bool strict;
+    bool rfc8785;
     VALUE sort_keys;
 } JSON_Generator_State;
 
-static VALUE mJSON, cState, cFragment, eGeneratorError, eNestingError, Encoding_UTF_8, default_sort_keys_proc;
+static VALUE mJSON, cState, cFragment, eGeneratorError, eNestingError, Encoding_UTF_8, default_sort_keys_proc,
+             rfc8785_number_formatter_proc, rfc8785_sort_keys_proc;
 
 static ID i_to_s, i_to_json, i_new, i_encode;
 static VALUE sym_indent, sym_space, sym_space_before, sym_object_nl, sym_array_nl, sym_max_nesting, sym_allow_nan, sym_allow_duplicate_key,
-             sym_ascii_only, sym_depth, sym_buffer_initial_length, sym_script_safe, sym_strict, sym_as_json, sym_sort_keys;
+             sym_ascii_only, sym_depth, sym_buffer_initial_length, sym_script_safe, sym_strict, sym_as_json, sym_sort_keys, sym_rfc8785;
 
 
 #define GET_STATE_TO(self, state) \
@@ -73,7 +75,7 @@ static void generate_json_bignum(FBuffer *buffer, struct generate_json_data *dat
 static void generate_json_float(FBuffer *buffer, struct generate_json_data *data, VALUE obj);
 static void generate_json_fragment(FBuffer *buffer, struct generate_json_data *data, VALUE obj);
 
-static int usascii_encindex, utf8_encindex, binary_encindex;
+static int usascii_encindex, utf8_encindex;
 
 NORETURN(static void) raise_generator_error_str(VALUE invalid_object, VALUE str)
 {
@@ -768,6 +770,12 @@ static void vstate_spill(struct generate_json_data *data)
     RB_OBJ_WRITTEN(vstate, Qundef, state->sort_keys);
 }
 
+static inline VALUE json_to_s(VALUE obj)
+{
+    VALUE tmp = rb_funcall(obj, i_to_s, 0);
+    return StringValue(tmp);
+}
+
 static inline VALUE json_call_to_json(struct generate_json_data *data, VALUE obj)
 {
     if (RB_UNLIKELY(!data->vstate)) {
@@ -863,21 +871,12 @@ NOINLINE(static) VALUE convert_invalid_encoding(struct generate_json_data *data,
         }
     }
 
-    if (RB_ENCODING_GET_INLINED(str) == binary_encindex) {
-        VALUE utf8_string = rb_enc_associate_index(rb_str_dup(str), utf8_encindex);
-        switch (rb_enc_str_coderange(utf8_string)) {
-            case ENC_CODERANGE_7BIT:
-                return utf8_string;
-            case ENC_CODERANGE_VALID:
-                // For historical reason, we silently reinterpret binary strings as UTF-8 if it would work.
-                // TODO: Raise in 3.0.0
-                rb_warn("JSON.generate: UTF-8 string passed as BINARY, this will raise an encoding error in json 3.0");
-                return utf8_string;
-                break;
-        }
+    str = rb_rescue(encode_json_string_try, str, encode_json_string_rescue, str);
+    Check_Type(str, T_STRING);
+    if (!valid_json_string_p(str)) {
+        raise_generator_error(str, "source sequence is illegal/malformed utf-8");
     }
-
-    return rb_rescue(encode_json_string_try, str, encode_json_string_rescue, str);
+    return str;
 }
 
 ALWAYS_INLINE(static) VALUE ensure_valid_encoding(struct generate_json_data *data, VALUE str, bool as_json_called, bool is_key)
@@ -892,12 +891,17 @@ ALWAYS_INLINE(static) VALUE ensure_valid_encoding(struct generate_json_data *dat
 
 static void raw_generate_json_string(FBuffer *buffer, struct generate_json_data *data, VALUE obj)
 {
+    VALUE str = obj;
+    if (RB_UNLIKELY(buffer->io)) {
+        // IO writes can mutate the original string while we are reading it.
+        str = rb_str_new_frozen(str);
+    }
     fbuffer_append_char(buffer, '"');
 
-    long len;
+    rb_len_t len;
     search_state search;
     search.buffer = buffer;
-    RSTRING_GETMEM(obj, search.ptr, len);
+    RSTRING_GETMEM(str, search.ptr, len);
     search.cursor = search.ptr;
     search.end = search.ptr + len;
 
@@ -908,7 +912,7 @@ static void raw_generate_json_string(FBuffer *buffer, struct generate_json_data
     search.chunk_end = NULL;
 #endif /* HAVE_SIMD */
 
-    switch (json_str_coderange(obj)) {
+    switch (json_str_coderange(str)) {
         case ENC_CODERANGE_7BIT:
         case ENC_CODERANGE_VALID:
             if (RB_UNLIKELY(data->state->ascii_only)) {
@@ -924,6 +928,7 @@ static void raw_generate_json_string(FBuffer *buffer, struct generate_json_data
             break;
     }
     fbuffer_append_char(buffer, '"');
+    RB_GC_GUARD(str);
 }
 
 static void generate_json_string(FBuffer *buffer, struct generate_json_data *data, VALUE obj)
@@ -1037,16 +1042,19 @@ json_object_i(VALUE key, VALUE val, VALUE _arg)
 static inline long increase_depth(struct generate_json_data *data)
 {
     JSON_Generator_State *state = data->state;
-    long depth = ++data->depth;
-    if (RB_UNLIKELY(depth > state->max_nesting && state->max_nesting)) {
-        rb_raise(eNestingError, "nesting of %ld is too deep. Did you try to serialize objects with circular references?", --data->depth);
+    if (RB_UNLIKELY(data->depth >= state->max_nesting && state->max_nesting)) {
+        rb_raise(eNestingError, "nesting of %ld is too deep. Did you try to serialize objects with circular references?", data->depth + 1);
     }
-    return depth;
+    return ++data->depth;
 }
 
 static void generate_json_object(FBuffer *buffer, struct generate_json_data *data, VALUE obj)
 {
-    if (RB_UNLIKELY(data->state->sort_keys)) {
+    if (RB_UNLIKELY(data->state->rfc8785)) {
+        VALUE args[2] = {obj, data->state->strict ? data->state->as_json : Qnil};
+        obj = rb_proc_call_with_block(rfc8785_sort_keys_proc, 2, args, Qnil);
+        Check_Type(obj, T_HASH);
+    } else if (RB_UNLIKELY(data->state->sort_keys)) {
         obj = rb_proc_call_with_block(data->state->sort_keys, 1, &obj, Qnil);
         Check_Type(obj, T_HASH);
     }
@@ -1090,7 +1098,7 @@ static void generate_json_array(FBuffer *buffer, struct generate_json_data *data
 
     fbuffer_append_char(buffer, '[');
     if (RB_UNLIKELY(data->state->array_nl)) fbuffer_append_str(buffer, data->state->array_nl);
-    for (int i = 0; i < RARRAY_LEN(obj); i++) {
+    for (rb_len_t i = 0; i < RARRAY_LEN(obj); i++) {
         if (i > 0) {
             fbuffer_append_char(buffer, ',');
             if (RB_UNLIKELY(data->state->array_nl)) fbuffer_append_str(buffer, data->state->array_nl);
@@ -1118,9 +1126,7 @@ static void generate_json_fallback(FBuffer *buffer, struct generate_json_data *d
         Check_Type(tmp, T_STRING);
         fbuffer_append_str(buffer, tmp);
     } else {
-        tmp = rb_funcall(obj, i_to_s, 0);
-        Check_Type(tmp, T_STRING);
-        generate_json_string(buffer, data, tmp);
+        generate_json_string(buffer, data, json_to_s(obj));
     }
 }
 
@@ -1139,15 +1145,29 @@ static void generate_json_true(FBuffer *buffer, struct generate_json_data *data,
     fbuffer_append(buffer, "true", 4);
 }
 
+static void generate_json_rfc8785_number(FBuffer *buffer, VALUE obj)
+{
+    VALUE str = rb_proc_call_with_block(rfc8785_number_formatter_proc, 1, &obj, Qnil);
+    Check_Type(str, T_STRING);
+    fbuffer_append_str(buffer, str);
+}
+
 static void generate_json_fixnum(FBuffer *buffer, struct generate_json_data *data, VALUE obj)
 {
+    if (RB_UNLIKELY(data->state->rfc8785)) {
+        generate_json_rfc8785_number(buffer, obj);
+        return;
+    }
     fbuffer_append_long(buffer, FIX2LONG(obj));
 }
 
 static void generate_json_bignum(FBuffer *buffer, struct generate_json_data *data, VALUE obj)
 {
-    VALUE tmp = rb_funcall(obj, i_to_s, 0);
-    fbuffer_append_str(buffer, StringValue(tmp));
+    if (RB_UNLIKELY(data->state->rfc8785)) {
+        generate_json_rfc8785_number(buffer, obj);
+        return;
+    }
+    fbuffer_append_str(buffer, json_to_s(obj));
 }
 
 static void generate_json_float(FBuffer *buffer, struct generate_json_data *data, VALUE obj)
@@ -1166,11 +1186,15 @@ static void generate_json_float(FBuffer *buffer, struct generate_json_data *data
                     return;
                 }
             }
-            raise_generator_error(obj, "%"PRIsVALUE" not allowed in JSON", rb_funcall(obj, i_to_s, 0));
+            raise_generator_error(obj, "%"PRIsVALUE" not allowed in JSON", json_to_s(obj));
         }
 
-        VALUE tmp = rb_funcall(obj, i_to_s, 0);
-        fbuffer_append_str(buffer, tmp);
+        fbuffer_append_str(buffer, json_to_s(obj));
+        return;
+    }
+
+    if (RB_UNLIKELY(data->state->rfc8785)) {
+        generate_json_rfc8785_number(buffer, obj);
         return;
     }
 
@@ -1291,10 +1315,28 @@ static void generate_json_no_fallback(FBuffer *buffer, struct generate_json_data
     generate_json_general(buffer, data, obj, false);
 }
 
+static void validate_rfc8785(JSON_Generator_State *state)
+{
+    if (!state->rfc8785) return;
+
+    const char *option = state->indent ? "indent" :
+        state->space ? "space" :
+        state->space_before ? "space_before" :
+        state->object_nl ? "object_nl" :
+        state->array_nl ? "array_nl" :
+        state->ascii_only ? "ascii_only" :
+        state->script_safe ? "script_safe" :
+        state->allow_nan ? "allow_nan" : NULL;
+    if (option) {
+        rb_raise(rb_eArgError, "%s cannot be used with rfc8785", option);
+    }
+}
+
 static VALUE generate_json_try(VALUE d)
 {
     struct generate_json_data *data = (struct generate_json_data *)d;
 
+    validate_rfc8785(data->state);
     data->func(data->buffer, data, data->obj);
 
     return fbuffer_finalize(data->buffer);
@@ -1542,7 +1584,7 @@ static VALUE cState_array_nl_set(VALUE self, VALUE array_nl)
 /*
  * call-seq: as_json()
  *
- * This string is put at the end of a line that holds a JSON array.
+ * Returns the callback used to convert unsupported objects in strict mode.
  */
 static VALUE cState_as_json(VALUE self)
 {
@@ -1550,16 +1592,28 @@ static VALUE cState_as_json(VALUE self)
     return state->as_json;
 }
 
+static VALUE as_json_config(VALUE value)
+{
+    if (rb_obj_is_proc(value)) {
+        return value;
+    }
+    VALUE proc = rb_check_funcall(value, rb_intern("to_proc"), 0, NULL);
+    if (proc == Qundef || !rb_obj_is_proc(proc)) {
+        rb_raise(rb_eTypeError, "as_json must be a Proc");
+    }
+    return proc;
+}
+
 /*
  * call-seq: as_json=(as_json)
  *
- * This string is put at the end of a line that holds a JSON array.
+ * Sets the Proc used to convert unsupported objects in strict mode.
  */
 static VALUE cState_as_json_set(VALUE self, VALUE as_json)
 {
     rb_check_frozen(self);
     GET_STATE(self);
-    RB_OBJ_WRITE(self, &state->as_json, rb_convert_type(as_json, T_DATA, "Proc", "to_proc"));
+    RB_OBJ_WRITE(self, &state->as_json, as_json_config(as_json));
     return Qnil;
 }
 
@@ -1733,9 +1787,34 @@ static VALUE cState_set_default_sort_keys_proc(VALUE self, VALUE proc)
     if (!rb_obj_is_proc(proc)) {
         rb_raise(rb_eTypeError, "sort_key_proc must be a Proc");
     }
+    if (default_sort_keys_proc) {
+        rb_raise(rb_eArgError, "sort_key_proc can only be set once");
+    }
     return default_sort_keys_proc = proc;
 }
 
+static VALUE cState_set_rfc8785_number_formatter_proc(VALUE self, VALUE proc)
+{
+    if (!rb_obj_is_proc(proc)) {
+        rb_raise(rb_eTypeError, "rfc8785_number_formatter_proc must be a Proc");
+    }
+    if (rfc8785_number_formatter_proc) {
+        rb_raise(rb_eArgError, "rfc8785_number_formatter_proc can only be set once");
+    }
+    return rfc8785_number_formatter_proc = proc;
+}
+
+static VALUE cState_set_rfc8785_sort_keys_proc(VALUE self, VALUE proc)
+{
+    if (!rb_obj_is_proc(proc)) {
+        rb_raise(rb_eTypeError, "rfc8785_sort_keys_proc must be a Proc");
+    }
+    if (rfc8785_sort_keys_proc) {
+        rb_raise(rb_eArgError, "rfc8785_sort_keys_proc can only be set once");
+    }
+    return rfc8785_sort_keys_proc = proc;
+}
+
 static VALUE normalize_sort_keys(VALUE value)
 {
     if (rb_obj_is_proc(value)) {
@@ -1754,7 +1833,7 @@ static VALUE normalize_sort_keys(VALUE value)
  *
  * Get the value of sort_keys.
  */
-static VALUE cState_sort_keys_p(VALUE self)
+static VALUE cState_sort_keys(VALUE self)
 {
     GET_STATE(self);
     return state->sort_keys;
@@ -1774,7 +1853,33 @@ static VALUE cState_sort_keys_set(VALUE self, VALUE value)
     rb_check_frozen(self);
     GET_STATE(self);
     RB_OBJ_WRITE(self, &state->sort_keys, normalize_sort_keys(value));
-    return Qnil;
+    return state->sort_keys;
+}
+
+
+/*
+ * call-seq: rfc8785?
+ *
+ * Get whether RFC8785 (canonicalization) is enabled.
+ */
+static VALUE cState_rfc8785_p(VALUE self)
+{
+    GET_STATE(self);
+    return state->rfc8785 ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq: rfc8785=
+ *
+ * Sets whether RFC8785 (canonicalization) is enabled.
+ */
+
+static VALUE cState_rfc8785_set(VALUE self, VALUE value)
+{
+    rb_check_frozen(self);
+    GET_STATE(self);
+    state->rfc8785 = RTEST(value);
+    return state->rfc8785 ? Qtrue : Qfalse;
 }
 
 static VALUE cState_allow_duplicate_key_p(VALUE self)
@@ -1797,8 +1902,7 @@ static VALUE cState_depth(VALUE self)
 /*
  * call-seq: depth=(depth)
  *
- * This sets the maximum level of data structure nesting in the generated JSON
- * to the integer depth, max_nesting = 0 if no maximum should be checked.
+ * Sets the current depth of data structure nesting to the integer +depth+.
  */
 static VALUE cState_depth_set(VALUE self, VALUE depth)
 {
@@ -1875,8 +1979,9 @@ static int configure_state_i(VALUE key, VALUE val, VALUE _arg)
     else if (key == sym_script_safe)           { state->script_safe = RTEST(val); }
     else if (key == sym_strict)                { state->strict = RTEST(val); }
     else if (key == sym_allow_duplicate_key)   { state->allow_duplicate_key = RTEST(val); }
+    else if (key == sym_rfc8785)               { state->rfc8785 = RTEST(val); }
     else if (key == sym_as_json)               {
-        VALUE proc = RTEST(val) ? rb_convert_type(val, T_DATA, "Proc", "to_proc") : Qfalse;
+        VALUE proc = RTEST(val) ? as_json_config(val) : Qfalse;
         state->as_json_single_arg = proc && rb_proc_arity(proc) == 1;
         state_write_value(data, &state->as_json, proc);
     }
@@ -1911,6 +2016,7 @@ static void configure_state(JSON_Generator_State *state, VALUE vstate, VALUE con
     rb_hash_foreach(config, configure_state_i, (VALUE)&data);
 
     raise_argument_error_on_unknown_keywords(data.unknown_keywords);
+    validate_rfc8785(state);
 }
 
 static VALUE cState_configure(VALUE self, VALUE opts)
@@ -1970,6 +2076,8 @@ void Init_generator(void)
     VALUE mGenerator = rb_define_module_under(mExt, "Generator");
 
     rb_global_variable(&default_sort_keys_proc);
+    rb_global_variable(&rfc8785_number_formatter_proc);
+    rb_global_variable(&rfc8785_sort_keys_proc);
 
     rb_global_variable(&eGeneratorError);
     eGeneratorError = rb_path2class("JSON::GeneratorError");
@@ -1981,6 +2089,8 @@ void Init_generator(void)
     rb_define_alloc_func(cState, cState_s_allocate);
     rb_define_singleton_method(cState, "from_state", cState_from_state_s, 1);
     rb_define_singleton_method(cState, "default_sort_keys_proc=", cState_set_default_sort_keys_proc, 1);
+    rb_define_singleton_method(cState, "rfc8785_number_formatter_proc=", cState_set_rfc8785_number_formatter_proc, 1);
+    rb_define_singleton_method(cState, "rfc8785_sort_keys_proc=", cState_set_rfc8785_sort_keys_proc, 1);
 
     rb_define_method(cState, "initialize", cState_initialize, -1);
     rb_define_alias(cState, "initialize", "initialize"); // avoid method redefinition warnings
@@ -2018,8 +2128,10 @@ void Init_generator(void)
     rb_define_method(cState, "buffer_initial_length=", cState_buffer_initial_length_set, 1);
     rb_define_method(cState, "generate", cState_generate, -1);
     rb_define_method(cState, "_generate_no_fallback", cState_generate_no_fallback, -1);
-    rb_define_method(cState, "sort_keys", cState_sort_keys_p, 0);
+    rb_define_method(cState, "sort_keys", cState_sort_keys, 0);
     rb_define_method(cState, "sort_keys=", cState_sort_keys_set, 1);
+    rb_define_method(cState, "rfc8785?", cState_rfc8785_p, 0);
+    rb_define_method(cState, "rfc8785=", cState_rfc8785_set, 1);
 
     rb_define_private_method(cState, "allow_duplicate_key?", cState_allow_duplicate_key_p, 0);
 
@@ -2049,10 +2161,10 @@ void Init_generator(void)
     sym_as_json = ID2SYM(rb_intern("as_json"));
     sym_allow_duplicate_key = ID2SYM(rb_intern("allow_duplicate_key"));
     sym_sort_keys = ID2SYM(rb_intern("sort_keys"));
+    sym_rfc8785 = ID2SYM(rb_intern("rfc8785"));
 
     usascii_encindex = rb_usascii_encindex();
     utf8_encindex = rb_utf8_encindex();
-    binary_encindex = rb_ascii8bit_encindex();
 
     rb_require("json/ext/generator/state");
 

data/ext/json/ext/json.h

@@ -5,6 +5,12 @@
 #include "ruby/encoding.h"
 #include <stdint.h>
 
+#ifndef HAVE_RB_LEN_T
+typedef long rb_len_t;
+# define LEN2NUM LONG2NUM
+# define PRIdLEN "ld"
+#endif
+
 #ifndef RBIMPL_ASSERT_OR_ASSUME
 # define RBIMPL_ASSERT_OR_ASSUME(x)
 #endif