ractor-rails-shim 0.2.4 → 0.2.6

data/lib/ractor_rails_shim/patches/make_shareable.rb

@@ -349,8 +349,16 @@ module RactorRailsShim
         # calls `#to_proc` and then requires the result to be a real Proc.
         # Return a frozen no-op lambda so the implicit conversion succeeds and
         # the (side-effect-free) call is a true no-op, matching `#call`.
+        #
+        # The lambda is a shareable constant (frozen at class load), NOT
+        # memoized on `@_to_proc`: NoOpProc instances are deep-frozen by
+        # `Ractor.make_shareable` during `make_app_shareable!`, so an
+        # `@_to_proc ||= ...` write would raise FrozenError on the frozen
+        # instance. A constant avoids the write entirely and is safe to share.
+        NO_OP_LAMBDA = ->(*) { nil }.freeze
+        Ractor.make_shareable(NO_OP_LAMBDA)
         def to_proc
-          @_to_proc ||= ->(*) { nil }.freeze
+          NO_OP_LAMBDA
         end
       end
       class Callable
@@ -539,7 +547,18 @@ module RactorRailsShim
     # Doesn't dedup procs — must replace every occurrence.
     def _replace_unshareable_procs!(app)
       mw = (app.instance_variable_get(:@app) rescue nil)
-      3.times do
+      # Replace every Proc in the graph. The same Proc object can live in
+      # many containers (e.g. deprecation behaviors shared across
+      # deprecators), and replacing one occurrence doesn't replace the
+      # others — so we loop until a fixed point (no Procs left). A safety
+      # cap guards against a pathological graph where replacement keeps
+      # introducing new Procs (the replacements themselves are NoOpProc/
+      # Callable instances, not Procs, so this shouldn't happen, but the
+      # cap prevents an infinite loop if a future callable class leaks a
+      # Proc). 3 passes was the original magic number; observed real graphs
+      # converge in 2.
+      max_passes = 8
+      max_passes.times do
         procs = _collect_procs(app)
         break if procs.empty?
         procs.each { |proc_obj, _path, parent, ivar| _replace_one_proc(proc_obj, parent, ivar, mw) }
@@ -573,28 +592,76 @@ module RactorRailsShim
         next if seen[o.object_id]
         seen[o.object_id] = true
         next if o.is_a?(Mutex) || o.is_a?(Monitor)
-        begin
-          o.instance_variables.each do |iv|
-            begin; v = o.instance_variable_get(iv); rescue; next; end
-            stack << [v, "#{_path}.#{iv}", o, iv] if v
-          end
-        rescue => e
-          # Some objects (BasicObject) don't support instance_variables
-        end
-        if o.is_a?(Array)
-          o.each_with_index { |e, i| stack << [e, "#{_path}[#{i}]", o, nil] if e }
-        elsif o.is_a?(Hash)
-          o.each do |k, val|
-            stack << [k, "#{_path}.key", o, nil] if k
-            stack << [val, "#{_path}[#{k.inspect}]", o, nil] if val
+        _each_ivar_and_child(o, _path) do |child, child_path, child_ivar|
+          if child_ivar == :__default_proc__
+            procs << [child, child_path, o, :__default_proc__]
+          else
+            stack << [child, child_path, o, child_ivar] if child
           end
-          dp = o.default_proc
-          procs << [dp, "#{_path}.default_proc", o, :__default_proc__] if dp
         end
       end
       procs
     end
 
