convenient_service 0.1.0

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

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class Concerns
+            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
+
+                ##
+                # Calls stack. In other words, invokes all its middlewares.
+                #
+                # Wraps `RubyMiddleware::Middleware::Builder#call`.
+                # @see https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware/builder.rb#L132
+                #
+                # @param env [Hash]
+                # @return Value of the last middleware invocation in the stack.
+                #
+                def call(env)
+                  plain_stack.call(env)
+                end
+
+                ##
+                # @param index_or_concern [Integer, ConvenientService::Support::Concern, Module]
+                # @param concern [ConvenientService::Support::Concern, Module]
+                # @param args [Array]
+                # @param block [Proc]
+                # @return [ConvenientService::Core::Entities::Config::Entities::Concerns::Entities::Stack]
+                #
+                # @see https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware/builder.rb#L88
+                #
+                def insert(index_or_concern, concern, *args, &block)
+                  plain_stack.insert(cast(index_or_concern), cast(concern), *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_concern [Integer, ConvenientService::Support::Concern, Module]
+                # @param concern [ConvenientService::Support::Concern, Module]
+                # @param args [Array]
+                # @param block [Proc]
+                # @return [ConvenientService::Core::Entities::Config::Entities::Concerns::Entities::Stack]
+                #
+                # @see https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware/builder.rb#L97
+                #
+                def insert_after(index_or_concern, concern, *args, &block)
+                  plain_stack.insert_after(cast(index_or_concern), cast(concern), *args, &block)
+
+                  self
+                end
+
+                ##
+                # @param concern [ConvenientService::Support::Concern, Module]
+                # @param args [Array]
+                # @param block [Proc]
+                # @return [ConvenientService::Core::Entities::Config::Entities::Concerns::Entities::Stack]
+                #
+                # @see https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware/builder.rb#L104
+                #
+                def insert_before_each(concern, *args, &block)
+                  plain_stack.insert_before_each(cast(concern), *args, &block)
+
+                  self
+                end
+
+                ##
+                # @param concern [ConvenientService::Support::Concern, Module]
+                # @return [ConvenientService::Core::Entities::Config::Entities::Concerns::Entities::Stack]
+                #
+                # @see https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware/builder.rb#L111
+                #
+                def insert_after_each(concern, *args, &block)
+                  plain_stack.insert_after_each(cast(concern), *args, &block)
+
+                  self
+                end
+
+                ##
+                # @param index_or_concern [Integer, ConvenientService::Support::Concern, Module]
+                # @param concern [ConvenientService::Support::Concern, Module]
+                # @param args [Array]
+                # @param block [Proc]
+                # @return [ConvenientService::Core::Entities::Config::Entities::Concerns::Entities::Stack]
+                #
+                # @see https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware/builder.rb#L118
+                #
+                def replace(index_or_concern, concern, *args, &block)
+                  plain_stack.replace(cast(index_or_concern), cast(concern), *args, &block)
+
+                  self
+                end
+
+                ##
+                # @param index_or_concern [Integer, ConvenientService::Support::Concern, Module]
+                # @return [ConvenientService::Core::Entities::Config::Entities::Concerns::Entities::Stack]
+                #
+                # @see https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware/builder.rb#L126
+                #
+                def delete(index_or_concern)
+                  plain_stack.delete(cast(index_or_concern))
+
+                  self
+                end
+
+                ##
+                # @param concern [ConvenientService::Support::Concern, Module]
+                # @param args [Array]
+                # @param block [Proc]
+                # @return [ConvenientService::Core::Entities::Config::Entities::Concerns::Entities::Stack]
+                #
+                # @see https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware/builder.rb#L76
+                #
+                def use(concern, *args, &block)
+                  plain_stack.use(cast(concern), *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::Concerns::Entities::Middleware>]
+                #
+                def to_a
+                  plain_stack.to_a
+                end
+
+                protected
+
+                ##
+                # @!attribute [r] stack
+                #   @return [ConvenientService::Support::Middleware::StackBuilder]
+                #
+                attr_reader :plain_stack
+
+                private
+
+                ##
+                # @param value [Integer, ConvenientService::Support::Concern, Module]
+                # @return [Class]
+                #
+                def cast(value)
+                  return value if value.is_a?(::Integer)
+
+                  Entities::Middleware.cast!(value)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "entities/default_concern"
+require_relative "entities/stack"
+require_relative "entities/middleware"

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

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require_relative "concerns/entities"
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class Concerns
+            ##
+            # @param klass [Class]
+            # @return [void]
+            #
+            def initialize(klass:)
+              @klass = klass
+            end
+
+            ##
+            # @param method_name [Symbol, String]
+            # @return [Boolean]
+            #
+            def instance_method_defined?(method_name)
+              return true if instance_method_defined_in_instance_methods_modules?(method_name)
+              return true if instance_method_defined_directly?(method_name)
+
+              false
+            end
+
+            ##
+            # @param method_name [Symbol, String]
+            # @return [Boolean]
+            #
+            def private_instance_method_defined?(method_name)
+              return true if private_instance_method_defined_in_instance_methods_modules?(method_name)
+              return true if private_instance_method_defined_directly?(method_name)
+
+              false
+            end
+
+            ##
+            # @param method_name [Symbol, String]
+            # @return [Boolean]
+            #
+            def class_method_defined?(method_name)
+              class_method_defined_in_class_methods_modules?(method_name)
+            end
+
+            ##
+            # @param method_name [Symbol, String]
+            # @return [Boolean]
+            #
+            def private_class_method_defined?(method_name)
+              private_class_method_defined_in_class_methods_modules?(method_name)
+            end
+
+            ##
+            # Checks whether concerns are included into klass (include! was called at least once).
+            #
+            # @return [Boolean]
+            #
+            # @internal
+            #   IMPORTANT: `included?` should be thread-safe.
+            #
+            def included?
+              klass.include?(Entities::DefaultConcern)
+            end
+
+            ##
+            # @param configuration_block [Proc]
+            # @return [ConvenientService::Core::Entities::Config::Entities::Concerns]
+            #
+            def configure(&configuration_block)
+              Utils::Proc.exec_config(configuration_block, stack)
+
+              self
+            end
+
+            ##
+            # Includes concerns into klass when called for the first time.
+            # Does nothing for the subsequent calls.
+            #
+            # @return [Boolean] true if called for the first time, false otherwise (similarly as Kernel#require).
+            #
+            # @see https://ruby-doc.org/core-3.1.2/Kernel.html#method-i-require
+            #
+            # @internal
+            #   NOTE: Modification of instance variable is NOT thread-safe, that is why `Entities::DefaultConcern` is added.
+            #   NOTE: `dup` is used for thread-safety as well.
+            #
+            def include!
+              return false if included?
+
+              stack.dup.insert_before(0, Entities::DefaultConcern).call(klass: klass)
+
+              true
+            end
+
+            ##
+            # @param other [ConvenientService::Core::Entities::Config::Entities::Concerns, Object]
+            # @return [Boolean, nil]
+            #
+            def ==(other)
+              return unless other.instance_of?(self.class)
+
+              return false if klass != other.klass
+              return false if stack != other.stack
+
+              true
+            end
+
+            ##
+            # @return [Array<Module>] concerns as plain modules.
+            #
+            def to_a
+              plain_concerns
+            end
+
+            protected
+
+            ##
+            # @!attribute [r] klass
+            #   @return [Class]
+            #
+            attr_reader :klass
+
+            ##
+            # @return [ConvenientService::Core::Entities::Config::Entities::Concerns::Entities::Stack]
+            #
+            def stack
+              @stack ||= Entities::Stack.new(name: stack_name)
+            end
+
+            private
+
+            ##
+            # @return [Array<Module>]
+            #
+            def plain_concerns
+              stack.to_a.map(&:first).map(&:concern)
+            end
+
+            ##
+            # @param method_name [Symbol, String]
+            # @return [Boolean]
+            #
+            def instance_method_defined_directly?(method_name)
+              plain_concerns.any? { |concern| concern.method_defined?(method_name) }
+            end
+
+            ##
+            # @param method_name [Symbol, String]
+            # @return [Boolean]
+            #
+            def private_instance_method_defined_directly?(method_name)
+              plain_concerns.any? { |concern| concern.private_method_defined?(method_name) }
+            end
+
+            ##
+            # @param method_name [Symbol, String]
+            # @return [Boolean]
+            #
+            def instance_method_defined_in_instance_methods_modules?(method_name)
+              instance_methods_modules.any? { |mod| mod.method_defined?(method_name) }
+            end
+
+            ##
+            # @param method_name [Symbol, String]
+            # @return [Boolean]
+            #
+            def private_instance_method_defined_in_instance_methods_modules?(method_name)
+              instance_methods_modules.any? { |mod| mod.private_method_defined?(method_name) }
+            end
+
+            ##
+            # @param method_name [Symbol, String]
+            # @return [Boolean]
+            #
+            def class_method_defined_in_class_methods_modules?(method_name)
+              class_methods_modules.any? { |mod| mod.method_defined?(method_name) }
+            end
+
+            ##
+            # @param method_name [Symbol, String]
+            # @return [Boolean]
+            #
+            def private_class_method_defined_in_class_methods_modules?(method_name)
+              class_methods_modules.any? { |mod| mod.private_method_defined?(method_name) }
+            end
+
+            ##
+            # @return [Array<Module>]
+            #
+            def instance_methods_modules
+              plain_concerns.filter_map { |concern| Utils::Module.get_own_const(concern, :InstanceMethods) }
+            end
+
+            ##
+            # @return [Array<Module>]
+            #
+            def class_methods_modules
+              plain_concerns.filter_map { |concern| Utils::Module.get_own_const(concern, :ClassMethods) }
+            end
+
+            ##
+            # @return [String]
+            #
+            def stack_name
+              "Concerns::#{klass}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Commands
+              class GenerateStackName < Support::Command
+                ##
+                # @!attribute [r] scope
+                #   @return [:instance, :class]
+                #
+                attr_reader :scope
+
+                ##
+                # @!attribute [r] method
+                #   @return [Symbol, String]
+                #
+                attr_reader :method
+
+                ##
+                # @!attribute [r] container
+                #   @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Container]
+                #
+                attr_reader :container
+
+                ##
+                # @param scope [:instance, :class]
+                # @param method [Symbol, String]
+                # @param container [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Container]
+                # @return [void]
+                #
+                def initialize(scope:, method:, container:)
+                  @method = method
+                  @scope = scope
+                  @container = container
+                end
+
+                ##
+                # @return [String]
+                #
+                def call
+                  "#{formatted_container}::MethodMiddlewares::#{formatted_scope}::#{formatted_method}"
+                end
+
+                ##
+                # @return [String]
+                #
+                def formatted_container
+                  container.klass
+                end
+
+                ##
+                # @return [String]
+                #
+                def formatted_scope
+                  Utils::String.camelize(scope)
+                end
+
+                ##
+                # @return [String]
+                #
+                def formatted_method
+                  "#{formatted_method_infix}#{formatted_method_suffix}"
+                end
+
+                ##
+                # @return [String]
+                #
+                # @see https://www.britannica.com/topic/affix
+                #
+                def formatted_method_infix
+                  Utils::String.camelize(method)
+                end
+
+                ##
+                # @return [String]
+                #
+                def formatted_method_suffix
+                  if method.end_with?("?")
+                    "QuestionMark"
+                  elsif method.end_with?("!")
+                    "ExclamationMark"
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "commands/generate_stack_name"

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              class Caller
+                module Commands
+                  class CastCaller < Support::Command
+                    ##
+                    # @!attribute [r] other
+                    #   @return [Hash]
+                    #
+                    attr_reader :other
+
+                    ##
+                    # @param other [Hash, ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Caller]
+                    # @return [void]
+                    #
+                    def initialize(other:)
+                      @other = other
+                    end
+
+                    ##
+                    # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Caller, nil]
+                    #
+                    def call
+                      case other
+                      when ::Hash
+                        cast_hash(other)
+                      when Caller
+                        cast_caller(other)
+                      end
+                    end
+
+                    private
+
+                    ##
+                    # @param hash [Hash]
+                    # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Caller, nil]
+                    #
+                    def cast_hash(hash)
+                      return unless hash[:scope]
+
+                      case hash[:scope]
+                      when :instance
+                        Caller.new(prefix: Caller::INSTANCE_PREFIX)
+                      when :class
+                        Caller.new(prefix: Caller::CLASS_PREFIX)
+                      end
+                    end
+
+                    ##
+                    # @param caller [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Caller]
+                    # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Caller]
+                    #
+                    def cast_caller(caller)
+                      caller.copy
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end