turbo-rails 0.5.2 → 2.0.0

data/app/models/turbo/streams/tag_builder.rb

@@ -14,7 +14,7 @@
 #   <%= turbo_stream.append "entries" do %>
 #     <% # format is automatically switched, such that _entry.html.erb partial is rendered, not _entry.turbo_stream.erb %>
 #     <%= render partial: "entries/entry", locals: { entry: entry } %>
-#   <%= end %>
+#   <% end %>
 #
 # Or you can render the HTML that should be part of the update inline:
 #
@@ -22,11 +22,30 @@
 #   <%= turbo_stream.append dom_id(topic_merge) do %>
 #     <%= link_to topic_merge.topic.name, topic_path(topic_merge.topic) %>
 #   <% end %>
+#
+# To integrate with custom actions, extend this class in response to the :turbo_streams_tag_builder load hook:
+#
+#   ActiveSupport.on_load :turbo_streams_tag_builder do
+#     def highlight(target)
+#       action :highlight, target
+#     end
+#
+#     def highlight_all(targets)
+#       action_all :highlight, targets
+#     end
+#   end
+#
+#   turbo_stream.highlight "my-element"
+#   # => <turbo-stream action="highlight" target="my-element"><template></template></turbo-stream>
+#
+#   turbo_stream.highlight_all ".my-selector"
+#   # => <turbo-stream action="highlight" targets=".my-selector"><template></template></turbo-stream>
 class Turbo::Streams::TagBuilder
   include Turbo::Streams::ActionHelper
 
   def initialize(view_context)
     @view_context = view_context
+    @view_context.formats |= [:html]
   end
 
   # Removes the <tt>target</tt> from the dom. The target can either be a dom id string or an object that responds to
@@ -39,7 +58,17 @@ class Turbo::Streams::TagBuilder
     action :remove, target, allow_inferred_rendering: false
   end
 
-  # Replace the <tt>target</tt> in the dom with the either the <tt>content</tt> passed in, a rendering result determined
+  # Removes the <tt>targets</tt> from the dom. The targets can either be a CSS selector string or an object that responds to
+  # <tt>to_key</tt>, which is then called and passed through <tt>ActionView::RecordIdentifier.dom_id</tt> (all Active Records
+  # do). Examples:
+  #
+  #   <%= turbo_stream.remove_all ".clearance_item" %>
+  #   <%= turbo_stream.remove_all clearance %>
+  def remove_all(targets)
+    action_all :remove, targets, allow_inferred_rendering: false
+  end
+
+  # Replace the <tt>target</tt> in the dom with either the <tt>content</tt> passed in, a rendering result determined
   # by the <tt>rendering</tt> keyword arguments, the content in the block, or the rendering of the target as a record. Examples:
   #
   #   <%= turbo_stream.replace "clearance_5", "<div id='clearance_5'>Replace the dom target identified by clearance_5</div>" %>
@@ -52,7 +81,72 @@ class Turbo::Streams::TagBuilder
     action :replace, target, content, **rendering, &block
   end
 
