turbo_ready 0.0.3 → 0.0.6

data/README.md

@@ -1,5 +1,8 @@
 <p align="center">
-  <img height="200" src="https://ik.imagekit.io/hopsoft/turbo-ready-logo_jYFJI1jgT.png?ik-sdk-version=javascript-1.4.3&updatedAt=1661471047153" />
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://ik.imagekit.io/hopsoft/turbo-ready-logo-light_df4jcvbDL.webp?ik-sdk-version=javascript-1.4.3&updatedAt=1661615678275">
+    <img height="200" src="https://ik.imagekit.io/hopsoft/turbo-ready-logo-dark_VN4hA2ctc.webp?ik-sdk-version=javascript-1.4.3&updatedAt=1661615678278" />
+  </picture>
   <h3 align="center">
     Turbo Stream's Swiss Army Knife
   </h3>
@@ -7,44 +10,76 @@
     Welcome to TurboReady 👋
   </h1>
   <p align="center">
-    <a href="http://blog.codinghorror.com/the-best-code-is-no-code-at-all/" target="_blank">
-      <img alt="Lines of Code" src="https://img.shields.io/badge/lines_of_code-275-brightgreen.svg?style=flat" />
+    <a href="http://blog.codinghorror.com/the-best-code-is-no-code-at-all/">
+      <img alt="Lines of Code" src="https://img.shields.io/badge/loc-143-47d299.svg" />
     </a>
-    <a href="https://github.com/testdouble/standard" target="_blank">
-      <img alt="Ruby Code Style" src="https://img.shields.io/badge/Ruby_Code_Style-standard-brightgreen.svg" />
+    <a href="https://codeclimate.com/github/hopsoft/turbo_ready/maintainability">
+      <img src="https://api.codeclimate.com/v1/badges/a69b6f73abc3ccd49261/maintainability" />
     </a>
-    <a href="https://github.com/sheerun/prettier-standard" target="_blank">
-      <img alt="JavaScript Code Style" src="https://img.shields.io/badge/JavaScript_Code_Style-prettier_standard-ff69b4.svg" />
+    <a href="https://rubygems.org/gems/turbo_ready">
+      <img alt="GEM" src="https://img.shields.io/gem/v/turbo_ready?color=168AFE&include_prereleases&logo=ruby&logoColor=FE1616">
+    </a>
+    <a href="https://rubygems.org/gems/turbo_ready">
+      <img alt="Gem" src="https://img.shields.io/gem/dt/turbo_ready?color=168AFE&logo=ruby&logoColor=FE1616">
+    </a>
+    <a href="https://github.com/testdouble/standard">
+      <img alt="Ruby Style" src="https://img.shields.io/badge/style-standard-168AFE?logo=ruby&logoColor=FE1616" />
+    </a>
+    <a href="https://www.npmjs.com/package/turbo_ready">
+      <img alt="NPM" src="https://img.shields.io/npm/v/turbo_ready?color=168AFE&logo=npm">
+    </a>
+    <a href="https://www.npmjs.com/package/turbo_ready">
+      <img alt="npm" src="https://img.shields.io/npm/dm/turbo_ready?color=168AFE&logo=npm">
+    </a>
+    <a href="https://bundlephobia.com/package/turbo_ready@">
+      <img alt="npm bundle size" src="https://img.shields.io/bundlephobia/minzip/turbo_ready?label=bundle%20size&logo=npm&color=47d299">
+    </a>
+    <a href="https://github.com/sheerun/prettier-standard">
+      <img alt="JavaScript Style" src="https://img.shields.io/badge/style-prettier--standard-168AFE?logo=javascript&logoColor=f4e137" />
+    </a>
+    <a href="https://github.com/hopsoft/turbo_ready/actions/workflows/tests.yml">
+      <img alt="Tests" src="https://github.com/hopsoft/turbo_ready/actions/workflows/tests.yml/badge.svg" />
+    </a>
+    <a href="https://twitter.com/hopsoft">
+      <img alt="Twitter Follow" src="https://img.shields.io/twitter/follow/hopsoft?logo=twitter&style=social">
     </a>
   </p>
 </p>
 
