render_turbo_stream 2.1.2 → 3.0.1

data/lib/render_turbo_stream/controller_helpers.rb

@@ -0,0 +1,241 @@
+module RenderTurboStream
+  module ControllerHelpers
+
+    # Handles translated flash messages as defined in translations and configs.
+    # If :redirect_on_success_to and channel set up and use_channel_for_turbo_stream_save are configured, sends flash message by channel_to_me.
+    # you can add more stream actions to the same response
+
+    def turbo_stream_save(
+      save_action,
+      redirect_on_success_to: nil, # does a regular redirect. Works if you are inside a turbo_frame and just want to redirect inside that frame BUT CANNOT STREAM OTHERS ACTIONS ON THE SAME RESPONSE https://github.com/rails/rails/issues/48056
+      turbo_redirect_on_success_to: nil, # does a full page redirect (break out of all frames by turbo_power redirect)
+      object: nil, # object used in save_action, example: @customer
+      id: nil, # if nil: no partial is rendered
+      partial: nil, # example: 'customers/form' default: "#{controller_path}/#{id}"
+      action: 'replace', # options: append, prepend
+      flash_action: action_name, # options: 'update', 'create', otherwise you have to declare a translation in config/locales like "activerecord.success.#{flash_action}" and "activerecord.errors.#{flash_action}"
+      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
+    )
+
+      unless object
+        object = eval("@#{controller_name.classify.underscore}")
+      end
+
+      #== Streams / Partials
+
+      streams = (id ? [id: id, partial: partial, locals: locals, action: action] : [])
+
+      if save_action
+        response.status = 200
+        streams_on_success.each do |s|
+          if s.is_a?(Array)
+            streams.push(s)
+          elsif s.is_a?(Hash) && s[:id].present?
+            streams.push(s)
+          end
+        end
+      else
+        response.status = :unprocessable_entity
+        streams += streams_on_error.select { |s| s[:id].present? }
+      end
+
+      #== FLASHES
+
+      model_name = object.model_name.human
+      if save_action
+        flash_notices = if flashes_on_success.present?
+                          flashes_on_success
+                        elsif flash_action.to_s == 'create'
+                          str = I18n.t(
+                            'activerecord.success.successfully_created',
+                            default: '%<model_name>s successfully created'
+                          )
+                          [format(str, model_name: model_name)]
+                        elsif flash_action.to_s == 'update'
+                          str = I18n.t(
+                            'activerecord.success.successfully_updated',
+                            default: '%<model_name>s successfully updated'
+                          )
+                          [format(str, model_name: model_name)]
+                        else
+                          str = I18n.t(
+                            "activerecord.success.#{flash_action}",
+                            default: '%<model_name>s successfully updated'
+                          )
+                          [format(str, model_name: model_name)]
+                        end
+        flash_alerts = []
+      else
+        flash_alerts = if flashes_on_error.present?
+                         flashes_on_error
+                       elsif flash_action.to_s == 'create'
+                         str = I18n.t(
+                           'activerecord.errors.messages.could_not_create',
+                           default: '%<model_name>s could not be created'
+                         )
+                         [format(str, model_name: model_name)]
+                       elsif flash_action.to_s == 'update'
+                         str = I18n.t(
+                           'activerecord.errors.messages.could_not_update',
+                           default: '%<model_name>s could not be updated'
+                         )
+                         [format(str, model_name: model_name)]
+                       else
+                         str = I18n.t(
+                           "activerecord.errors.messages.#{flash_action}",
+                           default: '%<model_name>s could not be updated'
+                         )
+                         [format(str, model_name: model_name)]
+                       end
+        flash_notices = []
+      end
+
+      flash_notices += add_flash_notices.to_a
+      flash_alerts += add_flash_alerts.to_a
+      _flash_id = Rails.configuration.x.render_turbo_stream.flash_id
+      flash_id = (_flash_id ? _flash_id : "ERROR, MISSING CONFIG => config.x.render_turbo_stream.flash_id")
+      flash_partial = Rails.configuration.x.render_turbo_stream.flash_partial
+      flash_action = Rails.configuration.x.render_turbo_stream.flash_action
+      flash_notices.each do |notice|
+        next unless notice.present?
+        # inside the flash partial has to be a loop that handles all theese flashes
+        flash_stream = {
+          id: flash_id,
+          partial: flash_partial,
+          action: flash_action,
+          locals: { success: true, message: notice }
+        }
+        streams.push(flash_stream)
+      end
+      flash_alerts.each do |alert|
+        next unless alert.present?
+        # inside the flash partial has to be a loop that handles all theese flashes
+        flash_stream = {
+          id: flash_id,
+          partial: flash_partial,
+          action: flash_action,
+          locals: { success: false, message: alert }
+        }
+        streams.push(flash_stream)
+      end
+
+      #== render
+
+      if save_action && turbo_redirect_on_success_to.present?
+        response.status = 302
+        flash[:alert] = flash_alerts
+        flash[:notice] = flash_notices
+        Rails.logger.debug("  • Set flash[:alert] => #{flash_alerts}") if flash_alerts.present?
+        Rails.logger.debug("  • Set flash[:notice] => #{flash_notices}") if flash_notices.present?
+        render_turbo_stream([
+                              [
+                                :redirect_to,
+                                turbo_redirect_on_success_to
+                              ]
+                            ])
+      elsif save_action && redirect_on_success_to.present?
+        response.status = 302
+        if Rails.configuration.x.render_turbo_stream.use_channel_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}»")
+            render_to_me(
+              s[:id],
+              flash_action,
+              partial: s[:partial],
+              locals: s[:locals]
+            )
+          end
+
+        else
+          flash[:alert] = flash_alerts
+          flash[:notice] = flash_notices
+          Rails.logger.debug("  • Set flash[:alert] => #{flash_alerts}") if flash_alerts.present?
+          Rails.logger.debug("  • Set flash[:notice] => #{flash_notices}") if flash_notices.present?
+        end
+        redirect_to redirect_on_success_to
+
+      else
+        flash.now[:alert] = flash_alerts
+        flash.now[:notice] = flash_notices
+        render_turbo_stream(streams)
+      end
+    end
+
+
+    # renders a array of partials to send by turbo-stream and / or actions like turbo_power gem includes, to turbo_stream
+    def render_turbo_stream(array)
+
+      ary = []
+      array.each do |pr|
+        if !pr.present?
+          Rails.logger.warn "  WARNING render_turbo_stream: Empty element inside attributes: «#{array}»"
+        elsif pr.is_a?(Hash)
+          props = pr.symbolize_keys
+          raise "missing attribute :id in #{props}" if !props[:id].present?
+          part = (props[:partial].present? ? props[:partial] : props[:id]).gsub('-', '_')
+          partial = (part.to_s.include?('/') ? part : [controller_path, part].join('/'))
+          r = props
+          r[:action] = (props[:action].present? ? props[:action] : :replace)
+          r[:partial] = partial
+          r[:type] = 'stream-partial'
+          ary.push(r)
+        elsif pr.is_a?(Array)
+          raise "array has to contain at least one element: #{pr}" unless pr.first.present?
+          ary.push(pr)
+        else
+          raise "ERROR render_turbo_stream invalid type: Only hash or array allowed"
+        end
+      end
+
+      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_request_test', locals: { streams: ary }, layout: false, formats: :html
+      end
+
+    end
+
+    # renders a partial to turbo_stream
+
+    def stream_partial(
+      id,
+      partial: nil, #=> default: id
+      action: :replace,
+      locals: {}
+    )
+      render_turbo_stream(
+        [
+          {
+            id: id,
+            partial: partial,
+            action: action,
+            locals: locals
+          }
+        ]
+      )
+    end
+
+  end
+end

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