-  # Update the <tt>target</tt> in the dom with the either the <tt>content</tt> passed in or a rendering result determined
+  # Replace the <tt>targets</tt> in the dom with either the <tt>content</tt> passed in, a rendering result determined
+  # by the <tt>rendering</tt> keyword arguments, the content in the block, or the rendering of the target as a record. Examples:
+  #
+  #   <%= turbo_stream.replace_all ".clearance_item", "<div class='clearance_item'>Replace the dom target identified by the class clearance_item</div>" %>
+  #   <%= turbo_stream.replace_all clearance %>
+  #   <%= turbo_stream.replace_all clearance, partial: "clearances/clearance", locals: { title: "Hello" } %>
+  #   <%= turbo_stream.replace_all ".clearance_item" do %>
+  #     <div class='.clearance_item'>Replace the dom target identified by the class clearance_item</div>
+  #   <% end %>
+  def replace_all(targets, content = nil, **rendering, &block)
+    action_all :replace, targets, content, **rendering, &block
+  end
+
+  # Insert the <tt>content</tt> passed in, a rendering result determined by the <tt>rendering</tt> keyword arguments,
+  # the content in the block, or the rendering of the target as a record before the <tt>target</tt> in the dom. Examples:
+  #
+  #   <%= turbo_stream.before "clearance_5", "<div id='clearance_4'>Insert before the dom target identified by clearance_5</div>" %>
+  #   <%= turbo_stream.before clearance %>
+  #   <%= turbo_stream.before clearance, partial: "clearances/clearance", locals: { title: "Hello" } %>
+  #   <%= turbo_stream.before "clearance_5" do %>
+  #     <div id='clearance_4'>Insert before the dom target identified by clearance_5</div>
+  #   <% end %>
+  def before(target, content = nil, **rendering, &block)
+    action :before, target, content, **rendering, &block
+  end
+
+  # Insert the <tt>content</tt> passed in, a rendering result determined by the <tt>rendering</tt> keyword arguments,
+  # the content in the block, or the rendering of the target as a record before the <tt>targets</tt> in the dom. Examples:
+  #
+  #   <%= turbo_stream.before_all ".clearance_item", "<div class='clearance_item'>Insert before the dom target identified by the class clearance_item</div>" %>
+  #   <%= turbo_stream.before_all clearance %>
+  #   <%= turbo_stream.before_all clearance, partial: "clearances/clearance", locals: { title: "Hello" } %>
+  #   <%= turbo_stream.before_all ".clearance_item" do %>
+  #     <div class='clearance_item'>Insert before the dom target identified by clearance_item</div>
+  #   <% end %>
+  def before_all(targets, content = nil, **rendering, &block)
+    action_all :before, targets, content, **rendering, &block
+  end
+
+  # Insert the <tt>content</tt> passed in, a rendering result determined by the <tt>rendering</tt> keyword arguments,
+  # the content in the block, or the rendering of the target as a record after the <tt>target</tt> in the dom. Examples:
+  #
+  #   <%= turbo_stream.after "clearance_5", "<div id='clearance_6'>Insert after the dom target identified by clearance_5</div>" %>
+  #   <%= turbo_stream.after clearance %>
+  #   <%= turbo_stream.after clearance, partial: "clearances/clearance", locals: { title: "Hello" } %>
+  #   <%= turbo_stream.after "clearance_5" do %>
+  #     <div id='clearance_6'>Insert after the dom target identified by clearance_5</div>
+  #   <% end %>
+  def after(target, content = nil, **rendering, &block)
+    action :after, target, content, **rendering, &block
+  end
+
+  # Insert the <tt>content</tt> passed in, a rendering result determined by the <tt>rendering</tt> keyword arguments,
+  # the content in the block, or the rendering of the target as a record after the <tt>targets</tt> in the dom. Examples:
+  #
+  #   <%= turbo_stream.after_all ".clearance_item", "<div class='clearance_item'>Insert after the dom target identified by the class clearance_item</div>" %>
+  #   <%= turbo_stream.after_all clearance %>
+  #   <%= turbo_stream.after_all clearance, partial: "clearances/clearance", locals: { title: "Hello" } %>
+  #   <%= turbo_stream.after_all "clearance_item" do %>
+  #     <div class='clearance_item'>Insert after the dom target identified by the class clearance_item</div>
+  #   <% end %>
+  def after_all(targets, content = nil, **rendering, &block)
+    action_all :after, targets, content, **rendering, &block
+  end
+
+  # Update the <tt>target</tt> in the dom with either the <tt>content</tt> passed in or a rendering result determined
   # by the <tt>rendering</tt> keyword arguments, the content in the block, or the rendering of the target as a record. Examples:
   #
   #   <%= turbo_stream.update "clearance_5", "Update the content of the dom target identified by clearance_5" %>
@@ -65,6 +159,19 @@ class Turbo::Streams::TagBuilder
     action :update, target, content, **rendering, &block
   end
 
+  # Update the <tt>targets</tt> in the dom with either the <tt>content</tt> passed in or a rendering result determined
+  # by the <tt>rendering</tt> keyword arguments, the content in the block, or the rendering of the targets as a record. Examples:
+  #
+  #   <%= turbo_stream.update_all "clearance_item", "Update the content of the dom target identified by the class clearance_item" %>
+  #   <%= turbo_stream.update_all clearance %>
+  #   <%= turbo_stream.update_all clearance, partial: "clearances/new_clearance", locals: { title: "Hello" } %>
+  #   <%= turbo_stream.update_all "clearance_item" do %>
+  #     Update the content of the dom target identified by the class clearance_item
+  #   <% end %>
+  def update_all(targets, content = nil, **rendering, &block)
+    action_all :update, targets, content, **rendering, &block
+  end
+
   # Append to the target in the dom identified with <tt>target</tt> either the <tt>content</tt> passed in or a
   # rendering result determined by the <tt>rendering</tt> keyword arguments, the content in the block,
   # or the rendering of the content as a record. Examples:
