render_turbo_stream 1.4.15 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ddf2d67786644e4776a58ead9c9bd705d54aa20e6c2a7f2a50383bcc59eacbc4
-  data.tar.gz: e5dce474494ad9076d96390ef06fca96b7303e821d2326e6d7b4a4b737f96670
+  metadata.gz: 00fd3b24190028352872dce17416ff89c2c31a416ae8f7a349de68193f39d10c
+  data.tar.gz: a1e51c47081672b873a5883fe580b31144aacdd3a33835dfd5e4d19db27e950e
 SHA512:
-  metadata.gz: c86bcd83fb42ebd8286c981e3a1d80d7b37d8ab3ae524f91679a2a3734429692cb3be356199252bbabb9161d056214fd7a63454095259b8cc95ba9bd62eb341e
-  data.tar.gz: 8330c7f4b8d178d68a7be8f8b54d76a6de88676c17178a2e46878934d2c3ecedac4bc968ffa78828e7fa6288324551698f5def18aff073883de0ab3fee42d63a
+  metadata.gz: 837d310de30b519f668e171f6eed9fac087e7fba358b6583e7e38ec5f0b9494ed613b94c1ca346dd25b5da1bc45acc635a11b5bc9b6c9df9275f0c434c448607
+  data.tar.gz: 1aaa0b80f38260fc542d3e6ea584473661664a84853cdfc8ab2f09946e0ffff34bf643a7677475d72be1334720f641143e591c0e41c6b6c47d435dae1b2a35ed

data/README.md

@@ -2,17 +2,21 @@
 
 Defining templates like `(create|update).turbo_stream.haml` annoyed me.
 
