mime_actor 0.6.2 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a448d97c462d23aa41abbbad40c1e2ba0a6336c0069e12dd905b18c7cfeee435
-  data.tar.gz: 3e7ee33e33138d37ef29ac4fa30d6b8284ca3fcb69dfd187b599be6a556aa963
+  metadata.gz: c54b7a74eed15ac67b37d8df3879584634955ff4db0275cecc1dd4b7d531ec55
+  data.tar.gz: da797d40d7f90f5c6f8e23b61f2fe1441aef08860c6af5ff1763f49cee15ccaa
 SHA512:
-  metadata.gz: d1284b778dc593f3a674a8c8de22d9b10d15eb46fa1e47025c091a0103701eb38426e2fdc0951960cfcac02de8587e9d63b9fde5267a44cebf3606cd4d58bb44
-  data.tar.gz: 65f832e20fc1eeb9a2b6da8e37eb49041697afd66695a91998c65fd16942c915e2c2d4adb870d094858cc7fcb7dbd7849f25d229686849c57e8c98ef0904abcd
+  metadata.gz: 79eea272d7e8c3b625584eb8ae54790076035b511210302bb948076f54d847f34bb5c1f354d03b5fa319fbcc7c370f4c72a97b806593a732dd6207dfb8b6bbbe
+  data.tar.gz: 387780b44aafbcd60e79b7f9ebedd3c00edc40faa1acdce0c6946aad5787f053ae17ae62cab3ba84f8dd695874074e66ef867f6cfbb79e9ba947ddff837c7baa

data/COMPARE.md

@@ -1,6 +1,6 @@
 ## Comparison in Rails
 
-### MIME Rendering
+### MIME Action
 
 #### before
 ```rb
@@ -22,103 +22,104 @@ end
 #### after
 ```rb
 class EventsController < ActionController::Base
-    include MimeActor::Action
+  include MimeActor::Action
 
-    before_action only: :index { @events = Event.all }
+  before_act -> { @events = Event.all }, action: :index
 
-    # dynamically defines the action method according to on: argument
-    respond_act_to :html, :json, on: :index 
+  # dynamically defines the action method according to on: argument
+  respond_act_to :html, :json, on: :index
 
-    def index_html
-        @event_categories = EventCategory.all
-        
-        # render html using @events and @event_categories
-        render :index
-    end
+  def index_html
+      @event_categories = EventCategory.all
+      
+      # render html using @events and @event_categories
+      render :index
+  end
 
-    def index_json
-        # render json using #as_json
-        render json: @events
-    end
+  def index_json
+      # render json using #as_json
+      render json: @events
+  end
 end
 ```
 
-### MIME Rescuing
+### MIME Rescue
 
 #### before
 ```rb
 class EventsController < ActionController::Base
-    # AbstractController::Callbacks here to load model with params
-    before_action only: [:show, :update] { @event = Event.find(params.require(:event_id)) }
-
-    rescue_from ActiveRecord::RecordNotFound do |ex|
-        case action_name.to_s
-        when "show"
-            respond_to do |format|
-                format.html { redirect_to events_path } # redirect to index
-                format.json { render status: :bad_request, json: { error: ex.message } }
-            end
-        when "update"
-            respond_to do |format|
-                format.html { render :edit }
-                format.json { render status: :bad_request, json: { error: ex.message } }
-            end
-        else
-            raise ex # re-raise since we are not handling it
-        end
+  before_action only: %i[show update], with: :load_event
+
+  rescue_from ActiveRecord::RecordNotFound do |ex|
+    case action_name.to_s
+    when "show"
+      respond_to do |format|
+        format.html { redirect_to events_path } # redirect to index
+        format.json { render status: :bad_request, json: { error: ex.message } }
+      end
+    when "update"
+      respond_to do |format|
+        format.html { render :edit }
+        format.json { render status: :bad_request, json: { error: ex.message } }
+      end
+    else
+      raise ex # re-raise since we are not handling it
     end
+  end
 
-    def show
-        respond_to do |format|
-            format.html { render :show } # render html using @event
-            format.json { render json: @event } # render json using #as_json
-        end
+  def show
+    respond_to do |format|
+      format.html { render :show } # render html using @event
+      format.json { render json: @event } # render json using #as_json
     end
+  end
 