@@ -79,6 +186,20 @@ class Turbo::Streams::TagBuilder
     action :append, target, content, **rendering, &block
   end
 
+  # Append to the targets in the dom identified with <tt>targets</tt> either the <tt>content</tt> passed in or a
+  # rendering result determined by the <tt>rendering</tt> keyword arguments, the content in the block,
+  # or the rendering of the content as a record. Examples:
+  #
+  #   <%= turbo_stream.append_all ".clearances", "<div class='clearance_item'>Append this to .clearance_group</div>" %>
+  #   <%= turbo_stream.append_all ".clearances", clearance %>
+  #   <%= turbo_stream.append_all ".clearances", partial: "clearances/new_clearance", locals: { clearance: clearance } %>
+  #   <%= turbo_stream.append_all ".clearances" do %>
+  #     <div id='clearance_item'>Append this to .clearances</div>
+  #   <% end %>
+  def append_all(targets, content = nil, **rendering, &block)
+    action_all :append, targets, content, **rendering, &block
+  end
+
   # Prepend to the target in the dom identified with <tt>target</tt> either the <tt>content</tt> passed in or a
   # rendering result determined by the <tt>rendering</tt> keyword arguments or the content in the block,
   # or the rendering of the content as a record. Examples:
@@ -93,35 +214,56 @@ class Turbo::Streams::TagBuilder
     action :prepend, target, content, **rendering, &block
   end
 
-  # Send an action of the type <tt>name</tt>. Options described in the concrete methods.
+  # Prepend to the targets in the dom identified with <tt>targets</tt> either the <tt>content</tt> passed in or a
+  # rendering result determined by the <tt>rendering</tt> keyword arguments or the content in the block,
+  # or the rendering of the content as a record. Examples:
+  #
+  #   <%= turbo_stream.prepend_all ".clearances", "<div class='clearance_item'>Prepend this to .clearances</div>" %>
+  #   <%= turbo_stream.prepend_all ".clearances", clearance %>
+  #   <%= turbo_stream.prepend_all ".clearances", partial: "clearances/new_clearance", locals: { clearance: clearance } %>
+  #   <%= turbo_stream.prepend_all ".clearances" do %>
+  #     <div class='clearance_item'>Prepend this to .clearances</div>
+  #   <% end %>
+  def prepend_all(targets, content = nil, **rendering, &block)
+    action_all :prepend, targets, content, **rendering, &block
+  end
+
+  # Send an action of the type <tt>name</tt> to <tt>target</tt>. Options described in the concrete methods.
   def action(name, target, content = nil, allow_inferred_rendering: true, **rendering, &block)
-    target_name = extract_target_name_from(target)
-
-    case
-    when content
-      turbo_stream_action_tag name, target: target_name, template: (render_record(content) if allow_inferred_rendering) || content
-    when block_given?
-      turbo_stream_action_tag name, target: target_name, template: @view_context.capture(&block)
-    when rendering.any?
-      turbo_stream_action_tag name, target: target_name, template: @view_context.render(formats: [ :html ], **rendering)
-    else
-      turbo_stream_action_tag name, target: target_name, template: (render_record(target) if allow_inferred_rendering)
-    end
+    template = render_template(target, content, allow_inferred_rendering: allow_inferred_rendering, **rendering, &block)
+
+    turbo_stream_action_tag name, target: target, template: template
+  end
+
+  # Send an action of the type <tt>name</tt> to <tt>targets</tt>. Options described in the concrete methods.
+  def action_all(name, targets, content = nil, allow_inferred_rendering: true, **rendering, &block)
+    template = render_template(targets, content, allow_inferred_rendering: allow_inferred_rendering, **rendering, &block)
+
+    turbo_stream_action_tag name, targets: targets, template: template
   end
 
   private
-    def extract_target_name_from(target)
-      if target.respond_to?(:to_key)
-        ActionView::RecordIdentifier.dom_id(target)
+    def render_template(target, content = nil, allow_inferred_rendering: true, **rendering, &block)
+      case
+      when content.respond_to?(:render_in)
+        content.render_in(@view_context, &block)
+      when content
+        allow_inferred_rendering ? (render_record(content) || content) : content
+      when block_given?
+        @view_context.capture(&block)
+      when rendering.any?
+        @view_context.render(formats: [ :html ], **rendering)
       else
