json 2.13.1 → 2.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51746c89475207b2f61cd248e90092dfbc5ede1c57226e3809f972ba83155b03
-  data.tar.gz: df39f6262a9eacd358a263b5ab00e0c30474115c9ef367132498f385eeb8fc03
+  metadata.gz: 3a69ef5582c620f7bfdf153a88827b4314d9d3dc01f2435a8c9ebe9d5821db91
+  data.tar.gz: 873e7ced8242e7cc715dbcd92c7d32970dbca037d0aa4ebf3bd37445461eb175
 SHA512:
-  metadata.gz: f192e8bd1e2008570805de002e2ee1ff75f5f31929f5f3c719e7dc11a2cb754f97d70655308372275e4eb9c39d5ee16cb85f2fe7823d5a94f71879d87b11d705
-  data.tar.gz: 69846485c78975cd38c91e5068f365bc8ee9b41ec761d964a8c2166e3e6e86e72d34634f26764a6532ec1e8a3537d669069774440742c2dec7003de09090041c
+  metadata.gz: 62aa3ce5d1660779ddcb14d4a0b082838de6f231358d5269c5055dd7bdbe114ad01aae6626e32c333c9c2085a17eef3841b4acf318ca4b1b269f54c2bf134163
+  data.tar.gz: a844976bd9734865ef55ee697f5fb1a87fcbfd86bc5c5931776c98af72a597c0ee8399089d2da64957dde012e5c2a328cd75fa186ebb09811ab3d8a5479143b2

data/CHANGES.md

@@ -2,6 +2,26 @@
 
 ### Unreleased
 
+* Add new `allow_duplicate_key` generator options. By default a warning is now emitted when a duplicated key is encountered.
+  In `json 3.0` an error will be raised.
+  ```ruby
+  >> Warning[:deprecated] = true
+  >> puts JSON.generate({ foo: 1, "foo" => 2 })
+  (irb):2: warning: detected duplicate key "foo" in {foo: 1, "foo" => 2}.
+  This will raise an error in json 3.0 unless enabled via `allow_duplicate_key: true`
+  {"foo":1,"foo":2}
+  >> JSON.generate({ foo: 1, "foo" => 2 }, allow_duplicate_key: false)
+  detected duplicate key "foo" in {foo: 1, "foo" => 2} (JSON::GeneratorError)
+  ```
+* Fix `JSON.generate` `strict: true` mode to also restrict hash keys.
+* Fix `JSON::Coder` to also invoke block for hash keys that aren't strings nor symbols.
+* Fix `JSON.unsafe_load` usage with proc
+* Fix the parser to more consistently reject invalid UTF-16 surogate pairs. 
+
+### 2025-07-28 (2.13.2)
+
+* Improve duplicate key warning and errors to include the key name and point to the right caller.
+
 ### 2025-07-24 (2.13.1)
 
 * Fix support for older compilers without `__builtin_cpu_supports`.
@@ -40,7 +60,7 @@
 ### 2025-04-24 (2.11.1)
 
 * Add back `JSON.restore`, `JSON.unparse`, `JSON.fast_unparse` and `JSON.pretty_unparse`.
-  These were deprecated 16 years ago, but never emited warnings, only undocumented, so are
+  These were deprecated 16 years ago, but never emitted warnings, only undocumented, so are
   still used by a few gems.
 
 ### 2025-04-24 (2.11.0)
@@ -67,7 +87,7 @@
 ### 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.
+* Raise a ParserError on all incomplete unicode escape sequence. This was the behavior until `2.10.0` inadvertently 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
@@ -98,7 +118,7 @@
 
 ### 2024-11-14 (2.8.2)
 
-* `JSON.load_file` explictly read the file as UTF-8.
+* `JSON.load_file` explicitly read the file as UTF-8.
 
 ### 2024-11-06 (2.8.1)
 
@@ -106,7 +126,7 @@
 
 ### 2024-11-06 (2.8.0)
 
-* Emit a deprecation warning when `JSON.load` create custom types without the `create_additions` option being explictly enabled.
+* Emit a deprecation warning when `JSON.load` create custom types without the `create_additions` option being explicitly enabled.
   * Prefer to use `JSON.unsafe_load(string)` or `JSON.load(string, create_additions: true)`.
 * Emit a deprecation warning when serializing valid UTF-8 strings encoded in `ASCII_8BIT` aka `BINARY`.
 * Bump required Ruby version to 2.7.
@@ -114,7 +134,7 @@
   pre-existing support for comments, make it suitable to parse `jsonc` documents.
 * Many performance improvements to `JSON.parse` and `JSON.load`, up to `1.7x` faster on real world documents.
 * Some minor performance improvements to `JSON.dump` and `JSON.generate`.
-* `JSON.pretty_generate` no longer include newline inside empty object and arrays. 
+* `JSON.pretty_generate` no longer includes newlines inside empty object and arrays.
 
 ### 2024-11-04 (2.7.6)
 
@@ -131,13 +151,13 @@
 * Workaround a bug in 3.4.8 and older https://github.com/rubygems/rubygems/pull/6490.
   This bug would cause some gems with native extension to fail during compilation.
 * Workaround different versions of `json` and `json_pure` being loaded (not officially supported).
-* Make `json_pure` Ractor compatible. 
+* Make `json_pure` Ractor compatible.
 
 ### 2024-10-24 (2.7.3)
 
 * Numerous performance optimizations in `JSON.generate` and `JSON.dump` (up to 2 times faster).
-* Limit the size of ParserError exception messages, only include up to 32 bytes of the unparseable source.
-* Fix json-pure's `Object#to_json` to accept non state arguments 
+* Limit the size of ParserError exception messages, only include up to 32 bytes of the unparsable source.
+* Fix json-pure's `Object#to_json` to accept non-state arguments.
 * Fix multiline comment support in `json-pure`.
 * Fix `JSON.parse` to no longer mutate the argument encoding when passed an ASCII-8BIT string.
 * Fix `String#to_json` to raise on invalid encoding in `json-pure`.
@@ -282,6 +302,7 @@
 ## 2015-09-11 (2.0.0)
   * Now complies to newest JSON RFC 7159.
   * Implements compatibility to ruby 2.4 integer unification.
