sleeping_king_studios-tools 0.7.1 → 0.8.0

data/lib/sleeping_king_studios/tools/object_tools.rb

@@ -1,16 +1,33 @@
-# lib/sleeping_king_studios/tools/object_tools.rb
+# frozen_string_literal: true
 
 require 'sleeping_king_studios/tools'
 
 module SleepingKingStudios::Tools
   # Low-level tools for working with objects.
-  module ObjectTools
-    extend self
+  class ObjectTools < SleepingKingStudios::Tools::Base
+    TEMPORARY_METHOD_NAME =
+      '__sleeping_king_studios_tools_apply_%i__'
+    private_constant :TEMPORARY_METHOD_NAME
+
+    class << self
+      def_delegators :instance,
+        :apply,
+        :deep_dup,
+        :deep_freeze,
+        :dig,
+        :eigenclass,
+        :immutable?,
+        :mutable?,
+        :object?,
+        :try
+
+      alias metaclass eigenclass
+    end
 
     # Takes a proc or lambda and invokes it with the given object as
     # receiver, with any additional arguments or block provided.
     #
-    # @param [Object] base The receiver. The proc will be called in the
+    # @param [Object] receiver The receiver. The proc will be called in the
     #   context of this object.
     # @param [Proc] proc The proc or lambda to call.
     # @param [Array] args Optional. Additional arguments to pass in to the
@@ -20,20 +37,16 @@ module SleepingKingStudios::Tools
     #
     # @return The result of calling the proc or lambda with the given
     #   receiver and any additional arguments or block.
-    def apply base, proc, *args, &block
-      return base.instance_exec *args, &proc unless block_given?
+    def apply(receiver, proc, *args, &block)
+      return receiver.instance_exec(*args, &proc) unless block_given?
 
-      temporary_method_name = :__sleeping_king_studios_tools_object_tools_temporary_method_for_applying_proc__
+      method_name =
+        Kernel.format(TEMPORARY_METHOD_NAME, Thread.current.object_id)
 
-      metaclass = class << base; self; end
-      metaclass.send :define_method, temporary_method_name, &proc
-
-      begin
-        base.send temporary_method_name, *args, &block
-      ensure
-        metaclass.send :remove_method, temporary_method_name if temporary_method_name && defined?(temporary_method_name)
+      with_temporary_method(receiver, method_name, proc) do
+        receiver.send(method_name, *args, &block)
       end
-    end # method apply
+    end
 
     # Creates a deep copy of the object. If the object is an Array, returns a
     # new Array with deep copies of each array item. If the object is a Hash,
@@ -43,7 +56,7 @@ module SleepingKingStudios::Tools
     # @param [Object] obj The object to copy.
     #
     # @return The copy of the object.
-    def deep_dup obj
+    def deep_dup(obj)
       case obj
       when FalseClass, Integer, Float, NilClass, Symbol, TrueClass
         obj
@@ -53,8 +66,8 @@ module SleepingKingStudios::Tools
         HashTools.deep_dup obj
       else
         obj.respond_to?(:deep_dup) ? obj.deep_dup : obj.dup
-      end # case
-    end # method deep_dup
+      end
+    end
 
     # Performs a deep freeze of the object. If the object is an Array, freezes
     # the array and performs a deep freeze on each array item. If the object is
@@ -62,7 +75,7 @@ module SleepingKingStudios::Tools
     # value. Otherwise, calls Object#freeze.
     #
     # @param [Object] obj The object to freeze.
-    def deep_freeze obj
+    def deep_freeze(obj)
       case obj
       when FalseClass, Integer, Float, NilClass, Symbol, TrueClass
         # Object is inherently immutable; do nothing here.
@@ -72,8 +85,8 @@ module SleepingKingStudios::Tools
         HashTools.deep_freeze obj
       else
         obj.respond_to?(:deep_freeze) ? obj.deep_freeze : obj.freeze
-      end # case
-    end # method deep_freeze
+      end
+    end
 
     # Accesses deeply nested attributes by calling the first named method on the
     # given object, and each subsequent method on the result of the previous
@@ -85,21 +98,21 @@ module SleepingKingStudios::Tools
     #
     # @return [Object] The result of the last method call, or nil if the last
     #   object does not respond to the last method.
-    def dig object, *method_names
+    def dig(object, *method_names)
       method_names.reduce(object) do |memo, method_name|
         memo.respond_to?(method_name) ? memo.send(method_name) : nil
-      end # reduce
-    end # method object
+      end
+    end
 
     # Returns the object's eigenclass.
     #
     # @param [Object] object The object for which an eigenclass is required.
     #
     # @return [Class] The object's eigenclass.
-    def eigenclass object
-      class << object; self; end
-    end # method eigenclass
-    alias_method :metaclass, :eigenclass
+    def eigenclass(object)
+      object.singleton_class
+    end
+    alias metaclass eigenclass
 
     # Returns true if the object is immutable. Values of nil, false, and true
     # are always immutable, as are instances of Numeric and Symbol. Arrays are
