convenient_service 0.1.0

data/lib/convenient_service/common/plugins/has_callbacks/entities/callback.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module HasCallbacks
+        module Entities
+          class Callback
+            attr_reader :types, :block
+
+            def initialize(types:, block:)
+              @types = Entities::TypeCollection.new(types: types)
+              @block = block
+            end
+
+            def called?
+              Utils::Bool.to_bool(@called)
+            end
+
+            def not_called?
+              !called?
+            end
+
+            def call(*args, **kwargs)
+              block.call(*args, **kwargs).tap { mark_as_called }
+            end
+
+            alias_method :yield, :call
+            alias_method :[], :call
+            alias_method :===, :call
+
+            def call_in_context(context, *args, **kwargs)
+              context.instance_exec(*args, **kwargs, &block).tap { mark_as_called }
+            end
+
+            def ==(other)
+              return unless other.instance_of?(self.class)
+
+              return false if types != other.types
+              return false if block&.source_location != other.block&.source_location
+
+              true
+            end
+
+            def to_proc
+              block
+            end
+
+            private
+
+            def mark_as_called
+              @called = true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/has_callbacks/entities/callback_collection.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module HasCallbacks
+        module Entities
+          class CallbackCollection
+            include Support::Delegate
+
+            attr_reader :callbacks
+
+            delegate :each, :include?, :<<, to: :callbacks
+
+            def initialize
+              @callbacks = []
+            end
+
+            def for(types)
+              callbacks.select { |callback| callback.types.contain_exactly?(types) }
+            end
+
+            def ==(other)
+              return unless other.instance_of?(self.class)
+
+              return false if callbacks != other.callbacks
+
+              true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/has_callbacks/entities/type/class_methods.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module HasCallbacks
+        module Entities
+          class Type
+            module ClassMethods
+              def cast(other)
+                case other
+                when ::Symbol
+                  Type.new(value: other)
+                when ::String
+                  Type.new(value: other.to_sym)
+                when Type
+                  Type.new(value: other.value)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/has_callbacks/entities/type.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "type/class_methods"
+
+module ConvenientService
+  module Common
+    module Plugins
+      module HasCallbacks
+        module Entities
+          class Type
+            include Support::Castable
+            include Support::Delegate
+
+            extend ClassMethods
+
+            attr_reader :value
+
+            delegate :hash, to: :value
+
+            def initialize(value:)
+              @value = value
+            end
+
+            def ==(other)
+              return unless other.instance_of?(self.class)
+
+              return false if value != other.value
+
+              true
+            end
+
+            ##
+            # NOTE: Used by `contain_exactly`. Check its specs.
+            #
+            # NOTE: This method is intented to be used only for hash keys comparison,
+            # when you know for sure that `other` is always an `Entities::Type` instance.
+            #
+            # IMPORTANT: Do NOT use `eql?` without a strong reason, prefer `==`.
+            #
+            def eql?(other)
+              return unless other.instance_of?(self.class)
+
+              hash == other.hash
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/has_callbacks/entities/type_collection.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module HasCallbacks
+        module Entities
+          class TypeCollection
+            attr_reader :types
+
+            def initialize(types:)
+              @types = types.map(&Entities::Type.method(:cast!))
+            end
+
+            def contain_exactly?(other_types)
+              other_types = other_types.map(&Entities::Type.method(:cast!))
+
+              Utils::Array.contain_exactly?(types, other_types)
+            end
+
+            def ==(other)
+              return unless other.instance_of?(self.class)
+
+              return false if types != other.types
+
+              true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/has_callbacks/entities.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "entities/callback_collection"
+require_relative "entities/callback"
+require_relative "entities/type_collection"
+require_relative "entities/type"

data/lib/convenient_service/common/plugins/has_callbacks/middleware.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module HasCallbacks
+        class Middleware < Core::MethodChainMiddleware
+          def next(...)
+            entity.callbacks.for([:before, method]).each { |callback| callback.call_in_context(entity) }
+
+            original_value = chain.next(...)
+
+            entity.callbacks.for([:after, method]).reverse_each { |callback| callback.call_in_context(entity, original_value) }
+
+            original_value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/has_callbacks.rb

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

data/lib/convenient_service/common/plugins/has_constructor/concern.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module HasConstructor
+        module Concern
+          include Support::Concern
+
+          instance_methods do
+            def initialize(...)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/has_constructor.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "has_constructor/concern"

data/lib/convenient_service/common/plugins/has_internals/commands/create_internals_class.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module HasInternals
+        module Commands
+          class CreateInternalsClass < Support::Command
+            attr_reader :service_class
+
+            def initialize(service_class:)
+              @service_class = service_class
+            end
+
+            def call
+              internals_class.include Entities::Internals::Concern
+
+              ##
+              # class Internals < ConvenientService::Common::Plugins::HasInternals::Entities::Internals # or just `class Internals` if service class defines its own.
+              #   include ConvenientService::Common::Plugins::HasInternals::Entities::Internals::Concern
+              #
+              #   class << self
+              #     def service_class
+              #       ##
+              #       # NOTE: Returns `service_class` passed to `CreateInternalsClass`.
+              #       #
+              #       service_class
+              #     end
+              #
+              #     def ==(other)
+              #       return unless other.instance_of?(self.class)
+              #
+              #       self.service_class == other.service_class
+              #     end
+              #   end
+              # end
+              #
+              internals_class.class_exec(service_class) do |service_class|
+                define_singleton_method(:service_class) { service_class }
+                define_singleton_method(:==) { |other| self.service_class == other.service_class if other.instance_of?(self.class) }
+              end
+
+              internals_class
+            end
+
+            private
+
+            def internals_class
+              @internals_class ||= Utils::Module.get_own_const(service_class, :Internals) || ::Class.new(Entities::Internals)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/has_internals/commands.rb

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

