respond_for_helper 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7f17979b8269d9fad0e710e0f593e6688477368e32a8d229f4ca8aeda7058e9
-  data.tar.gz: 7995b1e3ae788d7332f4cf3885a78946ad1980731e89cb7a2658e88608aba35c
+  metadata.gz: 605ea6e5b57890e065931756614d979f3f131a6581525622feb96d51c56dc91b
+  data.tar.gz: d7bd4702e2a3a0986b19b18361e39c24a8be69472e4c6f594ba51dae3971a3a0
 SHA512:
-  metadata.gz: d87eb932d5b4b2e7f9cbe8a5d9630a7633c40827bd6596b907e5094d801f685ed86d43b895be7564702547edb10b4f87ea91e9a4a509ee6b174be0bb45244c12
-  data.tar.gz: 33a6df7945b5d6acd9cf5da7bb50b3376533eb3746c669f4a4e2f31ee25a8dbfde5fa04cb5b92ee269d840e622e24fd8de817c48897a3431d8fdaa58ba6241dd
+  metadata.gz: ea3adad9460730c33cc318cdebe611c7ce76199241e5c83d6d6c885fdc665070aeabafefc7f1cfb5c4d2d8490c096a73d62a69a05423219e56cf35b10403b899
+  data.tar.gz: a57499b403d33f4e844f73ce0faf495954922d4d21848ee3bf3dac69e7b62ffb5ef92d652149827b4269f346043e75a96f5e6293adbd23d6cf0b9f88622ae94d

data/.github/workflows/ci.yml

@@ -8,23 +8,37 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [2.3, 2.4, 2.5, 2.6, 2.7, 3.0]
-        gemfile: ['rails50', 'rails51', 'rails52', 'rails60', 'rails61']
+        ruby: [2.3, 2.4, 2.5, 2.6, 2.7, '3.0', 3.1]
+        gemfile: ['rails50', 'rails51', 'rails52', 'rails60', 'rails61', 'rails70']
         exclude:
           - ruby: 2.3
             gemfile: rails60
           - ruby: 2.3
             gemfile: rails61
+          - ruby: 2.3
+            gemfile: rails70
           - ruby: 2.4
             gemfile: rails60
           - ruby: 2.4
             gemfile: rails61
+          - ruby: 2.4
+            gemfile: rails70
+          - ruby: 2.5
+            gemfile: rails70
+          - ruby: 2.6
+            gemfile: rails70
           - ruby: 3.0
             gemfile: rails50
           - ruby: 3.0
             gemfile: rails51
           - ruby: 3.0
             gemfile: rails52
+          - ruby: 3.1
+            gemfile: rails50
+          - ruby: 3.1
+            gemfile: rails51
+          - ruby: 3.1
+            gemfile: rails52
 
     name: ruby ${{ matrix.ruby }}, ${{ matrix.gemfile }}
 

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # CHANGELOG
 
+## 1.1.0
+
+* Add `formats` option to `respond_for`.
+* Add `status` and `failure_status` option to `respond_for`.
+* Support `any` and `turbo_stream` format.
+* Make `RespondForHelper.config` more configurable.
+`formats` option is renamed with `formatters` and introduce new `formats` option.
+`default_behaviours` is renamed with `behaviours` and all of its configuration values are changed.
+* The block of `respond_for` now takes format option like `respond_to`.
+If you want to call some process after respond, use `after_success` callback instead.
+
+## 1.0.2
+
+* Change redirect status to 303 (see other).
+
+## 1.0.1
+
+* Fix render status.
+
 ## 1.0.0
 
 * First release.

data/README.md

@@ -37,10 +37,21 @@ end
 ```
 
 this action is succeeded when `@item.errors` is empty, otherwise this action is failed.
-This action returns html or json corresponding to the request format.
+This action returns html, json or any data corresponding to the request format.
 
 `respond_for` allows some options as follows:
 
+```ruby
+# Always success without checking error existence.
+respond_for @item, success: true
+
+# Enable or disable some formats.
+respond_for @item, html: true, json: true, any: false
+
+```
+
+`respond_for` also supports short options for html format:
+
 ```ruby
 # Specify redirect location when succeeded.
 # The value should be one of string, symbol (action name) or proc.
@@ -55,13 +66,29 @@ respond_for @item, notice: 'Create was succceeded'
 
 # Specify alert message when failed.
 respond_for @item, alert: 'Create was failed'
+```
 
-# Always success without checking error existence.
-respond_for @item, success: true
+`respond_for` also supports block like `respond_to`:
 
-# Block is called when succeeded.
-respond_for @item do
-  puts "succeeded"
+```ruby
+# Use full-customized behaviour.
+respond_for @item do |format, respond|
+  if respond.success?
+    format.html { redirect_to action: :index }
+  else
+    format.html { redirect_to action: :show }
+  end
+end
+```
+
+You can use callbacks like `after_success` or `after_failure` in the block.
+Note that the callbacks are called after running respond behaviours like `render` or `redirect`:
+
+```ruby
+# Set callbacks running after respond.
+respond_for @item do |format, respond|
+  respond.after_success { puts "succeeded" }
+  respond.after_failure { puts "failed" }
 end
 ```
 
@@ -100,16 +127,16 @@ you can use `respond_for_message` as follows:
 ```ruby
 class ItemsController < ActionController::Base
   def create
-    respond_for_mesasge :notice
+    respond_for_message :notice
     #=> Successfully created (2021-01-01 10:00)
 
-    respond_for_mesasge :notice, success_num: 10
+    respond_for_message :notice, success_num: 10
     #=> Successfully created (10 succeeded) (2021-01-01 10:00)
 
-    respond_for_mesasge :notice, action_name: :update
+    respond_for_message :notice, action_name: :update
     #=> Successfully updated (2021-01-01 10:00)
 
-    respond_for_mesasge :alert
+    respond_for_message :alert
     #=> Failed to create (2021-01-01 10:00)
   end
 end
@@ -140,20 +167,23 @@ For example:
 
 ```ruby
 RespondForHelper.configure do |config|
-  config.default_behaviours = {
-    template: {},
-    location: {},
-    failure_template: { create: :new, update: :edit, destroy: :show, _default: :show },
-    failure_location: { _default: :show }
+  config.behaviours = {
+    html: {
+      index: { render: :index },
+      show: { render: :show },
+      create: {
+        success: { redirect: :index, status: :see_other, flash: :notice },
+        failure: { render: :new, status: :unprocessable_entity, flash: :alert }
+      }
+    }
   }
 end
 ```
 
-`template` and `location` is used when current action is succeeded,
-while `failure_template` and `failure_location` is used when current action is failed.
-All of them contains action name mapping:
-the key of mapping is a current action and the value of mapping is a next action after succeeded or failed.
-`_default` is a common action which is applied to all of actions which have not specific mapping.
+`html` is a request format.
+`index`, `show`, `create` is a action name of your controller.
+`success` is used when current action is succeeded, while `failure` is used when current action is failed.
+All of them contains default behaviours which are defined as `render`, `redirect` or `head`.
 
 #### Controller-specific behaviours
 
@@ -161,41 +191,45 @@ You can also customize controller-specific behaviours:
 
 ```ruby
 class ItemsController < ActionController::Base
-  self.respond_for_behaviours = {
-    location: { _default: :show }
+  self.respond_for_config = {
+    html: {
+      create: {
+        success: { redirect: :show }
+      }
+    }
   }
 end
 ```
 
-The way of setting is same as `config.default_behaviours`.
+The way of setting is same as `config.behaviours`.
 
 #### Format processors
 
-you can also set your own format processors as you like:
+You can also set your own format processors as you like:
 
 ```ruby
 RespondForHelper.configure do |config|
-  config.formats = {
+  config.formats = [:html, :json, :any]
+  config.formatters = {
     html: RespondForHelper::Formats::Html,
-    json: RespondForHelper::Formats::Json
+    json: RespondForHelper::Formats::Json,
+    any: RespondForHelper::Formats::Any
   }
-  config.flash = RespondForHelper::Flashes::Timestamp
 end
 ```
 
 Format processors should be extended by `RespondForHelper::Formats::Base`.
 
