convenient_service 0.12.0 → 0.13.0

data/lib/convenient_service/support/cache.rb

@@ -1,157 +1,30 @@
 # frozen_string_literal: true
 
-require_relative "cache/key"
+require_relative "cache/constants"
+require_relative "cache/entities"
+require_relative "cache/exceptions"
 
 module ConvenientService
   module Support
     class Cache
-      ##
-      # @return [void]
-      #
-      def initialize(hash = {})
-        @hash = hash
-      end
-
       class << self
         ##
-        # @return [ConvenientService::Support::Cache::Key]
+        # @param backend [Symbol]
+        # @return [ConvenientService::Support::Cache::Entities::Caches::Base]
         #
-        def keygen(...)
-          Cache::Key.new(...)
+        def create(backend: Constants::Backends::HASH)
+          case backend
+          when Constants::Backends::ARRAY
+            Entities::Caches::Array.new
+          when Constants::Backends::HASH
+            Entities::Caches::Hash.new
+          when Constants::Backends::THREAD_SAFE_ARRAY
+            Entities::Caches::ThreadSafeArray.new
+          else
+            raise Exceptions::NotSupportedBackend.new(backend: backend)
+          end
         end
       end
-
-      ##
-      # @return [Boolean]
-      #
-      # @internal
-      #   https://ruby-doc.org/core-2.7.0/Hash.html#method-i-empty-3F
-      #
-      def empty?
-        hash.empty?
-      end
-
-      ##
-      # @return [Boolean]
-      #
-      # @internal
-      #   https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-exist-3F
-      #
-      def exist?(key)
-        hash.has_key?(key)
-      end
-
-      ##
-      # @return [Object] Can be any type.
-      #
-      # @internal
-      #   https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-read
-      #
-      def read(key)
-        hash[key]
-      end
-
-      ##
-      # @return [Object] Can be any type.
-      #
-      # @internal
-      #   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
-
-      ##
-      # @param key [Object] Can be any type.
-      # @param value [Object] Can be any type.
-      # @return [Object] Can be any type.
-      #
-      # @internal
-      #   https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-write
-      #
-      def write(key, value)
-        hash[key] = value
-      end
-
-      ##
-      # @param key [Object] Can be any type.
-      # @param value [Object] Can be any type.
-      # @return [Object] Can be any type.
-      #
-      # @internal
-      #   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
-
-      ##
-      # @param key [Object] Can be any type.
-      # @return [Object] Can be any type.
-      #
-      # @internal
-      #   https://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html#method-i-delete
-      #
-      def delete(key)
-        hash.delete(key)
-      end
-
-      ##
-      # @param key [Object] Can be any type.
-      # @param block [Proc, nil]
-      # @return [Object] Can be any type.
-      #
-      # @internal
-      #   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
-
-      ##
-      # @return [ConvenientService::Support::Cache]
-      #
-      def clear
-        hash.clear
-
-        self
-      end
-
-      ##
-      # @return [ConvenientService::Support::Cache]
-      #
-      def scope(key)
-        fetch(key) { Support::Cache.new }
-      end
-
-      ##
-      # @return [ConvenientService::Support::Cache::Key]
-      #
-      def keygen(...)
-        Cache.keygen(...)
-      end
-
-      ##
-      # @param other [Object] Can be any type.
-      # @return [Boolean]
-      #
-      def ==(other)
-        return unless other.instance_of?(self.class)
-
-        return false if hash != other.hash
-
-        true
-      end
-
-      protected
-
-      ##
-      # @!attribute [r] hash
-      #   @return [Hash]
-      #
-      attr_reader :hash
     end
   end
 end

data/lib/convenient_service/support/castable/{errors.rb → exceptions.rb}

@@ -3,8 +3,8 @@
 module ConvenientService
   module Support
     module Castable
-      module Errors
-        class CastIsNotOverridden < ::ConvenientService::Error
+      module Exceptions
+        class CastIsNotOverridden < ::ConvenientService::Exception
           def initialize(klass:)
             message = <<~TEXT
               Cast method (.cast) of `#{klass}` is NOT overridden.
@@ -14,7 +14,7 @@ module ConvenientService
           end
         end
 
