turbo-rails 0.5.2 → 2.0.0

data/app/javascript/turbo/fetch_requests.js

@@ -0,0 +1,59 @@
+export function encodeMethodIntoRequestBody(event) {
+  if (event.target instanceof HTMLFormElement) {
+    const { target: form, detail: { fetchOptions } } = event
+
+    form.addEventListener("turbo:submit-start", ({ detail: { formSubmission: { submitter } } }) => {
+      const body = isBodyInit(fetchOptions.body) ? fetchOptions.body : new URLSearchParams()
+      const method = determineFetchMethod(submitter, body, form)
+
+      if (!/get/i.test(method)) {
+        if (/post/i.test(method)) {
+          body.delete("_method")
+        } else {
+          body.set("_method", method)
+        }
+
+        fetchOptions.method = "post"
+      }
+    }, { once: true })
+  }
+}
+
+function determineFetchMethod(submitter, body, form) {
+  const formMethod = determineFormMethod(submitter)
+  const overrideMethod = body.get("_method")
+  const method = form.getAttribute("method") || "get"
+
+  if (typeof formMethod == "string") {
+    return formMethod
+  } else if (typeof overrideMethod == "string") {
+    return overrideMethod
+  } else {
+    return method
+  }
+}
+
+function determineFormMethod(submitter) {
+  if (submitter instanceof HTMLButtonElement || submitter instanceof HTMLInputElement) {
+    // Rails 7 ActionView::Helpers::FormBuilder#button method has an override
+    // for formmethod if the button does not have name or value attributes
+    // set, which is the default. This means that if you use <%= f.button
+    // formmethod: :delete %>, it will generate a <button name="_method"
+    // value="delete" formmethod="post">. Therefore, if the submitter's name
+    // is already _method, it's value attribute already contains the desired
+    // method.
+    if (submitter.name === '_method') {
+      return submitter.value
+    } else if (submitter.hasAttribute("formmethod")) {
+      return submitter.formMethod
+    } else {
+      return null
+    }
+  } else {
+    return null
+  }
+}
+
+function isBodyInit(body) {
+  return body instanceof FormData || body instanceof URLSearchParams
+}

data/app/javascript/turbo/index.js

@@ -5,3 +5,9 @@ export { Turbo }
 
 import * as cable from "./cable"
 export { cable }
+
+import { encodeMethodIntoRequestBody } from "./fetch_requests"
+
+window.Turbo = Turbo
+
+addEventListener("turbo:before-fetch-request", encodeMethodIntoRequestBody)

data/app/javascript/turbo/snakeize.js

@@ -0,0 +1,31 @@
+// Based on https://github.com/nathan7/snakeize
+//
+// This software is released under the MIT license:
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+export default function walk (obj) {
+    if (!obj || typeof obj !== 'object') return obj;
+    if (obj instanceof Date || obj instanceof RegExp) return obj;
+    if (Array.isArray(obj)) return obj.map(walk);
+    return Object.keys(obj).reduce(function (acc, key) {
+        var camel = key[0].toLowerCase() + key.slice(1).replace(/([A-Z]+)/g, function (m, x) {
+            return '_' + x.toLowerCase();
+        });
+        acc[camel] = walk(obj[key]);
+        return acc;
+    }, {});
+};

data/app/jobs/turbo/streams/action_broadcast_job.rb

@@ -1,6 +1,8 @@
 # The job that powers all the <tt>broadcast_$action_later</tt> broadcasts available in <tt>Turbo::Streams::Broadcasts</tt>.
 class Turbo::Streams::ActionBroadcastJob < ActiveJob::Base
-  def perform(stream, action:, target:, **rendering)
-    Turbo::StreamsChannel.broadcast_action_to stream, action: action, target: target, **rendering
+  discard_on ActiveJob::DeserializationError
+  
+  def perform(stream, action:, target:, attributes: {}, **rendering)
+    Turbo::StreamsChannel.broadcast_action_to stream, action: action, target: target, attributes: attributes, **rendering
   end
 end

data/app/jobs/turbo/streams/broadcast_job.rb

@@ -1,6 +1,8 @@
 # The job that powers the <tt>broadcast_render_later_to</tt> available in <tt>Turbo::Streams::Broadcasts</tt> for rendering
 # turbo stream templates.
 class Turbo::Streams::BroadcastJob < ActiveJob::Base
