convenient_service 0.1.0

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              class Container
+                module Concern
+                  module InstanceMethods
+                    include Support::Copyable
+                    include Support::Delegate
+
+                    ##
+                    # @!attribute [r] klass
+                    #   @return [Class]
+                    #
+                    attr_reader :klass
+
+                    ##
+                    # @return [Array<Class, Module>]
+                    #
+                    delegate :ancestors, to: :klass
+
+                    ##
+                    # @param klass [Class]
+                    # @return [void]
+                    #
+                    def initialize(klass:)
+                      @klass = klass
+                    end
+
+                    ##
+                    # @param method_name [Symbol, String]
+                    # @return [UnboundMethod, nil]
+                    #
+                    def super_method_defined?(method_name)
+                      Utils::Bool.to_bool(resolve_unbound_super_method(method_name))
+                    end
+
+                    ##
+                    # Returns ancestors before the `methods_middlewares_callers` module. See the example below.
+                    # When ancestors do NOT contain `methods_middlewares_callers`, returns an empty array.
+                    #
+                    # @return [Array<Class, Module>]
+                    #
+                    # @example The entity is an object.
+                    #   class Service
+                    #     include ConvenientService::Core
+                    #
+                    #     middlewares :result do
+                    #       use ConvenientService::Plugins::Common::NormalizesEnv
+                    #     end
+                    #   end
+                    #
+                    #   entity = Service.new
+                    #
+                    #   entity.class.ancestors
+                    #   # [Service::InstanceMethodsMiddlewaresCallers, Service, ConvenientService::Core::InstanceMethods, ConvenientService::Core, ConvenientService::Support::Concern, Object, Kernel, BasicObject]
+                    #
+                    #   ancestors_greater_than_methods_middlewares_callers # For the entity defined above.
+                    #   # [Service, ConvenientService::Core::InstanceMethods, ConvenientService::Core, ConvenientService::Support::Concern, Object, Kernel, BasicObject]
+                    #
+                    # @example The entity is class.
+                    #   class Service
+                    #     include ConvenientService::Core
+                    #
+                    #     middlewares :result, scope: :class do
+                    #       use ConvenientService::Plugins::Common::NormalizesEnv
+                    #     end
+                    #   end
+                    #
+                    #   entity = Service
+                    #
+                    #   entity.singleton_class.ancestors
+                    #   # [Service::ClassMethodsMiddlewaresCallers, #<Class:Service>, ConvenientService::Core::ClassMethods, #<Class:Object>, #<Class:BasicObject>, Class, Module, Object, Kernel, BasicObject]
+                    #
+                    #   ancestors_greater_than_methods_middlewares_callers # For the entity defined above.
+                    #   # [#<Class:Service>, ConvenientService::Core::ClassMethods, #<Class:Object>, #<Class:BasicObject>, Class, Module, Object, Kernel, BasicObject]# [Service::ClassMethodsMiddlewaresCallers, #<Class:Service>, ConvenientService::Core::ClassMethods, #<Class:Object>, #<Class:BasicObject>, Class, Module, Object, Kernel, BasicObject]
+                    #
+                    # @note Returns empty array when `methods_middlewares_callers` are NOT prepended.
+                    # @note If you expect to receive not empty array, make sure the config is committed.
+                    #
+                    # @internal
+                    #   NOTE: greater than -> futher in the inheritance chain than
+                    #   https://ruby-doc.org/core-2.7.0/Module.html#method-i-3E
+                    #
+                    #   NOTE: lower than -> closer in the inheritance chain than
+                    #   https://ruby-doc.org/core-2.7.0/Module.html#method-i-ancestors
+                    #
+                    def ancestors_greater_than_methods_middlewares_callers
+                      Utils::Array.keep_after(ancestors, methods_middlewares_callers)
+                    end
+
+                    ##
+                    # @return [Module]
+                    #
+                    def methods_middlewares_callers
+                      @methods_middlewares_callers ||= Commands::ResolveMethodsMiddlewaresCallers.call(container: self)
+                    end
+
+                    ##
+                    # @return [void]
+                    #
+                    def prepend_methods_middlewares_callers_to_container
+                      klass.prepend(methods_middlewares_callers)
+                    end
+
+                    ##
+                    # @param method_name [Symbol, String]
+                    # @return [UnboundMethod, nil]
+                    #
+                    # @note Returns `nil` when `methods_middlewares_callers` are NOT prepended.
+                    # @note If you expect to receive not `nil`, make sure the config is committed.
+                    #
+                    def resolve_unbound_super_method(method_name)
+                      Utils::Array.find_yield(ancestors_greater_than_methods_middlewares_callers) { |ancestor| Utils::Module.get_own_instance_method(ancestor, method_name, private: true) }
+                    end
+
+                    ##
+                    # @param method_name [Symbol, String]
+                    # @param entity [Class, Object]
+                    # @return [Method, nil]
+                    #
+                    # @note Returns `nil` when `methods_middlewares_callers` are NOT prepended.
+                    # @note If you expect to receive not `nil`, make sure the config is committed.
+                    #
+                    def resolve_super_method(method_name, entity)
+                      unbound_super_method = resolve_unbound_super_method(method_name)
+
+                      return unless unbound_super_method
+
+                      unbound_super_method.bind(entity)
+                    end
+
+                    ##
+                    # @param other [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Container, Object]
+                    # @return [Boolean, nil]
+                    #
+                    def ==(other)
+                      return unless other.instance_of?(self.class)
+
+                      return false if klass != other.klass
+
+                      true
+                    end
+
+                    ##
+                    # @return [Hash]
+                    #
+                    def to_kwargs
+                      {klass: klass}
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/core/entities/config/entities/method_middlewares/entities/container/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 Container
+                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/container.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "container/commands"
+require_relative "container/concern"
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              class Container
+                include Concern
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              ##
+              # @abstract Subclass and override `#next`.
+              #
+              # @internal
+              #   NOTE: Do NOT pollute the interface of this class until really needed.
+              #   Avoid even pollution of private methods.
+              #   This way there is a lower risk that a plugin developer accidentally overwrites an internal middleware behavior.
+              #   https://github.com/Ibsciss/ruby-middleware#a-basic-example
+              #
+              class Middleware
+                include Support::AbstractMethod
+
+                ##
+                # @return [Object] Can be any type.
+                # @raise [ConvenientService::Support::AbstractMethod::Errors::AbstractMethodNotOverridden] if NOT overridden in descendant.
+                #
+                # @example Subclass should call `value = chain.next(*args, **kwargs, &block)` to trigger next middleware in a stack.
+                #   def next(*args, **kwargs, &block)
+                #     # pre processing...
+                #
+                #     value = chain.next(*args, **kwargs, &block)
+                #
+                #     # post processing...
+                #
+                #     post_processed_value
+                #   end
+                #
+                # @see https://refactoring.guru/design-patterns/decorator
+                #
+                # @note But it completely OK, to omit `chain.next(*args, **kwargs, &block)` completely.
+                #   This way middleware stack is stopped in the "middle" and its "middle" value is returned.
+                # @see https://refactoring.guru/design-patterns/proxy
+                # @see https://refactoring.guru/design-patterns/chain-of-responsibility
+                #
+                abstract_method :next
+
+                ##
+                # @param stack [#call<Hash>]
+                # @return [void]
+                #
+                def initialize(stack, env: {})
+                  @__stack__ = stack
+                  @__env__ = env
+                end
+
+                ##
+                # @param env [Hash]
+                # @return [Object] Can be any type.
+                #
+                def call(env)
+                  @__env__ = env
+
+                  ##
+                  # IMPORTANT: This is a library code. Do NOT do things like this in your application code.
+                  #
+                  chain.instance_variable_set(:@env, env)
+
+                  ##
+                  # NOTE: `__send__` is used since `next` is ruby keyword.
+                  # https://ruby-doc.org/core-2.7.0/doc/keywords_rdoc.html
+                  #
+                  # TODO: Enforce to always pass args, kwargs, block.
+                  #
+                  __send__(:next, *env[:args], **env[:kwargs], &env[:block])
+                end
+
+                ##
+                # @return [Class, Object]
+                #
+                # @internal
+                #   NOTE: `@__env__` is set inside `call`.
+                #
+                def entity
+                  @__env__[:entity]
+                end
+
+                ##
+                # @return [Symbol]
+                #
+                # @note Try to avoid `if` conditions based on `method` value when possible, prefer to create separate middlewares instead.
+                #
+                # @internal
+                #   NOTE: `@__env__` is set inside `call`.
+                #
+                def method
+                  @__env__[:method]
+                end
+
+                ##
+                # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Chain]
+                #
+                # @internal
+                #   NOTE: `@__env__` is set inside `call`.
+                #
+                def chain
+                  @__chain__ ||= Entities::Chain.new(stack: @__stack__)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              class Stack
+                ##
+                # @overload initialize(name:)
+                #   @param name [String]
+                #   @return [void]
+                #
+                # @overload initialize(plain_stack:)
+                #   @param name [ConvenientService::Support::Middleware::StackBuilder]
+                #   @return [void]
+                #
+                def initialize(name: nil, plain_stack: nil)
+                  @plain_stack = plain_stack || Support::Middleware::StackBuilder.new(name: name)
+                end
+
+                ##
+                # @return [String]
+                #
+                def name
+                  plain_stack.name
+                end
+
+                ##
+                # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Stack]
+                #
+                def dup
+                  self.class.new(plain_stack: plain_stack.dup)
+                end
+
+                ##
+                # @param env [Hash]
+                # @return [Object] Can be any type.
+                #
+                # @see https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware/builder.rb#L132
+                #
+                def call(env)
+                  plain_stack.call(env)
+                end
+
+                ##
+                # @param index_or_middleware [Integer, ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middleware]
+                # @param middleware [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middleware]
+                # @param args [Array]
+                # @param block [Proc]
+                # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Stack]
+                #
+                # @see https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware/builder.rb#L88
+                #
+                def insert(index_or_middleware, middleware, *args, &block)
+                  plain_stack.insert(index_or_middleware, middleware, *args, &block)
+
+                  self
+                end
+
+                ##
+                # @see insert
+                # @see https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware/builder.rb#L94
+                #
+                alias_method :insert_before, :insert
+
+                ##
+                # @param index_or_middleware [Integer, ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middleware]
+                # @param middleware [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middleware]
+                # @param args [Array]
+                # @param block [Proc]
+                # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Stack]
+                #
+                # @see https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware/builder.rb#L97
+                #
+                def insert_after(index_or_middleware, middleware, *args, &block)
+                  plain_stack.insert_after(index_or_middleware, middleware, *args, &block)
+
+                  self
+                end
+
+                ##
+                # @param middleware [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middleware]
+                # @param args [Array]
+                # @param block [Proc]
+                # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Stack]
+                #
+                # @see https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware/builder.rb#L104
+                #
+                def insert_before_each(middleware, *args, &block)
+                  plain_stack.insert_before_each(middleware, *args, &block)
+
+                  self
+                end
+
+                ##
+                # @param middleware [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middleware]
+                # @param args [Array]
+                # @param block [Proc]
+                # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Stack]
+                #
+                # @see https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware/builder.rb#L111
+                #
+                def insert_after_each(middleware, *args, &block)
+                  plain_stack.insert_after_each(middleware, *args, &block)
+
+                  self
+                end
+
+                ##
+                # @param index_or_middleware [Integer, ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middleware]
+                # @param middleware [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middleware]
+                # @param args [Array]
+                # @param block [Proc]
+                # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Stack]
+                #
+                # @see https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware/builder.rb#L118
+                #
+                def replace(index_or_middleware, middleware, *args, &block)
+                  plain_stack.replace(index_or_middleware, middleware, *args, &block)
+
+                  self
+                end
+
+                ##
+                # @param index_or_middleware [Integer, ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middleware]
+                # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Stack]
+                #
+                # @see https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware/builder.rb#L126
+                #
+                def delete(index_or_middleware)
+                  plain_stack.delete(index_or_middleware)
+
+                  self
+                end
+
+                ##
+                # @param middleware [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middleware]
+                # @param args [Array]
+                # @param block [Proc]
+                # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Stack]
+                #
+                # @see https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware/builder.rb#L76
+                #
+                def use(middleware, *args, &block)
+                  plain_stack.use(middleware, *args, &block)
+
+                  self
+                end
+
+                ##
+                # @return [Boolean]
+                #
+                def empty?
+                  to_a.empty?
+                end
+
+                ##
+                # @param other [ConvenientService::Core::Entities::Config::Entities::Concerns::Entities::Stack, Object]
+                # @return [Boolean, nil]
+                #
+                def ==(other)
+                  return unless other.instance_of?(self.class)
+
+                  return false if plain_stack != other.plain_stack
+
+                  true
+                end
+
+                ##
+                # @return [Array<ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middleware>]
+                #
+                def to_a
+                  plain_stack.to_a
+                end
+
+                protected
+
+                ##
+                # @!attribute [r] plain_stack
+                #   @return [ConvenientService::Support::Middleware::StackBuilder]
+                #
+                attr_reader :plain_stack
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "entities/caller"
+require_relative "entities/chain"
+require_relative "entities/container"
+require_relative "entities/middleware"
+require_relative "entities/stack"