convenient_service 0.1.0

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

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require_relative "method_middlewares/commands"
+require_relative "method_middlewares/entities"
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            include Support::Delegate
+
+            ##
+            # @param scope [:instance, :class]
+            # @param method [Symbol, String]
+            # @param klass [Class]
+            # @return [void]
+            #
+            def initialize(scope:, method:, klass:)
+              @scope = scope
+              @method = method
+              @klass = klass
+            end
+
+            ##
+            # @param entity [Object, Class]
+            # @return [String]
+            #
+            def no_super_method_exception_message_for(entity)
+              "super: no superclass method `#{method}' for #{entity}"
+            end
+
+            ##
+            # @return [Boolean]
+            #
+            def defined?
+              Utils::Module.has_own_instance_method?(methods_middlewares_callers, method)
+            end
+
+            ##
+            # @return [Boolean]
+            #
+            def super_method_defined?
+              container.super_method_defined?(method)
+            end
+
+            ##
+            # @return [Boolean]
+            #
+            def defined_without_super_method?
+              self.defined? && !super_method_defined?
+            end
+
+            ##
+            # @param configuration_block [Proc]
+            # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares]
+            #
+            def configure(&configuration_block)
+              Utils::Proc.exec_config(configuration_block, stack)
+
+              self
+            end
+
+            ##
+            # @note: Works in a similar way as `Kernel.require`.
+            #
+            # @return [Boolean]
+            #
+            def define!
+              caller.define_method_middlewares_caller!(scope, method, container)
+            end
+
+            ##
+            # @param env [Hash]
+            # @param original_method [Proc]
+            # @return [Object]
+            #
+            # @internal
+            #   NOTE: Stack is copied in order to be thread-safe (`stack.dup`).
+            #   NOTE: Stack backend will be rewritten in Core v3 in order to optimize performance of `stack.dup`.
+            #   TODO: Measure before any rewrite.
+            #
+            def call(env, original_method)
+              stack.dup.use(original_method).call(env.merge(method: method))
+            end
+
+            ##
+            # @param entity [Object, Class]
+            # @return [Method, nil]
+            #
+            # @internal
+            #   NOTE: Consider to remove when support for Ruby 2.7 is dropped.
+            #
+            def resolve_super_method(entity)
+              klass.commit_config!
+
+              container.resolve_super_method(method, entity)
+            end
+
+            ##
+            # @param other [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares, Object]
+            # @return [Boolean, nil]
+            #
+            def ==(other)
+              return unless other.instance_of?(self.class)
+
+              return false if scope != other.scope
+              return false if method != other.method
+              return false if klass != other.klass
+              return false if stack != other.stack
+
+              true
+            end
+
+            ##
+            # @return [Array<ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middleware>]
+            #
+            def to_a
+              stack.to_a.map(&:first)
+            end
+
+            protected
+
+            ##
+            # @!attribute [r] scope
+            #   @return [:instance, :class]
+            #
+            attr_reader :scope
+
+            ##
+            # @!attribute [r] method
+            #   @return [Symbol, String]
+            #
+            attr_reader :method
+
+            ##
+            # @!attribute [r] klass
+            #   @return [Symbol, String]
+            #
+            attr_reader :klass
+
+            ##
+            # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Stack]
+            #
+            def stack
+              @stack ||= Entities::Stack.new(name: stack_name)
+            end
+
+            private
+
+            ##
+            # @return [Module]
+            #
+            delegate :methods_middlewares_callers, to: :container
+
+            ##
+            # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Caller]
+            #
+            def caller
+              @caller ||= Entities::Caller.cast!({scope: scope})
+            end
+
+            ##
+            # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Container]
+            #
+            def container
+              @container ||= Entities::Container.cast!({scope: scope, klass: klass})
+            end
+
+            ##
+            # @return [String]
+            #
+            def stack_name
+              @stack_name ||= Commands::GenerateStackName.call(method: method, scope: scope, container: container)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "entities/concerns"
+require_relative "entities/method_middlewares"

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Errors
+          class ConfigIsCommitted < ConvenientService::Error
+            ##
+            # @param config [ConvenientService::Core::Entities::Config]
+            # @return [void]
+            #
+            def initialize(config:)
+              message = <<~TEXT
+                Config for `#{config.klass}` is already committed. Only uncommitted configs can be modified.
+
+                Did you accidentally call `concerns(&configuration_block)` or `middlewares(method, scope: scope, &configuration_block)` after using any plugin, after calling `commit_config!`?
+              TEXT
+
+              super(message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require_relative "config/entities"
+require_relative "config/errors"
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        ##
+        # @!attribute [r] klass
+        #   @return [Class]
+        #
+        attr_reader :klass
+
+        ##
+        # @param klass [Class]
+        # @return [void]
+        #
+        def initialize(klass:)
+          @klass = klass
+        end
+
+        ##
+        # Sets or gets concerns for a service class.
+        #
+        # @overload concerns
+        #   Returns all concerns.
+        #   @return [ConvenientService::Core::Entities::Config::Entities::Concerns]
+        #
+        # @overload concerns(&configuration_block)
+        #   Configures concerns.
+        #   @param configuration_block [Proc] Block that configures middlewares.
+        #   @see https://github.com/marian13/ruby-middleware#a-basic-example
+        #   @return [ConvenientService::Core::Entities::Config::Entities::Concerns]
+        #
+        # @example Getter
+        #   concerns
+        #
+        # @example Setter
+        #   concerns(&configuration_block)
+        #
+        def concerns(&configuration_block)
+          if configuration_block
+            assert_not_committed!
+
+            @concerns ||= Entities::Concerns.new(klass: klass)
+            @concerns.configure(&configuration_block)
+          end
+
+          @concerns || Entities::Concerns.new(klass: klass)
+        end
+
+        ##
+        # Sets or gets middlewares for a service class.
+        #
+        # @overload middlewares(method)
+        #   Returns all instance middlewares for particular method.
+        #   @param method [Symbol] Method name.
+        #   @return [Hash<Symbol, Hash<Symbol, ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares>>]
+        #
+        # @overload middlewares(method, scope:)
+        #   Returns all scoped middlewares for particular method.
+        #   @param method [Symbol] Method name.
+        #   @param scope [:instance, :class]
+        #   @return [Hash<Symbol, Hash<Symbol, ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares>>]
+        #
+        # @overload middlewares(method, &configuration_block)
+        #   Configures instance middlewares for particular method.
+        #   @param method [Symbol] Method name.
+        #   @param configuration_block [Proc] Block that configures middlewares.
+        #   @see https://github.com/marian13/ruby-middleware#a-basic-example
+        #   @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares]
+        #
+        # @overload middlewares(method, scope:, &configuration_block)
+        #   Configures scoped middlewares for particular method.
+        #   @param method [Symbol] Method name.
+        #   @param scope [:instance, :class]
+        #   @param configuration_block [Proc] Block that configures middlewares.
+        #   @see https://github.com/marian13/ruby-middleware#a-basic-example
+        #   @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares]
+        #
+        # @example Getters
+        #   middlewares(:result)
+        #   middlewares(:result, scope: :instance)
+        #   middlewares(:result, scope: :class)
+        #
+        # @example Setters
+        #   middlewares(:result, &configuration_block)
+        #   middlewares(:result, scope: :instance, &configuration_block)
+        #   middlewares(:result, scope: :class, &configuration_block)
+        #
+        def middlewares(method, scope: :instance, &configuration_block)
+          @middlewares ||= {}
+          @middlewares[scope] ||= {}
+
+          if configuration_block
+            assert_not_committed!
+
+            @middlewares[scope][method] ||= Entities::MethodMiddlewares.new(scope: scope, method: method, klass: klass)
+            @middlewares[scope][method].configure(&configuration_block)
+            @middlewares[scope][method].define!
+          end
+
+          @middlewares[scope][method] || Entities::MethodMiddlewares.new(scope: scope, method: method, klass: klass)
+        end
+
+        ##
+        # @return [Boolean]
+        #
+        def committed?
+          concerns.included?
+        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!
+          concerns.include!
+        end
+
+        private
+
+        ##
+        # @note: Config is committed either by `commit_config` or `method_missing` from `ConvenientService::Core::ClassMethods`.
+        #
+        # @return [void]
+        # @raise [ConvenientService::Core::Entities::Config::Errors::ConfigIsCommitted]
+        #
+        # @internal
+        #   NOTE: Concerns must be included only once since Ruby does NOT allow to modify the order of modules in the inheritance chain.
+        #   TODO: Redesign core to have an ability to change order of included/extended modules in v3? Does it really worth it?
+        #
+        def assert_not_committed!
+          return unless committed?
+
+          raise Errors::ConfigIsCommitted.new(config: self)
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/core/entities.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "entities/classic_middleware"
+require_relative "entities/config"

data/lib/convenient_service/core/instance_methods.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module InstanceMethods
+      ##
+      # @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 self.class.method_defined?(method_name)
+        return true if self.class.concerns.instance_method_defined?(method_name)
+
+        if include_private
+          return true if self.class.private_method_defined?(method_name)
+          return true if self.class.concerns.private_instance_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)
+        self.class.commit_config!
+
+        return super unless Utils::Module.instance_method_defined?(self.class, method, private: true)
+
+        return super if self.class.middlewares(method, scope: :instance).defined_without_super_method?
+
+        ConvenientService.logger.debug { "[Core] Committed config for `#{self.class}` | Triggered by `method_missing` | Method: `##{method}`" }
+
+        __send__(method, *args, **kwargs, &block)
+      end
+    end
+  end
+end

