convenient_service 0.12.0 → 0.14.0

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              module MiddlewareCreators
+                class Base
+                  include Support::Delegate
+
+                  ##
+                  # @!attribute [r] middleware
+                  #   @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middlewares::Base]
+                  #
+                  attr_reader :middleware
+
+                  ##
+                  # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middlewares::Base]
+                  #
+                  delegate :to_observable_middleware, to: :middleware
+
+                  ##
+                  # @return [void]
+                  #
+                  # @internal
+                  #   TODO: Verbose exception.
+                  #
+                  def initialize(**kwargs)
+                    @middleware = kwargs.fetch(:middleware)
+                  end
+
+                  ##
+                  # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::MiddlewareCreators::With]
+                  #
+                  def with(...)
+                    Entities::MiddlewareCreators::With.new(middleware: self, middleware_arguments: Support::Arguments.new(...))
+                  end
+
+                  ##
+                  # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::MiddlewareCreators::Observable]
+                  #
+                  def observable
+                    Entities::MiddlewareCreators::Observable.new(middleware: self)
+                  end
+
+                  ##
+                  # @param stack [#call<Hash>]
+                  # @param kwargs [Hash{Symbol => Object}]
+                  # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middlewares::Base]
+                  #
+                  def new(stack, **kwargs)
+                    decorated_middleware.new(stack, **[extra_kwargs, middleware.extra_kwargs, kwargs].reduce(:merge))
+                  end
+
+                  ##
+                  # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middlewares::Base]
+                  #
+                  # @note May be overridden by descendants.
+                  #
+                  def decorated_middleware
+                    middleware
+                  end
+
+                  ##
+                  # @return [Hash{Symbol => Object}]
+                  #
+                  # @note May be overridden by descendants.
+                  #
+                  def extra_kwargs
+                    {}
+                  end
+
+                  ##
+                  # @param other [Object]
+                  # @return [Boolean, nil]
+                  #
+                  def ==(other)
+                    return unless other.instance_of?(self.class)
+
+                    return false if middleware != other.middleware
+
+                    true
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/core/entities/config/entities/method_middlewares/entities/middleware_creators/observable/entities/event.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              module MiddlewareCreators
+                class Observable < MiddlewareCreators::Base
+                  module Entities
+                    class Event
+                      include ::Observable
+
+                      ##
+                      # @!attribute [r] type
+                      #   @return [Symbol]
+                      #
+                      attr_reader :type
+
+                      ##
+                      # @param type [Symbol]
+                      # @return [void]
+                      #
+                      def initialize(type:)
+                        @type = type
+                      end
+
+                      ##
+                      # @return [String]
+                      #
+                      def default_handler_name
+                        "handle_#{type}"
+                      end
+
+                      ##
+                      # @param observer [Object] Can be any type.
+                      # @return [void]
+                      #
+                      # @see https://ruby-doc.org/stdlib-2.7.0/libdoc/observer/rdoc/Observable.html#method-i-add_observer
+                      #
+                      def add_observer(observer, func = default_handler_name)
+                        super
+                      end
+
+                      ##
+                      # @return [void]
+                      #
+                      # @see https://ruby-doc.org/stdlib-2.7.0/libdoc/observer/rdoc/Observable.html#method-i-changed
+                      # @see https://ruby-doc.org/stdlib-2.7.0/libdoc/observer/rdoc/Observable.html#method-i-notify_observers
+                      #
+                      def notify_observers(...)
+                        changed
+
+                        super
+                      end
+
+                      ##
+                      # @param other [Object] Can be any type.
+                      # @return [Boolean, nil]
+                      #
+                      def ==(other)
+                        return unless other.instance_of?(self.class)
+
+                        return false if type != other.type
+                        return false if observer_peers != other.observer_peers
+
+                        true
+                      end
+
+                      protected
+
+                      ##
+                      # @return [Hash]
+                      #
+                      # @see https://ruby-doc.org/stdlib-2.7.0/libdoc/observer/rdoc/Observable.html#method-i-count_observers
+                      #
+                      # @internal
+                      #   IMPORTANT: This method is using inherited private instance varaible. Ruby may change its name without any warning.
+                      #
+                      def observer_peers
+                        @observer_peers if defined? @observer_peers
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "entities/event"

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "observable/entities"
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              module MiddlewareCreators
+                class Observable < MiddlewareCreators::Base
+                  ##
+                  # @return [Hash{Symbol => ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::MiddlewareCreators::Observable::Entities::Event}]
+                  #
+                  def middleware_events
+                    @middleware_events ||= ::Hash.new { |hash, key| hash[key] = Entities::Event.new(type: key) }
+                  end
+
+                  ##
+                  # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middlewares::Base]
+                  #
+                  def decorated_middleware
+                    middleware.to_observable_middleware
+                  end
+
+                  ##
+                  # @return [Hash{Symbol => Hash{Symbol => ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::MiddlewareCreators::Observable::Entities::Event}}]
+                  #
+                  def extra_kwargs
+                    {middleware_events: middleware_events}
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              module MiddlewareCreators
+                class With < MiddlewareCreators::Base
+                  ##
+                  # @!attribute [r] middleware_arguments
+                  #   @return [ConvenientService::Support::Arguments]
+                  #
+                  attr_reader :middleware_arguments
+
+                  ##
+                  # @param kwargs [Hash{Symbol => ConvenientService::Support::Arguments}]
+                  # @return [void]
+                  #
+                  def initialize(**kwargs)
+                    super
+
+                    @middleware_arguments = kwargs.fetch(:middleware_arguments) { Support::Arguments.null_arguments }
+                  end
+
+                  ##
+                  # @return [Hash{Symbol => ConvenientService::Support::Arguments}]
+                  #
+                  def extra_kwargs
+                    {middleware_arguments: middleware_arguments}
+                  end
+
+                  ##
+                  # @param other [Object] Can be any type.
+                  # @return [Boolean, nil]
+                  #
+                  def ==(other)
+                    super && Utils.to_bool(middleware_arguments == other.middleware_arguments)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "middleware_creators/base"
+
+require_relative "middleware_creators/observable"
+require_relative "middleware_creators/with"

