phlex-reactive 0.2.9 → 0.4.0

data/lib/phlex/reactive/streamable.rb

@@ -26,6 +26,41 @@ module Phlex
     module Streamable
       extend ActiveSupport::Concern
 
+      # A per-thread cache entry: an off-request view context + the Turbo
+      # TagBuilder bound to it, tagged with the renderer + generation it was
+      # built for. Rebuilt on a thread when the renderer object changes or the
+      # class generation is bumped — so a reset/reload/renderer-swap is picked
+      # up without ever sharing a mutable context across threads.
+      ThreadViewContext = Struct.new(:view_context, :builder, :renderer, :generation)
+
+      # Every class that includes Streamable, so the engine can flush their
+      # memoized view contexts on a Rails code reload (dev) in one pass. A
+      # WeakMap used as a set (the class is the key) so a class reloaded by
+      # Zeitwerk in dev is GC'd normally — a strong Array would pin every
+      # reloaded generation and leak across reloads. Guarded by a mutex;
+      # registration happens at class-load time, the reset iterates under lock.
+      @registry = ObjectSpace::WeakMap.new
+      @registry_mutex = Mutex.new
+
+      class << self
+        # Reset every streamable class's cached view context + builder. Called
+        # from the engine's reloader (config.to_prepare) so a reloaded renderer
+        # controller is never served from a stale memo. No-op outside Rails.
+        def reset_all_view_contexts!
+          @registry_mutex.synchronize do
+            @registry.each_key(&:reset_turbo_view_context!)
+          end
+        end
+
+        def register(klass)
+          @registry_mutex.synchronize { @registry[klass] = true }
+        end
+      end
+
+      included do
+        Phlex::Reactive::Streamable.register(self)
+      end
+
       class_methods do
         # The keyword the positional model maps to in `initialize`. For a
         # record-backed component (Component#reactive_record), this is the SAME
@@ -43,30 +78,68 @@ module Phlex
         end
 
         def component_args(model, options)
-          {model_param_name => model}.merge(options)
+          { model_param_name => model }.merge(options)
         end
 
         # Turbo::Streams::TagBuilder needs a real VIEW CONTEXT (it calls
         # `.formats` on it), not a controller class. Build one off-request from
-        # the configured renderer controller. Memoized per class.
+        # the configured renderer controller. Memoized PER THREAD — building a
+        # view context instantiates the renderer controller and assembles its
+        # whole helper module set, so doing it per render/broadcast was the
+        # hottest server-side allocation in the action round trip. The builder
+        # is bound to that one context and reused too.
+        #
+        # Why per-thread and not one-per-process: an ActionView context carries
+        # MUTABLE state (output_buffer/view_flow that #render_in's capture
+        # swaps), so a single instance shared across threads can interleave or
+        # bleed content between overlapping renders on a threaded server (Puma)
+        # or in concurrent jobs. A thread-local cache keeps the amortization
+        # (built once per thread, reused across that thread's renders) without
+        # ever sharing a buffer across threads.
         def turbo_stream_builder
-          ::Turbo::Streams::TagBuilder.new(turbo_view_context)
+          thread_view_context_cache.builder
         end
 
+        # The off-request view context for the current thread, built once and
+        # reused. Rebuilt when the configured renderer object changes (a swap of
+        # Phlex::Reactive.renderer) or when the class's view-context generation
+        # is bumped (reset_turbo_view_context! / Rails code reload), so a
+        # reloaded controller class is never served stale.
         def turbo_view_context
-          renderer.new.view_context
+          thread_view_context_cache.view_context
+        end
+
+        # Invalidate the cached view context + builder for ALL threads by bumping
+        # this class's generation — each thread rebuilds lazily on its next use,
+        # and entries for the old generation are dropped. Registered on Rails'
+        # reloader by the engine; also used by specs. Thread-safe (an integer
+        # bump; no shared mutable structure to tear down).
+        def reset_turbo_view_context!
+          @turbo_view_context_generation = turbo_view_context_generation + 1
+        end
+
+        def turbo_view_context_generation
+          @turbo_view_context_generation ||= 0
         end
 
-        # Render a component to HTML with a full Rails view context. Routing
-        # through the controller renderer keeps dom_id/url_for/t() working
-        # during a re-render or broadcast.
+        # Render a component to HTML with a full Rails view context. Uses
+        # phlex-rails' #render_in against our memoized off-request view context
+        # — a direct component.call that skips ActionController's renderer.render
+        # machinery (TemplateRenderer, LookupContext, the render log subscriber):
+        # ~2x faster with ~half the allocations, and byte-identical HTML. The
+        # view context still carries the full Rails helper set, so
+        # dom_id/url_for/t()/csrf keep working during a re-render or broadcast.
         def render_component(component)
-          renderer.render(component, layout: false)
+          component.render_in(turbo_view_context)
         end
 
-        def replace(model = nil, **options)
+        # `morph: true` emits `<turbo-stream action="replace" method="morph">` so
+        # Turbo 8's bundled Idiomorph morphs the subtree in place — preserving a
+        # focused <input> + caret — instead of an outerHTML swap (issue #28).
+        # Default (morph: false) is the unchanged plain replace.
+        def replace(model = nil, morph: false, **options)
           component = build(model, options)