-        class FailedToCast < ::ConvenientService::Error
+        class FailedToCast < ::ConvenientService::Exception
           def initialize(other:, klass:)
             message = <<~TEXT
               Failed to cast `#{other.inspect}` into `#{klass}`.

data/lib/convenient_service/support/castable.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "castable/errors"
+require_relative "castable/exceptions"
 
 module ConvenientService
   module Support
@@ -34,7 +34,7 @@ module ConvenientService
         def cast!(other, **options)
           casted = cast(other, **options)
 
-          raise Errors::FailedToCast.new(other: other, klass: self) unless casted
+          raise Exceptions::FailedToCast.new(other: other, klass: self) unless casted
 
           casted
         end

data/lib/convenient_service/support/command.rb

@@ -3,22 +3,61 @@
 module ConvenientService
   module Support
     ##
-    # @abstract Subclass and override {#initialize} and {#call} to implement a Command.
+    # @abstract Subclass and override {#initialize} and {#call} to implement a `Command`.
     #
     class Command
+      module Exceptions
+        class CallIsNotOverridden < ::ConvenientService::Exception
+          def initialize(command:)
+            message = <<~TEXT
+              Call method (#call) of `#{command.class}` is NOT overridden.
+            TEXT
+
+            super(message)
+          end
+        end
+      end
+
       class << self
         ##
-        # TODO: Specs.
+        # @return [Object] Can be any type.
         #
         def call(...)
           new(...).call
         end
+
+        ##
+        # @return [Object] Can be any type.
+        #
+        # @internal
+        #   NOTE: Delegates to `call` instead of aliasing in order to have an ability
+        #   to use the same RSpec stubs for short and usual syntax.
+        #
+        #   For example:
+        #
+        #     allow(Command).to receive(:call).with(:foo).and_call_original
+        #
+        #   works for both `Command.call(:foo)` and `Command[:foo]`.
+        #
+        def [](...)
+          call(...)
+        end
+      end
+
+      ##
+      # @abstract
+      # @return [void]
+      #
+      def initialize(...)
       end
 
       ##
-      # TODO: Specs. Raise error if not overridden.
+      # @abstract
+      # @return [Object] Can be any type.
+      # @raise [ConvenientService::Support::Command::Exceptions::CallIsNotOverridden]
       #
       def call
+        raise Exceptions::CallIsNotOverridden.new(command: self)
       end
     end
   end

data/lib/convenient_service/support/copyable.rb

@@ -19,6 +19,8 @@ module ConvenientService
       #   NOTE: Inline logic instead of private methods is used intentionally in order to NOT pollute the public interface.
       #   NOTE: This method is NOT likely to be ever changed, that is why inline logic is preferred over command classes in this particular case.
       #
+      #   NOTE: The `respond_to` solution was slower by 16%. Check this file history to review the previous implementation. Use the `empty_service` benchmark to compare.
+      #
       def copy(overrides: {})
         defaults = {args: {}, kwargs: {}}
 
@@ -27,32 +29,14 @@ module ConvenientService
         #
         overrides = defaults.merge(overrides)
 
-        ##
-        # TODO: Refactor runtime `respond_to?`. Investigate before refactoring.
-        #
         args =
-          if respond_to?(:to_args)
-            case overrides[:args]
-            when ::Array
-              overrides[:args]
-            when ::Hash
-              Utils::Array.merge(to_args, overrides[:args])
-            end
-          else
-            []
+          case overrides[:args]
+          when ::Array then overrides[:args]
+          when ::Hash then Utils::Array.merge(to_arguments.args, overrides[:args])
           end
 
-        kwargs =
-          if respond_to?(:to_kwargs)
-            to_kwargs.merge(overrides[:kwargs])
-          else
-            {}
-          end
-
-        block =
-          if respond_to?(:to_block)
-            overrides[:block] || to_block
-          end
+        kwargs = to_arguments.kwargs.merge(overrides[:kwargs])
+        block = overrides[:block] || to_arguments.block
 
         self.class.new(*args, **kwargs, &block)
       end

data/lib/convenient_service/support/counter.rb

@@ -11,8 +11,8 @@ module ConvenientService
     #   - https://stackoverflow.com/a/1402764/12201472
     #
     class Counter
-      module Errors
-        class ValueAfterIncrementIsGreaterThanMaxValue < ::ConvenientService::Error
+      module Exceptions
+        class ValueAfterIncrementIsGreaterThanMaxValue < ::ConvenientService::Exception
           ##
           # @param n [Integer]
           # @param current_value [Integer]
@@ -32,7 +32,7 @@ module ConvenientService
           end
         end
 
-        class ValueAfterDecrementIsLowerThanMinValue < ::ConvenientService::Error
+        class ValueAfterDecrementIsLowerThanMinValue < ::ConvenientService::Exception
           ##
           # @param n [Integer]
           # @param current_value [Integer]
@@ -91,7 +91,6 @@ module ConvenientService
         @current_value = initial_value
         @min_value = min_value
         @max_value = max_value
-        @lock = ::Mutex.new
       end
 
       ##
@@ -114,7 +113,7 @@ module ConvenientService
       ##
       # @param n [Integer]
       # @return [Integer]
-      # @raise [ConvenientService::Support::ThreadSafeCounter::Errors::ValueAfterIncrementIsGreaterThanMaxValue]
+      # @raise [ConvenientService::Support::ThreadSafeCounter::Exceptions::ValueAfterIncrementIsGreaterThanMaxValue]
       #
       # @internal
       #   NOTE: Instance variables are accessed directly to release the lock faster.
@@ -124,7 +123,7 @@ module ConvenientService
       #   - https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-save-21
       #
       def increment!(n = 1)
-        raise Errors::ValueAfterIncrementIsGreaterThanMaxValue.new(n: n, current_value: @current_value, max_value: @max_value) if @current_value + n > @max_value
+        raise Exceptions::ValueAfterIncrementIsGreaterThanMaxValue.new(n: n, current_value: @current_value, max_value: @max_value) if @current_value + n > @max_value
 
         @current_value += n
       end
@@ -167,7 +166,7 @@ module ConvenientService
       ##
       # @param n [Integer]
       # @return [Integer]
-      # @raise [ConvenientService::Support::ThreadSafeCounter::Errors::ValueAfterDecrementIsLowerThanMinValue]
+      # @raise [ConvenientService::Support::ThreadSafeCounter::Exceptions::ValueAfterDecrementIsLowerThanMinValue]
       #
       # @internal
       #   NOTE: Instance variables are accessed directly to release the lock faster.
@@ -177,7 +176,7 @@ module ConvenientService
       #   - https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-save-21
       #
       def decrement!(n = 1)
-        raise Errors::ValueAfterDecrementIsLowerThanMinValue.new(n: n, current_value: @current_value, min_value: @min_value) if @current_value - n < @min_value
+        raise Exceptions::ValueAfterDecrementIsLowerThanMinValue.new(n: n, current_value: @current_value, min_value: @min_value) if @current_value - n < @min_value
 
         @current_value -= n
       end

data/lib/convenient_service/support/dependency_container/commands/assert_valid_container.rb

@@ -21,10 +21,10 @@ module ConvenientService
 
           ##
           # @return [void]
-          # @raise [ConvenientService::Support::DependencyContainer::Errors::NotExportableModule]
+          # @raise [ConvenientService::Support::DependencyContainer::Exceptions::NotExportableModule]
           #
           def call
-            raise Errors::NotExportableModule.new(mod: container) unless Utils::Module.include_module?(container, DependencyContainer::Export)
+            raise Exceptions::NotExportableModule.new(mod: container) unless Utils::Module.include_module?(container, DependencyContainer::Export)
           end
         end
       end

data/lib/convenient_service/support/dependency_container/commands/assert_valid_method.rb

@@ -6,10 +6,10 @@ module ConvenientService
       module Commands
         class AssertValidMethod < Support::Command
           ##
-          # @!attribute [r] full_name
+          # @!attribute [r] slug
           #   @return [String, Symbol]
           #
-          attr_reader :full_name
+          attr_reader :slug
 
           ##
           # @!attribute [r] scope
@@ -24,23 +24,23 @@ module ConvenientService
           attr_reader :container
 
           ##
-          # @param full_name [String, Symbol]
+          # @param slug [String, Symbol]
           # @param scope [Symbol]
           # @param container[Module]
           # @return [void]
           #
-          def initialize(full_name:, scope:, container:)
-            @full_name = full_name
+          def initialize(slug:, scope:, container:)
+            @slug = slug
             @scope = scope
             @container = container
           end
 
           ##
           # @return [void]
-          # @raise [ConvenientService::Support::DependencyContainer::Errors::NotExportedMethod]
+          # @raise [ConvenientService::Support::DependencyContainer::Exceptions::NotExportedMethod]
           #
           def call
-            raise Errors::NotExportedMethod.new(method_name: full_name, method_scope: scope, mod: container) unless method
+            raise Exceptions::NotExportedMethod.new(method_name: slug, method_scope: scope, mod: container) unless method
           end
 
           private
@@ -49,7 +49,7 @@ module ConvenientService
           # @return [ConvenientService::Support::DependencyContainer::Entities::Method, nil]
           #
           def method
-            container.exported_methods.find_by(full_name: full_name, scope: scope)
+            container.exported_methods.find_by(slug: slug, scope: scope)
           end
         end
       end

data/lib/convenient_service/support/dependency_container/commands/assert_valid_scope.rb

@@ -21,10 +21,10 @@ module ConvenientService
 
           ##
           # @return [void]
-          # @raise [ConvenientService::Support::DependencyContainer::Errors::InvalidScope]
+          # @raise [ConvenientService::Support::DependencyContainer::Exceptions::InvalidScope]
           #
           def call
-            raise Errors::InvalidScope.new(scope: scope) unless Constants::SCOPES.include?(scope)
+            raise Exceptions::InvalidScope.new(scope: scope) unless Constants::SCOPES.include?(scope)
           end
         end
       end

data/lib/convenient_service/support/dependency_container/entities/method.rb

@@ -5,11 +5,13 @@ module ConvenientService
     module DependencyContainer
       module Entities
         class Method
+          include Support::Copyable
+
           ##
-          # @!attribute [r] full_name
+          # @!attribute [r] slug
           #   @return [String, Symbol]
           #
-          attr_reader :full_name
+          attr_reader :slug
 
           ##
           # @!attribute [r] scope
@@ -24,29 +26,37 @@ module ConvenientService
           attr_reader :body
 
           ##
-          # @param full_name [String, Symbol]
+          # @!attribute [r] alias_slug
+          #   @return [String, Symbol]
+          #
+          attr_reader :alias_slug
+
+          ##
+          # @param slug [String, Symbol]
           # @param scope [:instance, :class]
           # @param body [Proc]
+          # @param alias_slug [String, Symbol]
           # @return [void]
           #
-          def initialize(full_name:, scope:, body:)
-            @full_name = full_name
+          def initialize(slug:, scope:, body:, alias_slug: "")
+            @slug = slug
             @scope = scope
             @body = body
+            @alias_slug = alias_slug
           end
 
           ##
-          # @return [String]
+          # @return [Symbol]
           #
           def name
-            @name ||= full_name_parts.last
+            @name ||= alias_slug_parts.last || slug_parts.last
           end
 
           ##
           # @return [Array<ConvenientService::Support::DependencyContainer::Entities::Namespace>]
           #
           def namespaces
-            @namespaces ||= full_name_parts.slice(0..-2).map { |part| Entities::Namespace.new(name: part) }
+            @namespaces ||= (alias_slug_parts.any? ? alias_slug_parts : slug_parts).slice(0..-2).map { |part| Entities::Namespace.new(name: part) }
           end
 
           ##
@@ -92,20 +102,47 @@ module ConvenientService
           def ==(other)
             return unless other.instance_of?(self.class)
 
-            return false if full_name != other.full_name
+            return false if slug != other.slug
             return false if scope != other.scope
             return false if body != other.body
+            return false if alias_slug != other.alias_slug
 
             true
           end
 
+          ##
+          # @return [Hash{Symbol => Object}]
+          #
+          def to_kwargs
+            to_arguments.kwargs
+          end
+
+          ##
+          # @return [ConvenientService::Support::Arguments]
+          #
+          def to_arguments
+            Support::Arguments.new(
+              slug: slug,
+              scope: scope,
+              body: body,
+              alias_slug: alias_slug
+            )
+          end
+
           private
 
           ##
-          # @return [Array<String>]
+          # @return [Array<Symbol>]
+          #
+          def slug_parts
+            @slug_parts ||= Utils::String.split(slug, ".", "::").map(&:to_sym)
+          end
+
+          ##
+          # @return [Array<Symbol>]
           #
-          def full_name_parts
-            @full_name_parts ||= Utils::String.split(full_name, ".", "::").map(&:to_sym)
+          def alias_slug_parts
+            @alias_slug_parts ||= Utils::String.split(alias_slug, ".", "::").map(&:to_sym)
           end
         end
       end

data/lib/convenient_service/support/dependency_container/entities/method_collection.rb

@@ -15,15 +15,15 @@ module ConvenientService
 
           ##
           # @param name [String, Symbol]
-          # @param full_name [String, Symbol]
+          # @param slug [String, Symbol]
           # @param scope [:instance, :class]
           # @return [ConvenientService::Support::DependencyContainer::Entities::Method, nil]
           #
-          def find_by(name: Support::NOT_PASSED, full_name: Support::NOT_PASSED, scope: Support::NOT_PASSED)
+          def find_by(name: Support::NOT_PASSED, slug: Support::NOT_PASSED, scope: Support::NOT_PASSED)
             rules = []
 
             rules << ->(method) { method.name.to_s == name.to_s } if name != Support::NOT_PASSED
-            rules << ->(method) { method.full_name.to_s == full_name.to_s } if full_name != Support::NOT_PASSED
+            rules << ->(method) { method.slug.to_s == slug.to_s } if slug != Support::NOT_PASSED
             rules << ->(method) { method.scope == scope } if scope != Support::NOT_PASSED
 
             condition = Utils::Proc.conjunct(rules)

data/lib/convenient_service/support/dependency_container/{errors.rb → exceptions.rb}

@@ -3,8 +3,8 @@
 module ConvenientService
   module Support
     module DependencyContainer
-      module Errors
-        class InvalidScope < ::ConvenientService::Error
+      module Exceptions
+        class InvalidScope < ::ConvenientService::Exception
           ##
           # @param scope [Object]
           # @return [void]
@@ -29,7 +29,7 @@ module ConvenientService
           end
         end
 
-        class NotExportableModule < ::ConvenientService::Error
+        class NotExportableModule < ::ConvenientService::Exception
           ##
           # @param mod [Module]
           # @return [void]
@@ -45,7 +45,7 @@ module ConvenientService
           end
         end
 
-        class NotExportedMethod < ::ConvenientService::Error
+        class NotExportedMethod < ::ConvenientService::Exception
           ##
           # @param method_name [String]
           # @param method_scope [Symbol]
@@ -69,7 +69,7 @@ module ConvenientService
           end
         end
 
-        class NotModule < ::ConvenientService::Error
+        class NotModule < ::ConvenientService::Exception
           ##
           # @param klass [Class]
           # @return [void]

data/lib/convenient_service/support/dependency_container/export.rb

@@ -11,12 +11,12 @@ module ConvenientService
         # @return [Module]
         #
         included do |klass|
-          raise Errors::NotModule.new(klass: klass) unless klass.instance_of?(::Module)
+          raise Exceptions::NotModule.new(klass: klass) unless klass.instance_of?(::Module)
         end
 
         class_methods do
           ##
-          # @param full_name [String, Symbol]
+          # @param slug [String, Symbol]
           # @param scope [:instance, :class]
           # @param body [Proc]
           # @return [ConvenientService::Support::DependencyContainer::Entities::Method]
@@ -27,10 +27,10 @@ module ConvenientService
           #   You won't ever see a module in Ruby that contains methods for `include` and `prepend` at the same time.
           #   So why `export` should allow to do it?
           #
-          def export(full_name, scope: Constants::DEFAULT_SCOPE, &body)
+          def export(slug, scope: Constants::DEFAULT_SCOPE, &body)
             Commands::AssertValidScope.call(scope: scope)
 
-            Entities::Method.new(full_name: full_name, scope: scope, body: body).tap { |method| exported_methods << method }
+            Entities::Method.new(slug: slug, scope: scope, body: body).tap { |method| exported_methods << method }
           end
 
           ##