mime_actor 0.0.4.alpha → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b353a4f0f8625adf8fc788c30a501bb8406ede3bb6ac9309d6e459fc829e0dbd
-  data.tar.gz: e9f62e73020e5728e47ca3c6bd1386dc3b861261284c6bb55ce203cabf2d2a99
+  metadata.gz: 9ac518915a340b48be1aa4dbc91589df809cbbb297415fbc9ea1d2351e70e163
+  data.tar.gz: dde09568578db8acdf6f5b16d1a5e72f0b87750f954c6fb617e3b30ad29794c8
 SHA512:
-  metadata.gz: 6dd846f06c7461b7c1762f3ff18b16798d41994731fd09a887452830a851b4642431ec115b7a9054cd17cdecd8b3be0d360bf1a1c5a43305e20fab50094c9b47
-  data.tar.gz: 1a98f58e33535bd84d564a6c5413a1228cdaeecf0ae9f3203b822de60999623cbc412bc818a09c1b9878059149d7f564473b98a6abc07838862bde62ccaa0973
+  metadata.gz: c20053a6f4e13d78060b64980bb1bd128e3cfc0628692bc8c70f3e0a8201dbaa84ecd008f5500c3dd7a008eac6ff4bf2f5eb040e094d16dd816b1be087b33807
+  data.tar.gz: 280ef49bce9321ca1be252fa91978d6eb7b209dc14f56e1002ef01ccbccb70fc0bdba8fa2cfd3451b92343df5fc811a9d03a8ead4608726d66d4e543a433289c

data/lib/mime_actor/act.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'active_support/configurable'
+require "active_support/core_ext/module/attribute_accessors"
+require 'abstract_controller/logger'
+require 'abstract_controller/rendering'
+require 'action_controller/metal/mime_responds'
+
+module MimeActor
+  module Act
+    extend ActiveSupport::Concern
+    include ActiveSupport::Configurable
+    include AbstractController::Logger
+    include AbstractController::Rendering # required by MimeResponds
+    include ActionController::MimeResponds
+    include Scene
+    include Rescue
+
+    included do
+      mattr_accessor :raise_on_missing_actor, instance_writer: false, default: false
+    end
+
+    module ClassMethods
+      def dispatch_act(action: nil, format: nil, context: self, &block)
+        lambda do
+          context.instance_exec(&block)
+        rescue Exception => ex
+          respond_to?(:rescue_actor) && public_send(:rescue_actor, ex, action:, format:, context:) || raise
+        end
+      end
+    end
+
+    private
+
+    def play_scene(action)
+      action = action&.to_sym
+      return unless acting_scenes.key?(action)
+
+      mime_types = acting_scenes.fetch(action, Set.new)
+      respond_to do |collector|
+        mime_types.each do |mime_type|
+          next unless actor = find_actor(action, mime_type)
+
+          dispatch = self.class.dispatch_act(
+            action: action, 
+            format: mime_type,
+            context: self,
+            &actor
+          )
+          collector.public_send(mime_type, &dispatch)
+        end
+      end
+    end
+
+    def find_actor(action, mime_type)
+      actor_name = "#{action}_#{mime_type}"
+      
+      if respond_to?(:action_methods) && public_send(:action_methods).include?(actor_name)
+        return self.method(actor_name)
+      end
+
+      error = MimeActor::ActorNotFound.new(action, mime_type) 
+      unless self.raise_on_missing_actor
+        logger.warn { "Actor not found: #{error.inspect}" }
+        return
+      end
+
+      raise error
+    end
+  end
+end

data/lib/mime_actor/errors.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module MimeActor
+  class Error < StandardError
+  end
+
+  class ActorNotFound < Error
+    attr_reader :actor, :action, :format
+
+    def initialize(action, format)
+      @action = action
+      @format = format
+      @actor = "#{action}_#{format}"
+
+      super(":#{actor} not found")
+    end
+
+    def inspect
+      "<#{self.class.name}> actor:#{actor} not found for action:#{action}, format:#{format}"
+    end
+  end
+end

data/lib/mime_actor/rescue.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+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"
+require "action_dispatch/http/mime_type"
+
+module MimeActor
+  module Rescue
+    extend ActiveSupport::Concern
+
+    included do
+      mattr_accessor :actor_rescuers, instance_writer: false, default: []
+    end
+
+    module ClassMethods
+      def rescue_actor_from(*klazzes, action: nil, format: nil, with: nil, &block)
+        raise ArgumentError, "Error filter can't be empty" if klazzes.empty?
+        raise ArgumentError, "Provide only the with: keyword argument or a block" if with.present? && block_given?
+        raise ArgumentError, "Provide the with: keyword argument or a block" unless with.present? || block_given?
+
+        with = block if block_given?
+        raise ArgumentError, "Rescue handler can only be Symbol/Proc" unless with.is_a?(Proc) || with.is_a?(Symbol)
+
+        if format.present?
+          case format
+          when Symbol
+            raise ArgumentError, "Unsupported format: #{format}" unless Mime::SET.symbols.include?(format.to_sym)
+          when Enumerable
+            unfiltered = format.to_set
+            filtered = unfiltered & Mime::SET.symbols.to_set
+            rejected = unfiltered - filtered
+            raise ArgumentError, "Unsupported formats: #{rejected.join(', ')}" if rejected.size.positive?
+          else
+            raise ArgumentError, "Format filter can only be Symbol/Enumerable"
+          end
+        end
+
+        if action.present? && !(action.is_a?(Symbol) || action.is_a?(Enumerable))
+          raise ArgumentError, "Action filter can only be Symbol/Enumerable"
+        end
+
+        klazzes.each do |klazz|
+          error = if klazz.is_a?(Module)
+            klazz.name
+          elsif klazz.is_a?(String)
+            klazz
+          else
+            raise ArgumentError, "#{klazz.inspect} must be a class/module or a String referencing a class/module"
+          end
+
+          # append at the end because strategies are read in reverse.
+          self.actor_rescuers << [error, format, action, with]
+        end
+      end
+
+      def rescue_actor(error, action: nil, format: nil, context: self, visited: [])
+        visited << error
+
+        if rescuer = dispatch_rescuer(error, format:, action:, context:)
+          rescuer.call(error, format, action)
+          error
+        elsif error && error.cause && !visited.include?(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)
+          case rescuer_method.arity
+          when 0
+            -> e,f,a { rescuer_method.call }
+          when 1
+            -> e,f,a { rescuer_method.call(e) }
+          when 2
+            -> e,f,a { rescuer_method.call(e,f) }
+          else
+            -> e,f,a { rescuer_method.call(e,f,a) }
+          end
+        when Proc
+          case rescuer.arity
+          when 0
+            -> e,f,a { context.instance_exec(&rescuer) }
+          when 1
+            -> e,f,a { context.instance_exec(e, &rescuer) }
+          when 2
+            -> e,f,a { context.instance_exec(e, f, &rescuer) }
+          else
+            -> e,f,a { context.instance_exec(e, f, a, &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)
+
+          klazz === error # klazz is a member of error
+        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
+end

data/lib/mime_actor/scene.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/array/wrap"
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/module/attribute_accessors"
+require "action_dispatch/http/mime_type"
+
+module MimeActor
+  module Scene
+    extend ActiveSupport::Concern
+
+    included do
+      mattr_accessor :acting_scenes, instance_writer: false, default: ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    module ClassMethods
+      def compose_scene(*options)
+        config = options.extract_options!
+        actions = Array.wrap(config[:on])
+
+        if actions.empty?
+          raise ArgumentError, "Action name can't be empty, e.g. on: :create"
+        end
+
+        options.each do |mime_type|
+          unless Mime::SET.symbols.include?(mime_type.to_sym)
+            raise ArgumentError, "Unsupported format: #{mime_type}"
+          end
+
+          actions.each do |action|
+            unless acting_scenes.key?(action)
+              if respond_to?(:action_methods) && public_send(:action_methods).include?(action.to_s)
+                raise ArgumentError, "Action method already defined: #{action}"
+              end
+            end
+
+            acting_scenes[action] ||= Set.new
+            acting_scenes[action] |= [mime_type.to_sym]
+
+            unless respond_to?(action)
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{action}
+                  respond_to?(:play_scene) && public_send(:play_scene, :#{action})
+                end
+              RUBY
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mime_actor/version.rb

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

data/lib/mime_actor.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
 require_relative "mime_actor/version"
+require_relative "mime_actor/errors"
 
-require 'active_support'
+require 'active_support/dependencies/autoload'
 
 module MimeActor
-  extend ActiveSupport::Concern
   extend ActiveSupport::Autoload
 
-  autoload :Formatter
-  include Formatter
+  autoload :Act
+  autoload :Scene
+  autoload :Rescue
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mime_actor
 version: !ruby/object:Gem::Version
-  version: 0.0.4.alpha
+  version: 0.2.0
 platform: ruby
 authors:
 - Ryan Chang
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-06-22 00:00:00.000000000 Z
+date: 2024-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -94,7 +94,10 @@ files:
 - README.md
 - Rakefile
 - lib/mime_actor.rb
-- lib/mime_actor/formatter.rb
+- lib/mime_actor/act.rb
+- lib/mime_actor/errors.rb
+- lib/mime_actor/rescue.rb
+- lib/mime_actor/scene.rb
 - lib/mime_actor/version.rb
 - sig/mime_actor.rbs
 homepage: https://github.com/ryancyq/mime_actor

data/lib/mime_actor/formatter.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support'
-require "active_support/core_ext/array/extract_options"
-require "active_support/core_ext/array/wrap"
-require "active_support/core_ext/hash/indifferent_access"
-require "active_support/core_ext/module/attribute_accessors"
-require 'action_controller'
-
-module MimeActor
-  module Formatter
-    extend ActiveSupport::Concern
-    include ActiveSupport::Configurable
-    include AbstractController::Logger
-    include AbstractController::Rendering # required by MimeResponds
-    include ActionController::MimeResponds
-
-    SUPPORTED_MIME_TYPES = Mime::SET.symbols.to_set
-    private_constant :SUPPORTED_MIME_TYPES
-
-    included do
-      mattr_accessor :action_formatters, instance_writer: false, default: ActiveSupport::HashWithIndifferentAccess.new
-      mattr_accessor :raise_on_missing_action_formatter, instance_writer: false, default: false
-    end
-
-    module ClassMethods
-      def act_on_format(*formats_and_options)
-        options = formats_and_options.extract_options!
-        actions = Array.wrap(options[:on])
-
-        message = "Action name can't be blank, e.g. on: :create"
-        raise ArgumentError, message if actions.empty?
-
-        formats_and_options.each do |format|
-          message = "Unsupported format: #{format}"
-          raise ArgumentError, message unless SUPPORTED_MIME_TYPES.include?(format.to_sym)
-
-          actions.each do |action|
-            message = "Action method already defined: #{action}"
-            raise ArgumentError, message if action_methods.include?(action.to_s) && !action_formatters.key?(action)
-
-            action_formatters[action] ||= Set.new
-            action_formatters[action] |= [format]
-
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{action}
-                perform_act
-              end
-            RUBY
-          end
-        end
-      end
-    end
-
-    private
-
-    def perform_act
-      return unless action_formatters.key?(action_name)
-
-      formatters = action_formatters.fetch(action_name, Set.new)
-      respond_to do |collector|
-        formatters.each do |formatter|
-          next unless actor = find_actor(action_name, formatter)
-
-          collector.public_send(formatter, &actor)
-        end
-      end
-    end
-
-    def find_actor(action, format)
-      actor_name = "#{action}_#{format}"
-      
-      unless action_methods.include?(actor_name)
-        message = "Method: #{actor_name} could not be found for action: #{action_name}, format: #{format}"
-        raise AbstractController::ActionNotFound.new(message, self, actor_name) if raise_on_missing_action_formatter
-
-        logger.warn { message }
-        return
-      end
-
-      self.method(actor_name)
-    end
-  end
-end