+  discard_on ActiveJob::DeserializationError
+
   def perform(stream, **rendering)
     Turbo::StreamsChannel.broadcast_render_to stream, **rendering
   end

data/app/jobs/turbo/streams/broadcast_stream_job.rb

@@ -0,0 +1,7 @@
+class Turbo::Streams::BroadcastStreamJob < ActiveJob::Base
+  discard_on ActiveJob::DeserializationError
+
+  def perform(stream, content:)
+    Turbo::StreamsChannel.broadcast_stream_to(stream, content: content)
+  end
+end

data/app/models/concerns/turbo/broadcastable.rb

@@ -26,20 +26,85 @@
 # and finally prepend the result of that partial rendering to the target identified with the dom id "clearances"
 # (which is derived by default from the plural model name of the model, but can be overwritten).
 #
+# You can also choose to render html instead of a partial inside of a broadcast
+# you do this by passing the `html:` option to any broadcast method that accepts the **rendering argument. Example:
+#
+#   class Message < ApplicationRecord
+#     belongs_to :user
+#
+#     after_create_commit :update_message_count
+#
+#     private
+#       def update_message_count
+#         broadcast_update_to(user, :messages, target: "message-count", html: "<p> #{user.messages.count} </p>")
+#       end
+#   end
+#
+# If you want to render a template instead of a partial, e.g. ('messages/index' or 'messages/show'), you can use the `template:` option.
+# Again, only to any broadcast method that accepts the `**rendering` argument. Example:
+#
+#   class Message < ApplicationRecord
+#     belongs_to :user
+#
+#     after_create_commit :update_message
+#
+#     private
+#       def update_message
+#         broadcast_replace_to(user, :message, target: "message", template: "messages/show", locals: { message: self })
+#       end
+#   end
+#
+# If you want to render a renderable object you can use the `renderable:` option.
+#
+#   class Message < ApplicationRecord
+#     belongs_to :user
+#
+#     after_create_commit :update_message
+#
+#     private
+#       def update_message
+#         broadcast_replace_to(user, :message, target: "message", renderable: MessageComponent.new)
+#       end
+#   end
+#
 # There are four basic actions you can broadcast: <tt>remove</tt>, <tt>replace</tt>, <tt>append</tt>, and
 # <tt>prepend</tt>. As a rule, you should use the <tt>_later</tt> versions of everything except for remove when broadcasting
 # within a real-time path, like a controller or model, since all those updates require a rendering step, which can slow down
 # execution. You don't need to do this for remove, since only the dom id for the model is used.
 #
-# In addition to the four basic actions, you can also use <tt>broadcast_render_later</tt> or
-# <tt>broadcast_render_later_to</tt> to render a turbo stream template with multiple actions.
+# In addition to the four basic actions, you can also use <tt>broadcast_render</tt>,
+# <tt>broadcast_render_to</tt> <tt>broadcast_render_later</tt>, and <tt>broadcast_render_later_to</tt>
+# to render a turbo stream template with multiple actions.
+#
+# == Suppressing broadcasts
+#
+# Sometimes, you need to disable broadcasts in certain scenarios. You can use <tt>.suppressing_turbo_broadcasts</tt> to create
+# execution contexts where broadcasts are disabled:
+#
+#   class Message < ApplicationRecord
+#     after_create_commit :update_message
+#
+#     private
+#       def update_message
+#         broadcast_replace_to(user, :message, target: "message", renderable: MessageComponent.new)
+#       end
+#   end
+#
+#   Message.suppressing_turbo_broadcasts do
+#     Message.create!(board: board) # This won't broadcast the replace action
+#   end
 module Turbo::Broadcastable
   extend ActiveSupport::Concern
 
+  included do
+    thread_mattr_accessor :suppressed_turbo_broadcasts, instance_accessor: false
+    delegate :suppressed_turbo_broadcasts?, to: "self.class"
+  end
+
   module ClassMethods
     # Configures the model to broadcast creates, updates, and destroys to a stream name derived at runtime by the
     # <tt>stream</tt> symbol invocation. By default, the creates are appended to a dom id target name derived from
-    # the model's plural name. The insertion can also be made to be a prepend by overwriting <tt>insertion</tt> and
+    # the model's plural name. The insertion can also be made to be a prepend by overwriting <tt>inserts_by</tt> and
     # the target dom id overwritten by passing <tt>target</tt>. Examples:
     #
     #   class Message < ApplicationRecord
