mime_actor 0.6.4.alpha → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42ba1c04632b3b7ec4c1f1d9c1ab60571eac9e4c44272601d28dccbb45b535d0
-  data.tar.gz: 4d0ccbdba192617231ae0405580921e337412d3de9f63106ff772d33ab0d4208
+  metadata.gz: c90519d1f76ba2e87980b02d88bffdf6dfe0ae9bb133df9bda76d52d2b98e2e3
+  data.tar.gz: fb54fdf81e39bcaa79ca0099ca8b8ecbfef7411558ae3e3b0e359c902e8dce96
 SHA512:
-  metadata.gz: e8fa8dc7c8d8438a1dff0a7bed147f0603000e7491b2e3e8a70173acd9d71f65628390cc7778d50de084940aaafd56684a347b59da5a872ce485361398d0743d
-  data.tar.gz: 3c87a2ce45ec35aa56786e4fd625a3b689a27aba728d7207c5b3c0cf893afb936c5f944d0408d5ca0149267f46902c7c27ff65845397c9ddccfff12d55233a48
+  metadata.gz: 932b2de2863e2883093320d99a1c5e9b6545c1bb8c9d8c7f18e909b5608eee0acdca9286ccc594800dde39353fa5b5d92e7f1e6a95f07bc2dcb608eb60ceb695
+  data.tar.gz: f393a918ebac5edcae4d0de280f32e40152fedf1dcf2f717217387993f5d491bb64384333022a851dccf33b1786741bae19253cbf5d788d48bc23e189888b19d

data/COMPARE.md

@@ -56,18 +56,18 @@ end
 #### before
 ```rb
 class EventsController < ActionController::Base
-    def index
-        @events = Event.all
-        respond_to do |format|
-            format.html do
-                @event_categories = EventCategory.all
-
-                # render html using @events and @event_categories
-                render :index 
-            end
-            format.json { render json: @events } # render json using #as_json
-        end
+  def index
+    @events = Event.all
+    respond_to do |format|
+      format.html do
+        @event_categories = EventCategory.all
+
+        # render html using @events and @event_categories
+        render :index 
+      end
+      format.json { render json: @events } # render json using #as_json
     end
+  end
 end
 ```
 #### after
@@ -75,21 +75,21 @@ end
 class EventsController < ActionController::Base
   include MimeActor::Action
 
-  before_act -> { @events = Event.all }, action: :index
+  act_before -> { @events = Event.all }, action: :index
 
   # dynamically defines the action method according to on: argument
-  respond_act_to :html, :json, on: :index
+  act_on_action :index, format: %i[html json]
 
-  def index_html
-      @event_categories = EventCategory.all
-      
-      # render html using @events and @event_categories
-      render :index
-  end
+  act_after :render_index_html, action: :index, format: :html
+  act_after -> { render json: @events }, action: :index, format: :json
 
-  def index_json
-      # render json using #as_json
-      render json: @events
+  def index
+    @event_categories = EventCategory.all
+  end
+  
+  def render_index_html
+    # render html using @events and @event_categories
+    render :index
   end
 end
 ```
@@ -145,28 +145,36 @@ end
 class EventsController < ActionController::Base
   include MimeActor::Action
 
-  before_act :load_event, action: %i[show update]
+  act_before :load_event, action: %i[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
+  act_on_action :show, :update, format: :html
+  act_on_action :show, :update, format: :json, with: -> { render json: @event } # render json using #as_json
 
-  rescue_act_from ActiveRecord::RecordNotFound, format: :json, with: :handle_json_error
+  act_after :render_show_html, action: :show, format: :html
+  act_after :redirect_to_show, action: :update, format: :html
 
+  rescue_act_from ActiveRecord::RecordNotFound, format: :json, with: :handle_json_error
   rescue_act_from ActiveRecord::RecordNotFound, format: :html, action: :show do
     redirect_to events_path
   end
+  rescue_act_from ActiveRecord::RecrodNotSaved, format: :html, action: :update, with: -> { render :edit }
+
+  def show
+    # ...
+  end
+
+  def update
+    # ...
+  end
 
   private
-  
-  def show_html
+
+  def render_show_html
     render :show # render html using @event
   end
 
-  def update_html
-    # ...
+  def redirect_to_show
     redirect_to event_path(@event.id) # redirect to show upon sucessful update
-  rescue ActiveRecord::RecordNotFound
-    render :edit
   end
 
   def handle_json_error(error)

data/README.md

@@ -1,4 +1,4 @@
-# Mime Actor
+# mime_actor
 
 [![Version][rubygems_badge]][rubygems]
 [![CI][ci_badge]][ci_workflows]
@@ -29,47 +29,151 @@ However, it can be a litte bit messy when some actions render more than a single
 ## Usage
 
 **Mime Actor** allows you to do something like:
+
+#### Customize Action for certain MIME type
 ```rb
