convenient_service 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 481cc240efe2b9443d13ea66fc70dc2cd1b477c291be24b1b9e66af9e9e26e65
-  data.tar.gz: 07caed3e04809cd78e96818e69c99f9337a9882f689c05709ff57d38e6c5940f
+  metadata.gz: 7655bb52a95f02a3f973c4f26e8e881ebf2dec66e056de3e085515b8e1c9b8f9
+  data.tar.gz: 440d3e574c167e88ca942e98eb022665faf918933d20789d4acc50f90bd0e9e8
 SHA512:
-  metadata.gz: 35b346de371b82d3d8775a68783e1fdce3c42709bfb7aaa5a864f5bbb9c4ba494eb2f6a7f7ead303f5dcde1a079256c1cc881006cff5bc600b3c0e48a6810f6e
-  data.tar.gz: dac03d20c0c10765f4c1e5530d0f9d92a1ee0723f98a94f0a0804d13e2f7e3c8d28d2052a0037c08d6f5b49726038d55069a89bf3143d01b298a58e4a223c32b
+  metadata.gz: 2f76c7d18d8dbe51157e07c575718383148fc070cd85705450f9ea7d5bd4c3837d459b1da3125c4a1eb6188d14ce5e5d10c1b501104949f6c609e6a0f724e820
+  data.tar.gz: fb0f1e875261f71a01fefba836b45e6c8995ea94f9aa906050f9bebdf5b4690bafda699c624a9405cec65c14928ba1956d6c3a193f434ab471ceceb4635baef6

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.5.0](https://github.com/marian13/convenient_service/compare/v0.4.0...v0.5.0) (2023-01-19)
+
+
+### Features
+
+* **dependency_container:** introduce dependency containers ([7e2dd90](https://github.com/marian13/convenient_service/commit/7e2dd9072a4b8815ac74755b4fa2c3b66a093115), [aef8ac0](https://github.com/marian13/convenient_service/commit/aef8ac0ba7fdfdd968fae6e115bb9540bca28ec4))
+
 ## [0.4.0](https://github.com/marian13/convenient_service/compare/v0.3.1...v0.4.0) (2023-01-03)
 
 

data/convenient_service.gemspec

@@ -41,7 +41,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rerun"
   spec.add_development_dependency "rouge"
   spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "rubocop", "~> 1.40.0"
   spec.add_development_dependency "rubocop-rspec"
   spec.add_development_dependency "tty-prompt"
   spec.add_development_dependency "standard"

data/lib/convenient_service/aliases.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  DependencyContainer = ::ConvenientService::Support::DependencyContainer
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Commands
+        class CreateMethodsModule < Support::Command
+          ##
+          # @return [Module]
+          #
+          def call
+            ::Module.new do
+              class << self
+                ##
+                # @return namespaces [ConvenientService::Support::DependencyContainer::Entities::NamespaceCollection]
+                #
+                def namespaces
+                  @namespaces ||= Entities::NamespaceCollection.new
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Commands
+        class ImportMethod < Support::Command
+          ##
+          # @!attribute [r] importing_module
+          #   @return [Module]
+          #
+          attr_reader :importing_module
+
+          ##
+          # @!attribute [r] exporting_module
+          #   @return [Module]
+          #
+          attr_reader :exporting_module
+
+          ##
+          # @!attribute [r] method
+          #   @return [ConvenientService::Support::DependencyContainer::Method]
+          #
+          attr_reader :method
+
+          ##
+          # @!attribute [r] scope
+          #   @return [Symbol]
+          #
+          attr_reader :scope
+
+          ##
+          # @!attribute [r] prepend
+          #   @return [Boolean]
+          #
+          attr_reader :prepend
+
+          ##
+          # @param importing_module [Module]
+          # @param exporting_module [Module]
+          # @param method [ConvenientService::Support::DependencyContainer::Method]
+          # @param scope [:instance, :class]
+          # @param prepend [Boolean]
+          #
+          def initialize(importing_module:, exporting_module:, method:, scope:, prepend:)
+            @importing_module = importing_module
+            @exporting_module = exporting_module
+            @method = method
+            @scope = scope
+            @prepend = prepend
+          end
+
+          ##
+          # @return [ConvenientService::Support::DependencyContainer::Method]
+          #
+          def call
+            import imported_scoped_methods
+
+            method.define_in_module!(imported_scoped_methods)
+
+            method
+          end
+
+          private
+
+          ##
+          # @return [Module]
+          #
+          def imported_scoped_methods
+            @imported_scoped_methods ||= Utils::Module.fetch_own_const(importing_module, :"Imported#{imported_prefix}#{scoped_prefix}Methods") { Commands::CreateMethodsModule.call }
+          end
+
+          ##
+          # @return [String]
+          #
+          def imported_prefix
+            prepend ? "Prepended" : "Included"
+          end
+
+          ##
+          # @return [String]
+          #
+          def scoped_prefix
+            case scope
+            when Constants::INSTANCE_SCOPE then "Instance"
+            when Constants::CLASS_SCOPE then "Class"
+            end
+          end
+
+          ##
+          # @return [Module, Class]
+          #
+          def importer
+            case scope
+            when Constants::INSTANCE_SCOPE then importing_module
+            when Constants::CLASS_SCOPE then importing_module.singleton_class
+            end
+          end
+
+          ##
+          # @param mod [Module]
+          # @return [Module]
+          #
+          def import(mod)
+            prepend ? importer.prepend(mod) : importer.include(mod)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "commands/create_methods_module"
+require_relative "commands/import_method"

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Constants
+        INSTANCE_SCOPE = :instance
+        CLASS_SCOPE = :class
+
+        DEFAULT_SCOPE = Constants::INSTANCE_SCOPE
+        DEFAULT_PREPEND = false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Entities
+        class Method
+          ##
+          # @!attribute [r] full_name
+          #   @return [String, Symbol]
+          #
+          attr_reader :full_name
+
+          ##
+          # @!attribute [r] scope
+          #   @return [:instance, :class]
+          #
+          attr_reader :scope
+
+          ##
+          # @!attribute [r] body
+          #   @return [Proc]
+          #
+          attr_reader :body
+
+          ##
+          # @param full_name [String, Symbol]
+          # @param scope [:instance, :class]
+          # @param body [Proc]
+          # @return [void]
+          #
+          def initialize(full_name:, scope:, body:)
+            @full_name = full_name
+            @scope = scope
+            @body = body
+          end
+
+          ##
+          # @return [String]
+          #
+          def name
+            @name ||= full_name_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) }
+          end
+
+          ##
+          # @param mod [Module]
+          # @return [ConvenientService::Support::DependencyContainer::Entities::Method]
+          #
+          def define_in_module!(mod)
+            ##
+            # NOTE: `innermost_namespace` is just `mod`, when `namespaces` are empty.
+            #
+            innermost_namespace =
+              namespaces.reduce(mod) do |namespace, sub_namespace|
+                already_defined_sub_namespace = namespace.namespaces.find_by(name: sub_namespace.name)
+
+                ##
+                # NOTE:
+                #   - Reuses already defined namespace from previous "imports".
+                #   - In contrast, same methods are always redefined.
+                #
+                next already_defined_sub_namespace if already_defined_sub_namespace
+
+                namespace.namespaces << sub_namespace
+
+                namespace.define_method(sub_namespace.name) { sub_namespace.body.call }
+
+                sub_namespace
+              end
+
+            ##
+            # NOTE:
+            #   - Same methods are redefined.
+            #   - In contrast, same namespaces are always reused.
+            #
+            innermost_namespace.define_method(method.name, &method.body)
+
+            method
+          end
+
+          ##
+          # @param other [Object] Can be any type.
+          # @return [Boolean]
+          #
+          def ==(other)
+            return unless other.instance_of?(self.class)
+
+            return false if full_name != other.full_name
+            return false if scope != other.scope
+            return false if body != other.body
+
+            true
+          end
+
+          private
+
+          ##
+          # @return [ConvenientService::Support::DependencyContainer::Entities::Method]
+          #
+          def method
+            self
+          end
+
+          ##
+          # @return [Array<String>]
+          #
+          def full_name_parts
+            @full_name_parts ||= Utils::String.split(full_name, ".", "::").map(&:to_sym)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Entities
+        class MethodCollection
+          ##
+          # @param methods [Array<ConvenientService::Support::DependencyContainer::Entities::Method>]
+          # @return [void]
+          #
+          def initialize(methods: [])
+            @methods = methods
+          end
+
+          ##
+          # @param name [String, Symbol]
+          # @param full_name [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)
+            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.scope == scope } if scope != Support::NOT_PASSED
+
+            condition = Utils::Proc.conjunct(rules)
+
+            methods.find(&condition)
+          end
+
+          ##
+          # @param method [ConvenientService::Support::DependencyContainer::Entities::Method]
+          # @return [ConvenientService::Support::DependencyContainer::Entities::MethodCollection]
+          #
+          def <<(method)
+            methods << method
+
+            self
+          end
+
+          ##
+          # @return [Boolean]
+          #
+          def empty?
+            methods.empty?
+          end
+
+          ##
+          # @param method [ConvenientService::Support::DependencyContainer::Entities::Method]
+          # @return [Boolean]
+          #
+          def include?(method)
+            methods.include?(method)
+          end
+
+          ##
+          # @return [ConvenientService::Support::DependencyContainer::Entities::MethodCollection]
+          #
+          def clear
+            methods.clear
+
+            self
+          end
+
+          ##
+          # @return [Array]
+          #
+          def to_a
+            methods.to_a
+          end
+
+          ##
+          # @param other [Object] Can be any type.
+          # @return [Boolean]
+          #
+          def ==(other)
+            return unless other.instance_of?(self.class)
+
+            return false if methods != other.methods
+
+            true
+          end
+
+          protected
+
+          ##
+          # @!attribute [r] methods
+          #   @return [Array<ConvenientService::Support::DependencyContainer::Entities::Method>]
+          #
+          attr_reader :methods
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Entities
+        class Namespace
+          ##
+          # @!attribute [r] name
+          #   @return [String, Symbol]
+          #
+          attr_reader :name
+
+          ##
+          # @param name [String, Symbol]
+          # @return [void]
+          #
+          def initialize(name:)
+            @name = name
+          end
+
+          ##
+          # @return [Proc]
+          #
+          def body
+            @body ||= -> { namespace }
+          end
+
+          ##
+          # @return [ConvenientService::Support::DependencyContainer::Entities::NamespaceCollection]
+          #
+          def namespaces
+            @namespaces ||= Entities::NamespaceCollection.new
+          end
+
+          ##
+          # @param name [String, Symbol]
+          # @param body [Proc]
+          # @return [Symbol]
+          #
+          def define_method(name, &body)
+            define_singleton_method(name, &body)
+          end
+
+          ##
+          # @param other [Object] Can be any type.
+          # @return [Boolean]
+          #
+          def ==(other)
+            return unless other.instance_of?(self.class)
+
+            return false if name != other.name
+
+            true
+          end
+
+          private
+
+          ##
+          # @return [ConvenientService::Support::DependencyContainer::Entities::Namespace]
+          #
+          def namespace
+            self
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Entities
+        class NamespaceCollection
+          ##
+          # @param namespaces [Array<ConvenientService::Support::DependencyContainer::Entities::Namespace>]
+          # @return [void]
+          #
+          def initialize(namespaces: [])
+            @namespaces = namespaces
+          end
+
+          ##
+          #
+          #
+          def define_namespace(namespace)
+            namespaces << namespace
+
+            define_singleton_method(namespace.name) { namespace.body.call }
+          end
+
+          ##
+          # @param name [String, Symbol]
+          # @return [ConvenientService::Support::DependencyContainer::Entities::Namespace, nil]
+          #
+          def find_by(name: Support::NOT_PASSED)
+            rules = []
+
+            rules << ->(namespace) { namespace.name.to_s == name.to_s } if name != Support::NOT_PASSED
+
+            condition = Utils::Proc.conjunct(rules)
+
+            namespaces.find(&condition)
+          end
+
+          ##
+          # @param namespace [ConvenientService::Support::DependencyContainer::Entities::Namespace]
+          # @return [ConvenientService::Support::DependencyContainer::Entities::NamespaceCollection]
+          #
+          def <<(namespace)
+            namespaces << namespace
+
+            self
+          end
+
+          ##
+          # @return [Boolean]
+          #
+          def empty?
+            namespaces.empty?
+          end
+
+          ##
+          # @param namespace [ConvenientService::Support::DependencyContainer::Entities::Namespace]
+          # @return [Boolean]
+          #
+          def include?(namespace)
+            namespaces.include?(namespace)
+          end
+
+          ##
+          # @return [ConvenientService::Support::DependencyContainer::Entities::NamespaceCollection]
+          #
+          def clear
+            namespaces.clear
+
+            self
+          end
+
+          ##
+          # @return [Array]
+          #
+          def to_a
+            namespaces.to_a
+          end
+
+          ##
+          # @param other [Object] Can be any type.
+          # @return [Boolean]
+          #
+          def ==(other)
+            return unless other.instance_of?(self.class)
+
+            return false if namespaces != other.namespaces
+
+            true
+          end
+
+          protected
+
+          ##
+          # @!attribute [r] namespaces
+          #   @return [Array<ConvenientService::Support::DependencyContainer::Entities::Namespace>]
+          #
+          attr_reader :namespaces
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "entities/method_collection"
+require_relative "entities/method"
+require_relative "entities/namespace_collection"
+require_relative "entities/namespace"

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Errors
+        class NotExportableModule < ConvenientService::Error
+          ##
+          # @param mod [Module]
+          # @return [void]
+          #
+          def initialize(mod:)
+            message = <<~TEXT
+              Module `#{mod}` can NOT export methods.
+
+              Did you forget to include `ConvenientService::Container.export` into it?
+            TEXT
+
+            super(message)
+          end
+        end
+
+        class NotExportedMethod < ConvenientService::Error
+          ##
+          # @param method_name [String]
+          # @param method_scope [Symbol]
+          # @param mod [Module]
+          # @return [void]
+          #
+          def initialize(method_name:, method_scope:, mod:)
+            message = <<~TEXT
+              Module `#{mod}` does NOT export method `#{method_name}` with `#{method_scope}` scope.
+
+              Did you forget to export if from `#{mod}`? For example:
+
+              module #{mod}
+                export #{method_name}, scope: :#{method_scope} do |*args, **kwargs, &block|
+                  # ...
+                end
+              end
+            TEXT
+
+            super(message)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Export
+        include Support::Concern
+
+        class_methods do
+          ##
+          # @param full_name [String, Symbol]
+          # @param scope [:instance, :class]
+          # @param body [Proc]
+          # @return [ConvenientService::Support::DependencyContainer::Entities::Method]
+          #
+          def export(full_name, scope: Constants::DEFAULT_SCOPE, &body)
+            Entities::Method.new(full_name: full_name, scope: scope, body: body).tap { |method| exported_methods << method }
+          end
+
+          ##
+          # @return [ConvenientService::Support::DependencyContainer::Entities::MethodCollection]
+          #
+          def exported_methods
+            @exported_methods ||= Entities::MethodCollection.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Import
+        include Support::Concern
+
+        class_methods do
+          ##
+          # @param full_name [String, Symbol]
+          # @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)
+            raise Errors::NotExportableModule.new(mod: from) unless Utils::Module.include_module?(from, DependencyContainer::Export)
+
+            method = from.exported_methods.find_by(full_name: full_name, scope: scope)
+
+            raise Errors::NotExportedMethod.new(method_name: full_name, method_scope: scope, mod: from) unless method
+
+            Commands::ImportMethod.call(importing_module: self, exporting_module: from, method: method, scope: scope, prepend: prepend)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/support/dependency_container.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "dependency_container/commands"
+require_relative "dependency_container/constants"
+require_relative "dependency_container/entities"
+require_relative "dependency_container/errors"
+
+require_relative "dependency_container/export"
+require_relative "dependency_container/import"

