mime_actor 0.6.1.rc1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21ee0c18bb4a165c41bc6f583407eed1c79290dd4e63d99be14165b233b43104
-  data.tar.gz: 9f590546538dacb9f4179168c6e9180fbb012efae5ba7b9c4ba33117316d70bf
+  metadata.gz: a448d97c462d23aa41abbbad40c1e2ba0a6336c0069e12dd905b18c7cfeee435
+  data.tar.gz: 3e7ee33e33138d37ef29ac4fa30d6b8284ca3fcb69dfd187b599be6a556aa963
 SHA512:
-  metadata.gz: dab37a418fb045fe18c19a5c851706eefe558eebf1d8c247703c5248a2f355765981f9ec29c7053ba40b2b3799551340c0dad6c33048c64fca1b947337442346
-  data.tar.gz: 919de90346b9cea32d464aade78ab6aaaa1af5ab87dd473e1347b32595cf1756cae9f1ceaed37278a8deb3f7fe215fd67076b9c3627535c31ba4a1672a5dcd99
+  metadata.gz: d1284b778dc593f3a674a8c8de22d9b10d15eb46fa1e47025c091a0103701eb38426e2fdc0951960cfcac02de8587e9d63b9fde5267a44cebf3606cd4d58bb44
+  data.tar.gz: 65f832e20fc1eeb9a2b6da8e37eb49041697afd66695a91998c65fd16942c915e2c2d4adb870d094858cc7fcb7dbd7849f25d229686849c57e8c98ef0904abcd

data/lib/mime_actor/action.rb

@@ -46,7 +46,6 @@ module MimeActor
     #   end
     #
     def start_scene(action)
-      action = action&.to_sym
       formats = acting_scenes.fetch(action, {})
 
       if formats.empty?
@@ -56,9 +55,7 @@ module MimeActor
 
       respond_to do |collector|
         formats.each do |format, actor|
-          dispatch = self.class.dispatch_act(action: action, format: format, context: self) do
-            cue_actor(actor.presence || "#{action}_#{format}")
-          end
+          dispatch = -> { cue_actor(actor.presence || "#{action}_#{format}", action:, format:) }
           collector.public_send(format, &dispatch)
         end
       end

data/lib/mime_actor/dispatcher.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module MimeActor
+  module Dispatcher
+    class MethodCall
+      attr_reader :method_name, :args
+
+      def initialize(method_name, *args)
+        @method_name = method_name
+        @args = args
+        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
+      end
+
+      private
+
+      def validate!
+        raise ArgumentError, "invalid method name: #{method_name.inspect}" unless method_name in String | Symbol
+      end
+    end
+
+    class InstanceExec
+      attr_reader :block, :args
+
+      def initialize(block, *args)
+        @block = block
+        @args = args
+        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
+      end
+
+      private
+
+      def validate!
+        raise ArgumentError, "invalid block: #{block.inspect}" unless block in Proc
+      end
+    end
+
+    def self.build(callable, *args)
+      case callable
+      when String, Symbol
+        MethodCall.new(callable, *args)
+      when Proc
+        InstanceExec.new(callable, *args)
+      end
+    end
+  end
+end

data/lib/mime_actor/rescue.rb

@@ -2,8 +2,9 @@
 
 # :markup: markdown
 
-require "mime_actor/stage"
+require "mime_actor/dispatcher"
 require "mime_actor/validator"
+require "mime_actor/stage"
 
 require "active_support/concern"
 require "active_support/core_ext/array/wrap"
@@ -139,5 +140,59 @@ module MimeActor
         end
       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 visited the errors to skip after no rescue handler matched the filter
+    #
+    def rescue_actor(error, action:, format:, visited: [])
+      return if visited.include?(error)
+
+      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
+        error
+      elsif error&.cause
+        rescue_actor(error.cause, format:, action:, visited:)
+      end
+    end
+
+    private
+
+    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
 end

data/lib/mime_actor/stage.rb

@@ -3,6 +3,7 @@
 # :markup: markdown
 
 require "mime_actor/errors"
+require "mime_actor/dispatcher"
 require "mime_actor/logging"
 
 require "active_support/concern"
@@ -19,7 +20,7 @@ module MimeActor
     include Logging
 
     included do
-      mattr_accessor :raise_on_missing_actor, instance_writer: false, default: false
+      mattr_accessor :raise_on_actor_error, instance_writer: false, default: false
     end
 
     module ClassMethods
@@ -71,17 +72,14 @@ module MimeActor
     #
     # NOTE: method call on actor if it is String or Symbol. Proc#call if actor is Proc
     #
-    # @param actor either a method name or a block to evaluate
-    def cue_actor(actor, *args)
-      result = case actor
-               when String, Symbol
-                 actor_method_call(actor, *args)
-               when Proc
-                 actor_proc_call(actor, *args)
-               else
-                 raise TypeError, "invalid actor, got: #{actor.inspect}"
-               end
+    # @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
 
+      result = dispatch_actor(dispatch, action:, format:)
       if block_given?
         yield result
       else
@@ -91,20 +89,24 @@ module MimeActor
 
     private
 
-    def actor_method_call(actor_method, *args)
-      unless self.class.actor?(actor_method)
-        raise MimeActor::ActorNotFound, actor_method if raise_on_missing_actor
-
-        logger.warn { "actor #{actor_method.inspect} not found" }
-        return
+    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
-
-      public_send(actor_method, *args)
+      handle_actor_error(result) unless dispatched || rescued
+      result if dispatched
     end
 
-    def actor_proc_call(actor_proc, *args)
-      passable_args = actor_proc.arity.negative? ? args : args.take(actor_proc.arity)
-      instance_exec(*passable_args, &actor_proc)
+    def handle_actor_error(actor)
+      error = MimeActor::ActorNotFound.new(actor)
+      raise error if raise_on_actor_error
+
+      logger.error { "actor error, cause: #{error.inspect}" }
     end
   end
 end

data/lib/mime_actor/version.rb

@@ -4,18 +4,18 @@
 
 module MimeActor
   def self.version
-    gem_version
+    VERSION::STRING
   end
 
   def self.gem_version
-    Gem::Version.new VERSION::STRING
+    Gem::Version.new(VERSION::STRING)
   end
 
   module VERSION
     MAJOR = 0
     MINOR = 6
-    BUILD = 1
-    PRE   = "rc1"
+    BUILD = 2
+    PRE   = nil
 
     STRING = [MAJOR, MINOR, BUILD, PRE].compact.join(".")
   end

data/lib/mime_actor.rb

@@ -7,6 +7,7 @@ require "mime_actor/version"
 require "mime_actor/errors"
 
 require "active_support/dependencies/autoload"
+require "active_support/deprecation"
 
 module MimeActor
   extend ActiveSupport::Autoload
@@ -17,4 +18,18 @@ module MimeActor
   autoload :Rescue
   autoload :Validator
   autoload :Logging
+
+  def self.deprecator
+    @deprecator ||= ActiveSupport::Deprecation.new("0.7.0", "MimeActor")
+  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|
+    deprecator.deprecate_methods(klazz, *args)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mime_actor
 version: !ruby/object:Gem::Version
-  version: 0.6.1.rc1
+  version: 0.6.2
 platform: ruby
 authors:
 - Ryan Chang
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-07-13 00:00:00.000000000 Z
+date: 2024-07-21 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/dispatcher.rb
 - lib/mime_actor/errors.rb
 - lib/mime_actor/logging.rb
 - lib/mime_actor/rescue.rb