Add Ruby 4.0 support with minitest 6.x compatibility

- Update gemspec to allow minitest >= 5.0 (includes 6.x for Ruby 4.0)
- Update ci.yml to remove Gemfile.lock before bundle install
  for fresh dependency resolution per Ruby version
- Refactor tests to not use Object#stub (removed in minitest 6.x)
  - garbage_test.rb: manually create and call finalizer
  - finalize_freeze_test.rb: expose finalizer via class method

Test results:
- Ruby 2.6: 20 tests passed
- Ruby 3.3: 20 tests passed
- Ruby 4.0: 20 tests passed

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: koji-takao-sp

.github/workflows/ci.yml

@@ -20,6 +20,8 @@ jobs:
 
     steps:
     - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+    - name: Remove Gemfile.lock for fresh dependency resolution
+      run: rm -f Gemfile.lock
     - name: Set up Ruby
       uses: ruby/setup-ruby@4c24fa5ec04b2e79eb40571b1cee2a0d2b705771 # v1.278.0
       with:

schmooze.gemspec

@@ -19,5 +19,5 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.6.0'
   spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'minitest', '>= 5.0'
 end

test/finalize_freeze_test.rb

@@ -9,6 +9,11 @@ class LongRunningSchmoozer < Schmooze::Base
     # This method keeps the Node.js process running with a setTimeout
     # Even after stdin is closed, the process will wait for the timeout
     method :echo, 'function(x) { setTimeout(() => {}, 60000); return x; }'
+
+    # Expose the finalizer for testing
+    def self.create_finalizer(owner_pid, stdin, stdout, stderr, process_thread)
+      finalize(owner_pid, stdin, stdout, stderr, process_thread)
+    end
   end
 
   # Test that the finalizer does not hang when the process is still running.
@@ -21,19 +26,23 @@ class LongRunningSchmoozer < Schmooze::Base
   # The fix uses `Process.kill(:KILL, pid)` to actually terminate the process
   # before waiting for it.
   def test_finalizer_does_not_hang
-    finalizer = nil
-    pid = nil
+    # Create a schmoozer and get its internal state
+    schmoozer = LongRunningSchmoozer.new(__dir__)
+    schmoozer.echo("test")
+    pid = schmoozer.pid
 
-    # Capture the finalizer without letting it run automatically
-    ObjectSpace.stub :define_finalizer, proc { |_s, p| finalizer = p } do
-      schmoozer = LongRunningSchmoozer.new(__dir__)
-      schmoozer.echo("test")
-      pid = schmoozer.pid
+    # Get the internal process data
+    stdin = schmoozer.instance_variable_get(:@_schmooze_stdin)
+    stdout = schmoozer.instance_variable_get(:@_schmooze_stdout)
+    stderr = schmoozer.instance_variable_get(:@_schmooze_stderr)
+    process_thread = schmoozer.instance_variable_get(:@_schmooze_process_thread)
 
-      # Verify the process is running
-      assert pid, "Process should be running"
-      Process.kill(0, pid)  # Should not raise if process is running
-    end
+    # Create a finalizer manually (simulating what ObjectSpace.define_finalizer does)
+    finalizer = LongRunningSchmoozer.create_finalizer(Process.pid, stdin, stdout, stderr, process_thread)
+
+    # Verify the process is running
+    assert pid, "Process should be running"
+    Process.kill(0, pid)  # Should not raise if process is running
 
     # Run the finalizer with a timeout to detect hanging
     assert_raises_nothing_within(5) do
@@ -50,17 +59,24 @@ def test_finalizer_does_not_hang
   # This tests the scenario where GC.stress is enabled and many instances
   # are created and garbage collected.
   def test_finalizer_handles_multiple_instances_under_gc_pressure
-    pids = []
+    instances = []
     finalizers = []
 
