json 2.13.0 → 2.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41dcbe399cb5dd00e62d93c87f31b356674c1feb9430306902009ebf8f56bd9a
-  data.tar.gz: f398e819143dc90c162474b5c97241d7a8c8c8209d5a5512c1b081d72a29192a
+  metadata.gz: 71499860706a6f27871853ec88fe26d5bd6a53f85fba2e9764b9ef0aadc170d9
+  data.tar.gz: c07cd26190c4f36864490465890c162e1b9ce0ae1f262069e51c94d7cf74b117
 SHA512:
-  metadata.gz: ff828416dfb1f4a6ffcb51e02827d948b6c566ce008799cc9a02afb538b8d9a32ff1d6eee5c4e0e609757d1e9cfe1332ea359049a3fd820b199bdc7931a2573e
-  data.tar.gz: e5ea4c5bd447d2ed5c37b144219cd0cbed1474a5c7976f63b938996687cfc7f422e4e147582e6fee0a2d3f4ba09937496c23f08c42e2a525744a9246bcfcb5df
+  metadata.gz: f1c626d30c67e99c56d9f411b7944b6263261676567c02f6d57ba7566087743b26835d3c6c4c1636a0dc76cc2b8c4e2739a1130f286cd069406c38c66138df97
+  data.tar.gz: eb4fd62079fc730962359e4128f7abd36ca04c17b580506c3e8e3ebdd0e8e0c54c3cf75d1ae899dc53e13697bfa0c11c6c04277d701cfc83fa9ee611785ac85e

data/CHANGES.md

@@ -2,7 +2,15 @@
 
 ### Unreleased
 
-### 2025-05-23 (2.13.0)
+### 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`.
+
+### 2025-07-17 (2.13.0)
 
 * Add new `allow_duplicate_key` parsing options. By default a warning is now emitted when a duplicated key is encountered.
   In `json 3.0` an error will be raised.

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

@@ -1907,15 +1907,30 @@ static VALUE cState_buffer_initial_length_set(VALUE self, VALUE buffer_initial_l
     return Qnil;
 }
 
+struct configure_state_data {
+    JSON_Generator_State *state;
+    VALUE vstate;  // Ruby object that owns the state, or Qfalse if stack-allocated
+};
+
+static inline void state_write_value(struct configure_state_data *data, VALUE *field, VALUE value)
+{
+    if (RTEST(data->vstate)) {
+        RB_OBJ_WRITE(data->vstate, field, value);
+    } else {
+        *field = value;
+    }
+}
+
 static int configure_state_i(VALUE key, VALUE val, VALUE _arg)
 {
-    JSON_Generator_State *state = (JSON_Generator_State *)_arg;
+    struct configure_state_data *data = (struct configure_state_data *)_arg;
+    JSON_Generator_State *state = data->state;
 
-         if (key == sym_indent)                { state->indent = string_config(val); }
-    else if (key == sym_space)                 { state->space = string_config(val); }
-    else if (key == sym_space_before)          { state->space_before = string_config(val); }
-    else if (key == sym_object_nl)             { state->object_nl = string_config(val); }
-    else if (key == sym_array_nl)              { state->array_nl = string_config(val); }
+         if (key == sym_indent)                { state_write_value(data, &state->indent, string_config(val)); }
+    else if (key == sym_space)                 { state_write_value(data, &state->space, string_config(val)); }
+    else if (key == sym_space_before)          { state_write_value(data, &state->space_before, string_config(val)); }
+    else if (key == sym_object_nl)             { state_write_value(data, &state->object_nl, string_config(val)); }
+    else if (key == sym_array_nl)              { state_write_value(data, &state->array_nl, string_config(val)); }
     else if (key == sym_max_nesting)           { state->max_nesting = long_config(val); }
     else if (key == sym_allow_nan)             { state->allow_nan = RTEST(val); }
     else if (key == sym_ascii_only)            { state->ascii_only = RTEST(val); }
@@ -1924,11 +1939,14 @@ 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_as_json)               { state->as_json = RTEST(val) ? rb_convert_type(val, T_DATA, "Proc", "to_proc") : Qfalse; }
+    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);
+    }
     return ST_CONTINUE;
 }
 
-static void configure_state(JSON_Generator_State *state, VALUE config)
+static void configure_state(JSON_Generator_State *state, VALUE vstate, VALUE config)
 {
     if (!RTEST(config)) return;
 
@@ -1936,15 +1954,20 @@ static void configure_state(JSON_Generator_State *state, VALUE config)
 
     if (!RHASH_SIZE(config)) return;
 
+    struct configure_state_data data = {
+        .state = state,
+        .vstate = vstate
+    };
+
     // 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(config, configure_state_i, (VALUE)state);
+    rb_hash_foreach(config, configure_state_i, (VALUE)&data);
 }
 
 static VALUE cState_configure(VALUE self, VALUE opts)
 {
     GET_STATE(self);
-    configure_state(state, opts);
+    configure_state(state, self, opts);
     return self;
 }
 
@@ -1952,7 +1975,7 @@ static VALUE cState_m_generate(VALUE klass, VALUE obj, VALUE opts, VALUE io)
 {
     JSON_Generator_State state = {0};
     state_init(&state);
-    configure_state(&state, opts);
+    configure_state(&state, Qfalse, opts);
 
     char stack_buffer[FBUFFER_STACK_SIZE];
     FBuffer buffer = {

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
@@ -830,21 +832,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;
         }
     }

data/ext/json/ext/simd/conf.rb

@@ -1,20 +1,24 @@
 case RbConfig::CONFIG['host_cpu']
 when /^(arm|aarch64)/
   # Try to compile a small program using NEON instructions
-  header, type, init = 'arm_neon.h', 'uint8x16_t', 'vdupq_n_u8(32)'
+  header, type, init, extra = 'arm_neon.h', 'uint8x16_t', 'vdupq_n_u8(32)', nil
 when /^(x86_64|x64)/
-  header, type, init = 'x86intrin.h', '__m128i', '_mm_set1_epi8(32)'
+  header, type, init, extra = 'x86intrin.h', '__m128i', '_mm_set1_epi8(32)', 'if (__builtin_cpu_supports("sse2")) { printf("OK"); }'
 end
 if header
-  have_header(header) && try_compile(<<~SRC)
-    #{cpp_include(header)}
-    int main(int argc, char **argv) {
-      #{type} test = #{init};
-      if (argc > 100000) printf("%p", &test);
-      return 0;
-    }
-  SRC
-  $defs.push("-DJSON_ENABLE_SIMD")
+  if have_header(header) && try_compile(<<~SRC, '-Werror=implicit-function-declaration')
+      #{cpp_include(header)}
+      int main(int argc, char **argv) {
+        #{type} test = #{init};
+        #{extra}
+        if (argc > 100000) printf("%p", &test);
+        return 0;
+      }
+    SRC
+    $defs.push("-DJSON_ENABLE_SIMD")
+  else
+    puts "Disable SIMD"
+  end
 end
 
 have_header('cpuid.h')

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/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"
@@ -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("../../../", __FILE__) + "/"
+      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
     #

data/lib/json/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: json
 version: !ruby/object:Gem::Version
-  version: 2.13.0
+  version: 2.13.2
 platform: ruby
 authors:
 - Florian Frank
 bindir: bin
 cert_chain: []
-date: 2025-07-17 00:00:00.000000000 Z
+date: 2025-07-28 00:00:00.000000000 Z
 dependencies: []
 description: This is a JSON implementation as a Ruby extension in C.
 email: flori@ping.de