mime_actor 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e71c1193071831b1f09601cb8ea8909e1f7b2b6642dfdab1253f288df4717c2
-  data.tar.gz: 22c67a0d503292dffa976efb5fc467ab1e280abd59dd7b2058ea0b75759ca5bb
+  metadata.gz: 9ac518915a340b48be1aa4dbc91589df809cbbb297415fbc9ea1d2351e70e163
+  data.tar.gz: dde09568578db8acdf6f5b16d1a5e72f0b87750f954c6fb617e3b30ad29794c8
 SHA512:
-  metadata.gz: 04d272ad8c24f21fa92576969bf6e434a3c65c46dfb9e39ddfb7e9b80b7847055a21a9c5dc5e38274916af61be5fa9fcc08bd7e9612625a9a5992915ce4e14f5
-  data.tar.gz: 3d2f97f2b3ae25c7e64047629967932da4c0bceca4794f8b93fa87f98250e7a18256331ebdd24fe5ba5ca2d60eb9cb4a6349512da1040dbef0117a045277b76c
+  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/{rescuer.rb → rescue.rb}

@@ -1,35 +1,36 @@
 # frozen_string_literal: true
 
 require 'active_support/concern'
-require 'active_support/configurable'
+require "active_support/core_ext/array/wrap"
 require "active_support/core_ext/module/attribute_accessors"
-require 'abstract_controller/logger'
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/string/inflections"
+require "action_dispatch/http/mime_type"
 
 module MimeActor
-  module Rescuer
+  module Rescue
     extend ActiveSupport::Concern
-    include ActiveSupport::Configurable
-    include AbstractController::Logger
 
     included do
       mattr_accessor :actor_rescuers, instance_writer: false, default: []
     end
 
     module ClassMethods
-      def rescue_act_from(*klazzes, format: nil, action: nil, with: nil, &block)
-        unless with
-          raise ArgumentError, "Provide the with: keyword argument or a block" unless block_given?
-          with = block
-        end
+      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 SUPPORTED_MIME_TYPES.include?(format.to_sym)
+            raise ArgumentError, "Unsupported format: #{format}" unless Mime::SET.symbols.include?(format.to_sym)
           when Enumerable
             unfiltered = format.to_set
-            filtered = unfiltered & SUPPORTED_MIME_TYPES
+            filtered = unfiltered & Mime::SET.symbols.to_set
             rejected = unfiltered - filtered
             raise ArgumentError, "Unsupported formats: #{rejected.join(', ')}" if rejected.size.positive?
           else
@@ -37,9 +38,8 @@ module MimeActor
           end
         end
 
-        if action.present?
-          message = "Action filter can only be Symbol/Enumerable"
-          raise ArgumentError, message unless action.is_a?(Symbol) || action.is_a?(Enumerable)
+        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|
@@ -56,19 +56,6 @@ module MimeActor
         end
       end
 
-      def dispatch_act(action: nil, format: nil, context: self, &block)
-        lambda do
-          case block
-          when Proc
-            context.instance_exec(&block)
-          else
-            block.call
-          end
-        rescue Exception => ex
-          rescue_actor(ex, format:, action:, context:) || raise
-        end
-      end
-
       def rescue_actor(error, action: nil, format: nil, context: self, visited: [])
         visited << error
 

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,7 +11,7 @@ module MimeActor
 
   module VERSION
     MAJOR = 0
-    MINOR = 1
+    MINOR = 2
     BUILD = 0
     PRE   = nil
 

data/lib/mime_actor.rb

@@ -1,19 +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 :Rescuer
-  include Rescuer
-
-  SUPPORTED_MIME_TYPES = Mime::SET.symbols.to_set
-  private_constant :SUPPORTED_MIME_TYPES
+  autoload :Act
+  autoload :Scene
+  autoload :Rescue
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mime_actor
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Ryan Chang
@@ -94,8 +94,10 @@ files:
 - README.md
 - Rakefile
 - lib/mime_actor.rb
-- lib/mime_actor/formatter.rb
-- lib/mime_actor/rescuer.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,94 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-require 'active_support/configurable'
-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 'abstract_controller/logger'
-require 'abstract_controller/rendering'
-require 'action_controller/metal/mime_responds'
-
-module MimeActor
-  module Formatter
-    extend ActiveSupport::Concern
-    include ActiveSupport::Configurable
-    include AbstractController::Logger
-    include AbstractController::Rendering # required by MimeResponds
-    include ActionController::MimeResponds
-
-    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)
-
-          dispatch = unless self.class.respond_to?(:dispatch_act)
-            actor
-          else
-            self.class.public_send(:dispatch_act,
-              action: action_name.to_sym, 
-              format: formatter.to_sym,
-              context: self,
-              &actor
-            )
-          end
-          collector.public_send(formatter, &dispatch)
-        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