data/lib/convenient_service/core.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "core/instance_methods"
+require_relative "core/class_methods"
+
+require_relative "core/entities"
+
+require_relative "core/aliases"
+
+module ConvenientService
+  module Core
+    include Support::Concern
+
+    included do |service_class|
+      service_class.include InstanceMethods
+      service_class.extend ClassMethods
+    end
+  end
+end

data/lib/convenient_service/dependencies/built_in.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+##
+# This file loads built-in dependencies (from Ruby standard library).
+#
+# @internal
+#   https://github.com/marian13/convenient_service/wiki/Docs:-Dependencies
+#
+
+##
+# @internal
+#   - https://ruby-doc.org/stdlib-2.7.0/libdoc/forwardable/rdoc/Forwardable.html
+#   - https://github.com/ruby/forwardable
+#
+require "forwardable"
+
+##
+# @internal
+#   - https://ruby-doc.org/stdlib-2.7.0/libdoc/logger/rdoc/Logger.html
+#   - https://github.com/ruby/logger
+#
+require "logger"
+
+##
+# @internal
+#   - https://ruby-doc.org/stdlib-2.7.0/libdoc/ostruct/rdoc/OpenStruct.html
+#   - https://github.com/ruby/ostruct
+#
+require "ostruct"
+
+##
+# @internal
+#   - https://ruby-doc.org/stdlib-2.7.0/libdoc/singleton/rdoc/Singleton.html
+#   - https://github.com/ruby/singleton
+#
+require "singleton"