-        target
+        render_record(target) if allow_inferred_rendering
       end
     end
 
     def render_record(possible_record)
       if possible_record.respond_to?(:to_partial_path)
         record = possible_record
-        @view_context.render(partial: record.to_partial_path, locals: { record.model_name.singular.to_sym => record }, formats: [ :html ])
+        @view_context.render(partial: record, formats: :html)
       end
     end
+
+  ActiveSupport.run_load_hooks :turbo_streams_tag_builder, self
 end

data/app/models/turbo/thread_debouncer.rb

@@ -0,0 +1,28 @@
+# A decorated debouncer that will store instances in the current thread clearing them
+# after the debounced logic triggers.
+class Turbo::ThreadDebouncer
+  delegate :wait, to: :debouncer
+
+  def self.for(key, delay: Turbo::Debouncer::DEFAULT_DELAY)
+    Thread.current[key] ||= new(key, Thread.current, delay: delay)
+  end
+
+  private_class_method :new
+
+  def initialize(key, thread, delay: )
+    @key = key
+    @debouncer = Turbo::Debouncer.new(delay: delay)
+    @thread = thread
+  end
+
+  def debounce
+    debouncer.debounce do
+      yield.tap do
+        thread[key] = nil
+      end
+    end
+  end
+
+  private
+    attr_reader :key, :debouncer, :thread
+end

data/app/views/layouts/turbo_rails/frame.html.erb

@@ -0,0 +1,8 @@
+<html>
+  <head>
+    <%= yield :head %>
+  </head>
+  <body>
+    <%= yield %>
+  </body>
+</html>

data/config/routes.rb

@@ -1,6 +1,5 @@
-# FIXME: Offer flag to opt out of these native routes
 Rails.application.routes.draw do
   get "recede_historical_location"  => "turbo/native/navigation#recede",  as: :turbo_recede_historical_location
   get "resume_historical_location"  => "turbo/native/navigation#resume",  as: :turbo_resume_historical_location
   get "refresh_historical_location" => "turbo/native/navigation#refresh", as: :turbo_refresh_historical_location
-end
+end if Turbo.draw_routes

data/lib/install/turbo_needs_redis.rb

