mime_actor 0.3.3 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35c75654432a3dd52002da0a92b31560432709c940143b6da12d6c8381298cd5
-  data.tar.gz: 7a412d03ba99cc45ea2aceb4c3741a49b2bcbc53b04f2a627267e415c4e0955a
+  metadata.gz: 21576d34311aa9a06ac9542d118390900d8b9e3d9860fb6ed7d1a4a9b672bf96
+  data.tar.gz: a2ca714375f7892e1506bf55b5fcdbbaa3b1ea7884b9f2ad7a1b4284d3fed08a
 SHA512:
-  metadata.gz: db971845e8bd7544fea9b7bc711c9e290948eaeaf52526b49e72cab85023d6b8087f1f131c4f5f6ed70591ad342bfab94a09e44f3a9f6d250df6bd3c7d30b72e
-  data.tar.gz: 0014236f7f1720f88f6bbb7e807c0d34760786b5febc1037d3f871c0b0f2a67d976c4ccadf58d939bff563b5c214bc25ca2160669590050bf6e0ca14c975ae1e
+  metadata.gz: c24629937c5b2d7626588b1ef8ffa1d334450bda5dafe90693d0c65bfc5200d8122e0fdbd315206538c85cb6d8aae29eedf7f07289b3971a13f0a6903d757c0b
+  data.tar.gz: 07d9061ef2e41f55b0e5e9718f9a719a4da2309232be87bf59f638e2a0f9502cfbcdaa6f054f9e2764b9c9b5a9bb1cd5a3a8544a6844902d5dd1f72d07b8ea1f

data/.hound.yml

@@ -0,0 +1,2 @@
+rubocop:
+  enabled: false

data/.rubocop.yml

@@ -7,6 +7,7 @@ AllCops:
   NewCops: enable
   Exclude:
     - bin/*
+    - vendor/**/*
 
 Style/Documentation:
   Enabled: false
