phlex-reactive 0.16.1 → 0.16.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 860b397593c4d0a2d05d2485345bfc78564e784942c8413db1b67fbbacea6b41
-  data.tar.gz: '059b1148284859d6a69afdd4f62693f4dbedb0eab41370af843e30a4f3d27e4f'
+  metadata.gz: 96630c84c36efda322bafa8792e9e00bc0827d727a8d9db9c0f3191916f3a561
+  data.tar.gz: 2fc0570f0888b0905f04573b0ee8ecc71210ad08e5e10f430067b7141d1c468f
 SHA512:
-  metadata.gz: 0500ccbf1d82ea1039cf078dbe62e67efd6da9c9a2ecbeaace46d7d316f4a6c62ef479ea8b1a81e263ad1f738c25d9aa64f0dc53fc7af7a1bbadd6dab49e5021
-  data.tar.gz: eae4009ae39fba74bc6219c4b90df31589bed31ed70a457c7f240075ffd50b84662a39af475d878bc339d2e538611e248a287e11a5bbdacd52cb47d1bf73d45e
+  metadata.gz: c8487e66e0f93336442b6edbaaaa2cd2afdf0e18c809783e9001f25b1aaaf7525baab624c8d6b20a3acc896ccb1213423123d4ef914d335dcd147a4b19ab4927
+  data.tar.gz: 02d982c7a73c156d52d5a707e1745ea4de5df759f8d7c9d402c51c1ddabd68800d12a8972bf18fe9f5d10e074844922c6b31eec228508ebd14acb8ccac85d58b

data/CHANGELOG.md