-you can also set your own flash message generators:
+You can also set your own flash message generators:
 
 ```ruby
 RespondForHelper.configure do |config|
-  config.flash = RespondForHelper::Flashes::Timestamp
+  config.flasher = RespondForHelper::Flashes::Timestamp
 end
 ```
 
 Flash message generators should be extended by `RespondForHelper::Flashes::Base`.
 
-
 ## Contributing
 
 Bug reports and pull requests are welcome at https://github.com/kanety/respond_for_helper.

data/gemfiles/rails60.gemfile

@@ -1,5 +1,6 @@
 source 'https://rubygems.org'
 
 gem "rails", "~> 6.0.0"
+gem "psych", "~> 3.3.0"
 
 gemspec path: "../"

data/gemfiles/rails70.gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem "rails", "~> 7.0.1"
+
+gemspec path: "../"

data/lib/respond_for_helper/behaviour.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module RespondForHelper
+  class Behaviour
+    TYPES = [:render, :redirect, :head]
+
+    attr_accessor :type, :target, :flash, :options
+
+    def initialize(attrs)
+      @type = attrs.delete(:type)
+      @target = attrs.delete(:target)
+      @flash = attrs.delete(:flash)
+      @options = attrs
+    end
+
+    def render?
+      @type == :render
+    end
+
+    def redirect?
+      @type == :redirect
+    end
+
+    def head?
+      @type == :head
+    end
+
+    def flash?
+      @flash
+    end
+  end
+
+  class Behaviours
+    def initialize(controller, format, result, options)
+      @controller = controller
+      @format = format
+      @result = result
+      @options = options
+
+      @controller_behaviours = @controller.respond_for_config.fetch(:behaviours, {})
+      @default_behaviours = Config.behaviours
+    end
+
+    def call
+      behaviour = Behaviour.new(resolve_attributes)
+
+      if @format == :html
+        merge_html_options(behaviour)
+      end
+
+      behaviour
+    end
+
+    private
+
+    def resolve_attributes
+      keys1 = [@format, @controller.action_name.to_sym, @result]
+      keys2 = [@format, @controller.action_name.to_sym]
+      keys3 = [@format, :_default, @result]
+      keys4 = [@format, :_default]
+
+      attrs = {}
+      attrs.merge!(resolve_attributes_for(@default_behaviours, [keys1, keys2, keys3, keys4]))
+      attrs.merge!(resolve_attributes_for(@controller_behaviours, [keys1, keys2, keys3, keys4]))
+      attrs.merge!(resolve_attributes_for(@options, [[@format, @result], [@format]]))
+      attrs.empty? ? { type: :redirect, target: :index } : attrs
+    end
+
+    def resolve_attributes_for(behaviours, keys_list)
+      keys_list.each do |keys|
+        if (attrs = behaviours.dig(*keys))
+          attrs = attrs.deep_dup
+          Behaviour::TYPES.each do |type|
+            if attrs[type]
+              attrs[:type] = type
+              attrs[:target] = attrs.delete(type)
+            end
+          end
+          return attrs
+        end
+      end
+      {}
+    end
+
+    def merge_html_options(behaviour)
+      if @result == :success
+        if @options[:template]
+          change_to_render(behaviour) if behaviour.type != :render
+          behaviour.target = @options[:template]
+        end
+        if @options[:location]
+          change_to_redirect(behaviour) if behaviour.type != :redirect
+          behaviour.target = @options[:location]
+        end
+        if @options[:status]
+          behaviour.options[:status] = @options[:status]
+        end
+      else
+        if @options[:failure_template]
+          change_to_render(behaviour) if behaviour.type != :render
+          behaviour.target = @options[:failure_template]
+        end
+        if @options[:failure_location]
+          change_to_redirect(behaviour) if behaviour.type != :redirect
+          behaviour.target = @options[:failure_location]
+        end
+        if @options[:failure_status]
+          behaviour.options[:status] = @options[:failure_status]
+        end
+      end
+    end
+
+    def change_to_render(behaviour)
+      behaviour.type = :render
+      behaviour.options[:status] = @result == :success ? :ok : :unprocessable_entity
+    end
+
+    def change_to_redirect(behaviour)
+      behaviour.type = :redirect
+      behaviour.options[:status] = :see_other
+    end
+  end
+end