@@ -0,0 +1,55 @@
+module RenderTurboStream
+  module Test
+    module Request
+      module ChannelHelpers
+
+        # Assert a action by turbo streams channel to the current_user
+
+        def assert_channel_to_me(user, target_id, action: nil, count: 1, &block)
+
+          channel = "authenticated-user-#{user.id}"
+
+          libs = RenderTurboStream::Test::Request::Libs
+
+          r = libs.select_responses(response, channel, target_id, action, type: :channel, &block)
+
+          assert(
+            r[:responses].length == count,
+            libs.assert_error_message(count, r[:responses].length, r[:log])
+          )
+        end
+
+        # Assert a action by turbo streams channel to a group of authenticated users
+
+        def assert_channel_to_authenticated_group(group, target_id, action: nil, count: 1, &block)
+
+          channel = "authenticated-group-#{group}"
+
+          libs = RenderTurboStream::Test::Request::Libs
+
+          r = libs.select_responses(response, channel, target_id, action, type: :channel, &block)
+
+          assert(
+            r[:responses].length == count,
+            libs.assert_error_message(count, r[:responses].length, r[:log])
+          )
+        end
+
+        # Assert a action by turbo streams channel to all visitors of the page
+
+        def assert_channel_to_all(target_id, action: nil, count: 1, &block)
+
+          libs = RenderTurboStream::Test::Request::Libs
+
+          r = libs.select_responses(response, 'all', target_id, action, type: :channel, &block)
+
+          assert(
+            r[:responses].length == count,
+            libs.assert_error_message(count, r[:responses].length, r[:log])
+          )
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+module RenderTurboStream
+  module Test
+    module Request
+      module Helpers
+
+        # Assert that each of given target_ids is targeted exactly once
+
+        def assert_once_targeted(*target_ids)
+          responses = RenderTurboStream::Test::Request::Libs.all_turbo_responses(response)
+          id_counts = {}
+          responses.each do |r|
+            if r['target'].is_a?(Array)
+              r['target'].each do |t|
+                id = (t[0] == '#' ? t[1..-1] : t)
+                id_counts[t.to_s] ||= 0
+                id_counts[t.to_s] += 1
+              end
+            else
+              id = (r['target'][0] == '#' ? r['target'][1..-1] : r['target'])
+              id_counts[id] ||= 0
+              id_counts[id] += 1
+            end
+          end
+
+          assert(id_counts.keys.length == target_ids.length, "You checked for #{target_ids.length} but #{id_counts.keys.length} targeted: #{id_counts.keys.join(', ')}")
+          target_ids.each do |id|
+            assert(id_counts.key?(id), "The id #{id} is not within the targeted ids: #{id_counts.keys.join(', ')}")
+            expect(id_counts[id]).to eq(1)
+            assert(id_counts[id] == 1, "The id #{id} is targeted #{id_counts[id]} #{'time'.pluralize(id_counts[id])}")
+          end
+        end
+
+        # Helper for the developer for writing tests: Array with all attributes of all turbo-stream and turbo-channel actions that runned on the last request
+
+        def all_turbo_responses
+          RenderTurboStream::Test::Request::Libs.all_turbo_responses(response)
+        end
+
+        # Returns Array of all target_ids that arre affected at least once on the last response
+        def turbo_targets
+          RenderTurboStream::Test::Request::Libs.turbo_targets(response)
+        end
+
+        # Returns the path sent to turbo_stream.redirect_to.
+        def turbo_redirect_to
+          resps = RenderTurboStream::Test::Request::Libs.all_turbo_responses(response)
+          url = nil
+          resps.each do |r|
+            if r['type'] == 'stream-command'
+              if r['array'].first == 'redirect_to'
+                if url
+                  url = 'ERROR: REDIRECT CALLED MORE THAN ONCE'
+                else
+                  url = r['array'].second
+                end
+              end
+            end
+          end
+          url
+        end
+
+        # assert one or more specific actions to a target_id
+        def assert_stream_response(target_id, action: nil, count: 1, type: :stream, &block)
+
+          libs = RenderTurboStream::Test::Request::Libs
+
+          r = libs.select_responses(response, false, target_id, action, type: type, &block)
+
+          assert(
+            r[:responses].length == count,
+            libs.assert_error_message(count, r[:responses].length, r[:log])
+          )
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,156 @@
+module RenderTurboStream
+  module Test
+    module Request
+      class Libs
+        def self.all_turbo_responses(response)
+          e = Nokogiri::HTML(response.body).search('#rendered-partials').first
+          res = (e.present? ? JSON.parse(e.inner_html) : [])
+          response.headers.each do |k, v|
+            next unless k.match(/^test-turbo-channel-[\d]+$/)
+            h = JSON.parse(v)
+            res.push(h)
+          end
+          res
+        end
+
+        def self.select_responses(response, channel, target_id, action, type: nil, prohibit_multiple_to_same_target: [:replace], &block)
+          all = all_turbo_responses(response)
+          res = { log: [], responses: [] }
+
+          if !target_id.present?
+            res[:log].push("No target «##{target_id}» provided!")
+          elsif prohibit_multiple_to_same_target.present?
+            has_prohibited_action = false
+            c = all.select do |e|
+              if prohibit_multiple_to_same_target.include?(e['action']&.to_sym)
+                has_prohibited_action = true
+              end
+              e['target'] == "##{target_id}"
+            end.length
+            if c >= 2 && has_prohibited_action
+              res[:log].push("Target «##{target_id}» is targeted #{c} #{'time'.pluralize(c)} which is prohibited for the actions #{prohibit_multiple_to_same_target.join(', ')}")
+              return res
+            end
+          end
+
+          id_matched = false
+
+          responses = all.select do |a|
+            types = [a['type']]
+            if ['channel-partial', 'channel-template'].include?(a['type'])
+              types.push('channel')
+            elsif ['stream-partial'].include?(a['type'])
+              types.push('stream')
+            elsif ['stream-command'].include?(a['type'])
+              types.push('command')
+              types.push('stream')
+            elsif ['channel-command'].include?(a['type'])
+              types.push('command')
+              types.push('channel')
+            end
+
+            if target_id.present? && a['target'] == "##{target_id}"
+              id_matched = true
+            end
+
+            if target_id.present? && a['target'] != "##{target_id}"
+              false
+            elsif type.present? && !types.include?(type.to_s)
+              res[:log].push("Target «##{target_id}»: Types #{types.join(', ')} not matching with given type «#{type}»")
+              false
+            elsif channel.present? && a['channel'] != channel.to_s
+              res[:log].push("Target «##{target_id}»: Channel #{a['channel']} not matching with given channel «#{channel}»")
+              false
+            elsif action.present? && a['action'] != action.to_s
+              res[:log].push("Target «##{target_id}»: Action #{a['action']} not matching with given action «#{action}»")
+              false
+            elsif block_given?
+              if types.include?('command')
+                args = a['array'][1..-1]
+                if yield(args)
+                  true
+                else
+                  res[:log].push("Given block not matching Arguments => «#{args}»")
+                  false
+                end
+              else
+                nok = Nokogiri::HTML(a['html_response'])
+                if yield(nok).present?
+                  true
+                else
+                  res[:log].push("Target «##{target_id}»: Given block not matching (checked by .present?)")
+                  false
+                end
+              end
+            else
+              true
+            end
+          end
+
+          unless id_matched
+            res[:log].push("Target «##{target_id}» not found")
+          end
+
+          res[:responses] = responses
+          res
+        end
+
+        def self.turbo_targets(response)
+          responses = all_turbo_responses(response)
+          targets = []
+          responses.each do |r|
+            if r['target'].is_a?(Array)
+              r['target'].each do |t|
+                targets.push(t) unless targets.include?(t)
+              end
+            else
+              targets.push(r['target']) unless targets.include?(r['target'])
+            end
+          end
+
+          targets
+        end
+
+        def self.assert_error_message(expected, received, log)
+          [
+            "Expected #{expected} #{'response'.pluralize(expected)} but found #{received}.",
+            (log.present? ? "Messages => «#{log.join(', ')}»" : nil)
+          ].compact.join(' ')
+        end
+
+        def self.first_arg_is_html_id(method)
+          config = Rails.configuration.x.render_turbo_stream.first_argument_is_html_id
+          default = [
+            :graft,
+            :morph,
+            :inner_html,
+            :insert_adjacent_text,
+            :outer_html,
+            :text_content,
+            :add_css_class,
+            :remove_attribute,
+            :remove_css_class,
+            :set_attribute,
+            :set_dataset_attribute,
+            :set_property,
+            :set_style,
+            :set_styles,
+            :set_value,
+            :dispatch_event,
+            :reset_form,
+            :clear_storage,
+            :scroll_into_view,
+            :set_focus,
+            :turbo_frame_reload,
+            :turbo_frame_set_src,
+            :replace,
+            :append,
+            :prepend
+          ]
+          (config.present? ? config : default).map { |m| m.to_sym }.include?(method.to_sym)
+        end
+
+      end
+    end
+  end
+end

data/lib/render_turbo_stream/version.rb

@@ -1,3 +1,3 @@
 module RenderTurboStream
-  VERSION = "2.1.2"
+  VERSION = "3.0.1"
 end