convenient_service 0.1.0

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+##
+# @example:
+#   ConvenientService::Utils::Hash::Except.call({foo: :bar, baz: :qux}, [:foo])
+#
+module ConvenientService
+  module Utils
+    module Hash
+      class Except < Support::Command
+        ##
+        # @!attribute [r] hash
+        #   @return [Hash]
+        #
+        attr_reader :hash
+
+        ##
+        # @!attribute [r] keys
+        #   @return [Array]
+        #
+        attr_reader :keys
+
+        ##
+        # @param hash [Hash]
+        # @param keys [Array]
+        # @return [void]
+        #
+        def initialize(hash, keys)
+          @hash = hash
+          @keys = keys
+        end
+
+        ##
+        # @return [Hash]
+        #
+        # @internal
+        #   NOTE: Copied with minimal modifications from:
+        #   https://api.rubyonrails.org/classes/Hash.html#method-i-except
+        #
+        def call
+          hash.slice(*hash.keys - keys)
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/utils/hash.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "hash/except"
+
+module ConvenientService
+  module Utils
+    module Hash
+      class << self
+        def except(...)
+          Except.call(...)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Utils
+    module Method
+      class Defined < Support::Command
+        ##
+        # @!attribute [r] method
+        #   @return [Class]
+        #
+        attr_reader :method
+
+        ##
+        # @!attribute [r] klass
+        #   @return [Class]
+        #
+        attr_reader :klass
+
+        ##
+        # @!attribute [r] klass
+        #   @return [Class]
+        #
+        attr_reader :private
+
+        ##
+        # @param method [Symbol, String]
+        # @param klass [Class]
+        # @return [void]
+        #
+        def initialize(method, klass, private: false)
+          @method = method.to_s
+          @klass = klass
+          @private = private
+        end
+
+        ##
+        # @return [void]
+        #
+        def call
+          return true if klass.method_defined?(method)
+
+          return klass.private_method_defined?(method) if private
+
+          false
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/utils/method.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "method/defined"
+
+module ConvenientService
+  module Utils
+    module Method
+      class << self
+        def defined?(...)
+          Defined.call(...)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Utils
+    module Module
+      class ClassMethodDefined < Support::Command
+        ##
+        # @!attribute [r] mod
+        #   @return [Class, Module]
+        #
+        attr_reader :mod
+
+        ##
+        # @!attribute [r] method_name
+        #   @return [String, Symbol]
+        #
+        attr_reader :method_name
+
+        ##
+        # @!attribute [r] private
+        #   @return [Boolean]
+        #
+        attr_reader :private
+
+        ##
+        # @param mod [Class, Module]
+        # @param method_name [String, Symbol]
+        # @param private [Boolean]
+        # @return [void]
+        #
+        def initialize(mod, method_name, private: false)
+          @mod = mod
+          @method_name = method_name
+          @private = private
+        end
+
+        ##
+        # @return [Boolean]
+        #
+        def call
+          Utils::Method.defined?(method_name, mod.singleton_class, private: true)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+##
+# @example
+#   module Test
+#   end
+#
+#   ConvenientService::Utils::Module::GetOwnConst.call(Test, :File)
+#   # => nil, not File from Ruby Core.
+#
+#   module Test
+#     class File
+#     end
+#   end
+#
+#   ConvenientService::Utils::Module::GetOwnConst.call(Test, :File)
+#   # => Test::File
+#
+module ConvenientService
+  module Utils
+    module Module
+      class GetOwnConst < Support::Command
+        ##
+        # @!attribute [r] mod
+        #   @return [Class, Module]
+        #
+        attr_reader :mod
+
+        ##
+        # @!attribute [r] const_name
+        #   @return [Symbol]
+        #
+        attr_reader :const_name
+
+        ##
+        # @param mod [Class, Module]
+        # @param const_name [Symbol]
+        # @return [void]
+        #
+        def initialize(mod, const_name)
+          @mod = mod
+          @const_name = const_name
+        end
+
+        ##
+        # @return [Object] Value of own const. Can be any type.
+        #
+        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 unless mod.const_defined?(const_name, false)
+
+          mod.const_get(const_name, false)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Utils
+    module Module
+      class GetOwnInstanceMethod < Support::Command
+        include Support::FiniteLoop
+
+        ##
+        # @!attribute [r] mod
+        #   @return [Class, Module]
+        #
+        attr_reader :mod
+
+        ##
+        # @!attribute [r] method_name
+        #   @return [String, Symbol]
+        #
+        attr_reader :method_name
+
+        ##
+        # @!attribute [r] private
+        #   @return [Boolean]
+        #
+        attr_reader :private
+
+        ##
+        # @!attribute [r] max_iteration_count
+        #   @return [Integer]
+        #
+        attr_reader :max_iteration_count
+
+        ##
+        # @param mod [Class, Module]
+        # @param method_name [String, Symbol]
+        # @param private [Boolean]
+        # @param max_iteration_count [Integer]
+        # @return [void]
+        #
+        def initialize(mod, method_name, private: false, max_iteration_count: Support::FiniteLoop::MAX_ITERATION_COUNT)
+          @mod = mod
+          @method_name = method_name
+          @private = private
+          @max_iteration_count = max_iteration_count
+        end
+
+        ##
+        # @return [UnboundMethod, nil]
+        #
+        def call
+          method = mod.instance_method(method_name) if has_own_instance_method?
+
+          finite_loop do
+            break if method.nil?
+            break if method.owner == mod
+
+            method = method.super_method
+          end
+
+          method
+        end
+
+        private
+
+        ##
+        # @return [Boolean]
+        #
+        def has_own_instance_method?
+          Utils::Module.has_own_instance_method?(mod, method_name, private: private)
+        end
+
+        ##
+        # @return [Object] Block return value. Can be any type.
+        #
+        def finite_loop(&block)
+          super(max_iteration_count: max_iteration_count, &block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Utils
+    module Module
+      class HasOwnInstanceMethod < Support::Command
+        ##
+        # @!attribute [r] mod
+        #   @return [Class, Module]
+        #
+        attr_reader :mod
+
+        ##
+        # @!attribute [r] method_name
+        #   @return [String, Symbol]
+        #
+        attr_reader :method_name
+
+        ##
+        # @!attribute [r] private
+        #   @return [Boolean]
+        #
+        attr_reader :private
+
+        ##
+        # @param mod [Class, Module]
+        # @param method_name [String, Symbol]
+        # @param private [Boolean]
+        # @return [void]
+        #
+        def initialize(mod, method_name, private: false)
+          @mod = mod
+          @method_name = method_name
+          @private = private
+        end
+
+        ##
+        # @return [Boolean]
+        #
+        def call
+          method = method_name.to_sym
+
+          return true if own_instance_methods.include?(method)
+
+          if private
+            return true if private_own_instance_methods.include?(method)
+          end
+
+          false
+        end
+
+        private
+
+        ##
+        # @return [Array<Symbol>]
+        #
+        # @internal
+        #   NOTE: `instance_methods` returns both public and protected methods.
+        #   NOTE: `instance_methods(false)` returns only own methods.
+        #
+        def own_instance_methods
+          @own_instance_methods ||= mod.instance_methods(false)
+        end
+
+        ##
+        # @return [Array<Symbol>]
+        #
+        # @internal
+        #   NOTE: `private_instance_methods(false)` returns only own methods.
+        #
+        def private_own_instance_methods
+          @private_own_instance_methods ||= mod.private_instance_methods(false)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Utils
+    module Module
+      class InstanceMethodDefined < Support::Command
+        ##
+        # @!attribute [r] mod
+        #   @return [Class, Module]
+        #
+        attr_reader :mod
+
+        ##
+        # @!attribute [r] method_name
+        #   @return [String, Symbol]
+        #
+        attr_reader :method_name
+
+        ##
+        # @!attribute [r] private
+        #   @return [Boolean]
+        #
+        attr_reader :private
+
+        ##
+        # @param mod [Class, Module]
+        # @param method_name [String, Symbol]
+        # @param private [Boolean]
+        # @return [void]
+        #
+        def initialize(mod, method_name, private: false)
+          @mod = mod
+          @method_name = method_name
+          @private = private
+        end
+
+        ##
+        # @return [Boolean]
+        #
+        def call
+          Utils::Method.defined?(method_name, mod, private: true)
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/utils/module.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "module/class_method_defined"
+require_relative "module/get_own_instance_method"
+require_relative "module/get_own_const"
+require_relative "module/has_own_instance_method"
+require_relative "module/instance_method_defined"
+
+module ConvenientService
+  module Utils
+    ##
+    # @internal
+    #   NOTE: `Class` is descendant of `Module`, that is why `Module` is more generic term.
+    #   TODO: Better generic term for both `Module` and `Class`.
+    #
+    module Module
+      class << self
+        def class_method_defined?(...)
+          ClassMethodDefined.call(...)
+        end
+
+        def get_own_instance_method(...)
+          GetOwnInstanceMethod.call(...)
+        end
+
+        def get_own_const(...)
+          GetOwnConst.call(...)
+        end
+
+        def has_own_instance_method?(...)
+          HasOwnInstanceMethod.call(...)
+        end
+
+        def instance_method_defined?(...)
+          InstanceMethodDefined.call(...)
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/utils/object/resolve_type.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+##
+# @example
+#   ConvenientService::Utils::Object::ResolveType.call("foo")
+#   # => "instance"
+#
+#   ConvenientService::Utils::Object::ResolveType.call(Array)
+#   # => "class"
+#
+#   ConvenientService::Utils::Object::ResolveType.call(Kernel)
+#   # => "module"
+#
+module ConvenientService
+  module Utils
+    module Object
+      class ResolveType < Support::Command
+        ##
+        # @!attribute [r] object
+        #   @return [Object] Can be any type.
+        #
+        attr_reader :object
+
+        ##
+        # @param object [Object] Can be any type.
+        #
+        def initialize(object)
+          @object = object
+        end
+
+        ##
+        # @return ["class", "module", "instance"]
+        #
+        def call
+          case object
+          when ::Class
+            "class"
+          when ::Module
+            "module"
+          else
+            "instance"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/utils/object.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "object/resolve_type"
+
+module ConvenientService
+  module Utils
+    module Object
+      class << self
+        ##
+        # @example
+        #   ConvenientService::Utils::Object.resolve_type("foo")
+        #
+        def resolve_type(...)
+          ResolveType.call(...)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Utils
+    module Proc
+      ##
+      # TODO: Compose.
+      #
+      # TODO: Disjunct.
+      #
+      class Conjunct < Support::Command
+        attr_reader :procs
+
+        def initialize(procs)
+          @procs = procs
+        end
+
+        ##
+        # Creates a conjunction of procs.
+        # All procs should accept only one argument.
+        #
+        # For example, let's assume we have two arbitrary functions:
+        #   f(x) and g(x)
+        #
+        # Application of the `conjunct` procedure gives a new function h(x) that can be written as follows:
+        #   h(x) = f(x) && g(x)
+        #
+        # IMPORTANT: Please, learn what is a conjunction before diving into implementation details.
+        # - https://en.wikipedia.org/wiki/Logical_conjunction
+        #
+        def call
+          return ->(item) { true } if procs.none?
+
+          return procs.first if procs.one?
+
+          ##
+          # NOTE: reduce tries to use first element as its initial value if not specified explicitly.
+          # https://ruby-doc.org/core-2.6/Enumerable.html#method-i-reduce
+          #
+          # NOTE: proc can be called by `[]`.
+          # https://ruby-doc.org/core-2.7.1/Proc.html#method-i-5B-5D
+          #
+          procs.reduce(->(item) { true }) { |conjunction, proc| ->(item) { conjunction[item] && proc[item] } }
+        end
+      end
+    end
+  end
+end