-    def update
-        # ...
-        respond_to do |format|
-            format.html { redirect_to event_path(@event.id)  } # redirect to show upon sucessful update
-            format.json { render json: @event } # render json using #as_json
-        end
+  def update
+    # ...
+    respond_to do |format|
+      format.html { redirect_to event_path(@event.id) } # redirect to show upon sucessful update
+      format.json { render json: @event } # render json using #as_json
     end
+  end
+
+  private
+
+  def load_event
+    @event = Event.find(params.require(:event_id))
+  end
 end
 ```
 #### after
 ```rb
 class EventsController < ActionController::Base
-    include MimeActor::Action
+  include MimeActor::Action
 
-    # AbstractController::Callbacks here to load model with params
-    before_action only: [:show, :update] { @event = Event.find(params.require(:event_id)) }
+  before_action only: %i[show update], with: :load_event
 
-    respond_act_to :html, :json, on: [:show, :update]
+  respond_act_to :html, on: %i[show update]
+  respond_act_to :json, on: %i[show update], with: -> { render json: @event } # render json using #as_json
 
-    rescue_act_from ActiveRecord::RecordNotFound, format: :json do |ex|
-        render status: :bad_request, json: { error: ex.message }
-    end
+  rescue_act_from ActiveRecord::RecordNotFound, format: :json, with: :handle_json_error
 
-    rescue_act_from ActiveRecord::RecordNotFound, format: :html, action: :show do |ex|
-        redirect_to events_path
-    end
+  rescue_act_from ActiveRecord::RecordNotFound, format: :html, action: :show do
+    redirect_to events_path
+  end
 
-    def show_html
-        render :show # render html using @event
-    end
+  private
+  
+  def show_html
+    render :show # render html using @event
+  end
 
-    def update_html
-        redirect_to event_path(@event.id) # redirect to show upon sucessful update
-    rescue ActiveRecord::RecordNotFound
-        render :edit
-    end
-
-    def show_json
-        render json: @event # render json using #as_json
-    end
+  def update_html
+    # ...
+    redirect_to event_path(@event.id) # redirect to show upon sucessful update
+  rescue ActiveRecord::RecordNotFound
+    render :edit
+  end
 
-    def update_json
-        # ...
-        render json: @event # render json using #as_json
-    end
+  def handle_json_error(error)
+    render status: :bad_request, json: { error: error.message }
+  end
 end
 ```

data/README.md

@@ -5,55 +5,51 @@
 [![Coverage][coverage_badge]][coverage]
 [![Maintainability][maintainability_badge]][maintainability]
 
-Action Render + Rescue handlers for different MIME types in Rails
+Action processing with Callback + Rescue handlers for different MIME types in Rails.
 
 ## Usage
 
 MimeActor allows you to do something like below:
 ```rb
 class EventsController < ActionController::Base