-Working consistently with turbo_stream means shooting lots of partials from the backend to the frontend. This always requires the same attributes: the path to the partial, the html-id that turbo_stream points to, and maybe some locals. This gem serialises that: Partials can be controlled directly from the controller. It sets the status, generates a flash message, handles redirection, pushes it all to the front and comes with predefined helpers for enabling request-specs.
+The biggest advantage of this gem is the testing strategy.
+
+Working consistently with turbo_stream means shooting lots of partials from the backend to the frontend. This always requires the same attributes: the path to the partial, the html-id that turbo_stream points to, and maybe some locals. This gem serialises that: Partials can be controlled directly from the controller. It sets the status, generates a flash message, handles redirection, pushes it all to the front. Includes helpers for enabling request tests.
 
 And build it dynamically: Most [turbo_power](https://github.com/marcoroth/turbo_power) commands, such as adding a css class to an html element or pushing a state to the browser history, work directly from the controller. Since turbo allows it, custom javascript functions are also possible.
 
 ATTENTION: This plugin is in a early state.
 
-Hope this gem can help you.
-
 An overview of how we design a rails-7 application with turbo
 is [published on dev.to](https://dev.to/chmich/rails-7-vite-wrapping-up-1pia).
 
+A quick and dirty application with all the features, including tests, built in is [here](https://gitlab.com/sedl/renderturbostream_railsapp).
+
+Hope it can help you.
+
 ## Installation
 
 ```ruby
@@ -71,6 +75,9 @@ To get redirection and many other options working, you need to follow the instal
 
 A comprehensive tutorial on turbo and how to check that it is working properly can be found at [hotrails.dev](https://www.hotrails.dev/turbo-rails).
 
+**Turbo::StreamsChannel**
+
+The Rails team has seamlessly integrated `ActionCable` as `Turbo::StreamsChannel` into `Turbo Rails`. For installation along with this gem, see the [README](https://gitlab.com/sedl/renderturbostream/-/blob/main/README-cable.md).
 ## 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:
@@ -140,11 +147,19 @@ render_turbo_stream(
 
 Under the hood, inside a `*.turbo_stream.erb` template, it does the following: `= turbo_stream.send args.first, *(args[1..-1])`
 
-**WORKAROUND for redirects inside frame**
+**WORKAROUNDS for redirects inside frame**
 
 Suppose you have a CRUD controller that should do all its actions inside a turbo frame. Classic redirect_to, together with a turbo_stream action on the same response, would raise «Render and/or redirect were called multiple times in this action». See [issue](https://gitlab.com/sedl/renderturbostream/-/issues/3).
 
-A workaround is to use the src attribute of the parent frame. `turbo_frame_set_src` comes from turbo_power. The code could look like this:
+There are two workarounds:
+
+```ruby
+config.x.render_turbo_stream.use_cable_for_turbo_stream_save = true
+```
+
+With this config, the `turbo_stream_save` method will send flash messages through `Turbo::StreamsChannel` (if installed as described above) to a channel to the currently logged in user in parallel with the redirect.
+
+Another workaround is to use the src attribute of the parent frame. `turbo_frame_set_src` comes from turbo_power. The code might look like this:
 
 ```ruby
 def update
@@ -162,17 +177,6 @@ def update
 
 ```
 
-**Turbo::StreamsChannel**
-
-Another workaround as described above, but with more advantages, is to use Turbo Streams, which are seamlessly integrated into `turbo rails`. See the [README](https://gitlab.com/sedl/renderturbostream/-/blob/main/README-cable.md).
-If setup well and configured by
-
-```ruby
-config.x.render_turbo_stream.use_cable = true
-```
-
-The `turbo_stream_save` method, in the case of classical redirects (by redirect_to), would send the flashes plus additional partials, declared on arguments by `Turbo::StreamsChannel` in parallel to the redirect.
-
 **Parameters for turbo_stream_save**
 
     save_action,

data/lib/render_turbo_stream/turbo_cable_helpers.rb

@@ -1,50 +1,69 @@
 module RenderTurboStream
   module TurboCableHelpers
 
-    def turbo_cable_to_authenticated
-      if user_signed_in?
+    # def cable_partial_to_all_authenticated_users
+    #   raise "Function cable_partial_to_all_authenticated_users is "
+    #   if user_signed_in?
+    #
+    #   end
+    # end
 
-      end
-    end
+    def cable_partial_to_channel(action, channel, partial, id, locals: nil)
+
+      # add headers for test
 
-    def turbo_cable_to_current_user(target, action, *args, partial: nil, locals: nil)
       if Rails.env.test?
         args = {
-          target: target,
+          target: "##{id}",
           action: action,
-          type: 'turbo-cable-partial',
-          args: args,
+          type: 'cable-partial',
           partial: partial,
           locals: locals
         }
         h = response.headers.to_h
         i = 1
         loop do
-            k = "test-turbo-cable-#{i}"
-            unless h.keys.include?(k)
-                response.headers[k] = args.to_json
-                break
-            end
+          k = "test-turbo-cable-#{i}"
+          unless h.keys.include?(k)
+            response.headers[k] = args.to_json
+            break
+          end
           i += 1
         end
       end
-      if [:append, :prepend, :replace].include?(action.to_sym)
-        Turbo::StreamsChannel.send(
-          "broadcast_#{action}_to",
-          "current_user_#{helpers.current_user.id}",
-          *args,
-          target: target,
-          partial: partial,
-          locals: locals,
-          layout: false
-        )
-      else
-        # Turbo::StreamsChannel.broadcast_action_to(
-        #   "current_user_#{helpers.current_user.id}",
-        #   action:'toggle_css_class',
-        #   'colored-element'
-        # )
+
+      # send
+
+      Turbo::StreamsChannel.send(
+        "broadcast_#{action}_to",
+        channel.to_s,
+        target: id,
+        partial: partial,
+        locals: locals&.symbolize_keys,
+        layout: false
+      )
+    end
+
+    def cable_partial_to_me(partial, id, action: :replace, locals: nil)
+      begin
+        u_id = helpers.current_user&.id
+        a=1
+        unless u_id.present?
+          Rails.logger.debug('  • SKIP RenderTurboStream.cable_partial_to_me because current_user is nil')
+          return
+        end
+      rescue
+        Rails.logger.debug('  • ERROR RenderTurboStream.cable_partial_to_me because current_user is not available')
+        return
       end
+
+      cable_partial_to_channel(
+        action,
+        "current_user_#{helpers.current_user.id}",
+        partial,
+        id,
+        locals: locals
+        )
     end
 
   end

data/lib/render_turbo_stream/turbo_cable_view_helpers.rb

@@ -1,15 +1,31 @@
 module RenderTurboStream
   module TurboCableViewHelpers
 
-    def turbo_cable_from_current_user
+    def cable_from_me
       if current_user
         turbo_stream_from "current_user_#{current_user.id}"
+      else
+        Rails.logger.debug("  • SKIP CABLE_FROM_ME because not authenticated")
       end
     end
 
-    def turbo_cable_from_authenticated_users
-      if user_signed_in?
-        turbo_stream_from "authenticated_users"
+    # def cable_from_all_authenticated_users
+    #   if user_signed_in?
+    #     turbo_stream_from "all_authenticated_users"
+    #   else
+    #     Rails.logger.debug("  • SKIP CABLE_FROM_ALL_AUTHENTICATED_USERS because not authenticated")
+    #   end
+    # end
+
+    def cable_from_all
+        turbo_stream_from "all"
+    end
+
+    def local_model(object)
+      if (object.is_a?(String) && object[0..5] == 'gid://') || object.is_a?(GlobalID)
+        GlobalID::Locator.locate(object)
+      else
+        object
       end
     end
 

data/lib/render_turbo_stream/version.rb

@@ -1,3 +1,3 @@
 module RenderTurboStream
-  VERSION = "1.4.15"
+  VERSION = "2.0.1"
 end

data/lib/render_turbo_stream.rb

@@ -158,14 +158,14 @@ module RenderTurboStream
                           ])
     elsif save_action && redirect_on_success_to.present?
       response.status = 302
-      if Rails.configuration.x.render_turbo_stream.use_cable && helpers.user_signed_in?
+      if Rails.configuration.x.render_turbo_stream.use_cable_for_turbo_stream_save && helpers.user_signed_in?
         streams.each do |s|
           next unless s.is_a?(Hash)
           Rails.logger.debug("  • Send by Cable => «#{s}»")
-          turbo_cable_to_current_user(
+          cable_partial_to_me(
+            s[:partial],
             s[:id],
-            :prepend,
-            partial: s[:partial],
+            action: flash_action,
             locals: s[:locals]
           )
         end
@@ -211,6 +211,7 @@ module RenderTurboStream
     if request.format.to_sym == :turbo_stream
       render template: 'render_turbo_stream', locals: { streams: ary }, layout: false, formats: :turbo_stream
     else
+      Rails.logger.debug("  • Render Turbo Stream RENDERING AS HTML because request.format => #{request.format}")
       render template: 'render_turbo_stream', locals: { streams: ary }, layout: false, formats: :html
     end
   end
@@ -236,7 +237,24 @@ module RenderTurboStream
   class Libs
     def self.all_responses(response)
       e = Nokogiri::HTML(response.body).search('#rendered-partials').first
-      JSON.parse(e.inner_html)
+      if e.present?
+        res = JSON.parse(e.inner_html)
+      else
+        res = []
+      end
+      cables = response.headers.to_h.select { |k| k.match(/^test-turbo-cable-[\d]+$/) }
+      cables.each do |k, v|
+        args = JSON.parse(v)
+        html = ApplicationController.render(partial: args['partial'], locals: args['locals'].symbolize_keys)
+        res.push(
+          args.merge(
+            {
+              'html_response' => html,
+            }
+          )
+        )
+      end
+      res
     end
 
     # if partial is one word, its checked against the last behind the slash, example: 'articles/form' matches 'form'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: render_turbo_stream
 version: !ruby/object:Gem::Version
-  version: 1.4.15
+  version: 2.0.1
 platform: ruby
 authors:
 - christian
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-29 00:00:00.000000000 Z
+date: 2023-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails