turbo-rails 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a04c56491cef79ef30cdf087a1f1e4cd33d7673ac2cc48e239dfdda1d72eba9
-  data.tar.gz: 8c5e1082280c5663717638e3b78c136542b8692d952f2547880140efffc5abea
+  metadata.gz: 5b0552458511ec8ad34c4b0b3978d2a9ffb88485b844f60f6bc283287e0eecdd
+  data.tar.gz: eccd64955e5db2682efe9b503c24feeb6cbf50c1e542d7bcef0416ded95026fb
 SHA512:
-  metadata.gz: 14d8247c79082e8b6d495492b0b955703f8739247ce39c0604ca384b9b9d43e33d8509e1a5adfa97283cfa9420df3be0bd887b3109ec0784e67d83b2c952eefa
-  data.tar.gz: b8211e86013e1919df5099c830a5fe22964b8f4ef2cd59871da0d08d8152dc88e639992ac26dfedf9bc6e57cae1a62af20577e1dd103c85563e5203f9c27d562
+  metadata.gz: 950a8abe637775b61e610d9c99a61f22fa514704a2a3d4453a0e53854c2c4dfe4e4c65f342cd534869d9d1edd83c513590a70744632a6981df52265b20ca142e
+  data.tar.gz: 5d97247505d6934b2bda932a53b0ca3b19d69fe7000a269001cd50ecc9f38bba090e26f50a3d489073699a93ccc50093f218465f45b054969d10c10026052100

data/.github/workflows/ci.yml

@@ -6,10 +6,16 @@ jobs:
       matrix:
         ruby-version:
           - "2.7"
-          - head
+          - "3.0"
+        continue-on-error: [ false ]
+
+        include:
+          - ruby-version: head
+            continue-on-error: true
 
     name: ${{ format('Tests (Ruby {0})', matrix.ruby-version) }}
     runs-on: ubuntu-latest
+    continue-on-error: ${{ matrix.continue-on-error }}
 
     steps:
       - uses: actions/checkout@v1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    turbo-rails (0.5.0)
+    turbo-rails (0.5.1)
       rails (>= 6.0.0)
 
 GEM

data/README.md

@@ -1,6 +1,6 @@
 # Turbo
 