-    # AbstractController::Callbacks here to load model with params
-    before_action only: :index { @events = Event.all }
-    before_action only: [:show, :update] { @event = Event.find(params.require(:event_id)) }
-
-    respond_act_to :html, :json, on: :index
-    respond_act_to :html, :json, on: [:show, :update]
-
-    rescue_act_from ActiveRecord::RecordNotFound, format: :json do |ex|
-        render status: :bad_request, json: { error: "Resouce not found" }
-    end
-
-    rescue_act_from ActiveRecord::RecordNotFound, format: :html, action: :show do |ex|
-        redirect_to events_path
-    end
-
-    def index_html
-        @event_categories = EventCategory.all
-        render :index # render html using @events and @event_categories
-    end
-
-    def index_json
-        render json: @events # render json using #as_json
-    end
-
-    def show_html
-        render :show # render html using @event
-    end
-
-    def update_html
-        redirect_to event_path(@event.id) # redirect to show upon sucessful update
-    rescue ActiveRecord::RecordNotFound
-        render :edit
-    end
-
-    def show_json
-        render json: @event # render json using #as_json
-    end
-
-    def update_json
-        # ...
-        render json: @event # render json using #as_json
-    end
+  include MimeActor::Action
+
+  before_act -> { @events = Event.all }, action: :index
+  before_act :load_event, action: %i[show update]
+
+  respond_act_to :html, :json, on: :update
+  respond_act_to :html, on: %i[index show], with: :render_html
+  respond_act_to :json, on: %i[index show], with: -> { render json: { action: action_name } }
+
+  rescue_act_from ActiveRecord::RecordNotFound, format: :json, with: :handle_json_error
+  rescue_act_from ActiveRecord::RecordNotFound, format: :html, action: :show, with: -> { redirect_to "/events" }
+
+  private
+
+  def update_html
+    # ...
+    redirect_to "/events/#{@event.id}" # redirect to show upon sucessful update
+  rescue ActiveRecord::RecordNotFound
+    render html: :edit
+  end
+
+  def update_json
+    # ...
+    render json: @event # render json using #as_json
+  end
+
+  def render_html
+    @event_categories = EventCategory.all if action_name == :index
+    render html: action_name
+  end
+
+  def load_event
+    @event = Event.find(params.require(:event_id))
+  end
+
+  def handle_json_error(error)
+    render status: :bad_request, json: { error: error.message }
+  end
 end
 ```
 

data/lib/mime_actor/action.rb

@@ -2,9 +2,9 @@
 
 # :markup: markdown
 
+require "mime_actor/logging"
 require "mime_actor/scene"
 require "mime_actor/stage"
-require "mime_actor/rescue"
 
 require "active_support/concern"
 require "active_support/core_ext/object/blank"
@@ -17,7 +17,7 @@ module MimeActor
   #
   # `Action` is the recommended `Module` to be included in the `ActionController`.
   #
-  # Provides intuitive way of `action` rendering for a specific MIME type with rescue handlers.
+  # Provides intuitive way of `action` processing for a specific MIME type with callback + rescue handlers.
   #
   module Action
     extend ActiveSupport::Concern
@@ -27,15 +27,13 @@ module MimeActor
 
     include Scene
     include Stage
-    include Rescue
     include Logging
 
     # The core logic where rendering logics are collected as `Proc` and passed over to `ActionController::MimeResponds`
     #
-    # @param action the `action` of the controller
-    #
     # @example process `create` action
-    #   start_scene(:create)
+    #   # it uses AbstractController#action_name to process
+    #   start_scene
     #
     #   # it is equivalent to the following if `create` action is configured with `html` and `json` formats
     #   def create
@@ -45,17 +43,18 @@ module MimeActor
     #     end
     #   end
     #
-    def start_scene(action)
+    def start_scene
+      action = action_name.to_sym
       formats = acting_scenes.fetch(action, {})
 
       if formats.empty?
-        logger.warn { "format is empty for action: #{action.inspect}" }
+        logger.warn { "format is empty for action: #{action_name.inspect}" }
         return
       end
 
       respond_to do |collector|
         formats.each do |format, actor|
-          dispatch = -> { cue_actor(actor.presence || "#{action}_#{format}", action:, format:) }
+          dispatch = -> { cue_actor(actor.presence || "#{action}_#{format}", format:) }
           collector.public_send(format, &dispatch)
         end
       end

data/lib/mime_actor/callbacks.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "mime_actor/validator"
+
+require "active_support/callbacks"
+require "active_support/concern"
+require "active_support/core_ext/array/wrap"
+require "active_support/core_ext/object/blank"
+
+module MimeActor
+  # # MimeActor Callbacks
+  #
+  # MimeActor provides hooks during the life cycle of an act. Available callbacks are:
+  #
+  # - before_act
+  # - around_act
+  # - after_act
+  #
+  # NOTE: Calling the same callback multiple times will overwrite previous callback definitions.
+  #
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    include ActiveSupport::Callbacks
+    include MimeActor::Validator
+
+    included do
+      define_callbacks :act, skip_after_callbacks_if_terminated: true
+
+      %i[before after around].each { |kind| define_act_callbacks(kind) }
+    end
+
+    module ClassMethods
+      class ActionMatcher
+        def initialize(actions)
+          @actions = Array.wrap(actions).to_set(&:to_s)
+        end
+
+        def match?(controller)
+          @actions.include?(controller.action_name)
+        end
+
+        alias after  match?
+        alias before match?
+        alias around match?
+      end
+
+      def callback_chain_name(format = nil)
+        if format.present?
+          validate!(:format, format)
+          :"act_#{format}"
+        else
+          :act
+        end
+      end
+
+      def callback_chain_defined?(name)
+        !!get_callbacks(name)
+      end
+
+      private
+
+      def define_callback_chain(name)
+        return if callback_chain_defined?(name)
+
+        define_callbacks name, skip_after_callbacks_if_terminated: true
+      end
+
+      def configure_callbacks(callbacks, actions, formats, block)
+        options = {}
+        options[:if] = ActionMatcher.new(actions) if actions.present?
+        callbacks.push(block) if block
+
+        formats = Array.wrap(formats)
+        formats << nil if formats.empty?
+
+        callbacks.each do |callback|
+          formats.each do |format|
+            chain = callback_chain_name(format)
+            define_callback_chain(chain)
+            yield chain, callback, options
+          end
+        end
+      end
+
+      def validate_callback_options!(action, format)
+        validate!(:action_or_actions, action) if action.present?
+        validate!(:format_or_formats, format) if format.present?
+      end
+
+      def define_act_callbacks(kind)
+        module_eval(
+          # def self.before_act(*callbacks, action: nil, format: nil, &block)
+          #   validate_callback_options!(action, format)
+          #   configure_callbacks(callbacks, action, format, block) do |chain, callback, options|
+          #     set_callback(chain, :before, callback, options)
+          #   end
+          # end
+          #
+          # def self.prepend_before_act(*callbacks, action: nil, format: nil, &block)
+          #   validate_callback_options!(action, format)
+          #   configure_callbacks(callbacks, action, format, block) do |chain, callback, options|
+          #     set_callback(chain, :before, callback, options.merge!(prepend: true))
+          #   end
+          # end
+          <<-RUBY, __FILE__, __LINE__ + 1
+            def self.#{kind}_act(*callbacks, action: nil, format: nil, &block)
+              validate_callback_options!(action, format)
+              configure_callbacks(callbacks, action, format, block) do |chain, callback, options|
+                set_callback(chain, :#{kind}, callback, options)
+              end
+            end
+
+            def self.prepend_#{kind}_act(*callbacks, action: nil, format: nil, &block)
+              validate_callback_options!(action, format)
+              configure_callbacks(callbacks, action, format, block) do |chain, callback, options|
+                set_callback(chain, :#{kind}, callback, options.merge!(prepend: true))
+              end
+            end
+          RUBY
+        )
+      end
+    end
+
+    # Callbacks invocation sequence depends on the order of callback definition.
+    # (except for callbacks with `format` filter).
+    #
+    # @example callbacks with/without action filter
+    #   before_act :my_before_act_one
+    #   before_act :my_before_act_two, action: :create
+    #   before_act :my_before_act_three
+    #
+    #   around_act :my_around_act_one
+    #   around_act :my_around_act_two, action: :create
+    #   around_act :my_around_act_three
+    #
+    #   after_act :my_after_act_one
+    #   after_act :my_after_act_two, action: :create
+    #   after_act :my_after_act_three
+    #
+    #   # actual sequence:
+    #   # - my_before_act_one
+    #   # - my_before_act_two
+    #   # - my_before_act_three
+    #   # - my_around_act_one
+    #   # - my_around_act_two
+    #   # - my_around_act_three
+    #   # - my_after_act_three
+    #   # - my_after_act_two
+    #   # - my_after_act_one
+    #
+    # @example callbacks with format filter
+    #   before_act :my_before_act_one
+    #   before_act :my_before_act_two, action: :create
+    #   before_act :my_before_act_three, action: :create, format: :html
+    #   before_act :my_before_act_four
+    #
+    #   around_act :my_around_act_one
+    #   around_act :my_around_act_two, action: :create, format: :html
+    #   around_act :my_around_act_three, action: :create
+    #   around_act :my_around_act_four
+    #
+    #   after_act :my_after_act_one, format: :html
+    #   after_act :my_after_act_two
+    #   after_act :my_after_act_three, action: :create
+    #   after_act :my_after_act_four
+    #
+    #   # actual sequence:
+    #   # - my_before_act_one
+    #   # - my_before_act_two
+    #   # - my_before_act_four
+    #   # - my_around_act_one
+    #   # - my_around_act_three
+    #   # - my_around_act_four
+    #   # - my_before_act_three
+    #   # - my_around_act_two
+    #   # - my_after_act_one
+    #   # - my_after_act_four
+    #   # - my_after_act_three
+    #   # - my_after_act_two
+    #
+    def run_act_callbacks(format)
+      action_chain = self.class.callback_chain_name
+      format_chain = self.class.callback_chain_name(format)
+
+      if self.class.callback_chain_defined?(format_chain)
+        run_callbacks action_chain do
+          run_callbacks format_chain do
+            yield if block_given?
+          end
+        end
+      else
+        run_callbacks action_chain do
+          yield if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/mime_actor/dispatcher.rb

@@ -2,6 +2,8 @@
 
 # :markup: markdown
 
+require "mime_actor/errors"
+
 module MimeActor
   module Dispatcher
     class MethodCall
@@ -13,13 +15,12 @@ module MimeActor
         validate!
       end
 
-      def to_callable
-        lambda do |target|
-          throw :abort, method_name unless target.respond_to?(method_name)
-          method_call = target.method(method_name)
-          filtered_args = method_call.arity.negative? ? args : args.take(method_call.arity)
-          method_call.call(*filtered_args)
-        end
+      def call(target)
+        raise MimeActor::ActorNotFound, method_name unless target.respond_to?(method_name, true)
+
+        method_call = target.method(method_name)
+        filtered_args = method_call.arity.negative? ? args : args.take(method_call.arity)
+        method_call.call(*filtered_args)
       end
 
       private
@@ -38,11 +39,9 @@ module MimeActor
         validate!
       end
 
-      def to_callable
-        lambda do |target|
-          filtered_args = block.arity.negative? ? args : args.take(block.arity)
-          target.instance_exec(*filtered_args, &block)
-        end
+      def call(target)
+        filtered_args = block.arity.negative? ? args : args.take(block.arity)
+        target.instance_exec(*filtered_args, &block)
       end
 
       private

data/lib/mime_actor/rescue.rb

@@ -4,7 +4,6 @@
 
 require "mime_actor/dispatcher"
 require "mime_actor/validator"
-require "mime_actor/stage"
 
 require "active_support/concern"
 require "active_support/core_ext/array/wrap"
@@ -23,7 +22,6 @@ module MimeActor
   module Rescue
     extend ActiveSupport::Concern
 
-    include Stage
     include Validator
 
     included do
@@ -51,19 +49,11 @@ module MimeActor
         raise ArgumentError, "error filter is required" if klazzes.empty?
         raise ArgumentError, "provide either the with: argument or a block" unless with.present? ^ block_given?
 
-        if block_given?
-          with = block
-        else
-          validate!(:with, with)
-        end
-
-        if action.present?
-          action.is_a?(Enumerable) ? validate!(:actions, action) : validate!(:action, action)
-        end
+        validate!(:with, with) if with.present?
+        with = block if block_given?
 
-        if format.present?
-          format.is_a?(Enumerable) ? validate!(:formats, format) : validate!(:format, format)
-        end
+        validate!(:action_or_actions, action) if action.present?
+        validate!(:format_or_formats, format) if format.present?
 
         klazzes.each do |klazz|
           validate!(:klazz, klazz)
@@ -156,11 +146,7 @@ module MimeActor
       visited << error
       rescuer = find_rescuer(error, format:, action:)
       if (dispatch = MimeActor::Dispatcher.build(rescuer, error, format, action))
-        dispatched = false
-        result = catch(:abort) do
-          dispatch.to_callable.call(self).tap { dispatched = true }
-        end
-        logger.error { "rescue error, cause: #{result.inspect}" } unless dispatched
+        dispatch.call(self)
         error
       elsif error&.cause
         rescue_actor(error.cause, format:, action:, visited:)

data/lib/mime_actor/scene.rb

@@ -86,20 +86,12 @@ module MimeActor
 
         raise ArgumentError, "provide either the with: argument or a block" if with.present? && block_given?
 
-        if block_given?
-          with = block
-        elsif with.present?
-          validate!(:with, with)
-        end
+        validate!(:with, with) if with.present?
+        with = block if block_given?
 
-        case actions = on
-        when Enumerable
-          validate!(:actions, actions)
-        when Symbol, String
-          validate!(:action, actions)
-        else
-          raise ArgumentError, "action is required"
-        end
+        raise ArgumentError, "action is required" unless (actions = on).present?
+
+        validate!(:action_or_actions, actions)
 
         Array.wrap(actions).each do |action|
           formats.each { |format| compose_scene(action, format, with) }
@@ -124,11 +116,11 @@ module MimeActor
       def define_scene(action)
         module_eval(
           # def index
-          #   self.respond_to?(:start_scene) && self.start_scene(:index)
+          #   self.respond_to?(:start_scene) && self.start_scene
           # end
           <<-RUBY, __FILE__, __LINE__ + 1
             def #{action}
-              self.respond_to?(:start_scene) && self.start_scene(:#{action})
+              self.respond_to?(:start_scene) && self.start_scene
             end
           RUBY
         )

data/lib/mime_actor/stage.rb

@@ -2,9 +2,10 @@
 
 # :markup: markdown
 
-require "mime_actor/errors"
+require "mime_actor/callbacks"
 require "mime_actor/dispatcher"
 require "mime_actor/logging"
+require "mime_actor/rescue"
 
 require "active_support/concern"
 require "active_support/core_ext/module/attribute_accessors"
@@ -17,6 +18,8 @@ module MimeActor
   module Stage
     extend ActiveSupport::Concern
 
+    include Callbacks
+    include Rescue
     include Logging
 
     included do
@@ -75,38 +78,22 @@ module MimeActor
     # @param actor either a method name or a Proc to evaluate
     # @param args arguments to be passed when calling the actor
     #
-    def cue_actor(actor, *args, action:, format:)
-      dispatch = MimeActor::Dispatcher.build(actor, *args)
-      raise TypeError, "invalid actor, got: #{actor.inspect}" unless dispatch
+    def cue_actor(actor, *args, format:)
+      dispatcher = MimeActor::Dispatcher.build(actor, *args)
+      raise TypeError, "invalid actor, got: #{actor.inspect}" unless dispatcher
 
-      result = dispatch_actor(dispatch, action:, format:)
-      if block_given?
-        yield result
-      else
-        result
-      end
-    end
-
-    private
+      self.class.validate!(:format, format)
 
-    def dispatch_actor(dispatch, action:, format:)
-      dispatched = false
-      rescued = false
-      result = catch(:abort) do
-        dispatch.to_callable.call(self).tap { dispatched = true }
-      rescue StandardError => e
-        rescued = respond_to?(:rescue_actor) && rescue_actor(e, action:, format:)
-        raise unless rescued
+      run_act_callbacks(format) do
+        result = dispatcher.call(self)
+        block_given? ? yield(result) : result
       end
-      handle_actor_error(result) unless dispatched || rescued
-      result if dispatched
-    end
-
-    def handle_actor_error(actor)
-      error = MimeActor::ActorNotFound.new(actor)
-      raise error if raise_on_actor_error
-
-      logger.error { "actor error, cause: #{error.inspect}" }
+    rescue MimeActor::ActorNotFound => e
+      logger.error { "actor error, cause: #{e.inspect}" } unless raise_on_actor_error
+      raise e if raise_on_actor_error
+    rescue StandardError => e
+      rescued = rescue_actor(e, action: action_name.to_sym, format: format)
+      rescued || raise
     end
   end
 end

data/lib/mime_actor/validator.rb

@@ -32,7 +32,7 @@ module MimeActor
       # @param rule the name of validator
       def validate!(rule, *args)
         validator = "validate_#{rule}"
-        raise NameError, "Validator not found, got: #{validator.inspect}" unless respond_to?(validator, true)
+        raise NameError, "Validator not found, got: #{validator.inspect}" unless respond_to?(validator)
 
         error = send(validator, *args)
         raise error if error
@@ -53,6 +53,13 @@ module MimeActor
         NameError.new("invalid actions, got: #{rejected.map(&:inspect).join(", ")}") if rejected.size.positive?
       end
 
+      # Validate against `actions` rule if argument is a Enumerable. otherwise, validate against `action` rule.
+      #
+      # @param unchecked the `actions` or `action` to be validated
+      def validate_action_or_actions(unchecked)
+        unchecked.is_a?(Enumerable) ? validate_actions(unchecked) : validate_action(unchecked)
+      end
+
       # Validate `format` must be a Symbol and a valid MIME type
       #
       # @param unchecked the `format` to be validated
@@ -73,6 +80,13 @@ module MimeActor
         NameError.new("invalid formats, got: #{rejected.map(&:inspect).join(", ")}") if rejected.size.positive?
       end
 
+      # Validate against `formats` rule if argument is a Enumerable. otherwise, validate against `format` rule.
+      #
+      # @param unchecked the `formats` or `format` to be validated
+      def validate_format_or_formats(unchecked)
+        unchecked.is_a?(Enumerable) ? validate_formats(unchecked) : validate_format(unchecked)
+      end
+
       # Validate `klazz` must be a Class/Module or a String referencing a Class/Module
       #
       # @param unchecked the `klazz` to be validated

data/lib/mime_actor/version.rb

@@ -14,7 +14,7 @@ module MimeActor
   module VERSION
     MAJOR = 0
     MINOR = 6
-    BUILD = 2
+    BUILD = 3
     PRE   = nil
 
     STRING = [MAJOR, MINOR, BUILD, PRE].compact.join(".")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mime_actor
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.6.3
 platform: ruby
 authors:
 - Ryan Chang
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-07-21 00:00:00.000000000 Z
+date: 2024-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -59,18 +59,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".hound.yml"
-- ".rspec"
-- ".rubocop.yml"
-- ".ruby-version"
-- ".yardopts"
 - COMPARE.md
 - LICENSE
 - README.md
-- Rakefile
-- codecov.yml
 - lib/mime_actor.rb
 - lib/mime_actor/action.rb
+- lib/mime_actor/callbacks.rb
 - lib/mime_actor/dispatcher.rb
 - lib/mime_actor/errors.rb
 - lib/mime_actor/logging.rb
@@ -107,5 +101,6 @@ requirements: []
 rubygems_version: 3.5.9
 signing_key: 
 specification_version: 4
-summary: Action Render + Rescue handlers for different MIME types in Rails
+summary: Action processing with Callback + Rescue handlers for different MIME types
+  in Rails
 test_files: []

data/.hound.yml

@@ -1,2 +0,0 @@
-rubocop:
-  enabled: false

data/.rspec

@@ -1 +0,0 @@
---require spec_helper

data/.rubocop.yml

@@ -1,66 +0,0 @@
-require:
-  - rubocop-rake
-  - rubocop-rspec
-
-AllCops:
-  TargetRubyVersion: 3.1
-  NewCops: enable
-  Exclude:
-    - bin/*
-    - vendor/**/*
-
-Style/Documentation:
-  Enabled: false
-
-Style/BlockComments:
-  Exclude:
-    - spec/*_helper.rb
-
-Style/RegexpLiteral:
-  EnforcedStyle: percent_r
-
-Metrics/AbcSize:
-  Enabled: false
-  
-Metrics/BlockLength:
-  AllowedMethods:
-    - class_methods
-
-Metrics/CyclomaticComplexity:
-  Enabled: false
-
-Metrics/PerceivedComplexity:
-  Enabled: false
-
-Metrics/MethodLength:
-  CountAsOne: ['array', 'heredoc', 'method_call']
-  Max: 15
-
-Style/StringLiterals:
-  EnforcedStyle: double_quotes
-
-Style/StringLiteralsInInterpolation:
-  EnforcedStyle: double_quotes
-
-Style/HashSyntax:
-  EnforcedShorthandSyntax: consistent
-
-Layout/FirstHashElementIndentation:
-  EnforcedStyle: consistent
-
-Layout/HashAlignment:
-  EnforcedHashRocketStyle: table
-  EnforcedColonStyle: table
-
-RSpec/MultipleExpectations:
-  Max: 6
-
-RSpec/ExampleLength:
-  CountAsOne: ['array', 'heredoc', 'method_call']
-  Max: 10
-
-RSpec/MultipleMemoizedHelpers:
-  Max: 10
-
-RSpec/NestedGroups:
-  Max: 5

data/.ruby-version

@@ -1 +0,0 @@
-3.3.1

data/.yardopts

@@ -1,2 +0,0 @@
---markup markdown
-lib/**/*.rb

data/Rakefile

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-
-require "rubocop/rake_task"
-RuboCop::RakeTask.new
-
-require "rspec/core/rake_task"
-RSpec::Core::RakeTask.new(:spec)

data/codecov.yml

@@ -1,18 +0,0 @@
-codecov:
-  notify:
-    wait_for_ci: false
-  require_ci_to_pass: false
-
-coverage:
-  status:
-    project:
-      default:
-        target: 99%
-        threshold: 1%
-    patch:
-      default:
-        target: 99%
-        threshold: 1%
-
-comment:
-  require_changes: true