From b13b6b748bb7812db63b4d86ccde33df536f052e Mon Sep 17 00:00:00 2001 From: Jean Boussier Date: Mon, 17 Aug 2026 09:00:51 +0200 Subject: [PATCH 1/4] [ruby/json] Update Hash syntax in tests https://github.com/ruby/json/commit/0479b66aec --- test/json/json_common_interface_test.rb | 26 +++--- test/json/json_generator_test.rb | 110 ++++++++++++------------ test/json/json_parser_test.rb | 44 +++++----- 3 files changed, 90 insertions(+), 90 deletions(-) diff --git a/test/json/json_common_interface_test.rb b/test/json/json_common_interface_test.rb index 1acfc9ba530622..2c4c9a213a40d4 100644 --- a/test/json/json_common_interface_test.rb +++ b/test/json/json_common_interface_test.rb @@ -158,16 +158,16 @@ def test_load_with_proc def test_load_with_options json = '{ "foo": NaN }' - assert JSON.load(json, nil, :allow_nan => true)['foo'].nan? - assert JSON.load(json, :allow_nan => true)['foo'].nan? + assert JSON.load(json, nil, allow_nan: true)['foo'].nan? + assert JSON.load(json, allow_nan: true)['foo'].nan? end def test_load_null - assert_equal nil, JSON.load(nil, nil, :allow_blank => true) - assert_raise(TypeError) { JSON.load(nil, nil, :allow_blank => false) } - assert_raise(JSON::ParserError) { JSON.load('', nil, :allow_blank => false) } - assert_raise(TypeError) { JSON.load([], nil, :allow_blank => true) } - assert_raise(TypeError) { JSON.load({}, nil, :allow_blank => true) } + assert_equal nil, JSON.load(nil, nil, allow_blank: true) + assert_raise(TypeError) { JSON.load(nil, nil, allow_blank: false) } + assert_raise(JSON::ParserError) { JSON.load('', nil, allow_blank: false) } + assert_raise(TypeError) { JSON.load([], nil, allow_blank: true) } + assert_raise(TypeError) { JSON.load({}, nil, allow_blank: true) } end def test_unsafe_load @@ -240,16 +240,16 @@ def test_unsafe_load_default_options def test_unsafe_load_with_options nan_json = '{ "foo": NaN }' - assert_raise(JSON::ParserError) { JSON.unsafe_load(nan_json, nil, :allow_nan => false)['foo'].nan? } + assert_raise(JSON::ParserError) { JSON.unsafe_load(nan_json, nil, allow_nan: false)['foo'].nan? } # make sure it still uses the defaults when something is provided - assert JSON.unsafe_load(nan_json, nil, :allow_blank => true)['foo'].nan? - assert JSON.unsafe_load(nan_json, :allow_nan => true)['foo'].nan? + assert JSON.unsafe_load(nan_json, nil, allow_blank: true)['foo'].nan? + assert JSON.unsafe_load(nan_json, allow_nan: true)['foo'].nan? end def test_unsafe_load_null - assert_equal nil, JSON.unsafe_load(nil, nil, :allow_blank => true) - assert_raise(TypeError) { JSON.unsafe_load(nil, nil, :allow_blank => false) } - assert_raise(JSON::ParserError) { JSON.unsafe_load('', nil, :allow_blank => false) } + assert_equal nil, JSON.unsafe_load(nil, nil, allow_blank: true) + assert_raise(TypeError) { JSON.unsafe_load(nil, nil, allow_blank: false) } + assert_raise(JSON::ParserError) { JSON.unsafe_load('', nil, allow_blank: false) } end def test_dump diff --git a/test/json/json_generator_test.rb b/test/json/json_generator_test.rb index 27882458a934cb..2a64a5e7577f3c 100755 --- a/test/json/json_generator_test.rb +++ b/test/json/json_generator_test.rb @@ -175,7 +175,7 @@ def test_generate_pretty end def test_generate_pretty_custom - state = State.new(:space_before => "", :space => "", :indent => "", :object_nl => "\n\n", :array_nl => "") + state = State.new(space_before: "", space: "", indent: "", object_nl: "\n\n", array_nl: "") json = pretty_generate({1=>{}, 2=>['a','b'], 3=>4}, state) assert_equal(<<~'JSON'.chomp, json) { @@ -244,7 +244,7 @@ def test_generate_sort_keys_with_proc end def test_generate_custom - state = State.new(:space_before => " ", :space => " ", :indent => "", :object_nl => "\n", :array_nl => "") + state = State.new(space_before: " ", space: " ", indent: "", object_nl: "\n", array_nl: "") json = generate({1=>{2=>3,4=>[5,6]}}, state) assert_equal(<<~'JSON'.chomp, json) { @@ -307,62 +307,62 @@ def test_falsy_state def test_state_defaults state = JSON::State.new assert_equal({ - :allow_duplicate_key => false, - :allow_nan => false, - :array_nl => "", - :as_json => false, - :ascii_only => false, - :buffer_initial_length => 1024, - :depth => 0, - :script_safe => false, - :strict => false, - :indent => "", - :max_nesting => 100, - :object_nl => "", - :space => "", - :space_before => "", - :sort_keys => false, + allow_duplicate_key: false, + allow_nan: false, + array_nl: "", + as_json: false, + ascii_only: false, + buffer_initial_length: 1024, + depth: 0, + script_safe: false, + strict: false, + indent: "", + max_nesting: 100, + object_nl: "", + space: "", + space_before: "", + sort_keys: false, }.sort_by { |n,| n.to_s }.to_h, state.to_h.sort_by { |n,| n.to_s }.to_h) state = JSON::State.new(allow_duplicate_key: true) assert_equal({ - :allow_duplicate_key => true, - :allow_nan => false, - :array_nl => "", - :as_json => false, - :ascii_only => false, - :buffer_initial_length => 1024, - :depth => 0, - :script_safe => false, - :strict => false, - :indent => "", - :max_nesting => 100, - :object_nl => "", - :space => "", - :space_before => "", - :sort_keys => false, + allow_duplicate_key: true, + allow_nan: false, + array_nl: "", + as_json: false, + ascii_only: false, + buffer_initial_length: 1024, + depth: 0, + script_safe: false, + strict: false, + indent: "", + max_nesting: 100, + object_nl: "", + space: "", + space_before: "", + sort_keys: false, }.sort_by { |n,| n.to_s }, state.to_h.sort_by { |n,| n.to_s }) end def test_allow_nan error = assert_raise(GeneratorError) { generate([JSON::NaN]) } assert_same JSON::NaN, error.invalid_object - assert_equal '[NaN]', generate([JSON::NaN], :allow_nan => true) + assert_equal '[NaN]', generate([JSON::NaN], allow_nan: true) assert_raise(GeneratorError) { generate([JSON::NaN]) } assert_raise(GeneratorError) { pretty_generate([JSON::NaN]) } - assert_equal "[\n NaN\n]", pretty_generate([JSON::NaN], :allow_nan => true) + assert_equal "[\n NaN\n]", pretty_generate([JSON::NaN], allow_nan: true) error = assert_raise(GeneratorError) { generate([JSON::Infinity]) } assert_same JSON::Infinity, error.invalid_object - assert_equal '[Infinity]', generate([JSON::Infinity], :allow_nan => true) + assert_equal '[Infinity]', generate([JSON::Infinity], allow_nan: true) assert_raise(GeneratorError) { generate([JSON::Infinity]) } assert_raise(GeneratorError) { pretty_generate([JSON::Infinity]) } - assert_equal "[\n Infinity\n]", pretty_generate([JSON::Infinity], :allow_nan => true) + assert_equal "[\n Infinity\n]", pretty_generate([JSON::Infinity], allow_nan: true) error = assert_raise(GeneratorError) { generate([JSON::MinusInfinity]) } assert_same JSON::MinusInfinity, error.invalid_object - assert_equal '[-Infinity]', generate([JSON::MinusInfinity], :allow_nan => true) + assert_equal '[-Infinity]', generate([JSON::MinusInfinity], allow_nan: true) assert_raise(GeneratorError) { generate([JSON::MinusInfinity]) } assert_raise(GeneratorError) { pretty_generate([JSON::MinusInfinity]) } - assert_equal "[\n -Infinity\n]", pretty_generate([JSON::MinusInfinity], :allow_nan => true) + assert_equal "[\n -Infinity\n]", pretty_generate([JSON::MinusInfinity], allow_nan: true) end # An object that changes state.depth when it receives to_json(state) @@ -489,11 +489,11 @@ def test_gc def test_configure_using_configure_and_merge numbered_state = { - :indent => "1", - :space => '2', - :space_before => '3', - :object_nl => '4', - :array_nl => '5' + indent: "1", + space: '2', + space_before: '3', + object_nl: '4', + array_nl: '5' } state1 = JSON.state.new state1.merge(numbered_state) @@ -513,7 +513,7 @@ def test_configure_using_configure_and_merge def test_configure_hash_conversion state = JSON.state.new - state.configure(:indent => '1') + state.configure(indent: '1') assert_equal '1', state.indent state = JSON.state.new foo = 'foo'.dup @@ -595,14 +595,14 @@ def test_nesting too_deep = '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]' too_deep_ary = eval too_deep assert_raise(JSON::NestingError) { generate too_deep_ary } - assert_raise(JSON::NestingError) { generate too_deep_ary, :max_nesting => 100 } - ok = generate too_deep_ary, :max_nesting => 101 + assert_raise(JSON::NestingError) { generate too_deep_ary, max_nesting: 100 } + ok = generate too_deep_ary, max_nesting: 101 assert_equal too_deep, ok - ok = generate too_deep_ary, :max_nesting => nil + ok = generate too_deep_ary, max_nesting: nil assert_equal too_deep, ok - ok = generate too_deep_ary, :max_nesting => false + ok = generate too_deep_ary, max_nesting: false assert_equal too_deep, ok - ok = generate too_deep_ary, :max_nesting => 0 + ok = generate too_deep_ary, max_nesting: 0 assert_equal too_deep, ok assert_raise(TypeError) { generate too_deep_ary, max_nesting: "garbage" } @@ -631,27 +631,27 @@ def test_backslash # data = [ '/' ] json = '["\/"]' - assert_equal json, generate(data, :script_safe => true) + assert_equal json, generate(data, script_safe: true) # data = [ '///////////' ] json = '["\/\/\/\/\/\/\/\/\/\/\/"]' - assert_equal json, generate(data, :script_safe => true) + assert_equal json, generate(data, script_safe: true) # data = [ '///////////////////////////////////////////////////////' ] json = '["\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/"]' - assert_equal json, generate(data, :script_safe => true) + assert_equal json, generate(data, script_safe: true) # data = [ "\u2028\u2029" ] json = '["\u2028\u2029"]' - assert_equal json, generate(data, :script_safe => true) + assert_equal json, generate(data, script_safe: true) # data = [ "ABC \u2028 DEF \u2029 GHI" ] json = '["ABC \u2028 DEF \u2029 GHI"]' - assert_equal json, generate(data, :script_safe => true) + assert_equal json, generate(data, script_safe: true) # data = [ "/\u2028\u2029" ] json = '["\/\u2028\u2029"]' - assert_equal json, generate(data, :script_safe => true) + assert_equal json, generate(data, script_safe: true) # data = ['"'] json = '["\""]' diff --git a/test/json/json_parser_test.rb b/test/json/json_parser_test.rb index 1819d0abf7c303..e7940faa4ee6f4 100644 --- a/test/json/json_parser_test.rb +++ b/test/json/json_parser_test.rb @@ -120,11 +120,11 @@ def test_parse_numbers assert_equal_float(-3.141, parse('-3141.0e-3')) assert_equal_float(-3.141, parse('-3141e-3')) assert_raise(ParserError) { parse('NaN') } - assert parse('NaN', :allow_nan => true).nan? + assert parse('NaN', allow_nan: true).nan? assert_raise(ParserError) { parse('Infinity') } - assert_equal(1.0/0, parse('Infinity', :allow_nan => true)) + assert_equal(1.0/0, parse('Infinity', allow_nan: true)) assert_raise(ParserError) { parse('-Infinity') } - assert_equal(-1.0/0, parse('-Infinity', :allow_nan => true)) + assert_equal(-1.0/0, parse('-Infinity', allow_nan: true)) capture_output { assert_equal(Float::INFINITY, parse("23456789012E666")) } end @@ -258,9 +258,9 @@ def test_parse_json_primitive_values assert_equal_float 3.141, parse('3.141'), 1E-3 assert_equal 2 ** 64, parse('18446744073709551616') assert_equal 'foo', parse('"foo"') - assert parse('NaN', :allow_nan => true).nan? - assert parse('Infinity', :allow_nan => true).infinite? - assert parse('-Infinity', :allow_nan => true).infinite? + assert parse('NaN', allow_nan: true).nan? + assert parse('Infinity', allow_nan: true).infinite? + assert parse('-Infinity', allow_nan: true).infinite? end def test_parse_arrays_with_allow_trailing_comma @@ -471,17 +471,17 @@ def test_some_wrong_inputs def test_symbolize_names assert_equal({ "foo" => "bar", "baz" => "quux" }, parse('{"foo":"bar", "baz":"quux"}')) - assert_equal({ :foo => "bar", :baz => "quux" }, - parse('{"foo":"bar", "baz":"quux"}', :symbolize_names => true)) + assert_equal({ foo: "bar", baz: "quux" }, + parse('{"foo":"bar", "baz":"quux"}', symbolize_names: true)) end def test_freeze - assert_predicate parse('{}', :freeze => true), :frozen? - assert_predicate parse('[]', :freeze => true), :frozen? - assert_predicate parse('"foo"', :freeze => true), :frozen? + assert_predicate parse('{}', freeze: true), :frozen? + assert_predicate parse('[]', freeze: true), :frozen? + assert_predicate parse('"foo"', freeze: true), :frozen? - assert_same(-'foo', parse('"foo"', :freeze => true)) - assert_same(-'foo', parse('{"foo": 1}', :freeze => true).keys.first) + assert_same(-'foo', parse('"foo"', freeze: true)) + assert_same(-'foo', parse('{"foo": 1}', freeze: true).keys.first) end def test_parse_comments @@ -544,14 +544,14 @@ def test_nesting too_deep = '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]' too_deep_ary = eval too_deep assert_raise(JSON::NestingError) { parse too_deep } - assert_raise(JSON::NestingError) { parse too_deep, :max_nesting => 100 } - ok = parse too_deep, :max_nesting => 101 + assert_raise(JSON::NestingError) { parse too_deep, max_nesting: 100 } + ok = parse too_deep, max_nesting: 101 assert_equal too_deep_ary, ok - ok = parse too_deep, :max_nesting => nil + ok = parse too_deep, max_nesting: nil assert_equal too_deep_ary, ok - ok = parse too_deep, :max_nesting => false + ok = parse too_deep, max_nesting: false assert_equal too_deep_ary, ok - ok = parse too_deep, :max_nesting => 0 + ok = parse too_deep, max_nesting: 0 assert_equal too_deep_ary, ok end @@ -702,14 +702,14 @@ def shifted? end def test_parse_array_custom_array_derived_class - res = parse('[1,2]', :array_class => SubArray) + res = parse('[1,2]', array_class: SubArray) assert_equal([1,2], res) assert_equal(SubArray, res.class) assert res.shifted? end def test_parse_array_custom_non_array_derived_class - res = parse('[1,2]', :array_class => SubArrayWrapper) + res = parse('[1,2]', array_class: SubArrayWrapper) assert_equal([1,2], res.data) assert_equal(1, res[0]) assert_equal(SubArrayWrapper, res.class) @@ -748,7 +748,7 @@ def self.json_create(o) end def test_parse_object_custom_hash_derived_class - res = parse('{"foo":"bar"}', :object_class => SubHash) + res = parse('{"foo":"bar"}', object_class: SubHash) assert_equal({"foo" => "bar"}, res) assert_equal(SubHash, res.class) assert res.item_set? @@ -775,7 +775,7 @@ def method_missing(name, ...) end def test_parse_object_custom_non_hash_derived_class - res = parse('{"foo":"bar"}', :object_class => OpenStructLike) + res = parse('{"foo":"bar"}', object_class: OpenStructLike) assert_equal "bar", res.foo assert_equal "bar", res[:foo] assert_equal(OpenStructLike, res.class) From 3c4bd96d35cec11019d33d863403081d27aa3732 Mon Sep 17 00:00:00 2001 From: Nobuyoshi Nakada Date: Mon, 17 Aug 2026 19:14:58 +0900 Subject: [PATCH 2/4] [ruby/digest] Revert #140 in favor of #141 Revert commits: - "Pass config macros via command line" https://github.com/ruby/digest/commit/d3bcdccba396 - "Don't use _Atomic in C99 mode" https://github.com/ruby/digest/commit/505c2d159fe0 https://github.com/ruby/digest/commit/9be283b4ad --- ext/digest/blake3/extconf.rb | 19 +------------------ 1 file changed, 1 insertion(+), 18 deletions(-) diff --git a/ext/digest/blake3/extconf.rb b/ext/digest/blake3/extconf.rb index 05c98507ef44fd..e175bd26331eeb 100644 --- a/ext/digest/blake3/extconf.rb +++ b/ext/digest/blake3/extconf.rb @@ -82,26 +82,9 @@ def blake3_have_isa?(name, flag, snippet) have_header("sys/cdefs.h") -checking_for("C11 atomics") do - ok = try_compile(<<~C) - static _Atomic int atomic_int = 0; - static int t(void) {return atomic_int;} - #{MAIN_DOES_NOTHING 't'} - C - unless ok - $defs << "-DBLAKE3_ATOMICS=0" - end - ok -end - $preload = %w[digest] -create_makefile("digest/blake3") do |mk| - mk.grep(/^CPPFLAGS *=/) {|m| - m.sub!(/(?=-DRUBY_EXTCONF_H)/) {[$defs, ''].join(' ')} - } - mk -end +create_makefile("digest/blake3") # Emit one explicit compile rule per SIMD backend so each gets its own # instruction-set flag. mkmf's implicit .c.o rule compiles every object with From 1ee1a563c5d61659393baf89480d8a9f7ac49c79 Mon Sep 17 00:00:00 2001 From: Nobuyoshi Nakada Date: Sun, 16 Aug 2026 19:38:59 +0900 Subject: [PATCH 3/4] [ruby/digest] nmake defines `$<` only in suffix rules https://github.com/ruby/digest/commit/0f7d7c9f78 --- ext/digest/blake3/extconf.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/digest/blake3/extconf.rb b/ext/digest/blake3/extconf.rb index e175bd26331eeb..e57793db570f35 100644 --- a/ext/digest/blake3/extconf.rb +++ b/ext/digest/blake3/extconf.rb @@ -99,7 +99,7 @@ def blake3_have_isa?(name, flag, snippet) simd_cflags.each do |obj, flag| target = "#{obj}.#{$OBJEXT}" mf.puts "#{target}: $(srcdir)/#{obj}.c" - mf.puts "\t$(ECHO) compiling $(<)" + mf.puts "\t$(ECHO) compiling #{obj}.c" mf.puts "\t$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) #{flag} $(COUTFLAG)$@ -c $(CSRCFLAG)$(srcdir)/#{obj}.c" end end From b378be33d3d2525a5cf743a1ef4c8c7071ecd50b Mon Sep 17 00:00:00 2001 From: Nobuyoshi Nakada Date: Sun, 16 Aug 2026 20:01:14 +0900 Subject: [PATCH 4/4] [ruby/digest] Fix SIMD cflags detection for Visual C Architechture option is not standardized. As of Visual Studio 18, it does not have `-m` option. https://github.com/ruby/digest/commit/90ae46bb2c --- ext/digest/blake3/extconf.rb | 24 +++++++++++++----------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/ext/digest/blake3/extconf.rb b/ext/digest/blake3/extconf.rb index e57793db570f35..c4706593ba6cd2 100644 --- a/ext/digest/blake3/extconf.rb +++ b/ext/digest/blake3/extconf.rb @@ -31,7 +31,7 @@ def blake3_disable(macro) # Probe used to confirm the compiler both accepts +flag+ and can compile the # intrinsics the backend relies on. def blake3_have_isa?(name, flag, snippet) - checking_for("#{name} intrinsics (#{flag})") do + checking_for("#{name} intrinsics" + (flag ? " (#{flag})" : "")) do try_compile(snippet, flag) end end @@ -40,27 +40,29 @@ def blake3_have_isa?(name, flag, snippet) when /\A(x86_64|amd64|x64)\z/i # Try to detect which SIMD features this x86 machine and compiler has x86_backends = [ - ["blake3_sse2", "SSE2", "-msse2", + ["blake3_sse2", "SSE2", ["-msse2", "-arch:SSE2"], "#include \nint main(void){ volatile __m128i x = _mm_setzero_si128(); (void)x; return 0; }\n", "BLAKE3_NO_SSE2"], - ["blake3_sse41", "SSE4.1", "-msse4.1", + ["blake3_sse41", "SSE4.1", ["-msse4.1", "-arch:AVX"], "#include \nint main(void){ volatile __m128i x = _mm_setzero_si128(); return _mm_testz_si128(x, x); }\n", "BLAKE3_NO_SSE41"], - ["blake3_avx2", "AVX2", "-mavx2", + ["blake3_avx2", "AVX2", ["-mavx2", "-arch:AVX2"], "#include \nint main(void){ volatile __m256i x = _mm256_setzero_si256(); (void)x; return 0; }\n", "BLAKE3_NO_AVX2"], - ["blake3_avx512", "AVX-512", "-mavx512f -mavx512vl", + ["blake3_avx512", "AVX-512", ["-mavx512f -mavx512vl", "-arch:AVX512"], "#include \nint main(void){ volatile __m512i x = _mm512_setzero_si512(); (void)x; return 0; }\n", "BLAKE3_NO_AVX512"], ] - x86_backends.each do |obj, name, flag, snippet, no_macro| - if blake3_have_isa?(name, flag, snippet) - objs << obj - simd_cflags[obj] = flag - else + x86_backends.each do |obj, name, flags, snippet, no_macro| + [nil, *flags].any? do |flag| + if blake3_have_isa?(name, flag, snippet) + objs << obj + simd_cflags[obj] = flag + true + end + end or blake3_disable(no_macro) - end end when /\A(aarch64|arm64)\z/i # NEON is part of the AArch64 baseline, so no runtime detection or special