hashie 2.1.2 → 4.1.0

data/lib/hashie/extensions/ruby_version_check.rb

@@ -0,0 +1,21 @@
+require 'hashie/extensions/ruby_version'
+
+module Hashie
+  module Extensions
+    module RubyVersionCheck
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def with_minimum_ruby(version)
+          yield if with_minimum_ruby?(version)
+        end
+
+        def with_minimum_ruby?(version)
+          RubyVersion.new(RUBY_VERSION) >= RubyVersion.new(version)
+        end
+      end
+    end
+  end
+end

data/lib/hashie/extensions/strict_key_access.rb

@@ -0,0 +1,77 @@
+module Hashie
+  module Extensions
+    # SRP: This extension will fail an error whenever a key is accessed
+    #   that does not exist in the hash.
+    #
+    #   EXAMPLE:
+    #
+    #     class StrictKeyAccessHash < Hash
+    #       include Hashie::Extensions::StrictKeyAccess
+    #     end
+    #
+    #     >> hash = StrictKeyAccessHash[foo: "bar"]
+    #     => {:foo=>"bar"}
+    #     >> hash[:foo]
+    #     => "bar"
+    #     >> hash[:cow]
+    #       KeyError: key not found: :cow
+    #
+    # NOTE: For googlers coming from Python to Ruby, this extension makes a Hash
+    # behave more like a "Dictionary".
+    #
+    module StrictKeyAccess
+      class DefaultError < StandardError
+        def initialize
+          super('Setting or using a default with Hashie::Extensions::StrictKeyAccess'\
+                ' does not make sense'
+          )
+        end
+      end
+
+      # NOTE: Defaults don't make any sense with a StrictKeyAccess.
+      # NOTE: When key lookup fails a KeyError is raised.
+      #
+      # Normal:
+      #
+      #     >> a = Hash.new(123)
+      #     => {}
+      #     >> a["noes"]
+      #     => 123
+      #
+      # With StrictKeyAccess:
+      #
+      #     >> a = StrictKeyAccessHash.new(123)
+      #     => {}
+      #     >> a["noes"]
+      #       KeyError: key not found: "noes"
+      #
+      def [](key)
+        fetch(key)
+      end
+
+      def default(_ = nil)
+        raise DefaultError
+      end
+
+      def default=(_)
+        raise DefaultError
+      end
+
+      def default_proc
+        raise DefaultError
+      end
+
+      def default_proc=(_)
+        raise DefaultError
+      end
+
+      def key(value)
+        super.tap do |result|
+          if result.nil? && (!key?(result) || self[result] != value)
+            raise KeyError, "key not found with value of #{value.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hashie/extensions/stringify_keys.rb

@@ -0,0 +1,71 @@
+module Hashie
+  module Extensions
+    module StringifyKeys
+      # Convert all keys in the hash to strings.
+      #
+      # @example
+      #   test = {:abc => 'def'}
+      #   test.stringify_keys!
+      #   test # => {'abc' => 'def'}
+      def stringify_keys!
+        StringifyKeys.stringify_keys!(self)
+        self
+      end
+
+      # Return a new hash with all keys converted
+      # to strings.
+      def stringify_keys
+        StringifyKeys.stringify_keys(self)
+      end
+
+      module ClassMethods
+        # Stringify all keys recursively within nested
+        # hashes and arrays.
+        # @api private
+        def stringify_keys_recursively!(object)
+          case object
+          when self.class
+            stringify_keys!(object)
+          when ::Array
+            object.each do |i|
+              stringify_keys_recursively!(i)
+            end
+          when ::Hash
+            stringify_keys!(object)
+          end
+        end
+
+        # Convert all keys in the hash to strings.
+        #
+        # @param [::Hash] hash
+        # @example
+        #   test = {:abc => 'def'}
+        #   test.stringify_keys!
+        #   test # => {'abc' => 'def'}
+        def stringify_keys!(hash)
+          hash.extend(Hashie::Extensions::StringifyKeys) unless hash.respond_to?(:stringify_keys!)
+          hash.keys.each do |k| # rubocop:disable Performance/HashEachMethods
+            stringify_keys_recursively!(hash[k])
+            hash[k.to_s] = hash.delete(k)
+          end
+          hash
+        end
+
+        # Return a copy of hash with all keys converted
+        # to strings.
+        # @param [::Hash] hash
+        def stringify_keys(hash)
+          copy = hash.dup
+          copy.extend(Hashie::Extensions::StringifyKeys) unless copy.respond_to?(:stringify_keys!)
+          copy.tap do |new_hash|
+            stringify_keys!(new_hash)
+          end
+        end
+      end
+
+      class << self
+        include ClassMethods
+      end
+    end
+  end
+end