data/lib/convenient_service/common/plugins/has_internals/concern.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module HasInternals
+        module Concern
+          include Support::Concern
+
+          instance_methods do
+            def internals
+              @internals ||= self.class.internals_class.new
+            end
+          end
+
+          class_methods do
+            def internals_class
+              ##
+              # TODO: Generic `CreateInternalsClass`.
+              #
+              @internals_class ||= Commands::CreateInternalsClass.call(service_class: self)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/has_internals/entities/internals/concern.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module HasInternals
+        module Entities
+          class Internals
+            module Concern
+              include Support::Concern
+
+              instance_methods do
+                def ==(other)
+                  return unless other.instance_of?(self.class)
+
+                  true
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/has_internals/entities/internals/plugins/has_cache/concern.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module HasInternals
+        module Entities
+          class Internals
+            module Plugins
+              module HasCache
+                ##
+                # TODO: Specs.
+                #
+                module Concern
+                  include Support::Concern
+
+                  instance_methods do
+                    def cache
+                      @cache ||= Entities::Cache.new
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/has_internals/entities/internals/plugins/has_cache/entities/cache.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module HasInternals
+        module Entities
+          class Internals
+            module Plugins
+              module HasCache
+                module Entities
+                  ##
+                  # TODO: Specs.
+                  #
+                  class Cache
+                    attr_reader :hash
+
+                    def initialize
+                      @hash = {}
+                    end
+
+                    ##
+                    # https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-exist-3F
+                    #
+                    def exist?(key)
+                      hash.has_key?(key)
+                    end
+
+                    ##
+                    # https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-read
+                    #
+                    def read(key)
+                      hash[key]
+                    end
+
+                    ##
+                    # NOTE: `alias_method` is NOT used in order to have an ability to use `allow(cache).to receive(:read).with(key).and_call_original` for both `cache[key]` and `cache.read(key)` in RSpec.
+                    #
+                    def [](key)
+                      read(key)
+                    end
+
+                    ##
+                    # https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-write
+                    #
+                    def write(key, value)
+                      hash[key] = value
+                    end
+
+                    ##
+                    # NOTE: `alias_method` is NOT used in order to have an ability to use `allow(cache).to receive(:write).with(key, value).and_call_original` for both `cache[key] = value` and `cache.write(key, value)` in RSpec.
+                    #
+                    def []=(key, value)
+                      write(key, value)
+                    end
+
+                    ##
+                    # https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-delete
+                    #
+                    def delete(key)
+                      hash.delete(key)
+                    end
+
+                    ##
+                    # https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-fetch
+                    #
+                    def fetch(key, &block)
+                      return read(key) unless block
+
+                      exist?(key) ? read(key) : write(key, block.call)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/has_internals/entities/internals/plugins/has_cache/entities.rb

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

data/lib/convenient_service/common/plugins/has_internals/entities/internals/plugins/has_cache.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "has_cache/concern"
+require_relative "has_cache/entities"

data/lib/convenient_service/common/plugins/has_internals/entities/internals/plugins.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "plugins/has_cache"

data/lib/convenient_service/common/plugins/has_internals/entities/internals.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "internals/concern"
+require_relative "internals/plugins"
+
+module ConvenientService
+  module Common
+    module Plugins
+      module HasInternals
+        module Entities
+          class Internals
+            include Concern
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/has_internals/entities.rb

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

data/lib/convenient_service/common/plugins/has_internals.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "has_internals/commands"
+require_relative "has_internals/concern"
+require_relative "has_internals/entities"

data/lib/convenient_service/common/plugins/normalizes_env/middleware.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module NormalizesEnv
+        ##
+        # - Single splat `*` converts `nil` to empty array.
+        # - Double splat `**` raises on `nil`.
+        # - Umpersand `&` converts `nil` to `nil`.
+        #
+        # The following middleware converts `env[:kwargs]` to a hash.
+        # This way `stack.call(*env[:args], **env[:kwargs], &env[:block])` won't fail even if a user passes `nil` as `kwargs`.
+        #
+        # Check the following link for more details:
+        # - https://bugs.ruby-lang.org/issues/8507
+        #
+        class Middleware < Core::ClassicMiddleware
+          def call(env = nil)
+            env = env.to_h
+            env = env.merge(args: env[:args].to_a, kwargs: env[:kwargs].to_h, block: env[:block])
+
+            stack.call(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/normalizes_env.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "normalizes_env/middleware"

data/lib/convenient_service/common/plugins.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+##
+# NOTE: Order matters.
+#
+require_relative "plugins/normalizes_env"
+
+require_relative "plugins/caches_constructor_params"
+require_relative "plugins/caches_return_value"
+require_relative "plugins/can_be_copied"
+require_relative "plugins/has_around_callbacks"
+require_relative "plugins/has_callbacks"
+require_relative "plugins/has_constructor"
+require_relative "plugins/has_internals"
+
+require_relative "plugins/aliases"

data/lib/convenient_service/common.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "common/plugins"

data/lib/convenient_service/configs/aliases.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Standard
+    Config = ::ConvenientService::Configs::Standard
+  end
+end