convenient_service 0.1.0

data/env.rb

@@ -0,0 +1,19 @@
+##
+# NOTE: Appraisal sets `BUNDLE_GEMFILE` env variable.
+# This is how appraisals can be differentiated from each other.
+# https://github.com/thoughtbot/appraisal/blob/v2.4.1/lib/appraisal/command.rb#L36
+#
+# If `BUNDLE_GEMFILE` is an empty string, then `APPRAISAL_NAME` is resolved to an empty string as well.
+# User passed `APPRAISAL_NAME` has a precedence.
+#
+# IMPORTANT: `APPRAISAL_NAME` env variable should be initialized as far as it is possible.
+#
+# IMPORTANT: ENV variables declared in this file should NOT be used inside the lib folder.
+#
+ENV["APPRAISAL_NAME"] ||= ENV["BUNDLE_GEMFILE"].to_s.then(&File.method(:basename)).then { |name| name.end_with?(".gemfile") ? name.delete_suffix(".gemfile") : "" }
+
+##
+# NOTE: Ruby version may be set by docker.
+# https://github.com/docker-library/ruby/blob/master/3.1/alpine3.16/Dockerfile#L30
+#
+ENV["RUBY_VERSION"] ||= ::RUBY_VERSION

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Plugins
+    Common = ::ConvenientService::Common::Plugins
+    Internals = ::ConvenientService::Common::Plugins::HasInternals::Entities::Internals::Plugins
+  end
+end

data/lib/convenient_service/common/plugins/assigns_attributes_in_constructor/using_active_model_attribute_assignment/concern.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module AssignsAttributesInConstructor
+        module UsingActiveModelAttributeAssignment
+          module Concern
+            include Support::Concern
+
+            included do |service_class|
+              require "active_model"
+
+              service_class.include ::ActiveModel::AttributeAssignment
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/assigns_attributes_in_constructor/using_active_model_attribute_assignment/middleware.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module AssignsAttributesInConstructor
+        module UsingActiveModelAttributeAssignment
+          class Middleware < Core::MethodChainMiddleware
+            ##
+            # TODO: Consider creation of a plugin that assigns `*args` with `assign_attributes` as well, not only `**kwargs`.
+            # Check `Method#parameters` for a possible solution.
+            # https://ruby-doc.org/core-3.1.0/Method.html#method-i-parameters
+            #
+            def next(*args, **kwargs, &block)
+              chain.next(*args, **kwargs, &block)
+
+              ##
+              # NOTE: `assign_attributes` expects `attr_writer` for all `kwargs` keys.
+              #
+              # https://api.rubyonrails.org/classes/ActiveModel/AttributeAssignment.html#method-i-assign_attributes
+              #
+              entity.assign_attributes(kwargs)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/assigns_attributes_in_constructor/using_active_model_attribute_assignment.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "using_active_model_attribute_assignment/concern"
+require_relative "using_active_model_attribute_assignment/middleware"