@@ -110,7 +123,7 @@ module SleepingKingStudios::Tools
     # @param obj [Object] The object to test.
     #
     # @return [Boolean] True if the object is immutable, otherwise false.
-    def immutable? obj
+    def immutable?(obj)
       case obj
       when NilClass, FalseClass, TrueClass, Numeric, Symbol
         true
@@ -120,8 +133,8 @@ module SleepingKingStudios::Tools
         HashTools.immutable? obj
       else
         obj.frozen?
-      end # case
-    end # method immutable?
+      end
+    end
 
     # Returns true if the object is mutable.
     #
@@ -130,9 +143,9 @@ module SleepingKingStudios::Tools
     # @return [Boolean] True if the object is mutable, otherwise false.
     #
     # @see #immutable?
-    def mutable? obj
+    def mutable?(obj)
       !immutable?(obj)
-    end # method mutable?
+    end
 
     # Returns true if the object is an Object. This should return true only for
     # objects that have an alternate inheritance chain from BasicObject, such as
@@ -141,9 +154,9 @@ module SleepingKingStudios::Tools
     # @param obj [Object] The object to test.
     #
     # @return [Boolean] True if the object is an Object, otherwise false.
-    def object? obj
-      Object === obj
-    end # method object?
+    def object?(obj)
+      Object.instance_method(:is_a?).bind(obj).call(Object)
+    end
 
     # As #send, but returns nil if the object does not respond to the method.
     #
@@ -151,23 +164,27 @@ module SleepingKingStudios::Tools
     # @param [String, Symbol] method_name The name of the method to call.
     # @param [Array] args The arguments to the message.
     #
-    # @see active_support/core_ext/object/try.rb
-    def try object, method_name, *args
-      if object.nil?
-        return object.respond_to?(method_name) ?
-          object.send(method_name, *args) :
-          nil
-      end # if
-
-      # Delegate to ActiveSupport::CoreExt::Object#try.
+    # @see ActiveSupport::CoreExt::Object#try.
+    def try(object, method_name, *args)
       return object.try(method_name, *args) if object.respond_to?(:try)
 
+      return nil unless object.respond_to?(method_name)
+
       object.send method_name, *args
-    rescue NoMethodError => exception
-      nil
-    end # method try
-  end # module
-end # module
+    end
+
+    private
+
+    def with_temporary_method(receiver, method_name, proc)
+      metaclass = class << receiver; self; end
+      metaclass.send :define_method, method_name, &proc
+
+      yield
+    ensure
+      metaclass.send :remove_method, method_name
+    end
+  end
+end
 
 require 'sleeping_king_studios/tools/array_tools'
 require 'sleeping_king_studios/tools/hash_tools'

data/lib/sleeping_king_studios/tools/string_tools.rb

@@ -1,14 +1,35 @@
-# lib/sleeping_king_studios/tools/string_tools.rb
+# frozen_string_literal: true
 
 require 'sleeping_king_studios/tools'
-require 'sleeping_king_studios/tools/object_tools'
+require 'sleeping_king_studios/tools/toolbox/inflector'
 
 module SleepingKingStudios::Tools
   # Tools for working with strings.
-  module StringTools
-    extend self
-
-    autoload :PluralInflector, 'sleeping_king_studios/tools/string_tools/plural_inflector'
+  class StringTools < SleepingKingStudios::Tools::Base
+    class << self
+      def_delegators :instance,
+        :camelize,
+        :chain,
+        :define_irregular_word,
+        :define_plural_rule,
+        :define_singular_rule,
+        :define_uncountable_word,
+        :indent,
+        :map_lines,
+        :plural?,
+        :pluralize,
+        :singular?,
+        :singularize,
+        :string?,
+        :underscore
+    end
+
+    def initialize(inflector: nil)
+      @inflector =
+        inflector || SleepingKingStudios::Tools::Toolbox::Inflector.new
+    end
+
+    attr_reader :inflector
 
     # Converts a lowercase, underscore-separated string to CamelCase.
     #
@@ -17,13 +38,11 @@ module SleepingKingStudios::Tools
     # @return [String] The converted string.
     #
     # @see ActiveSupport::Inflector#camelize.
-    def camelize str
+    def camelize(str)
       str = require_string! str
 
-      str = str.dup
-      str.gsub!(/(\b|[_-])([a-z])/) { |match| $2.upcase }
-      str
-    end # method camelize
+      inflector.camelize(str)
+    end
 
     # Performs multiple string tools operations in sequence, starting with the
     # given string and passing the result of each operation to the next.
@@ -32,31 +51,39 @@ module SleepingKingStudios::Tools
     # @param commands [Array<String, Symbol>] The string operations to apply.
     #
     # @return [String] The processed string.
-    def chain str, *commands
+    def chain(str, *commands)
       str = require_string! str
 
       commands.reduce(str) { |memo, command| send(command, memo) }
-    end # method chain
+    end
 
     # (see PluralInflector#define_irregular_word)
-    def define_irregular_word singular, plural
-      plural_inflector.define_irregular_word singular, plural
-    end # method define_irregular_word
+    def define_irregular_word(singular, plural)
+      CoreTools.deprecate 'StringTools#define_irregular_word'
+
+      inflector.rules.define_irregular_word singular, plural
+    end
 
     # (see PluralInflector#define_plural_rule)