data/lib/convenient_service/support/not_passed.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    NOT_PASSED = ::Object.new
+  end
+end

data/lib/convenient_service/support.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "support/not_passed"
 require_relative "support/concern"
 
 require_relative "support/abstract_method"
@@ -8,6 +9,7 @@ require_relative "support/castable"
 require_relative "support/command"
 require_relative "support/copyable"
 require_relative "support/delegate"
+require_relative "support/dependency_container"
 require_relative "support/finite_loop"
 require_relative "support/gems"
 require_relative "support/middleware"

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+##
+# @example Two args form (works as GetOwnConst).
+#   module Test
+#   end
+#
+#   ConvenientService::Utils::Module::FetchOwnConst.call(Test, :File)
+#   # => nil, not File from Ruby Core.
+#
+#   module Test
+#     class File
+#     end
+#   end
+#
+#   ConvenientService::Utils::Module::FetchOwnConst.call(Test, :File)
+#   # => Test::File
+#
+# @example Two args + block form.
+#   module Test
+#   end
+#
+#   ConvenientService::Utils::Module::FetchOwnConst.call(Test, :File) { Class.new }
+#   # => Test::File, just created.
+#
+#   module Test
+#     class File
+#     end
+#   end
+#
+#   ConvenientService::Utils::Module::FetchOwnConst.call(Test, :File)
+#   # => Test::File, already existing.
+#
+module ConvenientService
+  module Utils
+    module Module
+      class FetchOwnConst < Support::Command
+        ##
+        # @!attribute [r] mod
+        #   @return [Class, Module]
+        #
+        attr_reader :mod
+
+        ##
+        # @!attribute [r] const_name
+        #   @return [Symbol]
+        #
+        attr_reader :const_name
+
+        ##
+        # @!attribute [r] fallback_block
+        #   @return [Proc, nil]
+        #
+        attr_reader :fallback_block
+
+        ##
+        # @param mod [Class, Module]
+        # @param const_name [Symbol]
+        # @param fallback_block [Proc]
+        # @return [void]
+        #
+        def initialize(mod, const_name, &fallback_block)
+          @mod = mod
+          @const_name = const_name
+          @fallback_block = fallback_block
+        end
+
+        ##
+        # @return [Object] Value of own const. Can be any type.
+        #
+        # @internal
+        #   TODO: Wrap by mutex?
+        #
+        def call
+          ##
+          # NOTE: > If `inherit` is `false`, the lookup only checks the constants in the receiver:
+          # https://ruby-doc.org/core-3.0.0/Module.html#method-i-const_defined-3F
+          #
+          return mod.const_get(const_name, false) if mod.const_defined?(const_name, false)
+
+          return mod.const_set(const_name, fallback_block.call) if fallback_block
+
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Utils
+    module Module
+      class IncludeModule < Support::Command
+        ##
+        # @!attribute [r] mod
+        #   @return [Module]
+        #
+        attr_reader :mod
+
+        ##
+        # @!attribute [r] other_mod
+        #   @return [Module]
+        #
+        attr_reader :other_mod
+
+        ##
+        # @param mod [Module]
+        # @param other_mod [Module]
+        # @return [void]
+        #
+        def initialize(mod, other_mod)
+          @mod = mod
+          @other_mod = other_mod
+        end
+
+        ##
+        # @return [Boolean]
+        #
+        def call
+          mod.included_modules.include?(other_mod)
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/utils/module.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 require_relative "module/class_method_defined"
+require_relative "module/fetch_own_const"
 require_relative "module/get_own_instance_method"
 require_relative "module/get_own_const"
 require_relative "module/has_own_instance_method"