+    # Enumerate every child reference of `o` for the graph traversals:
+    #   - instance variables (yields [value, "path.iv", iv])
+    #   - Array / Set / Enumerable members (yields [member, "path[i]", nil])
+    #   - Hash pairs (yields [key, "path.key", nil] and [val, "path[k]", nil])
+    #   - Hash#default_proc (yields [proc, "path.default_proc", :__default_proc__])
+    #   - Struct members (yields [value, "path.member", nil] via #each_pair)
+    #
+    # Pre-fix the traversals only handled Array and Hash, so a Mutex or Proc
+    # nested inside a Set (Rails uses Set in several caches, e.g.
+    # ActionDispatch::Journey::Routes) or a Struct was missed and left
+    # unshareable. Centralized here so _collect_procs and
+    # _replace_locks_and_concurrent_maps! share the same container coverage.
+    def _each_ivar_and_child(o, path)
+      begin
+        o.instance_variables.each do |iv|
+          begin; v = o.instance_variable_get(iv); rescue; next; end
+          yield v, "#{path}.#{iv}", iv
+        end
+      rescue => e
+        # BasicObject or frozen objects don't support instance_variables
+      end
+      if o.is_a?(Hash)
+        o.each do |k, val|
+          yield k, "#{path}.key", nil
+          yield val, "#{path}[#{k.inspect}]", nil
+        end
+        dp = o.default_proc
+        yield dp, "#{path}.default_proc", :__default_proc__ if dp
+      elsif o.is_a?(Array)
+        o.each_with_index { |e, i| yield e, "#{path}[#{i}]", nil }
+      elsif o.is_a?(::Set)
+        o.each_with_index { |e, i| yield e, "#{path}.set[#{i}]", nil }
+      elsif o.is_a?(::Struct)
+        o.each_pair { |name, val| yield val, "#{path}.#{name}", nil }
+      elsif _enumerable_but_not_basic?(o)
+        # Generic Enumerable fallback (Range, Enumerator, custom Enumerable
+        # mixes). Skip String/Hash/Array/Set/Struct — already handled. Best
+        # effort; rescue per-element in case #each raises for some members.
+        idx = -1
+        o.each do |e|
+          idx += 1
+          yield e, "#{path}.each[#{idx}]", nil
+        end rescue nil
+      end
+    end
+
+    # True if `o` is Enumerable but NOT one of the container types with a
+    # dedicated branch in _each_ivar_and_child. Used to gate the generic
+    # Enumerable fallback so we don't double-walk Array/Hash/etc.
+    def _enumerable_but_not_basic?(o)
+      return false unless o.is_a?(::Enumerable)
+      return false if o.is_a?(::Array) || o.is_a?(::Hash) || o.is_a?(::Set) || o.is_a?(::Struct)
+      return false if o.is_a?(::String) # String is Enumerable (chars) but not a container of refs we want
+      true
+    rescue NoMethodError
+      # BasicObject without Kernel — not Enumerable.
+      false
+    end
+
     def _replace_one_proc(proc_obj, parent, ivar, mw)
       src = proc_obj.source_location&.first || ""
       replacement =
@@ -619,8 +686,18 @@ module RactorRailsShim
         elsif src.end_with?(DEVISE_SCOPE_LOC)
           _devise_mapping_replacement(proc_obj, parent)
         elsif src.end_with?(MAPPER_LOC) && ivar == :@strategy
-          line = proc_obj.source_location[1]
-          line == 32 ? StrategyServe.new : StrategyCall.new
+          # Identify SERVE vs CALL by OBJECT IDENTITY against the actual
+          # ActionDispatch constants, NOT by source_location line number.
+          # The value stored in @strategy IS the constant object (Rails
+          # assigns it via `@strategy = strategy` where `strategy` is passed
+          # as Constraints::SERVE or Constraints::CALL), so `equal?` is the
+          # robust identifier — it survives any Rails patch release that
+          # shifts the constant definitions by a line or two, where the old
+          # `line == 32` check would silently swap the two strategies and
+          # break routing. Falls through to NoOpProc if the Proc isn't
+          # either constant (defensive: shouldn't happen, but never
+          # mis-route).
+          _strategy_replacement_for(proc_obj)
         else
           NoOpProc.new
         end
@@ -653,6 +730,22 @@ module RactorRailsShim
     # DeviseMappingCallable) now lives in warden.rb; `_find_files_server`
     # (Rack::Files target for the asset stack) now lives in rack.rb.
 
