render_turbo_stream 2.1.2 → 3.0.0

data/lib/render_turbo_stream.rb

@@ -1,335 +1,15 @@
 require "render_turbo_stream/version"
 require "render_turbo_stream/railtie"
 require 'render_turbo_stream/engine'
-require 'render_turbo_stream/test/request_helpers'
-require 'render_turbo_stream/test/rspec_request_helpers'
-require 'render_turbo_stream/turbo_cable_helpers'
-require 'render_turbo_stream/turbo_cable_view_helpers'
 
-module RenderTurboStream
+require 'render_turbo_stream/test/request/channel_helpers'
+require 'render_turbo_stream/test/request/helpers'
+require 'render_turbo_stream/test/request/libs'
 
-  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
-  )
+require 'render_turbo_stream/controller_helpers'
+require 'render_turbo_stream/controller_channel_helpers'
 
-    unless object
-      object = eval("@#{controller_name.classify.underscore}")
-    end
+require 'render_turbo_stream/channel_view_helpers'
 
-    #== Streams / Partials
+require 'render_turbo_stream/channel_libs'
 
-    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_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}»")
-          partial_to_me(
-            s[:partial],
-            s[:id],
-            action: flash_action,
-            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
-
-  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
-        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', locals: { streams: ary }, layout: false, formats: :html
-    end
-  end
-
-  def stream_partial(
-    id,
-    partial: nil, #=> default: id
-    action: :replace,
-    locals: {}
-  )
-    render_turbo_stream(
-      [
-        {
-          id: id,
-          partial: partial,
-          action: action,
-          locals: locals
-        }
-      ]
-    )
-  end
-
-  class Libs
-    def self.all_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-cable-[\d]+$/)
-        h = JSON.parse(v)
-        res.push(h)
-      end
-      res
-    end
-
-    # if partial is one word, its checked against the last behind the slash, example: 'articles/form' matches 'form'
-
-    def self.select_responses(response, id)
-      all = all_responses(response)
-
-      all.select do |a|
-        if id.present?
-          a['target'] == "##{id}"
-        else
-          false
-        end
-      end
-
-    end
-
-    def self.stream_targets(response)
-      responses = all_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.stream_target_response_count(response, id, total, &block)
-      responses = select_responses(response, id)
-
-      if total && responses.count != total
-        false
-      elsif block_given?
-        res = responses.select do |r|
-          parsed = Nokogiri::HTML(r['html_response'])
-          r = yield parsed
-          r.present?
-        end.length
-        (res == 0 ? nil : res)
-      else
-        responses.length
-      end
-
-    end
-
-    # on most methods the first attribute is the target.
-    # This method checks for that
-    # it includes the methods from turbo-power
-    # used for test helpers
-    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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: render_turbo_stream
 version: !ruby/object:Gem::Version
-  version: 2.1.2
+  version: 3.0.0
 platform: ruby
 authors:
 - christian
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-03 00:00:00.000000000 Z
+date: 2023-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -39,18 +39,20 @@ files:
 - Rakefile
 - app/controllers/render_turbo_stream/application_controller.rb
 - app/controllers/render_turbo_stream/render_turbo_stream_render_controller.rb
-- app/models/render_turbo_stream/cable_stream.rb
-- app/views/render_turbo_stream.html.erb
 - app/views/render_turbo_stream.turbo_stream.erb
-- db/migrate/20230428115511_cable_streams.rb
-- db/migrate/20230428115724_create_render_turbo_stream_cable_streams.rb
+- app/views/render_turbo_stream_command.html.erb
+- app/views/render_turbo_stream_empty_template.html.erb
+- app/views/render_turbo_stream_request_test.html.erb
 - lib/render_turbo_stream.rb
+- lib/render_turbo_stream/channel_libs.rb
+- lib/render_turbo_stream/channel_view_helpers.rb
+- lib/render_turbo_stream/controller_channel_helpers.rb
+- lib/render_turbo_stream/controller_helpers.rb
 - lib/render_turbo_stream/engine.rb
 - lib/render_turbo_stream/railtie.rb
