render_turbo_stream 1.3.3 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b32041ebda04bf085c6199ba1e29e5274f9fa86c2a210c7ee6a32e9937721037
-  data.tar.gz: 32b05f420b1ce6c6733615f2be5059a265ee58bf2c55269363aa14e0d0f41c2e
+  metadata.gz: 395968d08aa5420fbd50bb63bccb641098503d33002a36a1a9f753b52caaae2b
+  data.tar.gz: 537a3ed1c128c26df63083c545c7ba53c02167c30a38a69adf08261bbb27e069
 SHA512:
-  metadata.gz: bfdd0158be7131cdd05e7527b7005b40d90621d9a95919955bdeb58dd0e75cb41d5e7799ad43626f05d690a814600f267b9476e25e3a5b7400be6a8d36a481dd
-  data.tar.gz: f04d228c519cd617ff53e7292144673eaaf610e879f87fc4a95a6902e487bffab7a84bd0bbff3068a94f138b2c32a17ea91872e45f117c133f1f846029cf3ede
+  metadata.gz: a793feeaa175a29b27bd2811f6248de5e5e913224f455547b6fdb5cd1707e36f76d3e2b23824cd3c4a2c7197a5c25e50f99800c355ed0b55c76bae78f127586a
+  data.tar.gz: 0d0294aed7dc3c57e580d34a939145c3ccd423a434da2bfad40d8daf7a769b3e4efece554d814a4f533f0eb21fb1efcdba4d223a6fc701106434635bd2e58a32

data/README.md

@@ -6,6 +6,8 @@ Working consistently with turbo_stream means shooting lots of partials from the
 
 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.
+
 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).
 
@@ -34,11 +36,6 @@ RSpec.configure do |config|
 end
 ```
 
-**Redirection and more**
-
-For redirection to work, you must follow the installation steps
-from [turbo_power](https://github.com/marcoroth/turbo_power).
-
 **Flash**
 
 Required Configurations for Flash Partial
@@ -51,16 +48,37 @@ config.x.render_turbo_stream.flash_action = 'prepend'
 
 The corresponding partials for flashes could look [like this](https://gitlab.com/sedl/renderturbostream/-/wikis/flashes)
 
+**Translations**
+
+```
+activerecord.success.successfully_created
+activerecord.success.successfully_updated
+activerecord.errors.messages.could_not_create
+activerecord.errors.messages.could_not_update
+```
+
+example value: `"%<model_name>s successfully created"`
+
+Model name translations, see: Rails Docs.
+
+**Turbo power**
+
+To get redirection and many other options working, you need to follow the installation steps from [turbo_power](https://github.com/marcoroth/turbo_power).
+
+**Turbo itself**
+
+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).
+
 ## 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:
+`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:
 
 ```ruby
 
 def update
   turbo_stream_save(
     @customer.update(customer_params),
-    redirect_on_success_to: edit_customer_path(@customer)
+    redirect_on_success_to: edit_customer_path(@customer),
   )
 end
 ```