data/lib/convenient_service/core/entities/config/entities/method_middlewares/entities/middlewares/base/commands/create_observable_middleware.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              module Middlewares
+                class Base
+                  module Commands
+                    class CreateObservableMiddleware < Support::Command
+                      ##
+                      # @!attribute [r] middleware
+                      #   @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middlewares::Base]
+                      #
+                      attr_reader :middleware
+
+                      ##
+                      # @param middleware [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middlewares::Base]
+                      # @return [void]
+                      #
+                      def initialize(middleware:)
+                        @middleware = middleware
+                      end
+
+                      ##
+                      # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middlewares::Base]
+                      #
+                      def call
+                        observable_middleware.class_exec(middleware) do |middleware|
+                          ##
+                          # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middlewares::Base]
+                          #
+                          define_singleton_method(:middleware) { middleware }
+
+                          ##
+                          # @param other [Object] Can be any type.
+                          # @return [Boolean, nil]
+                          #
+                          define_singleton_method(:==) { |other| self.middleware == other.middleware if other.respond_to?(:middleware) }
+
+                          ##
+                          # @return [String]
+                          #
+                          define_singleton_method(:inspect) { "Observable(#{middleware})" }
+                        end
+
+                        observable_middleware
+                      end
+
+                      private
+
+                      ##
+                      # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middlewares::Base]
+                      #
+                      def observable_middleware
+                        @observable_middleware ||=
+                          ::Class.new(middleware) do
+                            ##
+                            # @param stack [#call<Hash>]
+                            # @param kwargs [Hash{Symbol => Object}]
+                            # @return [void]
+                            #
+                            def initialize(stack, **kwargs)
+                              arguments = Support::Arguments.new(stack, **Utils::Hash.except(kwargs, [:middleware_events]))
+
+                              @__middleware_events__ = kwargs[:middleware_events]
+
+                              @__middleware_events__[:before_initialize].notify_observers(arguments)
+
+                              super(stack, **arguments.kwargs)
+
+                              @__middleware_events__[:after_initialize].notify_observers(arguments)
+                            end
+
+                            ##
+                            # @return [Object] Can be any type.
+                            #
+                            def call(...)
+                              arguments = Support::Arguments.new(...)
+
+                              @__middleware_events__[:before_call].notify_observers(arguments)
+
+                              value = super
+
+                              @__middleware_events__[:after_call].notify_observers(value, arguments)
+
+                              value
+                            end
+                          end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              module Middlewares
+                ##
+                # @abstract Subclass and override `#call`.
+                #
+                # @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 Base
+                  module Concern
+                    module ClassMethods
+                      ##
+                      # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::MiddlewareCreators::With]
+                      #
+                      def with(...)
+                        Entities::MiddlewareCreators::With.new(middleware: self, middleware_arguments: Support::Arguments.new(...))
+                      end
+
+                      ##
+                      # @return [ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::MiddlewareCreators::Observable]
+                      #
+                      def observable
+                        Entities::MiddlewareCreators::Observable.new(middleware: self)
+                      end
+
+                      ##
+                      # @return [Hash{Symbol => Object}]
+                      #
+                      def extra_kwargs
+                        {}
+                      end
+
+                      ##
+                      # @return [Array<ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Structs::IntendedMethod>]
+                      #
+                      # @internal
+                      #   TODO: Consider to wrap with `WeakRef` to reduce memory consumption.
+                      #
+                      def intended_methods
+                        @intended_methods ||= []
+                      end
+
+                      ##
+                      # @return [Class]
+                      #
+                      def to_observable_middleware
+                        Commands::CreateObservableMiddleware.call(middleware: self)
+                      end
+
+                      private
+
+                      ##
+                      # @param method [Symbol]
+                      # @param scope [Symbol, ConvenientService::Support::UniqueValue]
+                      # @param entity [Symbol, ConvenientService::Support::UniqueValue]
+                      # @return [Array<ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Structs::IntendedMethod>]
+                      #
+                      # @internal
+                      #   TODO: Direct specs.
+                      #
+                      def intended_for(method, entity:, scope: :instance)
+                        intended_methods << Structs::IntendedMethod.new(method, scope, entity)
+                      end
+
+                      ##
+                      # @return [ConvenientService::Support::UniqueValue]
+                      #
+                      # @internal
+                      #   TODO: Direct specs.
+                      #
+                      def any_method
+                        Constants::ANY_METHOD
+                      end
+
+                      ##
+                      # @return [ConvenientService::Support::UniqueValue]
+                      #
+                      # @internal
+                      #   TODO: Direct specs.
+                      #
+                      def any_scope
+                        Constants::ANY_SCOPE
+                      end
+
+                      ##
+                      # @return [ConvenientService::Support::UniqueValue]
+                      #
+                      # @internal
+                      #   TODO: Direct specs.
+                      #
+                      def any_entity
+                        Constants::ANY_ENTITY
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              module Middlewares
+                ##
+                # @abstract Subclass and override `#call`.
+                #
+                # @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 Base
+                  module Concern
+                    module InstanceMethods
+                      include Support::AbstractMethod
+
+                      ##
+                      # @return [Object] Can be any type.
+                      #
+                      abstract_method :call
+
+                      ##
+                      # @param stack [#call<Hash>]
+                      # @return [void]
+                      #
+                      def initialize(stack, **kwargs)
+                        @__stack__ = stack
+                        @__env__ = kwargs.fetch(:env) { {} }
+                        @__middleware_arguments__ = kwargs.fetch(:middleware_arguments) { Support::Arguments.null_arguments }
+                      end
+
+                      ##
+                      # @return [ConvenientService::Support::Arguments]
+                      #
+                      def middleware_arguments
+                        @__middleware_arguments__
+                      end
+
+                      ##
+                      # @param other [Object] Can be any type.
+                      # @return [Boolean, nil]
+                      #
+                      def ==(other)
+                        return unless other.instance_of?(self.class)
+
+                        return false if @__stack__ != other.instance_variable_get(:@__stack__)
+                        return false if @__env__ != other.instance_variable_get(:@__env__)
+                        return false if @__middleware_arguments__ != other.instance_variable_get(:@__middleware_arguments__)
+
+                        true
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/core/entities/config/entities/method_middlewares/entities/middlewares/base/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
+              module Middlewares
+                class Base
+                  module Concern
+                    include Support::Concern
+
+                    included do |middleware_class|
+                      middleware_class.include InstanceMethods
+
+                      middleware_class.extend ClassMethods
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/core/entities/config/entities/method_middlewares/entities/middlewares/base/constants.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              module Middlewares
+                class Base
+                  module Constants
+                    ##
+                    # @return [ConvenientService::Support::UniqueValue]
+                    #
+                    ANY_METHOD = Support::UniqueValue.new("any_method")
+
+                    ##
+                    # @return [ConvenientService::Support::UniqueValue]
+                    #
+                    ANY_SCOPE = Support::UniqueValue.new("any_scope")
+
+                    ##
+                    # @return [ConvenientService::Support::UniqueValue]
+                    #
+                    ANY_ENTITY = Support::UniqueValue.new("any_entity")
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/core/entities/config/entities/method_middlewares/entities/middlewares/base/structs/intended_method.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Core
+    module Entities
+      class Config
+        module Entities
+          class MethodMiddlewares
+            module Entities
+              module Middlewares
+                class Base
+                  module Structs
+                    IntendedMethod = ::Struct.new(:method, :scope, :entity)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/core/entities/config/entities/method_middlewares/entities/middlewares/base/structs.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "structs/intended_method"