hashie 3.4.2 → 5.0.0

data/lib/hashie/mash.rb

@@ -1,4 +1,8 @@
 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
@@ -12,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
   #
@@ -55,19 +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(? ! = _)
-    SUFFIXES_PARSER  = /(.*?)([#{ALLOWED_SUFFIXES.join}]?)$/
+    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)
@@ -79,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
@@ -90,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
 
-    alias_method :regular_reader, :[]
-    alias_method :regular_writer, :[]=
+    class << self; alias [] new; end
 
-    # Retrieves an attribute set in the Mash. Will convert
-    # any key passed in to a string before retrieving.
+    alias regular_reader []
+    alias regular_writer []=
+
+    # 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))
@@ -104,15 +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:
+      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.
@@ -145,44 +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 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
+
+      # 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
 
-    # 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_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)
@@ -211,10 +282,9 @@ module Hashie
 
     def respond_to_missing?(method_name, *args)
       return true if key?(method_name)
-      _, suffix = method_suffix(method_name)
-      case suffix
-      when '=', '?', '!', '_'
-        return true
+      suffix = method_suffix(method_name)
+      if suffix
+        true
       else
         super
       end
@@ -225,17 +295,17 @@ 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_suffix(method_name)
+      name, suffix = method_name_and_suffix(method_name)
       case suffix
-      when '='
+      when '='.freeze
         assign_property(name, args.first)
-      when '?'
+      when '?'.freeze
         !!self[name]
-      when '!'
+      when '!'.freeze
         initializing_reader(name)
-      when '_'
+      when '_'.freeze
         underbang_reader(name)
       else
         self[method_name]
@@ -249,18 +319,63 @@ module Hashie
 
     # another ActiveSupport method, see issue #270
     def reverse_merge(other_hash)
-      Hashie::Mash.new(other_hash).merge(self)
+      self.class.new(other_hash).merge(self)
+    end
+
+    with_minimum_ruby('2.3.0') do
+      def dig(*keys)
+        super(*keys.map { |key| convert_key(key) })
+      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)
+      method_name = method_name.to_s
+      if method_name.end_with?(*ALLOWED_SUFFIXES)
+        [method_name[0..-2], method_name[-1]]
+      else
+        [method_name[0..-1], nil]
+      end
+    end
+
     def method_suffix(method_name)
-      match = method_name.to_s.match(SUFFIXES_PARSER)
-      [match[1], match[2]]
+      method_name = method_name.to_s
+      method_name[-1] if method_name.end_with?(*ALLOWED_SUFFIXES)
     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:
@@ -272,11 +387,37 @@ 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
         val
       end
     end
+
+    private
+
+    def log_built_in_message(method_key)
+      return if self.class.disable_warnings?(method_key)
+
+      method_information = Hashie::Utils.method_information(method(method_key))
+
+      Hashie.logger.warn(
+        'You are setting a key that conflicts with a built-in method ' \
+        "#{self.class}##{method_key} #{method_information}. " \
+        'This can cause unexpected behavior when accessing the key as a ' \
+        'property. You can still access the key via the #[] method.'
+      )
+    end
+
+    def log_collision?(method_key)
+      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
 end

data/lib/hashie/railtie.rb

@@ -0,0 +1,21 @@
+begin
+  require 'rails/railtie'
+
+  module Hashie
+    class Railtie < Rails::Railtie
+      # Set the Hashie.logger to use Rails.logger when used with rails.
+      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
+  Hashie.logger.info("Hashie skipping railtie as #{e.message}")
+end

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,18 +125,18 @@ 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
 
     def optimize_if_necessary!
       return unless (@lookups += 1) >= @optimize_every
-      @regexes = @regex_counts.sort_by { |_, count| -count }.map { |regex, _| regex }
+      @regexes = @regexes.sort_by { |regex| -@regex_counts[regex] }
       @lookups = 0
     end
   end

data/lib/hashie/utils.rb

@@ -0,0 +1,44 @@
+module Hashie
+  # A collection of helper methods that can be used throughout the gem.
+  module Utils
+    # Describes a method by where it was defined.
+    #
+    # @param bound_method [Method] The method to describe.
+    # @return [String]
+    def self.method_information(bound_method)
+      if bound_method.source_location
+        "defined at #{bound_method.source_location.join(':')}"
+      else
+        "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.4.2'
+  VERSION = '5.0.0'.freeze
 end

data/lib/hashie.rb

@@ -1,3 +1,4 @@
+require 'hashie/logger'
 require 'hashie/version'
 
 module Hashie
@@ -7,25 +8,30 @@ module Hashie
   autoload :Mash,               'hashie/mash'
   autoload :Trash,              'hashie/trash'
   autoload :Rash,               'hashie/rash'
+  autoload :Array,              'hashie/array'
+  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'
 
     module Parsers
       autoload :YamlErbParser, 'hashie/extensions/parsers/yaml_erb_parser'
@@ -34,10 +40,20 @@ module Hashie
     module Dash
       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
+      autoload :PrettyInspect, 'hashie/extensions/array/pretty_inspect'
     end
   end
 
@@ -45,4 +61,6 @@ module Hashie
     include Hashie::Extensions::StringifyKeys::ClassMethods
     include Hashie::Extensions::SymbolizeKeys::ClassMethods
   end
+
+  require 'hashie/railtie' if defined?(::Rails)
 end