-- lib/render_turbo_stream/test/request_helpers.rb
-- lib/render_turbo_stream/test/rspec_request_helpers.rb
-- lib/render_turbo_stream/turbo_cable_helpers.rb
-- lib/render_turbo_stream/turbo_cable_view_helpers.rb
+- lib/render_turbo_stream/test/request/channel_helpers.rb
+- lib/render_turbo_stream/test/request/helpers.rb
+- lib/render_turbo_stream/test/request/libs.rb
 - lib/render_turbo_stream/version.rb
 - lib/tasks/render_turbo_stream_tasks.rake
 homepage: https://gitlab.com/sedl/renderturbostream
@@ -78,6 +80,6 @@ requirements: []
 rubygems_version: 3.4.12
 signing_key:
 specification_version: 4
-summary: Run javascripts and render partials directly from the controller. With test
-  helpers.
+summary: Complete rails-like workflow for turbo streams and channels. With testing
+  strategy.
 test_files: []

data/app/models/render_turbo_stream/cable_stream.rb

@@ -1,4 +0,0 @@
-module RenderTurboStream
-  class CableStream < ApplicationRecord
-  end
-end

data/db/migrate/20230428115511_cable_streams.rb

@@ -1,4 +0,0 @@
-class CableStreams < ActiveRecord::Migration[7.0]
-  def change
-  end
-end

data/db/migrate/20230428115724_create_render_turbo_stream_cable_streams.rb

@@ -1,11 +0,0 @@
-class CreateRenderTurboStreamCableStreams < ActiveRecord::Migration[7.0]
-  def change
-    create_table :render_turbo_stream_cable_streams do |t|
-      t.string :request_id, limit: 80
-      t.text :locals
-      t.string :action, limit: 80
-      t.string :arguments
-      t.timestamps
-    end
-  end
-end

data/lib/render_turbo_stream/test/request_helpers.rb

@@ -1,100 +0,0 @@
-module RenderTurboStream
-  module Test
-    module RequestHelpers
-
-      # log as helper for the developer to see which flash is set and which partials are rendered to wich ids
-      def streams_log
-        RenderTurboStream::Libs.all_responses(response)
-      end
-
-      # Returns the path to which turbo_stream.redirect_to would be applied.
-      def turbo_redirect_to
-        resps = RenderTurboStream::Libs.all_responses(response)
-        url = nil
-        resps.each do |r|
-          if r['type'] == 'command'
-            if r['attributes'].first == 'redirect_to'
-              if url
-                url = 'ERROR: REDIRECT CALLED MORE THAN ONCE'
-              else
-                url = r['attributes'].second
-              end
-            end
-          end
-        end
-        url
-      end
-
-      def stream_target_response_count(id, total: 1, &block)
-        RenderTurboStream::Libs.stream_target_response_count(response, id, total, &block)
-      end
-
-      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
-            r.inner_html.include?(include_string)
-          elsif css
-            r.css(css)
-          else
-            r.inner_html
-          end
-        end
-        c == 1
-      end
-
-      def stream_targets
-        RenderTurboStream::Libs.stream_targets(response)
-      end
-
-      def stream_targets_count
-        stream_targets.length
-      end
-
-      # Returns false if a given action such as "replace" (for: turbo_stream.replace) is not performed exactly once on a given target id. Otherwise, it returns an array of attributes that were used to call the function.
-      # For stream actions, this only works if the given action has the HTML-ID as its first element.
-      def stream_action_once(action, id)
-        all_responses = RenderTurboStream::Libs.all_responses(response)
-        counts = {}
-        res = nil
-        all_responses.each do |r|
-
-          if r['type'] == 'command'
-            act = r['attributes'].first
-            is_id = RenderTurboStream::Libs.first_arg_is_html_id(act)
-            if action.to_s == act && is_id && r['attributes'].second == id.to_s
-              k = [act, r['attributes'].second].join('-')
-              counts[k] ||= 0
-              counts[k] += 1
-              if counts[k] == 1
-                res = r['attributes']
-              else
-                res = false
-              end
-            end
-
-          elsif r['type'] == 'partial'
-
-            act = r['action']
-            is_id = r['target'][0] == '#'
-            _id = r['target'][1..-1]
-            if action.to_s == act && is_id && _id == id.to_s
-              k = [act, _id].join('-')
-              counts[k] ||= 0
-              counts[k] += 1
-              if counts[k] == 1
-                res = [act, id, { locals: r['locals'] }]
-              else
-                res = false
-              end
-            end
-
-          end
-        end
-        res
-      end
-
-    end
-  end
-end