-          turbo_stream_builder.replace(component.id, html: render_component(component))
+          turbo_stream_builder.replace(component.id, html: render_component(component), **morph_method(morph))
         end
 
         def update(model = nil, **options)
@@ -103,11 +176,15 @@ module Phlex
         # connection id — pass it to suppress the actor's own echo (the actor
         # already got the action's HTTP response). With Action Cable these are
         # ignored; with pgbus they reach the dispatcher. See docs/broadcasting.
-        def broadcast_replace_to(*streamables, model: nil, exclude: nil, visible_to: nil, **options)
+        # `morph: true` makes the live cross-tab update morph in place (issue #28),
+        # so a peer tab keeps its focus/caret on the morphed row. The broadcast
+        # path takes EXTRA <turbo-stream> attributes via `attributes:` (not the
+        # TagBuilder's `method:` kwarg), so the morph flag rides there.
+        def broadcast_replace_to(*streamables, model: nil, exclude: nil, visible_to: nil, morph: false, **options)
           component = build(model, options)
           ::Turbo::StreamsChannel.broadcast_replace_to(
             *streamables, target: component.id, html: render_component(component),
-            **broadcast_transport_opts(exclude:, visible_to:)
+            **morph_attributes(morph), **broadcast_transport_opts(exclude:, visible_to:)
           )
         end
 
@@ -149,6 +226,20 @@ module Phlex
           new(**(model ? component_args(model, options) : options))
         end
 
+        # The TagBuilder (the .replace class builder + to_stream_morph) takes
+        # `method: :morph` to emit the `method="morph"` attribute. Pass it ONLY
+        # when morphing, so the default call produces today's plain replace.
+        def morph_method(morph)
+          morph ? { method: :morph } : {}
+        end
+
+        # The BROADCAST path renders extra <turbo-stream> attributes through
+        # `attributes:` (it has no `method:` kwarg — that would fall into the
+        # render args and be dropped). Same wire result: method="morph".
+        def morph_attributes(morph)
+          morph ? { attributes: { method: "morph" } } : {}
+        end
+
         # Only include transport opts that were actually given, so on Action
         # Cable (which doesn't accept them) the common no-opts call is unchanged.
         def broadcast_transport_opts(exclude:, visible_to:)
@@ -161,6 +252,25 @@ module Phlex
         def renderer
           Phlex::Reactive.renderer
         end
+
+        def thread_view_context_cache
+          store = (Thread.current[:phlex_reactive_view_contexts] ||= {})
+          current = renderer
+          generation = turbo_view_context_generation
+          cached = store[self]
+
+          unless cached && cached.renderer.equal?(current) && cached.generation == generation
+            view_context = current.new.view_context
+            cached = ThreadViewContext.new(
+              view_context,
+              ::Turbo::Streams::TagBuilder.new(view_context),
+              current,
+              generation
+            )
+            store[self] = cached
+          end
+          cached
+        end
       end
 
       # Required: the stable DOM id used as the Turbo Stream target. It MUST
@@ -184,10 +294,46 @@ module Phlex
         self.class.turbo_stream_builder.replace(id, html: self.class.render_component(self))
       end
 
+      # Render THIS instance as a MORPHING replace (issue #28):
+      # `<turbo-stream action="replace" method="morph">`. Turbo 8's bundled
+      # Idiomorph morphs the subtree in place — preserving the focused <input> +
+      # caret across the re-render — while still carrying the root's fresh
+      # data-reactive-token-value (so the signed token refreshes). Used by
+      # Response.morph / Response.replace(self, morph: true).
+      def to_stream_morph
+        self.class.turbo_stream_builder.replace(id, html: self.class.render_component(self), method: :morph)
+      end
+
       def to_stream_update
         self.class.turbo_stream_builder.update(id, html: self.class.render_component(self))
       end
 
+      # Render a TOKEN-ONLY refresh stream (issue #30): a tiny
+      # `<turbo-stream action="reactive:token">` carrying the component's fresh
+      # signed token, with NO rendered body. It lets an action update only PART
+      # of a component (its own hand-built streams) while still rolling the
+      # signed identity token forward — the client reads the next token from this
+      # attribute (#extractToken) and an inert client action writes it onto the
+      # root (a pure attribute set, so a focused <input> + caret survive). Unlike
+      # to_stream_replace, it does NOT re-render the children, so a live input
+      # the user is typing into is never torn down. Used by Response.streams.
+      #
+      # The component carries its token via Component#reactive_token; a Streamable
+      # that isn't a Component (no token) simply has nothing to refresh — guarded
+      # by respond_to? so the primitive stays usable on a bare Streamable.
+      #
+      # respond_to? MUST include private methods (the `true` arg): Component
+      # defines `reactive_token` as PRIVATE, so a plain `respond_to?(:reactive_token)`
+      # is false for every Component and the stream silently carries an EMPTY token —
+      # which makes any non-self-rendering reply (reply.streams #30, reply.append /
+      # reply.remove #35) add-once-only: the first action works, then the stale (here
+      # empty) token is rejected on the next dispatch (cosmos#1939). A bare Streamable
+      # has no reactive_token method at all, so it still returns false correctly.
+      def to_stream_token
+        token = respond_to?(:reactive_token, true) ? reactive_token : nil
+        %(<turbo-stream action="reactive:token" target="#{ERB::Util.html_escape(id)}" data-reactive-token-value="#{ERB::Util.html_escape(token)}"></turbo-stream>)
+      end
+
       # Render THIS instance as a remove stream. The component already knows its
       # own #id, so no record/class reconstruction is needed (works for record-
       # and state-backed components alike). Used by Response.remove.