data/lib/hashie/extensions/symbolize_keys.rb

@@ -0,0 +1,71 @@
+module Hashie
+  module Extensions
+    module SymbolizeKeys
+      # Convert all keys in the hash to symbols.
+      #
+      # @example
+      #   test = {'abc' => 'def'}
+      #   test.symbolize_keys!
+      #   test # => {:abc => 'def'}
+      def symbolize_keys!
+        SymbolizeKeys.symbolize_keys!(self)
+        self
+      end
+
+      # Return a new hash with all keys converted
+      # to symbols.
+      def symbolize_keys
+        SymbolizeKeys.symbolize_keys(self)
+      end
+
+      module ClassMethods
+        # Symbolize all keys recursively within nested
+        # hashes and arrays.
+        # @api private
+        def symbolize_keys_recursively!(object)
+          case object
+          when self.class
+            symbolize_keys!(object)
+          when ::Array
+            object.each do |i|
+              symbolize_keys_recursively!(i)
+            end
+          when ::Hash
+            symbolize_keys!(object)
+          end
+        end
+
+        # Convert all keys in hash to symbols.
+        #
+        # @param [Hash] hash
+        # @example
+        #   test = {'abc' => 'def'}
+        #   Hashie.symbolize_keys! test
+        #   test # => {:abc => 'def'}
+        def symbolize_keys!(hash)
+          hash.extend(Hashie::Extensions::SymbolizeKeys) unless hash.respond_to?(:symbolize_keys!)
+          hash.keys.each do |k| # rubocop:disable Performance/HashEachMethods
+            symbolize_keys_recursively!(hash[k])
+            hash[k.to_sym] = hash.delete(k)
+          end
+          hash
+        end
+
+        # Return a copy of hash with all keys converted
+        # to symbols.
+        # @param [::Hash] hash
+        def symbolize_keys(hash)
+          copy = hash.dup
+          copy.extend(Hashie::Extensions::SymbolizeKeys) unless copy.respond_to?(:symbolize_keys!)
+          copy.tap do |new_hash|
+            symbolize_keys!(new_hash)
+          end
+        end
+      end
+
+      class << self
+        include ClassMethods
+      end
+    end
+  end
+end

data/lib/hashie/hash.rb

@@ -1,25 +1,38 @@
-require 'hashie/hash_extensions'
+require 'hashie/extensions/stringify_keys'
+require 'hashie/extensions/pretty_inspect'
 
 module Hashie
   # A Hashie Hash is simply a Hash that has convenience
   # functions baked in such as stringify_keys that may
   # not be available in all libraries.
   class Hash < ::Hash
-    include HashExtensions
+    include Hashie::Extensions::PrettyInspect
+    include Hashie::Extensions::StringifyKeys
+
+    # Convert this hash into a Mash
+    def to_mash
+      ::Hashie::Mash.new(self)
+    end
 
     # Converts a mash back to a hash (with stringified or symbolized keys)
     def to_hash(options = {})
       out = {}
-      keys.each do |k|
-        assignment_key = k.to_s
-        assignment_key = assignment_key.to_sym if options[:symbolize_keys]
+      each_key do |k|
+        assignment_key =
+          if options[:stringify_keys]
+            k.to_s
+          elsif options[:symbolize_keys]
+            k.to_s.to_sym
+          else
+            k
+          end
         if self[k].is_a?(Array)
           out[assignment_key] ||= []
           self[k].each do |array_object|
-            out[assignment_key] << (Hash === array_object ? flexibly_convert_to_hash(array_object, options) : array_object)
+            out[assignment_key] << maybe_convert_to_hash(array_object, options)
           end
         else
-          out[assignment_key] = (Hash === self[k] || self[k].respond_to?(:to_hash)) ? flexibly_convert_to_hash(self[k], options) : self[k]
+          out[assignment_key] = maybe_convert_to_hash(self[k], options)
         end
       end
       out
@@ -32,8 +45,14 @@ module Hashie
 
     private
 
+    def maybe_convert_to_hash(object, options)
+      return object unless object.is_a?(Hash) || object.respond_to?(:to_hash)
+
+      flexibly_convert_to_hash(object, options)
+    end
+
     def flexibly_convert_to_hash(object, options = {})
