hashie 3.5.7 → 4.1.0

data/lib/hashie/extensions/mash/safe_assignment.rb

@@ -3,7 +3,9 @@ module Hashie
     module Mash
       module SafeAssignment
         def custom_writer(key, *args) #:nodoc:
-          fail ArgumentError, "The property #{key} clashes with an existing method." if !key?(key) && respond_to?(key, true)
+          if !key?(key) && respond_to?(key, true)
+            raise ArgumentError, "The property #{key} clashes with an existing method."
+          end
           super
         end
 

data/lib/hashie/extensions/mash/symbolize_keys.rb

@@ -19,7 +19,7 @@ module Hashie
         # @return [void]
         # @raise [ArgumentError] when the base class isn't a Mash
         def self.included(base)
-          fail ArgumentError, "#{base} must descent from Hashie::Mash" unless base <= Hashie::Mash
+          raise ArgumentError, "#{base} must descent from Hashie::Mash" unless base <= Hashie::Mash
         end
 
         private

data/lib/hashie/extensions/method_access.rb

@@ -27,7 +27,7 @@ module Hashie
     #
     #   user.not_declared # => NoMethodError
     module MethodReader
-      def respond_to?(name, include_private = false)
+      def respond_to_missing?(name, include_private = false)
         return true if key?(name.to_s) || key?(name.to_sym)
         super
       end
@@ -67,7 +67,7 @@ module Hashie
     #   h['awesome'] # => 'sauce'
     #
     module MethodWriter
-      def respond_to?(name, include_private = false)
+      def respond_to_missing?(name, include_private = false)
         return true if name.to_s =~ /=$/
         super
       end
@@ -106,7 +106,7 @@ module Hashie
     #   h.def? # => false
     #   h.hji? # => NoMethodError
     module MethodQuery
-      def respond_to?(name, include_private = false)
+      def respond_to_missing?(name, include_private = false)
         if query_method?(name) && indifferent_key?(key_from_query_method(name))
           true
         else
@@ -156,6 +156,22 @@ module Hashie
       end
     end
 
+    # A module shared between MethodOverridingWriter and MethodOverridingInitializer
+    # to contained shared logic. This module aids in redefining existing hash methods.
+    module RedefineMethod
+      protected
+
+      def method?(name)
+        methods.map(&:to_s).include?(name)
+      end
+
+      def redefine_method(method_name)
+        eigenclass = class << self; self; end
+        eigenclass.__send__(:alias_method, "__#{method_name}", method_name)
+        eigenclass.__send__(:define_method, method_name, -> { self[method_name] })
+      end
+    end
+
     # MethodOverridingWriter gives you #key_name= shortcuts for
     # writing to your hash. It allows methods to be overridden by
     # #key_name= shortcuts and aliases those methods with two
@@ -181,6 +197,8 @@ module Hashie
     #   h.__zip # => [[['awesome', 'sauce'], ['zip', 'a-dee-doo-dah']]]
     #
     module MethodOverridingWriter
+      include RedefineMethod
+
       def convert_key(key)
         key.to_s
       end
@@ -205,16 +223,6 @@ module Hashie
       def already_overridden?(name)
         method?("__#{name}")
       end
-
-      def method?(name)
-        methods.map(&:to_s).include?(name)
-      end
-
-      def redefine_method(method_name)
-        eigenclass = class << self; self; end
-        eigenclass.__send__(:alias_method, "__#{method_name}", method_name)
-        eigenclass.__send__(:define_method, method_name, -> { self[method_name] })
-      end
     end
 
     # A macro module that will automatically include MethodReader,
@@ -225,10 +233,35 @@ module Hashie
     # underscores.
     module MethodAccessWithOverride
       def self.included(base)
-        [MethodReader, MethodOverridingWriter, MethodQuery].each do |mod|
+        [MethodReader, MethodOverridingWriter,
+         MethodQuery, MethodOverridingInitializer].each do |mod|
           base.send :include, mod
         end
       end
     end
+
+    # MethodOverridingInitializer allows you to override default hash
+    # methods when passing in values from an existing hash. The overriden
+    # methods are aliased with two leading underscores.
+    #
+    # @example
+    #   class MyHash < Hash
+    #     include Hashie::Extensions::MethodOverridingInitializer
+    #   end
+    #
+    #   h = MyHash.new(zip: 'a-dee-doo-dah')
+    #   h.zip # => 'a-dee-doo-dah'
+    #   h.__zip # => [[['zip', 'a-dee-doo-dah']]]
+    module MethodOverridingInitializer
+      include RedefineMethod
+
+      def initialize(hash = {})
+        hash.each do |key, value|
+          skey = key.to_s
+          redefine_method(skey) if method?(skey)
+          self[skey] = value
+        end
+      end
+    end
   end
 end

data/lib/hashie/extensions/parsers/yaml_erb_parser.rb

@@ -1,22 +1,46 @@
 require 'yaml'
 require 'erb'
+require 'pathname'
+
 module Hashie
   module Extensions
     module Parsers
       class YamlErbParser
-        def initialize(file_path)
+        def initialize(file_path, options = {})
           @content = File.read(file_path)
           @file_path = file_path.is_a?(Pathname) ? file_path.to_s : file_path