-    def define_plural_rule match, replace
-      plural_inflector.define_plural_rule match, replace
-    end # method define_plural_rule
+    def define_plural_rule(match, replace)
+      CoreTools.deprecate 'StringTools#define_plural_rule'
+
+      inflector.rules.define_plural_rule match, replace
+    end
 
     # (see PluralInflector#define_singular_rule)
-    def define_singular_rule match, replace
-      plural_inflector.define_singular_rule match, replace
-    end # method define_singular_rule
+    def define_singular_rule(match, replace)
+      CoreTools.deprecate 'StringTools#define_singular_rule'
+
+      inflector.rules.define_singular_rule match, replace
+    end
 
     # (see PluralInflector#define_uncountable_word)
-    def define_uncountable_word word
-      plural_inflector.define_uncountable_word word
-    end # method define_uncountable_word
+    def define_uncountable_word(word)
+      CoreTools.deprecate 'StringTools#define_uncountable_word'
+
+      inflector.rules.define_uncountable_word word
+    end
 
     # Adds the specified number of spaces to the start of each line of the
     # string. Defaults to 2 spaces.
@@ -65,12 +92,12 @@ module SleepingKingStudios::Tools
     # @param count [Integer] The number of spaces to add.
     #
     # @return [String] The indented string.
-    def indent str, count = 2
+    def indent(str, count = 2)
       str = require_string! str
-      pre = " " * count
+      pre = ' ' * count
 
       map_lines(str) { |line| "#{pre}#{line}" }
-    end # method indent
+    end
 
     # Yields each line of the string to the provided block and combines the
     # results into a new multiline string.
@@ -81,23 +108,23 @@ module SleepingKingStudios::Tools
     # @yieldparam index [Integer] The index of the current line.
     #
     # @return [String] The mapped string.
-    def map_lines str
+    def map_lines(str)
       str = require_string! str
 
-      str.each_line.with_index.reduce('') do |memo, (line, index)|
+      str.each_line.with_index.reduce(+'') do |memo, (line, index)|
         memo << yield(line, index)
-      end # each_line
-    end # method map_lines
+      end
+    end
 
     # Determines whether or not the given word is in plural form. If calling
     # #pluralize(word) is equal to word, the word is considered plural.
     #
     # @return [Boolean] True if the word is in plural form, otherwise false.
-    def plural? word
+    def plural?(word)
       word = require_string!(word)
 
       word == pluralize(word)
-    end # method plural?
+    end
 
     # @overload pluralize(str)
     #   Takes a word in singular form and returns the plural form, based on the
@@ -125,44 +152,44 @@ module SleepingKingStudios::Tools
     #
     #   @return [String] The single form if count == 1; otherwise the plural
     #     form.
-    def pluralize *args
+    def pluralize(*args)
       if args.count == 3
         CoreTools.deprecate 'StringTools#pluralize with 3 arguments',
-          :message => 'Use IntegerTools#pluralize instead.'
+          message: 'Use IntegerTools#pluralize instead.'
 
         return IntegerTools.pluralize(*args)
-      end # if
+      end
 
       str = require_string! args.first
 
-      plural_inflector.pluralize str
-    end # method pluralize
+      inflector.pluralize str
+    end
 
     # Determines whether or not the given word is in singular form. If calling
     # #singularize(word) is equal to word, the word is considered singular.
     #
     # @return [Boolean] True if the word is in singular form, otherwise false.
-    def singular? word
+    def singular?(word)
       word = require_string!(word)
 
       word == singularize(word)
-    end # method singular?
+    end
 
     # (see PluralInflector#singularize)
-    def singularize str
+    def singularize(str)
       require_string! str
 
-      plural_inflector.singularize str
-    end # method singularize
+      inflector.singularize str
+    end
 
     # Returns true if the object is a String.
     #
     # @param str [Object] The object to test.
     #
     # @return [Boolean] True if the object is a String, otherwise false.
-    def string? str
-      String === str
-    end # method string?
+    def string?(str)
+      str.is_a?(String)
+    end
 
     # Converts a mixed-case string expression to a lowercase, underscore
     # separated string.
@@ -172,29 +199,20 @@ module SleepingKingStudios::Tools
     # @return [String] The converted string.
     #
     # @see ActiveSupport::Inflector#underscore.
-    def underscore str
+    def underscore(str)
       str = require_string! str
 
-      str = str.dup
-      str.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
-      str.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
-      str.tr!("-", "_")
-      str.downcase!
-      str
-    end # method underscore
+      inflector.underscore(str)
+    end
 
     private
 
-    def plural_inflector
-      @plural_inflector ||= PluralInflector.new
-    end # method plural_inflector
-
-    def require_string! value
+    def require_string!(value)
       return value if string?(value)
 
       return value.to_s if value.is_a?(Symbol)
 
       raise ArgumentError, 'argument must be a string', caller[1..-1]
-    end # method require_array
-  end # module
-end # module
+    end
+  end
+end