data/lib/convenient_service/common/plugins/assigns_attributes_in_constructor/using_dry_initializer/concern.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module AssignsAttributesInConstructor
+        module UsingDryInitializer
+          module Concern
+            include Support::Concern
+
+            included do |service_class|
+              require "dry-initializer"
+
+              service_class.extend ::Dry::Initializer
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/assigns_attributes_in_constructor/using_dry_initializer.rb

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

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module CachesConstructorParams
+        module Concern
+          include Support::Concern
+
+          ##
+          # TODO: `internals.cache[:constructor_params] || Entities::NullConstructorParams.new`
+          #
+          instance_methods do
+            def constructor_params
+              internals.cache[:constructor_params]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/caches_constructor_params/entities/constructor_params.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module CachesConstructorParams
+        module Entities
+          class ConstructorParams
+            attr_reader :args, :kwargs, :block
+
+            ##
+            # TODO: Specs for default values.
+            #
+            def initialize(args: [], kwargs: {}, block: nil)
+              @args = args
+              @kwargs = kwargs
+              @block = block
+            end
+
+            def ==(other)
+              return unless other.instance_of?(self.class)
+
+              return false if args != other.args
+              return false if kwargs != other.kwargs
+              return false if block&.source_location != other.block&.source_location
+
+              true
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module CachesConstructorParams
+        class Middleware < Core::MethodChainMiddleware
+          def next(*args, **kwargs, &block)
+            entity.internals.cache[:constructor_params] = Entities::ConstructorParams.new(args: args, kwargs: kwargs, block: block)
+
+            chain.next(*args, **kwargs, &block)
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/convenient_service/common/plugins/caches_return_value/entities/key.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module CachesReturnValue
+        module Entities
+          class Key
+            attr_reader :method, :args, :kwargs, :block
+
+            ##
+            #
+            #
+            def initialize(method:, args:, kwargs:, block:)
+              @method = method
+              @args = args
+              @kwargs = kwargs
+              @block = block
+            end
+
+            ##
+            #
+            #
+            def ==(other)
+              return unless other.instance_of?(self.class)
+
+              return false if method != other.method
+              return false if args != other.args
+              return false if kwargs != other.kwargs
+              return false if block&.source_location != other.block&.source_location
+
+              true
+            end
+
+            ##
+            # IMPORTANT: `Key` instances are used as Ruby hash keys.
+            #
+            # This method is overridden in order to avoid the following case:
+            #
+            #   hash = {}
+            #
+            #   ##
+            #   # Two equal keys in terms of `==`.
+            #   #
+            #   first_key = ConvenientService::Common::Plugins::CachesReturnValue::Entities::Key.new(method: :result, args: [], kwargs: {}, block: nil)
+            #   second_key = ConvenientService::Common::Plugins::CachesReturnValue::Entities::Key.new(method: :result, args: [], kwargs: {}, block: nil)
+            #
+            #   first_key == second_key
+            #   # => true
+            #
+            #   hash[first_key] = "value"
+            #
+            #   hash[second_key]
+            #   # => nil # This happens since keys are not equal in terms of `eql?`.
+            #
+            # NOTE: Ruby hash and Object#hash are not the same things.
+            # https://ruby-doc.org/core-3.1.2/Object.html#method-i-hash
+            # https://belighted.com/blog/overriding-equals-equals/
+            #
+            def eql?(other)
+              return unless other.instance_of?(self.class)
+
+              hash == other.hash
+            end
+
+            ##
+            # NOTE: hash is overridden to treat blocks that were defined at the same location as equal.
+            # https://ruby-doc.org/core-3.1.2/Proc.html#method-i-source_location
+            # https://ruby-doc.org/core-3.1.2/Object.html#method-i-hash
+            #
+            def hash
+              [method, args, kwargs, block&.source_location].hash
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module CachesReturnValue
+        class Middleware < Core::MethodChainMiddleware
+          def next(*args, **kwargs, &block)
+            key = Entities::Key.new(method: method, args: args, kwargs: kwargs, block: block)
+
+            entity.internals.cache.fetch(key) { chain.next(*args, **kwargs, &block) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "caches_return_value/entities"
+require_relative "caches_return_value/middleware"

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module CanBeCopied
+        module Concern
+          include Support::Concern
+
+          ##
+          # NOTE: `CanBeCopied` plugin expects that `CachesConstructorParams` plugin is already used.
+          # That is why `constructor_params` method is available.
+          #
+          instance_methods do
+            include Support::Copyable
+
+            def to_args
+              constructor_params.args
+            end
+
+            def to_kwargs
+              constructor_params.kwargs
+            end
+
+            def to_block
+              constructor_params.block
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module HasAroundCallbacks
+        module Concern
+          include Support::Concern
+
+          class_methods do
+            def around(type, &block)
+              Plugins::HasCallbacks::Entities::Callback.new(types: [:around, type], block: block).tap { |callback| callbacks << callback }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/has_around_callbacks/errors.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module HasAroundCallbacks
+        module Errors
+          class AroundCallbackChainIsNotContinued < ConvenientService::Error
+            def initialize(callback:)
+              message = <<~TEXT
+                Around callback chain is NOT continued from `#{callback.block.source_location}`.
+
+                Did you forget to call `chain.yield`? For example:
+
+                around :result do |chain|
+                  # ...
+                  chain.yield
+                  # ...
+                end
+              TEXT
+
+              super(message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module HasAroundCallbacks
+        class Middleware < Core::MethodChainMiddleware
+          def next(...)
+            ##
+            # A variable that stores return value of middleware `chain.next` aka `original_value`.
+            # It is reassigned later by the `initial_around_callback`.
+            #
+            original_value = nil
+
+            ##
+            # A list of around callbacks.
+            #
+            around_callbacks = entity.callbacks.for([:around, method])
+
+            ##
+            #
+            #
+            initial_around_callback = Plugins::HasCallbacks::Entities::Callback.new(
+              types: [:around, method],
+              block: proc { original_value = chain.next(...) }
+            )
+
+            ##
+            # Let's suppose that we have 3 `around` callbacks:
+            #
+            # class Service
+            #   # first
+            #   around do |chain|
+            #     # part before `chain.yield`
+            #     original_value = chain.yield
+            #     # part after `chain.yield`
+            #   end
+            #
+            #   # second
+            #   around do |chain|
+            #     # part before `chain.yield`
+            #     original_value = chain.yield
+            #     # part after `chain.yield`
+            #   end
+            #
+            #   # third
+            #   around do |chain|
+            #     # part before `chain.yield`
+            #     original_value = chain.yield
+            #     # part after `chain.yield`
+            #   end
+            # end
+            #
+            # NOTE: if a user forgets to call `chain.yield` - an error is raised.
+            #
+            # Then `composed` may be built with the following preudocode (that is why `reverse` is needed):
+            #
+            #   composed = original
+            #   composed = proc { instance_exec(composed, &third) }
+            #   composed = proc { instance_exec(composed, &second) }
+            #   composed = proc { instance_exec(composed, &first) }
+            #
+            # Where `first`, `second`, `third` are taken from `entity.callbacks.for([:around, method])`.
+            #
+            # Original implementation is modified in order to return `original_value` from all `chain.yield` calls.
+            #
+            #   # Original implementation:
+            #   composed =
+            #     callbacks.for([:around, method]).reverse.reduce(original) do |composed, callback|
+            #       proc { instance_exec(composed, &callback) }
+            #     end
+            #
+            # Original implementation is modified for the second time in order to raise an error
+            # if a user forgets to call `chain.yield` inside an around callback.
+            #
+            # rubocop:disable Style/Semicolon
+            composed =
+              around_callbacks.reverse.reduce(initial_around_callback) do |composed, callback|
+                proc { callback.call_in_context(entity, composed); original_value }
+              end
+            # rubocop:enable Style/Semicolon
+
+            ##
+            # Call sequence:
+            #
+            #   composed.call
+            #   proc { instance_exec(composed, &first) }.call  # part before `chain.yield`
+            #   proc { instance_exec(composed, &second) }.call # part before `chain.yield`
+            #   proc { instance_exec(composed, &third) }.call  # part before `chain.yield`
+            #   initial_around_callback
+            #   proc { instance_exec(composed, &third) }.call  # part after `chain.yield`
+            #   proc { instance_exec(composed, &second) }.call # part after `chain.yield`
+            #   proc { instance_exec(composed, &first) }.call  # part after `chain.yield`
+            #
+            composed.call
+
+            ##
+            #
+            #
+            raise Errors::AroundCallbackChainIsNotContinued.new(callback: Utils::Array.find_last(around_callbacks, &:called?)) if around_callbacks.any?(&:not_called?)
+
+            ##
+            #
+            #
+            raise Errors::AroundCallbackChainIsNotContinued.new(callback: around_callbacks.last) if initial_around_callback.not_called?
+
+            original_value
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/convenient_service/common/plugins/has_attributes/using_active_model_attributes/concern.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module HasAttributes
+        module UsingActiveModelAttributes
+          module Concern
+            include Support::Concern
+
+            included do |service_class|
+              service_class.include Patches::ActiveModelAttributes
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/has_attributes/using_active_model_attributes/patches/active_model_attributes.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module HasAttributes
+        module UsingActiveModelAttributes
+          ##
+          # TODO: Remove this patch when Rails updates `def initialize(*)` to  `def initialize(*args, **kwargs, &block)`.
+          # https://github.com/rails/rails/blob/3872bc0e54d32e8bf3a6299b0bfe173d94b072fc/activemodel/lib/active_model/attributes.rb#L78
+          #
+          module Patches
+            ##
+            # Copy of `ActiveModel::Attributes`.
+            # - https://api.rubyonrails.org/classes/ActiveModel/Attributes/ClassMethods.html
+            #
+            # - https://github.com/rails/rails/blob/v7.0.0/activemodel/lib/active_model/attributes.rb
+            # - https://github.com/rails/rails/blob/v6.1.0/activemodel/lib/active_model/attributes.rbhttps://github.com/rails/rails/blob/v6.1.0/activemodel/lib/active_model/attributes.rb
+            # - https://github.com/rails/rails/blob/v6.0.0/activemodel/lib/active_model/attributes.rb
+            # - https://github.com/rails/rails/blob/v5.2.0/activemodel/lib/active_model/attributes.rb
+            #
+            ActiveModelAttributes =
+              ::ActiveModel::Attributes.dup.tap do |mod|
+                mod.module_eval do
+                  ##
+                  # NOTE: Overrides `initialize` since current Rails implementation can not accept kwargs.
+                  #
+                  # TODO: Open a PR to Rails.
+                  #
+                  def initialize(*args, **kwargs, &block)
+                    ##
+                    # IMPORTANT: Should be kept in sync with:
+                    # https://github.com/rails/rails/blob/3872bc0e54d32e8bf3a6299b0bfe173d94b072fc/activemodel/lib/active_model/attributes.rb#L78
+                    #
+                    @attributes = self.class._default_attributes.deep_dup
+                    super
+                  end
+                end
+              end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/common/plugins/has_attributes/using_active_model_attributes/patches.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "patches/active_model_attributes"

data/lib/convenient_service/common/plugins/has_attributes/using_active_model_attributes.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "using_active_model_attributes/concern"
+require_relative "using_active_model_attributes/patches"

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Common
+    module Plugins
+      module HasCallbacks
+        module Concern
+          include Support::Concern
+
+          instance_methods do
+            include Support::Delegate
+
+            delegate :callbacks, to: :class
+          end
+
+          class_methods do
+            ##
+            # @api private
+            #
+            def callbacks
+              @__callbacks__ ||= Entities::CallbackCollection.new
+            end
+
+            def before(type, &block)
+              Entities::Callback.new(types: [:before, type], block: block).tap { |callback| callbacks << callback }
+            end
+
+            def after(type, &block)
+              Entities::Callback.new(types: [:after, type], block: block).tap { |callback| callbacks << callback }
+            end
+          end
+        end
+      end
+    end
+  end
+end