convenient_service 0.12.0 → 0.13.0

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

@@ -50,6 +50,9 @@ module ConvenientService
         def call
           method = mod.instance_method(method_name) if has_own_instance_method?
 
+          ##
+          # TODO: Warn if exceeded.
+          #
           finite_loop do
             break if method.nil?
             break if method.owner == mod

data/lib/convenient_service/utils/module/instance_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, private: true)
+          Utils::Method.defined?(method_name, mod, public: public, protected: protected, private: private)
         end
       end
     end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+##
+# Returns class when `object` is a class, module when `object` is a module or object's class.
+#
+# @example Aloid `if` condition for `ConvenientService::Core::Concern::ClassMethod#middlewares`.
+#
+#   service = Service.new # || Service
+#
+#   if service.is_a?(Module)
+#     service.middlewares(:result)
+#   else
+#     service.class.middelewares(:result)
+#   end
+#
+#   ##
+#   # With `ConvenientService::Utils::Object::clamp_class` it can be rewritten in the followiing way:
+#   #
+#   ConvenientService::Utils::Object::clamp_class(service).middlewares(:result)
+#
+# @example Possible returns values.
+#
+#   module Musician
+#   end
+#
+#   class Person
+#   end
+#
+#   person = Person.new
+#
+#   ConvenientService::Utils::Object::ClampClass.call(42)
+#   # => Integer
+#
+#   ConvenientService::Utils::Object::ClampClass.call("foo")
+#   # => String
+#
+#   ConvenientService::Utils::Object::ClampClass.call(person)
+#   # => Person
+#
+#   ConvenientService::Utils::Object::ClampClass.call(Person)
+#   # => Person
+#
+#   ConvenientService::Utils::Object::ClampClass.call(Musician)
+#   # => Musician
+#
+# @note Name is inspired by `Comparable#clamp`.
+#
+# @see https://ruby-doc.org/core-2.7.0/Comparable.html#method-i-clamp
+#
+module ConvenientService
+  module Utils
+    module Object
+      class ClampClass < Support::Command
+        ##
+        # @!attribute [r] object
+        #   @return [Object]
+        #
+        attr_reader :object
+
+        ##
+        # @param object [Object]
+        # @return [void]
+        #
+        def initialize(object)
+          @object = object
+        end
+
+        ##
+        # @return [Class]
+        #
+        def call
+          object.is_a?(::Module) ? object : object.class
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+##
+# Converts an object to a "duck" class in terms of `Module#method_defined?` or `Module#define_method`.
+#
+# @example Avoid `if` condition for `Module#method_defined?`.
+#
+#   object = Person.new # || Person
+#
+#   if object.is_a?(Module)
+#     ##
+#     # class Person
+#     #   def self.foo
+#     #   end
+#     # end
+#     #
+#     # Does `Person` has class method `foo`?
+#     #
+#     object.singleton_class.method_defined?(:foo)
+#   else
+#     ##
+#     # class Person
+#     #   def foo
+#     #   end
+#     # end
+#     #
+#     # Does `Person` has instance method `foo`?
+#     #
+#     object.class.method_defined?(:foo)
+#   end
+#
+#   ##
+#   # With `ConvenientService::Utils::Object.duck_class` it can be rewritten in the following way:
+#   #
+#   ConvenientService::Utils::Object.duck_class(object).method_defined?(:foo)
+#
+# @example Avoid `if` condition for `Module#define_method`.
+#
+#   object = Person.new # || Person
+#
+#   if object.is_a?(Module)
+#     ##
+#     # Defines class method `foo` in `Person` class.
+#     #
+#     object.singleton_class.define_method(:foo) { :bar }
+#   else
+#     ##
+#     # Defines instance method `foo` in `Person` class.
+#     #
+#     object.class.define_method(:foo) { :bar }
+#   end
+#
+#   ##
+#   # With `ConvenientService::Utils::Object.duck_class` it can be rewritten in the following way:
+#   #
+#   ConvenientService::Utils::Object.duck_class(object).define_method(:foo) { :bar }
+#
+# @example Possible return values.
+#
+#   module Musician
+#   end
+#
+#   class Person
+#   end
+#
+#   person = Person.new
+#
+#   ConvenientService::Utils::Object::DuckClass.call(42)
+#   # => Integer
+#
+#   ConvenientService::Utils::Object::DuckClass.call("foo")
+#   # => String
+#
+#   ConvenientService::Utils::Object::DuckClass.call(person)
+#   # => Person
+#
+#   ConvenientService::Utils::Object::DuckClass.call(Person)
+#   # => #<Class:Person>
+#
+#   ConvenientService::Utils::Object::DuckClass.call(Musician)
+#   # => #<Class:Musician>
+#
+module ConvenientService
+  module Utils
+    module Object
+      ##
+      # TODO: A better name.
+      #
+      class DuckClass < 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]
+        #
+        def call
+          object.is_a?(::Module) ? object.singleton_class : object.class
+        end
+      end
+    end
+  end
+end

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