@@ -51,18 +116,55 @@ module Turbo::Broadcastable
     #     belongs_to :board
     #     broadcasts_to ->(message) { [ message.board, :messages ] }, inserts_by: :prepend, target: "board_messages"
     #   end
-    def broadcasts_to(stream, inserts_by: :append, target: model_name.plural)
-      after_create_commit  -> { broadcast_action_later_to stream.try(:call, self) || send(stream), action: inserts_by, target: target }
-      after_update_commit  -> { broadcast_replace_later_to stream.try(:call, self) || send(stream) }
-      after_destroy_commit -> { broadcast_remove_to stream.try(:call, self) || send(stream) }
+    #
+    #   class Message < ApplicationRecord
+    #     belongs_to :board
+    #     broadcasts_to ->(message) { [ message.board, :messages ] }, partial: "messages/custom_message"
+    #   end
+    def broadcasts_to(stream, inserts_by: :append, target: broadcast_target_default, **rendering)
+      after_create_commit  -> { broadcast_action_later_to(stream.try(:call, self) || send(stream), action: inserts_by, target: target.try(:call, self) || target, **rendering) }
+      after_update_commit  -> { broadcast_replace_later_to(stream.try(:call, self) || send(stream), **rendering) }
+      after_destroy_commit -> { broadcast_remove_to(stream.try(:call, self) || send(stream)) }
     end
 
-    # Same as <tt>#broadcasts_to</tt>, but the designated stream is automatically set to the current model.
-    def broadcasts(inserts_by: :append, target: model_name.plural)
-      after_create_commit  -> { broadcast_action_later action: inserts_by, target: target }
-      after_update_commit  -> { broadcast_replace_later }
+    # Same as <tt>#broadcasts_to</tt>, but the designated stream for updates and destroys is automatically set to
+    # the current model, for creates - to the model plural name, which can be overriden by passing <tt>stream</tt>.
+    def broadcasts(stream = model_name.plural, inserts_by: :append, target: broadcast_target_default, **rendering)
+      after_create_commit  -> { broadcast_action_later_to(stream, action: inserts_by, target: target.try(:call, self) || target, **rendering) }
+      after_update_commit  -> { broadcast_replace_later(**rendering) }
       after_destroy_commit -> { broadcast_remove }
     end
+
+    # Configures the model to broadcast a "page refresh" on creates, updates, and destroys to a stream
+    # name derived at runtime by the <tt>stream</tt> symbol invocation.
+    def broadcasts_refreshes_to(stream)
+      after_commit -> { broadcast_refresh_later_to(stream.try(:call, self) || send(stream)) }
+    end
+
+    # Same as <tt>#broadcasts_refreshes_to</tt>, but the designated stream for page refreshes is automatically set to
+    # the current model, for creates - to the model plural name, which can be overriden by passing <tt>stream</tt>.
+    def broadcasts_refreshes(stream = model_name.plural)
+      after_create_commit  -> { broadcast_refresh_later_to(stream) }
+      after_update_commit  -> { broadcast_refresh_later }
+      after_destroy_commit -> { broadcast_refresh }
+    end
+
+    # All default targets will use the return of this method. Overwrite if you want something else than <tt>model_name.plural</tt>.
+    def broadcast_target_default
+      model_name.plural
+    end
+
+    # Executes +block+ preventing both synchronous and asynchronous broadcasts from this model.
+    def suppressing_turbo_broadcasts(&block)
+      original, self.suppressed_turbo_broadcasts = self.suppressed_turbo_broadcasts, true
+      yield
+    ensure
+      self.suppressed_turbo_broadcasts = original
+    end
+
+    def suppressed_turbo_broadcasts?
+      suppressed_turbo_broadcasts
+    end
   end
 
   # Remove this broadcastable model from the dom for subscribers of the stream name identified by the passed streamables.
@@ -70,8 +172,8 @@ module Turbo::Broadcastable
   #
   #   # Sends <turbo-stream action="remove" target="clearance_5"></turbo-stream> to the stream named "identity:2:clearances"
   #   clearance.broadcast_remove_to examiner.identity, :clearances
-  def broadcast_remove_to(*streamables)
-    Turbo::StreamsChannel.broadcast_remove_to *streamables, target: self
+  def broadcast_remove_to(*streamables, target: self)
+    Turbo::StreamsChannel.broadcast_remove_to(*streamables, target: target) unless suppressed_turbo_broadcasts?
   end
 
   # Same as <tt>#broadcast_remove_to</tt>, but the designated stream is automatically set to the current model.
