render_turbo_stream 0.1.9 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b699433559bcb2f6c79f10a8df305584db96042dd43de7999eb17b00cf87ffc9
-  data.tar.gz: 3c85d56f2991b7bb8676b2864caee8eb20c271161fc38d4c378d206838007648
+  metadata.gz: aa9b9cefa95d380af39fd2f096f569cb4eabe94fe024164722cae8497b7d076f
+  data.tar.gz: 9973fe128954730c6b1dc9f52ecc63a6b633951d118f06eae0e2672c54a519d2
 SHA512:
-  metadata.gz: 243377679364d09d0c3ced284dbdcbc72be83dc0f16d18f8d54f0c2f8c71c6e2d9b613cab3e493a6a4f8454fcfa29a837da5ffc624b5c77b3399e1fa3a2cdae3
-  data.tar.gz: ed18eee7081e7ebc1ea98fd4159d0876a1edee0116c34e4dd18362c214834dc8e37fca5af3b411f6f0bac33e86606f5f5dda6b537d3cbf529db87dafb3bdf180
+  metadata.gz: 1738911b840851ed5d3974702bea36029f8bcb453786b5524bef7c1f2fee0ee78dccfc0f275e8e5f72b724f787425aa13f821c7c251c5ad92876c5c728b2bad5
+  data.tar.gz: 6be68eb76a040ab06fb97380d80d03ce16e55096819062a5c8760604a5d9df5808ba1c72229afe7a9807e9ec6c6e69a305b17be2a94ed110eae4ec8461c148cd

data/README.md

@@ -1,58 +1,110 @@
 # RenderTurboStream
 
-Creating a gem currently is not possible because of [rails issue](https://github.com/rails/rails/issues/47954)
+The machine gun for your turbo-stream partials.
 
-So, applying this idea is currently only possible by copy and paste a method and a view, see below.
+Creating a gem from this is in work, see [rails issue](https://github.com/rails/rails/issues/47954)
 
-Working consistently by turbo_stream means: shooting a lot of partials to the html which always needs the same attributes: ID, partial and maybe some locals. This gem is a attempt to serialize that, especially for `update` and `create` action.
+Defining templates like `update.turbo_stream.haml` annoyed me.
 
-Logic is better placed inside the controller, instead of the view and it's boring to write always the same `ifs` inside the `update.turbo_stream.haml`. So this gem holds a `.turbo_stream.html.erb` view that loops through all the partials that should be rendered.
+Working consistently by turbo_stream means: shooting many partials to the frontend which always needs the same attributes: ID, partial and maybe some locals. This gem serializes that: Partials can be steered directly from the controller.
 
-In 90% of cases you have just define your partials, like `_form.haml` and steer them from the controller directly, without a `.turbo_stream.haml` view.
+Currently it is only possible by copy and paste the code, see below.
 
 ## Installation
 
-Because of [that issue](https://github.com/rails/rails/issues/47954) appying this feature is currently only possible by copy and paste following files to your app
+```ruby
+gem 'render_turbo_stream'
+```
 
-[application_controller](https://gitlab.com/sedl/renderturbostream/-/wikis/application_controller)
+```shell
+bundle install
+```
 
-[layout/render_partials.turbo_stream.erb](https://gitlab.com/sedl/renderturbostream/-/wikis/layout/render.turbo_stream.erb)
+**ApplicationController**
 
-[layouts/render_redirect.turbo_stream.erb](https://gitlab.com/sedl/renderturbostream/-/wikis/layouts/render_redirect.turbo_stream.erb)
+```ruby
+include RenderTurboStream
+```
 
 The corresponding partials for flashes could look [like this](https://gitlab.com/sedl/renderturbostream/-/wikis/flashes)
 
 ## Usage
 
+`turbo_stream_save` is a special method for streamline `update` or `create` functions for `turbo_stream`, which could look like so:
+
 ```ruby
  def create
     @customer = Customer.new(customer_params)
 
-    render_turbo_stream(
+    turbo_stream_save(
       @customer.save,
-      redirect_on_success_to: edit_customer_path(@customer),
-      id: 'customer-form-wrapper',
-      partial: 'customer_form',
+      redirect_on_success_to: edit_customer_path(@customer)
     )
 
   end
 ```
 
-and its done!
+This sets a status, generates a flash message and performs `stream_partials`, which could result like that:
+
+```ruby
+stream_partials(
+  [
+    {
+      id: 'form',
+      partial: 'form'
+    },
+    {
+      id: 'flash-wrapper',
+      partial: 'layouts/flashes',
+      action: :prepend
+    }
+  ]
+)
+```
+
+The `stream_partial` method is nothing else than a singular of `stream_partials`
 
-in 90% use cases it should be enough and not necessary writing any code inside `update.turbo_stream.haml` or `create.turbo_stream.haml`
+```ruby
+stream_partial(
+  id,
+  partial: nil, #=> default: id.gsub('-','_')
+  locals: {},
+  action: nil #=> default: :replace
+)
+```
 
 ## Testing
 
-Testing by regular `rspec` request specs the controller is rendering classic html templates, not turbo_stream. For that html templates are rendered, but only with hints so that your test can check which action is done.
+For system testing you need capybara.
 
-It has 3 cases of output with its resulting status codes which can be checked by rspec:
+For enabling request specs:
 
-Success and redirection: `302`
+If `request.format` is not `turbo_stream` the method responds as `json` with status.
+`response.body` returns a `json` where the key is the `html-ID` that is used by turbo-stream with the properties of the partials. Testing by rspec could look like this: 
 
-Success without redirection: `200`
+```ruby
+it 'update failed' do
+  a = FactoryBot.create(:article)
+  patch article_path(a, params: invalid_params)
+  expect(response.status).to eq(422)
+  h = JSON.parse(response.body)
+  expect(h['form']['partial']).to eq('articles/form')
+  expect(h['flash-box']['partial']).to eq('layouts/flash')
+  expect(h.keys.length).to eq(2)
+end
+```
 
-Save Action failed: `422` `:unprocessable_entity`
+Test for a redirection could look like this: 
+
+```ruby
+it 'update success' do
+    a = FactoryBot.create(:article)
+    patch article_path(a, params: valid_params)
+    expect(response.status).to eq(302)
+    r = JSON.parse(response.body)
+    expect(r['redirected_to']).to eq(articles_path)
+end
+```
 
 ## Parameters
 
@@ -84,7 +136,7 @@ Save Action failed: `422` `:unprocessable_entity`
 
 gem `turbo_power` (is included, used for redirection)
 
-**Translations used**
+**Translations**
 
 `activerecord.success.successfully_created`
 
@@ -94,6 +146,8 @@ gem `turbo_power` (is included, used for redirection)
 
 `activerecord.errors.messages.could_not_update`
 
+example value: `"%<model_name>s successfully created"`
+
 .. and Model Name Translations
 
 **Flash configuration**

data/app/controllers/render_turbo_stream/application_controller.rb

@@ -0,0 +1,4 @@
+module RenderTurboStream
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/views/render_turbo_stream_partials.turbo_stream.erb

@@ -0,0 +1,52 @@
+<% error = false %>
+<% control = [] %>
+<% local_assigns[:streams].each do |s| %>
+  <% ctl = { partial: s[:partial], id: s[:id] } %>
+  <% info = { id: s[:id], partial: s[:partial], locals: s[:locals] } %>
+
+  <% if !s[:id] %>
+    <% Rails.logger.error("  ERROR RENDER TURBO STREAM => MISSING ID => #{s}") %>
+    <% error = true %>
+
+  <% elsif !s[:partial].present? %>
+    <% Rails.logger.error("  ERROR RENDER TURBO STREAM => MISSING PARTIAL => #{s}") %>
+    <% error = true %>
+    <% ctl[:partial] = nil %>
+
+  <% elsif s[:action].to_sym == :replace %>
+    <% ctl[:action] = :replace %>
+    <% Rails.logger.debug("  • render-turbo-stream REPLACE => #{info}") %>
+    <%= turbo_stream.replace s[:id] do %>
+      <%= render s[:partial], locals: s[:locals] %>
+    <% end %>
+
+  <% elsif s[:action].to_sym == :prepend %>
+    <% ctl[:action] = :prepend %>
+    <% Rails.logger.debug("  • render-turbo-stream PREPEND => #{info}") %>
+    <%= turbo_stream.prepend s[:id] do %>
+      <%= render s[:partial], locals: s[:locals] %>
+    <% end %>
+
+  <% elsif s[:action].to_sym == :append %>
+    <% ctl[:action] = :append %>
+    <% Rails.logger.debug("  • render-turbo-stream APPEND => #{info}") %>
+    <%= turbo_stream.prepend s[:id] do %>
+      <%= render s[:partial], locals: s[:locals] %>
+    <% end %>
+
+  <% else %>
+    <% ctl[:action] = :UNKNOWN %>
+    <% Rails.logger.fatal("  ERROR render-turbo-stream => UNKNOWN ACTION => #{s}") %>
+    <% error = true %>
+  <% 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_redirect.turbo_stream.erb

@@ -0,0 +1 @@
+<%= turbo_stream.redirect_to local_assigns[:url] %>

data/lib/render_turbo_stream/engine.rb

@@ -0,0 +1,5 @@
+module RenderTurboStream
+  class Engine < ::Rails::Engine
+    isolate_namespace RenderTurboStream
+  end
+end

data/lib/render_turbo_stream/version.rb

@@ -1,3 +1,3 @@
 module RenderTurboStream
-  VERSION = "0.1.9"
+  VERSION = "0.1.12"
 end

data/lib/render_turbo_stream.rb

@@ -1,12 +1,162 @@
 require "render_turbo_stream/version"
 require "render_turbo_stream/railtie"
+require 'render_turbo_stream/engine'
 
 module RenderTurboStream
-  # Your code goes here...
-  def testmethod
-    render template: 'layouts/render', layout: false
-    respond_to do |format|
-      format.turbo_stream { render template: 'layouts/render', layout: false }
+
+  def turbo_stream_save(
+    save_action,
+    redirect_on_success_to: nil,
+    object: nil,
+    id: 'form', # if nil: no partial is rendered
+    partial: nil, # default: same like ID
+    action: 'replace',
+    locals: {},
+    streams_on_success: [
+      {
+        id: nil,
+        partial: 'form',
+        locals: {},
+        action: 'replace'
+      }
+    ],
+    streams_on_error: [
+      {
+        id: nil,
+        partial: 'form',
+        locals: {},
+        action: 'replace'
+      }
+    ],
+    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 } : nil)]
+
+    if save_action
+      response.status = 200
+      streams += streams_on_success.select { |s| s[:id].present? }
+    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 action_name == 'create'
+                        [format(I18n.t('activerecord.success.successfully_created'), model_name: model_name)]
+                      elsif action_name == 'update'
+                        [format(I18n.t('activerecord.success.successfully_updated'), model_name: model_name)]
+                      end
+      flash_alerts = []
+    else
+      flash_alerts = if flashes_on_error.present?
+                       flashes_on_error
+                     elsif action_name == 'create'
+                       [format(I18n.t('activerecord.errors.messages.could_not_create'), model_name: model_name)]
+                     elsif action_name == 'update'
+                       [format(I18n.t('activerecord.errors.messages.could_not_update'), model_name: model_name)]
+                     end
+      flash_notices = []
+    end
+    flash_notices += add_flash_notices
+    flash_alerts += add_flash_alerts
+    _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|
+      # 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|
+      # 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 && redirect_on_success_to.present?
+      response.status = 302
+      flash[:alert] = flash_alerts
+      flash[:notice] = flash_notices
+      if request.format.to_sym == :turbo_stream
+        render template: 'render_turbo_stream_redirect', locals: { url: redirect_on_success_to }, layout: false
+      else
+        render json: { redirected_to: redirect_on_success_to }
+      end
+    else
+      flash.now[:alert] = flash_alerts
+      flash.now[:notice] = flash_notices
+      stream_partials(streams)
+    end
+  end
+
+  def stream_partials(array)
+
+    ary = []
+    array.dup.each do |props|
+      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)
+    end
+
+    if request.format.to_sym == :turbo_stream
+      render template: 'render_turbo_stream_partials', locals: { streams: ary }, layout: false
+    else
+      check = {}
+      ary.each do |a|
+        b = a.dup
+        b.delete(:id)
+        check[a[:id]] = b
+      end
+      render json: check
+    end
+  end
+
+  def stream_partial(
+    id,
+    partial: nil, #=> default: id
+    action: :replace,
+    locals: {}
+  )
+    stream_partials(
+      [
+        {
+          id: id,
+          partial: partial,
+          action: action,
+          locals: locals
+        }
+      ]
+    )
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: render_turbo_stream
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.12
 platform: ruby
 authors:
 - christian
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-15 00:00:00.000000000 Z
+date: 2023-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -24,7 +24,10 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 7.0.4.3
-description: 'NOT USABLE AS GEM see: Homepage / README'
+description: 'Writing views like (create|update).turbo_stream.haml annoyed me. This
+  gem handles translated flash messages, set status and renders turbo-stream partials.
+  You can steer your turbo-stream partials directly from the contoller. It also handles
+  redirection: turbo_power is included.'
 email:
 - christian@sedlmair.ch
 executables: []
@@ -33,7 +36,11 @@ extra_rdoc_files: []
 files:
 - README.md
 - Rakefile
+- app/controllers/render_turbo_stream/application_controller.rb
+- app/views/render_turbo_stream_partials.turbo_stream.erb
+- app/views/render_turbo_stream_redirect.turbo_stream.erb
 - lib/render_turbo_stream.rb
+- lib/render_turbo_stream/engine.rb
 - lib/render_turbo_stream/railtie.rb
 - lib/render_turbo_stream/version.rb
 - lib/tasks/render_turbo_stream_tasks.rake
@@ -62,5 +69,5 @@ requirements: []
 rubygems_version: 3.4.12
 signing_key:
 specification_version: 4
-summary: 'NOT USABLE AS GEM see: Homepage / README'
+summary: Rendering turbo-stream partials directly from controller
 test_files: []