@@ -10,7 +10,7 @@ module ConvenientService
       # Can be used instead of `return @ivar if defined? @ivar`.
       # @see https://www.justinweiss.com/articles/4-simple-memoization-patterns-in-ruby-and-one-gem/
       #
-      # @note: `false` and `nil` are the only values that are considered `falsy` in Ruby.
+      # @note `false` and `nil` are the only values that are considered `falsy` in Ruby.
       # @see https://riptutorial.com/ruby/example/2092/truthy-and-falsy-values
       # @see https://www.ruby-lang.org/en/documentation/faq/6/
       #

data/lib/convenient_service/utils/object.rb

@@ -1,15 +1,32 @@
 # frozen_string_literal: true
 
+require_relative "object/clamp_class"
+require_relative "object/duck_class"
 require_relative "object/instance_variable_delete"
 require_relative "object/instance_variable_fetch"
 require_relative "object/memoize_including_falsy_values"
-require_relative "object/resolve_class"
 require_relative "object/resolve_type"
 
 module ConvenientService
   module Utils
     module Object
       class << self
+        ##
+        # @example
+        #   ConvenientService::Utils::Object.clamp_class("foo")
+        #
+        def clamp_class(...)
+          ClampClass.call(...)
+        end
+
+        ##
+        # @example
+        #   ConvenientService::Utils::Object.duck_class("foo")
+        #
+        def duck_class(...)
+          DuckClass.call(...)
+        end
+
         ##
         # @example
         #   ConvenientService::Utils::Object.instance_variable_delete("abc", :@foo)
@@ -30,20 +47,12 @@ module ConvenientService
         # @example
         #   object = Object.new.tap { |object| object.instance_eval { self.class.attr_reader :foo } }
         #
-        #   ConvenientService::Utils::Object.memoize_including_falsy_values(object, :@foo) { false }
+        #   ConvenientService::Utils.memoize_including_falsy_values(object, :@foo) { false }
         #
         def memoize_including_falsy_values(...)
           MemoizeIncludingFalsyValues.call(...)
         end
 
-        ##
-        # @example
-        #   ConvenientService::Utils::Object.resolve_class("foo")
-        #
-        def resolve_class(...)
-          ResolveClass.call(...)
-        end
-
         ##
         # @example
         #   ConvenientService::Utils::Object.resolve_type("foo")

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Utils
+    module String
+      ##
+      # @example
+      #   ConvenientService::Utils::String.truncate("hello", -1)                 # => ""
+      #   ConvenientService::Utils::String.truncate("hello", 0)                  # => ""
+      #   ConvenientService::Utils::String.truncate("hello", 1)                  # => "."
+      #   ConvenientService::Utils::String.truncate("hello", 2)                  # => ".."
+      #   ConvenientService::Utils::String.truncate("hello", 3)                  # => "..."
+      #   ConvenientService::Utils::String.truncate("hello", 4)                  # => "h..."
+      #   ConvenientService::Utils::String.truncate("hello", 4, omission: "--")  # => "he--"
+      #   ConvenientService::Utils::String.truncate("hello", 5)                  # => "hello"
+      #   ConvenientService::Utils::String.truncate("hello", 6)                  # => "hello"
+      #   ConvenientService::Utils::String.truncate("hello", 7)                  # => "hello"
+      #
+      # @internal
+      #   NOTE: Naming is inspired by `String#truncate` from Rails, but behaviour is different.
+      #   - https://api.rubyonrails.org/classes/String.html#method-i-truncate
+      #
+      class Truncate < Support::Command
+        ##
+        # @!attribute [r] string
+        #   @return [String]
+        #
+        attr_reader :string
+
+        ##
+        # @!attribute [r] truncate_at
+        #   @return [Integer]
+        #
+        attr_reader :truncate_at
+
+        ##
+        # @!attribute [r] omission
+        #   @return [String]
+        #
+        attr_reader :omission
+
+        ##
+        # @param string [#to_s]
+        # @param truncate_at [Integer]
+        # @param omission [String]
+        # @return [void]
+        #
+        def initialize(string, truncate_at, omission: "...")
+          @string = string.to_s
+          @truncate_at = truncate_at
+          @omission = omission
+        end
+
+        ##
+        # @return [String]
+        #
+        def call
+          return "" if truncate_at <= 0
+
+          return string if truncate_at >= string.length
+
+          return omission[...truncate_at] if truncate_at <= omission.length
+
+          "#{string[...truncate_at - omission.length]}#{omission}"
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/utils/string.rb