@@ -90,7 +192,7 @@ module Turbo::Broadcastable
   #   # to the stream named "identity:2:clearances"
   #   clearance.broadcast_replace_to examiner.identity, :clearances, partial: "clearances/other_partial", locals: { a: 1 }
   def broadcast_replace_to(*streamables, **rendering)
-    Turbo::StreamsChannel.broadcast_replace_to *streamables, target: self, **broadcast_rendering_with_defaults(rendering)
+    Turbo::StreamsChannel.broadcast_replace_to(*streamables, target: self, **broadcast_rendering_with_defaults(rendering)) unless suppressed_turbo_broadcasts?
   end
 
   # Same as <tt>#broadcast_replace_to</tt>, but the designated stream is automatically set to the current model.
@@ -98,6 +200,57 @@ module Turbo::Broadcastable
     broadcast_replace_to self, **rendering
   end
 
+  # Update this broadcastable model in the dom for subscribers of the stream name identified by the passed
+  # <tt>streamables</tt>. The rendering parameters can be set by appending named arguments to the call. Examples:
+  #
+  #   # Sends <turbo-stream action="update" target="clearance_5"><template><div id="clearance_5">My Clearance</div></template></turbo-stream>
+  #   # to the stream named "identity:2:clearances"
+  #   clearance.broadcast_update_to examiner.identity, :clearances
+  #
+  #   # Sends <turbo-stream action="update" target="clearance_5"><template><div id="clearance_5">Other partial</div></template></turbo-stream>
+  #   # to the stream named "identity:2:clearances"
+  #   clearance.broadcast_update_to examiner.identity, :clearances, partial: "clearances/other_partial", locals: { a: 1 }
+  def broadcast_update_to(*streamables, **rendering)
+    Turbo::StreamsChannel.broadcast_update_to(*streamables, target: self, **broadcast_rendering_with_defaults(rendering)) unless suppressed_turbo_broadcasts?
+  end
+
+  # Same as <tt>#broadcast_update_to</tt>, but the designated stream is automatically set to the current model.
+  def broadcast_update(**rendering)
+    broadcast_update_to self, **rendering
+  end
+
+  # Insert a rendering of this broadcastable model before the target identified by it's dom id passed as <tt>target</tt>
+  # for subscribers of the stream name identified by the passed <tt>streamables</tt>. The rendering parameters can be set by
+  # appending named arguments to the call. Examples:
+  #
+  #   # Sends <turbo-stream action="before" target="clearance_5"><template><div id="clearance_4">My Clearance</div></template></turbo-stream>
+  #   # to the stream named "identity:2:clearances"
+  #   clearance.broadcast_before_to examiner.identity, :clearances, target: "clearance_5"
+  #
+  #   # Sends <turbo-stream action="before" target="clearance_5"><template><div id="clearance_4">Other partial</div></template></turbo-stream>
+  #   # to the stream named "identity:2:clearances"
+  #   clearance.broadcast_before_to examiner.identity, :clearances, target: "clearance_5",
+  #     partial: "clearances/other_partial", locals: { a: 1 }
+  def broadcast_before_to(*streamables, target:, **rendering)
+    Turbo::StreamsChannel.broadcast_before_to(*streamables, target: target, **broadcast_rendering_with_defaults(rendering))
+  end
+
+  # Insert a rendering of this broadcastable model after the target identified by it's dom id passed as <tt>target</tt>
+  # for subscribers of the stream name identified by the passed <tt>streamables</tt>. The rendering parameters can be set by
+  # appending named arguments to the call. Examples:
+  #
+  #   # Sends <turbo-stream action="after" target="clearance_5"><template><div id="clearance_6">My Clearance</div></template></turbo-stream>
+  #   # to the stream named "identity:2:clearances"
+  #   clearance.broadcast_after_to examiner.identity, :clearances, target: "clearance_5"
+  #
+  #   # Sends <turbo-stream action="after" target="clearance_5"><template><div id="clearance_6">Other partial</div></template></turbo-stream>
+  #   # to the stream named "identity:2:clearances"
+  #   clearance.broadcast_after_to examiner.identity, :clearances, target: "clearance_5",
+  #     partial: "clearances/other_partial", locals: { a: 1 }
+  def broadcast_after_to(*streamables, target:, **rendering)
+    Turbo::StreamsChannel.broadcast_after_to(*streamables, target: target, **broadcast_rendering_with_defaults(rendering))
+  end
+
   # Append a rendering of this broadcastable model to the target identified by it's dom id passed as <tt>target</tt>
   # for subscribers of the stream name identified by the passed <tt>streamables</tt>. The rendering parameters can be set by
   # appending named arguments to the call. Examples:
@@ -111,7 +264,7 @@ module Turbo::Broadcastable
   #   clearance.broadcast_append_to examiner.identity, :clearances, target: "clearances",
   #     partial: "clearances/other_partial", locals: { a: 1 }
   def broadcast_append_to(*streamables, target: broadcast_target_default, **rendering)
-    Turbo::StreamsChannel.broadcast_append_to *streamables, target: target, **broadcast_rendering_with_defaults(rendering)
+    Turbo::StreamsChannel.broadcast_append_to(*streamables, target: target, **broadcast_rendering_with_defaults(rendering)) unless suppressed_turbo_broadcasts?
   end
 
   # Same as <tt>#broadcast_append_to</tt>, but the designated stream is automatically set to the current model.
@@ -132,32 +285,40 @@ module Turbo::Broadcastable
   #   clearance.broadcast_prepend_to examiner.identity, :clearances, target: "clearances",
   #     partial: "clearances/other_partial", locals: { a: 1 }
   def broadcast_prepend_to(*streamables, target: broadcast_target_default, **rendering)
-    Turbo::StreamsChannel.broadcast_prepend_to *streamables, target: target, **broadcast_rendering_with_defaults(rendering)
+    Turbo::StreamsChannel.broadcast_prepend_to(*streamables, target: target, **broadcast_rendering_with_defaults(rendering)) unless suppressed_turbo_broadcasts?
   end
 
-  # Same as <tt>#broadcast_append_to</tt>, but the designated stream is automatically set to the current model.
+  # Same as <tt>#broadcast_prepend_to</tt>, but the designated stream is automatically set to the current model.
   def broadcast_prepend(target: broadcast_target_default, **rendering)
     broadcast_prepend_to self, target: target, **rendering
   end
 
+  def broadcast_refresh_to(*streamables)
+    Turbo::StreamsChannel.broadcast_refresh_to(*streamables) unless suppressed_turbo_broadcasts?
+  end
+
+  def broadcast_refresh
+    broadcast_refresh_to self
+  end
+
   # Broadcast a named <tt>action</tt>, allowing for dynamic dispatch, instead of using the concrete action methods. Examples:
   #
   #   # Sends <turbo-stream action="prepend" target="clearances"><template><div id="clearance_5">My Clearance</div></template></turbo-stream>
   #   # to the stream named "identity:2:clearances"
   #   clearance.broadcast_action_to examiner.identity, :clearances, action: :prepend, target: "clearances"
-  def broadcast_action_to(*streamables, action:, target: broadcast_target_default, **rendering)
-    Turbo::StreamsChannel.broadcast_action_to(*streamables, action: action, target: target, **broadcast_rendering_with_defaults(rendering))
+  def broadcast_action_to(*streamables, action:, target: broadcast_target_default, attributes: {}, **rendering)
+    Turbo::StreamsChannel.broadcast_action_to(*streamables, action: action, target: target, attributes: attributes, **broadcast_rendering_with_defaults(rendering)) unless suppressed_turbo_broadcasts?
   end
 
   # Same as <tt>#broadcast_action_to</tt>, but the designated stream is automatically set to the current model.
-  def broadcast_action(action, target: broadcast_target_default, **rendering)
-    broadcast_action_to self, action: action, target: target, **rendering
+  def broadcast_action(action, target: broadcast_target_default, attributes: {}, **rendering)
+    broadcast_action_to self, action: action, target: target, attributes: attributes, **rendering
   end
 
 
   # Same as <tt>broadcast_replace_to</tt> but run asynchronously via a <tt>Turbo::Streams::BroadcastJob</tt>.
   def broadcast_replace_later_to(*streamables, **rendering)
