hashie 3.4.2 → 5.0.0

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

@@ -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

@@ -15,7 +15,7 @@ module Hashie
       # Return a new hash with all keys converted
       # to strings.
       def stringify_keys
-        dup.stringify_keys!
+        StringifyKeys.stringify_keys(self)
       end
 
       module ClassMethods
@@ -25,7 +25,7 @@ module Hashie
         def stringify_keys_recursively!(object)
           case object
           when self.class
-            object.stringify_keys!
+            stringify_keys!(object)
           when ::Array
             object.each do |i|
               stringify_keys_recursively!(i)
@@ -43,7 +43,8 @@ module Hashie
         #   test.stringify_keys!
         #   test # => {'abc' => 'def'}
         def stringify_keys!(hash)
-          hash.keys.each do |k|
+          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
@@ -54,8 +55,10 @@ module Hashie
         # to strings.
         # @param [::Hash] hash
         def stringify_keys(hash)
-          hash.dup.tap do | new_hash |
-            stringify_keys! new_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

data/lib/hashie/extensions/symbolize_keys.rb

@@ -15,7 +15,7 @@ module Hashie
       # Return a new hash with all keys converted
       # to symbols.
       def symbolize_keys
-        dup.symbolize_keys!
+        SymbolizeKeys.symbolize_keys(self)
       end
 
       module ClassMethods
@@ -23,9 +23,9 @@ module Hashie
         # hashes and arrays.
         # @api private
         def symbolize_keys_recursively!(object)
-          object.symbolize_keys! if object.respond_to? :symbolize_keys!
-
           case object
+          when self.class
+            symbolize_keys!(object)
           when ::Array
             object.each do |i|
               symbolize_keys_recursively!(i)
@@ -43,9 +43,10 @@ module Hashie
         #   Hashie.symbolize_keys! test
         #   test # => {:abc => 'def'}
         def symbolize_keys!(hash)
-          hash.keys.each do |k|
+          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)
+            hash[convert_key(k)] = hash.delete(k)
           end
           hash
         end
@@ -54,10 +55,23 @@ module Hashie
         # to symbols.
         # @param [::Hash] hash
         def symbolize_keys(hash)
-          hash.dup.tap do | new_hash |
-            symbolize_keys! new_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
+
+        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

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.respond_to?(:to_sym)
+            k.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/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