+require_relative "module/include_module"
 require_relative "module/instance_method_defined"
 
 module ConvenientService
@@ -19,6 +21,10 @@ module ConvenientService
           ClassMethodDefined.call(...)
         end
 
+        def fetch_own_const(...)
+          FetchOwnConst.call(...)
+        end
+
         def get_own_instance_method(...)
           GetOwnInstanceMethod.call(...)
         end
@@ -31,6 +37,10 @@ module ConvenientService
           HasOwnInstanceMethod.call(...)
         end
 
+        def include_module?(...)
+          IncludeModule.call(...)
+        end
+
         def instance_method_defined?(...)
           InstanceMethodDefined.call(...)
         end

data/lib/convenient_service/utils/proc/conjunct.rb

@@ -29,7 +29,7 @@ module ConvenientService
         # - https://en.wikipedia.org/wiki/Logical_conjunction
         #
         def call
-          return ->(item) { true } if procs.none?
+          return ->(item) {} if procs.none?
 
           return procs.first if procs.one?
 

data/lib/convenient_service/utils/string/split.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Utils
+    module String
+      class Split < Support::Command
+        ##
+        # @!attribute [r] string
+        #   @return [#to_s]
+        #
+        attr_reader :string
+
+        ##
+        # @!attribute [r] delimiters
+        #   @return [Array<String>]
+        #
+        attr_reader :delimiters
+
+        ##
+        # @param string [Symbol, String]
+        # @param delimiters [Array<String>]
+        # @return [void]
+        #
+        def initialize(string, *delimiters)
+          @string = string
+          @delimiters = delimiters
+        end
+
+        ##
+        # @return [String]
+        #
+        # @internal
+        #   https://stackoverflow.com/a/51380514/12201472
+        #
+        def call
+          string.to_s.split(::Regexp.union(delimiters))
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/utils/string.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "string/camelize"
+require_relative "string/split"
 
 module ConvenientService
   module Utils
