convenient_service 0.1.0

data/lib/convenient_service/configs/standard.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Configs
+    module Standard
+      include Support::Concern
+
+      ##
+      # IMPORTANT: Order of plugins matters.
+      #
+      # NOTE: `class_exec` (that is used under the hood by `included`) defines `class Result` in the global namespace.
+      # That is why `class self::Result` is used.
+      #
+      # https://stackoverflow.com/a/51965126/12201472
+      #
+      # rubocop:disable Lint/ConstantDefinitionInBlock
+      included do
+        include Core
+
+        concerns do
+          use Plugins::Common::HasInternals::Concern
+          use Plugins::Common::HasConstructor::Concern
+
+          use Plugins::Common::CachesConstructorParams::Concern
+          use Plugins::Common::CanBeCopied::Concern
+          use Plugins::Service::HasResult::Concern
+          use Plugins::Service::HasResultShortSyntax::Concern
+          use Plugins::Service::HasResultSteps::Concern
+          use Plugins::Service::CanRecalculateResult::Concern
+
+          use Plugins::Common::HasCallbacks::Concern
+          use Plugins::Common::HasAroundCallbacks::Concern
+
+          ##
+          # NOTE: Optional plugins.
+          # TODO: Specs.
+          #
+          #   use Plugins::Common::HasConfig::Concern
+          #
+        end
+
+        middlewares :initialize do
+          use Plugins::Common::NormalizesEnv::Middleware
+
+          use Plugins::Common::CachesConstructorParams::Middleware
+        end
+
+        middlewares :result do
+          use Plugins::Common::NormalizesEnv::Middleware
+
+          use Plugins::Service::HasResult::Middleware
+
+          use Plugins::Service::HasResultSteps::Middleware
+
+          use Plugins::Common::HasCallbacks::Middleware
+          use Plugins::Common::HasAroundCallbacks::Middleware
+
+          use Plugins::Service::RaisesOnDoubleResult::Middleware
+
+          use Plugins::Common::CachesReturnValue::Middleware
+        end
+
+        middlewares :success do
+          use Plugins::Common::NormalizesEnv::Middleware
+
+          use Plugins::Service::HasResultShortSyntax::Success::Middleware
+        end
+
+        middlewares :failure do
+          use Plugins::Common::NormalizesEnv::Middleware
+
+          use Plugins::Service::HasResultShortSyntax::Failure::Middleware
+        end
+
+        middlewares :error do
+          use Plugins::Common::NormalizesEnv::Middleware
+
+          use Plugins::Service::HasResultShortSyntax::Error::Middleware
+        end
+
+        middlewares :step, scope: :class do
+          use Plugins::Common::NormalizesEnv::Middleware
+
+          use Plugins::Service::HasResultMethodSteps::Middleware
+        end
+
+        class self::Internals
+          include Core
+
+          concerns do
+            use Plugins::Internals::HasCache::Concern
+          end
+        end
+
+        class self::Result
+          include Core
+
+          concerns do
+            use Plugins::Common::HasInternals::Concern
+
+            use Plugins::Result::HasResultShortSyntax::Concern
+            use Plugins::Result::CanRecalculateResult::Concern
+          end
+
+          middlewares :success? do
+            use Plugins::Common::NormalizesEnv::Middleware
+
+            use Plugins::Result::MarksResultStatusAsChecked::Middleware
+          end
+
+          middlewares :failure? do
+            use Plugins::Common::NormalizesEnv::Middleware
+
+            use Plugins::Result::MarksResultStatusAsChecked::Middleware
+          end
+
+          middlewares :error? do
+            use Plugins::Common::NormalizesEnv::Middleware
+
+            use Plugins::Result::MarksResultStatusAsChecked::Middleware
+          end
+
+          middlewares :not_success? do
+            use Plugins::Common::NormalizesEnv::Middleware
+
+            use Plugins::Result::MarksResultStatusAsChecked::Middleware
+          end
+
+          middlewares :not_failure? do
+            use Plugins::Common::NormalizesEnv::Middleware
+
+            use Plugins::Result::MarksResultStatusAsChecked::Middleware
+          end
+
+          middlewares :not_error? do
+            use Plugins::Common::NormalizesEnv::Middleware
+
+            use Plugins::Result::MarksResultStatusAsChecked::Middleware
+          end
+
+          middlewares :data do
+            use Plugins::Common::NormalizesEnv::Middleware
+
+            use Plugins::Result::RaisesOnNotCheckedResultStatus::Middleware
+          end
+
+          middlewares :message do
+            use Plugins::Common::NormalizesEnv::Middleware
+
+            use Plugins::Result::RaisesOnNotCheckedResultStatus::Middleware
+          end
+
+          middlewares :code do
+            use Plugins::Common::NormalizesEnv::Middleware
+
+            use Plugins::Result::RaisesOnNotCheckedResultStatus::Middleware
+          end
+
+          class self::Internals
+            include Core
+
+            concerns do
+              use Plugins::Internals::HasCache::Concern
+            end
+          end
+        end
+
+        class self::Step
+          include Core
+
+          concerns do
+            use Plugins::Common::HasInternals::Concern
+          end
+
+          middlewares :result do
+            use Plugins::Common::NormalizesEnv::Middleware
+
+            use Plugins::Common::CachesReturnValue::Middleware
+          end
+
+          class self::Internals
+            include Core
+
+            concerns do
+              use Plugins::Internals::HasCache::Concern
+            end
+          end
+        end
+      end
+      # rubocop:enable Lint/ConstantDefinitionInBlock
+    end
+  end
+end