-TurboReady extends [Turbo Streams](https://turbo.hotwired.dev/reference/streams) to give you full control of the
-browser's [Document Object Model (DOM).](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model)
-
-**Thats right!**
-You can `invoke` any DOM method on any DOM object *(including 3rd party libs)* using Turbo Streams.
+**TurboReady extends [Turbo Streams](https://turbo.hotwired.dev/reference/streams) to give you full control of the
+browser's [Document Object Model (DOM).](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model)**
 
 ```ruby
-turbo_stream.invoke "console.log", "Hello World!"
+turbo_stream.invoke "console.log", args: ["Hello World!"]
 ```
 
+**Thats right!**
+You can `invoke` any DOM method on the client with Turbo Streams.
+
 <!-- Tocer[start]: Auto-generated, don't remove. -->
 
 ## Table of Contents
 
   - [Why TurboReady?](#why-turboready)
-  - [Discord Community](#discord-community)
   - [Sponsors](#sponsors)
   - [Dependencies](#dependencies)
   - [Installation](#installation)
   - [Setup](#setup)
   - [Usage](#usage)
-  - [Endless Possibilities](#endless-possibilities)
-  - [Advanced Usage](#advanced-usage)
+    - [Method Chaining](#method-chaining)
+    - [Dispatching Events](#dispatching-events)
+    - [Syntax Styles](#syntax-styles)
     - [Extending Behavior](#extending-behavior)
-  - [Public API](#public-api)
+    - [Implementation Details](#implementation-details)
+    - [Broadcasting](#broadcasting)
+      - [Background Job Queues](#background-job-queues)
+  - [FAQ](#faq)
   - [A Word of Caution](#a-word-of-caution)
+  - [Community](#community)
+    - [Discord](#discord)
+    - [Discussions](#discussions)
+    - [Twitter](#twitter)
+  - [TODOs](#todos)
   - [Releasing](#releasing)
   - [License](#license)
 
@@ -52,21 +87,17 @@ turbo_stream.invoke "console.log", "Hello World!"
 
 ## Why TurboReady?
 
-Turbo Streams [intentionally restricts](https://turbo.hotwired.dev/handbook/streams#but-what-about-running-javascript)
+Turbo Streams [intentionally restricts](https://turbo.hotwired.dev/handbook/streams#but-what-about-running-javascript%3F)
 official actions to CRUD related activity.
-The [official actions](https://turbo.hotwired.dev/reference/streams#the-seven-actions) work well for a
-considerable number of use cases and you should push Streams as far as possible before reaching for TurboReady.
-
-If you discover that CRUD isn't enough, TurboReady covers pretty much everything else.
-
-## Community
+These [official actions](https://turbo.hotwired.dev/reference/streams#the-seven-actions) work well for a considerable number of use cases.
+*Try pushing Turbo Streams as far as possible before reaching for TurboReady.*
 
-Please join nearly 2000 of us on [Discord](https://discord.gg/stimulus-reflex) for support getting started,
-as well as active discussions around Rails, Hotwire, Stimulus, Turbo (Drive, Frames, Streams), TurboReady, CableReady, StimulusReflex, ViewComponent, Phlex, and more.
+If you find that CRUD isn't enough, TurboReady is there to handle pretty much everything else.
 
-![](https://img.shields.io/discord/629472241427415060)
+> ⚠️ TurboReady is intended for Rails apps that use Hotwire but not [CableReady](https://github.com/stimulusreflex/cable_ready).
+This is because CableReady already provides a rich set of powerful [DOM operations](https://cableready.stimulusreflex.com/reference/operations).
 
-Stop by #newcomers and introduce yourselves!
+> 📘 **NOTE:** Efforts are underway to bring [CableReady's DOM operations to Turbo Streams](https://github.com/marcoroth/turbo_power).
 
 ## Sponsors
 
@@ -87,79 +118,84 @@ Stop by #newcomers and introduce yourselves!
 
 ## Installation
 
+Be sure to install the same version for each libary.
+
 ```sh
 bundle add "turbo_ready --version VERSION"
 yarn add "turbo_ready@VERSION --exact"
 ```
 
-**IMPORTANT:** Be sure to use the same version for each libary.
-
 ## Setup
 
-1. Create a Rails intializer and patch Turbo.
+Import and intialize TurboReady in your application.
 
-    ```ruby
-    # config/initializers/turbo_ready.rb
-    TurboReady.patch! # Adds TurboReady stream actions to Turbo
-    ```
-2. Import and intialize TurboReady in your JavaScript application.
+```diff
+# Gemfile
++gem "turbo_ready", "~> 0.0.6"
+```
 
-    ```js
-    // app/javascript/application.js
-    import '@hotwired/turbo-rails'
-    import TurboReady from 'turbo_ready'
+```diff
+# package.json
+"dependencies": {
++  "@hotwired/turbo-rails": ">=7.2.0-beta.2",
++  "turbo_ready": "^0.0.6"
+```
 
-    TurboReady.initialize(Turbo.StreamActions) // Adds TurboReady stream actions to Turbo
-    ```
+```diff
+# app/javascript/application.js
+import '@hotwired/turbo-rails'
++import TurboReady from 'turbo_ready'
+
++TurboReady.initialize(Turbo.StreamActions) // Adds TurboReady stream actions to Turbo
+```
 
 ## Usage
 
-Manipulate the DOM from anywhere you use [official Turbo Streams](https://turbo.hotwired.dev/handbook/streams#integration-with-server-side-frameworks).
-Namely, [**M**odels](https://github.com/hotwired/turbo-rails/blob/main/app/models/concerns/turbo/broadcastable.rb),
-[**V**iews](https://github.com/hotwired/turbo-rails/blob/main/app/models/concerns/turbo/broadcastable.rb),
-and [**C**ontrollers](https://github.com/hotwired/turbo-rails/blob/main/app/models/concerns/turbo/broadcastable.rb).
+Manipulate the DOM from anywhere you use official [Turbo Streams](https://turbo.hotwired.dev/handbook/streams#integration-with-server-side-frameworks).
+The possibilities are endless.
+[Learn more about the DOM at MDN.](https://developer.mozilla.org/en-US/docs/Web/API.)
 
-You can **chain invocations.** ❤️
+```ruby
+turbo_stream.invoke "console.log", args: ["Hello World!"]
+```
+
+### Method Chaining
+
+You can use [dot notation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Property_accessors#dot_notation)
+or [selectors](https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelectorAll) and even combine them!
 
 ```ruby
 turbo_stream
-  .invoke("document.body.insertAdjacentHTML", "afterbegin", "<h1>Hello World!</h1>") # dot notation
-  .invoke("setAttribute", "data-turbo-ready", true, selector: ".button") # selector
-  .invoke("classList.add", "turbo-ready", selector: "a") # dot notation + selector
-  .flush # flush must be called when chaining invocations
+  .invoke("document.body.insertAdjacentHTML", args: ["afterbegin", "<h1>Hello World!</h1>"]) # dot notation
+  .invoke("setAttribute", args: ["data-turbo-ready", true], selector: ".button") # selector
+  .invoke("classList.add", args: ["turbo-ready"], selector: "a") # dot notation + selector
+  .flush # call flush when chaining invocations
 ```
 
-You can use [dot notation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Property_accessors#dot_notation)
-or [selectors](https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelectorAll)... and can even combine them!** 🤯
+### Dispatching Events
 
-Can I dispatch events? **You bet!** ⚡️
+It's possible to fire events on `window`, `document`, and element(s).
 
 ```ruby
 turbo_stream
-  .invoke("dispatchEvent", "turbo-ready:demo") // fires on window
-  .invoke("dispatchEvent", "turbo-ready:demo", selector: "#my-element") // fires on matching element(s)
-  .invoke("dispatchEvent", {bubbles: true, detail: {...}}) // set event options
+  .invoke("dispatchEvent", args: ["turbo-ready:demo"]) # fires on window
+  .invoke("document.dispatchEvent", args: ["turbo-ready:demo"]) # fires on document
+  .invoke("dispatchEvent", args: ["turbo-ready:demo"], selector: "#my-element") # fires on matching element(s)
+  .invoke("dispatchEvent", args: ["turbo-ready:demo", {bubbles: true, detail: {...}}]) # set event options
   .flush
 ```
 
-## Endless Possibilities
-
-**What else can I do?**
-MDN has your back... [learn about the DOM and web APIs here.](https://developer.mozilla.org/en-US/docs/Web/API.)
+### Syntax Styles
 
-## Advanced Usage
-
-You can use symbols and [snake case](https://en.wikipedia.org/wiki/Snake_case) when invoking DOM functionality.
-It'll implicitly convert to [camel case](https://en.wikipedia.org/wiki/Camel_case). 💎
+You can use [`snake_case`](https://en.wikipedia.org/wiki/Snake_case) when invoking DOM functionality.
+It will implicitly convert to [`camelCase`](https://en.wikipedia.org/wiki/Camel_case).
 
 ```ruby
-turbo_stream
-  .invoke(:animate, [{opacity: 0}, {opacity: 1}], 2000)
-  .invoke(:dispatch_event, {detail: {converts_to_camel_case: true}})
-  .flush
+turbo_stream.invoke :dispatch_event,
+  args: ["turbo-ready:demo", {detail: {converts_to_camel_case: true}}]
 ```
 
-Need to opt out of camelize? No problem... just disable it.
+Need to opt-out? No problem... just disable it.
 
 ```ruby
 turbo_stream.invoke :contrived_demo, camelize: false
@@ -167,10 +203,10 @@ turbo_stream.invoke :contrived_demo, camelize: false
 
 ### Extending Behavior
 
-Want to extend things with custom functionality? **Let's do it.** 🔌
+If you add new capabilities to the browser, you can control them from the server.
 
 ```js
-// JavaScript
+// JavaScript on the client
 import morphdom from 'morphdom'
 
 window.MyNamespace = {
@@ -181,51 +217,180 @@ window.MyNamespace = {
 ```
 
 ```ruby
-# Ruby
-turbo_stream
-  .invoke "MyNamespace.morph", "#demo", "<div id='demo'><p>You've changed...</p></div>", {childrenOnly: true}
+# Ruby on the server
+turbo_stream.invoke "MyNamespace.morph",
+  args: [
+    "#demo",
+    "<div id='demo'><p>You've changed...</p></div>",
+    {children_only: true}
+  ]
 ```
 
-## Public API
+### Implementation Details
 
-There's only one method to consider, `invoke` defined in the
-[tag builder](https://github.com/hopsoft/turbo_ready/blob/main/lib/turbo_ready/tag_builder.rb).
+There's basically one method to learn... `invoke`
 
 ```ruby
 # Ruby
 turbo_stream
-  .invoke(method, *args, selector: nil, camelize: true, id: nil)
-#         |        |     |              |               |
-#         |        |     |              |               |- Identifies this invocation (optional)
-#         |        |     |              |
-#         |        |     |              |- Should we camelize the JavaScript stuff? (optional)
-#         |        |     |                 (allows us to write snake_case Ruby)
-#         |        |     |
-#         |        |     |- An CSS selector for the element(s) to target (optional)
-#         |        |
-#         |        |- The arguments to pass to the JavaScript method being invoked (optional)
+  .invoke(method, args: [], selector: nil, camelize: true, id: nil)
+#         |       |         |              |               |
+#         |       |         |              |               |- Identifies this invocation (optional)
+#         |       |         |              |
+#         |       |         |              |- Should we camelize the JavaScript stuff? (optional)
+#         |       |         |                 (allows us to write snake_case in Ruby)
+#         |       |         |
+#         |       |         |- A CSS selector for the element(s) to target (optional)
+#         |       |
+#         |       |- The arguments to pass to the JavaScript method (optional)
 #         |
 #         |- The JavaScript method to invoke (can use dot notation)
 ```
 
-**NOTE:** The JavaScript method will be invoked on all matching elements when a `selector` is passed.
+> 📘 **NOTE:** The method will be invoked on all matching elements if a `selector` is present.
+
+The following Ruby code,
+
+```ruby
+turbo_stream.invoke "console.log", args: ["Hello World!"], id: "1"
+```
+
+emits this HTML markup.
+
+```html
+<turbo-stream action="invoke" target="DOM">
+  <template>{"id":"1","receiver":"console","method":"log","args":["Hello World!"]}</template>
+</turbo-stream>
+```
+
+When this element enters the DOM,
+Turbo Streams automatically executes `invoke` on the client with the template's JSON payload and then removes the element from the DOM.
+
+### Broadcasting
+
+You can also broadcast DOM invocations to subscribed users.
+
+1. First, setup the stream subscription.
+
+    ```erb
+    <!-- app/views/posts/show.html.erb -->
+    <%= turbo_stream_from @post %>
+    <!--                  |
+                          |- *streamables - model(s), string(s), etc...
+    -->
+    ```
+
+2. Then, broadcast to the subscription.
+
+    ```ruby
+    # app/models/post.rb
+    class Post < ApplicationRecord
+      after_save do
+        # emit a message in the browser conosle for anyone subscribed to this post
+        broadcast_invoke "console.log", args: ["Post was saved! #{to_gid.to_s}"]
+
+        # broadcast with a background job
+        broadcast_invoke_later "console.log", args: ["Post was saved! #{to_gid.to_s}"]
+      end
+    end
+    ```
+
+    ```ruby
+    # app/controllers/posts_controller.rb
+    class PostsController < ApplicationController
+      def create
+        @post = Post.find params[:id]
+
+        if @post.update post_params
+          # emit a message in the browser conosle for anyone subscribed to this post
+          @post.broadcast_invoke "console.log", args: ["Post was saved! #{to_gid.to_s}"]
+
+          # broadcast with a background job
+          @post.broadcast_invoke_later "console.log", args: ["Post was saved! #{to_gid.to_s}"]
+
+          # you can also broadcast directly from the channel
+          Turbo::StreamsChannel.broadcast_invoke_to @post, "console.log",
+            args: ["Post was saved! #{@post.to_gid.to_s}"]
+
+          # broadcast with a background job
+          Turbo::StreamsChannel.broadcast_invoke_later_to @post, "console.log",
+            args: ["Post was saved! #{@post.to_gid.to_s}"]
+        end
+      end
+    end
+    ```
+
+> 📘 **NOTE:** [Method Chaining](#method-chaining) is not currently supported when broadcasting.
+
+#### Background Job Queues
+
+You may want to change the queue name for Turbo Stream background jobs in order to isolate, prioritize, and scale the workers independently.
+
+```ruby
+# config/initializers/turbo_streams.rb
+Turbo::Streams::BroadcastJob.queue_name = :turbo_streams
+TurboReady::BroadcastInvokeJob.queue_name = :turbo_streams
+```
+
+## FAQ
+
+- Isn't this just RJS?
+
+  > No. But, perhaps it could be considered RJS's "modern" spirtual successor. 🤷‍♂️
+  > Though it embraces JavaScript instead of trying to avoid it.
+
+- Does it use `eval`?
+
+  > **No.** TurboReady can only invoke existing functions on the client.
+  > It's not a carte blanche invitation to emit free-form JavaScript to be evaluated on the client.
 
 ## A Word of Caution
 
-Manually orchestrating DOM activity gets tedious fast.
-**⚠️ Don't abuse this superpower!**
+**Don't abuse this superpower!**
 
 > With great power comes great responsibility. *-Uncle Ben*
 
+Manually orchestrating DOM activity is tedious.
+*Don't overdo it... or you may find that you've created spaghetti reminiscent of the jQuery days.*
+
 This library is an extremely sharp tool. 🔪
-Consider it a low-level building block that can be used to craft additional libraries with
-great [DX](https://en.wikipedia.org/wiki/User_experience#Developer_experience)
+Consider it a low-level building block that can be used to craft additional libraries
 like [CableReady](https://github.com/stimulusreflex/cable_ready)
 and [StimulusReflex](https://github.com/stimulusreflex/stimulus_reflex).
 
-Restrict your direct application usage to DOM manipulation that falls outside the purview of
-[Turbo's official actions](https://turbo.hotwired.dev/reference/streams#the-seven-actions)...
-*and for Pete's sake, don't overdo it and find yourself maintaining spaghetti code reminiscent of the jQuery days.*
+## Community
+
+### Discord
+
+Please join nearly 2000 of us on [Discord](https://discord.gg/stimulus-reflex) for support getting started,
+as well as active discussions around Rails, Hotwire, Stimulus, Turbo (Drive, Frames, Streams), TurboReady, CableReady, StimulusReflex, ViewComponent, Phlex, and more.
+
+<a href="https://discord.gg/stimulus-reflex" target="_blank">
+  <img alt="Discord" src="https://img.shields.io/discord/629472241427415060?color=168AFE&logo=discord&logoColor=FFF">
+</a>
+
+Be sure to introduce yourselves in the #newcomers channel!
+
+### Discussions
+
+Feel free to add to the conversation here on [GitHub Discussions](https://github.com/hopsoft/turbo_ready/discussions).
+
+<a href="https://github.com/hopsoft/turbo_ready/discussions" target="_blank">
+  <img alt="GitHub Discussions" src="https://img.shields.io/github/discussions/hopsoft/turbo_ready?color=168AFE&logo=github">
+</a>
+
+### Twitter
+
+Connect with the core team on Twitter.
+
+<a href="https://twitter.com/hopsoft" target="_blank">
+  <img alt="Twitter Follow" src="https://img.shields.io/twitter/follow/hopsoft?logo=twitter&style=social">
+</a>
+
+## TODOs
+
+- [ ] Add system tests [(review turbo-rails for guidance)](https://github.com/hotwired/turbo-rails/blob/main/test/system/broadcasts_test.rb)
+- [ ] Look into adding method chaining for broadcasts
 
 ## Releasing