mime_actor 0.6.2 → 0.6.3.alpha

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a448d97c462d23aa41abbbad40c1e2ba0a6336c0069e12dd905b18c7cfeee435
-  data.tar.gz: 3e7ee33e33138d37ef29ac4fa30d6b8284ca3fcb69dfd187b599be6a556aa963
+  metadata.gz: 5221de8b1d1149a88de730ab8e6c6c764a22e7067b9e57b6265ce801c671ce3f
+  data.tar.gz: e98f9d6f3e5a8aa04f16cf77921edad0b4a61893ddb3c019157885079462fcde
 SHA512:
-  metadata.gz: d1284b778dc593f3a674a8c8de22d9b10d15eb46fa1e47025c091a0103701eb38426e2fdc0951960cfcac02de8587e9d63b9fde5267a44cebf3606cd4d58bb44
-  data.tar.gz: 65f832e20fc1eeb9a2b6da8e37eb49041697afd66695a91998c65fd16942c915e2c2d4adb870d094858cc7fcb7dbd7849f25d229686849c57e8c98ef0904abcd
+  metadata.gz: 9f6ce7e70ab30a4be726f346beb517c8036c95a1d516c3012d9ed62723a14c130d4af05cdf3695244f5fcb56d33f83cf719369ead9d05eabeba89e5335de1f3a
+  data.tar.gz: 90e8ca69ac9ff99e9813c1dac19bc0826893f106968bb6c6684201a84523b13ab9df225fd597daf96379825080f9164ecfb19a6f7b48c8eabf217e5411654530

data/lib/mime_actor/action.rb

@@ -2,9 +2,10 @@
 
 # :markup: markdown
 
+require "mime_actor/callbacks"
+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"
@@ -25,9 +26,9 @@ module MimeActor
     include AbstractController::Rendering # required by MimeResponds
     include ActionController::MimeResponds
 
+    include Callbacks
     include Scene
     include Stage
-    include Rescue
     include Logging
 
     # The core logic where rendering logics are collected as `Proc` and passed over to `ActionController::MimeResponds`
@@ -55,7 +56,11 @@ module MimeActor
 
       respond_to do |collector|
         formats.each do |format, actor|
-          dispatch = -> { cue_actor(actor.presence || "#{action}_#{format}", action:, format:) }
+          dispatch = lambda do
+            run_act_callbacks(format) do
+              cue_actor(actor.presence || "#{action}_#{format}", action:, format:)
+            end
+          end
           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)
+
+        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) }

data/lib/mime_actor/stage.rb

@@ -2,9 +2,9 @@
 
 # :markup: markdown
 
-require "mime_actor/errors"
 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 +17,7 @@ module MimeActor
   module Stage
     extend ActiveSupport::Concern
 
+    include Rescue
     include Logging
 
     included do
@@ -76,37 +77,21 @@ module MimeActor
     # @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
+      dispatcher = MimeActor::Dispatcher.build(actor, *args)
+      raise TypeError, "invalid actor, got: #{actor.inspect}" unless dispatcher
 
-      result = dispatch_actor(dispatch, action:, format:)
+      result = dispatcher.call(self)
       if block_given?
         yield result
       else
         result
       end
-    end
-
-    private
-
-    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
-      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:, 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,8 +14,8 @@ module MimeActor
   module VERSION
     MAJOR = 0
     MINOR = 6
-    BUILD = 2
-    PRE   = nil
+    BUILD = 3
+    PRE   = "alpha"
 
     STRING = [MAJOR, MINOR, BUILD, PRE].compact.join(".")
   end

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.alpha
 platform: ruby
 authors:
 - Ryan Chang
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-07-21 00:00:00.000000000 Z
+date: 2024-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -71,6 +71,7 @@ files:
 - 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