+  * Removed support for `quirks_mode` option.
   * Drops support for old rubies whose life has ended, that is rubies < 2.0.
     Also see https://www.ruby-lang.org/en/news/2014/07/01/eol-for-1-8-7-and-1-9-2/
   * There were still some mentions of dual GPL licensing in the source, but JSON

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

@@ -24,6 +24,14 @@ typedef unsigned char _Bool;
 #endif
 #endif
 
+#ifndef NOINLINE
+#if defined(__has_attribute) && __has_attribute(noinline)
+#define NOINLINE() __attribute__((noinline))
+#else
+#define NOINLINE()
+#endif
+#endif
+
 #ifndef RB_UNLIKELY
 #define RB_UNLIKELY(expr) expr
 #endif
@@ -169,12 +177,17 @@ static inline void fbuffer_inc_capa(FBuffer *fb, unsigned long requested)
     }
 }
 
-static void fbuffer_append(FBuffer *fb, const char *newstr, unsigned long len)
+static inline void fbuffer_append_reserved(FBuffer *fb, const char *newstr, unsigned long len)
+{
+    MEMCPY(fb->ptr + fb->len, newstr, char, len);
+    fbuffer_consumed(fb, len);
+}
+
+static inline void fbuffer_append(FBuffer *fb, const char *newstr, unsigned long len)
 {
     if (len > 0) {
         fbuffer_inc_capa(fb, len);
-        MEMCPY(fb->ptr + fb->len, newstr, char, len);
-        fbuffer_consumed(fb, len);
+        fbuffer_append_reserved(fb, newstr, len);
     }
 }
 
@@ -197,11 +210,24 @@ static void fbuffer_append_str(FBuffer *fb, VALUE str)
     const char *newstr = StringValuePtr(str);
     unsigned long len = RSTRING_LEN(str);
 
-    RB_GC_GUARD(str);
-
     fbuffer_append(fb, newstr, len);
 }
 
