sleeping_king_studios-tools 0.5.0 → 0.6.0.rc.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3227b681ac258bbee96c30202fa75f3100b9de31
-  data.tar.gz: b89aca8c0dab167cc523f25b6f1ef533a84c4f62
+  metadata.gz: 7643481360065ffb89a2bd3e439caf8a6483edea
+  data.tar.gz: 3c956ccdcd390d4c3e3368210b6e7759f98bff96
 SHA512:
-  metadata.gz: 1aa82e451bd91b63a253d8b5e54eed13c614f5ac87587b88a8ca09f21bf27645eb4ef8fa90be5dcc32267c0445adaf8417a95c3e82c4ef1f072f046cf165e215
-  data.tar.gz: 91ac849f14d1573bc6fa2eb616aa84a0a0ddcd8cf723516d482814c8d81e6820045a763fa8eba500cf8ef2dd17f13c24364fa69be28ac16e8985032e8c21b1aa
+  metadata.gz: 3e7fb8a49db7792f425f0b411a5fdbfc10436b4b3365a28d06bf119a5e76a673bc4f138454196a9ddf35a1826e4cddc34d46ddf933f2fa8812c2ad336bea3d73
+  data.tar.gz: 4a6ba7debe9880d7f6502eb8eea33dd60aa6dff3c942ad9df8423b4fc371bdb5a269d16f2d515afd0b97ab628d99fecd5d21bbd954391b6031d66bd06167e0b8

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## Current Release
 
+### 0.6.0
+
+- Implement HashTools#convert_keys_to_strings and #convert_keys_to_symbols.
+- Implement ObjectTools#dig.
+- Implement StringTools#singular? and #plural?.
+- Implement Toolbelt::instance, #inspect, #to_s.
+- Implement Toolbox::ConstantMap.
+- Implement Toolbox::Mixin.
+- Add support for Ruby 2.4.0.
+
 ### 0.5.0
 
 - Implement CoreTools#require_each.

data/DEVELOPMENT.md

@@ -1,17 +1,31 @@
 # Development Notes
 
+## 0.7.0
+
+- StringTools - support symbolic arguments
+- StringTools#chain |
+
+  tools.chain(str, :underscore, :pluralize)
+  #=> shorthand for tools.pluralize(tools.underscore str)
+
+- IntegerTools#pluralize - have third (plural string) parameter be optional and defer to StringTools#pluralize.
+
 ## Future Tasks
 
 - Remove 'extend self' from Tools modules.
 
 ### Features
 
-#### Tools
+- HashTools::slice, ::bisect_keys
+- ObjectTools::apply_with_arity
+- ObjectTools::method_arity
+- StringTools#map_lines |
 
-- StringTools#chain |
+  tools.map_lines("10\n20 GOTO 10") { |str| "  #{str}" }
+  #=> "  10\n  20 GOTO 10"
+- Delegator#delegate, :prefix => prefix_name
 
-  tools.chain(str, :underscore, :pluralize)
-  #=> shorthand for tools.pluralize(tools.underscore str)
+#### Tools
 
 - ObjectTools#pretty - returns user-friendly string representation. :multiline option? Delegates to specific toolset implementations.
 - RegexpTools#matching_string - generates a string that matches the regular expression. Does not support advanced Regexp features.
@@ -22,22 +36,6 @@
 #### Toolkit
 
 - Configuration
-- ConstantEnumerator |
-
-  class MyClass
-    ROLES = ConstantEnumerator.new do
-      USER  = 'user'
-      ADMIN = 'admin'
-    end
-
-    MyClass::ROLES::USER # 'user'
-    MyClass::ROLES.admin # 'admin'
-    MyClass::ROLES.all { 'USER' => 'user', 'ADMIN' => 'admin' }
-  end
-- ImmutableConstantEnumerator
-  - Values cannot be added or removed after initial block
-  - Freezes individual values
-  - Equivalent to ConstantEnumerator.new do ... end.immutable!
 
 ### Maintenance
 

data/README.md

@@ -18,7 +18,7 @@ The tools can be accessed in a convenient form using the Toolbelt class.
 
     require 'sleeping_king_studios/tools/toolbelt'
 