data/lib/convenient_service/configs.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "configs/standard"
+
+require_relative "configs/aliases"

data/lib/convenient_service/core/aliases.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    ClassicMiddleware = ::ConvenientService::Core::Entities::ClassicMiddleware
+    ConcernMiddleware = ::ConvenientService::Core::Entities::Config::Entities::Concerns::Entities::Middleware
+    MethodChainMiddleware = ::ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middleware
+  end
+end

data/lib/convenient_service/core/class_methods.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module ClassMethods
+      ##
+      # @see ConvenientService::Core::Entities::Config#concerns
+      #
+      def concerns(...)
+        (@__config__ ||= Entities::Config.new(klass: self)).concerns(...)
+      end
+
+      ##
+      # @see ConvenientService::Core::Entities::Config#middlewares
+      #
+      def middlewares(...)
+        (@__config__ ||= Entities::Config.new(klass: self)).middlewares(...)
+      end
+
+      ##
+      # Commits config 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
+      #
+      def commit_config!
+        (@__config__ ||= Entities::Config.new(klass: self)).commit!
+          .tap { ConvenientService.logger.debug { "[Core] Committed config for `#{self}` | Triggered by `.commit_config!`" } }
+      end
+
+      ##
+      # @see https://thoughtbot.com/blog/always-define-respond-to-missing-when-overriding
+      # @see https://stackoverflow.com/a/3304683/12201472
+      #
+      # @param method_name [Symbol, String]
+      # @param include_private [Boolean]
+      # @return [Boolean]
+      #
+      def respond_to_missing?(method_name, include_private = false)
+        return true if singleton_class.method_defined?(method_name)
+        return true if concerns.class_method_defined?(method_name)
+
+        if include_private
+          return true if singleton_class.private_method_defined?(method_name)
+          return true if concerns.private_class_method_defined?(method_name)
+        end
+
+        false
+      end
+
+      private
+
+      ##
+      # Includes `concerns` into the mixing class.
+      # If `method` is still NOT defined, raises `NoMethodError`, otherwise - retries to call the `method`.
+      #
+      # @param method [Symbol]
+      # @param args [Array<Object>]
+      # @param kwargs [Hash<Symbol, Object>]
+      # @param block [Proc]
+      # @return [void]
+      #
+      # @internal
+      #   IMPORTANT: `method_missing` should be thread-safe.
+      #
+      def method_missing(method, *args, **kwargs, &block)
+        commit_config!
+
+        return super unless Utils::Module.class_method_defined?(self, method, private: true)
+
+        return super if middlewares(method, scope: :class).defined_without_super_method?
+
+        ConvenientService.logger.debug { "[Core] Committed config for `#{self}` | Triggered by `method_missing` | Method: `.#{method}`" }
+
+        __send__(method, *args, **kwargs, &block)
+      end
+    end
+  end
+end

data/lib/convenient_service/core/entities/classic_middleware.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class ClassicMiddleware
+        ##
+        # @param stack [#call<Hash>]
+        # @return [void]
+        #
+        def initialize(stack)
+          @stack = stack
+        end
+
+        ##
+        # @return [Object] Can be any type.
+        #
+        def call(env)
+          stack.call(env)
+        end
+
+        private
+
+        ##
+        # @!attribute [r] stack
+        #   @return [#call<Hash>]
+        #
+        attr_reader :stack
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class Concerns
+            module Entities
+              module DefaultConcern
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/core/entities/config/entities/concerns/entities/middleware/commands/cast_middleware.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class Concerns
+            module Entities
+              class Middleware
+                module Commands
+                  class CastMiddleware < Support::Command
+                    ##
+                    # @!attribute [r] other
+                    #   @return [Module, ConvenientService::Support::Concern]
+                    #
+                    attr_reader :other
+
+                    ##
+                    # @param other [Module, ConvenientService::Support::Concern, ConvenientService::Core::Entities::Config::Entities::Concerns::Entities::Middleware]
+                    # @return [void]
+                    #
+                    def initialize(other:)
+                      @other = other
+                    end
+
+                    ##
+                    # @return [ConvenientService::Core::Entities::Config::Entities::Concerns::Entities::Middleware, nil]
+                    #
+                    def call
+                      if other.instance_of?(Class) && other < Entities::Middleware
+                        cast_middleware(other)
+                      elsif other.instance_of?(Module)
+                        cast_module(other)
+                      end
+                    end
+
+                    private
+
+                    ##
+                    # @param mod [Module, ConvenientService::Support::Concern]
+                    # @return [ConvenientService::Core::Entities::Config::Entities::Concerns::Entities::Middleware]
+                    #
+                    # @internal
+                    #   NOTE: `ruby-middleware` expects a `Class` or object that responds to `call`.
+                    #   https://github.com/Ibsciss/ruby-middleware/blob/v0.4.2/lib/middleware/runner.rb#L52
+                    #   https://github.com/Ibsciss/ruby-middleware#middleware-lambdas
+                    #
+                    #   IMPORTANT: Must be kept in sync with `def concern` in `ConvenientService::Core::Entities::Config::Entities::Concerns::Middleware`.
+                    #
+                    def cast_module(mod)
+                      middleware = ::Class.new(Entities::Middleware)
+
+                      ##
+                      # @return [Module, ConvenientService::Support::Concern]
+                      #
+                      middleware.define_singleton_method(:concern) { mod }
+
+                      middleware
+                    end
+
+                    ##
+                    # @param middleware [ConvenientService::Core::Entities::Config::Entities::Concerns::Entities::Middleware]
+                    # @return [ConvenientService::Core::Entities::Config::Entities::Concerns::Entities::Middleware]
+                    #
+                    def cast_middleware(middleware)
+                      middleware.dup
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative "middleware/commands"
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class Concerns
+            module Entities
+              class Middleware
+                include Support::Castable
+
+                ##
+                # @param stack [#call<Hash>]
+                # @return [void]
+                #
+                def initialize(stack)
+                  @stack = stack
+                end
+
+                class << self
+                  ##
+                  # @internal
+                  #   TODO: Why regular `include Support::AbstractMethod` does NOT work?.
+                  #
+                  extend Support::AbstractMethod::ClassMethods
+
+                  ##
+                  # @return [ConvenientService::Support::Concern, Module]
+                  #
+                  abstract_method :concern
+
+                  ##
+                  # @param other [ConvenientService::Support::Concern, Module]
+                  # @return [ConvenientService::Core::Entities::Config::Entities::Concerns::Entities::Middleware, nil]
+                  #
+                  def cast(other)
+                    Commands::CastMiddleware.call(other: other)
+                  end
+
+                  ##
+                  # @return [Boolean]
+                  #
+                  # @internal
+                  #   NOTE: `@param other [Module, ConvenientService::Support::Concern, ConvenientService::Core::Entities::Config::Entities::Concerns::Entities::Middleware]`
+                  #   TODO: How to document `alias_method`?
+                  #
+                  #   https://ruby-doc.org/core-2.7.0/Module.html#method-i-3D-3D
+                  #
+                  alias_method :original_two_equals, :==
+
+                  ##
+                  # @param other [Module, ConvenientService::Support::Concern, ConvenientService::Core::Entities::Config::Entities::Concerns::Entities::Middleware]
+                  # @return [Boolean]
+                  #
+                  # @internal
+                  #   https://ruby-doc.org/core-2.7.0/Module.html#method-i-3C
+                  #
+                  def ==(other)
+                    return true if original_two_equals(other)
+
+                    return unless other.instance_of?(Class)
+                    return unless other < Entities::Middleware
+
+                    concern == other.concern
+                  end
+                end
+
+                ##
+                # @param env [Hash]
+                # @option env [Class] :klass
+                #
+                # @return [void]
+                #
+                def call(env)
+                  env[:klass].include concern
+
+                  @stack.call(env)
+                end
+
+                private
+
+                ##
+                # @return [Module, ConvenientService::Support::Concern]
+                #
+                # @internal
+                #   NOTE: `self.class.concern` is overridden by descendants. Descendants are created dynamically. See `Concerns::MiddlewareStack#cast`.
+                #
+                #   IMPORTANT: Must be kept in sync with `cast` in `ConvenientService::Core::Entities::Config::Entities::Concerns::MiddlewareStack`.
+                #
+                def concern
+                  self.class.concern
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end