data/lib/render_turbo_stream/test/rspec_request_helpers.rb

@@ -1,34 +0,0 @@
-module RenderTurboStream
-  module Test
-    module RspecRequestHelpers
-
-      # expect status 200 and a each one time response to given ids
-
-      def expect_successful_saved(*ids)
-        responses = RenderTurboStream::Libs.all_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
-
-        expect(response.status).to eq(200)
-        expect(id_counts.keys.length).to eq(ids.length)
-        ids.each do |id|
-          expect(id_counts.key?(id)).to be_truthy
-          expect(id_counts[id]).to eq(1)
-        end
-      end
-
-    end
-  end
-end

data/lib/render_turbo_stream/turbo_cable_helpers.rb

@@ -1,75 +0,0 @@
-module RenderTurboStream
-  module TurboCableHelpers
-
-    def partial_to_all_authenticated_users
-      raise "Function partial_to_all_authenticated_users is not yet implemented"
-      if user_signed_in?
-
-      end
-    end
-
-    def partial_to_channel(action, channel, partial, id, locals: nil)
-
-      # add headers for test
-      if Rails.env.test?
-        html = RenderTurboStreamRenderController.render(partial: partial, locals: locals)
-        props = {
-          target: "##{id}",
-          action: action,
-          type: 'cable-partial',
-          partial: partial,
-          locals: locals,
-          html_response: html.to_s
-        }
-        h = response.headers.to_h
-        i = 1
-        loop do
-          k = "test-turbo-cable-#{i}"
-          unless h.keys.include?(k)
-            response.headers[k] = props.to_json
-            break
-          end
-          i += 1
-        end
-      end
-
-      # send
-
-      Turbo::StreamsChannel.send(
-        "broadcast_#{action}_to",
-        channel.to_s,
-        target: id,
-        partial: partial,
-        locals: locals&.symbolize_keys,
-        layout: false
-      )
-    end
-
-    def partial_to_all(action, partial, id, locals: nil)
-      partial_to_channel(action, 'all', partial, id, locals: locals)
-    end
-
-    def 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.partial_to_me because current_user is nil')
-          return
-        end
-      rescue
-        Rails.logger.debug('  • ERROR RenderTurboStream.partial_to_me because current_user is not available')
-        return
-      end
-
-      partial_to_channel(
-        action,
-        "authenticated-user-#{helpers.current_user.id}",
-        partial,
-        id,
-        locals: locals
-        )
-    end
-
-  end
-end

data/lib/render_turbo_stream/turbo_cable_view_helpers.rb

@@ -1,36 +0,0 @@
-module RenderTurboStream
-  module TurboCableViewHelpers
-
-    def cable_from_me
-      if current_user
-        turbo_stream_from "authenticated-user-#{current_user.id}"
-      else
-        Rails.logger.debug("  • SKIP CABLE_FROM_ME because not authenticated")
-        nil
-      end
-    end
-
-    def cable_from_all_authenticated_users
-      raise "Function cable_from_all_authenticated_users is not yet implemented"
-      if user_signed_in?
-        turbo_stream_from "all-authenticated-users"
-      else
-        Rails.logger.debug("  • SKIP CABLE_FROM_ALL_AUTHENTICATED_USERS because not authenticated")
-        nil
-      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
-
-  end
-end