convenient_service 0.11.0 → 0.13.0

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Commands
+        class AssertValidContainer < Support::Command
+          ##
+          # @!attribute [r] container
+          #   @return [Module]
+          #
+          attr_reader :container
+
+          ##
+          # @param container [Module]
+          # @return [void]
+          #
+          def initialize(container:)
+            @container = container
+          end
+
+          ##
+          # @return [void]
+          # @raise [ConvenientService::Support::DependencyContainer::Exceptions::NotExportableModule]
+          #
+          def call
+            raise Exceptions::NotExportableModule.new(mod: container) unless Utils::Module.include_module?(container, DependencyContainer::Export)
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -7,12 +7,12 @@ module ConvenientService
         class AssertValidScope < Support::Command
           ##
           # @!attribute [r] scope
-          #   @return [Object]
+          #   @return [Symbol]
           #
           attr_reader :scope
 
           ##
-          # @param scope [Object]
+          # @param scope [Symbol]
           # @return [void]
           #
           def initialize(scope:)
@@ -20,10 +20,11 @@ module ConvenientService
           end
 
           ##
-          # @return [Module]
+          # @return [void]
+          # @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/commands/define_entry.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Commands
+        class DefineEntry < Support::Command
+          ##
+          # @!attribute [r] container
+          #   @return [Module]
+          #
+          attr_reader :container
+
+          ##
+          # @!attribute [r] name
+          #   @return [String, Symbol]
+          #
+          attr_reader :name
+
+          ##
+          # @!attribute [r] body
+          #   @return [Proc]
+          #
+          attr_reader :body
+
+          ##
+          # @param container [Module]
+          # @param name [String, Symbol]
+          # @param body [Proc]
+          #
+          def initialize(container:, name:, body:)
+            @container = container
+            @name = name
+            @body = body
+          end
+
+          ##
+          # @return [String, Symbol]
+          #
+          def call
+            container.define_singleton_method(name, &body)
+
+            name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "commands/assert_valid_scope"
+require_relative "commands/assert_valid_container"
+require_relative "commands/assert_valid_method"
 require_relative "commands/create_methods_module"
+require_relative "commands/define_entry"
 require_relative "commands/import_method"

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Container
+        include Export
+
+        export :"constants.DEFAULT_SCOPE" do
+          Constants::DEFAULT_SCOPE
+        end
+
+        export :"commands.AssertValidContainer" do
+          Commands::AssertValidContainer
+        end
+
+        export :"commands.AssertValidScope" do
+          Commands::AssertValidScope
+        end
+      end
+    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/entry.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Entry
+        include Support::Concern
+
+        class_methods do
+          ##
+          # @param name [String, Symbol]
+          # @param body [Proc]
+          # @return [String, Symbol]
+          #
+          def entry(name, &body)
+            Commands::DefineEntry.call(container: self, name: name, body: body)
+          end
+        end
+      end
+    end
+  end
+end

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]
@@ -38,14 +38,14 @@ module ConvenientService
             message = <<~TEXT
               Module `#{mod}` can NOT export methods.
 
-              Did you forget to include `ConvenientService::Container.export` into it?
+              Did you forget to include `ConvenientService::DependencyContainer::Export` into it?
             TEXT
 
             super(message)
           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)
 
-            raise Errors::NotExportableModule.new(mod: from) unless Utils::Module.include_module?(from, DependencyContainer::Export)
+            Commands::AssertValidContainer.call(container: from)
 
-            method = from.exported_methods.find_by(full_name: full_name, scope: scope)
+            Commands::AssertValidMethod.call(slug: slug, scope: scope, container: from)
 
-            raise Errors::NotExportedMethod.new(method_name: full_name, method_scope: scope, mod: from) unless method
+            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,10 @@
 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"
 require_relative "dependency_container/import"
+
+require_relative "dependency_container/container"

data/lib/convenient_service/support/finite_loop.rb

@@ -3,10 +3,17 @@
 module ConvenientService
   module Support
     module FiniteLoop
+      ##
+      # @return [Integer]
+      #
       MAX_ITERATION_COUNT = 1_000
 
-      module Errors
-        class MaxIterationCountExceeded < ::StandardError
+      module Exceptions
+        class MaxIterationCountExceeded < ::ConvenientService::Exception
+          ##
+          # @param limit [Integer]
+          # @return [void]
+          #
           def initialize(limit:)
             message = <<~TEXT
               Max iteration count is exceeded. Current limit is #{limit}.
@@ -18,7 +25,10 @@ module ConvenientService
           end
         end
 
-        class NoBlockGiven < ::StandardError
+        class NoBlockGiven < ::ConvenientService::Exception
+          ##
+          # @return [void]
+          #
           def initialize
             message = <<~TEXT
               `finite_loop` always expects a block to be given.
@@ -31,17 +41,42 @@ module ConvenientService
 
       private
 
-      def finite_loop(max_iteration_count: MAX_ITERATION_COUNT, raise_on_exceedance: true, &block)
-        raise Errors::NoBlockGiven.new unless block
+      ##
+      # @example Provides `self.finite_loop` in order to have a way to use `finite_loop` without including `ConvenientService::Support::FiniteLoop`.
+      #   ConvenientService::Support::FiniteLoop.finite_loop do |index|
+      #     break if index > 3
+      #   end
+      #
+      module_function
+
+      ##
+      # @param max_iteration_count [Integer]
+      # @param raise_on_exceedance [Boolean]
+      # @param block [Proc, nil]
+      # @return [Object] Can be any type.
+      #
+      # @example
+      #   class Person
+      #     include ConvenientService::Support::FiniteLoop
+      #
+      #     def foo
+      #       finite_loop do |index|
+      #         break if index > 3
+      #       end
+      #     end
+      #   end
+      #
+      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/middleware/stack_builder.rb

@@ -13,7 +13,7 @@ module ConvenientService
       class StackBuilder < Dependencies::Extractions::RubyMiddleware::Middleware::Builder
         ##
         # @param opts [Hash]
-        # @param block [Proc]
+        # @param block [Proc, nil]
         # @return [void]
         #
         # @see https://github.com/marian13/ruby-middleware/blob/v0.4.2/lib/middleware/builder.rb#L43

data/lib/convenient_service/support/not_passed.rb

@@ -2,8 +2,9 @@
 
 module ConvenientService
   module Support
-    NOT_PASSED = ::Object.new.tap do |object|
-      object.define_singleton_method(:inspect) { "not_passed" }
-    end
+    ##
+    # @return [ConvenientService::Support::UniqueValue]
+    #
+    NOT_PASSED = Support::UniqueValue.new("not_passed")
   end
 end