convenient_service 0.4.0 → 0.6.0

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,94 @@
+# 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
+
+          ##
+          # @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,74 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Errors
+        class InvalidScope < ConvenientService::Error
+          ##
+          # @param scope [Object]
+          # @return [void]
+          #
+          def initialize(scope:)
+            message = <<~TEXT
+              Scope `#{scope.inspect}` is NOT valid.
+
+              Valid options are #{printable_valid_scopes}.
+            TEXT
+
+            super(message)
+          end
+
+          private
+
+          ##
+          # @return [String]
+          #
+          def printable_valid_scopes
+            Constants::SCOPES.map { |scope| "`:#{scope}`" }.join(", ")
+          end
+        end
+
+        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,38 @@
+# 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]
+          #
+          # @internal
+          #   NOTE: `export` does NOT accept `prepend` kwarg intentionally.
+          #   It is done to follow "the Ruby way".
+          #   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)
+            Commands::AssertValidScope.call(scope: scope)
+
+            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,32 @@
+# 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)
+            Commands::AssertValidScope.call(scope: scope)
+
+            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, exported_method: method, 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/version/null_version.rb

@@ -11,6 +11,13 @@ module ConvenientService
       #   - https://avdi.codes/null-objects-and-falsiness/
       #
       class NullVersion
+        ##
+        # @return [Boolean]
+        #
+        def null_version?
+          true
+        end
+
         ##
         # @return [nil]
         #

data/lib/convenient_service/support/version.rb

@@ -24,10 +24,17 @@ module ConvenientService
         # @return [ConvenientService::Support::Version::NullVersion]
         #
         def null_version
-          @null_version ||= NullVersion.new
+          @null_version ||= Support::Version::NullVersion.new
         end
       end
 
+      ##
+      # @return [Boolean]
+      #
+      def null_version?
+        false
+      end
+
       ##
       # @return [Gem::Version, nil]
       #
@@ -52,6 +59,9 @@ module ConvenientService
 
       private
 
+      ##
+      # @return [String]
+      #
       attr_reader :value
 
       ##

data/lib/convenient_service/support.rb

@@ -1,13 +1,16 @@
 # frozen_string_literal: true
 
+require_relative "support/not_passed"
 require_relative "support/concern"
 
 require_relative "support/abstract_method"
+require_relative "support/arguments"
 require_relative "support/cache"
 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/object/instance_variable_delete.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+##
+#
+#
+module ConvenientService
+  module Utils
+    module Object
+      class InstanceVariableDelete < Support::Command
+        ##
+        # @!attribute [r] object
+        #   @return [Object]
+        #
+        attr_reader :object
+
+        ##
+        # @!attribute [r] ivar_name
+        #   @return [Symbol, String]
+        #
+        attr_reader :ivar_name
+
+        ##
+        # @param object [Object]
+        # @param ivar_name [Symbol]
+        # @return [void]
+        #
+        def initialize(object, ivar_name)
+          @object = object
+          @ivar_name = ivar_name
+        end
+
+        ##
+        # @return [Object] Value of ivar. Can be any type.
+        #
+        def call
+          return object.remove_instance_variable(ivar_name) if object.instance_variable_defined?(ivar_name)
+        end
+      end
+    end
+  end
+end