phlex-reactive 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 786d397de0be7e32424c73079906cdf8d32d0325727d06027025d888693754e6
-  data.tar.gz: b080f12ff8c8f4271066993548f9c951278fe2dacabf9b7d21c2113704f58da4
+  metadata.gz: 8ec8a731ff4ae0e729288d805070e04c8860b7a51591a69b946ed42bd4996d97
+  data.tar.gz: '018dafe55b68a05a46ef52c4e896803a9933beecf50e87f1d428073065fd3205'
 SHA512:
-  metadata.gz: 316b9b2094490dd5045d1362276a8f31ba4deee96df08e6614dc9db8f62a2ceb822f5a474d2204dcb65f7ed1bb27b3c99303f14a180a336c2d5bc3d21c3bf31a
-  data.tar.gz: f54ecfe74e977b3d4a399cd004071792a3a7245636d1c82f19441b0240fb2d24d32bb072a3ae863a9e04efcab5a31182560628237f72bf77ff73ac387592e4c4
+  metadata.gz: 949549bc92c39def933aea8d83cf61db41ad686c8184c8a284657bdd99e1178dece129258e0e874ec1dd157748f69fcd11dc77fe140557c20d7dab217500a46b
+  data.tar.gz: ab245aa3bf1a4f65f392ae2c4b3e98cf20a6d45064375a2c2168b2c7214ed4d27bc78c6cd0f069d2ef82cad771ee233376742de6e22636f5b0efb81390f5b8ea

data/CHANGELOG.md

@@ -72,6 +72,31 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Fixed
 
+- **Collections of *reactive* rows were still add-once-only — a prepended/appended
+  row's OWN token suppressed the container's token refresh (#44).** When an action
+  appended/prepended a *reactive* child row into a container whose `#id` equals the
+  append target (the most common collection shape — rows go directly into the
+  container element), that single `append`/`prepend` stream carried BOTH
+  `target="<container>"` and the row's own `data-reactive-token-value` (embedded in
+  the `<template>`). `carries_token_for?` matched
+  `include?("data-reactive-token-value") && include?(target)` in that one string →
+  both true → it concluded the container's token was already fresh and **skipped**
+  the container's `reactive:token` refresh. So the container (which owns the
+  add/remove trigger) never rolled its token forward, and the second dispatch was
+  rejected with the stale token — the list silently stopped after the first add.
+  This hit both the hand-rolled `reply.streams(Row.prepend(...), …)` form **and**
+  the `reactive_collection` / `reply.append`/`reply.prepend` helper, since they
+  share the gate. Fixed by tightening `carries_token_for?`: a stream "carries the
+  token for C" only when its action RE-RENDERS C itself (`replace`/`update`/
+  `reactive:token` at C's target) — `append`/`prepend` (which insert *children*
+  into C) never count, because a reactive child's token is not the container's. The
+  idempotency the gate provided is preserved (a caller's own self-replace still
+  suppresses the duplicate token) and the #30 sibling case still refreshes
+  correctly. Covered at the request level: a reactive row appended twice in a row
+  (the second using the token the first rolled forward) now succeeds, and each
+  response carries a `reactive:token` stream targeting the container with a
+  non-empty token. Refs cosmos#1939, #35, #30.
+
 - **0.4.0 regression: re-renders lost the `request`, crashing `form_authenticity_token`
   and other request-dependent helpers (#42).** The 0.4.0 render-path perf rework
   built the cached off-request view context from a bare

data/app/controllers/phlex/reactive/actions_controller.rb

@@ -107,15 +107,49 @@ module Phlex
         streams
       end
 
-      # True when one of `streams` already carries a fresh token TARGETING this
-      # component — i.e. the caller hand-built the actor's own token-bearing
-      # stream, so appending to_stream_token would double it. Scoped to the
-      # component's target id (not a global substring) so a sibling component's
-      # stream, which carries its OWN token for a DIFFERENT target, doesn't fool
-      # us into skipping this component's refresh.
+      # Actions that RE-RENDER the component's own root (so the root's fresh
+      # data-reactive-token-value rolls the signed token forward). `append`/
+      # `prepend` are deliberately excluded: they insert CHILDREN into the
+      # component, and a reactive child carries its OWN token — that child token is
+      # not the component's (issue #44). reactive:token is our inert token-only
+      # refresh; replace/update re-render the root.
+      SELF_RENDER_ACTIONS = %w[replace update reactive:token].freeze
+      private_constant :SELF_RENDER_ACTIONS
+
+      # True when one of `streams` already carries a fresh token by RE-RENDERING
+      # this component itself — i.e. the caller hand-built the actor's own
+      # token-bearing stream, so appending to_stream_token would double it.
+      #
+      # The match requires BOTH (a) the stream's action re-renders the component's
+      # ROOT (replace/update/reactive:token — never append/prepend, which insert
+      # children) AND (b) it targets the component's id AND (c) it actually carries
+      # a token. This is stricter than a same-string substring check on purpose:
+      #   * A sibling component's replace targets a DIFFERENT id → (b) fails, so we
+      #     still refresh ours (issue #30).
+      #   * A reactive child row appended/prepended INTO the component carries its
+      #     own token at the component's target, but the action is append/prepend →
+      #     (a) fails, so we still refresh the CONTAINER's token (issue #44). Before
+      #     this, the child's token at the container target suppressed the
+      #     container's refresh and the list was add-once-only.
       def carries_token_for?(streams, component)
         target = %(target="#{ERB::Util.html_escape(component.id)}")
-        streams.any? {  it.include?("data-reactive-token-value") && it.include?(target) }
+        streams.any? do
+          it.include?("data-reactive-token-value") &&
+            it.include?(target) &&
+            self_render_stream_for?(it, target)
+        end
+      end
+
+      # Does this turbo-stream's OPENING tag re-render `target` itself? Matches a
+      # `<turbo-stream action="<self-render>" ... target="<id>">` opening tag — the
+      # action and target on the SAME tag — so a child row's token embedded in an
+      # append/prepend `<template>` can never count as the container's own refresh.
+      def self_render_stream_for?(stream, target)
+        open_tag = stream[/<turbo-stream\b[^>]*>/]
+        return false unless open_tag&.include?(target)
+
+        action = open_tag[/\baction="([^"]+)"/, 1]
+        SELF_RENDER_ACTIONS.include?(action)
       end
 
       # A 200 turbo-stream carrying a namespaced custom action the client turns

data/lib/phlex/reactive/version.rb

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

metadata

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