@@ -9,6 +10,10 @@ module ConvenientService
         def camelize(...)
           Camelize.call(...)
         end
+
+        def split(...)
+          Split.call(...)
+        end
       end
     end
   end

data/lib/convenient_service/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ConvenientService
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/convenient_service.rb

@@ -29,3 +29,9 @@ require_relative "convenient_service/core"
 require_relative "convenient_service/common"
 require_relative "convenient_service/service"
 require_relative "convenient_service/configs"
+
+##
+# @internal
+#   Convenient Service Aliases.
+#
+require_relative "convenient_service/aliases"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: convenient_service
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Marian Kostyk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-03 00:00:00.000000000 Z
+date: 2023-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: appraisal
@@ -182,16 +182,16 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.40.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.40.0
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -331,6 +331,7 @@ files:
 - docker/3.1/Dockerfile
 - env.rb
 - lib/convenient_service.rb
+- lib/convenient_service/aliases.rb
 - lib/convenient_service/common.rb
 - lib/convenient_service/common/plugins.rb
 - lib/convenient_service/common/plugins/aliases.rb
@@ -702,12 +703,26 @@ files:
 - lib/convenient_service/support/concern.rb
 - lib/convenient_service/support/copyable.rb
 - lib/convenient_service/support/delegate.rb