@@ -0,0 +1,20 @@
+if (cable_config_path = Rails.root.join("config/cable.yml")).exist?
+  say "Enable redis in bundle"
+
+  gemfile_content = File.read(Rails.root.join("Gemfile"))
+  pattern = /gem ['"]redis['"]/
+
+  if gemfile_content.match?(pattern)
+    uncomment_lines "Gemfile", pattern
+  else
+    append_file "Gemfile", "\n# Use Redis for Action Cable"
+    gem 'redis', '~> 4.0'
+  end
+
+  run_bundle
+
+  say "Switch development cable to use redis"
+  gsub_file cable_config_path.to_s, /development:\n\s+adapter: async/, "development:\n  adapter: redis\n  url: redis://localhost:6379/1"
+else
+  say 'ActionCable config file (config/cable.yml) is missing. Uncomment "gem \'redis\'" in your Gemfile and create config/cable.yml to use the Turbo Streams broadcast feature.'
+end

data/lib/install/turbo_with_bun.rb

@@ -0,0 +1,9 @@
+if (js_entrypoint_path = Rails.root.join("app/javascript/application.js")).exist?
+  say "Import Turbo"
+  append_to_file "app/javascript/application.js", %(import "@hotwired/turbo-rails"\n)
+else
+  say "You must import @hotwired/turbo-rails in your JavaScript entrypoint file", :red
+end
+
+say "Install Turbo"
+run "bun add @hotwired/turbo-rails"

data/lib/install/turbo_with_importmap.rb

@@ -0,0 +1,5 @@
+say "Import Turbo"
+append_to_file "app/javascript/application.js", %(import "@hotwired/turbo-rails"\n)
+
+say "Pin Turbo"
+append_to_file "config/importmap.rb", %(pin "@hotwired/turbo-rails", to: "turbo.min.js"\n)

data/lib/install/turbo_with_node.rb

@@ -0,0 +1,9 @@
+if (js_entrypoint_path = Rails.root.join("app/javascript/application.js")).exist?
+  say "Import Turbo"
+  append_to_file "app/javascript/application.js", %(import "@hotwired/turbo-rails"\n)
+else
+  say "You must import @hotwired/turbo-rails in your JavaScript entrypoint file", :red
+end
+
+say "Install Turbo"
+run "yarn add @hotwired/turbo-rails"

data/lib/tasks/turbo_tasks.rake

@@ -1,24 +1,66 @@
-def run_install_template(path) system "#{RbConfig.ruby} ./bin/rails app:template LOCATION=#{File.expand_path("../install/#{path}.rb",  __dir__)}" end
+module Turbo
+  module Tasks
+    extend self
+    def run_turbo_install_template(path)
+      system "#{RbConfig.ruby} ./bin/rails app:template LOCATION=#{File.expand_path("../install/#{path}.rb", __dir__)}"
+    end
+
+    def redis_installed?
+      Gem.win_platform? ?
+        system('where redis-server > NUL 2>&1') :
+        system('which redis-server > /dev/null')
+    end
+
+    def switch_on_redis_if_available
+      if redis_installed?
+        Rake::Task["turbo:install:redis"].invoke
+      else
+        puts "Run turbo:install:redis to switch on Redis and use it in development for turbo streams"
+      end
+    end
+
+    def using_bun?
+      Rails.root.join("bun.config.js").exist?
+    end
+  end
+end
 
 namespace :turbo do
   desc "Install Turbo into the app"
   task :install do
-    if defined?(Webpacker::Engine)
-      Rake::Task["turbo:install:webpacker"].invoke
+    if Rails.root.join("config/importmap.rb").exist?
+      Rake::Task["turbo:install:importmap"].invoke
+    elsif Rails.root.join("package.json").exist? && Turbo::Tasks.using_bun?
+      Rake::Task["turbo:install:bun"].invoke
+    elsif Rails.root.join("package.json").exist?
+      Rake::Task["turbo:install:node"].invoke
     else
-      Rake::Task["turbo:install:asset_pipeline"].invoke
+      puts "You must either be running with node (package.json) or importmap-rails (config/importmap.rb) to use this gem."
     end
   end
 
   namespace :install do
     desc "Install Turbo into the app with asset pipeline"
-    task :asset_pipeline do
-      run_install_template "turbo_with_asset_pipeline"
+    task :importmap do
+      Turbo::Tasks.run_turbo_install_template "turbo_with_importmap"
+      Turbo::Tasks.switch_on_redis_if_available
     end
 
     desc "Install Turbo into the app with webpacker"
-    task :webpacker do
-      run_install_template "turbo_with_webpacker"
+    task :node do
+      Turbo::Tasks.run_turbo_install_template "turbo_with_node"
+      Turbo::Tasks.switch_on_redis_if_available
+    end
+
+    desc "Install Turbo into the app with bun"
+    task :bun do
+      Turbo::Tasks.run_turbo_install_template "turbo_with_bun"
+      Turbo::Tasks.switch_on_redis_if_available
+    end
+
+    desc "Switch on Redis and use it in development"
+    task :redis do
+      Turbo::Tasks.run_turbo_install_template "turbo_needs_redis"
     end
   end
 end

data/lib/turbo/broadcastable/test_helper.rb

@@ -0,0 +1,172 @@
+module Turbo
+  module Broadcastable
+    module TestHelper
+      extend ActiveSupport::Concern
+
+      included do
+        include ActionCable::TestHelper
+
+        include Turbo::Streams::StreamName
+      end
+
+      # Asserts that `<turbo-stream>` elements were broadcast over Action Cable
+      #
+      # === Arguments
+      #
+      # * <tt>stream_name_or_object</tt> the objects used to generate the
+      #   channel Action Cable name, or the name itself
+      # * <tt>&block</tt> optional block executed before the
+      #   assertion
+      #
+      # === Options
+      #
+      # * <tt>count:</tt> the number of `<turbo-stream>` elements that are
+      # expected to be broadcast
+      #
+      # Asserts `<turbo-stream>` elements were broadcast:
+      #
+      #     message = Message.find(1)
+      #     message.broadcast_replace_to "messages"
+      #
+      #     assert_turbo_stream_broadcasts "messages"
+      #
+      # Asserts that two `<turbo-stream>` elements were broadcast:
+      #
+      #     message = Message.find(1)
+      #     message.broadcast_replace_to "messages"
+      #     message.broadcast_remove_to "messages"
+      #
+      #     assert_turbo_stream_broadcasts "messages", count: 2
+      #
+      # You can pass a block to run before the assertion:
+      #
+      #     message = Message.find(1)
+      #
+      #     assert_turbo_stream_broadcasts "messages" do
+      #       message.broadcast_append_to "messages"
+      #     end
+      #
+      # In addition to a String, the helper also accepts an Object or Array to
+      # determine the name of the channel the elements are broadcast to:
+      #
+      #     message = Message.find(1)
+      #
+      #     assert_turbo_stream_broadcasts message do
+      #       message.broadcast_replace
+      #     end
+      #
+      def assert_turbo_stream_broadcasts(stream_name_or_object, count: nil, &block)
+        payloads = capture_turbo_stream_broadcasts(stream_name_or_object, &block)
+        stream_name = stream_name_from(stream_name_or_object)
+
+        if count.nil?
+          assert_not_empty payloads, "Expected at least one broadcast on #{stream_name.inspect}, but there were none"
+        else
+          broadcasts = "Turbo Stream broadcast".pluralize(count)
+
+          assert count == payloads.count, "Expected #{count} #{broadcasts} on #{stream_name.inspect}, but there were #{payloads.count}"
+        end
+      end
+
+      # Asserts that no `<turbo-stream>` elements were broadcast over Action Cable
+      #
+      # === Arguments
+      #
+      # * <tt>stream_name_or_object</tt> the objects used to generate the
+      #   channel Action Cable name, or the name itself
+      # * <tt>&block</tt> optional block executed before the
+      #   assertion
+      #
+      # Asserts that no `<turbo-stream>` elements were broadcast:
+      #
+      #     message = Message.find(1)
+      #     message.broadcast_replace_to "messages"
+      #
+      #     assert_no_turbo_stream_broadcasts "messages" # fails with MiniTest::Assertion error
+      #
+      # You can pass a block to run before the assertion:
+      #
+      #     message = Message.find(1)
+      #
+      #     assert_no_turbo_stream_broadcasts "messages" do
+      #       # do something other than broadcast to "messages"
+      #     end
+      #
+      # In addition to a String, the helper also accepts an Object or Array to
+      # determine the name of the channel the elements are broadcast to:
+      #
+      #     message = Message.find(1)
+      #
+      #     assert_no_turbo_stream_broadcasts message do
+      #       # do something other than broadcast to "message_1"
+      #     end
+      #
+      def assert_no_turbo_stream_broadcasts(stream_name_or_object, &block)
+        block&.call
+
+        stream_name = stream_name_from(stream_name_or_object)
+
+        payloads = broadcasts(stream_name)
+
+        assert payloads.empty?, "Expected no broadcasts on #{stream_name.inspect}, but there were #{payloads.count}"
+      end
+
+      # Captures any `<turbo-stream>` elements that were broadcast over Action Cable
+      #
+      # === Arguments
+      #
+      # * <tt>stream_name_or_object</tt> the objects used to generate the
+      #   channel Action Cable name, or the name itself
+      # * <tt>&block</tt> optional block to capture broadcasts during execution
+      #
+      # Returns any `<turbo-stream>` elements that have been broadcast as an
+      # Array of <tt>Nokogiri::XML::Element</tt> instances
+      #
+      #     message = Message.find(1)
+      #     message.broadcast_append_to "messages"
+      #     message.broadcast_prepend_to "messages"
+      #
+      #     turbo_streams = capture_turbo_stream_broadcasts "messages"
+      #
+      #     assert_equal "append", turbo_streams.first["action"]
+      #     assert_equal "prepend", turbo_streams.second["action"]
+      #
+      # You can pass a block to limit the scope of the broadcasts being captured:
+      #
+      #     message = Message.find(1)
+      #
+      #     turbo_streams = capture_turbo_stream_broadcasts "messages" do
+      #       message.broadcast_append_to "messages"
+      #     end
+      #
+      #     assert_equal "append", turbo_streams.first["action"]
+      #
+      # In addition to a String, the helper also accepts an Object or Array to
+      # determine the name of the channel the elements are broadcast to:
+      #
+      #     message = Message.find(1)
+      #
+      #     replace, remove = capture_turbo_stream_broadcasts message do
+      #       message.broadcast_replace
+      #       message.broadcast_remove
+      #     end
+      #
+      #     assert_equal "replace", replace["action"]
+      #     assert_equal "replace", remove["action"]
+      #
+      def capture_turbo_stream_broadcasts(stream_name_or_object, &block)
+        block&.call
+
+        stream_name = stream_name_from(stream_name_or_object)
+        payloads = broadcasts(stream_name)
+
+        payloads.flat_map do |payload|
+          html = ActiveSupport::JSON.decode(payload)
+          document = Nokogiri::HTML5.parse(html)
+
+          document.at("body").element_children
+        end
+      end
+    end
+  end
+end