convenient_service 0.1.0

data/lib/convenient_service/core/entities/config/entities/method_middlewares/entities/caller/commands/define_method_middlewares_caller.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              class Caller
+                module Commands
+                  class DefineMethodMiddlewaresCaller < Support::Command
+                    include Support::Delegate
+
+                    ##
+                    # @!attribute [r] scope
+                    #   @return [:instance, :class]
+                    #
+                    attr_reader :scope
+
+                    ##
+                    # @!attribute [r] method
+                    #   @return [String, Symbol]
+                    #
+                    attr_reader :method
+
+                    ##
+                    # @!attribute [r] container
+                    #   @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Container]
+                    #
+                    attr_reader :container
+
+                    ##
+                    # @!attribute [r] caller
+                    #   @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Caller]
+                    #
+                    attr_reader :caller
+
+                    ##
+                    # @return [void]
+                    #
+                    delegate :prepend_methods_middlewares_callers_to_container, to: :container
+
+                    ##
+                    # @return [Module]
+                    #
+                    delegate :methods_middlewares_callers, to: :container
+
+                    ##
+                    # @return [String]
+                    #
+                    delegate :prefix, to: :caller
+
+                    ##
+                    # @param scope [:instance, :class]
+                    # @param method [String, Symbol]
+                    # @param container [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Container]
+                    # @param caller [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Caller]
+                    # @return [void]
+                    #
+                    def initialize(scope:, method:, container:, caller:)
+                      @scope = scope
+                      @method = method
+                      @container = container
+                      @caller = caller
+                    end
+
+                    ##
+                    # @return [Boolean] true if method middlewares caller is just defined, false if already defined.
+                    #
+                    def call
+                      return false if Utils::Method.defined?(method, methods_middlewares_callers, private: true)
+
+                      prepend_methods_middlewares_callers_to_container
+
+                      define_method_middlewares_caller
+
+                      true
+                    end
+
+                    private
+
+                    ##
+                    # @return [void]
+                    #
+                    # @internal
+                    #   NOTE: Make assignment of `scope`, `method`, `prefix` in the beginning for easier debugging. For example:
+                    #     method = :#{method}
+                    #     method = :#{scope}
+                    #     prefix = "#{prefix}"
+                    #
+                    #   NOTE: Check the following link in order to get an idea why two versions of `define_method_middlewares_caller` exist.
+                    #   https://gist.github.com/marian13/9c25041f835564e945d978839097d419
+                    #
+                    if ::RUBY_VERSION >= "3.0"
+                      def define_method_middlewares_caller
+                        <<~RUBY.tap { |code| methods_middlewares_callers.module_eval(code, __FILE__, __LINE__ + 1) }
+                          def #{method}(*args, **kwargs, &block)
+                            method_middlewares = #{prefix}middlewares(:#{method}, scope: :#{scope})
+
+                            env = {args: args, kwargs: kwargs, block: block, entity: self}
+                            original_method = proc { |env| super(*env[:args], **env[:kwargs], &env[:block]) }
+
+                            method_middlewares.call(env, original_method)
+                          end
+                        RUBY
+                      end
+                    else
+                      def define_method_middlewares_caller
+                        <<~RUBY.tap { |code| methods_middlewares_callers.module_eval(code, __FILE__, __LINE__ + 1) }
+                          def #{method}(*args, **kwargs, &block)
+                            method_middlewares = #{prefix}middlewares(:#{method}, scope: :#{scope})
+
+                            env = {args: args, kwargs: kwargs, block: block, entity: self}
+                            super_method = method_middlewares.resolve_super_method(self)
+                            original_method = proc { |env| super_method.call(*env[:args], **env[:kwargs], &env[:block]) }
+
+                            raise ::NoMethodError, method_middlewares.no_super_method_exception_message_for(self) unless super_method
+
+                            method_middlewares.call(env, original_method)
+                          end
+                        RUBY
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/core/entities/config/entities/method_middlewares/entities/caller/commands.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "commands/cast_caller"
+require_relative "commands/define_method_middlewares_caller"