-    tools = ::SleepingKingStudios::Tools::Toolbelt.new
+    tools = ::SleepingKingStudios::Tools::Toolbelt.instance
 
     tools.array.humanize_list 'one', 'two', 'three'
     #=> calls ArrayTools#humanize_list
@@ -201,6 +201,38 @@ Takes a file pattern or a list of file names and requires each file.
 
 Tools for working with array-like enumerable objects.
 
+#### `#convert_keys_to_strings`
+
+Creates a copy of the hash with the keys converted to strings, including keys of nested hashes and hashes inside nested arrays.
+
+    hsh = { :one => 1, :two => 2, :three => 3 }
+    cpy = HashTools.convert_keys_to_strings(hsh)
+    #=> { 'one' => 1, 'two' => 2, 'three' => 3 }
+    hsh
+    #=> { :one => 1, :two => 2, :three => 3 }
+
+    hsh = { :odd => { :one => 1, :three => 3 }, :even => { :two => 2, :four => 4 } }
+    cpy = HashTools.convert_keys_to_strings(hsh)
+    #=> { 'odd' => { 'one' => 1, 'three' => 3 }, 'even' => { 'two' => 2, 'four' => 4 } }
+    hsh
+    #=> { :odd => { :one => 1, :three => 3 }, :even => { :two => 2, :four => 4 } }
+
+#### `#convert_keys_to_symbols`
+
+Creates a copy of the hash with the keys converted to symbols, including keys of nested hashes and hashes inside nested arrays.
+
+    hsh = { 'one' => 1, 'two' => 2, 'three' => 3 }
+    cpy = HashTools.convert_keys_to_strings(hsh)
+    #=> { :one => 1, :two => 2, :three => 3 }
+    hsh
+    #=> { 'one' => 1, 'two' => 2, 'three' => 3 }
+
+    hsh = { 'odd' => { 'one' => 1, 'three' => 3 }, 'even' => { 'two' => 2, 'four' => 4 } }
+    cpy = HashTools.convert_keys_to_strings(hsh)
+    #=> { :odd => { :one => 1, :three => 3 }, :even => { :two => 2, :four => 4 } }
+    hsh
+    #=> { 'odd' => { 'one' => 1, 'three' => 3 }, 'even' => { 'two' => 2, 'four' => 4 } }
+
 #### `#deep_dup`
 
 Creates a deep copy of the object by returning a new Hash with deep copies of each key and value. See also ObjectTools#deep_dup[#label-Object+Tools].
@@ -258,9 +290,17 @@ Returns true if the hash is immutable, i.e. if the hash is frozen and each hash
 
 Returns true if the hash is mutable (see `#immutable?`, above).
 
+#### `#stringify_keys`
+
+See HashTools#convert_keys_to_strings[#label-Hash+Tools]
+
+#### `#symbolize_keys`
+
+See HashTools#convert_keys_to_symbols[#label-Hash+Tools]
+
 ### Integer Tools
 
-Tools for working with integers and fixnums.
+Tools for working with integers.
 
 #### `#count_digits`
 
@@ -315,7 +355,7 @@ Returns true if the object is an Integer.
 
 Returns the singular or the plural value, depending on the provided item count.
 
-    StringTools.pluralize 4, 'light', 'lights'
+    IntegerTools.pluralize 4, 'light', 'lights'
     #=> 'lights'
 
 #### `#romanize`
@@ -409,6 +449,13 @@ Performs a deep freeze of the object. If the object is an Array, freezes the arr
     data[:songs][0].name.frozen?
     #=> true
 
+#### `#dig`
+
+Accesses deeply nested attributes by calling the first named method on the given object, and each subsequent method on the result of the previous method call. If the object does not respond to the method name, nil is returned instead of calling the method.
+
+    ObjectTools.dig my_object, :first_method, :second_method, :third_method
+    #=> my_object.first_method.second_method.third_method
+
 #### `#eigenclass`, `#metaclass`
 
 Returns the object's eigenclass.
@@ -485,6 +532,16 @@ Converts a lowercase, underscore separated string to a mixed-case string express
     StringTools#camelize 'muspelheimr_and_niflheimr'
     #=> 'MuspelheimrAndNiflheimr'
 
