hashie 3.4.3 → 5.0.0

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

@@ -0,0 +1,90 @@
+module Hashie
+  module Extensions
+    module Mash
+      module DefineAccessors
+        def self.included(klass)
+          klass.class_eval do
+            mod = Ext.new
+            include mod
+          end
+        end
+
+        def self.extended(obj)
+          included(obj.singleton_class)
+        end
+
+        class Ext < Module
+          def initialize
+            mod = self
+            define_method(:method_missing) do |method_name, *args, &block|
+              key, suffix = method_name_and_suffix(method_name)
+              case suffix
+              when '='.freeze
+                mod.define_writer(key, method_name)
+              when '?'.freeze
+                mod.define_predicate(key, method_name)
+              when '!'.freeze
+                mod.define_initializing_reader(key, method_name)
+              when '_'.freeze
+                mod.define_underbang_reader(key, method_name)
+              else
+                mod.define_reader(key, method_name)
+              end
+              send(method_name, *args, &block)
+            end
+          end
+
+          def define_reader(key, method_name)
+            define_method(method_name) do |&block|
+              if key? method_name
+                self.[](method_name, &block)
+              else
+                self.[](key, &block)
+              end
+            end
+          end
+
+          def define_writer(key, method_name)
+            define_method(method_name) do |value = nil|
+              if key? method_name
+                self.[](method_name, &proc)
+              else
+                assign_property(key, value)
+              end
+            end
+          end
+
+          def define_predicate(key, method_name)
+            define_method(method_name) do
+              if key? method_name
+                self.[](method_name, &proc)
+              else
+                !!self[key]
+              end
+            end
+          end
+
+          def define_initializing_reader(key, method_name)
+            define_method(method_name) do
+              if key? method_name
+                self.[](method_name, &proc)
+              else
+                initializing_reader(key)
+              end
+            end
+          end
+
+          def define_underbang_reader(key, method_name)
+            define_method(method_name) do
+              if key? method_name
+                self.[](key, &proc)
+              else
+                underbang_reader(key)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Hashie
+  module Extensions
+    module Mash
+      # Overrides the indifferent access of a Mash to keep keys in the
+      # original format given to the Mash.
+      #
+      # @example
+      #   class KeepingMash < Hashie::Mash
+      #     include Hashie::Extensions::Mash::KeepOriginalKeys
+      #   end
+      #
+      #   mash = KeepingMash.new(:symbol_key => :symbol, 'string_key' => 'string')
+      #   mash.to_hash  #=> { :symbol_key => :symbol, 'string_key' => 'string' }
+      #   mash['string_key'] == mash[:string_key]  #=> true
+      #   mash[:symbol_key] == mash['symbol_key']  #=> true
+      module KeepOriginalKeys
+        def self.included(descendant)
+          error_message = "#{descendant} is not a kind of Hashie::Mash"
+          raise ArgumentError, error_message unless descendant <= Hashie::Mash
+        end
+
+        private
+
+        # Converts the key when necessary to access the correct Mash key.
+        #
+        # @param [Object, String, Symbol] key the key to access.
+        # @return [Object] the value assigned to the key.
+        def convert_key(key)
+          if regular_key?(key)
+            key
+          elsif (converted_key = __convert(key)) && regular_key?(converted_key)
+            converted_key
+          else
+            key
+          end
+        end
+
+        # Converts symbol/string keys to their alternative formats, but leaves
+        # other keys alone.
+        #
+        # @param [Object, String, Symbol] key the key to convert.
+        # @return [Object, String, Symbol] the converted key.
+        def __convert(key)
+          case key
+          when Symbol then key.to_s
+          when String then key.to_sym
+          else key
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Hashie
+  module Extensions
+    module Mash
+      # Allow a Mash to properly respond to everything
+      #
+      # By default, Mashes only say they respond to methods for keys that exist
+      # in their key set or any of the affix methods (e.g. setter, underbang,
+      # etc.). This causes issues when you try to use them within a
+      # SimpleDelegator or bind to a method for a key that is unset.
+      #
+      # This extension allows a Mash to properly respond to `respond_to?` and
+      # `method` for keys that have not yet been set. This enables full
+      # compatibility with SimpleDelegator and thunk-oriented programming.
+      #
+      # There is a trade-off with this extension: it will run slower than a
+      # regular Mash; insertions and initializations with keys run approximately
+      # 20% slower and cost approximately 19KB of memory per class that you
+      # make permissive.
+      #
+      # @api public
+      # @example Make a new, permissively responding Mash subclass
+      #   class PermissiveMash < Hashie::Mash
+      #     include Hashie::Extensions::Mash::PermissiveRespondTo
+      #   end
+      #
+      #   mash = PermissiveMash.new(a: 1)
+      #   mash.respond_to? :b  #=> true
+      module PermissiveRespondTo
+        # The Ruby hook for behavior when including the module
+        #
+        # @api private
+        # @private
+        # @return void
+        def self.included(base)
+          base.instance_variable_set :@_method_cache, base.instance_methods
+          base.define_singleton_method(:method_cache) { @_method_cache }
+        end
+
+        # The Ruby hook for determining what messages a class might respond to
+        #
+        # @api private
+        # @private
+        def respond_to_missing?(_method_name, _include_private = false)
+          true
+        end
+
+        private
+
+        # Override the Mash logging behavior to account for permissiveness
+        #
+        # @api private
+        # @private
+        def log_collision?(method_key)
+          self.class.method_cache.include?(method_key) &&
+            !self.class.disable_warnings?(method_key) &&
+            !(regular_key?(method_key) || regular_key?(method_key.to_s))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Hashie
+  module Extensions
+    module Mash
+      # Overrides Mash's default behavior of converting keys to strings
+      #
+      # @example
+      #   class LazyResponse < Hashie::Mash
+      #     include Hashie::Extensions::Mash::SymbolizeKeys
+      #   end
+      #
+      #   response = LazyResponse.new("id" => 123, "name" => "Rey").to_h
+      #   #=> {id: 123, name: "Rey"}
+      #
+      # @api public
+      module SymbolizeKeys
+        # Hook for being included in a class
+        #
+        # @api private
+        # @return [void]
+        # @raise [ArgumentError] when the base class isn't a Mash
+        def self.included(base)
+          raise ArgumentError, "#{base} must descent from Hashie::Mash" unless base <= Hashie::Mash
+        end
+
+        private
+
+        # Converts a key to a symbol, if possible
+        #
+        # @api private
+        # @param [<K>] key the key to attempt convert to a symbol
+        # @return [Symbol, K]
+        def convert_key(key)
+          key.respond_to?(:to_sym) ? key.to_sym : key
+        end
+      end
+    end
+  end
+end

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,17 +106,42 @@ module Hashie
     #   h.def? # => false
     #   h.hji? # => NoMethodError
     module MethodQuery