data/lib/convenient_service/core/entities/config/entities/method_middlewares/entities/caller/concern/class_methods.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              class Caller
+                module Concern
+                  module ClassMethods
+                    ##
+                    # @param other [Hash, ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Caller]
+                    # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Caller, nil]
+                    #
+                    def cast(other)
+                      Commands::CastCaller.call(other: other)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/core/entities/config/entities/method_middlewares/entities/caller/concern/instance_methods.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              class Caller
+                module Concern
+                  module InstanceMethods
+                    include Support::Copyable
+
+                    ##
+                    # @!attribute [r] prefix
+                    #   @return [String]
+                    #
+                    attr_reader :prefix
+
+                    ##
+                    # @param prefix [String]
+                    # @return [void]
+                    #
+                    def initialize(prefix:)
+                      @prefix = prefix
+                    end
+
+                    ##
+                    # @param scope [:instance, :class]
+                    # @param method [Symbol]
+                    # @param container [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Container]
+                    # @return [Boolean]
+                    #
+                    def define_method_middlewares_caller!(scope, method, container)
+                      Commands::DefineMethodMiddlewaresCaller.call(scope: scope, method: method, container: container, caller: self)
+                    end
+
+                    ##
+                    # @param other [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Caller, Object]
+                    # @return [Boolean]
+                    #
+                    def ==(other)
+                      return unless other.instance_of?(self.class)
+
+                      return false if prefix != other.prefix
+
+                      true
+                    end
+
+                    ##
+                    # @return [Hash]
+                    #
+                    def to_kwargs
+                      {prefix: prefix}
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/core/entities/config/entities/method_middlewares/entities/caller/concern.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "concern/instance_methods"
+require_relative "concern/class_methods"
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              class Caller
+                module Concern
+                  include Support::Concern
+
+                  included do |container_klass|
+                    container_klass.include Support::Castable
+
+                    container_klass.include InstanceMethods
+
+                    container_klass.extend ClassMethods
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/core/entities/config/entities/method_middlewares/entities/caller.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "caller/commands"
+require_relative "caller/concern"
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              class Caller
+                INSTANCE_PREFIX = "self.class."
+                CLASS_PREFIX = ""
+
+                include Concern
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/core/entities/config/entities/method_middlewares/entities/chain.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              ##
+              # @internal
+              #   NOTE: Do NOT pollute the interface of this class until really needed.
+              #
+              class Chain
+                ##
+                # @param stack [#call<Hash>]
+                # @param env [Hash]
+                # @return [void]
+                #
+                def initialize(stack:, env: {})
+                  @stack = stack
+                  @env = env
+                end
+
+                ##
+                # @param args [Array]
+                # @param kwargs [Hash]
+                # @param block [Proc]
+                # @return [Object] Can be any type.
+                #
+                # @internal
+                #   TODO: Enforce to always pass args, kwargs, block.
+                #
+                def next(*args, **kwargs, &block)
+                  stack.call(env.merge(args: args, kwargs: kwargs, block: block))
+                end
+
+                ##
+                # @param other [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Chain, Object]
+                # @return [Boolean]
+                #
+                def ==(other)
+                  return unless other.instance_of?(self.class)
+
+                  return false if stack != other.stack
+                  return false if env != other.env
+
+                  true
+                end
+
+                protected
+
+                ##
+                # @!attribute [r] stack
+                #   @return [#call<Hash>]
+                #
+                attr_reader :stack
+
+                ##
+                # @!attribute [r] env
+                #   @return [Hash]
+                #
+                attr_reader :env
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/core/entities/config/entities/method_middlewares/entities/container/commands/cast_container.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              class Container
+                module Commands
+                  class CastContainer < Support::Command
+                    ##
+                    # @!attribute [r] other
+                    #   @return [Hash]
+                    #
+                    attr_reader :other
+
+                    ##
+                    # @param other [Hash, ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Container]
+                    # @return [void]
+                    #
+                    def initialize(other:)
+                      @other = other
+                    end
+
+                    ##
+                    # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Container, nil]
+                    #
+                    def call
+                      case other
+                      when ::Hash
+                        cast_hash(other)
+                      when Container
+                        cast_container(other)
+                      end
+                    end
+
+                    private
+
+                    ##
+                    # @param hash [Hash]
+                    # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Container, nil]
+                    #
+                    def cast_hash(hash)
+                      return unless hash[:scope]
+                      return unless hash[:klass]
+                      return unless hash[:klass].is_a?(Class)
+
+                      case hash[:scope]
+                      when :instance
+                        Container.new(klass: hash[:klass])
+                      when :class
+                        Container.new(klass: hash[:klass].singleton_class)
+                      end
+                    end
+
+                    ##
+                    # @param container [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Container]
+                    # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Container]
+                    #
+                    def cast_container(container)
+                      container.copy
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/core/entities/config/entities/method_middlewares/entities/container/commands/resolve_methods_middlewares_callers.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              class Container
+                module Commands
+                  class ResolveMethodsMiddlewaresCallers < Support::Command
+                    include Support::Delegate
+
+                    ##
+                    # @!attribute [r] container
+                    #   @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Container]
+                    #
+                    attr_reader :container
+
+                    ##
+                    # @return [Class]
+                    #
+                    delegate :klass, to: :container
+
+                    ##
+                    # @param container [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Container]
+                    # @return [void]
+                    #
+                    def initialize(container:)
+                      @container = container
+                    end
+
+                    ##
+                    # @return [Module]
+                    #
+                    def call
+                      get_methods_middlewares_callers || set_methods_middlewares_callers
+                    end
+
+                    private
+
+                    ##
+                    # @return [Module, nil]
+                    #
+                    def get_methods_middlewares_callers
+                      Utils::Module.get_own_const(klass, module_name)
+                    end
+
+                    ##
+                    # @return [Module]
+                    #
+                    def set_methods_middlewares_callers
+                      klass.const_set(module_name, ::Module.new)
+                    end
+
+                    ##
+                    # @return [Symbol]
+                    #
+                    def module_name
+                      @module_name ||= :MethodsMiddlewaresCallers
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/core/entities/config/entities/method_middlewares/entities/container/commands.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "commands/cast_container"
+require_relative "commands/resolve_methods_middlewares_callers"

data/lib/convenient_service/core/entities/config/entities/method_middlewares/entities/container/concern/class_methods.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              class Container
+                module Concern
+                  module ClassMethods
+                    ##
+                    # @param other [Hash, ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Container]
+                    # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Container, nil]
+                    #
+                    def cast(other)
+                      Commands::CastContainer.call(other: other)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end