-    ObjectSpace.stub :define_finalizer, proc { |_s, p| finalizers << p } do
-      5.times do
-        schmoozer = LongRunningSchmoozer.new(__dir__)
-        schmoozer.echo("test")
-        pids << schmoozer.pid
-      end
+    5.times do
+      schmoozer = LongRunningSchmoozer.new(__dir__)
+      schmoozer.echo("test")
+
+      stdin = schmoozer.instance_variable_get(:@_schmooze_stdin)
+      stdout = schmoozer.instance_variable_get(:@_schmooze_stdout)
+      stderr = schmoozer.instance_variable_get(:@_schmooze_stderr)
+      process_thread = schmoozer.instance_variable_get(:@_schmooze_process_thread)
+
+      instances << { schmoozer: schmoozer, pid: schmoozer.pid }
+      finalizers << LongRunningSchmoozer.create_finalizer(Process.pid, stdin, stdout, stderr, process_thread)
     end
 
+    pids = instances.map { |i| i[:pid] }
+
     assert_equal 5, pids.length
     assert_equal 5, finalizers.length
 
@@ -81,14 +97,17 @@ def test_finalizer_handles_multiple_instances_under_gc_pressure
   def test_finalizer_is_fork_safe
     skip "Fork not available on this platform" unless Process.respond_to?(:fork)
 
-    finalizer = nil
-    pid = nil
+    schmoozer = LongRunningSchmoozer.new(__dir__)
+    schmoozer.echo("test")
+    pid = schmoozer.pid
 
-    ObjectSpace.stub :define_finalizer, proc { |_s, p| finalizer = p } do
-      schmoozer = LongRunningSchmoozer.new(__dir__)
-      schmoozer.echo("test")
-      pid = schmoozer.pid
-    end
+    stdin = schmoozer.instance_variable_get(:@_schmooze_stdin)
+    stdout = schmoozer.instance_variable_get(:@_schmooze_stdout)
+    stderr = schmoozer.instance_variable_get(:@_schmooze_stderr)
+    process_thread = schmoozer.instance_variable_get(:@_schmooze_process_thread)
+
+    # Create finalizer with parent's PID
+    finalizer = LongRunningSchmoozer.create_finalizer(Process.pid, stdin, stdout, stderr, process_thread)
 
     # Fork and try to run finalizer in child
     child_pid = fork do

test/garbage_test.rb

@@ -3,6 +3,11 @@
 class GarbageTest < Minitest::Test
   class GarbageSchmoozer < Schmooze::Base
     method :test, 'function(){ return 1; }'
+
+    # Expose the finalizer for testing
+    def self.create_finalizer(owner_pid, stdin, stdout, stderr, process_thread)
+      finalize(owner_pid, stdin, stdout, stderr, process_thread)
+    end
   end
 
   def test_process_is_not_started_until_used
@@ -13,17 +18,24 @@ def test_process_is_not_started_until_used
   end
 
   def test_process_is_closed
-    # Hacky way to test the finalizer. There is no way to guarantee that the
-    # finalizer is called so instead we stub define_finalizer to call it immediately
-    finalizer = nil
-    ObjectSpace.stub :define_finalizer, proc {|s, p| finalizer = p} do
-      garbage = GarbageSchmoozer.new(__dir__)
-      garbage.test
-      pid = garbage.pid
-      finalizer.call
-      assert_raises Errno::ESRCH do
-        Process.kill(0, pid)
-      end
+    # Create an instance and get its internal state
+    garbage = GarbageSchmoozer.new(__dir__)
+    garbage.test
+    pid = garbage.pid
+
+    # Get the internal process data
+    stdin = garbage.instance_variable_get(:@_schmooze_stdin)
+    stdout = garbage.instance_variable_get(:@_schmooze_stdout)
+    stderr = garbage.instance_variable_get(:@_schmooze_stderr)
+    process_thread = garbage.instance_variable_get(:@_schmooze_process_thread)
+
+    # Create and call the finalizer manually
+    finalizer = GarbageSchmoozer.create_finalizer(Process.pid, stdin, stdout, stderr, process_thread)
+    finalizer.call
+
+    # Verify the process was killed
+    assert_raises Errno::ESRCH do
+      Process.kill(0, pid)
     end
   end
 end

test/test_helper.rb

@@ -2,3 +2,11 @@
 require 'schmooze'
 
 require 'minitest/autorun'
+
+# For minitest 6.x compatibility, try to require minitest/mock
+# This provides stub functionality
+begin
+  require 'minitest/mock'
+rescue LoadError
+  # minitest/mock not available, stub might still work in older versions
+end