@@ -6,6 +6,39 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.16.2] - 2026-10-17
+
+### Fixed
+
+- **An app on Rails main boots in Ractor mode with phlex-reactive mounted.**
+  Rails main's `RouteSet#finalize!` makes the route set Ractor-shareable, the
+  blocks engines append included. The engine's route block had the engine as
+  its `self`, so with `ActiveSupport::Ractors.unshareable_proc_action = :raise`
+  boot raised `Ractor::IsolationError: Proc's self is not shareable`. On Ruby
+  4.0+ the block is now built with `Ractor.shareable_proc`; the routes it
+  draws are unchanged, and older Rubies get the same block as before.
+
+- **A warmed component's class can be read from a non-main Ractor.** Boot's
+  `Component::Registry.warm!` froze each class's resolution cache only at the
+  top level, so the action definitions in it (their `params` Hash, their
+  compiled `ParamSchema`) stayed mutable, and the class's own declarations
+  (`@reactive_own_actions`, `@reactive_own_state_keys`, …) were not frozen at
+  all. Every reactive render or action in a non-main Ractor raised
+  `Ractor::IsolationError: can not get unshareable values from instance
+  variables of classes/modules`. warm! now shares the cache, every
+  `@reactive_own_*` declaration and the render memos deeply
+  (`Phlex::Reactive::Shareable.share`, which learned to copy `Data` values
+  that keep Data's own `initialize`; one with its own is kept as it is);
+  a compiled `ParamSchema` is frozen with a deep-frozen copy of its schema,
+  and `action` keeps a frozen copy of `params:`, so the app's own Hash is
+  never frozen. A value no Ractor can share (a `reactive_collection size:`
+  lambda that assigns what it captures) is kept as it is and works on the
+  main Ractor; boot never raises for it. A declaration after warm! (a
+  development reload) writes to a fresh copy, as before. The Ractor canary
+  now reads a warmed component with an action that takes params.
+
+## [0.16.1] - 2026-10-17
+
 ### Added
 
 - **Draggable regions: move and resize a box, or move a point, inside a
@@ -4114,7 +4147,9 @@ room for dogfood fixes.
   scaffolds a reactive component (and an RSpec spec when the app uses RSpec),
   state-backed by default or record-backed with `--record`.
 
-[Unreleased]: https://github.com/mhenrixon/phlex-reactive/compare/v0.16.0...HEAD
+[Unreleased]: https://github.com/mhenrixon/phlex-reactive/compare/v0.16.2...HEAD
+[0.16.2]: https://github.com/mhenrixon/phlex-reactive/compare/v0.16.1...v0.16.2
+[0.16.1]: https://github.com/mhenrixon/phlex-reactive/compare/v0.16.0...v0.16.1
 [0.16.0]: https://github.com/mhenrixon/phlex-reactive/compare/v0.15.5...v0.16.0
 [0.15.5]: https://github.com/mhenrixon/phlex-reactive/compare/v0.15.4...v0.15.5
 [0.15.4]: https://github.com/mhenrixon/phlex-reactive/compare/v0.15.3...v0.15.4

data/lib/phlex/reactive/component/dsl.rb

@@ -311,6 +311,9 @@ module Phlex
 
             # Issue #184: params: :symbol resolves a registered named schema.
             params = Phlex::Reactive.param_schema(params) if params.is_a?(Symbol)
+            # A deep-frozen copy, shared with the compiled schema below: the
+            # definition stays readable from a non-main Ractor once warmed.
+            params = Phlex::Reactive::Shareable.share(params)
             # If a scope is already declared, reject a schema nested under the scope
             # key here (the scope-first declaration order). The action-first order is
             # caught in reactive_scope.

data/lib/phlex/reactive/component/registry.rb

@@ -103,6 +103,13 @@ module Phlex
         # attribute fragments), shared by warm! so a non-main Ractor can read it.
         MEMO_IVARS = %i[@reactive_record_ivar @reactive_state_ivars @reactive_effect_attrs @reactive_on_complete_attr].freeze
 
+        # Every class ivar warm! leaves for a request to read, each shared
+        # deeply so a non-main Ractor can read it: the class's own
+        # declarations, the resolution cache and the render path's memos.
+        # (The generation counters next to them are Integers, shareable as
+        # they are.)
+        WARMED_IVARS = [*OWN_IVARS.values, :@reactive_registry_cache, *MEMO_IVARS].freeze
+
         # Every class with the reactive DSL, a ClientBindings-only view
         # included (Streamable's registry has only the token-bearing ones):
         # what the engine warms at boot. Per-Ractor (Phlex::Reactive::Store);
@@ -161,7 +168,7 @@ module Phlex
 
           # Resolve every registry kind and build the render path's per-class
           # memos for each reactive component class among `classes`, then
-          # freeze each class's resolution cache. The engine runs it at boot
+          # share (deep-freeze) what each class keeps (WARMED_IVARS). The engine runs it at boot
           # when the app eager-loads (every class is loaded by then), so a
           # request reads memos and never writes the class. A declaration
           # after it (a development reload) bumps the generation and the next
@@ -226,10 +233,14 @@ module Phlex
           end
 
           # The class's own storage for `kind`, initialized from the block on
-          # first write.
+          # first write. warm! shares (freezes) it, so a declaration after
+          # warm! (a development reload) writes to a fresh copy.
           def own!(klass, kind)
             ivar = OWN_IVARS.fetch(kind)
-            klass.instance_variable_get(ivar) || klass.instance_variable_set(ivar, yield)
+            current = klass.instance_variable_get(ivar)
+            return current if current && !current.frozen?
+
+            klass.instance_variable_set(ivar, current ? current.dup : yield)
           end
 
           # Invalidate every resolution memo in the process (generation bump)
@@ -257,8 +268,7 @@ module Phlex
 
           def warm_class(klass)
             [*READERS.values, *MEMO_READERS].each { klass.public_send(it) if klass.respond_to?(it) }
-            klass.instance_variable_get(:@reactive_registry_cache)&.freeze
-            MEMO_IVARS.each do
+            WARMED_IVARS.each do
               next unless klass.instance_variable_defined?(it)
 
               klass.instance_variable_set(it, Phlex::Reactive::Shareable.share(klass.instance_variable_get(it)))

data/lib/phlex/reactive/engine.rb

@@ -34,13 +34,20 @@ module Phlex
       # (the privately cacheable lazy render, issue #277). Apps can change the
       # paths with Phlex::Reactive.action_path / .defer_path / .fragment_path
       # before boot.
+      #
+      # Rails main's RouteSet#finalize! makes the route set Ractor-shareable,
+      # append blocks included, and a block's self here is the engine, which
+      # no Ractor can share. Ractor.shareable_proc (Ruby 4.0+) gives the block
+      # a nil self; Mapper evaluates it with its own self either way.
       initializer "phlex_reactive.routes" do
-        it.routes.append do
+        routes = proc do
           post Phlex::Reactive.action_path, to: "phlex/reactive/actions#create", as: :phlex_reactive_action
           post Phlex::Reactive.defer_path, to: "phlex/reactive/actions#deferred", as: :phlex_reactive_defer
           get "#{Phlex::Reactive.fragment_path}/:id", to: "phlex/reactive/fragments#show",
             as: :phlex_reactive_fragment
         end
+        routes = ::Ractor.shareable_proc(&routes) if defined?(::Ractor) && ::Ractor.respond_to?(:shareable_proc)
+        it.routes.append(&routes)
       end
 
       # Make the MINIFIED client build available to Propshaft/Sprockets so it can

data/lib/phlex/reactive/param_schema.rb

@@ -143,8 +143,12 @@ module Phlex
 
       attr_reader :schema
 
+      # Ractor-shareable once built: a deep-frozen copy of the declared schema
+      # (the app's own Hash is left alone) and nothing written after this, so
+      # a warmed action definition can be read from a non-main Ractor.
       def initialize(schema)
-        @schema = schema
+        @schema = Phlex::Reactive::Shareable.share(schema)
+        freeze
       end
 
       # Coerce client params against this schema. Anything not in the schema is

data/lib/phlex/reactive/shareable.rb

@@ -23,6 +23,10 @@ module Phlex
       #     works on the main Ractor only;
       #   * a Hash keeps its default value or default proc and its
       #     compare_by_identity;
+      #   * a Data value (the gem's declarations: an action, a compute, a
+      #     collection) comes back as a copy with every member shared, when
+      #     its class keeps Data's own initialize (one of its own may
+      #     normalize or validate, and is never run again);
       #   * any other object (a MessageVerifier, an APM adapter, an app object)
       #     is kept as is.
       #
@@ -35,6 +39,7 @@ module Phlex
         when ::Proc then share_proc(value.dup) || value
         when ::Array then seal(value.map { share(it) })
         when ::Hash then share_hash(value)
+        when ::Data then plain_data?(value) ? share_data(value) : value
         when ::String then value.dup.freeze
         else value
         end
@@ -60,12 +65,14 @@ module Phlex
       end
 
       # The Proc made shareable in place, or nil when it cannot be (or there
-      # is no Ractor).
+      # is no Ractor). Ruby raises Ractor::IsolationError for an unshareable
+      # self or capture, and ArgumentError for a Proc that assigns a variable
+      # it captures.
       def share_proc(callable)
         return unless defined?(::Ractor)
 
         ::Ractor.make_shareable(callable)
-      rescue ::Ractor::Error
+      rescue ::Ractor::Error, ::ArgumentError
         nil
       end
 
@@ -78,10 +85,18 @@ module Phlex
         seal(copy)
       end
 
+      # Data#with runs the class's initialize again: only Data's own, which
+      # just assigns the members, is safe to.
+      def plain_data?(data) = data.class.instance_method(:initialize).owner.equal?(::Data)
+
+      # A copy with every member shared. Data is always frozen, so the copy
+      # is shareable when every member is.
+      def share_data(data) = data.with(**data.to_h.transform_values { share(it) })
+
       # Frozen; shareable as well when everything inside it is.
       def seal(collection) = collection.freeze
 
-      private_class_method :share_proc, :share_hash, :seal
+      private_class_method :share_proc, :share_hash, :plain_data?, :share_data, :seal
     end
   end
 end

data/lib/phlex/reactive/version.rb

@@ -2,6 +2,6 @@
 
 module Phlex
   module Reactive
-    VERSION = "0.16.1"
+    VERSION = "0.16.2"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: phlex-reactive
 version: !ruby/object:Gem::Version
-  version: 0.16.1
+  version: 0.16.2
 platform: ruby
 authors:
 - Mikael Henriksson