convenient_service 0.12.0 → 0.14.0

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
 
           ##

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

@@ -8,20 +8,23 @@ module ConvenientService
 
         class_methods do
           ##
-          # @param full_name [String, Symbol]
+          # @param slug [String, Symbol]
+          # @param as [String, Symbol, nil]
           # @param from [Module]
           # @param scope [:instance, :class]
           # @param prepend [Boolean]
           # @return [ConvenientService::Support::DependencyContainer::Entities::Method]
           #
-          def import(full_name, from:, scope: Constants::DEFAULT_SCOPE, prepend: Constants::DEFAULT_PREPEND)
+          def import(slug, from:, as: Support::NOT_PASSED, scope: Constants::DEFAULT_SCOPE, prepend: Constants::DEFAULT_PREPEND)
             Commands::AssertValidScope.call(scope: scope)
 
             Commands::AssertValidContainer.call(container: from)
 
-            Commands::AssertValidMethod.call(full_name: full_name, scope: scope, container: from)
+            Commands::AssertValidMethod.call(slug: slug, scope: scope, container: from)
 
-            method = from.exported_methods.find_by(full_name: full_name, scope: scope)
+            method = from.exported_methods.find_by(slug: slug, scope: scope)
+
+            method = method.copy(overrides: {kwargs: {alias_slug: as}}) if as != Support::NOT_PASSED
 
             Commands::ImportMethod.call(importing_module: self, exported_method: method, prepend: prepend)
           end

data/lib/convenient_service/support/dependency_container.rb

@@ -3,7 +3,7 @@
 require_relative "dependency_container/commands"
 require_relative "dependency_container/constants"
 require_relative "dependency_container/entities"
-require_relative "dependency_container/errors"
+require_relative "dependency_container/exceptions"
 
 require_relative "dependency_container/entry"
 require_relative "dependency_container/export"

data/lib/convenient_service/support/finite_loop.rb

@@ -8,8 +8,8 @@ module ConvenientService
       #
       MAX_ITERATION_COUNT = 1_000
 
-      module Errors
-        class MaxIterationCountExceeded < ::ConvenientService::Error
+      module Exceptions
+        class MaxIterationCountExceeded < ::ConvenientService::Exception
           ##
           # @param limit [Integer]
           # @return [void]
@@ -25,7 +25,7 @@ module ConvenientService
           end
         end
 
-        class NoBlockGiven < ::ConvenientService::Error
+        class NoBlockGiven < ::ConvenientService::Exception
           ##
           # @return [void]
           #
@@ -66,17 +66,17 @@ module ConvenientService
       #     end
       #   end
       #
-      def finite_loop(max_iteration_count: MAX_ITERATION_COUNT, raise_on_exceedance: true, &block)
-        raise Errors::NoBlockGiven.new unless block
+      def finite_loop(default: nil, max_iteration_count: MAX_ITERATION_COUNT, raise_on_exceedance: true, &block)
+        raise Exceptions::NoBlockGiven.new unless block
 
         loop.with_index do |_, index|
           if index >= max_iteration_count
-            break unless raise_on_exceedance
+            break default unless raise_on_exceedance
 
-            raise Errors::MaxIterationCountExceeded.new(limit: max_iteration_count)
+            raise Exceptions::MaxIterationCountExceeded.new(limit: max_iteration_count)
           end
 
-          block.call(index)
+          yield(index)
         end
       end
     end