-    Turbo::StreamsChannel.broadcast_replace_later_to *streamables, target: self, **broadcast_rendering_with_defaults(rendering)
+    Turbo::StreamsChannel.broadcast_replace_later_to(*streamables, target: self, **broadcast_rendering_with_defaults(rendering)) unless suppressed_turbo_broadcasts?
   end
 
   # Same as <tt>#broadcast_replace_later_to</tt>, but the designated stream is automatically set to the current model.
@@ -165,9 +326,19 @@ module Turbo::Broadcastable
     broadcast_replace_later_to self, **rendering
   end
 
+  # Same as <tt>broadcast_update_to</tt> but run asynchronously via a <tt>Turbo::Streams::BroadcastJob</tt>.
+  def broadcast_update_later_to(*streamables, **rendering)
+    Turbo::StreamsChannel.broadcast_update_later_to(*streamables, target: self, **broadcast_rendering_with_defaults(rendering)) unless suppressed_turbo_broadcasts?
+  end
+
+  # Same as <tt>#broadcast_update_later_to</tt>, but the designated stream is automatically set to the current model.
+  def broadcast_update_later(**rendering)
+    broadcast_update_later_to self, **rendering
+  end
+
   # Same as <tt>broadcast_append_to</tt> but run asynchronously via a <tt>Turbo::Streams::BroadcastJob</tt>.
   def broadcast_append_later_to(*streamables, target: broadcast_target_default, **rendering)
-    Turbo::StreamsChannel.broadcast_append_later_to *streamables, target: target, **broadcast_rendering_with_defaults(rendering)
+    Turbo::StreamsChannel.broadcast_append_later_to(*streamables, target: target, **broadcast_rendering_with_defaults(rendering)) unless suppressed_turbo_broadcasts?
   end
 
   # Same as <tt>#broadcast_append_later_to</tt>, but the designated stream is automatically set to the current model.
@@ -177,7 +348,7 @@ module Turbo::Broadcastable
 
   # Same as <tt>broadcast_prepend_to</tt> but run asynchronously via a <tt>Turbo::Streams::BroadcastJob</tt>.
   def broadcast_prepend_later_to(*streamables, target: broadcast_target_default, **rendering)
-    Turbo::StreamsChannel.broadcast_prepend_later_to *streamables, target: target, **broadcast_rendering_with_defaults(rendering)
+    Turbo::StreamsChannel.broadcast_prepend_later_to(*streamables, target: target, **broadcast_rendering_with_defaults(rendering)) unless suppressed_turbo_broadcasts?
   end
 
   # Same as <tt>#broadcast_prepend_later_to</tt>, but the designated stream is automatically set to the current model.
@@ -185,19 +356,25 @@ module Turbo::Broadcastable
     broadcast_prepend_later_to self, target: target, **rendering
   end
 
-  # Same as <tt>broadcast_action_later_to</tt> but run asynchronously via a <tt>Turbo::Streams::BroadcastJob</tt>.
-  def broadcast_action_later_to(*streamables, action:, target: broadcast_target_default, **rendering)
-    Turbo::StreamsChannel.broadcast_action_later_to(*streamables, action: action, target: target, **broadcast_rendering_with_defaults(rendering))
+  def broadcast_refresh_later_to(*streamables)
+    Turbo::StreamsChannel.broadcast_refresh_later_to(*streamables, request_id: Turbo.current_request_id) unless suppressed_turbo_broadcasts?
   end
 
-  # Same as <tt>#broadcast_action_later_to</tt>, but the designated stream is automatically set to the current model.
-  def broadcast_action_later(action:, target: broadcast_target_default, **rendering)
-    broadcast_action_later_to self, action: action, target: target, **rendering
+  def broadcast_refresh_later
+    broadcast_refresh_later_to self
+  end
+
+  # Same as <tt>broadcast_action_to</tt> but run asynchronously via a <tt>Turbo::Streams::BroadcastJob</tt>.
+  def broadcast_action_later_to(*streamables, action:, target: broadcast_target_default, attributes: {}, **rendering)
+    Turbo::StreamsChannel.broadcast_action_later_to(*streamables, action: action, target: target, attributes: attributes, **broadcast_rendering_with_defaults(rendering)) unless suppressed_turbo_broadcasts?
   end
 
+  # Same as <tt>#broadcast_action_later_to</tt>, but the designated stream is automatically set to the current model.
+  def broadcast_action_later(action:, target: broadcast_target_default, attributes: {}, **rendering)
+    broadcast_action_later_to self, action: action, target: target, attributes: attributes, **rendering
+  end
 