+static void fbuffer_append_str_repeat(FBuffer *fb, VALUE str, size_t repeat)
+{
+    const char *newstr = StringValuePtr(str);
+    unsigned long len = RSTRING_LEN(str);
+
+    fbuffer_inc_capa(fb, repeat * len);
+    while (repeat) {
+#ifdef JSON_DEBUG
+        fb->requested = len;
+#endif
+        fbuffer_append_reserved(fb, newstr, len);
+        repeat--;
+    }
+}
+
 static inline void fbuffer_append_char(FBuffer *fb, char newchr)
 {
     fbuffer_inc_capa(fb, 1);

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

@@ -9,6 +9,12 @@
 
 /* ruby api and some helpers */
 
+enum duplicate_key_action {
+    JSON_DEPRECATED = 0,
+    JSON_IGNORE,
+    JSON_RAISE,
+};
+
 typedef struct JSON_Generator_StateStruct {
     VALUE indent;
     VALUE space;
@@ -21,6 +27,8 @@ typedef struct JSON_Generator_StateStruct {
     long depth;
     long buffer_initial_length;
 
+    enum duplicate_key_action on_duplicate_key;
+
     bool allow_nan;
     bool ascii_only;
     bool script_safe;
@@ -31,10 +39,10 @@ typedef struct JSON_Generator_StateStruct {
 #define RB_UNLIKELY(cond) (cond)
 #endif
 
-static VALUE mJSON, cState, cFragment, mString_Extend, eGeneratorError, eNestingError, Encoding_UTF_8;
+static VALUE mJSON, cState, cFragment, eGeneratorError, eNestingError, Encoding_UTF_8;
 
 static ID i_to_s, i_to_json, i_new, i_pack, i_unpack, i_create_id, i_extend, i_encode;
-static VALUE sym_indent, sym_space, sym_space_before, sym_object_nl, sym_array_nl, sym_max_nesting, sym_allow_nan,
+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_escape_slash, sym_strict, sym_as_json;
 
 
@@ -137,8 +145,8 @@ static inline FORCE_INLINE void search_flush(search_state *search)
 {
     // Do not remove this conditional without profiling, specifically escape-heavy text.
     // escape_UTF8_char_basic will advance search->ptr and search->cursor (effectively a search_flush).
-    // For back-to-back characters that need to be escaped, specifcally for the SIMD code paths, this method
-    // will be called just before calling escape_UTF8_char_basic. There will be no characers to append for the
+    // For back-to-back characters that need to be escaped, specifically for the SIMD code paths, this method
+    // will be called just before calling escape_UTF8_char_basic. There will be no characters to append for the
     // consecutive characters that need to be escaped. While the fbuffer_append is a no-op if
     // nothing needs to be flushed, we can save a few memory references with this conditional.
     if (search->ptr > search->cursor) {
@@ -835,18 +843,6 @@ static VALUE mFloat_to_json(int argc, VALUE *argv, VALUE self)
     return cState_partial_generate(Vstate, self, generate_json_float, Qfalse);
 }
 
-/*
- * call-seq: String.included(modul)
- *
- * Extends _modul_ with the String::Extend module.
- */
-static VALUE mString_included_s(VALUE self, VALUE modul)
-{
-    VALUE result = rb_funcall(modul, i_extend, 1, mString_Extend);
-    rb_call_super(1, &modul);
-    return result;
-}
-
 /*
  * call-seq: to_json(*)
  *
@@ -861,51 +857,6 @@ static VALUE mString_to_json(int argc, VALUE *argv, VALUE self)
     return cState_partial_generate(Vstate, self, generate_json_string, Qfalse);
 }
 
-/*
- * call-seq: to_json_raw_object()
- *
- * This method creates a raw object hash, that can be nested into
- * other data structures and will be generated as a raw string. This
- * method should be used, if you want to convert raw strings to JSON
- * instead of UTF-8 strings, e. g. binary data.
- */
-static VALUE mString_to_json_raw_object(VALUE self)
-{
-    VALUE ary;
-    VALUE result = rb_hash_new();
-    rb_hash_aset(result, rb_funcall(mJSON, i_create_id, 0), rb_class_name(rb_obj_class(self)));
-    ary = rb_funcall(self, i_unpack, 1, rb_str_new2("C*"));
-    rb_hash_aset(result, rb_utf8_str_new_lit("raw"), ary);
-    return result;
-}
-
-/*
- * call-seq: to_json_raw(*args)
- *
- * This method creates a JSON text from the result of a call to
- * to_json_raw_object of this String.
- */
-static VALUE mString_to_json_raw(int argc, VALUE *argv, VALUE self)
-{
-    VALUE obj = mString_to_json_raw_object(self);
-    Check_Type(obj, T_HASH);
-    return mHash_to_json(argc, argv, obj);
-}
-
-/*
- * call-seq: json_create(o)
- *
- * Raw Strings are JSON Objects (the raw bytes are stored in an array for the
- * key "raw"). The Ruby String can be created by this module method.
- */
-static VALUE mString_Extend_json_create(VALUE self, VALUE o)
-{
-    VALUE ary;
-    Check_Type(o, T_HASH);
-    ary = rb_hash_aref(o, rb_str_new2("raw"));
-    return rb_funcall(ary, i_pack, 1, rb_str_new2("C*"));
-}
-
 /*
  * call-seq: to_json(*)
  *
@@ -1044,8 +995,11 @@ static inline VALUE vstate_get(struct generate_json_data *data)
 }
 
 struct hash_foreach_arg {
+    VALUE hash;
     struct generate_json_data *data;
-    int iter;
+    int first_key_type;
+    bool first;
+    bool mixed_keys_encountered;
 };
 
 static VALUE
@@ -1063,6 +1017,22 @@ convert_string_subclass(VALUE key)
     return key_to_s;
 }
 
+NOINLINE()
+static void
+json_inspect_hash_with_mixed_keys(struct hash_foreach_arg *arg)
+{
+    if (arg->mixed_keys_encountered) {
+        return;
+    }
+    arg->mixed_keys_encountered = true;
+
+    JSON_Generator_State *state = arg->data->state;
+    if (state->on_duplicate_key != JSON_IGNORE) {
+        VALUE do_raise = state->on_duplicate_key == JSON_RAISE ? Qtrue : Qfalse;
+        rb_funcall(mJSON, rb_intern("on_mixed_keys_hash"), 2, arg->hash, do_raise);
+    }
+}
+
 static int
 json_object_i(VALUE key, VALUE val, VALUE _arg)
 {
@@ -1073,21 +1043,33 @@ json_object_i(VALUE key, VALUE val, VALUE _arg)
     JSON_Generator_State *state = data->state;
 
     long depth = state->depth;
-    int j;
+    int key_type = rb_type(key);
+
+    if (arg->first) {
+        arg->first = false;
+        arg->first_key_type = key_type;
+    }
+    else {
+        fbuffer_append_char(buffer, ',');
+    }
 
-    if (arg->iter > 0) fbuffer_append_char(buffer, ',');
     if (RB_UNLIKELY(data->state->object_nl)) {
         fbuffer_append_str(buffer, data->state->object_nl);
     }
     if (RB_UNLIKELY(data->state->indent)) {
-        for (j = 0; j < depth; j++) {
-            fbuffer_append_str(buffer, data->state->indent);
-        }
+        fbuffer_append_str_repeat(buffer, data->state->indent, depth);
     }
 
     VALUE key_to_s;
-    switch (rb_type(key)) {
+    bool as_json_called = false;
+
+  start:
+    switch (key_type) {
         case T_STRING:
+            if (RB_UNLIKELY(arg->first_key_type != T_STRING)) {
+                json_inspect_hash_with_mixed_keys(arg);
+            }
+
             if (RB_LIKELY(RBASIC_CLASS(key) == rb_cString)) {
                 key_to_s = key;
             } else {
@@ -1095,9 +1077,23 @@ json_object_i(VALUE key, VALUE val, VALUE _arg)
             }
             break;
         case T_SYMBOL:
+            if (RB_UNLIKELY(arg->first_key_type != T_SYMBOL)) {
+                json_inspect_hash_with_mixed_keys(arg);
+            }
+
             key_to_s = rb_sym2str(key);
             break;
         default:
+            if (data->state->strict) {
+                if (RTEST(data->state->as_json) && !as_json_called) {
+                    key = rb_proc_call_with_block(data->state->as_json, 1, &key, Qnil);
+                    key_type = rb_type(key);
+                    as_json_called = true;
+                    goto start;
+                } else {
+                    raise_generator_error(key, "%"PRIsVALUE" not allowed as object key in JSON", CLASS_OF(key));
+                }
+            }
             key_to_s = rb_convert_type(key, T_STRING, "String", "to_s");
             break;
     }
@@ -1112,7 +1108,6 @@ json_object_i(VALUE key, VALUE val, VALUE _arg)
     if (RB_UNLIKELY(state->space)) fbuffer_append_str(buffer, data->state->space);
     generate_json(buffer, data, val);
 
-    arg->iter++;
     return ST_CONTINUE;
 }
 
@@ -1128,7 +1123,6 @@ static inline long increase_depth(struct generate_json_data *data)
 
 static void generate_json_object(FBuffer *buffer, struct generate_json_data *data, VALUE obj)
 {
-    int j;
     long depth = increase_depth(data);
 
     if (RHASH_SIZE(obj) == 0) {
@@ -1140,8 +1134,9 @@ static void generate_json_object(FBuffer *buffer, struct generate_json_data *dat
     fbuffer_append_char(buffer, '{');
 
     struct hash_foreach_arg arg = {
+        .hash = obj,
         .data = data,
-        .iter = 0,
+        .first = true,
     };
     rb_hash_foreach(obj, json_object_i, (VALUE)&arg);
 
@@ -1149,9 +1144,7 @@ static void generate_json_object(FBuffer *buffer, struct generate_json_data *dat
     if (RB_UNLIKELY(data->state->object_nl)) {
         fbuffer_append_str(buffer, data->state->object_nl);
         if (RB_UNLIKELY(data->state->indent)) {
-            for (j = 0; j < depth; j++) {
-                fbuffer_append_str(buffer, data->state->indent);
-            }
+            fbuffer_append_str_repeat(buffer, data->state->indent, depth);
         }
     }
     fbuffer_append_char(buffer, '}');
@@ -1159,7 +1152,6 @@ static void generate_json_object(FBuffer *buffer, struct generate_json_data *dat
 
 static void generate_json_array(FBuffer *buffer, struct generate_json_data *data, VALUE obj)
 {
-    int i, j;
     long depth = increase_depth(data);
 
     if (RARRAY_LEN(obj) == 0) {
@@ -1170,15 +1162,13 @@ 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 (i = 0; i < RARRAY_LEN(obj); i++) {
+    for (int 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);
         }
         if (RB_UNLIKELY(data->state->indent)) {
-            for (j = 0; j < depth; j++) {
-                fbuffer_append_str(buffer, data->state->indent);
-            }
+            fbuffer_append_str_repeat(buffer, data->state->indent, depth);
         }
         generate_json(buffer, data, RARRAY_AREF(obj, i));
     }
@@ -1186,9 +1176,7 @@ static void generate_json_array(FBuffer *buffer, struct generate_json_data *data
     if (RB_UNLIKELY(data->state->array_nl)) {
         fbuffer_append_str(buffer, data->state->array_nl);
         if (RB_UNLIKELY(data->state->indent)) {
-            for (j = 0; j < depth; j++) {
-                fbuffer_append_str(buffer, data->state->indent);
-            }
+            fbuffer_append_str_repeat(buffer, data->state->indent, depth);
         }
     }
     fbuffer_append_char(buffer, ']');
@@ -1850,6 +1838,19 @@ static VALUE cState_ascii_only_set(VALUE self, VALUE enable)
     return Qnil;
 }
 
+static VALUE cState_allow_duplicate_key_p(VALUE self)
+{
+    GET_STATE(self);
+    switch (state->on_duplicate_key) {
+        case JSON_IGNORE:
+            return Qtrue;
+        case JSON_DEPRECATED:
+            return Qnil;
+        default:
+            return Qfalse;
+    }
+}
+
 /*
  * call-seq: depth
  *
@@ -1939,6 +1940,7 @@ 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_escape_slash)          { state->script_safe = RTEST(val); }
     else if (key == sym_strict)                { state->strict = RTEST(val); }
+    else if (key == sym_allow_duplicate_key)   { state->on_duplicate_key = RTEST(val) ? JSON_IGNORE : JSON_RAISE; }
     else if (key == sym_as_json)               {
         VALUE proc = RTEST(val) ? rb_convert_type(val, T_DATA, "Proc", "to_proc") : Qfalse;
         state_write_value(data, &state->as_json, proc);
@@ -2064,6 +2066,8 @@ void Init_generator(void)
     rb_define_method(cState, "generate", cState_generate, -1);
     rb_define_alias(cState, "generate_new", "generate"); // :nodoc:
 
+    rb_define_private_method(cState, "allow_duplicate_key?", cState_allow_duplicate_key_p, 0);
+
     rb_define_singleton_method(cState, "generate", cState_m_generate, 3);
 
     VALUE mGeneratorMethods = rb_define_module_under(mGenerator, "GeneratorMethods");
@@ -2091,13 +2095,7 @@ void Init_generator(void)
     rb_define_method(mFloat, "to_json", mFloat_to_json, -1);
 
     VALUE mString = rb_define_module_under(mGeneratorMethods, "String");
-    rb_define_singleton_method(mString, "included", mString_included_s, 1);
     rb_define_method(mString, "to_json", mString_to_json, -1);
-    rb_define_method(mString, "to_json_raw", mString_to_json_raw, -1);
-    rb_define_method(mString, "to_json_raw_object", mString_to_json_raw_object, 0);
-
-    mString_Extend = rb_define_module_under(mString, "Extend");
-    rb_define_method(mString_Extend, "json_create", mString_Extend_json_create, 1);
 
     VALUE mTrueClass = rb_define_module_under(mGeneratorMethods, "TrueClass");
     rb_define_method(mTrueClass, "to_json", mTrueClass_to_json, -1);
@@ -2134,6 +2132,7 @@ void Init_generator(void)
     sym_escape_slash = ID2SYM(rb_intern("escape_slash"));
     sym_strict = ID2SYM(rb_intern("strict"));
     sym_as_json = ID2SYM(rb_intern("as_json"));
+    sym_allow_duplicate_key = ID2SYM(rb_intern("allow_duplicate_key"));
 
     usascii_encindex = rb_usascii_encindex();
     utf8_encindex = rb_utf8_encindex();

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

@@ -422,10 +422,12 @@ static void emit_parse_warning(const char *message, JSON_ParserState *state)
     long line, column;
     cursor_position(state, &line, &column);
 
-    rb_warn("%s at line %ld column %ld", message, line, column);
+    VALUE warning = rb_sprintf("%s at line %ld column %ld", message, line, column);
+    rb_funcall(mJSON, rb_intern("deprecation_warning"), 1, warning);
 }
 
 #define PARSE_ERROR_FRAGMENT_LEN 32
+
 #ifdef RBIMPL_ATTR_NORETURN
 RBIMPL_ATTR_NORETURN()
 #endif
@@ -711,11 +713,16 @@ static VALUE json_string_unescape(JSON_ParserState *state, const char *string, c
                         }
                         if (pe[0] == '\\' && pe[1] == 'u') {
                             uint32_t sur = unescape_unicode(state, (unsigned char *) pe + 2);
+
+                            if ((sur & 0xFC00) != 0xDC00) {
+                                raise_parse_error_at("invalid surrogate pair at %s", state, p);
+                            }
+
                             ch = (((ch & 0x3F) << 10) | ((((ch >> 6) & 0xF) + 1) << 16)
                                     | (sur & 0x3FF));
                             pe += 5;
                         } else {
-                            unescape = (char *) "?";
+                            raise_parse_error_at("incomplete surrogate pair at %s", state, p);
                             break;
                         }
                     }
@@ -830,21 +837,64 @@ static inline VALUE json_decode_array(JSON_ParserState *state, JSON_ParserConfig
     return array;
 }
 
+static VALUE json_find_duplicated_key(size_t count, const VALUE *pairs)
+{
+    VALUE set = rb_hash_new_capa(count / 2);
+    for (size_t index = 0; index < count; index += 2) {
+        size_t before = RHASH_SIZE(set);
+        VALUE key = pairs[index];
+        rb_hash_aset(set, key, Qtrue);
+        if (RHASH_SIZE(set) == before) {
+            if (RB_SYMBOL_P(key)) {
+                return rb_sym2str(key);
+            }
+            return key;
+        }
+    }
+    return Qfalse;
+}
+
+static void emit_duplicate_key_warning(JSON_ParserState *state, VALUE duplicate_key)
+{
+    VALUE message = rb_sprintf(
+        "detected duplicate key %"PRIsVALUE" in JSON object. This will raise an error in json 3.0 unless enabled via `allow_duplicate_key: true`",
+        rb_inspect(duplicate_key)
+    );
+
+    emit_parse_warning(RSTRING_PTR(message), state);
+    RB_GC_GUARD(message);
+}
+
+#ifdef RBIMPL_ATTR_NORETURN
+RBIMPL_ATTR_NORETURN()
+#endif
+static void raise_duplicate_key_error(JSON_ParserState *state, VALUE duplicate_key)
+{
+    VALUE message = rb_sprintf(
+        "duplicate key %"PRIsVALUE,
+        rb_inspect(duplicate_key)
+    );
+
+    raise_parse_error(RSTRING_PTR(message), state);
+    RB_GC_GUARD(message);
+}
+
 static inline VALUE json_decode_object(JSON_ParserState *state, JSON_ParserConfig *config, size_t count)
 {
     size_t entries_count = count / 2;
     VALUE object = rb_hash_new_capa(entries_count);
-    rb_hash_bulk_insert(count, rvalue_stack_peek(state->stack, count), object);
+    const VALUE *pairs = rvalue_stack_peek(state->stack, count);
+    rb_hash_bulk_insert(count, pairs, object);
 
     if (RB_UNLIKELY(RHASH_SIZE(object) < entries_count)) {
         switch (config->on_duplicate_key) {
             case JSON_IGNORE:
                 break;
             case JSON_DEPRECATED:
-                emit_parse_warning("detected duplicate keys in JSON object. This will raise an error in json 3.0 unless enabled via `allow_duplicate_key: true`", state);
+                emit_duplicate_key_warning(state, json_find_duplicated_key(count, pairs));
                 break;
             case JSON_RAISE:
-                raise_parse_error("duplicate key", state);
+                raise_duplicate_key_error(state, json_find_duplicated_key(count, pairs));
                 break;
         }
     }
@@ -930,7 +980,7 @@ static inline bool FORCE_INLINE string_scan(JSON_ParserState *state)
         if (RB_UNLIKELY(string_scan_table[(unsigned char)*state->cursor])) {
             return 1;
         }
-        *state->cursor++;
+        state->cursor++;
     }
     return 0;
 }
@@ -1220,7 +1270,7 @@ static VALUE json_parse_any(JSON_ParserState *state, JSON_ParserConfig *config)
             break;
     }
 
-    raise_parse_error("unreacheable: %s", state);
+    raise_parse_error("unreachable: %s", state);
 }
 
 static void json_ensure_eof(JSON_ParserState *state)
@@ -1269,7 +1319,7 @@ static int parser_config_init_i(VALUE key, VALUE val, VALUE data)
     else if (key == sym_symbolize_names)      { config->symbolize_names = RTEST(val); }
     else if (key == sym_freeze)               { config->freeze = RTEST(val); }
     else if (key == sym_on_load)              { config->on_load_proc = RTEST(val) ? val : Qfalse; }
-    else if (key == sym_allow_duplicate_key) { config->on_duplicate_key = RTEST(val) ? JSON_IGNORE : JSON_RAISE; }
+    else if (key == sym_allow_duplicate_key)  { config->on_duplicate_key = RTEST(val) ? JSON_IGNORE : JSON_RAISE; }
     else if (key == sym_decimal_class)        {
         if (RTEST(val)) {
             if (rb_respond_to(val, i_try_convert)) {

data/ext/json/ext/simd/simd.h

@@ -7,45 +7,45 @@ typedef enum {
 #ifdef JSON_ENABLE_SIMD
 
 #ifdef __clang__
-  #if __has_builtin(__builtin_ctzll)
-    #define HAVE_BUILTIN_CTZLL 1
-  #else
-    #define HAVE_BUILTIN_CTZLL 0
-  #endif
+# if __has_builtin(__builtin_ctzll)
+#   define HAVE_BUILTIN_CTZLL 1
+# else
+#   define HAVE_BUILTIN_CTZLL 0
+# endif
 #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
-  #define HAVE_BUILTIN_CTZLL 1
+# define HAVE_BUILTIN_CTZLL 1
 #else
-  #define HAVE_BUILTIN_CTZLL 0
+# define HAVE_BUILTIN_CTZLL 0
 #endif
 
 static inline uint32_t trailing_zeros64(uint64_t input)
 {
 #if HAVE_BUILTIN_CTZLL
-  return __builtin_ctzll(input);
+    return __builtin_ctzll(input);
 #else
-  uint32_t trailing_zeros = 0;
-  uint64_t temp = input;
-  while ((temp & 1) == 0 && temp > 0) {
-    trailing_zeros++;
-    temp >>= 1;
-  }
-  return trailing_zeros;
+    uint32_t trailing_zeros = 0;
+    uint64_t temp = input;
+    while ((temp & 1) == 0 && temp > 0) {
+        trailing_zeros++;
+        temp >>= 1;
+    }
+    return trailing_zeros;
 #endif
 }
 
 static inline int trailing_zeros(int input)
 {
-  #if HAVE_BUILTIN_CTZLL
+#if HAVE_BUILTIN_CTZLL
     return __builtin_ctz(input);
-  #else
+#else
     int trailing_zeros = 0;
     int temp = input;
     while ((temp & 1) == 0 && temp > 0) {
-      trailing_zeros++;
-      temp >>= 1;
+        trailing_zeros++;
+        temp >>= 1;
     }
     return trailing_zeros;
-  #endif
+#endif
 }
 
 #if (defined(__GNUC__ ) || defined(__clang__))
@@ -79,37 +79,38 @@ static inline FORCE_INLINE uint64_t neon_match_mask(uint8x16_t matches)
 
 static inline FORCE_INLINE uint64_t compute_chunk_mask_neon(const char *ptr)
 {
-  uint8x16_t chunk = vld1q_u8((const unsigned char *)ptr);
+    uint8x16_t chunk = vld1q_u8((const unsigned char *)ptr);
 
-  // Trick: c < 32 || c == 34 can be factored as c ^ 2 < 33
-  // https://lemire.me/blog/2025/04/13/detect-control-characters-quotes-and-backslashes-efficiently-using-swar/
-  const uint8x16_t too_low_or_dbl_quote = vcltq_u8(veorq_u8(chunk, vdupq_n_u8(2)), vdupq_n_u8(33));
+    // Trick: c < 32 || c == 34 can be factored as c ^ 2 < 33
+    // https://lemire.me/blog/2025/04/13/detect-control-characters-quotes-and-backslashes-efficiently-using-swar/
+    const uint8x16_t too_low_or_dbl_quote = vcltq_u8(veorq_u8(chunk, vdupq_n_u8(2)), vdupq_n_u8(33));
 
-  uint8x16_t has_backslash = vceqq_u8(chunk, vdupq_n_u8('\\'));
-  uint8x16_t needs_escape  = vorrq_u8(too_low_or_dbl_quote, has_backslash);
-  return neon_match_mask(needs_escape);
+    uint8x16_t has_backslash = vceqq_u8(chunk, vdupq_n_u8('\\'));
+    uint8x16_t needs_escape  = vorrq_u8(too_low_or_dbl_quote, has_backslash);
+    return neon_match_mask(needs_escape);
 }
 
 static inline FORCE_INLINE int string_scan_simd_neon(const char **ptr, const char *end, uint64_t *mask)
 {
     while (*ptr + sizeof(uint8x16_t) <= end) {
-      uint64_t chunk_mask = compute_chunk_mask_neon(*ptr);
-      if (chunk_mask) {
-          *mask = chunk_mask;
-          return 1;
-      }
-      *ptr += sizeof(uint8x16_t);
+        uint64_t chunk_mask = compute_chunk_mask_neon(*ptr);
+        if (chunk_mask) {
+            *mask = chunk_mask;
+            return 1;
+        }
+        *ptr += sizeof(uint8x16_t);
     }
     return 0;
 }
 
-uint8x16x4_t load_uint8x16_4(const unsigned char *table) {
-  uint8x16x4_t tab;
-  tab.val[0] = vld1q_u8(table);
-  tab.val[1] = vld1q_u8(table+16);
-  tab.val[2] = vld1q_u8(table+32);
-  tab.val[3] = vld1q_u8(table+48);
-  return tab;
+static inline uint8x16x4_t load_uint8x16_4(const unsigned char *table)
+{
+    uint8x16x4_t tab;
+    tab.val[0] = vld1q_u8(table);
+    tab.val[1] = vld1q_u8(table+16);
+    tab.val[2] = vld1q_u8(table+32);
+    tab.val[3] = vld1q_u8(table+48);
+    return tab;
 }
 
 #endif /* ARM Neon Support.*/
@@ -150,12 +151,12 @@ static inline TARGET_SSE2 FORCE_INLINE int compute_chunk_mask_sse2(const char *p
 static inline TARGET_SSE2 FORCE_INLINE int string_scan_simd_sse2(const char **ptr, const char *end, int *mask)
 {
     while (*ptr + sizeof(__m128i) <= end) {
-      int chunk_mask = compute_chunk_mask_sse2(*ptr);
-      if (chunk_mask) {
-          *mask = chunk_mask;
-          return 1;
-      }
-      *ptr += sizeof(__m128i);
+        int chunk_mask = compute_chunk_mask_sse2(*ptr);
+        if (chunk_mask) {
+            *mask = chunk_mask;
+            return 1;
+        }
+        *ptr += sizeof(__m128i);
     }
 
     return 0;

data/lib/json/add/core.rb

@@ -7,6 +7,7 @@ require 'json/add/date_time'
 require 'json/add/exception'
 require 'json/add/range'
 require 'json/add/regexp'
+require 'json/add/string'
 require 'json/add/struct'
 require 'json/add/symbol'
 require 'json/add/time'

data/lib/json/add/string.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
+  require 'json'
+end
+
+class String
+  # call-seq: json_create(o)
+  #
+  # Raw Strings are JSON Objects (the raw bytes are stored in an array for the
+  # key "raw"). The Ruby String can be created by this class method.
+  def self.json_create(object)
+    object["raw"].pack("C*")
+  end
+
+  # call-seq: to_json_raw_object()
+  #
+  # This method creates a raw object hash, that can be nested into
+  # other data structures and will be generated as a raw string. This
+  # method should be used, if you want to convert raw strings to JSON
+  # instead of UTF-8 strings, e. g. binary data.
+  def to_json_raw_object
+    {
+      JSON.create_id => self.class.name,
+      "raw" => unpack("C*"),
+    }
+  end
+
+  # call-seq: to_json_raw(*args)
+  #
+  # This method creates a JSON text from the result of a call to
+  # to_json_raw_object of this String.
+  def to_json_raw(...)
+    to_json_raw_object.to_json(...)
+  end
+end

data/lib/json/common.rb

@@ -48,7 +48,7 @@ module JSON
         end
       end
 
-      # TODO: exctract :create_additions support to another gem for version 3.0
+      # TODO: extract :create_additions support to another gem for version 3.0
       def create_additions_proc(opts)
         if opts[:symbolize_names]
           raise ArgumentError, "options :symbolize_names and :create_additions cannot be  used in conjunction"
@@ -73,7 +73,7 @@ module JSON
             if opts[:create_additions] != false
               if class_name = object[JSON.create_id]
                 klass = JSON.deep_const_get(class_name)
-                if (klass.respond_to?(:json_creatable?) && klass.json_creatable?) || klass.respond_to?(:json_create)
+                if klass.respond_to?(:json_creatable?) ? klass.json_creatable? : klass.respond_to?(:json_create)
                   create_additions_warning if create_additions.nil?
                   object = klass.json_create(object)
                 end
@@ -87,31 +87,32 @@ module JSON
         opts
       end
 
-      GEM_ROOT = File.expand_path("../../../", __FILE__) + "/"
       def create_additions_warning
-        message = "JSON.load implicit support for `create_additions: true` is deprecated " \
+        JSON.deprecation_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`"
+      end
+    end
+  end
 
-        uplevel = 4
-        caller_locations(uplevel, 10).each do |frame|
-          if frame.path.nil? || frame.path.start_with?(GEM_ROOT) || frame.path.end_with?("/truffle/cext_ruby.rb", ".c")
-            uplevel += 1
-          else
-            break
-          end
-        end
-
-        if RUBY_VERSION >= "3.0"
-          warn(message, uplevel: uplevel - 1, category: :deprecated)
+  class << self
+    def deprecation_warning(message, uplevel = 3) # :nodoc:
+      gem_root = File.expand_path("..", __dir__) + "/"
+      caller_locations(uplevel, 10).each do |frame|
+        if frame.path.nil? || frame.path.start_with?(gem_root) || frame.path.end_with?("/truffle/cext_ruby.rb", ".c")
+          uplevel += 1
         else
-          warn(message, uplevel: uplevel - 1)
+          break
         end
       end
+
+      if RUBY_VERSION >= "3.0"
+        warn(message, uplevel: uplevel, category: :deprecated)
+      else
+        warn(message, uplevel: uplevel)
+      end
     end
-  end
 
-  class << self
     # :call-seq:
     #   JSON[object] -> new_array or new_string
     #
@@ -185,6 +186,25 @@ module JSON
 
     private
 
+    # Called from the extension when a hash has both string and symbol keys
+    def on_mixed_keys_hash(hash, do_raise)
+      set = {}
+      hash.each_key do |key|
+        key_str = key.to_s
+
+        if set[key_str]
+          message = "detected duplicate key #{key_str.inspect} in #{hash.inspect}"
+          if do_raise
+            raise GeneratorError, message
+          else
+            deprecation_warning("#{message}.\nThis will raise an error in json 3.0 unless enabled via `allow_duplicate_key: true`")
+          end
+        else
+          set[key_str] = true
+        end
+      end
+    end
+
     def deprecated_singleton_attr_accessor(*attrs)
       args = RUBY_VERSION >= "3.0" ? ", category: :deprecated" : ""
       attrs.each do |attr|
@@ -390,7 +410,7 @@ module JSON
   #
   # Returns a \String containing the generated \JSON data.
   #
-  # See also JSON.fast_generate, JSON.pretty_generate.
+  # See also JSON.pretty_generate.
   #
   # Argument +obj+ is the Ruby object to be converted to \JSON.
   #
@@ -642,6 +662,7 @@ module JSON
   #     when Array
   #       obj.map! {|v| deserialize_obj v }
   #     end
+  #     obj
   #   })
   #   pp ruby
   # Output:
@@ -683,9 +704,13 @@ module JSON
     if opts[:allow_blank] && (source.nil? || source.empty?)
       source = 'null'
     end
-    result = parse(source, opts)
-    recurse_proc(result, &proc) if proc
-    result
+
+    if proc
+      opts = opts.dup
+      opts[:on_load] = proc.to_proc
+    end
+
+    parse(source, opts)
   end
 
   # :call-seq:
@@ -802,6 +827,7 @@ module JSON
   #     when Array
   #       obj.map! {|v| deserialize_obj v }
   #     end
+  #     obj
   #   })
   #   pp ruby
   # Output:
@@ -1001,7 +1027,7 @@ module JSON
     # See {Parsing Options}[#module-JSON-label-Parsing+Options], and {Generating Options}[#module-JSON-label-Generating+Options].
     #
     # For generation, the <tt>strict: true</tt> option is always set. When a Ruby object with no native \JSON counterpart is
-    # encoutered, the block provided to the initialize method is invoked, and must return a Ruby object that has a native
+    # encountered, the block provided to the initialize method is invoked, and must return a Ruby object that has a native
     # \JSON counterpart:
     #
     #  module MyApp

data/lib/json/ext/generator/state.rb

@@ -8,20 +8,8 @@ module JSON
         #
         # Instantiates a new State object, configured by _opts_.
         #
-        # _opts_ can have the following keys:
-        #
-        # * *indent*: a string used to indent levels (default: ''),
-        # * *space*: a string that is put after, a : or , delimiter (default: ''),
-        # * *space_before*: a string that is put before a : pair delimiter (default: ''),
-        # * *object_nl*: a string that is put at the end of a JSON object (default: ''),
-        # * *array_nl*: a string that is put at the end of a JSON array (default: ''),
-        # * *allow_nan*: true if NaN, Infinity, and -Infinity should be
-        #   generated, otherwise an exception is thrown, if these values are
-        #   encountered. This options defaults to false.
-        # * *ascii_only*: true if only ASCII characters should be generated. This
-        #   option defaults to false.
-        # * *buffer_initial_length*: sets the initial length of the generator's
-        #   internal buffer.
+        # Argument +opts+, if given, contains a \Hash of options for the generation.
+        # See {Generating Options}[#module-JSON-label-Generating+Options].
         def initialize(opts = nil)
           if opts && !opts.empty?
             configure(opts)
@@ -68,6 +56,11 @@ module JSON
             buffer_initial_length: buffer_initial_length,
           }
 
+          allow_duplicate_key = allow_duplicate_key?
+          unless allow_duplicate_key.nil?
+            result[:allow_duplicate_key] = allow_duplicate_key
+          end
+
           instance_variables.each do |iv|
             iv = iv.to_s[1..-1]
             result[iv.to_sym] = self[iv]

data/lib/json/generic_object.rb

@@ -52,14 +52,6 @@ module JSON
       table
     end
 
-    def [](name)
-      __send__(name)
-    end unless method_defined?(:[])
-
-    def []=(name, value)
-      __send__("#{name}=", value)
-    end unless method_defined?(:[]=)
-
     def |(other)
       self.class[other.to_hash.merge(to_hash)]
     end

data/lib/json/truffle_ruby/generator.rb

@@ -271,6 +271,12 @@ module JSON
             false
           end
 
+          if opts.key?(:allow_duplicate_key)
+            @allow_duplicate_key = !!opts[:allow_duplicate_key]
+          else
+            @allow_duplicate_key = nil # nil is deprecation
+          end
+
           @strict                = !!opts[:strict] if opts.key?(:strict)
 
           if !opts.key?(:max_nesting) # defaults to 100
@@ -284,6 +290,10 @@ module JSON
         end
         alias merge configure
 
+        def allow_duplicate_key? # :nodoc:
+          @allow_duplicate_key
+        end
+
         # Returns the configuration instance variables as a hash, that can be
         # passed to the configure method.
         def to_h
@@ -292,6 +302,11 @@ module JSON
             iv = iv.to_s[1..-1]
             result[iv.to_sym] = self[iv]
           end
+
+          if result[:allow_duplicate_key].nil?
+            result.delete(:allow_duplicate_key)
+          end
+
           result
         end
 
@@ -330,8 +345,17 @@ module JSON
           when Hash
             buf << '{'
             first = true
+            key_type = nil
             obj.each_pair do |k,v|
-              buf << ',' unless first
+              if first
+                key_type = k.class
+              else
+                if key_type && !@allow_duplicate_key && key_type != k.class
+                  key_type = nil # stop checking
+                  JSON.send(:on_mixed_keys_hash, obj, !@allow_duplicate_key.nil?)
+                end
+                buf << ','
+              end
 
               key_str = k.to_s
               if key_str.class == String
@@ -471,11 +495,30 @@ module JSON
             delim = ",#{state.object_nl}"
             result = +"{#{state.object_nl}"
             first = true
+            key_type = nil
             indent = !state.object_nl.empty?
             each { |key, value|
-              result << delim unless first
+              if first
+                key_type = key.class
+              else
+                if key_type && !state.allow_duplicate_key? && key_type != key.class
+                  key_type = nil # stop checking
+                  JSON.send(:on_mixed_keys_hash, self, state.allow_duplicate_key? == false)
+                end
+                result << delim
+              end
               result << state.indent * depth if indent
 
+              if state.strict? && !(Symbol === key || String === key)
+                if state.as_json
+                  key = state.as_json.call(key)
+                end
+
+                unless Symbol === key || String === key
+                  raise GeneratorError.new("#{key.class} not allowed as object key in JSON", value)
+                end
+              end
+
               key_str = key.to_s
               if key_str.is_a?(String)
                 key_json = key_str.to_json(state)
@@ -635,39 +678,6 @@ module JSON
           rescue Encoding::UndefinedConversionError => error
             raise ::JSON::GeneratorError.new(error.message, self)
           end
-
-          # Module that holds the extending methods if, the String module is
-          # included.
-          module Extend
-            # Raw Strings are JSON Objects (the raw bytes are stored in an
-            # array for the key "raw"). The Ruby String can be created by this
-            # module method.
-            def json_create(o)
-              o['raw'].pack('C*')
-            end
-          end
-
-          # Extends _modul_ with the String::Extend module.
-          def self.included(modul)
-            modul.extend Extend
-          end
-
-          # This method creates a raw object hash, that can be nested into
-          # other data structures and will be unparsed as a raw string. This
-          # method should be used, if you want to convert raw strings to JSON
-          # instead of UTF-8 strings, e. g. binary data.
-          def to_json_raw_object
-            {
-              JSON.create_id  => self.class.name,
-              'raw'           => self.unpack('C*'),
-            }
-          end
-
-          # This method creates a JSON text from the result of
-          # a call to to_json_raw_object of this String.
-          def to_json_raw(*args)
-            to_json_raw_object.to_json(*args)
-          end
         end
 
         module TrueClass

data/lib/json/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JSON
-  VERSION = '2.13.1'
+  VERSION = '2.14.0'
 end

data/lib/json.rb

@@ -133,7 +133,7 @@ require 'json/common'
 # When not specified:
 #   # The last value is used and a deprecation warning emitted.
 #   JSON.parse('{"a": 1, "a":2}') => {"a" => 2}
-#   # waring: detected duplicate keys in JSON object.
+#   # warning: detected duplicate keys in JSON object.
 #   # This will raise an error in json 3.0 unless enabled via `allow_duplicate_key: true`
 #
 # When set to `+true+`
@@ -307,6 +307,25 @@ require 'json/common'
 #
 # ---
 #
+# Option +allow_duplicate_key+ (boolean) specifies whether
+# hashes with duplicate keys should be allowed or produce an error.
+# defaults to emit a deprecation warning.
+#
+# With the default, (not set):
+#   Warning[:deprecated] = true
+#   JSON.generate({ foo: 1, "foo" => 2 })
+#   # warning: detected duplicate key "foo" in {foo: 1, "foo" => 2}.
+#   # This will raise an error in json 3.0 unless enabled via `allow_duplicate_key: true`
+#   # => '{"foo":1,"foo":2}'
+#
+# With <tt>false</tt>
+#   JSON.generate({ foo: 1, "foo" => 2 }, allow_duplicate_key: false)
+#   # detected duplicate key "foo" in {foo: 1, "foo" => 2} (JSON::GeneratorError)
+#
+# In version 3.0, <tt>false</tt> will become the default.
+#
+# ---
+#
 # Option +max_nesting+ (\Integer) specifies the maximum nesting depth
 # in +obj+; defaults to +100+.
 #
@@ -384,6 +403,9 @@ require 'json/common'
 #
 # == \JSON Additions
 #
+# Note that JSON Additions must only be used with trusted data, and is
+# deprecated.
+#
 # When you "round trip" a non-\String object from Ruby to \JSON and back,
 # you have a new \String, instead of the object you began with:
 #   ruby0 = Range.new(0, 2)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: json
 version: !ruby/object:Gem::Version
-  version: 2.13.1
+  version: 2.14.0
 platform: ruby
 authors:
 - Florian Frank
 bindir: bin
 cert_chain: []
-date: 2025-07-24 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: This is a JSON implementation as a Ruby extension in C.
 email: flori@ping.de
@@ -45,6 +45,7 @@ files:
 - lib/json/add/rational.rb
 - lib/json/add/regexp.rb
 - lib/json/add/set.rb
+- lib/json/add/string.rb
 - lib/json/add/struct.rb
 - lib/json/add/symbol.rb
 - lib/json/add/time.rb
@@ -81,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: JSON Implementation for Ruby
 test_files: []