data/lib/convenient_service/support/gems/logger.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module Gems
+      class Logger
+        class << self
+          ##
+          # @api private
+          #
+          # @return [Boolean]
+          #
+          # @internal
+          #   `Style/TernaryParentheses` is disabled since `defined?` has too low priority without parentheses.
+          #
+          # rubocop:disable Style/TernaryParentheses
+          def loaded?
+            (defined? ::Logger) ? true : false
+          end
+          # rubocop:enable Style/TernaryParentheses
+
+          ##
+          # @api private
+          #
+          # @return [ConvenientService::Support::Version]
+          #
+          # @internal
+          #   - https://github.com/ruby/logger/blob/v1.5.3/lib/logger/version.rb
+          #
+          def version
+            loaded? ? Support::Version.new(::Logger::VERSION) : Support::Version.null_version
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/support/gems/paint.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module Gems
+      class Paint
+        class << self
+          ##
+          # @api private
+          #
+          # @return [Boolean]
+          #
+          # @internal
+          #   `Style/TernaryParentheses` is disabled since `defined?` has too low priority without parentheses.
+          #
+          # rubocop:disable Style/TernaryParentheses
+          def loaded?
+            (defined? ::Paint) ? true : false
+          end
+          # rubocop:enable Style/TernaryParentheses
+
+          ##
+          # @api private
+          #
+          # @return [ConvenientService::Support::Version]
+          #
+          # @internal
+          #   - https://github.com/janlelis/paint/blob/v2.2.1/lib/paint/version.rb
+          #
+          def version
+            loaded? ? Support::Version.new(::Paint::VERSION) : Support::Version.null_version
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/support/gems.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "gems/active_model"
+require_relative "gems/logger"
+require_relative "gems/paint"
 require_relative "gems/rspec"

data/lib/convenient_service/support/safe_method.rb

@@ -58,7 +58,7 @@ module ConvenientService
       # @return [Class]
       #
       def klass
-        @klass ||= Utils::Object.resolve_class(object)
+        @klass ||= Utils::Object.duck_class(object)
       end
     end
   end

data/lib/convenient_service/support/thread_safe_counter.rb

@@ -8,6 +8,15 @@ module ConvenientService
     #   - https://en.wikipedia.org/wiki/Semaphore_(programming)
     #
     class ThreadSafeCounter < Support::Counter
+      ##
+      # @return [void]
+      #
+      def initialize(...)
+        super
+
+        @lock = ::Mutex.new
+      end
+
       ##
       # @see ConvenientService::Support::Counter#current_value=
       #

data/lib/convenient_service/support.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "support/unique_value"
+
 require_relative "support/not_passed"
 require_relative "support/undefined"
 

data/lib/convenient_service/utils/array/contain_exactly.rb

@@ -44,11 +44,7 @@ module ConvenientService
         # @return [Boolean]
         #
         def call
-          first_array_counts = first_array.each_with_object(::Hash.new { |h, k| h[k] = 0 }) { |item, counts| counts[item] += 1 }
-
-          second_array_counts = second_array.each_with_object(::Hash.new { |h, k| h[k] = 0 }) { |item, counts| counts[item] += 1 }
-
-          first_array_counts == second_array_counts
+          first_array.tally == second_array.tally
         end
       end
     end

data/lib/convenient_service/utils/array/{errors.rb → exceptions.rb}

@@ -3,8 +3,8 @@
 module ConvenientService
   module Utils
     module Array
-      module Errors
-        class NonIntegerIndex < ::ConvenientService::Error
+      module Exceptions
+        class NonIntegerIndex < ::ConvenientService::Exception
           def initialize(index:)
             message = <<~TEXT
               Index `#{index.inspect}` is NOT an integer.

data/lib/convenient_service/utils/array/limited_push.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Utils
+    module Array
+      class LimitedPush < Support::Command
+        module Constants
+          ##
+          # @return [Integer]
+          #
+          DEFAULT_LIMIT = 1_000
+        end
+
+        ##
+        # @!attribute [r] array
+        #   @return [Array<Object>]
+        #
+        attr_reader :array
+
+        ##
+        # @!attribute [r] object
+        #   @return [Object] Can be any type.
+        #
+        attr_reader :object
+
+        ##
+        # @!attribute [r] limit
+        #   @return [Integer]
+        #
+        attr_reader :limit
+
+        ##
+        # @param array [Array<Object>]
+        # @param object [Object] Can be any type.
+        # @return [void]
+        #
+        def initialize(array, object, limit: Constants::DEFAULT_LIMIT)
+          @array = array
+          @object = object
+          @limit = limit
+        end
+
+        ##
+        # @return [Array<Object>]
+        #
+        def call
+          return array if array.size >= limit
+
+          array.push(object)
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/utils/array/merge.rb

@@ -36,7 +36,7 @@ module ConvenientService
 
         ##
         # @return [Array]