-      if object.method(:to_hash).arity == 0
+      if object.method(:to_hash).arity.zero?
         object.to_hash
       else
         object.to_hash(options)

data/lib/hashie/logger.rb

@@ -0,0 +1,18 @@
+require 'logger'
+
+module Hashie
+  # The logger that Hashie uses for reporting errors.
+  #
+  # @return [Logger]
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+  end
+
+  # Sets the logger that Hashie uses for reporting errors.
+  #
+  # @param logger [Logger] The logger to set as Hashie's logger.
+  # @return [void]
+  def self.logger=(logger)
+    @logger = logger
+  end
+end

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,9 +62,37 @@ module Hashie
   #   mash.author # => <Mash>
   #
   class Mash < Hash
-    ALLOWED_SUFFIXES = %w(? ! = _)
-    include Hashie::PrettyInspect
-    alias_method :to_s, :inspect
+    include Hashie::Extensions::PrettyInspect
+    include Hashie::Extensions::RubyVersionCheck
+    extend Hashie::Extensions::KeyConflictWarning
+
+    ALLOWED_SUFFIXES = %w[? ! = _].freeze
+
+    def self.load(path, options = {})
+      @_mashes ||= new
+
+      return @_mashes[path] if @_mashes.key?(path)
+      raise ArgumentError, "The following file doesn't exist: #{path}" unless File.file?(path)
+
+      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)
+      mash = self
+      Module.new do |m|
+        m.send :define_method, mash_method_name.to_sym do
+          mash
+        end
+      end
+    end
+
+    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
@@ -68,22 +103,28 @@ module Hashie
       default ? super(default) : super(&blk)
     end
 
-    class << self; alias_method :[], :new; end
-
-    def id #:nodoc:
-      self['id']
+    # 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
 
-    def type #:nodoc:
-      self['type']
-    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.
     def custom_reader(key)
+      default_proc.call(self, key) if default_proc && !key?(key)
       value = regular_reader(convert_key(key))
       yield value if block_given?
       value
@@ -93,11 +134,14 @@ module Hashie
     # a string before it is set, and Hashes will be converted
     # into Mashes for nesting purposes.
     def custom_writer(key, value, convert = true) #:nodoc:
-      regular_writer(convert_key(key), convert ? convert_value(value) : value)
+      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)
     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.
@@ -126,44 +170,98 @@ module Hashie
       super(convert_key(key))
     end
 
-    alias_method :regular_dup, :dup
+    def values_at(*keys)
+      super(*keys.map { |key| convert_key(key) })
+    end
+
+    # 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
+          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)
+      self[name] = value
+    end
 
     # Performs a shallow_update on a duplicate of the current mash
     def shallow_merge(other_hash)
@@ -185,11 +283,14 @@ module Hashie
       self
     end
 
-    # Will return true if the Mash has had a key
-    # set in addition to normal respond_to? functionality.
-    def respond_to?(method_name, include_private = false)
-      return true if key?(method_name) || prefix_method?(method_name)
-      super
+    def respond_to_missing?(method_name, *args)
+      return true if key?(method_name)
+      suffix = method_suffix(method_name)
+      if suffix
+        true
+      else
+        super
+      end
     end
 
     def prefix_method?(method_name)
@@ -197,26 +298,78 @@ 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)
-      suffixes_regex = ALLOWED_SUFFIXES.join
-      match = method_name.to_s.match(/(.*?)([#{suffixes_regex}]?)$/)
-      case match[2]
-      when '='
-        self[match[1]] = args.first
-      when '?'
-        !!self[match[1]]
-      when '!'
-        initializing_reader(match[1])
-      when '_'
-        underbang_reader(match[1])
+      name, suffix = method_name_and_suffix(method_name)
+      case suffix
+      when '='.freeze
+        assign_property(name, args.first)
+      when '?'.freeze
+        !!self[name]
+      when '!'.freeze
+        initializing_reader(name)
+      when '_'.freeze
+        underbang_reader(name)
       else
-        default(method_name)
+        self[method_name]
+      end
+    end
+
+    # play nice with ActiveSupport Array#extract_options!
+    def extractable_options?
+      true
+    end
+
+    # another ActiveSupport method, see issue #270
+    def reverse_merge(other_hash)
+      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
 
     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)
+      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
     end
@@ -230,11 +383,36 @@ 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 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