data/lib/respond_for_helper/config.rb

@@ -5,18 +5,66 @@ module RespondForHelper
     class_attribute :data
 
     self.data = {
-      flash: RespondForHelper::Flashes::Timestamp,
-      formats: {
+      formats: [:html, :json],
+      formatters: {
+        turbo_stream: RespondForHelper::Formats::TurboStream,
         html: RespondForHelper::Formats::Html,
-        json: RespondForHelper::Formats::Json
+        json: RespondForHelper::Formats::Json,
+        any: RespondForHelper::Formats::Any
       },
-      default_behaviours: {
-        template: {},
-        location: {},
-        failure_template: { create: :new, update: :edit, destroy: :show, _default: :show },
-        failure_location: { _default: :show }
-      },
-      member_actions: [:show, :edit, :update, :destroy]
+      flasher: RespondForHelper::Flashes::Timestamp,
+      behaviours: {
+        turbo_stream: {
+          _default: {
+            success: { render: -> { action_name.to_sym }, status: :ok },
+            failure: { render: -> { action_name.to_sym }, status: :unprocessable_entity }
+          }
+        },
+        html: {
+          index: { render: :index },
+          show: { render: :show },
+          create: {
+            success: { redirect: :index, status: :see_other, flash: :notice },
+            failure: { render: :new, status: :unprocessable_entity, flash: :alert }
+          },
+          update: {
+            success: { redirect: :index, status: :see_other, flash: :notice },
+            failure: { render: :edit, status: :unprocessable_entity, flash: :alert }
+          },
+          destroy: {
+            success: { redirect: :index, status: :see_other, flash: :notice },
+            failure: { render: :show, status: :unprocessable_entity, flash: :alert }
+          },
+          _default: {
+            success: { redirect: :index, status: :see_other, flash: :notice },
+            failure: { render: :show, status: :unprocessable_entity, flash: :alert }
+          }
+        },
+        json: {
+          index: { render: :item },
+          show: { render: :item },
+          create: {
+            success: { render: :item, status: :created },
+            failure: { render: :item_errors, status: :unprocessable_entity }
+          },
+          update: {
+            success: { render: :item, status: :ok },
+            failure: { render: :item_errors, status: :unprocessable_entity }
+          },
+          destroy: {
+            success: { head: :no_content },
+            failure: { head: :unprocessable_entity }
+          },
+          _default: {
+            success: { render: :item, status: :ok },
+            failure: { render: :item_errors, status: :unprocessable_entity }
+          }
+        },
+        any: {
+          index: { render: :index },
+          show: { render: :show }
+        }
+      }
     }
 
     data.keys.each do |key|

data/lib/respond_for_helper/controller.rb

@@ -5,19 +5,26 @@ module RespondForHelper
     extend ActiveSupport::Concern
 
     def respond_for(item, options = {})
-      klass = Config.formats[request.format.to_sym] || Config.formats[:html]
-      formatter = klass.new(self, item, options)
-      formatter.call
-      yield if block_given? && formatter.succeeded?
+      respond = Respond.new(self, item, options)
+      respond_to do |format|
+        yield(format, respond) if block_given?
+        respond.formatters.each do |formatter|
+          format.send(formatter.format) { formatter.call }
+        end
+        respond.run_before_callbacks
+      end
+      respond.run_after_callbacks
     end
 
     def respond_for_message(type, options = {})
+      klass = Lookups::Flash.new(self, options).call
       options = options.reverse_merge(controller_path: controller_path, action_name: action_name)
-      Config.flash.new(type, options).call
+      klass.new(type, options).call
     end
 
     included do
-      class_attribute :respond_for_behaviours
+      class_attribute :respond_for_config
+      self.respond_for_config = {}
     end
   end
 end

data/lib/respond_for_helper/formats/any.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RespondForHelper
+  module Formats
+    class Any < Html
+      self.format = :any
+    end
+  end
+end

data/lib/respond_for_helper/formats/base.rb

@@ -3,37 +3,58 @@
 module RespondForHelper
   module Formats
     class Base
-      attr_reader :controller
-      delegate :request, :respond_to, :render, :head, :redirect_to, :flash, :url_for, :action_name, to: :controller
+      class_attribute :format
+
+      attr_reader :controller, :item, :format, :result, :behaviour
+      delegate :request, :render, :head, :redirect_to, :flash, :url_for, :action_name, to: :controller
 
       def initialize(controller, item, options)
         @controller = controller
         @item = item
         @options = options
+
+        @format = self.class.format.to_sym
+        @result = @options[:success] ? :success : :failure
+        @behaviour = Behaviours.new(@controller, @format, @result, @options).call
       end
 
       def call
-        respond do
-          if respond_to?("_#{action_name}", true)
-            send("_#{action_name}")
-          else
-            default_action
-          end
+        if respond_to?("_#{action_name}", true)
+          send("_#{action_name}")
+        else
+          perform
         end
       end
 
+      private
+
+      def perform
+      end
+
       def succeeded?
-        if @options.key?(:success)
-          @options[:success]
-        else
-          Array(@item).all? { |item| item.errors.blank? }
-        end
+        @result == :success
       end
 
-      def respond
+      def resolve_target(target)
+        if target.respond_to?(:call)
+          @controller.instance_exec(&target)
+        elsif target.is_a?(Symbol)
+          if respond_to?(target)
+            send(target)
+          elsif @behaviour.redirect?
+            resolve_url(target)
+          else
+            target
+          end
+        else
+          target
+        end
       end
 
-      def default_action
+      def resolve_url(target)
+        url_for(action: target)
+      rescue ActionController::UrlGenerationError
+        url_for(action: target, id: @item)
       end
     end
   end

data/lib/respond_for_helper/formats/html.rb

@@ -3,84 +3,40 @@
 module RespondForHelper
   module Formats
     class Html < Base
-      def respond
-        respond_to do |format|
-          format.html { yield }
-        end
-      end
-
-      def _index
-        render @options[:template] || :index
-      end
+      self.format = :html
 
-      def _show
-        render @options[:template] || :show
-      end
+      private
 
-      def default_action
-        if succeeded?
-          render_or_redirect(:template, :location, :notice)
-        else
-          render_or_redirect(:failure_template, :failure_location, :alert)
+      def perform
+        if @behaviour.render?
+          perform_render
+        elsif @behaviour.redirect?
+          perform_redirect
         end
-      end
 
-      def render_or_redirect(template_key, location_key, type)
-        behaviour = resolve_behaviour(template_key, location_key)
-        if behaviour[0] == :template
-          message = resolve_flash(type)
-          flash.now[type] = message if message
-          render resolve_template(behaviour[1]), status: :unprocessable_entity
-        else
-          message = resolve_flash(type)
-          flash[type] = message if message
-          redirect_to resolve_location(behaviour[1])
+        if @behaviour.flash? && !request.xhr?
+          perform_flash
         end
       end
 
-      def resolve_flash(type)
-        return if request.xhr?
-        @controller.respond_for_message(type, @options)
+      def perform_render
+        render resolve_target(@behaviour.target), @behaviour.options
       end
 
-      def resolve_behaviour(template_key, location_key)
-        [ [:template, @options[template_key]],
-          [:location, @options[location_key]],
-          [:template, behaviour_config(template_key)],
-          [:location, behaviour_config(location_key)]
-        ].each do |behaviour|
-          return behaviour if behaviour[1].present?
-        end
-        [:location, url_for(action: :index)]
+      def perform_redirect
+        redirect_to resolve_target(@behaviour.target), @behaviour.options
       end
 
-      def behaviour_config(key)
-        [@controller.class.respond_for_behaviours, Config.default_behaviours].each do |behaviours|
-          behaviour = behaviours&.dig(key, action_name.to_sym) || behaviours&.dig(key, :_default)
-          return behaviour if behaviour
-        end
-        return nil
-      end
-
-      def resolve_template(template)
-        if template.respond_to?(:call)
-          @controller.instance_exec(&template)
-        else
-          template
-        end
+      def perform_flash
+        key = @behaviour.flash
+        flash_content[key] = @controller.respond_for_message(key, @options)
       end
 
-      def resolve_location(location)
-        if location.respond_to?(:call)
-          @controller.instance_exec(&location)
-        elsif location.is_a?(Symbol)
-          if location.in?(Config.member_actions)
-            url_for(action: location, id: @item)
-          else
-            url_for(action: location)
-          end
-        else
-          location
+      def flash_content
+        if @behaviour.render?
+          flash.now
+        elsif @behaviour.redirect?
+          flash
         end
       end
     end

data/lib/respond_for_helper/formats/json.rb

@@ -3,50 +3,28 @@
 module RespondForHelper
   module Formats
     class Json < Base
-      def respond
-        respond_to do |format|
-          format.json { yield }
-        end
-      end
-
-      def _index
-        render json: @item
-      end
+      self.format = :json
 
-      def _show
-        render json: @item
+      def item_errors
+        @item.errors
       end
 
-      def _create
-        if succeeded?
-          render json: @item, status: :created
-        else
-          render json: @item.errors, status: :unprocessable_entity
-        end
-      end
+      private
 
-      def _update
-        if succeeded?
-          render json: @item, status: :ok
-        else
-          render json: @item.errors, status: :unprocessable_entity
+      def perform
+        if @behaviour.render?
+          perform_render
+        elsif @behaviour.head?
+          perform_head
         end
       end
 
-      def _destroy
-        if succeeded?
-          head :no_content
-        else
-          head :unprocessable_entity
-        end
+      def perform_render
+        render @behaviour.options.merge(json: resolve_target(@behaviour.target))
       end
 
-      def default_action
-        if succeeded?
-          render json: @item, status: :ok
-        else
-          render json: @item.errors, status: :unprocessable_entity
-        end
+      def perform_head
+        head resolve_target(@behaviour.target), @behaviour.options
       end
     end
   end

data/lib/respond_for_helper/formats/turbo_stream.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RespondForHelper
+  module Formats
+    class TurboStream < Html
+      self.format = :turbo_stream
+    end
+  end
+end

data/lib/respond_for_helper/lookups/flash.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RespondForHelper
+  module Lookups
+    class Flash
+      def initialize(controller, options)
+        @controller = controller
+        @options = options
+
+        @controller_config = @controller.class.respond_for_config
+      end
+
+      def call
+        if @controller_config[:flasher]
+          @controller_config[:flasher]
+        else
+          Config.flasher
+        end
+      end
+    end
+  end
+end

data/lib/respond_for_helper/lookups/format.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RespondForHelper
+  module Lookups
+    class Format
+      def initialize(controller, options)
+        @controller = controller
+        @options = options
+
+        @controller_config = @controller.class.respond_for_config
+      end
+
+      def call
+        formats = adjust_formats(resolve_formats.deep_dup)
+        formatters = resolve_formatters
+        formatters.select { |format, _| formats.include?(format) }.to_h
+      end
+
+      private
+
+      def resolve_formats
+        if @options[:formats]
+          Array(@options[:formats])
+        elsif @controller_config[:formats]
+          Array(@controller_config[:formats])
+        else
+          Config.formats
+        end
+      end
+
+      def adjust_formats(formats)
+        Config.formatters.keys.each do |format|
+          if @options[format] == true
+            @options.delete(format)
+            formats.unshift(format)
+          elsif @options[format] == false
+            @options.delete(format)
+            formats.delete(format)
+          end
+        end
+        formats
+      end
+
+      def resolve_formatters
+        if @controller_config[:formatters]
+          Array(@controller_config[:formatters])
+        else
+          Config.formatters
+        end
+      end
+    end
+  end
+end

data/lib/respond_for_helper/respond.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RespondForHelper
+  class Respond
+    def initialize(controller, item, options)
+      @controller = controller
+      @item = item
+      @options = options
+
+      unless @options.key?(:success)
+        @options[:success] = Array(item).all? { |item| item.errors.blank? }
+      end
+
+      @callbacks = {}
+    end
+
+    def success?
+      @options[:success]
+    end
+
+    def before_success(&block)
+      @callbacks[:before_success] ||= []
+      @callbacks[:before_success] << block
+    end
+
+    def before_failure(&block)
+      @callbacks[:before_failure] ||= []
+      @callbacks[:before_failure] << block
+    end
+
+    def after_success(&block)
+      @callbacks[:after_success] ||= []
+      @callbacks[:after_success] << block
+    end
+
+    def after_failure(&block)
+      @callbacks[:after_failure] ||= []
+      @callbacks[:after_failure] << block
+    end
+
+    def run_before_callbacks
+      if success?
+        run_callbacks_for(:before_success)
+      else
+        run_callbacks_for(:before_failure)
+      end
+    end
+
+    def run_after_callbacks
+      if success?
+        run_callbacks_for(:after_success)
+      else
+        run_callbacks_for(:after_failure)
+      end
+    end
+
+    def run_callbacks_for(name)
+      if @callbacks[name]
+        @callbacks[name].each do |callback|
+          callback.call
+        end
+      end
+    end
+
+    def formatters
+      Lookups::Format.new(@controller, @options).call.map do |_, klass|
+        klass.new(@controller, @item, @options)
+      end
+    end
+  end
+end

data/lib/respond_for_helper/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RespondForHelper
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/lib/respond_for_helper.rb

@@ -4,10 +4,16 @@ require 'active_support/all'
 
 require 'respond_for_helper/formats/base'
 require 'respond_for_helper/formats/html'
+require 'respond_for_helper/formats/turbo_stream'
 require 'respond_for_helper/formats/json'
+require 'respond_for_helper/formats/any'
 require 'respond_for_helper/flashes/base'
 require 'respond_for_helper/flashes/timestamp'
 require 'respond_for_helper/config'
+require 'respond_for_helper/lookups/format'
+require 'respond_for_helper/lookups/flash'
+require 'respond_for_helper/behaviour'
+require 'respond_for_helper/respond'
 require 'respond_for_helper/controller'
 require 'respond_for_helper/helper'
 require 'respond_for_helper/railtie' if defined?(Rails)

data/respond_for_helper.gemspec

@@ -24,4 +24,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec-rails"
   spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "webrick"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: respond_for_helper
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Yoshikazu Kaneta
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-09-21 00:00:00.000000000 Z
+date: 2022-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A rails helper for responding request format
 email:
 - kaneta@sitebridge.co.jp
@@ -116,18 +130,25 @@ files:
 - gemfiles/rails52.gemfile
 - gemfiles/rails60.gemfile
 - gemfiles/rails61.gemfile
+- gemfiles/rails70.gemfile
 - lib/respond_for_helper.rb
+- lib/respond_for_helper/behaviour.rb
 - lib/respond_for_helper/config.rb
 - lib/respond_for_helper/controller.rb
 - lib/respond_for_helper/flashes/base.rb
 - lib/respond_for_helper/flashes/timestamp.rb
+- lib/respond_for_helper/formats/any.rb
 - lib/respond_for_helper/formats/base.rb
 - lib/respond_for_helper/formats/html.rb
 - lib/respond_for_helper/formats/json.rb
+- lib/respond_for_helper/formats/turbo_stream.rb
 - lib/respond_for_helper/helper.rb
 - lib/respond_for_helper/locales/en.yml
 - lib/respond_for_helper/locales/ja.yml
+- lib/respond_for_helper/lookups/flash.rb
+- lib/respond_for_helper/lookups/format.rb
 - lib/respond_for_helper/railtie.rb
+- lib/respond_for_helper/respond.rb
 - lib/respond_for_helper/version.rb
 - respond_for_helper.gemspec
 homepage: https://github.com/kanety/respond_for_helper
@@ -148,7 +169,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.3.3
 signing_key: 
 specification_version: 4
 summary: A rails helper for responding request format