turbo-rails 1.0.1 → 1.4.0

data/app/channels/turbo/streams/broadcasts.rb

@@ -35,7 +35,7 @@ module Turbo::Streams::Broadcasts
 
   def broadcast_action_to(*streamables, action:, target: nil, targets: nil, **rendering)
     broadcast_stream_to(*streamables, content: turbo_stream_action_tag(action, target: target, targets: targets, template:
-      rendering.delete(:content) || (rendering.any? ? render_format(:html, **rendering) : nil)
+      rendering.delete(:content) || rendering.delete(:html) || (rendering.any? ? render_format(:html, **rendering) : nil)
     ))
   end
 

data/app/controllers/turbo/frames/frame_request.rb

@@ -1,19 +1,27 @@
 # Turbo frame requests are requests made from within a turbo frame with the intention of replacing the content of just
 # that frame, not the whole page. They are automatically tagged as such by the Turbo Frame JavaScript, which adds a
-# <tt>Turbo-Frame</tt> header to the request. When that header is detected by the controller, we ensure that any
-# template layout is skipped (since we're only working on an in-page frame, thus can skip the weight of the layout), and
-# that the etag for the page is changed (such that a cache for a layout-less request isn't served on a normal request
-# and vice versa).
+# <tt>Turbo-Frame</tt> header to the request.
 #
-# This is merely a rendering optimization. Everything would still work just fine if we rendered everything including the layout.
-# Turbo Frames knows how to fish out the relevant frame regardless.
+# When that header is detected by the controller, we substitute our own minimal layout in place of the
+# application-supplied layout (since we're only working on an in-page frame, thus can skip the weight of the layout). We
+# use a minimal layout, rather than avoid the layout entirely, so that it's still possible to render content into the
+# <tt>head<tt>.
+#
+# Accordingly, we ensure that the etag for the page is changed, such that a cache for a minimal-layout request isn't
+# served on a normal request and vice versa.
+#
+# This is merely a rendering optimization. Everything would still work just fine if we rendered everything including the
+# full layout. Turbo Frames knows how to fish out the relevant frame regardless.
+#
+# The layout used is <tt>turbo_rails/frame.html.erb</tt>. If there's a need to customize this layout, an application can
+# supply its own (such as <tt>app/views/layouts/turbo_rails/frame.html.erb</tt>) which will be used instead.
 #
 # This module is automatically included in <tt>ActionController::Base</tt>.
 module Turbo::Frames::FrameRequest
   extend ActiveSupport::Concern
 
   included do
-    layout -> { false if turbo_frame_request? }
+    layout -> { "turbo_rails/frame" if turbo_frame_request? }
     etag { :frame if turbo_frame_request? }
   end
 

data/app/controllers/turbo/native/navigation.rb

@@ -33,8 +33,10 @@ module Turbo::Native::Navigation
 
   # :nodoc:
   def turbo_native_action_or_redirect(url, action, redirect_type, options = {})
+    native_params = options.delete(:native_params) || {}
+
     if turbo_native_app?
-      redirect_to send("turbo_#{action}_historical_location_url", notice: options[:notice] || options.delete(:native_notice))
+      redirect_to send("turbo_#{action}_historical_location_url", notice: options[:notice], **native_params)
     elsif redirect_type == :back
       redirect_back fallback_location: url, **options
     else

data/app/helpers/turbo/drive_helper.rb

@@ -1,6 +1,5 @@
 module Turbo::DriveHelper
-  # Pages that are more likely than not to be a cache miss can skip turbo cache to avoid visual jitter.
-  # Note: This requires a +yield :head+ provision in the application layout.
+  # Note: These helpers require a +yield :head+ provision in the layout.
   #
   # ==== Example
   #
@@ -10,7 +9,21 @@ module Turbo::DriveHelper
   #   # app/views/trays/index.html.erb
   #   <% turbo_exempts_page_from_cache %>
   #   <p>Page that shouldn't be cached by Turbo</p>
+
+  # Pages that are more likely than not to be a cache miss can skip turbo cache to avoid visual jitter.
+  # Cannot be used along with +turbo_exempts_page_from_preview+.
   def turbo_exempts_page_from_cache