+#### `#plural?`
+
+Returns true if the word is in plural form, and returns false otherwise. A word is in plural form if and only if calling `#pluralize` (see below) on the word returns the word without modification.
+
+    StringTools.plural? 'light'
+    #=> false
+
+    StringTools.plural? 'lights'
+    #=> true
+
 #### `#pluralize`
 
 Takes a word in singular form and returns the plural form, based on the defined rules and known irregular/uncountable words.
@@ -513,6 +570,16 @@ Additional rules can be defined using the following methods:
     StringTools.pluralize 'series'
     # => 'series'
 
+#### `#singular?`
+
+Returns true if the word is in singular form, and returns false otherwise. A word is in singular form if and only if calling `#singularize` (see below) on the word returns the word without modification.
+
+    StringTools.singular? 'light'
+    #=> true
+
+    StringTools.singular? 'lights'
+    #=> false
+
 #### `#singularize`
 
 Takes a word in plural form and returns the singular form, based on the defined rules and known irregular/uncountable words.
@@ -553,34 +620,53 @@ Converts a mixed-case string expression to a lowercase, underscore separated str
 
 Common objects or patterns that are useful across projects but are larger than or do not fit the functional paradigm of the tools.* pattern.
 
-### Delegator
+### ConstantMap
+
+    require 'sleeping_king_studios/tools/toolbox/constant_map'
+
+Provides an enumerable interface for defining a group of constants.
+
+    UserRoles = ConstantMap.new(
+      :GUEST => 'guest',
+      :USER  => 'user',
+      :ADMIN => 'admin'
+    ) # end constants
 
-    require 'sleeping_king_studios/tools/delegator'
+    UserRoles::GUEST
+    #=> 'guest'
+
+    UserRoles.user
+    #=> 'user'
+
+    UserRoles.all
+    #=> { :GUEST => 'guest', :USER => 'user', :ADMIN => 'admin' }
+
+### Delegator
 
     require 'sleeping_king_studios/tools/toolbox/delegator'
 
+Module for extending classes with basic delegation.
+
     class MyClass
-      extend SleepingKingStudios::Tools::Delegator
+      extend SleepingKingStudios::Tools::Toolbox::Delegator
 
       delegate :my_method, :to => MyService
     end # class
 
-Module for extending classes with basic delegation.
-
 #### `::delegate`
 
 Defines a wrapper method to delegate implementation of the specified method or methods to an object, to the object at another specified method, or to the object at a specified instance variable.
 
     # Delegate to an object
     class MyModule
-      extend SleepingKingStudios::Tools::Delegator
+      extend SleepingKingStudios::Tools::Toolbox::Delegator
 
       delegate :my_method, :to => MyService
     end class
 
     # Delegate to a method
     class MyModule
-      extend SleepingKingStudios::Tools::Delegator
+      extend SleepingKingStudios::Tools::Toolbox::Delegator
 
       def my_service
         MyService.new
@@ -591,7 +677,7 @@ Defines a wrapper method to delegate implementation of the specified method or m
 
     # Delegate to an instance variable
     class MyModule
-      extend SleepingKingStudios::Tools::Delegator
+      extend SleepingKingStudios::Tools::Toolbox::Delegator
 
       def initialize
         @my_service = MyService.new
@@ -604,14 +690,13 @@ Expects one or more method names and a delegation target, which can be an object
 
 #### `::wrap_delegate`
 
-Wraps a delegate object by automatically delegating each method that is defined on the delegate class from the instance to the delegate. The
-delegate can be specified with an object literal or with the name of an instance method or instance variable.
+Wraps a delegate object by automatically delegating each method that is defined on the delegate class from the instance to the delegate. The delegate can be specified with an object literal or with the name of an instance method or instance variable.
 
 Only methods that are defined at the time #wrap_delegate is called will be delegated, so make sure to call #wrap_delegate after loading any gems or libraries that extend your delegate class, such as ActiveSupport.
 
     # Create a class that wraps a Hash
     class Errors
-      extend SleepingKingStudios::Tools::Delegator
+      extend SleepingKingStudios::Tools::Toolbox::Delegator
 
       wrap_delegate Hash.new { |hsh, key| hsh[key] = Errors.new }, :klass => Hash
 
