phlex-reactive 0.3.0 → 0.4.1

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,25 +78,62 @@ 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, bound to a real request so
+        # request-dependent helpers (form_authenticity_token, host-aware URL
+        # helpers) work during a re-render/broadcast (issue #42). 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
 
         # `morph: true` emits `<turbo-stream action="replace" method="morph">` so
@@ -161,14 +233,14 @@ module Phlex
         # `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} : {}
+          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"}} : {}
+          morph ? { attributes: { method: "morph" } } : {}
         end
 
         # Only include transport opts that were actually given, so on Action
@@ -183,6 +255,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 = Phlex::Reactive.request_bound_view_context(current)
+            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
@@ -233,8 +324,16 @@ module Phlex
       # 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) ? reactive_token : nil
+        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
 

data/lib/phlex/reactive/version.rb

@@ -2,6 +2,6 @@
 
 module Phlex
   module Reactive
-    VERSION = "0.3.0"
+    VERSION = "0.4.1"
   end
 end

data/lib/phlex/reactive.rb

@@ -78,6 +78,30 @@ module Phlex
         @renderer ||= defined?(::ActionController::Base) ? ::ActionController::Base : nil
       end
 
+      # Build an off-request view context whose controller has a REAL `request`.
+      #
+      # A bare `controller.new.view_context` (the naive off-request context) has
+      # `request == nil`, so any request-dependent helper raises
+      # `undefined method 'env' for nil` — form_authenticity_token,
+      # protect_against_forgery?, and host-aware URL helpers all read
+      # `request.env` (issue #42). We replicate exactly what
+      # ActionController::Renderer#render does to set up its mock request — build
+      # an ActionDispatch::Request from the renderer's env (which derives the host
+      # from the routes' default_url_options), bind the routes, and attach it —
+      # then return the controller's view context instead of rendering a template.
+      # The result keeps the 0.4.0 render_in speedup (no renderer.render
+      # machinery) while restoring the request those helpers need.
+      def request_bound_view_context(controller_class)
+        ar_renderer = controller_class.renderer
+        request = ::ActionDispatch::Request.new(ar_renderer.send(:env_for_request))
+        request.routes = controller_class._routes
+
+        instance = controller_class.new
+        instance.set_request!(request)
+        instance.set_response!(controller_class.make_response!(request))
+        instance.view_context
+      end
+
       # DOM id of the host-app container a Response#flash appends into.
       # Default "flash"; override to match your layout's flash region.
       def flash_target
@@ -87,17 +111,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 = request_bound_view_context(current)
+          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 +242,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 +301,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.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -148,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:
   - - ">="