render_turbo_stream 4.3.7 → 4.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea7913deb2cafba8983dac02703b99af22fdc6258a065ee9a133764bb7b5eb65
-  data.tar.gz: af7c12ff7132866f47467069cd1acaa7a3cba770ad71e52e723f346c7f1ded48
+  metadata.gz: 95cbd0f9e34c5d905454c7107c682719e7f689e857ab48e94cd3a150ee475947
+  data.tar.gz: 2dda5f5ddcdf497c8b1c937c7bada6fb0d93b24cc7b578e6c8c7e76dafebc106
 SHA512:
-  metadata.gz: 84fb7d4e0a4ed16afe2fffbaa1552e7c805094eec885ba05bb9d5a7339aae0269a027d5194f238bb0e5f4913bcabc9e5c7916067b7e35fbb9f297e5c6e4f8e80
-  data.tar.gz: 5c1889def50f6eca8fa5c733792bb1cd721a399cc7ff3c1a20ff6de7eac988894a42ac9933c16a3ea59fcb68b0fda53a3a39f1549c195c6de5bdd099f1edefed
+  metadata.gz: 2c95e55aed3274b6f38f272262c2d35f23f50d660cb83cb7222fc75b046819b22c219d3022e64879c858bd7bb781fddb651c3d421827f806ae5931a394430754
+  data.tar.gz: 23c2c473430f0c16506957f7abe7e03c119ac918b3895ed9dfa056141583831d1fa7f04523206b2cb47d44ce490c20ca974bf681cbb398511d0a91cbf31a0a28

data/README.md