+    # Identify which ActionDispatch strategy a Proc is and return its
+    # shareable replacement. The Proc stored in
+    # `ActionDispatch::Routing::Mapper::Constraints#@strategy` is the
+    # constant `SERVE` or `CALL` (assigned by reference), so `equal?` is
+    # the robust identifier — independent of the source line number, which
+    # any Rails patch release can shift. Returns NoOpProc for an unknown
+    # Proc (defensive; never mis-route).
+    def _strategy_replacement_for(proc_obj)
+      constraints = defined?(::ActionDispatch::Routing::Mapper::Constraints) ?
+        ::ActionDispatch::Routing::Mapper::Constraints : nil
+      return NoOpProc.new unless constraints
+      return StrategyServe.new if proc_obj.equal?(constraints::SERVE)
+      return StrategyCall.new if proc_obj.equal?(constraints::CALL)
+      NoOpProc.new
+    end
+
     def _replace_locks_and_concurrent_maps!(app)
       seen = {}
       stack = [[app, "app", nil, nil]]
@@ -663,24 +756,20 @@ module RactorRailsShim
         next if seen[o.object_id]
         seen[o.object_id] = true
         next if o.is_a?(Mutex) || o.is_a?(Monitor)
-        begin
-          o.instance_variables.each do |iv|
-            begin; v = o.instance_variable_get(iv); rescue; next; end
-            if v.is_a?(Mutex) || v.is_a?(Monitor)
-              o.instance_variable_set(iv, NoOpLock.new) rescue nil
-            elsif defined?(::Concurrent::Map) && v.is_a?(::Concurrent::Map)
-              hash_copy = {}
-              v.each_pair { |k, val| hash_copy[k] = val }
-              o.instance_variable_set(iv, hash_copy) rescue nil
-            elsif v
-              stack << [v, "#{_p}.#{iv}", o, iv]
-            end
+        _each_ivar_and_child(o, _p) do |child, child_path, child_ivar|
+          next if child_ivar == :__default_proc__
+          if child.is_a?(Mutex) || child.is_a?(Monitor)
+            o.instance_variable_set(child_ivar, NoOpLock.new) rescue nil if child_ivar
+            # If the lock is in an Array/Set/Hash (no ivar), we can't swap
+            # it in place here — leave it; make_shareable will handle the
+            # frozen container. The ivar case is the load-bearing one.
+          elsif defined?(::Concurrent::Map) && child.is_a?(::Concurrent::Map) && child_ivar
+            hash_copy = {}
+            child.each_pair { |k, val| hash_copy[k] = val }
+            o.instance_variable_set(child_ivar, hash_copy) rescue nil
+          elsif child
+            stack << [child, child_path, o, child_ivar]
           end
-        rescue => e
-          # BasicObject or frozen objects don't support instance_variables
-        end
-        if o.is_a?(Array); o.each_with_index { |e, i| stack << [e, "#{_p}[#{i}]", o, nil] if e }
-        elsif o.is_a?(Hash); o.each { |k, val| stack << [k, "#{_p}.key", o, nil] if k; stack << [val, "#{_p}[#{k.inspect}]", o, nil] if val }
         end
       end
     end

data/lib/ractor_rails_shim/patches/mattr_accessor.rb

@@ -81,7 +81,7 @@ module RactorRailsShim
             singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{sym}
                 v = ActiveSupport::IsolatedExecutionState[#{key_str}]
-                return v unless v.nil?
+                return v if ActiveSupport::IsolatedExecutionState.key?(#{key_str})
 
                 if #{!!shareable}
                   if class_variable_defined?(#{cv_str})
@@ -128,7 +128,7 @@ module RactorRailsShim
               module_eval <<-RUBY, __FILE__, __LINE__ + 1
                 def #{sym}
                   v = ActiveSupport::IsolatedExecutionState[#{key_str}]
-                  return v unless v.nil?
+                  return v if ActiveSupport::IsolatedExecutionState.key?(#{key_str})
                   if Ractor.main?
                     self.class.class_variable_defined?(#{cv_str}) ? self.class.class_variable_get(#{cv_str}) : nil
                   else

data/lib/ractor_rails_shim/patches/orm_adapter.rb

@@ -21,7 +21,7 @@ module RactorRailsShim
         def to_adapter
           key = :"ractor_rails_shim_orm_adapter_\#{object_id}"
           v = ActiveSupport::IsolatedExecutionState[key]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(key)
           adapter = self::OrmAdapter.new(self)
           ActiveSupport::IsolatedExecutionState[key] = adapter
           adapter

data/lib/ractor_rails_shim/patches/rack.rb

@@ -56,7 +56,7 @@ module RactorRailsShim
       req.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def forwarded_priority
           v = ActiveSupport::IsolatedExecutionState[#{fp_key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{fp_key_str})
           if Ractor.main? && instance_variable_defined?(:@forwarded_priority)
             @forwarded_priority
           else
@@ -70,7 +70,7 @@ module RactorRailsShim
         end
         def x_forwarded_proto_priority
           v = ActiveSupport::IsolatedExecutionState[#{xp_key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{xp_key_str})
           if Ractor.main? && instance_variable_defined?(:@x_forwarded_proto_priority)
             @x_forwarded_proto_priority
           else
@@ -105,7 +105,7 @@ module RactorRailsShim
       u.singleton_class.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def default_query_parser
           v = ActiveSupport::IsolatedExecutionState[#{dqp_key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{dqp_key_str})
           if Ractor.main? && instance_variable_defined?(:@default_query_parser)
             v = @default_query_parser
             ActiveSupport::IsolatedExecutionState[#{dqp_key_str}] = v
@@ -116,7 +116,7 @@ module RactorRailsShim
         end
         def multipart_total_part_limit
           v = ActiveSupport::IsolatedExecutionState[#{mtp_key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{mtp_key_str})
           if Ractor.main? && instance_variable_defined?(:@multipart_total_part_limit)
             v = @multipart_total_part_limit
             ActiveSupport::IsolatedExecutionState[#{mtp_key_str}] = v
@@ -127,7 +127,7 @@ module RactorRailsShim
         end
         def multipart_file_limit
           v = ActiveSupport::IsolatedExecutionState[#{mfl_key_str}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{mfl_key_str})
           if Ractor.main? && instance_variable_defined?(:@multipart_file_limit)
             v = @multipart_file_limit
             ActiveSupport::IsolatedExecutionState[#{mfl_key_str}] = v

data/lib/ractor_rails_shim/patches/rails_module.rb

@@ -36,6 +36,13 @@ module RactorRailsShim
     # :class fires when `rails.rb` opens `module Rails` (module bodies fire
     # as :class); once the constant is assigned, we patch once and disable
     # the hook.
+    #
+    # Two flags are intentional and guard *different* things:
+    #   @rails_load_hook_installed — the TracePoint one-shot is armed (so we
+    #     don't stack multiple TracePoints on repeated `install` calls).
+    #   @rails_module_patched — the patch itself has been applied (checked
+    #     again inside the TracePoint block and in `patch_rails_module!`
+    #     because the immediate-path caller also goes through that method).
     def install_rails_load_hook
       return if @rails_load_hook_installed
       @rails_load_hook_installed = true
@@ -89,7 +96,7 @@ module RactorRailsShim
         # slot is empty until they boot their own app).
         def application
           v = ActiveSupport::IsolatedExecutionState[#{k[:application].inspect}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{k[:application].inspect})
           if Ractor.main?
             super
           else
@@ -108,7 +115,7 @@ module RactorRailsShim
         # value at make_app_shareable! time) when their own IES slot is empty.
         def app_class
           v = ActiveSupport::IsolatedExecutionState[#{k[:app_class].inspect}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{k[:app_class].inspect})
           return super if Ractor.main?
           RactorRailsShim::SHAREABLE_FALLBACK[#{k[:app_class].inspect}]
         end
@@ -120,7 +127,7 @@ module RactorRailsShim
 
         def cache
           v = ActiveSupport::IsolatedExecutionState[#{k[:cache].inspect}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{k[:cache].inspect})
           return super if Ractor.main?
           RactorRailsShim::SHAREABLE_FALLBACK[#{k[:cache].inspect}]
         end
@@ -132,7 +139,7 @@ module RactorRailsShim
 
         def logger
           v = ActiveSupport::IsolatedExecutionState[#{k[:logger].inspect}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{k[:logger].inspect})
           return super if Ractor.main?
           # Loggers are intrinsically mutable (formatters hold tag stacks,
           # logdevs hold IO + Mutex) and can't be shared read-only. Build a
@@ -152,7 +159,7 @@ module RactorRailsShim
 
         def backtrace_cleaner
           v = ActiveSupport::IsolatedExecutionState[#{k[:backtrace_cleaner].inspect}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{k[:backtrace_cleaner].inspect})
           return super if Ractor.main?
           RactorRailsShim::SHAREABLE_FALLBACK[#{k[:backtrace_cleaner].inspect}]
         end
@@ -167,7 +174,7 @@ module RactorRailsShim
         # lazily builds and caches in @_env.
         def env
           v = ActiveSupport::IsolatedExecutionState[#{k[:env].inspect}]
-          return v unless v.nil?
+          return v if ActiveSupport::IsolatedExecutionState.key?(#{k[:env].inspect})
           if Ractor.main?
             super
           else

data/lib/ractor_rails_shim/patches/zeitwerk_registry.rb

@@ -23,6 +23,13 @@ module RactorRailsShim
       else
         # Defer until Zeitwerk loads. A TracePoint(:class) fires when
         # `module Registry` opens. One-shot.
+        #
+        # Two flags guard different things (mirrors `rails_module.rb`):
+        #   @zeitwerk_patched          — `install_zeitwerk_registry` ran
+        #                                 (so we don't arm a second TracePoint).
+        #   @zeitwerk_registry_patched — the actual patch was applied (checked
+        #                                 again inside the TracePoint block and
+        #                                 in `patch_zeitwerk_registry!`).
         @zw_tp = TracePoint.new(:class) do |trace|
           if defined?(::Zeitwerk::Registry) && !@zeitwerk_registry_patched
             @zw_tp.disable
@@ -69,7 +76,7 @@ module RactorRailsShim
         reader_patch.module_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{ivar}
             v = ActiveSupport::IsolatedExecutionState[#{key_str}]
-            return v unless v.nil?
+            return v if ActiveSupport::IsolatedExecutionState.key?(#{key_str})
             if Ractor.main?
               existing = instance_variable_get(#{ivar_str}) if instance_variable_defined?(#{ivar_str})
               if existing

data/lib/ractor_rails_shim/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RactorRailsShim
-  VERSION = "0.2.4"
+  VERSION = "0.2.6"
 end

data/lib/ractor_rails_shim/version_check.rb

@@ -23,9 +23,11 @@
 #     exactly what applied to their runtime.
 module RactorRailsShim
   module Version
-    # Ruby version the shim was developed against (major.minor). Ractor
-    # semantics are still settling; non-4.0 Rubies may behave differently.
-    SUPPORTED_RUBY = "4.0"
+    # Ruby version the shim was developed against (major.minor.patch). Ractor
+    # semantics are still settling; the frozen-iseq call-cache fix (#22075) and
+    # the cross-ractor env-string fix that the shim relies on both shipped in
+    # 4.0.6, so earlier 4.0.x patch releases are NOT supported.
+    SUPPORTED_RUBY = "4.0.6"
     # Rails versions each patch was tested against. Patches are registered
     # with one or more entries from this list; the dispatcher applies a patch
     # only if the runtime Rails version matches one of its tags. To add 7.x
@@ -33,7 +35,7 @@ module RactorRailsShim
     TESTED_RAILS = ["8.1"].freeze
 
     class << self
-      # Runtime Ruby version as a Gem::Version (e.g. "4.0.5"). Always
+      # Runtime Ruby version as a Gem::Version (e.g. "4.0.6"). Always
       # available — Ruby is obviously loaded.
       def ruby
         Gem::Version.new(RUBY_VERSION)
@@ -64,9 +66,11 @@ module RactorRailsShim
         "#{v.segments[0]}.#{v.segments[1]}"
       end
 
-      # True if the runtime Ruby's major.minor matches the supported segment.
+      # True if the runtime Ruby is >= the supported version (4.0.6). Uses a
+      # full Gem::Version compare (not a segment match) so the minimum patch
+      # release is enforced — the shim relies on fixes that shipped in 4.0.6.
       def supported_ruby?
-        ruby_segment == SUPPORTED_RUBY
+        ruby >= Gem::Version.new(SUPPORTED_RUBY)
       end
 
       # True if the runtime Rails major.minor is in the tested set (or Rails

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: ractor-rails-shim
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.6
 platform: ruby
 authors:
-- dev
+- Daniil Kachur
 bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
@@ -99,7 +99,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '4.0'
+      version: 4.0.6
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="