-[Turbo](https://turbo.hotwire.dev) gives you the speed of a single-page web application without having to write any JavaScript. Turbo accelerates links and form submissions without requiring you to change your server-side generated HTML. It lets you carve up a page into independent frames, which can be lazy-loaded and operate as independent components. And finally, helps you make partial page updates using just HTML and a set of CRUD-like container tags. These three techniques reduce the amount of custom JavaScript that many web applications need to write by an order of magnitude. And for the few dynamic bits that are left, you're invited to finished the job with Stimulus.
+[Turbo](https://turbo.hotwire.dev) gives you the speed of a single-page web application without having to write any JavaScript. Turbo accelerates links and form submissions without requiring you to change your server-side generated HTML. It lets you carve up a page into independent frames, which can be lazy-loaded and operate as independent components. And finally, helps you make partial page updates using just HTML and a set of CRUD-like container tags. These three techniques reduce the amount of custom JavaScript that many web applications need to write by an order of magnitude. And for the few dynamic bits that are left, you're invited to finish the job with [Stimulus](https://github.com/hotwired/stimulus).
 
 On top of accelerating web applications, Turbo was built from the ground-up to form the foundation of hybrid native applications. Write the navigational shell of your Android or iOS app using the standard platform tooling, then seamlessly fill in features from the web, following native navigation patterns. Not every mobile screen needs to be written in Swift or Kotlin to feel native. With Turbo, you spend less time wrangling JSON, waiting on app stores to approve updates, or reimplementing features you've already created in HTML.
 
@@ -32,36 +32,16 @@ With this Rails integration, you can create these asynchronous updates directly
 
 ## Installation
 
-The JavaScript for Turbo can either be run through the asset pipeline, which is included with this gem, or through the package that lives on NPM, through Webpacker. If you use the asset pipeline, installation is as follows:
+The JavaScript for Turbo can either be run through the asset pipeline, which is included with this gem, or through the package that lives on NPM, through Webpacker.
 
 1. Add the `turbo-rails` gem to your Gemfile: `gem 'turbo-rails'`
 2. Run `./bin/bundle install`
 3. Run `./bin/rails turbo:install`
 
-If you use Webpacker, it's:
+Running `turbo:install` will install through NPM if Webpacker is installed in the application. Otherwise the asset pipeline version is used.
 
-1. Add the `turbo-rails` gem to your Gemfile: `gem 'turbo-rails'`
-2. Run `./bin/bundle install`
-3. Run `./bin/yarn add @hotwired/turbo-rails`
-4. Add it to your application's JavaScript pack:
+If you're using Webpack and need to use either the cable consumer or the Turbo instance, you can import [`Turbo`](https://turbo.hotwire.dev/reference/drive) and/or [`cable`](https://github.com/hotwired/turbo-rails/blob/87542edecc4008c46249e5d8ede79b3eda62a5e2/app/javascript/turbo/cable.js) (`import { Turbo, cable } from "@hotwired/turbo-rails"`), but ensure that your application actually *uses* the members it `import`s when using this style (see [turbo-rails#48](https://github.com/hotwired/turbo-rails/issues/48)).
 
-   ```js
-   import { Turbo, cable } from "@hotwired/turbo-rails"
-   ```
- 
-Note, if you were using Turbolinks/Rails UJS in your app previously, you should remove them:
-
-1. Remove the `turbolinks` gem from your Gemfile.
-2. Run `./bin/bundle install`
-3. Run `./bin/yarn remove turbolinks @rails/ujs`
-4. Remove these from your application's JavaScript pack:
-
-   ```js
-   import Rails from "@rails/ujs"
-   import Turbolinks from "turbolinks"
-   Rails.start()
-   Turbolinks.start()
-   ```
 
 ## Usage
 

data/app/assets/javascripts/turbo.js

@@ -2675,7 +2675,7 @@ var cable = Object.freeze({
 class TurboCableStreamSourceElement extends HTMLElement {
   async connectedCallback() {
     connectStreamSource(this);
-    this.subscription = subscribeTo(this.channel, {
+    this.subscription = await subscribeTo(this.channel, {
       received: this.dispatchMessageEvent.bind(this)
     });
   }

data/app/helpers/turbo/frames_helper.rb

@@ -7,17 +7,22 @@ module Turbo::FramesHelper
   #   <%= turbo_frame_tag "tray", src: tray_path(tray) %>
   #   # => <turbo-frame id="tray" src="http://example.com/trays/1"></turbo-frame>
   #
-  #   <%= turbo_frame_tag "tray", src: tray_path(tray), links_target: "top" %>
-  #   # => <turbo-frame id="tray" links-target="top" src="http://example.com/trays/1"></turbo-frame>
+  #   <%= turbo_frame_tag tray, src: tray_path(tray) %>
+  #   # => <turbo-frame id="tray_1" src="http://example.com/trays/1"></turbo-frame>
   #
-  #   <%= turbo_frame_tag "tray", links_target: "other_tray" %>
-  #   # => <turbo-frame id="tray" links-target="other_tray"></turbo-frame>
+  #   <%= turbo_frame_tag "tray", src: tray_path(tray), target: "_top" %>
+  #   # => <turbo-frame id="tray" target="_top" src="http://example.com/trays/1"></turbo-frame>
+  #
+  #   <%= turbo_frame_tag "tray", target: "other_tray" %>
+  #   # => <turbo-frame id="tray" target="other_tray"></turbo-frame>
   #
   #   <%= turbo_frame_tag "tray" do %>
   #     <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
+
     tag.turbo_frame(**attributes.merge(id: id, src: src, target: target).compact, &block)
   end
 end

data/app/helpers/turbo/streams_helper.rb

@@ -1,6 +1,29 @@
 module Turbo::StreamsHelper
   # Returns a new <tt>Turbo::Streams::TagBuilder</tt> object that accepts stream actions and renders them them as
   # the template tags needed to send across the wire. This object is automatically yielded to turbo_stream.erb templates.
+  #
+  # When responding to HTTP requests, controllers can declare `turbo_stream` format response templates in that same
+  # style as `html` and `json` response formats. For example, consider a `MessagesController` that responds to both
+  # `text/html` and `text/html; turbo-stream=*; charset=utf-8` requests along with a `.turbo_stream.erb` action template:
+  #
+  #   def create
+  #     @message = Message.create!(params.require(:message).permit(:content))
+  #     respond_to do |format|
+  #       format.turbo_stream
+  #       format.html { redirect_to messages_url }
+  #     end
+  #   end
+  #
+  #   <%# app/views/messages/create.turbo_stream.erb %>
+  #   <%= turbo_stream.append "messages", @message %>
+  #
+  #   <%= turbo_stream.replace "new_message" do %>
+  #     <%= render partial: "new_message", locals: { room: @room } %>
+  #   <% end %>
+  #
+  # When a `app/views/messages/create.turbo_stream.erb` template exists, the
+  # `MessagesController#create` will respond to `text/html; turbo-stream`
+  # requests by rendering the `messages/create.turbo_stream.erb` view template and transmitting the response
   def turbo_stream
     Turbo::Streams::TagBuilder.new(self)
   end
@@ -15,7 +38,7 @@ module Turbo::StreamsHelper
   #
   # The example above will process all turbo streams sent to a stream name like <tt>account:5:entries</tt>
   # (when Current.account.id = 5). Updates to this stream can be sent like
-  # <tt>entry.broadcast_append_to entry.account, :entries, contrainer: "entries"</tt>.
+  # <tt>entry.broadcast_append_to entry.account, :entries, container: "entries"</tt>.
   def turbo_stream_from(*streamables)
     tag.turbo_cable_stream_source channel: "Turbo::StreamsChannel", "signed-stream-name": Turbo::StreamsChannel.signed_stream_name(streamables)
   end

data/app/javascript/turbo/cable_stream_source_element.js

@@ -4,7 +4,7 @@ import { subscribeTo } from "./cable"
 class TurboCableStreamSourceElement extends HTMLElement {
   async connectedCallback() {
     connectStreamSource(this)
-    this.subscription = subscribeTo(this.channel, { received: this.dispatchMessageEvent.bind(this) })
+    this.subscription = await subscribeTo(this.channel, { received: this.dispatchMessageEvent.bind(this) })
   }
 
   disconnectedCallback() {

data/app/javascript/turbo/index.js

@@ -1,3 +1,7 @@
 import "./cable_stream_source_element"
-export * as Turbo from "@hotwired/turbo"
-export * as cable from "./cable"
+
+import * as Turbo from "@hotwired/turbo"
+export { Turbo }
+
+import * as cable from "./cable"
+export { cable }

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

@@ -202,15 +202,14 @@ module Turbo::Broadcastable
   #   # Template: entries/_entry.turbo_stream.erb
   #   <%= turbo_stream.remove entry %>
   #
-  #   <%= turbo_stream.append "entries" do %>
-  #     <%= render partial: "entries/entry", locals: { entry: entry }, formats: [ :html ] %>
-  #   <% end if entry.active? %>
+  #   <%= turbo_stream.append "entries", entry if entry.active? %>
   #
-  #   # Sends:
-  #   #   <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"
-  #   entry.broadcast_render_later
+  # Sends:
+  #
+  #   <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"
   def broadcast_render_later(**rendering)
     broadcast_render_later_to self, **rendering
   end

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

@@ -12,8 +12,8 @@
 #   <%= turbo_stream.remove entry %>
 #
 #   <%= turbo_stream.append "entries" do %>
-#     <% # format ensures that the _entry.html.erb partial is rendered, not _entry.turbo_stream.erb %>
-#     <%= render partial: "entries/entry", locals: { entry: entry }, formats: [ :html ] %>
+#     <% # 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 %>
 #
 # Or you can render the HTML that should be part of the update inline:

data/lib/install/turbo_with_asset_pipeline.rb

@@ -0,0 +1,20 @@
+APPLICATION_LAYOUT_PATH = Rails.root.join("app/views/layouts/application.html.erb")
+
+if APPLICATION_LAYOUT_PATH.exist?
+  say "Yield head in application layout for cache helper"
+  insert_into_file APPLICATION_LAYOUT_PATH.to_s, "\n    <%= yield :head %>", before: /\s*<\/head>/
+
+  say "Add Turbo include tags in application layout"
+  insert_into_file APPLICATION_LAYOUT_PATH.to_s, "\n    <%= turbo_include_tags %>", before: /\s*<\/head>/
+else
+  say "Default application.html.erb is missing!", :red
+  say "        Add <%= turbo_include_tags %> and <%= yield :head %> within the <head> tag in your custom layout."
+end
+
+say "Enable redis in bundle"
+uncomment_lines "Gemfile", %(gem 'redis')
+
+say "Switch development cable to use redis"
+gsub_file "config/cable.yml", /development:\n\s+adapter: async/, "development:\n  adapter: redis\n  url: redis://localhost:6379/1"
+
+say "Turbo successfully installed ⚡️", :green

data/lib/install/turbo_with_webpacker.rb

@@ -0,0 +1,24 @@
+# Some Rails versions use commonJS(require) others use ESM(import).
+TURBOLINKS_REGEX = /(import .* from "turbolinks".*\n|require\("turbolinks"\).*\n)/.freeze
+
+abort "❌ Webpacker not found. Exiting." unless defined?(Webpacker::Engine)
+
+say "Install Turbo"
+run "yarn add @hotwired/turbo-rails"
+insert_into_file "#{Webpacker.config.source_entry_path}/application.js",
+  "import \"@hotwired/turbo-rails\"\n", before: TURBOLINKS_REGEX
+
+say "Remove Turbolinks"
+gsub_file 'Gemfile', /gem 'turbolinks'.*/, ''
+run "bin/bundle", capture: true
+run "bin/yarn remove turbolinks"
+gsub_file "#{Webpacker.config.source_entry_path}/application.js", TURBOLINKS_REGEX, ''
+gsub_file "#{Webpacker.config.source_entry_path}/application.js", /Turbolinks.start.*\n/, ''
+
+say "Enable redis in bundle"
+uncomment_lines "Gemfile", %(gem 'redis')
+
+say "Switch development cable to use redis"
+gsub_file "config/cable.yml", /development:\n\s+adapter: async/, "development:\n  adapter: redis\n  url: redis://localhost:6379/1"
+
+say "Turbo successfully installed ⚡️", :green

data/lib/tasks/turbo_tasks.rake

@@ -1,6 +1,24 @@
+def run_install_template(path) system "#{RbConfig.ruby} ./bin/rails app:template LOCATION=#{File.expand_path("../install/#{path}.rb",  __dir__)}" end
+
 namespace :turbo do
   desc "Install Turbo into the app"
   task :install do
-    system "#{RbConfig.ruby} ./bin/rails app:template LOCATION=#{File.expand_path("../install/turbo.rb", __dir__)}"
+    if defined?(Webpacker::Engine)
+      Rake::Task["turbo:install:webpacker"].invoke
+    else
+      Rake::Task["turbo:install:asset_pipeline"].invoke
+    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"
+    end
+
+    desc "Install Turbo into the app with webpacker"
+    task :webpacker do
+      run_install_template "turbo_with_webpacker"
+    end
   end
 end

data/lib/turbo/engine.rb

@@ -6,6 +6,15 @@ module Turbo
     isolate_namespace Turbo
     config.eager_load_namespaces << Turbo
     config.turbo = ActiveSupport::OrderedOptions.new
+    config.autoload_once_paths = %W(
+      #{root}/app/channels
+      #{root}/app/controllers
+      #{root}/app/controllers/concerns
+      #{root}/app/helpers
+      #{root}/app/models
+      #{root}/app/models/concerns
+      #{root}/app/jobs
+    )
 
     initializer "turbo.assets" do
       if Rails.application.config.respond_to?(:assets)

data/lib/turbo/version.rb

@@ -1,3 +1,3 @@
 module Turbo
-  VERSION = "0.5.1"
+  VERSION = "0.5.2"
 end

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotwired/turbo-rails",
-  "version": "7.0.0-beta.1",
+  "version": "7.0.0-beta.2",
   "description": "The speed of a single-page web application without having to write any JavaScript",
   "module": "app/javascript/turbo/index.js",
   "main": "app/assets/javascripts/turbo.js",
@@ -8,7 +8,9 @@
     "app/javascript/turbo"
   ],
   "scripts": {
-    "build": "rollup -c"
+    "build": "rollup -c",
+    "prerelease": "yarn build && git --no-pager diff && echo && npm pack --dry-run && echo && read -n 1 -p \"Look OK? Press any key to publish and commit v$npm_package_version\" && echo",
+    "release": "npm publish && git commit -am \"$npm_package_name v$npm_package_version\" && git push"
   },
   "dependencies": {
     "@hotwired/turbo": "^7.0.0-beta.1",

data/test/frames/frames_helper_test.rb

@@ -9,6 +9,12 @@ class Turbo::FramesHelperTest < ActionView::TestCase
     assert_dom_equal %(<turbo-frame src="/trays/1" id="tray" target="_top"></turbo-frame>), turbo_frame_tag("tray", src: "/trays/1", target: "_top")
   end
 
+  test "frame with model argument" do
+    record = Message.new(record_id: "1", content: "ignored")
+
+    assert_dom_equal %(<turbo-frame id="message_1"></turbo-frame>), turbo_frame_tag(record)
+  end
+
   test "block style" do
     assert_dom_equal(%(<turbo-frame id="tray"><p>tray!</p></turbo-frame>), turbo_frame_tag("tray") { tag.p("tray!") })
   end

data/turbo-rails.gemspec

@@ -9,6 +9,7 @@ Gem::Specification.new do |s|
   s.homepage = "https://github.com/hotwired/turbo-rails"
   s.license  = "MIT"
 
+  s.required_ruby_version = ">= 2.6.0"
   s.add_dependency "rails", ">= 6.0.0"
 
   s.files      = `git ls-files`.split("\n")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: turbo-rails
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors:
 - Sam Stephenson
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-23 00:00:00.000000000 Z
+date: 2020-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -60,7 +60,8 @@ files:
 - app/models/concerns/turbo/broadcastable.rb
 - app/models/turbo/streams/tag_builder.rb
 - config/routes.rb
-- lib/install/turbo.rb
+- lib/install/turbo_with_asset_pipeline.rb
+- lib/install/turbo_with_webpacker.rb
 - lib/tasks/turbo_tasks.rake
 - lib/turbo-rails.rb
 - lib/turbo/engine.rb
@@ -161,7 +162,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/install/turbo.rb

@@ -1,11 +0,0 @@
-say "Yield head in application layout for cache helper"
-insert_into_file Rails.root.join("app/views/layouts/application.html.erb").to_s, "\n    <%= yield :head %>", before: /\s*<\/head>/
-
-say "Add Turbo include tags in application layout"
-insert_into_file Rails.root.join("app/views/layouts/application.html.erb").to_s, "\n    <%= turbo_include_tags %>", before: /\s*<\/head>/
-
-say "Enable redis in bundle"
-uncomment_lines "Gemfile", %(gem 'redis')
-
-say "Switch development cable to use redis"
-gsub_file "config/cable.yml", /development:\n\s+adapter: async/, "development:\n  adapter: redis\n  url: redis://localhost:6379/1"