-        # @raise [ConvenientService::Utils::Array::Errors::NonIntegerIndex]
+        # @raise [ConvenientService::Utils::Array::Exceptions::NonIntegerIndex]
         #
         def call
           ensure_valid_overrides!
@@ -48,14 +48,14 @@ module ConvenientService
 
         ##
         # @return [void]
-        # @raise [ConvenientService::Utils::Array::Errors::NonIntegerIndex]
+        # @raise [ConvenientService::Utils::Array::Exceptions::NonIntegerIndex]
         #
         def ensure_valid_overrides!
           return integer_key_overrides unless raise_on_non_integer_index
 
           return if overrides.size == integer_key_overrides.size
 
-          raise Errors::NonIntegerIndex.new(index: non_integer_index)
+          raise Exceptions::NonIntegerIndex.new(index: non_integer_index)
         end
 
         ##

data/lib/convenient_service/utils/array.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
-require_relative "array/errors"
+require_relative "array/exceptions"
 
 require_relative "array/contain_exactly"
 require_relative "array/drop_while"
 require_relative "array/find_last"
 require_relative "array/find_yield"
 require_relative "array/keep_after"
+require_relative "array/limited_push"
 require_relative "array/merge"
 require_relative "array/rjust"
 require_relative "array/wrap"
@@ -35,6 +36,10 @@ module ConvenientService
           KeepAfter.call(...)
         end
 
+        def limited_push(...)
+          LimitedPush.call(...)
+        end
+
         def merge(...)
           Merge.call(...)
         end

data/lib/convenient_service/utils/class/display_name.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+##
+# @example Usual class.
+#   ConvenientService::Utils::Class::DisplayName.call(String)
+#   # => "String"
+#
+# @example Anonymous class.
+#   ConvenientService::Utils::Class::DisplayName.call(Сlass.new)
+#   # => "AnonymousClass(#76940)"
+#
+module ConvenientService
+  module Utils
+    module Class
+      class DisplayName < Support::Command
+        ##
+        # @api private
+        #
+        # @!attribute [r] klass
+        #   @return [Class]
+        #
+        attr_reader :klass
+
+        ##
+        # @api private
+        #
+        # @param klass [Class]
+        # @return [void]
+        #
+        def initialize(klass)
+          @klass = klass
+        end
+
+        ##
+        # @api private
+        #
+        # @return [String]
+        #
+        # @internal
+        #   TODO: `Module#name` returns `nil` for anonymous classes.
+        #   - https://ruby-doc.org/core-2.7.0/Module.html#method-i-name
+        #
+        def call
+          klass.name || "AnonymousClass(##{klass.object_id})"
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/utils/class.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "class/display_name"
+
+module ConvenientService
+  module Utils
+    module Class
+      class << self
+        ##
+        # @api private
+        #
+        # @return [String]
+        #
+        def display_name(...)
+          DisplayName.call(...)
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/utils/hash/assert_valid_keys.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+##
+# @example
+#   ConvenientService::Utils::Hash::AssertValidKeys.call({foo: "foo", bar: "bar"}, [:foo, :bar])
+#
+module ConvenientService
+  module Utils
+    module Hash
+      class AssertValidKeys < Support::Command
+        ##
+        # @!attribute [r] hash
+        #   @return [Hash]
+        #
+        attr_reader :hash
+
+        ##
+        # @!attribute [r] valid_keys
+        #   @return [Array]
+        #
+        attr_reader :valid_keys
+
+        ##
+        # @param hash [Hash]
+        # @param valid_keys [Array]
+        # @return [void]
+        #
+        def initialize(hash, valid_keys)
+          @hash = hash
+          @valid_keys = valid_keys.flatten
+        end
+
+        ##
+        # @return [Hash]
+        #
+        # @internal
+        #   NOTE: Copied with minimal modifications from:
+        #   https://api.rubyonrails.org/classes/Hash.html#method-i-assert_valid_keys
+        #
+        def call
+          hash.each_key do |key|
+            next if valid_keys.include?(key)
+
+            raise ::ArgumentError.new("Unknown key: #{key.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(", ")}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/utils/hash/except.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 ##
-# @example:
+# @example
 #   ConvenientService::Utils::Hash::Except.call({foo: :bar, baz: :qux}, [:foo])
 #
 module ConvenientService