hashie 3.5.7 → 5.0.0

data/lib/hashie/mash.rb

@@ -2,6 +2,7 @@ require 'hashie/hash'
 require 'hashie/array'
 require 'hashie/utils'
 require 'hashie/logger'
+require 'hashie/extensions/key_conflict_warning'
 
 module Hashie
   # Mash allows you to create pseudo-objects that have method-like
@@ -15,9 +16,12 @@ module Hashie
   #
   # * No punctuation: Returns the value of the hash for that key, or nil if none exists.
   # * Assignment (<tt>=</tt>): Sets the attribute of the given method name.
-  # * Existence (<tt>?</tt>): Returns true or false depending on whether that key has been set.
-  # * Bang (<tt>!</tt>): Forces the existence of this key, used for deep Mashes. Think of it as "touch" for mashes.
-  # * Under Bang (<tt>_</tt>): Like Bang, but returns a new Mash rather than creating a key.  Used to test existance in deep Mashes.
+  # * Truthiness (<tt>?</tt>): Returns true or false depending on the truthiness of
+  #   the attribute, or false if the key is not set.
+  # * Bang (<tt>!</tt>): Forces the existence of this key, used for deep Mashes. Think of it
+  #   as "touch" for mashes.
+  # * Under Bang (<tt>_</tt>): Like Bang, but returns a new Mash rather than creating a key.
+  #   Used to test existance in deep Mashes.
   #
   # == Basic Example
   #
@@ -58,51 +62,20 @@ module Hashie
   #   mash.author # => <Mash>
   #
   class Mash < Hash
-    include Hashie::Extensions::PrettyInspect
     include Hashie::Extensions::RubyVersionCheck
+    extend Hashie::Extensions::KeyConflictWarning
 
-    ALLOWED_SUFFIXES = %w(? ! = _)
-
-    class CannotDisableMashWarnings < StandardError
-      def initialize(message = 'You cannot disable warnings on the base Mash class. Please subclass the Mash and disable it in the subclass.')
-        super(message)
-      end
-    end
-
-    # Disable the logging of warnings based on keys conflicting keys/methods
-    #
-    # @api semipublic
-    # @return [void]
-    def self.disable_warnings
-      fail CannotDisableMashWarnings if self == Hashie::Mash
-      @disable_warnings = true
-    end
-
-    # Checks whether this class disables warnings for conflicting keys/methods
-    #
-    # @api semipublic
-    # @return [Boolean]
-    def self.disable_warnings?
-      @disable_warnings ||= false
-    end
-
-    # Inheritance hook that sets class configuration when inherited.
-    #
-    # @api semipublic
-    # @return [void]
-    def self.inherited(subclass)
-      super
-      subclass.disable_warnings if disable_warnings?
-    end
+    ALLOWED_SUFFIXES = %w[? ! = _].freeze
 
     def self.load(path, options = {})
       @_mashes ||= new
 
       return @_mashes[path] if @_mashes.key?(path)
-      fail ArgumentError, "The following file doesn't exist: #{path}" unless File.file?(path)
+      raise ArgumentError, "The following file doesn't exist: #{path}" unless File.file?(path)
 
-      parser = options.fetch(:parser) {  Hashie::Extensions::Parsers::YamlErbParser }
-      @_mashes[path] = new(parser.perform(path)).freeze
+      options = options.dup
+      parser = options.delete(:parser) { Hashie::Extensions::Parsers::YamlErbParser }
+      @_mashes[path] = new(parser.perform(path, options)).freeze
     end
 
     def to_module(mash_method_name = :settings)
@@ -114,7 +87,11 @@ module Hashie
       end
     end
 
-    alias_method :to_s, :inspect
+    def with_accessors!
+      extend Hashie::Extensions::Mash::DefineAccessors
+    end
+
+    alias to_s inspect
 
     # If you pass in an existing hash, it will
     # convert it to a Mash including recursively
@@ -125,13 +102,26 @@ module Hashie
       default ? super(default) : super(&blk)
     end
 
-    class << self; alias_method :[], :new; end
+    # Creates a new anonymous subclass with key conflict
+    # warnings disabled. You may pass an array of method
+    # symbols to restrict the disabled warnings to.
+    # Hashie::Mash.quiet.new(hash) all warnings disabled.
+    # Hashie::Mash.quiet(:zip).new(hash) only zip warning
+    # is disabled.
+    def self.quiet(*method_keys)
+      @memoized_classes ||= {}
+      @memoized_classes[method_keys] ||= Class.new(self) do
+        disable_warnings(*method_keys)
+      end
+    end
+
+    class << self; alias [] new; end
 
-    alias_method :regular_reader, :[]
-    alias_method :regular_writer, :[]=
+    alias regular_reader []
+    alias regular_writer []=
 
-    # Retrieves an attribute set in the Mash. Will convert
-    # any key passed in to a string before retrieving.
+    # Retrieves an attribute set in the Mash. Will convert a key passed in
+    # as a symbol to a string before retrieving.
     def custom_reader(key)
       default_proc.call(self, key) if default_proc && !key?(key)
       value = regular_reader(convert_key(key))
@@ -139,18 +129,16 @@ module Hashie
       value
     end
 
-    # Sets an attribute in the Mash. Key will be converted to
-    # a string before it is set, and Hashes will be converted
-    # into Mashes for nesting purposes.
+    # Sets an attribute in the Mash. Symbol keys will be converted to
+    # strings before being set, and Hashes will be converted into Mashes
+    # for nesting purposes.
     def custom_writer(key, value, convert = true) #:nodoc:
-      key_as_symbol = (key = convert_key(key)).to_sym
-
-      log_built_in_message(key_as_symbol) if log_collision?(key_as_symbol)
-      regular_writer(key, convert ? convert_value(value) : value)
+      log_built_in_message(key) if key.respond_to?(:to_sym) && log_collision?(key.to_sym)
+      regular_writer(convert_key(key), convert ? convert_value(value) : value)
     end
 
-    alias_method :[], :custom_reader
-    alias_method :[]=, :custom_writer
+    alias [] custom_reader
+    alias []= custom_writer
 
     # This is the bang method reader, it will return a new Mash
     # if there isn't a value already assigned to the key requested.
@@ -183,45 +171,89 @@ module Hashie
       super(*keys.map { |key| convert_key(key) })
     end
 
-    alias_method :regular_dup, :dup
+    # Returns a new instance of the class it was called on, using its keys as
+    # values, and its values as keys. The new values and keys will always be
+    # strings.
+    def invert
+      self.class.new(super)
+    end
+
+    # Returns a new instance of the class it was called on, containing elements
+    # for which the given block returns false.
+    def reject(&blk)
+      self.class.new(super(&blk))
+    end
+
+    # Returns a new instance of the class it was called on, containing elements
+    # for which the given block returns true.
+    def select(&blk)
+      self.class.new(super(&blk))
+    end
+
+    alias regular_dup dup
     # Duplicates the current mash as a new mash.
     def dup
-      self.class.new(self, default)
+      self.class.new(self, default, &default_proc)
     end
 
-    alias_method :regular_key?, :key?
+    alias regular_key? key?
     def key?(key)
       super(convert_key(key))
     end
-    alias_method :has_key?, :key?
-    alias_method :include?, :key?
-    alias_method :member?, :key?
+    alias has_key? key?
+    alias include? key?
+    alias member? key?
+
+    if with_minimum_ruby?('2.6.0')
+      # Performs a deep_update on a duplicate of the
+      # current mash.
+      def deep_merge(*other_hashes, &blk)
+        dup.deep_update(*other_hashes, &blk)
+      end
 
-    # Performs a deep_update on a duplicate of the
-    # current mash.
-    def deep_merge(other_hash, &blk)
-      dup.deep_update(other_hash, &blk)
+      # Recursively merges this mash with the passed
+      # in hash, merging each hash in the hierarchy.
+      def deep_update(*other_hashes, &blk)
+        other_hashes.each do |other_hash|
+          _deep_update(other_hash, &blk)
+        end
+        self
+      end
+    else
+      # Performs a deep_update on a duplicate of the
+      # current mash.
+      def deep_merge(other_hash, &blk)
+        dup.deep_update(other_hash, &blk)
+      end
+
+      # Recursively merges this mash with the passed
+      # in hash, merging each hash in the hierarchy.
+      def deep_update(other_hash, &blk)
+        _deep_update(other_hash, &blk)
+        self
+      end
     end
-    alias_method :merge, :deep_merge
 
-    # Recursively merges this mash with the passed
-    # in hash, merging each hash in the hierarchy.
-    def deep_update(other_hash, &blk)
+    # Alias these lexically so they get the correctly defined
+    # #deep_merge and #deep_update based on ruby version.
+    alias merge deep_merge
+    alias deep_merge! deep_update
+    alias update deep_update
+    alias merge! update
+
+    def _deep_update(other_hash, &blk)
       other_hash.each_pair do |k, v|
         key = convert_key(k)
-        if regular_reader(key).is_a?(Mash) && v.is_a?(::Hash)
+        if v.is_a?(::Hash) && key?(key) && regular_reader(key).is_a?(Mash)
           custom_reader(key).deep_update(v, &blk)
         else
           value = convert_value(v, true)
-          value = convert_value(blk.call(key, self[k], value), true) if blk && self.key?(k)
+          value = convert_value(yield(key, self[k], value), true) if blk && key?(k)
           custom_writer(key, value, false)
         end
       end
-      self
     end
-    alias_method :deep_merge!, :deep_update
-    alias_method :update, :deep_update
-    alias_method :merge!, :update
+    private :_deep_update
 
     # Assigns a value to a key
     def assign_property(name, value)
@@ -263,7 +295,7 @@ module Hashie
       method_name.end_with?(*ALLOWED_SUFFIXES) && key?(method_name.chop)
     end
 
-    def method_missing(method_name, *args, &blk)
+    def method_missing(method_name, *args, &blk) # rubocop:disable Style/MethodMissing
       return self.[](method_name, &blk) if key?(method_name)
       name, suffix = method_name_and_suffix(method_name)
       case suffix
@@ -296,6 +328,36 @@ module Hashie
       end
     end
 
+    with_minimum_ruby('2.4.0') do
+      def transform_values(&blk)
+        self.class.new(super(&blk))
+      end
+
+      # Returns a new instance of the class it was called on, with nil values
+      # removed.
+      def compact
+        self.class.new(super)
+      end
+    end
+
+    with_minimum_ruby('2.5.0') do
+      def slice(*keys)
+        string_keys = keys.map { |key| convert_key(key) }
+        self.class.new(super(*string_keys))
+      end
+
+      def transform_keys(&blk)
+        self.class.new(super(&blk))
+      end
+    end
+
+    with_minimum_ruby('3.0.0') do
+      def except(*keys)
+        string_keys = keys.map { |key| convert_key(key) }
+        self.class.new(super(*string_keys))
+      end
+    end
+
     protected
 
     def method_name_and_suffix(method_name)
@@ -313,7 +375,7 @@ module Hashie
     end
 
     def convert_key(key) #:nodoc:
-      key.to_s
+      key.respond_to?(:to_sym) ? key.to_s : key
     end
 
     def convert_value(val, duping = false) #:nodoc:
@@ -325,8 +387,6 @@ module Hashie
       when ::Hash
         val = val.dup if duping
         self.class.new(val)
-      when Array
-        val.map { |e| convert_value(e) }
       when ::Array
         Array.new(val.map { |e| convert_value(e) })
       else
@@ -337,7 +397,7 @@ module Hashie
     private
 
     def log_built_in_message(method_key)
-      return if self.class.disable_warnings?
+      return if self.class.disable_warnings?(method_key)
 
       method_information = Hashie::Utils.method_information(method(method_key))
 
@@ -350,7 +410,13 @@ module Hashie
     end
 
     def log_collision?(method_key)
-      respond_to?(method_key) && !self.class.disable_warnings? &&
+      return unless method_key.is_a?(String) || method_key.is_a?(Symbol)
+      return unless respond_to?(method_key)
+
+      _, suffix = method_name_and_suffix(method_key)
+
+      (!suffix || suffix == '='.freeze) &&
+        !self.class.disable_warnings?(method_key) &&
         !(regular_key?(method_key) || regular_key?(method_key.to_s))
     end
   end

data/lib/hashie/railtie.rb

@@ -7,6 +7,13 @@ begin
       initializer 'hashie.configure_logger', after: 'initialize_logger' do
         Hashie.logger = Rails.logger
       end
+
+      initializer 'hashie.patch_hash_except', after: 'load_active_support' do
+        if Rails::VERSION::MAJOR >= 6
+          require 'hashie/extensions/active_support/core_ext/hash'
+          Hashie::Mash.send(:include, Hashie::Extensions::ActiveSupport::CoreExt::Hash)
+        end
+      end
     end
   end
 rescue LoadError => e

data/lib/hashie/rash.rb

@@ -64,7 +64,7 @@ module Hashie
     # Raise (or yield) unless something matches the key.
     #
     def fetch(*args)
-      fail ArgumentError, "Expected 1-2 arguments, got #{args.length}" \
+      raise ArgumentError, "Expected 1-2 arguments, got #{args.length}" \
         unless (1..2).cover?(args.length)
 
       key, default = args
@@ -78,7 +78,7 @@ module Hashie
       elsif default
         default
       else
-        fail KeyError, "key not found: #{key.inspect}"
+        raise KeyError, "key not found: #{key.inspect}"
       end
     end
 
@@ -117,7 +117,7 @@ module Hashie
         end
 
       when Regexp
-        # Reverse operation: `rash[/regexp/]` returns all the hash's string keys which match the regexp
+        # Reverse operation: `rash[/regexp/]` returns all string keys matching the regexp
         @hash.each do |key, val|
           yield val if key.is_a?(String) && query =~ key
         end
@@ -125,11 +125,11 @@ module Hashie
     end
 
     def method_missing(*args, &block)
-      @hash.send(*args, &block)
+      @hash.send(*args, &block) || super
     end
 
-    def respond_to_missing?(*args)
-      @hash.respond_to?(*args)
+    def respond_to_missing?(method_name, _include_private = false)
+      @hash.respond_to?(method_name)
     end
 
     private

data/lib/hashie/utils.rb

@@ -12,5 +12,33 @@ module Hashie
         "defined in #{bound_method.owner}"
       end
     end
+
+    # Duplicates a value or returns the value when it is not duplicable
+    #
+    # @api public
+    #
+    # @param value [Object] the value to safely duplicate
+    # @return [Object] the duplicated value
+    def self.safe_dup(value)
+      case value
+      when Complex, FalseClass, NilClass, Rational, Method, Symbol, TrueClass, *integer_classes
+        value
+      else
+        value.dup
+      end
+    end
+
+    # Lists the classes Ruby uses for integers
+    #
+    # @api private
+    # @return [Array<Class>]
+    def self.integer_classes
+      @integer_classes ||=
+        if 0.class == Integer
+          [Integer]
+        else
+          [Fixnum, Bignum] # rubocop:disable Lint/UnifiedInteger
+        end
+    end
   end
 end

data/lib/hashie/version.rb

@@ -1,3 +1,3 @@
 module Hashie
-  VERSION = '3.5.7'
+  VERSION = '5.0.0'.freeze
 end

data/lib/hashie.rb

@@ -12,26 +12,26 @@ module Hashie
   autoload :Utils,              'hashie/utils'
 
   module Extensions
-    autoload :Coercion,          'hashie/extensions/coercion'
-    autoload :DeepMerge,         'hashie/extensions/deep_merge'
-    autoload :IgnoreUndeclared,  'hashie/extensions/ignore_undeclared'
-    autoload :IndifferentAccess, 'hashie/extensions/indifferent_access'
-    autoload :MergeInitializer,  'hashie/extensions/merge_initializer'
-    autoload :MethodAccess,      'hashie/extensions/method_access'
-    autoload :MethodQuery,       'hashie/extensions/method_access'
-    autoload :MethodReader,      'hashie/extensions/method_access'
-    autoload :MethodWriter,      'hashie/extensions/method_access'
-    autoload :StringifyKeys,     'hashie/extensions/stringify_keys'
-    autoload :SymbolizeKeys,     'hashie/extensions/symbolize_keys'
-    autoload :DeepFetch,         'hashie/extensions/deep_fetch'
-    autoload :DeepFind,          'hashie/extensions/deep_find'
-    autoload :DeepLocate,        'hashie/extensions/deep_locate'
-    autoload :PrettyInspect,     'hashie/extensions/pretty_inspect'
-    autoload :KeyConversion,     'hashie/extensions/key_conversion'
+    autoload :Coercion,           'hashie/extensions/coercion'
+    autoload :DeepMerge,          'hashie/extensions/deep_merge'
+    autoload :IgnoreUndeclared,   'hashie/extensions/ignore_undeclared'
+    autoload :IndifferentAccess,  'hashie/extensions/indifferent_access'
+    autoload :MergeInitializer,   'hashie/extensions/merge_initializer'
+    autoload :MethodAccess,       'hashie/extensions/method_access'
+    autoload :MethodQuery,        'hashie/extensions/method_access'
+    autoload :MethodReader,       'hashie/extensions/method_access'
+    autoload :MethodWriter,       'hashie/extensions/method_access'
+    autoload :StringifyKeys,      'hashie/extensions/stringify_keys'
+    autoload :SymbolizeKeys,      'hashie/extensions/symbolize_keys'
+    autoload :DeepFetch,          'hashie/extensions/deep_fetch'
+    autoload :DeepFind,           'hashie/extensions/deep_find'
+    autoload :DeepLocate,         'hashie/extensions/deep_locate'
+    autoload :PrettyInspect,      'hashie/extensions/pretty_inspect'
+    autoload :KeyConversion,      'hashie/extensions/key_conversion'
     autoload :MethodAccessWithOverride, 'hashie/extensions/method_access'
-    autoload :StrictKeyAccess,   'hashie/extensions/strict_key_access'
-    autoload :RubyVersion,       'hashie/extensions/ruby_version'
-    autoload :RubyVersionCheck,  'hashie/extensions/ruby_version_check'
+    autoload :StrictKeyAccess,    'hashie/extensions/strict_key_access'
+    autoload :RubyVersion,        'hashie/extensions/ruby_version'
+    autoload :RubyVersionCheck,   'hashie/extensions/ruby_version_check'
 
     module Parsers
       autoload :YamlErbParser, 'hashie/extensions/parsers/yaml_erb_parser'
@@ -41,12 +41,15 @@ module Hashie
       autoload :IndifferentAccess, 'hashie/extensions/dash/indifferent_access'
       autoload :PropertyTranslation, 'hashie/extensions/dash/property_translation'
       autoload :Coercion, 'hashie/extensions/dash/coercion'
+      autoload :PredefinedValues, 'hashie/extensions/dash/predefined_values'
     end
 
     module Mash
       autoload :KeepOriginalKeys, 'hashie/extensions/mash/keep_original_keys'
+      autoload :PermissiveRespondTo, 'hashie/extensions/mash/permissive_respond_to'
       autoload :SafeAssignment, 'hashie/extensions/mash/safe_assignment'
       autoload :SymbolizeKeys, 'hashie/extensions/mash/symbolize_keys'
+      autoload :DefineAccessors, 'hashie/extensions/mash/define_accessors'
     end
 
     module Array