@@ -625,6 +710,52 @@ Only methods that are defined at the time #wrap_delegate is called will be deleg
 
 Expects a delegation target and optionally a class or module (to determine which methods to delegate), as well as optional :except and :only arrays to limit which methods are delegated. The delegation target can be an object literal, or the name of an method or instance variable as a String or Symbol (in which case a class or module must be specified in :klass or an ArgumentError will be raised).
 
+### Mixin
+
+    require 'sleeping_king_studios/tools/toolbox/mixin'
+
+Implements module-based inheritance for both instance- and class-level methods, similar to the (in)famous ActiveSupport::Concern. When a Mixin is included into a class, the class will be extended with any methods defined in the special ClassMethods module, even if the Mixin is being included indirectly via one or more intermediary Mixins.
+
+    Widget = Struct.new(:widget_type)
+
+    module Widgets
+      extend SleepingKingStudios::Tools::Toolbox::Mixin
+
+      module ClassMethods
+        def widget_types
+          %w(gadget doohickey thingamabob)
+        end # class method widget_types
+      end # module
+
+      def widget? widget_type
+        self.class.widget_types.include?(widget_type)
+      end # method widget?
+    end # module
+
+    module WidgetBuilding
+      extend SleepingKingStudios::Tools::Toolbox::Mixin
+
+      include Widgets
+
+      def build_widget widget_type
+        raise ArgumentError, 'not a widget', caller unless widget?(widget_type)
+
+        Widget.new(widget_type)
+      end # method build_widget
+    end # module
+
+    class WidgetFactory
+      include WidgetBuilding
+    end # class
+
+    factory = WidgetFactory.new
+
+    factory.build_widget('gadget')
+    #=> Widget
+
+    WidgetFactory.widget_types
+    #=> ['gadget', 'doohickey', 'thingamabob']
+
 ### Semantic Version
 
     require 'sleeping_king_studios/tools/toolbox/semantic_version'

data/lib/sleeping_king_studios/tools/core_tools.rb

@@ -34,6 +34,8 @@ module SleepingKingStudios::Tools
     end # method deprecate
 
     # Expands each file pattern and requires each file.
+    #
+    # @param file_patterns [Array] The files to require.
     def require_each *file_patterns
       file_patterns.each do |file_pattern|
         if file_pattern.include?('*')

data/lib/sleeping_king_studios/tools/hash_tools.rb

@@ -1,6 +1,7 @@
 # lib/sleeping_king_studios/tools/hash_tools.rb
 
 require 'sleeping_king_studios/tools'
+require 'sleeping_king_studios/tools/array_tools'
 require 'sleeping_king_studios/tools/object_tools'
 
 module SleepingKingStudios::Tools
@@ -10,6 +11,38 @@ module SleepingKingStudios::Tools
 
     HASH_METHODS = [:[], :count, :each, :each_key, :each_pair].freeze
 
+    # Returns a copy of the hash with the keys converted to strings.
+    #
+    # @param [Hash] hsh The hash to convert.
+    #
+    # @return [Hash] The converted copy of the hash.
+    def convert_keys_to_strings hsh
+      require_hash! hsh
+
+      hsh.each.with_object({}) do |(key, value), cpy|
+        sym = key.to_s
+
+        cpy[sym] = convert_value_to_stringified_hash(value)
+      end # each
+    end # method convert_keys_to_strings
+    alias_method :stringify_keys, :convert_keys_to_strings
+
+    # Returns a copy of the hash with the keys converted to symbols.
+    #
+    # @param [Hash] hsh The hash to convert.
+    #
+    # @return [Hash] The converted copy of the hash.
+    def convert_keys_to_symbols hsh
+      require_hash! hsh
+
+      hsh.each.with_object({}) do |(key, value), cpy|
+        sym = key.to_s.intern
+
+        cpy[sym] = convert_value_to_symbolic_hash(value)
+      end # each
+    end # method convert_keys_to_symbols
+    alias_method :symbolize_keys, :convert_keys_to_symbols
+
     # Creates a deep copy of the object by returning a new Hash with deep
     # copies of each key and value.
     #
@@ -17,6 +50,8 @@ module SleepingKingStudios::Tools
     #
     # @return [Hash] The copy of the hash.
     def deep_dup hsh
