phlex-reactive 0.16.1 → 0.16.3

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/helpers.rb

@@ -741,7 +741,18 @@ module Phlex
         # exactly one of field/input: per call — the field form stays the
         # blessed default:
         #   reactive_filter(input: "#user_tags_query")
-        def reactive_filter(field = nil, input: nil, option: nil, group: nil, empty: nil)
+        #
+        # Issue #425: `match:` picks where the query must sit in the haystack —
+        # :substring (anywhere, the default), :prefix (at its start) or
+        # :word_start (at its start, or right after whitespace or one of
+        # - ' ( ) , . /). A long alphabetical list (countries, cities, people)
+        # wants :word_start, so "n" keeps Nantes and New York, not every name
+        # with an n in it. `fold: true` folds diacritics on BOTH sides before
+        # comparing, so "zur" finds Zürich and "zür" still does. The defaults
+        # emit nothing, so an existing filter's wire is byte-identical:
+        #   reactive_filter(:q, match: :word_start, fold: true)
+        def reactive_filter(field = nil, input: nil, option: nil, group: nil, empty: nil,
+                            match: :substring, fold: false)
           # nil-presence, NOT truthiness: `input: cond && "#sel"` with cond false
           # must fail loudly in filter_selector! below (a boolean is never a
           # selector), never slip into the field branch and emit a dead binding.
@@ -768,6 +779,10 @@ module Phlex
           # byte-stable wire and always-emit an attribute the client would then query).
           data[:reactive_filter_group] = filter_selector!(:group, group) if group
           data[:reactive_filter_empty] = filter_selector!(:empty, empty) if empty
+          # match:/fold: too (issue #425): the defaults emit nothing.
+          mode = filter_match!(match)
+          data[:reactive_filter_match] = mode.to_s unless mode == :substring
+          data[:reactive_filter_fold] = "true" if fold
 
           { data: }
         end
@@ -1427,8 +1442,24 @@ module Phlex
         LEGACY_SHOW_PREDICATE_KEYS = %i[equals not in gte gt lte lt].freeze
         LEGACY_SHOW_CONNECTIVE_KEYS = %i[all any].freeze
 
+        # reactive_filter's match: modes (issue #425), in the order the error names them.
+        FILTER_MATCH_MODES = %i[substring prefix word_start].freeze
+        private_constant :FILTER_MATCH_MODES
+
         private
 
+        # reactive_filter's match: (issue #425), a Symbol or a String naming one
+        # of FILTER_MATCH_MODES (the reactive_persist storage: precedent).
+        # Anything else raises at render: the client would fall back to
+        # substring matching and the list would narrow the wrong way.
+        def filter_match!(match)
+          mode = match.to_sym if match.is_a?(Symbol) || match.is_a?(String)
+          return mode if FILTER_MATCH_MODES.include?(mode)
+
+          raise ArgumentError,
+            "reactive_filter match: must be one of #{FILTER_MATCH_MODES.join(", ")}, got #{match.inspect}"
+        end
+
         # A reactive_filter/reactive_listnav selector, validated non-blank and
         # stringified (issue #163). A blank selector is a dead binding — the
         # client would silently match nothing — so it fails loudly at render,

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

@@ -10,7 +10,7 @@ module Phlex
       #
       # THE token hot path. Both memos below are bare defined?/||= fast paths
       # ON PURPOSE: a render must never pay a per-read generation compare
-      # (issue #115 invariant, .claude/rules/performance.md). Coherence comes
+      # (issue #115 invariant, AGENTS.md → Performance). Coherence comes
       # from the WRITE side instead — Component::Registry.bump! sweeps these
       # memos off the declaring class and all its descendants whenever any
       # registry declaration lands (class-load-shaped, rare), so they can't go

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.3"
   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.3
 platform: ruby
 authors:
 - Mikael Henriksson