-  # Render a turbo stream template asynchronously with this broadcastable model passed as the local variable using a
-  # <tt>Turbo::Streams::BroadcastJob</tt>. Example:
+  # Render a turbo stream template with this broadcastable model passed as the local variable. Example:
   #
   #   # Template: entries/_entry.turbo_stream.erb
   #   <%= turbo_stream.remove entry %>
@@ -209,27 +386,58 @@ module Turbo::Broadcastable
   #   <turbo-stream action="remove" target="entry_5"></turbo-stream>
   #   <turbo-stream action="append" target="entries"><template><div id="entry_5">My Entry</div></template></turbo-stream>
   #
-  # ...to the stream named "entry:5"
+  # ...to the stream named "entry:5".
+  #
+  # Note that rendering inline via this method will cause template rendering to happen synchronously. That is usually not
+  # desireable for model callbacks, certainly not if those callbacks are inside of a transaction. Most of the time you should
+  # be using `broadcast_render_later`, unless you specifically know why synchronous rendering is needed.
+  def broadcast_render(**rendering)
+    broadcast_render_to self, **rendering
+  end
+
+  # Same as <tt>broadcast_render</tt> but run with the added option of naming the stream using the passed
+  # <tt>streamables</tt>.
+  #
+  # Note that rendering inline via this method will cause template rendering to happen synchronously. That is usually not
+  # desireable for model callbacks, certainly not if those callbacks are inside of a transaction. Most of the time you should
+  # be using `broadcast_render_later_to`, unless you specifically know why synchronous rendering is needed.
+  def broadcast_render_to(*streamables, **rendering)
+    Turbo::StreamsChannel.broadcast_render_to(*streamables, **broadcast_rendering_with_defaults(rendering)) unless suppressed_turbo_broadcasts?
+  end
+
+  # Same as <tt>broadcast_action_to</tt> but run asynchronously via a <tt>Turbo::Streams::BroadcastJob</tt>.
   def broadcast_render_later(**rendering)
     broadcast_render_later_to self, **rendering
   end
 
-  # Same as <tt>broadcast_prepend_to</tt> but run with the added option of naming the stream using the passed
+  # Same as <tt>broadcast_render_later</tt> but run with the added option of naming the stream using the passed
   # <tt>streamables</tt>.
   def broadcast_render_later_to(*streamables, **rendering)
-    Turbo::StreamsChannel.broadcast_render_later_to *streamables, **broadcast_rendering_with_defaults(rendering)
+    Turbo::StreamsChannel.broadcast_render_later_to(*streamables, **broadcast_rendering_with_defaults(rendering)) unless suppressed_turbo_broadcasts?
   end
 
 
   private
     def broadcast_target_default
-      model_name.plural
+      self.class.broadcast_target_default
     end
 
     def broadcast_rendering_with_defaults(options)
       options.tap do |o|
-        o[:locals]    = (o[:locals] || {}).reverse_merge!(model_name.singular.to_sym => self)
-        o[:partial] ||= to_partial_path
+        # Add the current instance into the locals with the element name (which is the un-namespaced name)
+        # as the key. This parallels how the ActionView::ObjectRenderer would create a local variable.
+        o[:locals] = (o[:locals] || {}).reverse_merge!(model_name.element.to_sym => self, request_id: Turbo.current_request_id).compact
+
+        if o[:html] || o[:partial]
+          return o
+        elsif o[:template] || o[:renderable]
+          o[:layout] = false
+        elsif o[:render] == false
+          return o
+        else
+          # if none of these options are passed in, it will set a partial from #to_partial_path
+          o[:partial] ||= to_partial_path
+        end
       end
     end
 end

data/app/models/turbo/debouncer.rb

@@ -0,0 +1,24 @@
+class Turbo::Debouncer
+  attr_reader :delay, :scheduled_task
+
+  DEFAULT_DELAY = 0.5
+
+  def initialize(delay: DEFAULT_DELAY)
+    @delay = delay
+    @scheduled_task = nil
+  end
+
+  def debounce(&block)
+    scheduled_task&.cancel unless scheduled_task&.complete?
+    @scheduled_task = Concurrent::ScheduledTask.execute(delay, &block)
+  end
+
+  def wait
+    scheduled_task&.wait(wait_timeout)
+  end
+
+  private
+    def wait_timeout
+      delay + 1
+    end
+end