-      def respond_to?(name, include_private = false)
-        return true if name.to_s =~ /(.*)\?$/ && (key?(Regexp.last_match[1]) || key?(Regexp.last_match[1].to_sym))
-        super
+      def respond_to_missing?(name, include_private = false)
+        if query_method?(name) && indifferent_key?(key_from_query_method(name))
+          true
+        else
+          super
+        end
       end
 
       def method_missing(name, *args)
-        if args.empty? && name.to_s =~ /(.*)\?$/ && (key?(Regexp.last_match[1]) || key?(Regexp.last_match[1].to_sym))
-          return self[Regexp.last_match[1]] || self[Regexp.last_match[1].to_sym]
+        return super unless args.empty?
+
+        if query_method?(name)
+          key = key_from_query_method(name)
+          if indifferent_key?(key)
+            !!(self[key] || self[key.to_sym])
+          else
+            super
+          end
+        else
+          super
         end
+      end
 
-        super
+      private
+
+      def indifferent_key?(name)
+        name = name.to_s
+        key?(name) || key?(name.to_sym)
+      end
+
+      def key_from_query_method(query_method)
+        query_method.to_s[0..-2]
+      end
+
+      def query_method?(name)
+        name.to_s.end_with?('?')
       end
     end
 
@@ -131,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
@@ -156,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
@@ -180,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,
@@ -200,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
+          @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.rb

@@ -0,0 +1,60 @@
+# Copyright (c) Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# Portions copyright (c) Engine Yard and Andre Arko
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# 'Software'), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+module Hashie
+  module Extensions
+    class RubyVersion
+      include Comparable
+
+      attr_accessor :segments
+
+      def initialize(version)
+        @segments = split_to_segments(version)
+      end
+
+      def <=>(other)
+        lhsegments = segments
+        rhsegments = other.segments
+
+        lhsize = lhsegments.size
+        rhsize = rhsegments.size
+        limit  = (lhsize > rhsize ? lhsize : rhsize) - 1
+
+        i = 0
+
+        while i <= limit
+          lhs = lhsegments[i] || 0
+          rhs = rhsegments[i] || 0
+          i += 1
+
+          next      if lhs == rhs
+          return -1 if lhs.is_a?(String) && rhs.is_a?(Numeric)
+          return  1 if lhs.is_a?(Numeric) && rhs.is_a?(String)
+
+          return lhs <=> rhs
+        end
+
+        0
+      end
+
+      private
+
+      def split_to_segments(version)
+        version.scan(/[0-9]+|[a-z]+/i).map do |segment|
+          /^\d+$/ =~ segment ? segment.to_i : segment
+        end.freeze
+      end
+    end
+  end
+end

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

@@ -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,9 +44,9 @@ 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)
+            hash[convert_key(k)] = hash.delete(k)
           end
           hash
         end
@@ -61,6 +61,17 @@ module Hashie
             symbolize_keys!(new_hash)
           end
         end
+
+        private
+
+        # Converts a key to a symbol, if possible
+        #
+        # @api private
+        # @param [<K>] key the key to attempt convert to a symbol
+        # @return [Symbol, K]
+        def convert_key(key)
+          key.respond_to?(:to_sym) ? key.to_sym : key
+        end
       end
 
       class << self