mime_actor 0.6.4 → 0.7.1

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,117 @@ 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
+      def generate_act_callback_methods
+        ActiveSupport::CodeGenerator.batch(singleton_class, __FILE__, __LINE__) do |owner|
+          %i[before after around].each do |kind|
+            owner.define_cached_method(:"append_act_#{kind}", namespace: :mime_callbacks) do |batch|
+              batch << act_callback_kind_template(kind, append: true)
             end
+            owner.define_cached_method(:"prepend_act_#{kind}", namespace: :mime_callbacks) do |batch|
+              batch << act_callback_kind_template(kind, append: false)
+            end
+          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 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
+      def act_callback_kind_template(kind, append:)
+        type = append ? "append" : "prepend"
+        <<-RUBY
+          def #{type}_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: #{!append}))
             end
-          RUBY
-        )
+          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
+    #   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)