+      require_hash! hsh
+
       hsh.each.with_object(Hash.new) do |(key, value), copy|
         copy[ObjectTools.deep_dup key] = ObjectTools.deep_dup(value)
       end # each
@@ -27,6 +62,8 @@ module SleepingKingStudios::Tools
     #
     # @param [Hash] hsh The object to freeze.
     def deep_freeze hsh
+      require_hash! hsh
+
       hsh.freeze
 
       hsh.each do |key, value|
@@ -57,6 +94,8 @@ module SleepingKingStudios::Tools
     #
     # @return [Boolean] True if the hash is immutable, otherwise false.
     def immutable? hsh
+      require_hash! hsh
+
       return false unless hsh.frozen?
 
       hsh.each do |key, value|
@@ -76,5 +115,33 @@ module SleepingKingStudios::Tools
     def mutable? hsh
       !immutable?(hsh)
     end # method mutable?
+
+    private
+
+    def convert_value_to_stringified_hash value
+      if hash?(value)
+        convert_keys_to_strings(value)
+      elsif ArrayTools.array?(value)
+        value.map { |item| convert_value_to_stringified_hash(item) }
+      else
+        value
+      end # if-else
+    end # method convert_value_to_stringified_hash
+
+    def convert_value_to_symbolic_hash value
+      if hash?(value)
+        convert_keys_to_symbols(value)
+      elsif ArrayTools.array?(value)
+        value.map { |item| convert_value_to_symbolic_hash(item) }
+      else
+        value
+      end # if-else
+    end # method convert_value_to_symbolic_hash
+
+    def require_hash! value
+      return if hash?(value)
+
+      raise ArgumentError, 'argument must be a hash', caller[1..-1]
+    end # method require_array
   end # module
 end # module

data/lib/sleeping_king_studios/tools/integer_tools.rb

@@ -3,7 +3,7 @@
 require 'sleeping_king_studios/tools'
 
 module SleepingKingStudios::Tools
-  # Tools for working with integers and fixnums.
+  # Tools for working with integers.
   module IntegerTools
     extend self
 

data/lib/sleeping_king_studios/tools/object_tools.rb

@@ -20,14 +20,8 @@ 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, **kwargs, &block
-      unless block_given?
-        if kwargs.empty?
-          return base.instance_exec *args, &proc
-        else
-          return base.instance_exec *args, **kwargs, &proc
-        end # if-else
-      end # unless
+    def apply base, proc, *args, &block
+      return base.instance_exec *args, &proc unless block_given?
 
       temporary_method_name = :__sleeping_king_studios_tools_object_tools_temporary_method_for_applying_proc__
 
@@ -35,11 +29,7 @@ module SleepingKingStudios::Tools
       metaclass.send :define_method, temporary_method_name, &proc
 
       begin
-        if kwargs.empty?
-          base.send temporary_method_name, *args, &block
-        else
-          base.send temporary_method_name, *args, **kwargs, &block
-        end # if-else
+        base.send temporary_method_name, *args, &block
       ensure
         metaclass.send :remove_method, temporary_method_name if temporary_method_name && defined?(temporary_method_name)
       end
@@ -55,7 +45,7 @@ module SleepingKingStudios::Tools
     # @return The copy of the object.
     def deep_dup obj
       case obj
-      when FalseClass, Fixnum, Float, NilClass, Symbol, TrueClass
+      when FalseClass, Integer, Float, NilClass, Symbol, TrueClass
         obj
       when ->(_) { ArrayTools.array?(obj) }
         ArrayTools.deep_dup obj
@@ -74,7 +64,7 @@ module SleepingKingStudios::Tools
     # @param [Object] obj The object to freeze.
     def deep_freeze obj
       case obj
-      when FalseClass, Fixnum, Float, NilClass, Symbol, TrueClass
+      when FalseClass, Integer, Float, NilClass, Symbol, TrueClass
         # Object is inherently immutable; do nothing here.
       when ->(_) { ArrayTools.array?(obj) }
         ArrayTools.deep_freeze(obj)
@@ -85,6 +75,22 @@ module SleepingKingStudios::Tools
       end # case
     end # method deep_freeze
 