@@ -15,6 +16,19 @@ Style/BlockComments:
   Exclude:
     - spec/*_helper.rb
 
+Metrics/AbcSize:
+  Enabled: false
+  
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Metrics/MethodLength:
+  CountAsOne: ['array', 'heredoc', 'method_call']
+  Max: 15
+
 Style/StringLiterals:
   EnforcedStyle: double_quotes
 
@@ -32,7 +46,14 @@ Layout/HashAlignment:
   EnforcedColonStyle: table
 
 RSpec/MultipleExpectations:
-  Enabled: false
+  Max: 6
 
 RSpec/ExampleLength:
-  Enabled: false
+  CountAsOne: ['array', 'heredoc', 'method_call']
+  Max: 10
+
+RSpec/MultipleMemoizedHelpers:
+  Max: 10
+
+RSpec/NestedGroups:
+  Max: 5

data/README.md

@@ -1,25 +1,89 @@
 # mime_actor
 
-[![Gem Version](https://badge.fury.io/rb/mime_actor.svg)](https://badge.fury.io/rb/mime_actor)
+[![Gem Version](https://badge.fury.io/rb/mime_actor.png)](https://badge.fury.io/rb/mime_actor)
+[![codecov](https://codecov.io/gh/ryancyq/mime_actor/graph/badge.svg?token=4C091RHXC3)](https://codecov.io/gh/ryancyq/mime_actor)
 [![Build](https://github.com/ryancyq/mime_actor/actions/workflows/build.yml/badge.svg)](https://github.com/ryancyq/mime_actor/actions/workflows/build.yml)
 
-Action rendering and rescue with mime type via configuration in actionpack
+Render + Rescue handlers for different MIME types in Rails
 
-## Installation
+## Usage
 
-Install the gem and add to the application's Gemfile by executing:
+MimeActor allows you to do something like below:
+```rb
+class EventsController < ActionController::Base
+    # AbstractController::Callbacks here to load model with params
+    before_action only: :index { @events = Event.all }
+    before_action only: [:show, :update] { @event = Event.find(params.require(:event_id)) }
 
-    $ bundle add mime_actor
+    compose_scene :html, :json, on: :index
+    compose_scene :html, :json, on: [:show, :update]
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+    rescue_actor_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|
+        redirect_to events_path
+    end
+
+    def index_html
+        @event_categories = EventCategory.all
+        render :index # render html using @events and @event_categories
+    end
+
+    def index_json
+        render json: @events # render json using #as_json
+    end
+
+    def show_html
+        render :show # render html using @event
+    end
+
+    def update_html
+        redirect_to event_path(@event.id) # redirect to show upon sucessful update
+    rescue ActiveRecord::RecordNotFound
+        render :edit
+    end
+
+    def show_json
+        render json: @event # render json using #as_json
+    end
 
-    $ gem install mime_actor
+    def update_json
+        # ...
+        render json: @event # render json using #as_json
+    end
+end
+```
 
-## Getting Started
+## Features
+
+- Action customisation for ActionController per MIME type
+- Customisation are deduplicated automatically when configured multiple times
+- Flexible rescue handler definition for the combination of Action/MIME type or both
+- Built on top of `ActionController::Metal::MimeResponds`
+- Fully compatible with other `ActionController` functionalities 
+
+## Requirements
+
+- Ruby: MRI 3.1+
+- Rails: 5.0+
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+```sh
+bundle add mime_actor
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+```sh
+gem install mime_actor
+```
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 

data/lib/mime_actor/action.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "mime_actor/scene"
+require "mime_actor/stage"
+require "mime_actor/rescue"
+
+require "active_support/concern"
+require "active_support/lazy_load_hooks"
+require "abstract_controller/rendering"
+require "action_controller/metal/mime_responds"
+
+module MimeActor
+  module Action
+    extend ActiveSupport::Concern
+
+    include AbstractController::Rendering # required by MimeResponds
+    include ActionController::MimeResponds
+
+    include Scene
+    include Stage
+    include Rescue
+    include Logging
+
+    def start_scene(action)
+      action = action&.to_sym
+      formats = acting_scenes.fetch(action, Set.new)
+
+      if formats.empty?
+        logger.warn { "format is empty for action :#{action}" }
+        return
+      end
+
+      respond_to do |collector|
+        formats.each do |format|
+          dispatch = self.class.dispatch_cue(action: action, format: format, context: self) do
+            cue_actor("#{action}_#{format}")
+          end
+          collector.public_send(format, &dispatch)
+        end
+      end
+    end
+
+    ActiveSupport.run_load_hooks(:mime_actor, self)
+  end
+end

data/lib/mime_actor/errors.rb

@@ -1,20 +1,45 @@
 # frozen_string_literal: true
 
+require "set"
+
 module MimeActor
   class Error < StandardError
+    def inspect
+      "<#{self.class.name}> #{message}"
+    end
+
+    def generate_message
+      self.class.name
+    end
   end
 
-  class ActorNotFound < Error
+  class ActorError < Error
     attr_reader :actor
 
     def initialize(actor)
       @actor = actor
+      super(generate_message)
+    end
+  end
 
-      super(":#{actor} not found")
+  class ActorNotFound < ActorError
+    def generate_message
+      ":#{actor} not found"
     end
+  end
 
-    def inspect
-      "<#{self.class.name}> #{message}"
+  class ActionError < Error
+    attr_reader :action
+
+    def initialize(action = nil)
+      @action = action
+      super(generate_message)
+    end
+  end
+
+  class ActionExisted < ActionError
+    def generate_message
+      "action :#{action} already existed"
     end
   end
 end

data/lib/mime_actor/logging.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+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"
+
+module MimeActor
+  module Logging
+    extend ActiveSupport::Concern
+
+    include ActiveSupport::Configurable
+
+    included do
+      config_accessor :logger, default: ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new($stdout))
+    end
+
+    private
+
+    def fill_run_sheet(*scenes, &)
+      return yield unless logger.respond_to?(:tagged)
+
+      scenes.unshift "MimeActor" unless logger.formatter.current_tags.include?("MimeActor")
+
+      logger.tagged(*scenes, &)
+    end
+  end
+end

data/lib/mime_actor/rescue.rb

@@ -1,56 +1,56 @@
 # frozen_string_literal: true
 
+require "mime_actor/stage"
+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"
-require "set" # remove when ruby > 3,1
-require "action_dispatch/http/mime_type"
 
 module MimeActor
   module Rescue
     extend ActiveSupport::Concern
 
+    include Stage
+    include Validator
+
     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?
+        raise ArgumentError, "error filter is required" if klazzes.empty?
 
+        validate!(:with, with, block)
         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?
+        if action.present?
+          if action.is_a?(Enumerable)
+            validate!(:actions, action)
           else
-            raise ArgumentError, "Format filter can only be Symbol/Enumerable"
+            validate!(:action, action)
           end
         end
 
-        if action.present? && !(action.is_a?(Symbol) || action.is_a?(Enumerable))
-          raise ArgumentError, "Action filter can only be Symbol/Enumerable"
+        if format.present?
+          if format.is_a?(Enumerable)
+            validate!(:formats, format)
+          else
+            validate!(:format, format)
+          end
         end
 
         klazzes.each do |klazz|
-          error = if klazz.is_a?(Module)
+          error = case klazz
+                  when Module
                     klazz.name
-                  elsif klazz.is_a?(String)
+                  when String
                     klazz
                   else
-                    raise ArgumentError,
-                          "#{klazz.inspect} must be a class/module or a String referencing a class/module"
+                    message = "#{klazz.inspect} must be a Class/Module or a String referencing a Class/Module"
+                    raise ArgumentError, message
                   end
 
           # append at the end because strategies are read in reverse.
@@ -59,12 +59,13 @@ module MimeActor
       end
 
       def rescue_actor(error, action: nil, format: nil, context: self, visited: [])
-        visited << error
+        return if visited.include?(error)
 
+        visited << error
         if (rescuer = dispatch_rescuer(error, format:, action:, context:))
           rescuer.call(error, format, action)
           error
-        elsif error&.cause && !visited.include?(error.cause)
+        elsif error&.cause
           rescue_actor(error.cause, format:, action:, context:, visited:)
         end
       end

data/lib/mime_actor/scene.rb

@@ -1,52 +1,54 @@
 # frozen_string_literal: true
 
-require "mime_actor/stage"
+require "mime_actor/errors"
+require "mime_actor/validator"
 
 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 "set" # remove when ruby > 3,1
-require "action_dispatch/http/mime_type"
 
 module MimeActor
   module Scene
     extend ActiveSupport::Concern
 
-    include Stage
+    include Validator
 
     included do
-      mattr_accessor :acting_scenes, instance_writer: false, default: ActiveSupport::HashWithIndifferentAccess.new
+      mattr_accessor :acting_scenes, instance_writer: false, default: {}
     end
 
     module ClassMethods
       def compose_scene(*options)
         config = options.extract_options!
-        actions = Array.wrap(config[:on])
-
-        raise ArgumentError, "Action name can't be empty, e.g. on: :create" if actions.empty?
-
-        options.each do |mime_type|
-          raise ArgumentError, "Unsupported format: #{mime_type}" unless Mime::SET.symbols.include?(mime_type.to_sym)
+        validate!(:formats, options)
+
+        actions = config[:on]
+        if !actions
+          raise ArgumentError, "action is required"
+        elsif actions.is_a?(Enumerable)
+          validate!(:actions, actions)
+        else
+          validate!(:action, actions)
+        end
 
-          actions.each do |action|
-            if !acting_scenes.key?(action) && actor?(action)
-              raise ArgumentError, "Action method already defined: #{action}"
-            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] |= [mime_type.to_sym]
+            acting_scenes[action] |= [format]
 
-            next if actor?(action)
+            next if action_defined
 
             class_eval(
               # def index
-              #   self.cue_actor(:play_scene, :index)
+              #   self.respond_to?(:start_scene) && self.start_scene(:index)
               # end
               <<-RUBY, __FILE__, __LINE__ + 1
                 def #{action}
-                  self.cue_actor(:play_scene, :#{action})
+                  self.respond_to?(:start_scene) && self.start_scene(:#{action})
                 end
               RUBY
             )

data/lib/mime_actor/stage.rb

@@ -1,18 +1,16 @@
 # frozen_string_literal: true
 
 require "mime_actor/errors"
+require "mime_actor/logging"
 
 require "active_support/concern"
-require "active_support/configurable"
 require "active_support/core_ext/module/attribute_accessors"
-require "abstract_controller/logger"
 
 module MimeActor
   module Stage
     extend ActiveSupport::Concern
 
-    include ActiveSupport::Configurable
-    include AbstractController::Logger
+    include Logging
 
     included do
       mattr_accessor :raise_on_missing_actor, instance_writer: false, default: false
@@ -20,29 +18,31 @@ module MimeActor
 
     module ClassMethods
       def actor?(actor_name)
-        return action_methods.include?(actor_name.to_s) if singleton_methods.include?(:action_methods)
-
-        instance_methods.include?(actor_name.to_sym)
+        # exclude public methods from ancestors
+        found = public_instance_methods(false).include?(actor_name.to_sym)
+        # exclude private methods from ancestors
+        if !found && private_instance_methods(false).include?(actor_name.to_sym)
+          logger.debug { "actor must be public method, #{actor_name} is private method" }
+        end
+        found
       end
-    end
-
-    def actor?(actor_name)
-      return action_methods.include?(actor_name.to_s) if respond_to?(:action_methods)
-
-      methods.include?(actor_name.to_sym)
-    end
 
-    def find_actor(actor_name)
-      return method(actor_name) if actor?(actor_name)
-
-      error = MimeActor::ActorNotFound.new(actor_name)
-      raise error if raise_on_missing_actor
-
-      logger.warn { "Actor not found: #{error.inspect}" }
+      def dispatch_cue(action: nil, format: nil, context: self, &block)
+        lambda do
+          context.instance_exec(&block)
+        rescue StandardError => e
+          (respond_to?(:rescue_actor) && rescue_actor(e, action:, format:, context:)) || raise
+        end
+      end
     end
 
     def cue_actor(actor_name, *args)
-      return unless actor?(actor_name)
+      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
 
       result = public_send(actor_name, *args)
       if block_given?

data/lib/mime_actor/validator.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "set" # required by mime_type with ruby <= 3.1
+require "action_dispatch/http/mime_type"
+
+module MimeActor
+  module Validator
+    extend ActiveSupport::Concern
+
+    included do
+      mattr_accessor :scene_formats, instance_writer: false, default: Mime::SET.symbols.to_set
+    end
+
+    module ClassMethods
+      def validate!(rule, *args)
+        validator = "validate_#{rule}"
+        raise NameError, "Validator not found, got: #{validator}" unless respond_to?(validator, true)
+
+        error = send(validator, *args)
+        raise error if error
+      end
+
+      def validate_action(unchecked)
+        ArgumentError.new("action must be a Symbol") unless unchecked.is_a?(Symbol)
+      end
+
+      def validate_actions(unchecked)
+        rejected = unchecked.reject { |action| action.is_a?(Symbol) }
+        NameError.new("invalid actions, got: #{rejected.join(", ")}") if rejected.size.positive?
+      end
+
+      def validate_format(unchecked)
+        return ArgumentError.new("format must be a Symbol") unless unchecked.is_a?(Symbol)
+
+        NameError.new("invalid format, got: #{unchecked}") unless scene_formats.include?(unchecked)
+      end
+
+      def validate_formats(unchecked)
+        unfiltered = unchecked.to_set
+        filtered = unfiltered & scene_formats
+        rejected = unfiltered - filtered
+
+        NameError.new("invalid formats, got: #{rejected.join(", ")}") if rejected.size.positive?
+      end
+
+      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?
+        return if unchecked.is_a?(Proc) || unchecked.is_a?(Symbol)
+
+        ArgumentError.new("with handler must be a Symbol or Proc, got: #{unchecked.inspect}")
+      end
+    end
+  end
+end

data/lib/mime_actor/version.rb

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

data/lib/mime_actor.rb

@@ -8,8 +8,10 @@ require "active_support/dependencies/autoload"
 module MimeActor
   extend ActiveSupport::Autoload
 
-  autoload :Act
+  autoload :Action
   autoload :Scene
   autoload :Stage
   autoload :Rescue
+  autoload :Validator
+  autoload :Logging
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mime_actor
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.5.1
 platform: ruby
 authors:
 - Ryan Chang
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-06-24 00:00:00.000000000 Z
+date: 2024-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -59,6 +59,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".hound.yml"
 - ".rspec"
 - ".rubocop.yml"
 - ".ruby-version"
@@ -66,11 +67,13 @@ files:
 - README.md
 - Rakefile
 - lib/mime_actor.rb
-- lib/mime_actor/act.rb
+- lib/mime_actor/action.rb
 - lib/mime_actor/errors.rb
+- lib/mime_actor/logging.rb
 - lib/mime_actor/rescue.rb
 - lib/mime_actor/scene.rb
 - lib/mime_actor/stage.rb
+- lib/mime_actor/validator.rb
 - lib/mime_actor/version.rb
 - sig/mime_actor.rbs
 homepage: https://github.com/ryancyq/mime_actor

data/lib/mime_actor/act.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require "mime_actor/scene"
-require "mime_actor/stage"
-require "mime_actor/rescue"
-
-require "active_support/concern"
-require "abstract_controller/rendering"
-require "action_controller/metal/mime_responds"
-
-module MimeActor
-  module Act
-    extend ActiveSupport::Concern
-
-    include AbstractController::Rendering # required by MimeResponds
-    include ActionController::MimeResponds
-    include Scene
-    include Stage
-    include Rescue
-
-    module ClassMethods
-      def dispatch_act(action: nil, format: nil, context: self, &block)
-        lambda do
-          context.instance_exec(&block)
-        rescue StandardError => e
-          (respond_to?(:rescue_actor) && rescue_actor(e, 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
-  end
-end