@@ -3,6 +3,7 @@
 require_relative "string/camelize"
 require_relative "string/demodulize"
 require_relative "string/split"
+require_relative "string/truncate"
 
 module ConvenientService
   module Utils
@@ -19,6 +20,10 @@ module ConvenientService
         def split(...)
           Split.call(...)
         end
+
+        def truncate(...)
+          Truncate.call(...)
+        end
       end
     end
   end

data/lib/convenient_service/utils.rb

@@ -2,9 +2,30 @@
 
 require_relative "utils/array"
 require_relative "utils/bool"
+require_relative "utils/class"
 require_relative "utils/hash"
 require_relative "utils/method"
 require_relative "utils/module"
 require_relative "utils/proc"
 require_relative "utils/string"
 require_relative "utils/object"
+
+module ConvenientService
+  module Utils
+    class << self
+      ##
+      # @return [Object] Can be any type.
+      #
+      def memoize_including_falsy_values(...)
+        Object::MemoizeIncludingFalsyValues.call(...)
+      end
+
+      ##
+      # @return [Boolean]
+      #
+      def to_bool(...)
+        Bool::ToBool.call(...)
+      end
+    end
+  end
+end

data/lib/convenient_service/version.rb

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

data/lib/convenient_service.rb

@@ -11,7 +11,7 @@ require_relative "convenient_service/dependencies"
 #   Convenient Service Inner Tools and Utilities.
 #
 require_relative "convenient_service/logger"
-require_relative "convenient_service/error"
+require_relative "convenient_service/exception"
 require_relative "convenient_service/support"
 require_relative "convenient_service/utils"
 require_relative "convenient_service/version"
@@ -30,12 +30,6 @@ require_relative "convenient_service/common"
 require_relative "convenient_service/service"
 require_relative "convenient_service/configs"
 
-##
-# @internal
-#   Convenient Service Predefined Services.
-#
-require_relative "convenient_service/services"
-
 ##
 # @internal
 #   Convenient Service Feature.
@@ -47,3 +41,16 @@ require_relative "convenient_service/feature"
 #   Convenient Service Aliases.
 #
 require_relative "convenient_service/aliases"
+
+module ConvenientService
+  class << self
+    ##
+    # @api public
+    #
+    # @return [ConvenientService::Logger]
+    #
+    def logger
+      Logger.instance
+    end
+  end
+end

data/minitest.rb

@@ -0,0 +1,30 @@
+##
+# A custom runner for minitest.
+# It is created to have a "simpler" interface than original rake task provides.
+# - https://stackoverflow.com/questions/4788288/how-to-run-all-tests-with-minitest
+##
+
+##
+# Takes the current working directory.
+# - https://ruby-doc.org/core-2.7.0/Dir.html#method-c-pwd
+#
+current_dir = ::Dir.pwd
+
+##
+# Adds `test` to the load path in order to allow writing simply `require "test_helper"` in test files.
+# - https://thoughtbot.com/blog/following-the-path
+#
+# NOTE: `unless` for idempotence.
+#
+$LOAD_PATH.unshift("#{current_dir}/test") unless $LOAD_PATH.include?("#{current_dir}/test")
+
+##
+# Recursively selects all `*_test.rb` files from the `test` folder or takes files passed in `ARGV`.
+# - https://lofic.github.io/tips/ruby-recursive_globbing.html
+#
+files = ::ARGV.empty? ? ::Dir.glob("#{current_dir}/test/**/*_test.rb") : ::ARGV.to_a
+
+##
+# Runs test files.
+#
+files.each { |file| require file }