+    # Accesses deeply nested attributes by calling the first named method on the
+    # given object, and each subsequent method on the result of the previous
+    # method call. If the object does not respond to the method name, nil is
+    # returned instead of calling the method.
+    #
+    # @param [Object] obj The object to dig.
+    # @param [Array] method_names The names of the methods to call.
+    #
+    # @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
+      method_names.reduce(object) do |memo, method_name|
+        memo.respond_to?(method_name) ? memo.send(method_name) : nil
+      end # reduce
+    end # method object
+
     # Returns the object's eigenclass.
     #
     # @param [Object] object The object for which an eigenclass is required.

data/lib/sleeping_king_studios/tools/string_tools.rb

@@ -45,6 +45,14 @@ module SleepingKingStudios::Tools
       plural_inflector.define_uncountable_word word
     end # method define_uncountable_word
 
+    # 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
+      word == pluralize(word)
+    end # method plural?
+
     # @overload pluralize(str)
     #   Takes a word in singular form and returns the plural form, based on the
     #   defined rules and known irregular/uncountable words.
@@ -84,6 +92,14 @@ module SleepingKingStudios::Tools
       plural_inflector.pluralize args.first
     end # method pluralize
 
+    # 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
+      word == singularize(word)
+    end # method singular?
+
     # (see PluralInflector#singularize)
     def singularize str
       require_string! str

data/lib/sleeping_king_studios/tools/toolbelt.rb

@@ -5,6 +5,10 @@ require 'sleeping_king_studios/tools/all'
 module SleepingKingStudios::Tools
   # Helper object for quick access to all available tools.
   class Toolbelt < BasicObject
+    def self.instance
+      @instance ||= new
+    end # class method instance
+
     namespace = ::SleepingKingStudios::Tools
 
     %w(array core hash integer object string).each do |name|
@@ -16,5 +20,15 @@ module SleepingKingStudios::Tools
         end # begin-rescue
       end # each
     end # each
+
+    def inspect
+      @to_s ||=
+        begin
+          object_class = class << self; self; end.superclass
+
+          "#<#{object_class.name}>"
+        end # string
+    end # method inspect
+    alias_method :to_s, :inspect
   end # module
 end # module

data/lib/sleeping_king_studios/tools/toolbox/constant_map.rb

@@ -0,0 +1,94 @@
+# lib/sleeping_king_studios/tools/toolbox/constant_map.rb
+
+require 'sleeping_king_studios/tools/string_tools'
+require 'sleeping_king_studios/tools/toolbox'
+
+module SleepingKingStudios::Tools::Toolbox
+  # Provides an enumerable interface for defining a group of constants.
+  module ConstantMap
+    class << self
+      # Creates a new ConstantMap.
+      #
+      # @param constants [Hash] The constants to define.
+      def new constants
+        mod = Module.new
+        mod.extend self
+
+        constants.each do |const_name, const_value|
+          mod.const_set const_name, const_value
+        end # each
+
+        mod
+      end # class method new
+    end # eigenclass
+
+    # Returns a hash with the names and values of the defined constants.
+    #
+    # @return [Hash] The defined constants.
+    def all
+      constants.each.with_object({}) do |const_name, hsh|
+        hsh[const_name] = const_get(const_name)
+      end # each
+    end # method all
+
+    # Iterates through the defined constants, yielding the name and value of
+    # each constant to the block.
+    #
+    # @yieldparam key [Symbol] The name of the symbol.
+    # @yieldparam value [Object] The value of the symbol.
+    def each &block
+      all.each(&block)
+    end # method each
+
+    # Freezes the constant map and recursively freezes every constant value
+    # using ObjectTools#deep_freeze. Also pre-emptively defines any reader
+    # methods that are not already undefined.
+    #
+    # @see ObjectTools#deep_freeze
+    def freeze
+      constants.each do |const_name|
+        reader_name = const_name.downcase
+
+        define_reader(const_name, reader_name) unless methods.include?(reader_name)
+
+        object_tools.deep_freeze const_get(const_name)
+      end # each
+
+      super
+    end # method freeze
+
+    private
+
+    def define_reader const_name, reader_name = nil
+      reader_name ||= const_name.downcase
+
+      define_singleton_method reader_name, ->() { const_get const_name }
+    end # method define_reader
+
+    def method_missing symbol, *args, &block
+      const_name = string_tools.underscore(symbol.to_s).upcase.intern
+
+      if constants.include?(const_name)
+        define_reader(const_name, symbol)
+
+        return send(symbol, *args, &block)
+      end # if
+
+      super
+    end # method method_missing
+
+    def object_tools
+      ::SleepingKingStudios::Tools::ObjectTools
+    end # method object_tools
+
+    def respond_to_missing? symbol, include_all = false
+      const_name = string_tools.underscore(symbol.to_s).upcase.intern
+
+      constants.include?(const_name) || super
+    end # method respond_to_missing?
+
+    def string_tools
+      ::SleepingKingStudios::Tools::StringTools
+    end # method string_tools
+  end # module
+end # module

data/lib/sleeping_king_studios/tools/toolbox/delegator.rb

@@ -19,14 +19,14 @@ module SleepingKingStudios::Tools::Toolbox
     #
     # @example Delegate to an object
     #   class MyModule
-    #     extend SleepingKingStudios::Tools::Delegator
+    #     extend SleepingKingStudios::Tools::Toolbox::Delegator
     #
     #     delegate :my_method, :to => MyService
     #   end # class
     #
     # @example Delegate to a method
     #   class MyModule
-    #     extend SleepingKingStudios::Tools::Delegator
+    #     extend SleepingKingStudios::Tools::Toolbox::Delegator
     #
     #     def my_service
     #       MyService.new
@@ -37,7 +37,7 @@ module SleepingKingStudios::Tools::Toolbox
     #
     # @example Delegate to an instance variable
     #   class MyModule
-    #     extend SleepingKingStudios::Tools::Delegator
+    #     extend SleepingKingStudios::Tools::Toolbox::Delegator
     #
     #     def initialize
     #       @my_service = MyService.new

data/lib/sleeping_king_studios/tools/toolbox/mixin.rb

@@ -0,0 +1,32 @@
+# lib/sleeping_king_studios/tools/toolbox/mixin.rb
+
+require 'sleeping_king_studios/tools/toolbox'
+
+module SleepingKingStudios::Tools::Toolbox
+  # Implements recursive inheritance of both class and instance methods.
+  module Mixin
+    # @api private
+    def self.mixin? mod
+      return false unless mod.is_a?(Module)
+
+      mod.singleton_class.include?(self)
+    end # class method mixin?
+
+    # @api private
+    def included other
+      return super unless defined?(self::ClassMethods)
+
+      if SleepingKingStudios::Tools::Toolbox::Mixin.mixin?(other)
+        unless other.constants(false).include?(:ClassMethods)
+          other.const_set(:ClassMethods, Module.new)
+        end # unless
+
+        other::ClassMethods.send :include, self::ClassMethods
+      else
+        other.extend self::ClassMethods
+      end # if-else
+
+      super
+    end # method included
+  end # module
+end # module

data/lib/sleeping_king_studios/tools/version.rb

@@ -13,10 +13,10 @@ module SleepingKingStudios
       private
 
       MAJOR      = 0
-      MINOR      = 5
+      MINOR      = 6
       PATCH      = 0
-      PRERELEASE = nil
-      BUILD      = nil
+      PRERELEASE = :rc
+      BUILD      = 0
     end # module
 
     VERSION = Version.to_gem_version

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sleeping_king_studios-tools
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0.rc.0
 platform: ruby
 authors:
 - Rob "Merlin" Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-12 00:00:00.000000000 Z
+date: 2017-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -104,7 +104,9 @@ files:
 - lib/sleeping_king_studios/tools/string_tools/plural_inflector.rb
 - lib/sleeping_king_studios/tools/toolbelt.rb
 - lib/sleeping_king_studios/tools/toolbox.rb
+- lib/sleeping_king_studios/tools/toolbox/constant_map.rb
 - lib/sleeping_king_studios/tools/toolbox/delegator.rb
+- lib/sleeping_king_studios/tools/toolbox/mixin.rb
 - lib/sleeping_king_studios/tools/toolbox/semantic_version.rb
 - lib/sleeping_king_studios/tools/version.rb
 homepage: http://sleepingkingstudios.com
@@ -122,12 +124,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: A library of utility services and concerns.