+          @options = options
         end
 
         def perform
           template = ERB.new(@content)
           template.filename = @file_path
-          YAML.load template.result
+          permitted_classes = @options.fetch(:permitted_classes) { [] }
+          permitted_symbols = @options.fetch(:permitted_symbols) { [] }
+          aliases = @options.fetch(:aliases) { true }
+
+          yaml_safe_load(template, permitted_classes, permitted_symbols, aliases)
         end
 
-        def self.perform(file_path)
-          new(file_path).perform
+        def self.perform(file_path, options = {})
+          new(file_path, options).perform
+        end
+
+        private
+
+        if Gem::Version.new(Psych::VERSION) >= Gem::Version.new('3.1.0') # Ruby 2.6+
+          def yaml_safe_load(template, permitted_classes, permitted_symbols, aliases)
+            YAML.safe_load(
+              template.result,
+              permitted_classes: permitted_classes,
+              permitted_symbols: permitted_symbols,
+              aliases: aliases
+            )
+          end
+        else
+          def yaml_safe_load(template, permitted_classes, permitted_symbols, aliases)
+            YAML.safe_load(template.result, permitted_classes, permitted_symbols, aliases)
+          end
         end
       end
     end

data/lib/hashie/extensions/ruby_version_check.rb

@@ -9,7 +9,11 @@ module Hashie
 
       module ClassMethods
         def with_minimum_ruby(version)
-          yield if RubyVersion.new(RUBY_VERSION) >= RubyVersion.new(version)
+          yield if with_minimum_ruby?(version)
+        end
+
+        def with_minimum_ruby?(version)
+          RubyVersion.new(RUBY_VERSION) >= RubyVersion.new(version)
         end
       end
     end

data/lib/hashie/extensions/strict_key_access.rb

@@ -1,6 +1,7 @@
 module Hashie
   module Extensions
-    # SRP: This extension will fail an error whenever a key is accessed that does not exist in the hash.
+    # SRP: This extension will fail an error whenever a key is accessed
+    #   that does not exist in the hash.
     #
     #   EXAMPLE:
     #
@@ -15,12 +16,15 @@ module Hashie
     #     >> 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".
+    # 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(msg = 'Setting or using a default with Hashie::Extensions::StrictKeyAccess does not make sense', *args)
-          super
+        def initialize
+          super('Setting or using a default with Hashie::Extensions::StrictKeyAccess'\
+                ' does not make sense'
+          )
         end
       end
 
@@ -46,27 +50,26 @@ module Hashie
       end
 
       def default(_ = nil)
-        fail DefaultError
+        raise DefaultError
       end
 
       def default=(_)
-        fail DefaultError
+        raise DefaultError
       end
 
       def default_proc
-        fail DefaultError
+        raise DefaultError
       end
 
       def default_proc=(_)
-        fail DefaultError
+        raise DefaultError
       end
 
       def key(value)
-        result = super
-        if result.nil? && (!key?(result) || self[result] != value)
-          fail KeyError, "key not found with value of #{value.inspect}"
-        else
-          result
+        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

data/lib/hashie/extensions/stringify_keys.rb

@@ -44,7 +44,7 @@ module Hashie
         #   test # => {'abc' => 'def'}
         def stringify_keys!(hash)
           hash.extend(Hashie::Extensions::StringifyKeys) unless hash.respond_to?(:stringify_keys!)
-          hash.keys.each do |k|
+          hash.keys.each do |k| # rubocop:disable Performance/HashEachMethods
             stringify_keys_recursively!(hash[k])
             hash[k.to_s] = hash.delete(k)
           end

data/lib/hashie/extensions/symbolize_keys.rb

@@ -44,7 +44,7 @@ module Hashie
         #   test # => {:abc => 'def'}
         def symbolize_keys!(hash)
           hash.extend(Hashie::Extensions::SymbolizeKeys) unless hash.respond_to?(:symbolize_keys!)
-          hash.keys.each do |k|
+          hash.keys.each do |k| # rubocop:disable Performance/HashEachMethods
             symbolize_keys_recursively!(hash[k])
             hash[k.to_sym] = hash.delete(k)
           end

data/lib/hashie/hash.rb

@@ -17,21 +17,22 @@ module Hashie
     # Converts a mash back to a hash (with stringified or symbolized keys)
     def to_hash(options = {})
       out = {}
-      keys.each do |k|
-        assignment_key = if options[:stringify_keys]
-                           k.to_s
-                         elsif options[:symbolize_keys]
-                           k.to_s.to_sym
-                         else
-                           k
-                         end
+      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
@@ -44,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/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
   #
@@ -60,49 +64,19 @@ module Hashie
   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 +88,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,10 +103,23 @@ 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.
@@ -149,8 +140,8 @@ module Hashie
       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.
@@ -183,45 +174,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?
 
-    # Performs a deep_update on a duplicate of the
-    # current mash.
-    def deep_merge(other_hash, &blk)
-      dup.deep_update(other_hash, &blk)
+    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
+
+      # 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 +298,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 +331,29 @@ 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
+
     protected
 
     def method_name_and_suffix(method_name)
@@ -325,8 +383,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 +393,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 +406,12 @@ module Hashie
     end
 
     def log_collision?(method_key)
-      respond_to?(method_key) && !self.class.disable_warnings? &&
+      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