@@ -72,7 +90,7 @@ render_turbo_stream(
   [
     {
       id: 'form',
-      partial: 'form'
+      partial: 'customers/form'
     },
     {
       id: 'flash-wrapper',
@@ -96,7 +114,7 @@ stream_partial(
 
 **locals**: The hash for locals goes through a `symbolize_keys`, so you need to use locals in used partials like this: `locals[:message]`.
 
-## More options
+**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:
 
@@ -111,12 +129,45 @@ render_turbo_stream(
       :add_css_class,
       '#colored-element',
       'red'
+    ],
+    [
+      
     ]
   ]
 )
 ```
 
-which is done under the hood, for the array: `= turbo_stream.send args.first, *(args[1..-1])`
+Under the hood, inside a `*.turbo_stream.erb` template, it does the following: `= turbo_stream.send args.first, *(args[1..-1])`
+
+**Parameters for turbo_stream_save**
+
+    save_action,
+    redirect_on_success_to: nil,
+    object: nil, # object used in save_action, example: @customer
+    id: 'form', # if nil: no partial is rendered
+    partial: nil, # example: 'customers/form' default: "#{controller_path}/#{id}"
+    action: 'replace', # options: append, prepend
+    locals: {}, # locals used by the partial
+    streams_on_success: [
+      {
+        id: nil,
+        partial: 'form',
+        locals: {},
+        action: 'replace'
+      }
+    ], # additional partials that should be rendered if save_action succeeded
+    streams_on_error: [
+      {
+        id: nil,
+        partial: 'form',
+        locals: {},
+        action: 'replace'
+      }
+    ], # additional partials that should be rendered if save_action failed
+    add_flash_alerts: [], #=> array of strings
+    add_flash_notices: [], #=> array of strings
+    flashes_on_success: [], #=> array of strings
+    flashes_on_error: [] #=> array of strings
 
 
 ## Testing Scenarios
@@ -126,7 +177,7 @@ For system testing there is Capybara. Its the only way to check if frontend and
 If the request format is not `turbo_stream`, which is the case on request specs, the method responds in a special html
 that contains the medadata that is interesting for our tests and is parsed by included test helpers. 
 
-There is a helper for writing the test: In the debugger, within the test, check the output of `partials_log`.
+There is a helper for writing the test: In the debugger, within the test, check the output of `streams_log`.
 
 Test scenarios are:
 
@@ -141,7 +192,7 @@ For rspec there is a special helper, for a successful save action:
 ```ruby
 it 'update failed' do
   patch article_path(article, params: valid_params)
-  expect_successful_saved('form', 'flash-box')
+  expect_successful_saved('customer-form', 'flash-box')
   # expects response.status 200
   # Make sure that the responses point to exactly these 2 IDs ('form' and 'flash-box').
   # Make sure that each ID is responded to exactly once.
@@ -160,13 +211,13 @@ end
 
 For checking a little more inside the partial responses, but with a simple syntax that checks for a one-time response from a specific partial and may be sufficient for most cases:
 ```ruby
-expect(partials_count).to eq(2)
-# Check the total number of responding partials, in most cases it will be one form and one flash.
+expect(stream_targets_count).to eq(2)
+# Check the total number of targeted html-ids, in most cases it will be one form and one flash.
  
-expect(partial_response('form')).to eq(true)
-# Make sure that the form part (controller_path is not checked) has responded exactly once.
+expect(stream_response('customer-form')).to eq(true)
+# Make sure that the id «customer-form» is targeted exactly once.
 
-expect(partial_response('articles/form', id: 'form', css: '.field_with_errors', include_string: 'Title')).to eq(true)
+expect(stream_response('customer-form', css: '.field_with_errors', include_string: 'Title')).to eq(true)
 # Check the content inside at least one in any of the elements that match the given css and check the id that turbo has pointed to..
 ```
 
@@ -175,21 +226,21 @@ expect(partial_response('articles/form', id: 'form', css: '.field_with_errors',
 Consider a controller action that should respond in 2 flashes:
 
 ```ruby
-expect(partials_count).to eq(1)
+expect(stream_targets_count).to eq(1)
 
 expect(
-  partial_response_count('flash', total: 2) do |p|
+  stream_target_response_count('flash-box', total: 2) do |p|
     p.css('.callout.success').inner_html.include?('All perfect')
   end
 ).to eq(1)
 
 expect(
-  partial_response_count('layouts/flash', id: 'flash-box', total: 2) do |p|
+  stream_target_response_count('flash-box', total: 2) do |p|
     p.css('.callout.alert').inner_html.include?('Something went wrong')
   end
 ).to eq(1)
 ```
-`partial_response_count` always returns the number of matched responses.
+`stream_target_response_count` always returns the number of matched responses.
 
 Possible matchers can be found at [Nokogiri](https://nokogiri.org/tutorials/searching_a_xml_html_document.html). That should be enough for this level. For more detailed testing of partials, there are view tests. And many of the partials are regularly accessed in two ways, for example a `form': it is pushed by turbo_stream as well as by calling edit_customer_path.
 
@@ -198,54 +249,6 @@ P.S.:
 Testing the plugin itself: There is a [quick-and-dirty app](https://gitlab.com/sedl/renderturbostream_railsapp) which
 includes the plugin and has tests done by rspec/request and capybara.
 
-## Parameters for turbo_stream_save
-
-    save_action,
-    redirect_on_success_to: nil,
-    object: nil, # object used in save_action, example: @customer
-    id: 'form', # if nil: no partial is rendered
-    partial: nil, # example: 'customers/form' default: "#{controller_path}/#{id}"
-    action: 'replace', # options: append, prepend
-    locals: {}, # locals used by the partial
-    streams_on_success: [
-      {
-        id: nil,
-        partial: 'form',
-        locals: {},
-        action: 'replace'
-      }
-    ], # additional partials that should be rendered if save_action succeeded
-    streams_on_error: [
-      {
-        id: nil,
-        partial: 'form',
-        locals: {},
-        action: 'replace'
-      }
-    ], # additional partials that should be rendered if save_action failed
-    add_flash_alerts: [], #=> array of strings
-    add_flash_notices: [], #=> array of strings
-    flashes_on_success: [], #=> array of strings
-    flashes_on_error: [] #=> array of strings
-
-## Requirements
-
-gem `turbo_power` (is included, used for redirection)
-
-**Translations**
-
-`activerecord.success.successfully_created`
-
-`activerecord.success.successfully_updated`
-
-`activerecord.errors.messages.could_not_create`
-
-`activerecord.errors.messages.could_not_update`
-
-example value: `"%<model_name>s successfully created"`
-
-.. and Model Name Translations
-
 ## Contributing
 
 Contribution welcome.

data/app/views/_render_turbo_stream.turbo_stream.erb

@@ -0,0 +1,49 @@
+<% error = false %>
+<% control = [] %>
+<% streams = local_assigns[:streams] %>
+<% streams.each do |args| %>
+
+
+  <% if args.is_a?(Array) %>
+
+    <% ctl = "turbo_stream.#{args.first}, #{args[1..-1].join(', ')}" %>
+
+    <% if args.last.is_a?(Proc) %>
+      <% Rails.logger.error("  RENDER TURBO STREAM BLOCK => #{ctl}") %>
+      <%#= turbo_stream.replace 'form' do %>
+        <%#= render partial: 'articles/form' %>
+      <%# end %>
+      <%= turbo_stream.send args.first, *(args[1..-2]) { args.last.call } %>
+    <% else %>
+      <% Rails.logger.error("  RENDER TURBO POWER => #{ctl}") %>
+      <%= turbo_stream.send args.first, *(args[1..-1]) %>
+    <% end %>
+
+  <% else %>
+    <% ctl = { partial: args[:partial], id: args[:id], action: args[:action] } %>
+    <% info = { id: args[:id], partial: args[:partial], locals: args[:locals] } %>
+    <% if !args[:action].present? %>
+      <% Rails.logger.error("  ERROR RENDER TURBO STREAM => MISSING ACTION => #{args}") %>
+      <% error = true %>
+
+    <% elsif args[:action].present? %>
+      <% Rails.logger.debug("  • render-turbo-stream #{args[:action].upcase} => #{info}") %>
+      <%= turbo_stream.send args[:action].to_sym, args[:id] do %>
+        <%= render args[:partial], locals: args[:locals]&.symbolize_keys %>
+      <% end %>
+
+    <% else %>
+      <% Rails.logger.error("  ERROR RENDER TURBO STREAM => NOTHING DONE! => #{args}") %>
+    <% end %>
+  <% end %>
+
+  <% control.push(ctl) %>
+
+<% end %>
+
+<% if error %>
+  <% Rails.logger.error("  RENDER TURBO STREAM HAD ERRORS, REPEATING WHOLE ARRAY: ") %>
+  <% control.each do |c| %>
+    <% Rails.logger.error("    #{c}") %>
+  <% end %>
+<% end %>

data/app/views/render_turbo_stream.html.erb

@@ -6,6 +6,7 @@
     <% rendered_partials.push({ command: "turbo_stream.#{s.first}, #{s[1..-1].join(', ')}", method: s.first, attributes: s[1..-1] }) %>
   <% else %>
     <% html = (render s[:partial], locals: s[:locals]&.symbolize_keys, formats: [:html]) %>
+    <% s.delete(:partial) %>
     <% rendered_partials.push({ html_response: html }.merge(s)) %>
   <% end %>
 

data/lib/render_turbo_stream/test/request_helpers.rb

@@ -2,16 +2,8 @@ module RenderTurboStream
   module Test
     module RequestHelpers
 
-      # count of rendered partials
-      # count rendering different partials (example: «customer/form»)
-      # doesnt check how often a specific partial is rendered
-
-      def partials_count
-        RenderTurboStream::Libs.partials_count(response)
-      end
-
       # log as helper for the developer to see which flash is set and which partials are rendered to wich ids
-      def partials_log
+      def streams_log
         all_responses = RenderTurboStream::Libs.all_responses(response)
         r = []
         if response.status == 302
@@ -48,12 +40,12 @@ module RenderTurboStream
         url
       end
 
-      def partial_response_count(partial, id: nil, total: 1, &block)
-        RenderTurboStream::Libs.partial_response_count(response, partial, id, total, &block)
+      def stream_target_response_count(id, total: 1, &block)
+        RenderTurboStream::Libs.stream_target_response_count(response, id, total, &block)
       end
 
-      def partial_response(partial, id: nil, css: nil, include_string: nil)
-        c = partial_response_count(partial, id: id, total: 1) do |r|
+      def stream_response(id, css: nil, include_string: nil)
+        c = stream_target_response_count(id, total: 1) do |r|
           if css && include_string
             r.css(css).inner_html.include?(include_string)
           elsif include_string
@@ -67,8 +59,12 @@ module RenderTurboStream
         c == 1
       end
 
-      def partial_ids
-        RenderTurboStream::Libs.partial_ids(response)
+      def stream_targets
+        RenderTurboStream::Libs.stream_targets(response)
+      end
+
+      def stream_targets_count
+        stream_targets.length
       end
     end
   end

data/lib/render_turbo_stream/version.rb

@@ -1,3 +1,3 @@
 module RenderTurboStream
-  VERSION = "1.3.3"
+  VERSION = "1.4.1"
 end

data/lib/render_turbo_stream.rb

@@ -126,12 +126,12 @@ module RenderTurboStream
       response.status = 302
       flash[:alert] = flash_alerts
       flash[:notice] = flash_notices
-        render_turbo_stream([
-                          [
-                            :redirect_to,
-                            redirect_on_success_to
-                          ]
-                        ])
+      render_turbo_stream([
+                            [
+                              :redirect_to,
+                              redirect_on_success_to
+                            ]
+                          ])
     else
       flash.now[:alert] = flash_alerts
       flash.now[:notice] = flash_notices
@@ -191,40 +191,20 @@ module RenderTurboStream
 
     # if partial is one word, its checked against the last behind the slash, example: 'articles/form' matches 'form'
 
-    def self.select_responses(response, partial, id)
+    def self.select_responses(response, id)
       all = all_responses(response)
 
       all.select do |a|
-        partial_matched = if !partial.present?
-                            false
-                          elsif partial.include?('/')
-                            a['partial'] == partial
-                          else
-                            a['partial'].split('/').last == partial
-                          end
-        id_matched = if !id.present?
-                       false
-                     else
-                       a['id'] == id
-                     end
-        partial_matched && (id.present? ? id_matched : true)
-      end
-
-    end
-
-    def self.partials_count(response)
-      all = all_responses(response)
-      part = []
-      all.each do |p|
-        _p = p['partial']
-        unless part.include?(_p)
-          part.push(_p)
+        if id.present?
+          a['id'] == id
+        else
+          false
         end
       end
-      part.length
+
     end
 
-    def self.partial_ids(response)
+    def self.stream_targets(response)
       all = all_responses(response)
       ids = []
       all.each do |p|
@@ -236,8 +216,8 @@ module RenderTurboStream
       ids
     end
 
-    def self.partial_response_count(response, partial, id, total, &block)
-      responses = select_responses(response, partial, id)
+    def self.stream_target_response_count(response, id, total, &block)
+      responses = select_responses(response, id)
 
       if total && responses.count != total
         false

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: render_turbo_stream
 version: !ruby/object:Gem::Version
-  version: 1.3.3
+  version: 1.4.1
 platform: ruby
 authors:
 - christian
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-23 00:00:00.000000000 Z
+date: 2023-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -38,6 +38,7 @@ files:
 - README.md
 - Rakefile
 - app/controllers/render_turbo_stream/application_controller.rb
+- app/views/_render_turbo_stream.turbo_stream.erb
 - app/views/render_turbo_stream.html.erb
 - app/views/render_turbo_stream.turbo_stream.erb
 - lib/render_turbo_stream.rb