sin_deep_merge 1.0.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 668e1937a83c6eb5dc101ee1412bfc3ccee4a8eae0acda798f524b43b0483539
-  data.tar.gz: b63c85ff319bee536d2ee92c42bdc30533e67b691db2d67455851ca99bdaed7b
+  metadata.gz: 9c0de78531accd5e3c4de48840657ad242cfae56cc25da3af72c2f40f96c613f
+  data.tar.gz: 9a2d92dbc4ed62240558fdb49b1941bb8bfe8c882735e9d40058b62d7018a26b
 SHA512:
-  metadata.gz: 8f974b808bd991ca5da998e4bc36591a94096d523cf02a7f23ff1a2fd27e645d6e4c8b9889b679b1b6efaf09ad11bc5b38b8181db914e9128d3f04ee73bcea73
-  data.tar.gz: f29b8af3fbc7df6de7f940a878beecca72af8fca5af239cbb2ef49e9808ea51dc37de0701d2ddb158cfaa7c4ddaf71ce828bf3e6a8bdecc9d87c22139e4b24ff
+  metadata.gz: 9115d25940608f6d6a983c3ce023072f25baf3e1e3e880314bd49ac69bd3bbb1c3ac8af025a01cda7db03ac2e6b39da7f68943edcc476af1c6c962ca02c09555
+  data.tar.gz: 28ed98467cb848f6e7bbee14da77682e52acbfa081a11993d7bff9a660503cf7d90afe19051833b93e5a97a35812e0c333e75b832ef0ad845dee581542e6c1be

data/CHANGELOG.md

@@ -0,0 +1,124 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [2.0.0] - 2026-08-10
+
+### Added
+
+- Add Ractor support (C, Java)
+- Add `SinDeepMerge::Fallback` and route Hash subclasses that override `merge!` or `update` such as `ActiveSupport::HashWithIndifferentAccess` through it (C, Java)
+
+### Fixed
+
+- Merge nested hashes into copies in `deep_merge!` so that a shared or frozen nested hash is never mutated in place (C)
+- Raise `TypeError` for non-Hash argument (C)
+- Raise `SystemStackError` instead of crashing on deeply nested hashes (Java)
+- Prevent crash on repeated stack overflow (C)
+- Fix `ClassCastException` for non-Symbol keys (Java)
+- Align `deep_merge` and `deep_merge!` arity across C and Java
+- Load Java extension without `JRuby::Util.load_ext`
+- Include files under lib in packaged gem
+- Install C extension under `sin_deep_merge` directory
+- Keep stray compiled jar out of packaged gem
+
+### Changed
+
+- Optimize block invocation by yielding directly instead of allocating a Proc (C)
+- Skip `initialize_dup` when copying hashes (C)
+- Simplify native extension loading
+- Improve readability of C extension
+- Remove unneeded json gem dependency
+- Minimize gem version constraints
+- Add JRuby build and test script
+- Make test task depend on compile
+- Recompile jar
+- Rework benchmark to compare like for like and report measurement error
+- Add Ractor, Hash subclass and key type test coverage
+- Update Ruby and JRuby versions in CI matrix
+- Verify committed jar matches Java source in CI
+- Require tests to pass before releasing in CI
+- Pin `google-java-format` version and fail on download errors in CI
+- Update `actions/checkout` v6 to v7 in CI
+- Remove assign workflow
+- Update sponsor link to GitHub Sponsors
+- Update README.md
+- Update .gitignore
+- Update .rubocop.yml
+
+## [1.0.2] - 2026-02-22
+
+### Changed
+
+- Recompile jar
+
+## [1.0.1] - 2026-02-21
+
+### Fixed
+
+- Add frozen check for `deep_merge!` to raise `FrozenError` on frozen Hash (C, Java)
+- Fix `deep_merge!` in Java to modify nested hashes in-place instead of duplicating them
+
+### Changed
+
+- Optimize block invocation in C by using `rb_funcallv` instead of `rb_proc_call` with temporary Array allocation
+- Optimize hash lookup in Java by using `fastARef` instead of `op_aref`
+- Skip `to_hash` conversion when argument is already a Hash (C)
+- Add `Check_Type` validation after `to_hash` conversion to ensure type safety (C)
+- Use previously unused `id_call` variable for block invocation via `rb_funcallv` (C)
+- Add TruffleRuby compatibility (Gemfile, C)
+- Pin gem versions in Gemfile
+- Refactor benchmark scripts into a single unified runner
+- Add `.clang-format` configuration
+- Add C and Java lint to CI (`clang-format`, `google-java-format`)
+- Update `actions/checkout` v4 to v6 in CI
+- Update .gitignore
+- Update README.md benchmark results
+
+## [1.0.0] - 2025-08-11
+
+### Changed
+
+- Improve performance
+
+### Fixed
+
+- Update tests
+- Update .gitignore
+- Improve lint CI
+- Update README.md
+
+## [0.0.2] - 2025-03-18
+
+### Changed
+
+- Update summary
+
+## [0.0.1] - 2025-03-12
+
+### Fixed
+
+- Fix permission
+
+### Changed
+
+- Update tests
+- Update summary
+- Update README.md
+
+## [0.0.0] - 2025-03-11
+
+### Added
+
+- Initial release
+
+[2.0.0]: https://github.com/cadenza-tech/sin_deep_merge/compare/v1.0.2...v2.0.0
+[1.0.2]: https://github.com/cadenza-tech/sin_deep_merge/compare/v1.0.1...v1.0.2
+[1.0.1]: https://github.com/cadenza-tech/sin_deep_merge/compare/v1.0.0...v1.0.1
+[1.0.0]: https://github.com/cadenza-tech/sin_deep_merge/compare/v0.0.2...v1.0.0
+[0.0.2]: https://github.com/cadenza-tech/sin_deep_merge/compare/v0.0.1...v0.0.2
+[0.0.1]: https://github.com/cadenza-tech/sin_deep_merge/compare/v0.0.0...v0.0.1
+[0.0.0]: https://github.com/cadenza-tech/sin_deep_merge/releases/tag/v0.0.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Masahiro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,191 @@
+# SinDeepMerge
+
+[![License](https://img.shields.io/github/license/cadenza-tech/sin_deep_merge?label=License&labelColor=343B42&color=blue)](https://github.com/cadenza-tech/sin_deep_merge/blob/main/LICENSE.txt) [![Tag](https://img.shields.io/github/tag/cadenza-tech/sin_deep_merge?label=Tag&logo=github&labelColor=343B42&color=2EBC4F)](https://github.com/cadenza-tech/sin_deep_merge/blob/main/CHANGELOG.md) [![Release](https://github.com/cadenza-tech/sin_deep_merge/actions/workflows/release.yml/badge.svg)](https://github.com/cadenza-tech/sin_deep_merge/actions?query=workflow%3Arelease) [![Test](https://github.com/cadenza-tech/sin_deep_merge/actions/workflows/test.yml/badge.svg)](https://github.com/cadenza-tech/sin_deep_merge/actions?query=workflow%3Atest) [![Lint](https://github.com/cadenza-tech/sin_deep_merge/actions/workflows/lint.yml/badge.svg)](https://github.com/cadenza-tech/sin_deep_merge/actions?query=workflow%3Alint)
+
+Merge deeply nested hashes faster than DeepMerge or ActiveSupport.
+
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Hash#deep\_merge](#hashdeep_merge)
+  - [Hash#deep\_merge!](#hashdeep_merge-1)
+- [Benchmark](#benchmark)
+- [Changelog](#changelog)
+- [Development](#development)
+  - [Building for JRuby](#building-for-jruby)
+- [Contributing](#contributing)
+- [License](#license)
+- [Code of Conduct](#code-of-conduct)
+- [Sponsor](#sponsor)
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add sin_deep_merge
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install sin_deep_merge
+```
+
+## Usage
+
+Both methods can be called inside non-main Ractors on CRuby 3.0+.
+
+Requiring ActiveSupport afterwards is safe from 7.1 on, where Hash reaches both methods through `ActiveSupport::DeepMergeable` and a method defined on Hash itself wins over an included module. Up to 7.0 ActiveSupport defines them on Hash directly and replaces these when `active_support/core_ext/hash/deep_merge` is loaded last, so require `sin_deep_merge` after ActiveSupport there. `Hash.instance_method(:deep_merge).source_location` is `nil` while the extension is the one in place.
+
+### Hash#deep_merge
+
+SinDeepMerge's Hash#deep_merge is compatible with ActiveSupport's Hash#deep_merge.
+
+Hash subclasses that override `merge!` or `update`, such as `ActiveSupport::HashWithIndifferentAccess`, are merged through that override, so they behave the same as with ActiveSupport. Such a merge runs in Ruby rather than in the extension, so it is no faster than ActiveSupport.
+
+What SinDeepMerge recurses into is any pair of Hashes, where ActiveSupport asks its `deep_merge?` hook instead. Two cases follow from that: a value that includes `ActiveSupport::DeepMergeable` without being a Hash is replaced rather than merged into, and a Hash subclass that overrides `deep_merge?` to refuse a value is merged into all the same.
+
+```ruby
+require 'sin_deep_merge'
+
+hash1 = { a: 1, b: '2', c: :three, d: true, e: nil }
+hash2 = { b: :two, c: nil, d: false, e: 0, f: 'f' }
+hash1.deep_merge(hash2) # => { a: 1, b: :two, c: nil, d: false, e: 0, f: 'f' }
+
+hash1 = { a: [1, 2], b: [3, 4] }
+hash2 = { a: [3, 4], b: 5 }
+hash1.deep_merge(hash2) # => { a: [3, 4], b: 5 }
+
+hash1 = { a: { b: 1, c: 2 }, b: { c: 3 } }
+hash2 = { a: { c: 3, d: 4 }, b: 5 }
+hash1.deep_merge(hash2) # => { a: { b: 1, c: 3, d: 4 }, b: 5 }
+
+hash1 = { a: 1, b: 2 }
+hash2 = { b: 3, c: 4 }
+hash1.deep_merge(hash2) { |_key, old_val, new_val| old_val + new_val } # => { a: 1, b: 5, c: 4 }
+
+hash1 = { a: [1, 2], b: 3 }
+hash2 = { a: [3, 4], b: 5 }
+hash1.deep_merge(hash2) do |_key, old_val, new_val|
+  if old_val.is_a?(Array) && new_val.is_a?(Array)
+    old_val + new_val
+  else
+    new_val
+  end
+end # => { a: [1, 2, 3, 4], b: 5 }
+```
+
+### Hash#deep_merge!
+
+SinDeepMerge's Hash#deep_merge! is compatible with ActiveSupport's Hash#deep_merge!.
+
+Hash#deep_merge! destructively updates self by merging new values into it. Like ActiveSupport, nested hashes are merged into copies, so a nested hash shared with another object or a frozen nested hash is never mutated in place.
+
+One case differs: a plain Hash carrying a singleton `merge!` is written into by the extension, so that override never runs, where ActiveSupport reaches it. Hash#deep_merge is not affected, since ActiveSupport merges into a `dup` there, and a `dup` no longer carries the singleton method.
+
+## Benchmark
+
+SinDeepMerge's Hash#deep_merge is about 2.5-2.7x faster than ActiveSupport's Hash#deep_merge, and SinDeepMerge's Hash#deep_merge! is about 4.4x faster than DeepMerge's Hash#deep_merge! and about 2.4x faster than ActiveSupport's Hash#deep_merge!.
+
+The first four tables hold only methods that leave the hash they were called on alone, so every iteration of the timed loop repeats the work of the first. DeepMerge is absent from them because it has no such method: its Hash#deep_merge writes into the receiver and returns it, the same as its Hash#deep_merge!. It also reads its second argument as an options Hash rather than as a block, so it has no block form either.
+
+The last table is the one DeepMerge belongs in. Its entry there is Hash#deep_merge! rather than Hash#deep_merge, because Hash#deep_merge leaves an existing value alone where the other two overwrite it, and on these inputs it would walk the hash without writing anything. Every row there merges into a receiver that already carries the merge from the second iteration on. These inputs keep their shape once merged, so that costs little, but an input that grew the receiver would flatter each library by a different amount. Read those ratios as the rough comparison they are rather than as the measurement the first four tables give.
+
+```bash
+$ bundle exec rake benchmark
+Benchmarking: Shallow Recursion...
+Benchmarking: Shallow Recursion With Block...
+Benchmarking: Deep Recursion...
+Benchmarking: Deep Recursion With Block...
+Benchmarking: Deep Recursion In Place...
+
++--------------------------------------------------------------------------+
+|                   Benchmark Result (Shallow Recursion)                   |
++----------------------------+----------------------+--------+-------------+
+| Name                       | Iteration Per Second | Error  | Speed Ratio |
++----------------------------+----------------------+--------+-------------+
+| SinDeepMerge - deep_merge  | 2678917.7            | ±0.56% | Fastest     |
+| Scratch - deep_merge       | 1251682.2            | ±0.55% | 2.1x slower |
+| ActiveSupport - deep_merge | 1006374.4            | ±0.53% | 2.7x slower |
++----------------------------+----------------------+--------+-------------+
+
++---------------------------------------------------------------------------------------------------------+
+|                             Benchmark Result (Shallow Recursion With Block)                             |
++-----------------------------------------------------------+----------------------+--------+-------------+
+| Name                                                      | Iteration Per Second | Error  | Speed Ratio |
++-----------------------------------------------------------+----------------------+--------+-------------+
+| SinDeepMerge - deep_merge (Shallow Recursion With Block)  | 2283373.8            | ±0.62% | Fastest     |
+| Scratch - deep_merge (Shallow Recursion With Block)       | 1100891.3            | ±0.50% | 2.1x slower |
+| ActiveSupport - deep_merge (Shallow Recursion With Block) | 913719.8             | ±0.68% | 2.5x slower |
++-----------------------------------------------------------+----------------------+--------+-------------+
+
++--------------------------------------------------------------------------+
+|                    Benchmark Result (Deep Recursion)                     |
++----------------------------+----------------------+--------+-------------+
+| Name                       | Iteration Per Second | Error  | Speed Ratio |
++----------------------------+----------------------+--------+-------------+
+| SinDeepMerge - deep_merge  | 28403.8              | ±0.78% | Fastest     |
+| Scratch - deep_merge       | 12948.1              | ±0.76% | 2.2x slower |
+| ActiveSupport - deep_merge | 11271.6              | ±0.45% | 2.5x slower |
++----------------------------+----------------------+--------+-------------+
+
++------------------------------------------------------------------------------------------------------+
+|                             Benchmark Result (Deep Recursion With Block)                             |
++--------------------------------------------------------+----------------------+--------+-------------+
+| Name                                                   | Iteration Per Second | Error  | Speed Ratio |
++--------------------------------------------------------+----------------------+--------+-------------+
+| SinDeepMerge - deep_merge (Deep Recursion With Block)  | 27810.9              | ±0.58% | Fastest     |
+| Scratch - deep_merge (Deep Recursion With Block)       | 12943.0              | ±0.47% | 2.1x slower |
+| ActiveSupport - deep_merge (Deep Recursion With Block) | 10803.1              | ±0.56% | 2.6x slower |
++--------------------------------------------------------+----------------------+--------+-------------+
+
++---------------------------------------------------------------------------+
+|                Benchmark Result (Deep Recursion In Place)                 |
++-----------------------------+----------------------+--------+-------------+
+| Name                        | Iteration Per Second | Error  | Speed Ratio |
++-----------------------------+----------------------+--------+-------------+
+| SinDeepMerge - deep_merge!  | 27075.8              | ±0.66% | Fastest     |
+| ActiveSupport - deep_merge! | 11284.2              | ±0.44% | 2.4x slower |
+| DeepMerge - deep_merge!     | 6089.0               | ±0.62% | 4.4x slower |
++-----------------------------+----------------------+--------+-------------+
+```
+
+Each row's error is how much its own measurement moved within that run, which is not how far that run sits from the next one. A run taken while the machine was busy reported errors just as narrow as these and ratios well away from these, so the numbers above are from a quiet machine and from two runs that agreed to within 0.1.
+
+The error is also what decides the Speed Ratio column: a row is labelled Fastest when its gap to the top row is narrower than the two errors together, because a gap that small is the measurement failing to separate them rather than a difference it found. More than one row can therefore read Fastest.
+
+The benchmark was executed in the following environment:
+
+- Ruby 4.0.6 (2026-07-14 revision 03b6d3f889) +YJIT +PRISM [arm64-darwin25]
+- DeepMerge 1.2.2
+- ActiveSupport 8.1.3.1
+
+## Changelog
+
+See [CHANGELOG.md](https://github.com/cadenza-tech/sin_deep_merge/blob/main/CHANGELOG.md).
+
+## Development
+
+### Building for JRuby
+
+To build the Java extension and run tests for JRuby support:
+
+```bash
+./script/jruby_build_and_test.sh
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/cadenza-tech/sin_deep_merge. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/cadenza-tech/sin_deep_merge/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://github.com/cadenza-tech/sin_deep_merge/blob/main/LICENSE.txt).
+
+## Code of Conduct
+
+Everyone interacting in the SinDeepMerge project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/cadenza-tech/sin_deep_merge/blob/main/CODE_OF_CONDUCT.md).
+
+## Sponsor
+
+You can sponsor this project on [GitHub Sponsors](https://github.com/sponsors/cadenza-tech).

data/Rakefile

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'rubocop/rake_task'
+require 'rubygems/package_task'
+
+gemspec = Gem::Specification.load("#{__dir__}/sin_deep_merge.gemspec")
+
+if RUBY_ENGINE == 'jruby'
+  require 'rake/javaextensiontask'
+
+  Rake::JavaExtensionTask.new('sin_deep_merge', gemspec) do |task|
+    task.ext_dir = 'ext/java'
+    task.source_version = '1.8'
+    task.target_version = '1.8'
+  end
+else
+  require 'rake/extensiontask'
+
+  Rake::ExtensionTask.new('sin_deep_merge', gemspec) do |task|
+    task.lib_dir = 'lib/sin_deep_merge'
+  end
+end
+
+Gem::PackageTask.new(gemspec)
+
+Rake::TestTask.new(:test) do |task|
+  task.pattern = 'test/**/test_*.rb'
+end
+
+# Without this the suite happily runs against a stale binary, so a changed extension looks like it passed.
+Rake::Task[:test].enhance([:compile])
+
+RuboCop::RakeTask.new(:rubocop) do |task|
+  task.options = ['--format', ENV['RUBOCOP_FORMAT']] if ENV['RUBOCOP_FORMAT']
+end
+
+task benchmark: [:compile] do
+  RubyVM::YJIT.enable if defined?(RubyVM::YJIT) && !RubyVM::YJIT.enabled?
+
+  require_relative 'script/deep_merge_benchmark'
+
+  DeepMergeBenchmark.run
+end

data/ext/sin_deep_merge/extconf.rb

@@ -2,4 +2,12 @@
 
 require 'mkmf'
 
-create_makefile 'sin_deep_merge'
+# rb_ext_ractor_safe() arrived in Ruby 3.0 and the gem still supports 2.3, so Init_sin_deep_merge guards its call on this.
+have_func('rb_ext_ractor_safe')
+# TruffleRuby has no ruby_stack_check(), so deep_merge_hashes guards its stack check on this.
+have_func('ruby_stack_check')
+have_var('rb_eSysStackError', 'ruby.h')
+# rb_hash_dup() skips the initialize_dup dispatch rb_obj_dup() pays for, and deep_merge_hash_dup falls back to the latter without it.
+have_func('rb_hash_dup')
+
+create_makefile 'sin_deep_merge/sin_deep_merge'

data/ext/sin_deep_merge/sin_deep_merge.c

@@ -1,91 +1,119 @@
 #include <ruby.h>
 
-static ID id_call;
-static ID id_to_hash;
+#if defined(HAVE_RUBY_STACK_CHECK) && defined(HAVE_RB_ESYSSTACKERROR)
+#define DEEP_MERGE_STACK_GUARD
+#endif
 
 typedef struct {
   VALUE hash;
-  VALUE block;
-  int destructive;
   int block_given;
 } deep_merge_context;
 
-static VALUE deep_merge_hashes(VALUE self, VALUE other, VALUE block, int destructive);
+/*
+ * Only plain hashes are ever copied here, a subclass being handed to SinDeepMerge::Fallback instead, and a plain hash has no
+ * initialize_copy of its own to run. That leaves rb_obj_dup() dispatching initialize_dup for nothing, which rb_hash_dup() skips.
+ *
+ * Before Ruby 3.3 that shortcut loses compare_by_identity from a hash holding nothing, since the flag lives on a table an empty hash has
+ * yet to allocate. Copying an empty hash costs the same either way, so it goes the general route and the shortcut is left to the rest.
+ */
+static VALUE deep_merge_hash_dup(VALUE hash) {
+#ifdef HAVE_RB_HASH_DUP
+  if (RHASH_SIZE(hash) > 0) return rb_hash_dup(hash);
+#endif
+
+  return rb_obj_dup(hash);
+}
+
+static VALUE deep_merge_hashes(VALUE self, VALUE other, int block_given);
+
+/*
+ * A Hash subclass may override merge! or update to police what gets stored, as ActiveSupport's HashWithIndifferentAccess does to keep its
+ * keys strings. rb_hash_aset writes past that override, so those receivers go to SinDeepMerge::Fallback, which is ActiveSupport's own
+ * implementation and therefore reaches the override through merge!. rb_obj_class sees through a singleton class, so a plain hash carrying
+ * singleton methods still takes the fast path.
+ */
+static int plain_hash_p(VALUE hash) { return rb_obj_class(hash) == rb_cHash; }
+
+static VALUE deep_merge_forward(VALUE recv, ID mid, int argc, const VALUE* argv) {
+  if (!rb_block_given_p()) return rb_funcallv(recv, mid, argc, argv);
+
+  /* rb_funcall_passing_block would spare the Proc, but Sulong lacks it up to TruffleRuby 22.3. */
+  return rb_funcall_with_block(recv, mid, argc, argv, rb_block_proc());
+}
+
+static VALUE deep_merge_fallback(VALUE self, VALUE other, const char* name) {
+  VALUE args[2] = {self, other};
+
+  return deep_merge_forward(rb_path2class("SinDeepMerge::Fallback"), rb_intern(name), 2, args);
+}
 
 static int deep_merge_iter(VALUE key, VALUE other_val, VALUE data) {
   deep_merge_context* ctx = (deep_merge_context*)data;
   VALUE current_val = rb_hash_lookup2(ctx->hash, key, Qundef);
-
-  if (current_val == Qundef) {
-    rb_hash_aset(ctx->hash, key, other_val);
-  } else if (RB_TYPE_P(current_val, T_HASH) && RB_TYPE_P(other_val, T_HASH)) {
-    VALUE merged;
-    if (ctx->destructive) {
-      merged = deep_merge_hashes(current_val, other_val, ctx->block, 1);
-    } else {
-      merged = deep_merge_hashes(rb_obj_dup(current_val), other_val, ctx->block, 0);
+  VALUE new_val = other_val;
+
+  /* An absent key takes other_val as is, which is what new_val already holds. */
+  if (current_val != Qundef) {
+    if (RB_TYPE_P(current_val, T_HASH) && RB_TYPE_P(other_val, T_HASH)) {
+      /* Merge into a copy like ActiveSupport so shared or frozen nested hashes are never mutated. */
+      new_val = plain_hash_p(current_val)
+                    ? deep_merge_hashes(deep_merge_hash_dup(current_val), other_val, ctx->block_given)
+                    /* ActiveSupport recurses as this_val.deep_merge(other_val), so a nested subclass gets its own override too. */
+                    : deep_merge_forward(current_val, rb_intern("deep_merge"), 1, &other_val);
+    } else if (ctx->block_given) {
+      /* Yield directly: no Proc to allocate, and it avoids rb_proc_call_with_block, which Sulong lacks up to TruffleRuby 23.0. */
+      new_val = rb_yield_values(3, key, current_val, other_val);
     }
-    rb_hash_aset(ctx->hash, key, merged);
-  } else if (ctx->block_given) {
-    VALUE args[3] = {key, current_val, other_val};
-    /* rb_funcallv for TruffleRuby compat (Sulong lacks rb_proc_call_with_block) */
-    VALUE result = rb_funcallv(ctx->block, id_call, 3, args);
-    rb_hash_aset(ctx->hash, key, result);
-  } else {
-    rb_hash_aset(ctx->hash, key, other_val);
   }
 
+  rb_hash_aset(ctx->hash, key, new_val);
+
   return ST_CONTINUE;
 }
 
-static VALUE deep_merge_hashes(VALUE self, VALUE other, VALUE block, int destructive) {
-  int block_given = !NIL_P(block);
-  deep_merge_context ctx = {self, block, destructive, block_given};
+static VALUE deep_merge_hashes(VALUE self, VALUE other, int block_given) {
+  deep_merge_context ctx = {self, block_given};
+
+#ifdef DEEP_MERGE_STACK_GUARD
+  /* Raise while stack remains; overflowing the machine stack guard from C recursion can crash the process on a later overflow. */
+  if (ruby_stack_check()) rb_raise(rb_eSysStackError, "stack level too deep");
+#endif
 
   rb_hash_foreach(other, deep_merge_iter, (VALUE)&ctx);
 
   return self;
 }
 
-static VALUE hash_deep_merge_bang(int argc, VALUE* argv, VALUE self) {
-  VALUE other;
-  rb_scan_args(argc, argv, "1", &other);
-  rb_check_frozen(self);
-  if (!RB_TYPE_P(other, T_HASH)) {
-    other = rb_funcall(other, id_to_hash, 0);
-    Check_Type(other, T_HASH);
-  }
-  VALUE block = Qnil;
-  if (rb_block_given_p()) {
-    block = rb_block_proc();
-  }
+static VALUE hash_deep_merge_bang(VALUE self, VALUE other) {
+  /* Hand over before converting other: a subclass may treat a Hash and a to_hash convertible differently, as merge! is free to. */
+  if (!plain_hash_p(self)) return deep_merge_fallback(self, other, "deep_merge!");
 
-  deep_merge_hashes(self, other, block, 1);
+  rb_check_frozen(self);
+  other = rb_convert_type(other, T_HASH, "Hash", "to_hash");
 
-  return self;
+  return deep_merge_hashes(self, other, rb_block_given_p());
 }
 
-static VALUE hash_deep_merge(int argc, VALUE* argv, VALUE self) {
-  VALUE other;
-  rb_scan_args(argc, argv, "1", &other);
-  if (!RB_TYPE_P(other, T_HASH)) {
-    other = rb_funcall(other, id_to_hash, 0);
-    Check_Type(other, T_HASH);
-  }
-  VALUE block = Qnil;
-  if (rb_block_given_p()) {
-    block = rb_block_proc();
-  }
+static VALUE hash_deep_merge(VALUE self, VALUE other) {
+  if (!plain_hash_p(self)) return deep_merge_fallback(self, other, "deep_merge");
 
-  VALUE duplicated = rb_obj_dup(self);
-  deep_merge_hashes(duplicated, other, block, 0);
+  other = rb_convert_type(other, T_HASH, "Hash", "to_hash");
 
-  return duplicated;
+  return deep_merge_hashes(deep_merge_hash_dup(self), other, rb_block_given_p());
 }
 
 void Init_sin_deep_merge(void) {
-  id_call = rb_intern("call");
-  id_to_hash = rb_intern("to_hash");
-  rb_define_method(rb_cHash, "deep_merge", RUBY_METHOD_FUNC(hash_deep_merge), -1);
-  rb_define_method(rb_cHash, "deep_merge!", RUBY_METHOD_FUNC(hash_deep_merge_bang), -1);
+  /*
+   * Declaring this is a promise, and what backs it is that there is no file-scope state at all, and that every write lands on a hash the
+   * calling Ractor owns: deep_merge builds a dup and writes into that, and deep_merge! is kept off a shareable receiver, which is frozen by
+   * definition, either by rb_check_frozen or by the frozen check merge! runs on the subclass path. The only thing reached for outside the
+   * arguments is the SinDeepMerge::Fallback constant, and a module is shareable. It has to run before the definitions, because what it marks
+   * is whatever is defined after it.
+   */
+#ifdef HAVE_RB_EXT_RACTOR_SAFE
+  rb_ext_ractor_safe(true);
+#endif
+
+  rb_define_method(rb_cHash, "deep_merge", RUBY_METHOD_FUNC(hash_deep_merge), 1);
+  rb_define_method(rb_cHash, "deep_merge!", RUBY_METHOD_FUNC(hash_deep_merge_bang), 1);
 }

data/lib/sin_deep_merge/fallback.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module SinDeepMerge
+  # ActiveSupport's implementation, kept for Hash subclasses that override merge! or update, ActiveSupport's
+  # HashWithIndifferentAccess being the common one. The extensions write straight into the storage of the hash, which skips such an
+  # override, so they hand those receivers here instead. dup and merge! are called on the receiver so that its own overrides run.
+  module Fallback # :nodoc:
+    module_function
+
+    def deep_merge(hash, other_hash, &block)
+      deep_merge!(hash.dup, other_hash, &block)
+    end
+
+    def deep_merge!(hash, other_hash, &block)
+      hash.merge!(other_hash) do |key, this_val, other_val|
+        if this_val.is_a?(Hash) && other_val.is_a?(Hash)
+          this_val.deep_merge(other_val, &block)
+        elsif block
+          yield(key, this_val, other_val)
+        else
+          other_val
+        end
+      end
+    end
+  end
+end

data/lib/sin_deep_merge/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SinDeepMerge
+  VERSION = '2.0.0'
+end

data/lib/sin_deep_merge.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Hash
+  # Explicitly undefine method before redefining to avoid Ruby warnings.
+  undef_method(:deep_merge) if method_defined?(:deep_merge)
+  undef_method(:deep_merge!) if method_defined?(:deep_merge!)
+end
+
+# Both extensions look this up by name when they meet a Hash subclass, so it has to be in place before they can be called.
+require 'sin_deep_merge/fallback'
+
+case RUBY_ENGINE
+when 'jruby'
+  require 'jruby'
+  require 'sin_deep_merge/sin_deep_merge.jar'
+
+  Java::sin_deep_merge::SinDeepMergeLibrary.new.load(JRuby.runtime, false)
+else
+  # The extension-less require lets Ruby resolve the platform-specific shared library suffix (.bundle on macOS, .so elsewhere) via DLEXT.
+  require 'sin_deep_merge/sin_deep_merge'
+end
+
+require 'sin_deep_merge/version'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sin_deep_merge
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Masahiro
@@ -17,18 +17,25 @@ extensions:
 - ext/sin_deep_merge/extconf.rb
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
 - ext/sin_deep_merge/extconf.rb
 - ext/sin_deep_merge/sin_deep_merge.c
-homepage: https://github.com/cadenza-tech/sin_deep_merge/tree/v1.0.2
+- lib/sin_deep_merge.rb
+- lib/sin_deep_merge/fallback.rb
+- lib/sin_deep_merge/version.rb
+homepage: https://github.com/cadenza-tech/sin_deep_merge/tree/v2.0.0
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/cadenza-tech/sin_deep_merge/tree/v1.0.2
-  source_code_uri: https://github.com/cadenza-tech/sin_deep_merge/tree/v1.0.2
-  changelog_uri: https://github.com/cadenza-tech/sin_deep_merge/blob/v1.0.2/CHANGELOG.md
+  homepage_uri: https://github.com/cadenza-tech/sin_deep_merge/tree/v2.0.0
+  source_code_uri: https://github.com/cadenza-tech/sin_deep_merge/tree/v2.0.0
+  changelog_uri: https://github.com/cadenza-tech/sin_deep_merge/blob/v2.0.0/CHANGELOG.md
   bug_tracker_uri: https://github.com/cadenza-tech/sin_deep_merge/issues
-  documentation_uri: https://rubydoc.info/gems/sin_deep_merge/1.0.2
-  funding_uri: https://patreon.com/CadenzaTech
+  documentation_uri: https://rubydoc.info/gems/sin_deep_merge/2.0.0
+  funding_uri: https://github.com/sponsors/cadenza-tech
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -44,7 +51,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Merge deeply nested hashes faster than DeepMerge or ActiveSupport
 test_files: []