@@ -105,63 +105,22 @@ The Rails team has integrated `ActionCable` as `Turbo::StreamsChannel` into `Tur
 
 # Usage
 
-`turbo_stream_save` is a special method for streamlining `update` or `create` functions with `turbo_stream`. A controller action for update might look like this:
+**render_turbo_stream**
 
-```ruby
-
-def create
-  turbo_stream_save(
-    @article.update(article_params),
-    if_success_redirect_to: articles_path,
-    partial: 'form'
-  )
-end
-```
-
-Note that if you want to redirect to show path, but the save action fails, `article_path(@article)` would throw an error. For this, the arguments `if_success_turbo_redirect_to` and `if_success_redirect_to` accept procs that are evaluated only on success. So your line would look like this `if_success_redirect_to: ->{article_path(@article)}`.
-
-Assuming we want to build a form that works within a turbo-frame, including flash messages and redirects, we have to build all that inside a `turbo-frame`, and, within that we need a target-id, that must not be a turbo-frame. For that, there is a helper:
-
-```haml
-= turbo_target_tag do
-  = simple_form ... 
-```
-
-This will generate an element like `<turbo-target id="new-article-form">`.
-
-And the form should work!
-
-If the update succeeds, it sends a flash message by channel(!), because stream cannot work alongside redirect, and redirects to articles#index. If it fails, it sends a flash message by stream and replaces the form tag by stream so that the invalid fields are marked red and you can see the errors inside the form.
-
-Technical details? see later in this README.
-
-As mentioned above, the turbo stream actions are handled by the `render_turbo_stream` controller helper:
+The basic idea for this gem is **to have all the decisions/logic within the controller** so that the views are just views. So in the end we have an array of turbo stream actions that are handled by the gem. In normal cases, `*.turbo_stream.*` templates are not needed anymore.
 
 ```ruby
 render_turbo_stream(
   [
     {
-      id: 'customer-form',
-      partial: 'customers/customer_form'
+      partial: 'customers/customer_form' #=> The target id can be defined within the form and retrieved during rendering. The default :action is :replace
     },
     {
       id: 'flash-wrapper',
       partial: 'layouts/flashes',
-      action: :prepend
-    }
-  ]
-)
-```
-
-If the update succeeds, it will do a `redirect_to` action from turbo_power
-
-**More options**
-
-`render_turbo_stream` interprets a hash as a partial to be sent by `turbo_stream` and an array as a command to be sent. This allows you to perform most actions from, e.g., [turbo_power](https://github.com/marcoroth/turbo_power). An example of adding a css class to an html element and updating the browser history would look like this:
-
-```ruby
-render_turbo_stream(
-  [
+      action: :prepend,
+      locals: { success: true }
+    },
     [
       :push_state,
       '/articles/my-special-path'
@@ -175,7 +134,35 @@ render_turbo_stream(
 )
 ```
 
-Under the hood, inside a `*.turbo_stream.erb` template, it does the following: `= turbo_stream.send args.first, *(args[1..-1])`
+this enables:
+
+- turbo-stream or custom javascript actions from turbo and all actions from [turbo_power](https://github.com/marcoroth/turbo_power)
+- Testing helpers (request-testing), as mentioned later
+- Helpers for handling the target id, as mentioned later
+
+If element is an array instead of a hash, it does this under the hood: `= turbo_stream.send args.first, *(args[1..-1])`. If element is a hash, it is interpreted as a partial or template to render.
+
+**turbo_stream_save**
+
+`turbo_stream_save` is a special method for `update` or `create` functions with `turbo_stream`. A controller action for update might look like this:
+
+```ruby
+
+def create
+  turbo_stream_save(
+    @article.update(article_params),
+    if_success_redirect_to: articles_path,
+    partial: 'form'
+  )
+end
+```
+- uses `render_turbo_stream` or [render_to_me](https://gitlab.com/sedl/renderturbostream/-/blob/main/README-channels.md) (if allowed by config) under the hood
+- Generates translated flash messages
+- Handles redirects: Either classic redirect, which would never break out of a turbo-frame or the redirect from [turbo_power](https://github.com/marcoroth/turbo_power) which does a full-page-reload.
+
+
+Note that if you want to redirect to show path, but the save action fails, `article_path(@article)` would throw an error. For this, the arguments `if_success_turbo_redirect_to` and `if_success_redirect_to` accept procs that are evaluated only on success. So your line would look like this `if_success_redirect_to: ->{article_path(@article)}`.
+
 
 **Config: allow_channel_to_me_for_turbo_stream_save**
 
@@ -185,6 +172,19 @@ If this config is set to true, Turbo::StreamsChannel is installed and a current
 
 If an `if_success_redirect_to` argument is provided and the save action was successful, `turbo_stream_save` would send the partials by channel.
 
+
+**turbo_target_tag**
+
+Assuming we want to build a form that works within a turbo-frame, including flash messages and redirects, we have to build all that inside a `turbo-frame`, and, within that we need a target-id, that must not be a turbo-frame. For that, there is a helper:
+
+```haml
+= turbo_target_tag do
+  = simple_form ... 
+```
+
+- Generates an element like `<turbo-target id="new-article-form">`
+- If no target-id is defined on `turbo_stream_save` or `render_turbo_stream` the renderer will grab inside the rendered content for a turbo-frame or turbo-target and get the target-id from there, so you can avoid having to define the same target-id on multiple places.
+
 **Target-ID**
 
 The target ID for turbo has to be unique for sure, and it has to be nice, because, at least during testing the developer has to deal with it. Since the default ID builder dom_id is too simple for this, there are some helpers. How it works is best shown by the `request-test helper target_id`:
@@ -204,6 +204,8 @@ target_id
 target_id(Customer.first) #=> 'customer-1-my-form'
 target_id( [Customer.first, Article.last, 'hello'] ) #=> 'customer-1-article-7-hello-my-form'
 target_id('hi-joe') #=> 'hi-joe'
+
+target_id_css('hi-joe') #=> '#hi-joe'
 ```
 
 Why include the filename in a html-id? Because for turbo its likely to have multiple cases for the same object on the same page, for example: _form, _show, _password. These can all be the same customer.
@@ -287,18 +289,6 @@ config.x.render_turbo_stream.first_argument_is_html_id = %[replace append prepen
 
 This setting is relevant for testing helpers.
 
-# Personal note
-
-The World Wide Web, founded around 1990 by [Tim Berners-Lee](https://en.wikipedia.org/wiki/Tim_Berners-Lee), was an html response from the server.
-
-Frameworks like Angular, Ember, React, Vue brought a much better user experience, so called "single page applications". But they changed a paradigma: Now Javascript was the processor of HTML, which is far from the [Progressive Enhancement](https://developer.mozilla.org/en-US/docs/Glossary/Progressive_Enhancement).
-
-2021 DHH annouced a great milestone in web development with [Rails 7, "Fulfilling a Vision"](https://rubyonrails.org/2021/12/15/Rails-7-fulfilling-a-vision). The Rails core now has done a big step, for bringing a user experience like a single page app, but by reducing javascript. This is a modern back to the roots. Thank you Rails Team!
-
-But as of 2023, I searched for months and found nothing to solve all these details to make this Vision really work for rails. Now i am really happy and i cannot imagine working without Turbo!
-
-Let us build on this vision and make rails what it has always been: A framework ahead of its time!
-
 # Contributing
 
 Contributors welcome.

data/lib/render_turbo_stream/test/request/helpers.rb

@@ -89,6 +89,10 @@ module RenderTurboStream
           libs.target_id(relative_view_path, object)
         end
 
+        def target_id_css(relative_view_path, object)
+          "##{target_id(relative_view_path, object)}"
+        end
+
       end
     end
   end

data/lib/render_turbo_stream/version.rb

@@ -1,3 +1,3 @@
 module RenderTurboStream
-  VERSION = "4.3.7"
+  VERSION = "4.3.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: render_turbo_stream
 version: !ruby/object:Gem::Version
-  version: 4.3.7
+  version: 4.3.8
 platform: ruby
 authors:
 - christian
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-19 00:00:00.000000000 Z
+date: 2023-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails