mime_actor 0.5.4 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5eb8de0fc146859794812ae3cb81cb99a1a775668af9681e22409fd8df0b245e
-  data.tar.gz: b39aa38f9a21c2b8a794ba1edaf01e184fbe0277cc256721e61df9f2fa98a3c4
+  metadata.gz: f5a67bb80dd83c069ea2f06a4afea5e241987d8b9a2a30f0a3eb0d01748b3759
+  data.tar.gz: acb0cd8b89e39ea3962c0949bff4666c96c36f6c15eae5a3709775daa5ef2516
 SHA512:
-  metadata.gz: c4c8f432f1cd6d7a1678b9ed1da3cada46a28ed9406003f4fa9cac78375567dbc15f600c11cf3ef10acd76c8d4449b24385db6397be8f5dab6fc9f1ab6b9c3d9
-  data.tar.gz: bbe236716e0a3969737388f9390349563d088581486b17b8601b150bf88ccaf8a68beadb913c1496cfad0652727a17689a0f2ad9db46c4917bac6449e36e8a21
+  metadata.gz: e64c6a62feb248b76672d75ef4cf9bc0f822b0f2fd57311f879874e910377b80549b133c85b148fd61d44d91259c780299770d7fae4792dbab094c01676df201
+  data.tar.gz: 2577dc3d03d3fa233ba136613e63d0c18a3e59f51bac690b582b18f424cc4ee7e5fee736eafc76393a94af20e3fcf930cd953b4eec07f21282fa9b5dd7be552d

data/.rubocop.yml

@@ -19,6 +19,10 @@ Style/BlockComments:
 Metrics/AbcSize:
   Enabled: false
   
+Metrics/BlockLength:
+  AllowedMethods:
+    - class_methods
+
 Metrics/CyclomaticComplexity:
   Enabled: false
 

data/COMPARE.md

@@ -27,7 +27,7 @@ class EventsController < ActionController::Base
     before_action only: :index { @events = Event.all }
 
     # dynamically defines the action method according to on: argument
-    act_on_format :html, :json, on: :index 
+    respond_act_to :html, :json, on: :index 
 
     def index_html
         @event_categories = EventCategory.all
@@ -92,13 +92,13 @@ class EventsController < ActionController::Base
     # AbstractController::Callbacks here to load model with params
     before_action only: [:show, :update] { @event = Event.find(params.require(:event_id)) }
 
-    act_on_format :html, :json, on: [:show, :update]
+    respond_act_to :html, :json, on: [:show, :update]
 
-    rescue_actor_from ActiveRecord::RecordNotFound, format: :json do |ex|
+    rescue_act_from ActiveRecord::RecordNotFound, format: :json do |ex|
         render status: :bad_request, json: { error: ex.message }
     end
 
-    rescue_actor_from ActiveRecord::RecordNotFound, format: :html, action: :show do |ex|
+    rescue_act_from ActiveRecord::RecordNotFound, format: :html, action: :show do |ex|
         redirect_to events_path
     end
 

data/README.md

@@ -16,14 +16,14 @@ class EventsController < ActionController::Base
     before_action only: :index { @events = Event.all }
     before_action only: [:show, :update] { @event = Event.find(params.require(:event_id)) }
 
-    act_on_format :html, :json, on: :index
-    act_on_format :html, :json, on: [:show, :update]
+    respond_act_to :html, :json, on: :index
+    respond_act_to :html, :json, on: [:show, :update]
 
-    rescue_actor_from ActiveRecord::RecordNotFound, format: :json do |ex|
+    rescue_act_from ActiveRecord::RecordNotFound, format: :json do |ex|
         render status: :bad_request, json: { error: "Resouce not found" }
     end
 
-    rescue_actor_from ActiveRecord::RecordNotFound, format: :html, action: :show do |ex|
+    rescue_act_from ActiveRecord::RecordNotFound, format: :html, action: :show do |ex|
         redirect_to events_path
     end
 
@@ -99,7 +99,7 @@ Please see [LICENSE](https://github.com/ryancyq/mime_actor/blob/main/LICENSE) fo
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/ryancyq/mime_actor.
+Bug reports and pull requests are welcome on GitHub at [https://github.com/ryancyq/mime_actor](https://github.com/ryancyq/mime_actor).
 
 [rubygems_badge]: https://img.shields.io/gem/v/mime_actor.svg
 [rubygems]: https://rubygems.org/gems/mime_actor

data/codecov.yml

@@ -0,0 +1,18 @@
+codecov:
+  notify:
+    wait_for_ci: false
+  require_ci_to_pass: false
+
+coverage:
+  status:
+    project:
+      default:
+        target: 99%
+        threshold: 1%
+    patch:
+      default:
+        target: 99%
+        threshold: 1%
+
+comment:
+  require_changes: true

data/lib/mime_actor/action.rb

@@ -5,6 +5,7 @@ require "mime_actor/stage"
 require "mime_actor/rescue"
 
 require "active_support/concern"
+require "active_support/core_ext/object/blank"
 require "active_support/lazy_load_hooks"
 require "abstract_controller/rendering"
 require "action_controller/metal/mime_responds"
@@ -27,7 +28,7 @@ module MimeActor
     include Rescue
     include Logging
 
-    # The core logic where rendering logics are collected as `Proc` through configuration and passed over to `ActionController::MimeResponds`
+    # The core logic where rendering logics are collected as `Proc` and passed over to `ActionController::MimeResponds`
     #
     # @param action the `action` of the controller
     #
@@ -44,17 +45,17 @@ module MimeActor
     #
     def start_scene(action)
       action = action&.to_sym
-      formats = acting_scenes.fetch(action, Set.new)
+      formats = acting_scenes.fetch(action, {})
 
       if formats.empty?
-        logger.warn { "format is empty for action :#{action}" }
+        logger.warn { "format is empty for action: #{action.inspect}" }
         return
       end
 
       respond_to do |collector|
-        formats.each do |format|
+        formats.each do |format, actor|
           dispatch = self.class.dispatch_cue(action: action, format: format, context: self) do
-            cue_actor("#{action}_#{format}")
+            cue_actor(actor.presence || "#{action}_#{format}")
           end
           collector.public_send(format, &dispatch)
         end

data/lib/mime_actor/errors.rb

@@ -24,7 +24,7 @@ module MimeActor
 
   class ActorNotFound < ActorError
     def generate_message
-      ":#{actor} not found"
+      "#{actor.inspect} not found"
     end
   end
 
@@ -39,7 +39,7 @@ module MimeActor
 
   class ActionExisted < ActionError
     def generate_message
-      "action :#{action} already existed"
+      "action #{action.inspect} already existed"
     end
   end
 end

data/lib/mime_actor/rescue.rb

@@ -8,6 +8,7 @@ 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
@@ -16,7 +17,7 @@ module MimeActor
   # Simillar to `ActionController::Rescue` but with additional filtering logic on `action`/`format`.
   #
   # @example Rescue RuntimeError when raised for any action with `json` format
-  #   rescue_actor_from RuntimeError, format: :json, with: :handle_json_error
+  #   rescue_act_from RuntimeError, format: :json, with: :handle_json_error
   #
   module Rescue
     extend ActiveSupport::Concern
@@ -34,49 +35,38 @@ module MimeActor
       # @param klazzes the error classes to rescue
       # @param action the `action` filter
       # @param format the `format` filter
-      # @param with the rescue hanlder when `block` is not provided
+      # @param with the rescue handler when `block` is not provided
       # @param block the `block` to evaluate when `with` is not provided
       #
       # @example Rescue StandardError when raised for any action with `html` format
-      #   rescue_actor_from StandardError, format: :html, with: :handle_html_error
+      #   rescue_act_from StandardError, format: :html, with: :handle_html_error
       #
       # @example Rescue StandardError when raised for `show` action with `json` format
-      #   rescue_actor_from StandardError, format: :json, action: :show do |ex|
+      #   rescue_act_from StandardError, format: :json, action: :show do |ex|
       #     render status: :bad_request, json: { error: ex.message }
       #   end
       #
-      def rescue_actor_from(*klazzes, action: nil, format: nil, with: nil, &block)
+      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 the with: argument or a block" unless with.present? ^ block_given?
 
-        validate!(:with, with, block)
-        with = block if block_given?
+        if block_given?
+          with = block
+        else
+          validate!(:with, with)
+        end
 
         if action.present?
-          if action.is_a?(Enumerable)
-            validate!(:actions, action)
-          else
-            validate!(:action, action)
-          end
+          action.is_a?(Enumerable) ? validate!(:actions, action) : validate!(:action, action)
         end
 
         if format.present?
-          if format.is_a?(Enumerable)
-            validate!(:formats, format)
-          else
-            validate!(:format, format)
-          end
+          format.is_a?(Enumerable) ? validate!(:formats, format) : validate!(:format, format)
         end
 
         klazzes.each do |klazz|
-          error = case klazz
-                  when Module
-                    klazz.name
-                  when String
-                    klazz
-                  else
-                    message = "#{klazz.inspect} must be a Class/Module or a String referencing a Class/Module"
-                    raise ArgumentError, message
-                  end
+          validate!(:klazz, klazz)
+          error = klazz.is_a?(Module) ? klazz.name : klazz
 
           # append at the end because strategies are read in reverse.
           actor_rescuers << [error, format, action, with]
@@ -111,26 +101,14 @@ module MimeActor
         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) }
+          lambda do |*args|
+            passable_args = rescuer_method.arity.negative? ? args : args.take(rescuer_method.arity)
+            rescuer_method.call(*passable_args)
           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) }
+          lambda do |*args|
+            passable_args = rescuer.arity.negative? ? args : args.take(rescuer.arity)
+            context.instance_exec(*passable_args, &rescuer)
           end
         end
       end

data/lib/mime_actor/scene.rb

@@ -9,6 +9,7 @@ require "active_support/concern"
 require "active_support/core_ext/array/extract_options"
 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
@@ -16,9 +17,27 @@ module MimeActor
   # Scene provides configuration for `action` + `format` definitions
   #
   # @example register a `html` format on action `index`
-  #     act_on_format :html, on: :index
+  #   respond_act_to :html, on: :index
+  #
+  #   # this method should be defined in the class
+  #   def index_html; end
   # @example register `html`, `json` formats on actions `index`, `show`
-  #     act_on_format :html, :json , on: [:index, :show]
+  #   respond_act_to :html, :json , on: [:index, :show]
+  #
+  #   # 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
+  #
+  #   # 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
+  #     render :index
+  #   end
   #
   # NOTE: Calling the same `action`/`format` multiple times will overwrite previous `action` + `format` definitions.
   #
@@ -34,54 +53,86 @@ module MimeActor
     module ClassMethods
       # Register `action` + `format` definitions.
       #
-      # @param options [Array]
-      # @option options [Array] klazzes the collection of `format`
-      # @option options [Hash] on the collection of `action`
+      # @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
       #
       # @example register a `html` format on action `index`
-      #   compose_scene :html, on: :index
+      #   respond_act_to :html, on: :index
+      #
+      #   # this method should be defined in the class
+      #   def index_html; end
       # @example register `html`, `json` formats on actions `index`, `show`
-      #   compose_scene :html, :json , on: [:index, :show]
+      #   respond_act_to :html, :json , on: [:index, :show]
+      #
+      #   # 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
+      #
+      #   # 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
+      #     render :index
+      #   end
       #
       # For each unique `action` being registered, it will have a corresponding `action` method being defined.
-      def compose_scene(*options)
-        config = options.extract_options!
-        validate!(:formats, options)
+      def respond_act_to(*formats, on: nil, with: nil, &block)
+        validate!(:formats, formats)
 
-        actions = config[:on]
-        if !actions
-          raise ArgumentError, "action is required"
-        elsif actions.is_a?(Enumerable)
+        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
+
+        case actions = on
+        when Enumerable
           validate!(:actions, actions)
-        else
+        when Symbol, String
           validate!(:action, actions)
+        else
+          raise ArgumentError, "action is required"
         end
 
-        options.each do |format|
-          Array.wrap(actions).each do |action|
-            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] ||= Set.new
-            acting_scenes[action] |= [format]
-
-            next if action_defined
-
-            class_eval(
-              # def index
-              #   self.respond_to?(:start_scene) && self.start_scene(:index)
-              # end
-              <<-RUBY, __FILE__, __LINE__ + 1
-                def #{action}
-                  self.respond_to?(:start_scene) && self.start_scene(:#{action})
-                end
-              RUBY
-            )
-          end
+        Array.wrap(actions).each do |action|
+          formats.each { |format| compose_scene(action, format, with) }
         end
       end
 
-      alias act_on_format compose_scene
+      alias act_on_format respond_act_to
+
+      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
+      end
+
+      def define_scene(action)
+        class_eval(
+          # def index
+          #   self.respond_to?(:start_scene) && self.start_scene(:index)
+          # end
+          <<-RUBY, __FILE__, __LINE__ + 1
+            def #{action}
+              self.respond_to?(:start_scene) && self.start_scene(:#{action})
+            end
+          RUBY
+        )
+      end
     end
   end
 end

data/lib/mime_actor/stage.rb

@@ -37,7 +37,8 @@ module MimeActor
         found
       end
 
-      # Wraps the given `block` with a `lambda`, rescue any error raised from the `block` via `rescue_actor` if defined, otherwise, error will be re-raised
+      # 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`
@@ -62,25 +63,45 @@ module MimeActor
       end
     end
 
-    # Calls the `actor` method if defined, supports passing arguments to the `actor` method.
-    #
+    # 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.
     #
-    # @param actor_name
-    def cue_actor(actor_name, *args)
-      unless self.class.actor?(actor_name)
-        raise MimeActor::ActorNotFound, actor_name if raise_on_missing_actor
-
-        logger.warn { "actor not found, expected :#{actor_name}" }
-        return
-      end
+    # 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
 
-      result = public_send(actor_name, *args)
       if block_given?
         yield result
       else
         result
       end
     end
+
+    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
+      end
+
+      public_send(actor_method, *args)
+    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)
+    end
   end
 end

data/lib/mime_actor/validator.rb

@@ -3,6 +3,7 @@
 # :markup: markdown
 
 require "active_support/concern"
+require "active_support/core_ext/object/blank"
 require "set" # required by mime_type with ruby <= 3.1
 require "action_dispatch/http/mime_type"
 
@@ -31,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}" unless respond_to?(validator, true)
+        raise NameError, "Validator not found, got: #{validator.inspect}" unless respond_to?(validator, true)
 
         error = send(validator, *args)
         raise error if error
@@ -41,7 +42,7 @@ module MimeActor
       #
       # @param unchecked the `action` to be validated
       def validate_action(unchecked)
-        ArgumentError.new("action must be a Symbol") unless unchecked.is_a?(Symbol)
+        TypeError.new("action must be a Symbol") unless unchecked.is_a?(Symbol)
       end
 
       # Validate `actions` must be a collection of Symbol
@@ -49,16 +50,16 @@ module MimeActor
       # @param unchecked the `actions` to be validated
       def validate_actions(unchecked)
         rejected = unchecked.reject { |action| action.is_a?(Symbol) }
-        NameError.new("invalid actions, got: #{rejected.join(", ")}") if rejected.size.positive?
+        NameError.new("invalid actions, got: #{rejected.map(&:inspect).join(", ")}") if rejected.size.positive?
       end
 
       # Validate `format` must be a Symbol and a valid MIME type
       #
       # @param unchecked the `format` to be validated
       def validate_format(unchecked)
-        return ArgumentError.new("format must be a Symbol") unless unchecked.is_a?(Symbol)
+        return TypeError.new("format must be a Symbol") unless unchecked.is_a?(Symbol)
 
-        NameError.new("invalid format, got: #{unchecked}") unless scene_formats.include?(unchecked)
+        NameError.new("invalid format, got: #{unchecked.inspect}") unless scene_formats.include?(unchecked)
       end
 
       # Validate `formats` must be an collection of Symbol which each of them is a valid MIME type
@@ -69,25 +70,25 @@ module MimeActor
         filtered = unfiltered & scene_formats
         rejected = unfiltered - filtered
 
-        NameError.new("invalid formats, got: #{rejected.join(", ")}") if rejected.size.positive?
+        NameError.new("invalid formats, got: #{rejected.map(&:inspect).join(", ")}") if rejected.size.positive?
       end
 
-      # Validate `with` or `block` must be provided and if `with` is provided, it must be a Symbol or Proc
+      # Validate `klazz` must be a Class/Module or a String referencing a Class/Module
+      #
+      # @param unchecked the `klazz` to be validated
+      def validate_klazz(unchecked)
+        return if unchecked.is_a?(Module) || unchecked.is_a?(String)
+
+        TypeError.new("#{unchecked.inspect} must be a Class/Module or a String referencing a Class/Module")
+      end
+
+      # Validate `with` must be a Symbol or Proc
       #
       # @param unchecked the `with` to be validated
-      # @param block the `block` to be valiated
-      def validate_with(unchecked, block)
-        if unchecked.present? && block.present?
-          return ArgumentError.new("provide either the with: keyword argument or a block")
-        end
-        unless unchecked.present? || block.present?
-          return ArgumentError.new("provide the with: keyword argument or a block")
-        end
-
-        return if block.present?
+      def validate_with(unchecked)
         return if unchecked.is_a?(Proc) || unchecked.is_a?(Symbol)
 
-        ArgumentError.new("with handler must be a Symbol or Proc, got: #{unchecked.inspect}")
+        TypeError.new("with handler must be a Symbol or Proc, got: #{unchecked.inspect}")
       end
     end
   end

data/lib/mime_actor/version.rb

@@ -11,8 +11,8 @@ module MimeActor
 
   module VERSION
     MAJOR = 0
-    MINOR = 5
-    BUILD = 4
+    MINOR = 6
+    BUILD = 1
     PRE   = nil
 
     STRING = [MAJOR, MINOR, BUILD, PRE].compact.join(".")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mime_actor
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.6.1
 platform: ruby
 authors:
 - Ryan Chang
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-06-29 00:00:00.000000000 Z
+date: 2024-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -68,6 +68,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- codecov.yml
 - lib/mime_actor.rb
 - lib/mime_actor/action.rb
 - lib/mime_actor/errors.rb