-    provide :head, %(<meta name="turbo-cache-control" content="no-cache">).html_safe
+    provide :head, tag.meta(name: "turbo-cache-control", content: "no-cache")
+  end
+
+  # Specify that a cached version of the page should not be shown as a preview during an application visit.
+  # Cannot be used along with +turbo_exempts_page_from_cache+.
+  def turbo_exempts_page_from_preview
+    provide :head, tag.meta(name: "turbo-cache-control", content: "no-preview")
+  end
+
+  # Force the page, when loaded by Turbo, to be cause a full page reload.
+  def turbo_page_requires_reload
+    provide :head, tag.meta(name: "turbo-visit-control", content: "reload")
   end
 end

data/app/helpers/turbo/frames_helper.rb

@@ -23,8 +23,20 @@ module Turbo::FramesHelper
   #     <div>My tray frame!</div>
   #   <% end %>
   #   # => <turbo-frame id="tray"><div>My tray frame!</div></turbo-frame>
-  def turbo_frame_tag(id, src: nil, target: nil, **attributes, &block)
-    id = id.respond_to?(:to_key) ? dom_id(id) : id
+  #
+  # The `turbo_frame_tag` helper will convert the arguments it receives to their
+  # `dom_id` if applicable to easily generate unique ids for Turbo Frames:
+  #
+  #   <%= turbo_frame_tag(Article.find(1)) %>
+  #   # => <turbo-frame id="article_1"></turbo-frame>
+  #
+  #   <%= turbo_frame_tag(Article.find(1), "comments") %>
+  #   # => <turbo-frame id="article_1_comments"></turbo-frame>
+  #
+  #   <%= turbo_frame_tag(Article.find(1), Comment.new) %>
+  #   # => <turbo-frame id="article_1_new_comment"></turbo-frame>
+  def turbo_frame_tag(*ids, src: nil, target: nil, **attributes, &block)
+    id = ids.map { |id| id.respond_to?(:to_key) ? ActionView::RecordIdentifier.dom_id(id) : id }.join("_")
     src = url_for(src) if src.present?
 
     tag.turbo_frame(**attributes.merge(id: id, src: src, target: target).compact, &block)

data/app/helpers/turbo/streams/action_helper.rb

@@ -1,4 +1,6 @@
 module Turbo::Streams::ActionHelper
+  include ActionView::Helpers::TagHelper
+
   # Creates a `turbo-stream` tag according to the passed parameters. Examples:
   #
   #   turbo_stream_action_tag "remove", target: "message_1"
@@ -9,22 +11,22 @@ module Turbo::Streams::ActionHelper
   #
   #   turbo_stream_action_tag "replace", targets: "message_1", template: %(<div id="message_1">Hello!</div>)
   #   # => <turbo-stream action="replace" targets="message_1"><template><div id="message_1">Hello!</div></template></turbo-stream>
-  def turbo_stream_action_tag(action, target: nil, targets: nil, template: nil)
-    template = action.to_sym == :remove ? "" : "<template>#{template}</template>"
+  def turbo_stream_action_tag(action, target: nil, targets: nil, template: nil, **attributes)
+    template = action.to_sym == :remove ? "" : tag.template(template.to_s.html_safe)
 
     if target = convert_to_turbo_stream_dom_id(target)
