convenient_service 0.12.0 → 0.13.0

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

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+##
+# @example
+#   {foo: (1..10), bar: /abc/} == {foo: 5, bar: :abc}
+#   # => false, since values are compared by `#==` under the hood.
+#
+#   ConvenientService::Utils::Hash::TripleEqualityCompare.call({foo: (1..10), bar: /abc/}, {foo: 5, bar: :abc})
+#   # => true, since values are compared by `#===` under the hood.
+#
+module ConvenientService
+  module Utils
+    module Hash
+      class TripleEqualityCompare < Support::Command
+        ##
+        # @!attribute [r] hash
+        #   @return [Hash]
+        #
+        attr_reader :hash
+
+        ##
+        # @!attribute [r] other_hash
+        #   @return [Array]
+        #
+        attr_reader :other_hash
+
+        ##
+        # @param hash [Hash]
+        # @param other_hash [Hash]
+        # @return [void]
+        #
+        def initialize(hash, other_hash)
+          @hash = hash
+          @other_hash = other_hash
+        end
+
+        ##
+        # @return [Boolean]
+        #
+        def call
+          return false if hash.size != other_hash.size
+          return false if hash.keys.difference(other_hash.keys).any?
+
+          return false unless hash.all? { |key, value| value === other_hash[key] }
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/utils/hash.rb

@@ -1,14 +1,24 @@
 # frozen_string_literal: true
 
+require_relative "hash/assert_valid_keys"
 require_relative "hash/except"
+require_relative "hash/triple_equality_compare"
 
 module ConvenientService
   module Utils
     module Hash
       class << self
+        def assert_valid_keys(...)
+          AssertValidKeys.call(...)
+        end
+
         def except(...)
           Except.call(...)
         end
+
+        def triple_equality_compare(...)
+          TripleEqualityCompare.call(...)
+        end
       end
     end
   end

data/lib/convenient_service/utils/method/defined.rb

@@ -4,6 +4,12 @@ module ConvenientService
   module Utils
     module Method
       class Defined < Support::Command
+        METHOD_DEFINED_CHECKERS = {
+          public: ->(klass, method) { klass.public_method_defined?(method) },
+          protected: ->(klass, method) { klass.protected_method_defined?(method) },
+          private: ->(klass, method) { klass.private_method_defined?(method) }
+        }
+
         ##
         # @!attribute [r] method
         #   @return [Class]
@@ -17,19 +23,40 @@ module ConvenientService
         attr_reader :klass
 
         ##
-        # @!attribute [r] klass
-        #   @return [Class]
+        # @!attribute [r] public
+        #   @return [Boolean]
+        #
+        attr_reader :public
+
+        ##
+        # @!attribute [r] protected
+        #   @return [Boolean]
+        #
+        attr_reader :protected
+
+        ##
+        # @!attribute [r] private
+        #   @return [Boolean]
         #
         attr_reader :private
 
         ##
         # @param method [Symbol, String]
         # @param klass [Class]
+        # @param public [Boolean]
+        # @param protected [Boolean]
+        # @param private [Boolean]
         # @return [void]
         #
-        def initialize(method, klass, private: false)
+        # @internal
+        #   NOTE: `protected` is set to `true` by default to keep the same semantics as `Module#method_defined?`.
+        #   - https://ruby-doc.org/core-3.1.0/Module.html#method-i-method_defined-3F
+        #
+        def initialize(method, klass, public: true, protected: true, private: false)
           @method = method.to_s
           @klass = klass
+          @public = public
+          @protected = protected
           @private = private
         end
 
@@ -37,11 +64,28 @@ module ConvenientService
         # @return [void]
         #
         def call
-          return true if klass.method_defined?(method)
+          return false if selected_visibilities.none?
 
-          return klass.private_method_defined?(method) if private
+          selected_visibilities.any? { |visibility| method_defined?(visibility) }
+        end
 
-          false
+        ##
+        # @return [Array<Symbol>]
+        #
+        # @internal
+        #   NOTE: `keep_if` seems more readable than `select` (just a personal feeling).
+        #   It is safe to use `keep_if` since a new hash is created. Prefer `select` in a general case, since it is NOT mutable.
+        #
+        def selected_visibilities
+          @selected_visibilities ||= {public: public, protected: protected, private: private}.keep_if { |_, should_be_checked| should_be_checked }.keys
+        end
+
+        ##
+        # @param visibility [Symbol]
+        # @return [Boolean]
+        #
+        def method_defined?(visibility)
+          METHOD_DEFINED_CHECKERS[visibility].call(klass, method)
         end
       end
     end

data/lib/convenient_service/utils/module/class_method_defined.rb

@@ -16,6 +16,18 @@ module ConvenientService
         #
         attr_reader :method_name
 
+        ##
+        # @!attribute [r] public
+        #   @return [Boolean]
+        #
+        attr_reader :public
+
+        ##
+        # @!attribute [r] protected
+        #   @return [Boolean]
+        #
+        attr_reader :protected
+
         ##
         # @!attribute [r] private
         #   @return [Boolean]
@@ -25,12 +37,20 @@ module ConvenientService
         ##
         # @param mod [Class, Module]
         # @param method_name [String, Symbol]
+        # @param public [Boolean]
+        # @param protected [Boolean]
         # @param private [Boolean]
         # @return [void]
         #
-        def initialize(mod, method_name, private: false)
+        # @internal
+        #   NOTE: `protected` is set to `true` by default to keep the same semantics as `Module#method_defined?`.
+        #   - https://ruby-doc.org/core-3.1.0/Module.html#method-i-method_defined-3F
+        #
+        def initialize(mod, method_name, public: true, protected: true, private: false)
           @mod = mod
           @method_name = method_name
+          @public = public
+          @protected = protected
           @private = private
         end
 
@@ -38,7 +58,7 @@ module ConvenientService
         # @return [Boolean]
         #
         def call
-          Utils::Method.defined?(method_name, mod.singleton_class, private: true)
+          Utils::Method.defined?(method_name, mod.singleton_class, public: public, protected: protected, private: private)
         end
       end
     end