-class EventsController < ActionController::Base
-  include MimeActor::Action
+  act_on_action :index, :show, format: %i[html json]
+  act_on_action :create, format: :json
+
+  def index
+    @events = Event.all
+  end
+  def show
+    @event = Event.find(params[:id])
+  end
+  def create
+    @event = Event.new.save!
+  end
+```
+The above is equivalent to the following:
+```rb
+  def index
+    respond_to do |format|
+      format.html { @events = Event.all }
+      format.json { @events = Event.all }
+    end
+  end
+  def show
+    respond_to do |format|
+      format.html { @event = Event.find(params[:id]) }
+      format.json { @event = Event.find(params[:id]) }
+    end
+  end
+  def create
+    respond_to do |format|
+      format.json { @event = Event.new.save! }
+    end
+  end
+```
 
-  before_act -> { @events = Event.all }, action: :index
-  before_act :load_event, action: %i[show update]
-  before_act -> { @event_categories = EventCategory.all }, action: :show, format: :html
+#### Callback registration for certain Action + MIME type
+```rb
+  act_before :load_event_categories, action: :index, format: :html
 
-  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 } }
+  act_on_action :index, :show, format: %i[html json]
 
-  rescue_act_from ActiveRecord::RecordNotFound, format: :json, with: :handle_json_error
-  rescue_act_from ActiveRecord::RecordNotFound, format: :html, action: :show, with: -> { redirect_to "/events" }
+  def index
+    @events = Event.all
+  end
 
-  private
+  def show
+    @event = Event.find(params[:id])
+  end
 
-  def update_html
-    # ...
-    redirect_to "/events/#{@event.id}" # redirect to show upon sucessful update
-  rescue ActiveRecord::RecordNotFound
-    render html: :edit
+  def load_event_categories
+    @event_categories = EventCategory.all
+  end
+```
+The above is equivalent to the following:
+```rb
+  def index
+    respond_to do |format|
+      format.html do 
+        load_event_categories
+        @events = Event.all
+      end
+      format.json { @events = Event.all }
+    end
   end
 
-  def update_json
+  def show
+    respond_to do |format|
+      format.html { @event = Event.find(params[:id]) }
+      format.json { @event = Event.find(params[:id]) }
+    end
+  end
+
+  def load_event_categories
+    @event_categories = EventCategory.all
+  end
+```
+
+#### Rescue handler registration for certain Action + MIME type
+```rb
+  act_before :load_event, action: %i[show update]
+
+  act_on_action :show, :update, format: :json
+  act_on_action :show, format: :html
+
+  rescue_act_from ActiveRecord::RecordNotFound, ActiveRecord::RecordNotSaved, format: :json, with: :handle_json_error
+  rescue_act_from ActiveRecord::RecordNotSaved, action: :show, format: :html, with: -> { redirect_to "/events" }
+  rescue_act_from ActiveRecord::RecordNotSaved, action: :update, format: :html, with: -> { render :edit }
+
+  def show
     # ...
-    render json: @event # render with #to_json
   end
 
-  def render_html
-    render html: action_name
+  def update
+    @event.name = params[:name]
+    @event.save!
+    redirect_to "/events/#{@event.id}"
   end
 
   def load_event
-    @event = Event.find(params.require(:event_id))
+    @event = Event.find(params[:id])
+  end
+
+  def handle_json_error(error)
+    render status: :bad_request, json: { error: error.message }
+  end
+```
+The above is equivalent to the following:
+```rb
+  before_action :load_event, only: %i[show update]
+
+  rescue_from ActiveRecord::RecordNotFound, with: :handle_not_found_error
+  rescue_from ActiveRecord::RecordNotSaved, with: :handle_not_saved_error
+
+  def show
+    respond_to do |format|
+      format.html { ... }
+      format.json { ... }
+    end
+  end
+
+  def update
+    @event.name = params[:name]
+    @event.save!
+    redirect_to "/events/#{@event.id}"
+  end
+
+  def handle_not_found_error(error)
+    respond_to do |format|
+      format.html { redirect_to "/events" }
+      format.json { handle_json_error(error) }
+    end
+  end
+
+  def handle_not_saved_error(error)
+    respond_to do |format|
+      format.html { render :edit }
+      format.json { handle_json_error(error) }
+    end
   end
 
   def handle_json_error(error)
     render status: :bad_request, json: { error: error.message }
   end