+- lib/convenient_service/support/dependency_container.rb
+- lib/convenient_service/support/dependency_container/commands.rb
+- lib/convenient_service/support/dependency_container/commands/create_methods_module.rb
+- lib/convenient_service/support/dependency_container/commands/import_method.rb
+- lib/convenient_service/support/dependency_container/constants.rb
+- lib/convenient_service/support/dependency_container/entities.rb
+- lib/convenient_service/support/dependency_container/entities/method.rb
+- lib/convenient_service/support/dependency_container/entities/method_collection.rb
+- lib/convenient_service/support/dependency_container/entities/namespace.rb
+- lib/convenient_service/support/dependency_container/entities/namespace_collection.rb
+- lib/convenient_service/support/dependency_container/errors.rb
+- lib/convenient_service/support/dependency_container/export.rb
+- lib/convenient_service/support/dependency_container/import.rb
 - lib/convenient_service/support/finite_loop.rb
 - lib/convenient_service/support/gems.rb
 - lib/convenient_service/support/gems/active_model.rb
 - lib/convenient_service/support/gems/rspec.rb
 - lib/convenient_service/support/middleware.rb
 - lib/convenient_service/support/middleware/stack_builder.rb
+- lib/convenient_service/support/not_passed.rb
 - lib/convenient_service/support/raw_value.rb
 - lib/convenient_service/support/ruby.rb
 - lib/convenient_service/support/version.rb
@@ -731,9 +746,11 @@ files:
 - lib/convenient_service/utils/method/defined.rb
 - lib/convenient_service/utils/module.rb
 - lib/convenient_service/utils/module/class_method_defined.rb
+- lib/convenient_service/utils/module/fetch_own_const.rb
 - lib/convenient_service/utils/module/get_own_const.rb
 - lib/convenient_service/utils/module/get_own_instance_method.rb
 - lib/convenient_service/utils/module/has_own_instance_method.rb
+- lib/convenient_service/utils/module/include_module.rb
 - lib/convenient_service/utils/module/instance_method_defined.rb
 - lib/convenient_service/utils/object.rb
 - lib/convenient_service/utils/object/instance_variable_fetch.rb
@@ -743,6 +760,7 @@ files:
 - lib/convenient_service/utils/proc/exec_config.rb
 - lib/convenient_service/utils/string.rb
 - lib/convenient_service/utils/string/camelize.rb
+- lib/convenient_service/utils/string/split.rb
 - lib/convenient_service/version.rb
 - logo.png
 homepage: https://github.com/marian13/convenient_service