-      %(<turbo-stream action="#{action}" target="#{target}">#{template}</turbo-stream>).html_safe
+      tag.turbo_stream(template, **attributes, action: action, target: target)
     elsif targets = convert_to_turbo_stream_dom_id(targets, include_selector: true)
-      %(<turbo-stream action="#{action}" targets="#{targets}">#{template}</turbo-stream>).html_safe
+      tag.turbo_stream(template, **attributes, action: action, targets: targets)
     else
-      raise ArgumentError, "target or targets must be supplied"
+      tag.turbo_stream(template, **attributes, action: action)
     end
   end
 
   private
     def convert_to_turbo_stream_dom_id(target, include_selector: false)
       if target.respond_to?(:to_key)
-        [ ("#" if include_selector), ActionView::RecordIdentifier.dom_id(target) ].compact.join
+        "#{"#" if include_selector}#{ActionView::RecordIdentifier.dom_id(target)}"
       else
         target
       end

data/app/helpers/turbo/streams_helper.rb

@@ -44,6 +44,11 @@ module Turbo::StreamsHelper
   # or a class name):
   #
   #   <%= turbo_stream_from "room", channel: RoomChannel %>
+  #
+  # It is also possible to pass additional parameters to the channel by passing them through `data` attributes:
+  #
+  #   <%= turbo_stream_from "room", channel: RoomChannel, data: {room_name: "room #1"} %>
+  #
   def turbo_stream_from(*streamables, **attributes)
     attributes[:channel] = attributes[:channel]&.to_s || "Turbo::StreamsChannel"
     attributes[:"signed-stream-name"] = Turbo::StreamsChannel.signed_stream_name(streamables)

data/app/javascript/turbo/cable_stream_source_element.js

@@ -1,10 +1,15 @@
 import { connectStreamSource, disconnectStreamSource } from "@hotwired/turbo"
 import { subscribeTo } from "./cable"
+import snakeize from "./snakeize"
 
 class TurboCableStreamSourceElement extends HTMLElement {
   async connectedCallback() {
     connectStreamSource(this)
-    this.subscription = await subscribeTo(this.channel, { received: this.dispatchMessageEvent.bind(this) })
+    this.subscription = await subscribeTo(this.channel, {
+      received: this.dispatchMessageEvent.bind(this),
+      connected: this.subscriptionConnected.bind(this),
+      disconnected: this.subscriptionDisconnected.bind(this)
+    })
   }
 
   disconnectedCallback() {
@@ -17,11 +22,22 @@ class TurboCableStreamSourceElement extends HTMLElement {
     return this.dispatchEvent(event)
   }
 
+  subscriptionConnected() {
+    this.setAttribute("connected", "")
+  }
+
+  subscriptionDisconnected() {
+    this.removeAttribute("connected")
+  }
+
   get channel() {
     const channel = this.getAttribute("channel")
     const signed_stream_name = this.getAttribute("signed-stream-name")
-    return { channel, signed_stream_name }
+    return { channel, signed_stream_name, ...snakeize({ ...this.dataset }) }
   }
 }
 
-customElements.define("turbo-cable-stream-source", TurboCableStreamSourceElement)
+
+if (customElements.get("turbo-cable-stream-source") === undefined) {
+  customElements.define("turbo-cable-stream-source", TurboCableStreamSourceElement)
+}

data/app/javascript/turbo/fetch_requests.js

@@ -0,0 +1,50 @@
+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) {
+    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,7 @@ export { Turbo }
 
 import * as cable from "./cable"
 export { cable }
+
+import { encodeMethodIntoRequestBody } from "./fetch_requests"
+
+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/models/concerns/turbo/broadcastable.rb

@@ -27,8 +27,8 @@
 # (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
-# 
+# you do this by passing the `html:` option to any broadcast method that accepts the **rendering argument. Example:
+#
 #   class Message < ApplicationRecord
 #     belongs_to :user
 #
@@ -39,7 +39,21 @@
 #         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
+#
 # 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
@@ -66,16 +80,22 @@ 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: broadcast_target_default)
-      after_create_commit  -> { broadcast_action_later_to stream.try(:call, self) || send(stream), action: inserts_by, target: target.try(:call, self) || 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: broadcast_target_default)
-      after_create_commit  -> { broadcast_action_later action: inserts_by, target: target.try(:call, self) || 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
 
@@ -329,8 +349,13 @@ module Turbo::Broadcastable
         # 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)
-        # if the html option is passed in it will skip setting a partial from #to_partial_path
-        unless o.include?(:html)
+
+        if o[:html] || o[:partial]
+          return o
+        elsif o[:template]
+          o[:layout] = false
+        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

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

@@ -50,7 +50,7 @@ class Turbo::Streams::TagBuilder
     action_all :remove, targets, 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
+  # 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>" %>
@@ -63,7 +63,7 @@ class Turbo::Streams::TagBuilder
     action :replace, target, content, **rendering, &block
   end
 
-  # Replace the <tt>targets</tt> in the dom with the either the <tt>content</tt> passed in, 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>" %>
@@ -128,7 +128,7 @@ class Turbo::Streams::TagBuilder
     action_all :after, targets, 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
+  # 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" %>
@@ -141,7 +141,7 @@ class Turbo::Streams::TagBuilder
     action :update, target, content, **rendering, &block
   end
 
-  # Update the <tt>targets</tt> in the dom with the either the <tt>content</tt> passed in or a rendering result determined
+  # 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" %>
@@ -227,6 +227,8 @@ class Turbo::Streams::TagBuilder
   private
     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?

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

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

data/lib/tasks/turbo_tasks.rake

@@ -3,7 +3,9 @@ def run_turbo_install_template(path)
 end
 
 def redis_installed?
-  system('which redis-server > /dev/null')
+  Gem.win_platform? ?
+    system('where redis-server > NUL 2>&1') : 
+    system('which redis-server > /dev/null')
 end
 
 def switch_on_redis_if_available

data/lib/turbo/engine.rb

@@ -16,8 +16,8 @@ module Turbo
       #{root}/app/jobs
     )
 
-    initializer "turbo.no_action_cable" do
-      Rails.autoloaders.once.do_not_eager_load(Dir["#{root}/app/channels/turbo/*_channel.rb"]) unless defined?(ActionCable)
+    initializer "turbo.no_action_cable", before: :set_eager_load_paths do
+      config.eager_load_paths.delete("#{root}/app/channels") unless defined?(ActionCable)
     end
 
     # If you don't want to precompile Turbo's assets (eg. because you're using webpack),
@@ -61,8 +61,10 @@ module Turbo
     end
 
     initializer "turbo.signed_stream_verifier_key" do
-      Turbo.signed_stream_verifier_key = config.turbo.signed_stream_verifier_key ||
-        Rails.application.key_generator.generate_key("turbo/signed_stream_verifier_key")
+      config.after_initialize do
+        Turbo.signed_stream_verifier_key = config.turbo.signed_stream_verifier_key ||
+          Rails.application.key_generator.generate_key("turbo/signed_stream_verifier_key")
+      end
     end
 
     initializer "turbo.test_assertions" do

data/lib/turbo/test_assertions.rb

@@ -7,15 +7,21 @@ module Turbo
       delegate :dom_id, :dom_class, to: ActionView::RecordIdentifier
     end
 
-    def assert_turbo_stream(action:, target: nil, status: :ok, &block)
+    def assert_turbo_stream(action:, target: nil, targets: nil, status: :ok, &block)
       assert_response status
       assert_equal Mime[:turbo_stream], response.media_type
-      assert_select %(turbo-stream[action="#{action}"][target="#{target.respond_to?(:to_key) ? dom_id(target) : target}"]), count: 1, &block
+      selector =  %(turbo-stream[action="#{action}"])
+      selector << %([target="#{target.respond_to?(:to_key) ? dom_id(target) : target}"]) if target
+      selector << %([targets="#{targets}"]) if targets
+      assert_select selector, count: 1, &block
     end
 
-    def assert_no_turbo_stream(action:, target: nil)
+    def assert_no_turbo_stream(action:, target: nil, targets: nil)
       assert_equal Mime[:turbo_stream], response.media_type
-      assert_select %(turbo-stream[action="#{action}"][target="#{target.respond_to?(:to_key) ? dom_id(target) : target}"]), count: 0
+      selector =  %(turbo-stream[action="#{action}"])
+      selector << %([target="#{target.respond_to?(:to_key) ? dom_id(target) : target}"]) if target
+      selector << %([targets="#{targets}"]) if targets
+      assert_select selector, count: 0
     end
   end
 end

data/lib/turbo/version.rb

@@ -1,3 +1,3 @@
 module Turbo
-  VERSION = "1.0.1"
+  VERSION = "1.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: turbo-rails
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.4.0
 platform: ruby
 authors:
 - Sam Stephenson
@@ -10,8 +10,22 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-16 00:00:00.000000000 Z
+date: 2023-03-01 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
 - !ruby/object:Gem::Dependency
   name: actionpack
   requirement: !ruby/object:Gem::Requirement
@@ -66,11 +80,14 @@ files:
 - app/helpers/turbo/streams_helper.rb
 - app/javascript/turbo/cable.js
 - app/javascript/turbo/cable_stream_source_element.js
+- app/javascript/turbo/fetch_requests.js
 - app/javascript/turbo/index.js
+- app/javascript/turbo/snakeize.js
 - app/jobs/turbo/streams/action_broadcast_job.rb
 - app/jobs/turbo/streams/broadcast_job.rb
 - app/models/concerns/turbo/broadcastable.rb
 - app/models/turbo/streams/tag_builder.rb
+- app/views/layouts/turbo_rails/frame.html.erb
 - config/routes.rb
 - lib/install/turbo_needs_redis.rb
 - lib/install/turbo_with_importmap.rb
@@ -99,7 +116,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: The speed of a single-page web application without having to write any JavaScript.