data/lib/phlex/reactive/version.rb

@@ -2,6 +2,6 @@
 
 module Phlex
   module Reactive
-    VERSION = "0.2.9"
+    VERSION = "0.4.0"
   end
 end

data/lib/phlex/reactive.rb

@@ -87,17 +87,69 @@ module Phlex
       attr_writer :flash_target
 
       # Render a Phlex component to HTML with a full (off-request) view context.
+      # Uses phlex-rails' #render_in against the memoized view context — a direct
+      # component.call that skips ActionController's renderer.render machinery
+      # (~2x faster, ~half the allocations), with the same HTML and full helper
+      # access (dom_id/url_for/t/csrf). Used for a Phlex component embedded as
+      # Response#with content.
       def render(component)
-        renderer.render(component, layout: false)
+        component.render_in(off_request_view_context)
       end
 
       # A Turbo::Streams::TagBuilder bound to an off-request view context, used
       # to build standalone streams (e.g. a Response flash append) not tied to a
-      # specific component's id.
+      # specific component's id. Cached PER THREAD alongside the context it's
+      # bound to (see off_request_view_context for why per-thread).
       def flash_builder
-        ::Turbo::Streams::TagBuilder.new(renderer.new.view_context)
+        off_request_view_context_cache[:builder]
       end
 
+      # The off-request view context for the current thread, built once and
+      # reused for both the flash builder and standalone component renders.
+      # Cached PER THREAD, not per process: an ActionView context carries mutable
+      # output_buffer/view_flow state (render_in's capture swaps it), so sharing
+      # one instance across threads can interleave content on a threaded server.
+      # Rebuilt when the renderer object changes or the generation is bumped
+      # (reset_flash_builder! / Rails code reload), so a reloaded controller is
+      # never served stale.
+      def off_request_view_context
+        off_request_view_context_cache[:view_context]
+      end
+
+      # Invalidate the per-thread context + builder for ALL threads by bumping
+      # the generation; each thread rebuilds lazily on next use. Registered on
+      # Rails' reloader by the engine; also used by specs. Thread-safe (an
+      # integer bump, no shared structure to tear down).
+      def reset_flash_builder!
+        @off_request_view_context_generation = off_request_view_context_generation + 1
+      end
+
+      def off_request_view_context_generation
+        @off_request_view_context_generation ||= 0
+      end
+
+      private
+
+      def off_request_view_context_cache
+        cache = Thread.current[:phlex_reactive_off_request_view_context]
+        current = renderer
+        generation = off_request_view_context_generation
+
+        unless cache && cache[:renderer].equal?(current) && cache[:generation] == generation
+          view_context = current.new.view_context
+          cache = {
+            view_context: view_context,
+            builder: ::Turbo::Streams::TagBuilder.new(view_context),
+            renderer: current,
+            generation: generation
+          }
+          Thread.current[:phlex_reactive_off_request_view_context] = cache
+        end
+        cache
+      end
+
+      public
+
       def base_controller_name
         @base_controller_name ||= "ActionController::Base"
       end
@@ -166,7 +218,7 @@ module Phlex
         logger.warn(
           "[phlex-reactive] POST #{path} does not resolve to #{ACTIONS_CONTROLLER}. " \
           "A host catch-all route (e.g. match \"*path\", ...) likely shadows it, so reactive " \
-          "actions will 404. Exempt #{path.sub(%r{\A/}, "")} from the catch-all, or set " \
+          "actions will 404. Exempt #{path.delete_prefix("/")} from the catch-all, or set " \
           "Phlex::Reactive.action_path to an unshadowed path. See the README integration section."
         )
       end
@@ -225,4 +277,4 @@ loader.ignore("#{lib}/generators")
 loader.do_not_eager_load("#{__dir__}/reactive/engine.rb")
 loader.setup
 
-require "phlex/reactive/engine" if defined?(::Rails::Engine)
+require "phlex/reactive/engine" if defined?(Rails::Engine)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: phlex-reactive
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.4.0
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -129,6 +129,7 @@ files:
 - lib/phlex/reactive.rb
 - lib/phlex/reactive/component.rb
 - lib/phlex/reactive/engine.rb
+- lib/phlex/reactive/reply.rb
 - lib/phlex/reactive/response.rb
 - lib/phlex/reactive/streamable.rb
 - lib/phlex/reactive/version.rb
@@ -147,7 +148,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="