-end
 ```
 
 ## Features
@@ -87,7 +191,8 @@ You can find the documentation on [RubyDoc][doc_mime_actor].
 ## Requirements
 
 - Ruby: MRI 3.1+
-- Rails: 5.0+
+- ActiveSupport: 7.0+
+- ActionPack: 7.0+
 
 ## Installation
 

data/lib/mime_actor/action.rb

@@ -7,8 +7,6 @@ require "mime_actor/scene"
 require "mime_actor/stage"
 
 require "active_support/concern"
-require "active_support/core_ext/module/attribute_accessors"
-require "active_support/core_ext/object/blank"
 require "active_support/lazy_load_hooks"
 require "abstract_controller/rendering"
 require "action_controller/metal/mime_responds"
@@ -30,37 +28,46 @@ module MimeActor
     include Stage
     include Logging
 
-    included do
-      mattr_accessor :actor_delegator, instance_writer: false, default: ->(action, format) { "#{action}_#{format}" }
-    end
-
     # The core logic where rendering logics are collected as `Proc` and passed over to `ActionController::MimeResponds`
     #
+    # @param block the block to be evaluated
+    #
     # @example process `create` action
     #   # it uses AbstractController#action_name to process
-    #   start_scene
+    #   start_scene { create_internal }
     #
     #   # it is equivalent to the following if `create` action is configured with `html` and `json` formats
     #   def create
     #     respond_to |format|
-    #       format.html { public_send(:create_html) }
-    #       format.json { public_send(:create_json) }
+    #       format.html { create_internal }
+    #       format.json { create_internal }
     #     end
     #   end
     #
-    def start_scene
+    def start_scene(&block)
       action = action_name.to_sym
       formats = acting_scenes.fetch(action, {})
 
       if formats.empty?
-        logger.warn { "format is empty for action: #{action_name.inspect}" }
-        return
+        logger.warn { "no format found for action: #{action_name.inspect}" }
+        yield if block_given?
+      else
+        respond_to_scene(action, formats, block)
       end
+    end
+
+    private
 
+    def respond_to_scene(action, formats, block)
       respond_to do |collector|
         formats.each do |format, actor|
-          callable = actor.presence || actor_delegator.call(action, format)
-          dispatch = -> { cue_actor(callable, format:) }
+          callable = actor.presence || block
+          if callable.nil?
+            logger.warn { "no #respond_to handler found for action: #{action.inspect} format: #{format.inspect}" }
+            next
+          end
+
+          dispatch = -> { cue_actor(callable, action, format, action:, format:) }
           collector.public_send(format, &dispatch)
         end
       end

data/lib/mime_actor/callbacks.rb

@@ -5,18 +5,24 @@
 require "mime_actor/validator"
 
 require "active_support/callbacks"
+require "active_support/code_generator"
 require "active_support/concern"
-require "active_support/core_ext/array/wrap"
-require "active_support/core_ext/object/blank"
+require "active_support/core_ext/module/attr_internal"
 
 module MimeActor
   # # MimeActor Callbacks
   #
   # MimeActor provides hooks during the life cycle of an act. Available callbacks are:
   #
-  # - before_act
-  # - around_act
-  # - after_act
+  # - append_act_before
+  # - append_act_around
+  # - append_act_after
+  # - act_before
+  # - act_around
+  # - act_after
+  # - prepend_act_before
+  # - prepend_act_around
+  # - prepend_act_after
   #
   # NOTE: Calling the same callback multiple times will overwrite previous callback definitions.
   #
@@ -27,19 +33,25 @@ module MimeActor
     include MimeActor::Validator
 
     included do
+      attr_internal_reader :act_action, :act_format
       define_callbacks :act, skip_after_callbacks_if_terminated: true
-
-      %i[before after around].each { |kind| define_act_callbacks(kind) }
+      generate_act_callback_methods
     end
 
     module ClassMethods
-      class ActionMatcher
-        def initialize(actions)
-          @actions = Array.wrap(actions).to_set(&:to_s)
+      class ActMatcher
+        attr_reader :actions, :formats
+
+        def initialize(actions, formats)
+          @actions = actions&.then { |a| Array(a).to_set(&:to_sym) }
+          @formats = formats&.then { |f| Array(f).to_set(&:to_sym) }
         end
 
         def match?(controller)
-          @actions.include?(controller.action_name)
+          matched = true
+          matched &= actions.include?(controller.act_action) if !actions.nil? && controller.respond_to?(:act_action)
+          matched &= formats.include?(controller.act_format) if !formats.nil? && controller.respond_to?(:act_format)
+          matched
         end
 
         alias after  match?
@@ -47,154 +59,123 @@ module MimeActor
         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?
+        options[:if] = ActMatcher.new(actions, formats) unless actions.nil? && formats.nil?
         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
+          yield callback, options
         end
       end
 
       def validate_callback_options!(action, format)
-        validate!(:action_or_actions, action) if action.present?
-        validate!(:format_or_formats, format) if format.present?
+        validate!(:action_or_actions, action) unless action.nil?
+        validate!(:format_or_formats, format) unless format.nil?
       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
-        )
+      def generate_act_callback_methods
+        ActiveSupport::CodeGenerator.batch(singleton_class, __FILE__, __LINE__) do |owner|
+          %i[before after around].each do |kind|
+            generate_act_callback_kind(owner, kind)
+          end
+        end
+        # as: check against the defined method in owner, code only generated after #batch block is yielded
+        ActiveSupport::CodeGenerator.batch(singleton_class, __FILE__, __LINE__) do |owner|
+          %i[before after around].each do |kind|
+            owner.define_cached_method(:"act_#{kind}", as: :"append_act_#{kind}", namespace: :mime_callbacks)
+          end
+        end
+      end
+
+      def generate_act_callback_kind(generator, kind)
+        generator.define_cached_method(:"append_act_#{kind}", namespace: :mime_callbacks) do |batch|
+          batch.push(
+            "def append_act_#{kind}(*callbacks, action: nil, format: nil, &block)",
+            "validate_callback_options!(action, format)",
+            "configure_callbacks(callbacks, action, format, block) do |callback, options|",
+            "set_callback(:act, :#{kind}, callback, options)",
+            "end",
+            "end"
+          )
+        end
+        generator.define_cached_method(:"prepend_act_#{kind}", namespace: :mime_callbacks) do |batch|
+          batch.push(
+            "def prepend_act_#{kind}(*callbacks, action: nil, format: nil, &block)",
+            "validate_callback_options!(action, format)",
+            "configure_callbacks(callbacks, action, format, block) do |callback, options|",
+            "set_callback(:act, :#{kind}, callback, options.merge!(prepend: true))",
+            "end",
+            "end"
+          )
+        end
       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
+    #   act_before :my_act_before_one
+    #   act_before :my_act_before_two, action: :create
+    #   act_before :my_act_before_three
     #
-    #   around_act :my_around_act_one
-    #   around_act :my_around_act_two, action: :create
-    #   around_act :my_around_act_three
+    #   act_around :my_act_around_one
+    #   act_around :my_act_around_two, action: :create
+    #   act_around :my_act_around_three
     #
-    #   after_act :my_after_act_one
-    #   after_act :my_after_act_two, action: :create
-    #   after_act :my_after_act_three
+    #   act_after :my_act_after_one
+    #   act_after :my_act_after_two, action: :create
+    #   act_after :my_act_after_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
+    #   # - my_act_before_one
+    #   # - my_act_before_two
+    #   # - my_act_before_three
+    #   # - my_act_around_one
+    #   # - my_act_around_two
+    #   # - my_act_around_three
+    #   # - my_act_after_three
+    #   # - my_act_after_two
+    #   # - my_act_after_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
+    #   act_before :my_act_before_one
+    #   act_before :my_act_before_two, action: :create
+    #   act_before :my_act_before_three, action: :create, format: :html
+    #   act_before :my_act_before_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
+    #   act_around :my_act_around_one
+    #   act_around :my_act_around_two, action: :create, format: :html
+    #   act_around :my_act_around_three, action: :create
+    #   act_around :my_act_around_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
+    #   act_after :my_act_after_one, format: :html
+    #   act_after :my_act_after_two
+    #   act_after :my_act_after_three, action: :create
+    #   act_after :my_act_after_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
+    #   # - my_act_before_one
+    #   # - my_act_before_two
+    #   # - my_act_before_four
+    #   # - my_act_before_three
+    #   # - my_act_around_one
+    #   # - my_act_around_two
+    #   # - my_act_around_three
+    #   # - my_act_around_four
+    #   # - my_act_after_four
+    #   # - my_act_after_three
+    #   # - my_act_after_two
+    #   # - my_act_after_one
     #
-    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
+    def run_act_callbacks(action:, format:)
+      @_act_action = action.to_sym
+      @_act_format = format.to_sym
+
+      run_callbacks :act do
+        yield if block_given?
       end
     end
   end

data/lib/mime_actor/deprecator.rb

@@ -6,16 +6,6 @@ require "active_support/deprecation"
 
 module MimeActor
   def self.deprecator
-    @deprecator ||= ActiveSupport::Deprecation.new("0.7.0", "MimeActor")
+    @deprecator ||= ActiveSupport::Deprecation.new("0.8.0", "MimeActor")
   end
 end
-
-[
-  [MimeActor::Rescue::ClassMethods, { rescue_actor: "use #rescue_actor instance method" }],
-  [MimeActor::Scene::ClassMethods, { act_on_format: :respond_act_to }],
-  [MimeActor::Stage::ClassMethods, { actor?: "no longer supported, use Object#respond_to?" }],
-  [MimeActor::Stage::ClassMethods, { dispatch_cue: "no longer support anonymous proc with rescue" }],
-  [MimeActor::Stage::ClassMethods, { dispatch_act: "no longer support anonymous proc with rescue" }]
-].each do |klazz, *args|
-  MimeActor.deprecator.deprecate_methods(klazz, *args)
-end

data/lib/mime_actor/errors.rb

@@ -39,9 +39,9 @@ module MimeActor
     end
   end
 
-  class ActionExisted < ActionError
+  class ActionNotImplemented < ActionError
     def generate_message
-      "action #{action.inspect} already existed"
+      "action #{action.inspect} not implemented"
     end
   end
 end

data/lib/mime_actor/logging.rb

@@ -2,9 +2,12 @@
 
 # :markup: markdown
 
+# required by active_support/tagged_logging
+require "active_support/version"
+require "active_support/isolated_execution_state" if ActiveSupport::VERSION::MAJOR >= 7
+
 require "active_support/concern"
 require "active_support/configurable"
-require "active_support/isolated_execution_state" # required by active_support/logger
 require "active_support/logger"
 require "active_support/tagged_logging"
 
@@ -18,7 +21,14 @@ module MimeActor
     include ActiveSupport::Configurable
 
     included do
-      config_accessor :logger, default: ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new($stdout))
+      default_logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new($stdout))
+      if ActiveSupport::VERSION::MAJOR >= 7
+        config_accessor :logger, default: default_logger
+      else
+        config_accessor :logger do
+          default_logger
+        end
+      end
     end
 
     private

data/lib/mime_actor/railtie.rb

@@ -5,7 +5,7 @@
 module MimeActor
   class Railtie < Rails::Railtie
     initializer "mime_actor.deprecator", before: :load_environment_config do |app|
-      app.deprecators[:mime_actor] = MimeActor.deprecator
+      app.deprecators[:mime_actor] = MimeActor.deprecator if Rails::VERSION::MAJOR >= 7
     end
   end
 end

data/lib/mime_actor/rescue.rb

@@ -6,9 +6,7 @@ require "mime_actor/dispatcher"
 require "mime_actor/validator"
 
 require "active_support/concern"
-require "active_support/core_ext/array/wrap"
 require "active_support/core_ext/module/attribute_accessors"
-require "active_support/core_ext/object/blank"
 require "active_support/core_ext/string/inflections"
 
 module MimeActor
@@ -47,13 +45,13 @@ module MimeActor
       #
       def rescue_act_from(*klazzes, action: nil, format: nil, with: nil, &block)
         raise ArgumentError, "error filter is required" if klazzes.empty?
-        raise ArgumentError, "provide either with: or a block" unless with.present? ^ block_given?
+        raise ArgumentError, "provide either with: or a block" unless !with.nil? ^ block_given?
 
-        validate!(:callable, with) if with.present?
+        validate!(:callable, with) unless with.nil?
         with = block if block_given?
 
-        validate!(:action_or_actions, action) if action.present?
-        validate!(:format_or_formats, format) if format.present?
+        validate!(:action_or_actions, action) unless action.nil?
+        validate!(:format_or_formats, format) unless format.nil?
 
         klazzes.each do |klazz|
           validate!(:klazz, klazz)
@@ -63,72 +61,6 @@ module MimeActor
           actor_rescuers << [error, format, action, with]
         end
       end
-
-      # Resolve the error provided with the registered handlers.
-      #
-      # The handled error will be returned to indicate successful handling.
-      #
-      # @param error the error instance to rescue
-      # @param action the `action` filter
-      # @param format the `format` filter
-      # @param context the context to evaluate for rescue handler
-      # @param visited the errors to skip after no rescue handler matched the filter
-      #
-      def rescue_actor(error, action: nil, format: nil, context: self, visited: [])
-        return if visited.include?(error)
-
-        visited << error
-        if (rescuer = dispatch_rescuer(error, format:, action:, context:))
-          rescuer.call(error, format, action)
-          error
-        elsif error&.cause
-          rescue_actor(error.cause, format:, action:, context:, visited:)
-        end
-      end
-
-      private
-
-      def dispatch_rescuer(error, format:, action:, context:)
-        case rescuer = find_rescuer(error, format:, action:)
-        when Symbol
-          rescuer_method = context.method(rescuer)
-          lambda do |*args|
-            passable_args = rescuer_method.arity.negative? ? args : args.take(rescuer_method.arity)
-            rescuer_method.call(*passable_args)
-          end
-        when Proc
-          lambda do |*args|
-            passable_args = rescuer.arity.negative? ? args : args.take(rescuer.arity)
-            context.instance_exec(*passable_args, &rescuer)
-          end
-        end
-      end
-
-      def find_rescuer(error, format:, action:)
-        return unless error
-
-        *_, rescuer = actor_rescuers.reverse_each.detect do |rescuee, format_filter, action_filter|
-          next if action_filter.present? && !Array.wrap(action_filter).include?(action)
-          next if format_filter.present? && !Array.wrap(format_filter).include?(format)
-          next unless (klazz = constantize_rescuee(rescuee))
-
-          error.is_a?(klazz)
-        end
-        rescuer
-      end
-
-      def constantize_rescuee(class_or_name)
-        case class_or_name
-        when String, Symbol
-          begin
-            const_get(class_or_name)
-          rescue NameError
-            class_or_name.safe_constantize
-          end
-        else
-          class_or_name
-        end
-      end
     end
 
     # Resolve the error provided with the registered handlers.
@@ -159,8 +91,8 @@ module MimeActor
       return unless error
 
       *_, rescuer = actor_rescuers.reverse_each.detect do |rescuee, format_filter, action_filter|
-        next if action_filter.present? && !Array.wrap(action_filter).include?(action)
-        next if format_filter.present? && !Array.wrap(format_filter).include?(format)
+        next unless action_filter.nil? || Array(action_filter).include?(action)
+        next unless format_filter.nil? || Array(format_filter).include?(format)
         next unless (klazz = constantize_rescuee(rescuee))
 
         error.is_a?(klazz)

data/lib/mime_actor/scene.rb

@@ -5,36 +5,29 @@
 require "mime_actor/errors"
 require "mime_actor/validator"
 
+require "active_support/code_generator"
 require "active_support/concern"
-require "active_support/core_ext/array/wrap"
 require "active_support/core_ext/module/attribute_accessors"
-require "active_support/core_ext/object/blank"
 
 module MimeActor
   # # MimeActor Scene
   #
   # Scene provides configuration for `action` + `format` definitions
   #
-  # @example register a `html` format on action `index`
-  #   respond_act_to :html, on: :index
+  # @example register a `html` format on action `create`
+  #   act_on_action :create, format: :html
   #
-  #   # this method should be defined in the class
-  #   def index_html; end
   # @example register `html`, `json` formats on actions `index`, `show`
-  #   respond_act_to :html, :json , on: [:index, :show]
+  #   act_on_action :index, :show, format: [:html, :json]
   #
-  #   # these methods should be defined in the class
-  #   def index_html; end
-  #   def index_json; end
-  #   def show_html; end
-  #   def show_json; end
   # @example register a `html` format on action `index` with respond handler method
-  #   respond_act_to :html, on: :index, with: :render_html
+  #   act_on_action :index, format: :html, with: :render_html
   #
-  #   # this method should be defined in the class
-  #   def render_html; end
-  # @example register a `html` format on action `index` with respond handler proc
-  #   respond_act_to :html, on: :index do
+  # @example register a `html` format on action `index` with respond handler Proc
+  #   act_on_action :index, format: :html, with: -> { render html: "<h1>my header</h1>" }
+  #
+  # @example register a `html` format on action `index` with respond handler block
+  #   act_on_action :html, on: :index do
   #     render :index
   #   end
   #
@@ -52,78 +45,87 @@ module MimeActor
     module ClassMethods
       # Register `action` + `format` definitions.
       #
-      # @param formats the collection of `format`
-      # @param on the collection of `action`
-      # @param with the respond handler when `block` is not provided
-      # @param block the `block` to evaluate when `with` is not provided
+      # @param action a collection of `action`
+      # @param format a single `format` or a collection of `format`
+      # @param with the respond handler for the given `action` + `format`
+      # @param block the `block` to be yieled for the given `action` + `format`
       #
-      # @example register a `html` format on action `index`
-      #   respond_act_to :html, on: :index
+      # @example register a `html` format on action `create`
+      #   act_on_action :create, format: :html
       #
-      #   # this method should be defined in the class
-      #   def index_html; end
+      #   # an action method will be defined in the class
+      #   def indexl; end
       # @example register `html`, `json` formats on actions `index`, `show`
-      #   respond_act_to :html, :json , on: [:index, :show]
+      #   act_on_action :index, :show, format: [:html, :json]
       #
-      #   # these methods should be defined in the class
-      #   def index_html; end
-      #   def index_json; end
-      #   def show_html; end
-      #   def show_json; end
+      #   # these action methods will be defined in the class
+      #   def index; end
+      #   def show; end
       # @example register a `html` format on action `index` with respond handler method
-      #   respond_act_to :html, on: :index, with: :render_html
+      #   act_on_action :index, format: :html, with: :render_html
       #
-      #   # this method should be defined in the class
+      #   # an action method will be defined in the class
+      #   # the handler method will be called by the action method.
+      #   def index; end
+      #   # the given method should be defined in the class
       #   def render_html; end
-      # @example register a `html` format on action `index` with respond handler proc
-      #   respond_act_to :html, on: :index do
+      # @example register a `html` format on action `index` with respond handler Proc
+      #   act_on_action :index, format: :html, with: -> { render html: "<h1>my header</h1>" }
+      #
+      #   # an action method will be defined in the class,
+      #   # the handler Proc will be called by the action method.
+      #   def index; end
+      # @example register a `html` format on action `index` with respond handler block
+      #   act_on_action :html, on: :index do
       #     render :index
       #   end
       #
-      # For each unique `action` being registered, it will have a corresponding `action` method being defined.
-      def respond_act_to(*formats, on: nil, with: nil, &block)
-        validate!(:formats, formats)
-
-        raise ArgumentError, "provide either with: or a block" if with.present? && block_given?
-
-        validate!(:callable, with) if with.present?
+      #   # an action method will be defined in the class
+      #   def index; end
+      #
+      # For each unique `action` being registered, a corresponding `action` method will be defined.
+      def act_on_action(*actions, format:, with: nil, &block)
+        raise ArgumentError, "format is required" if format.nil?
+        raise ArgumentError, "provide either with: or a block" if !with.nil? && block_given?
+
+        validate!(:actions, actions)
+        validate!(:format_or_formats, format)
+        validate!(:callable, with) unless with.nil?
         with = block if block_given?
 
-        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) }
+        actions.each do |action|
+          acting_scenes[action] ||= {}
+          Array(format).each do |action_format|
+            acting_scenes[action][action_format] = with
+          end
         end
-      end
 
-      # TODO: remove on next breaking change release
-      alias act_on_format respond_act_to
+        generate_action_methods(actions)
+      end
 
       private
 
-      def compose_scene(action, format, actor)
-        action_defined = (instance_methods + private_instance_methods).include?(action.to_sym)
-        raise MimeActor::ActionExisted, action if !acting_scenes.key?(action) && action_defined
-
-        acting_scenes[action] ||= {}
-        acting_scenes[action][format] = actor
-
-        define_scene(action) unless action_defined
+      def generated_action_methods
+        @generated_action_methods ||= Module.new.tap { |mod| prepend mod }
       end
 
-      def define_scene(action)
-        module_eval(
-          # def index
-          #   self.respond_to?(:start_scene) && self.start_scene
-          # end
-          <<-RUBY, __FILE__, __LINE__ + 1
-            def #{action}
-              self.respond_to?(:start_scene) && self.start_scene
+      def generate_action_methods(actions)
+        ActiveSupport::CodeGenerator.batch(generated_action_methods, __FILE__, __LINE__) do |owner|
+          actions.each do |action|
+            owner.define_cached_method(action, namespace: :mime_scene) do |batch|
+              batch.push(
+                "def #{action}",
+                "if respond_to?(:start_scene)",
+                "start_scene { raise #{MimeActor::ActionNotImplemented}, :#{action} unless defined?(super); super } ",
+                "else",
+                "raise #{MimeActor::ActionNotImplemented}, :#{action} unless defined?(super)",
+                "super",
+                "end",
+                "end"
+              )
             end
-          RUBY
-        )
+          end
+        end
       end
     end
   end

data/lib/mime_actor/stage.rb

@@ -26,50 +26,6 @@ module MimeActor
       mattr_accessor :raise_on_actor_error, instance_writer: false, default: false
     end
 
-    module ClassMethods
-      # Determine if the `actor_name` belongs to a public instance method excluding methods inherited from ancestors
-      #
-      # @param actor_name
-      #
-      def actor?(actor_name)
-        # exclude public methods from ancestors
-        found = public_instance_methods(false).include?(actor_name.to_sym)
-        # exclude private methods from ancestors
-        if !found && private_instance_methods(false).include?(actor_name.to_sym)
-          logger.debug { "actor must be public method, #{actor_name} is private method" }
-        end
-        found
-      end
-
-      # Wraps the given `block` with a `lambda`, rescue any error raised from the `block`.
-      # Otherwise, error will be re-raised.
-      #
-      # @param action the `action` to be passed on to `rescue_actor`
-      # @param format the `format` to be passed on to `rescue_actor`
-      # @param context the context for the block evaluation
-      # @param block the `block` to be evaluated
-      #
-      # @example Dispatch a cue that prints out a text
-      #   dispatch = self.class.dispatch_act(action: :create, format: :json, context: self) do
-      #       puts "completed the dispatch"
-      #   end
-      #
-      #   dispatch.call == "completed the dispatch" # true
-      #
-      def dispatch_act(action: nil, format: nil, context: self, &block)
-        raise ArgumentError, "block must be provided" unless block_given?
-
-        lambda do
-          context.instance_exec(&block)
-        rescue StandardError => e
-          (respond_to?(:rescue_actor) && rescue_actor(e, action:, format:, context:)) || raise
-        end
-      end
-
-      # TODO: remove on next breaking change release
-      alias dispatch_cue dispatch_act
-    end
-
     # Calls the `actor` and passing arguments to it.
     # If a block is given, the result from the `actor` method will be yieled to the block.
     #
@@ -78,13 +34,13 @@ 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, format:)
+    def cue_actor(actor, *args, action:, format:)
       dispatcher = MimeActor::Dispatcher.build(actor, *args)
       raise TypeError, "invalid actor, got: #{actor.inspect}" unless dispatcher
 
       self.class.validate!(:format, format)
 
-      run_act_callbacks(format) do
+      run_act_callbacks(action:, format:) do
         result = dispatcher.call(self)
         block_given? ? yield(result) : result
       end
@@ -92,7 +48,7 @@ module MimeActor
       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 = rescue_actor(e, action:, format:)
       rescued || raise
     end
   end

data/lib/mime_actor/validator.rb

@@ -49,6 +49,8 @@ module MimeActor
       #
       # @param unchecked the `actions` to be validated
       def validate_actions(unchecked)
+        return TypeError.new("actions must not be empty") if unchecked.empty?
+
         rejected = unchecked.reject { |action| action.is_a?(Symbol) }
         NameError.new("invalid actions, got: #{rejected.map(&:inspect).join(", ")}") if rejected.size.positive?
       end
@@ -73,6 +75,8 @@ module MimeActor
       #
       # @param unchecked the `formats` to be validated
       def validate_formats(unchecked)
+        return TypeError.new("formats must not be empty") if unchecked.empty?
+
         unfiltered = unchecked.to_set
         filtered = unfiltered & scene_formats
         rejected = unfiltered - filtered

data/lib/mime_actor/version.rb

@@ -13,9 +13,9 @@ module MimeActor
 
   module VERSION
     MAJOR = 0
-    MINOR = 6
-    BUILD = 4
-    PRE   = "alpha"
+    MINOR = 7
+    BUILD = 0
+    PRE   = nil
 
     STRING = [MAJOR, MINOR, BUILD, PRE].compact.join(".")
   end

metadata

@@ -1,57 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: mime_actor
 version: !ruby/object:Gem::Version
-  version: 0.6.4.alpha
+  version: 0.7.0
 platform: ruby
 authors:
 - Ryan Chang
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-07-25 00:00:00.000000000 Z
+date: 2024-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '11.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '11.0'
+        version: '7.0'
 description: ''
 email:
 - ryancyq@gmail.com
@@ -91,9 +77,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="