hashie 3.1.0 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8151e8630508db39e56ae5ac2b5333913573f3f
-  data.tar.gz: de13b700b22ff856acabc7be36581e32f50ea43e
+  metadata.gz: 9392e6b092e218e8f232ce4232ffc42e593321d8
+  data.tar.gz: 96d123ecbe640bf034bd43108e27da8d437d9720
 SHA512:
-  metadata.gz: 4a2ea8a3fd07a80a75bbb4a687258c0ae92f3a85fdef18178bc9319fc0bc122a1c2b7d7f47fdfd6ba378d3459165642cdf8610e491d7e6438254a289434ed75f
-  data.tar.gz: cf309ea2aec15071033875bcdeb4885f2a4755a0611856acdb44c4d92c07b2b8a739d5e81c42ba163014a0485788f7597ca055ae86f913105e6efea3f90b8519
+  metadata.gz: 13c30a48d328a2427cfe2325f0690e2621fcf601bc0354b5d0831f005e4c23ea4fc83b40aef250ce85b9c4434fe6733cff2b5be2822f313b9535485e7003eef6
+  data.tar.gz: e03895318b6f26ac05e394069c30eb9eb8a98f86b206996f04a19402dd2c283ad2cd52f203e739b7a2b30f7ae4282840a6be783ea8f21cf550e047d2ed732129

data/.travis.yml

@@ -2,7 +2,7 @@ language: ruby
 
 rvm:
   - ruby-head
-  - 2.1.1
+  - 2.1.2
   - 2.1.0
   - 2.0.0
   - 1.9.3

data/CHANGELOG.md

@@ -1,4 +1,14 @@
-## 3.1 (7/25/2014)
+## 3.2.0 (7/10/2014)
+
+* [#164](https://github.com/intridea/hashie/pull/164), [#165](https://github.com/intridea/hashie/pull/165), [#166](https://github.com/intridea/hashie/pull/166): Fixed stack overflow when coercing mashes that contain ActiveSupport::HashWithIndifferentAccess values - [@numinit](https://github.com/numinit), [@kgrz](https://github.com/kgrz).
+* [#177](https://github.com/intridea/hashie/pull/177): Added support for coercing enumerables and collections - [@gregory](https://github.com/gregory).
+* [#179](https://github.com/intridea/hashie/pull/179): Mash#values_at will convert each key before doing the lookup - [@nahiluhmot](https://github.com/nahiluhmot).
+* [#184](https://github.com/intridea/hashie/pull/184): Allow ranges on Rash to match all Numeric types - [@medcat](https://github.com/medcat).
+* [#187](https://github.com/intridea/hashie/pull/187): Automatically require version - [@medcat](https://github.com/medcat).
+* [#190](https://github.com/intridea/hashie/issues/190): Fixed `coerce_key` with `from` Trash feature and Coercion extension - [@gregory](https://github.com/gregory).
+* [#192](https://github.com/intridea/hashie/pull/192): Fixed StringifyKeys#stringify_keys! to recursively stringify keys of embedded ::Hash types - [@dblock](https://github.com/dblock).
+
+## 3.1.0 (6/25/2014)
 
 * [#169](https://github.com/intridea/hashie/pull/169): Hash#to_hash will also convert nested objects that implement to_hash - [@gregory](https://github.com/gregory).
 * [#171](https://github.com/intridea/hashie/pull/171): Include Trash and Dash class name when raising `NoMethodError` - [@gregory](https://github.com/gregory).
@@ -6,7 +16,7 @@
 * [#173](https://github.com/intridea/hashie/pull/173): Auto include Dash::IndifferentAccess when IndiferentAccess is included in Dash - [@gregory](https://github.com/gregory).
 * [#174](https://github.com/intridea/hashie/pull/174): Fixed `from` and `transform_with` Trash features when IndifferentAccess is included - [@gregory](https://github.com/gregory).
 
-## 3.0 (6/3/2014)
+## 3.0.0 (6/3/2014)
 
 **Note:** This version introduces several backward incompatible API changes. See [UPGRADING](UPGRADING.md) for details.
 
@@ -18,6 +28,7 @@
 * [#149](https://github.com/intridea/hashie/issues/149): Allow IgnoreUndeclared and DeepMerge to be used with undeclared properties - [@jhaesus](https://github.com/jhaesus).
 
 ## 2.1.1 (4/12/2014)
+
 * [#144](https://github.com/intridea/hashie/issues/144): Fixed regression invoking `to_hash` with no parameters - [@mbleigh](https://github.com/mbleigh).
 
 ## 2.1.0 (4/6/2014)

data/Gemfile

@@ -8,4 +8,7 @@ end
 
 gemspec
 
-gem 'rubocop', '0.21.0'
+gem 'rubocop', '0.24.1'
+
+# ActiveSupport required to test compatibility with ActiveSupport Core Extensions.
+gem 'activesupport', require: false

data/README.md

@@ -12,7 +12,7 @@ $ gem install hashie
 
 ## Upgrading
 
-You're reading the documentation for the stable release of Hashie, 3.1. Please read [UPGRADING](UPGRADING.md) when upgrading from a previous version.
+You're reading the documentation for the stable release of Hashie, 3.2.0. Please read [UPGRADING](UPGRADING.md) when upgrading from a previous version.
 
 ## Hash Extensions
 
@@ -52,6 +52,50 @@ class SpecialHash < Hash
 end
 ```
 
+### Coercing Collections
+
+```ruby
+class Tweet < Hash
+  include Hashie::Extensions::Coercion
+  coerce_key :mentions, Array[User]
+  coerce_key :friends, Set[User]
+end
+
+user_hash = { name: "Bob" }
+mentions_hash= [user_hash, user_hash]
+friends_hash = [user_hash]
+tweet = Tweet.new(mentions: mentions_hash, friends: friends_hash)
+# => automatically calls User.coerce(user_hash) or
+#    User.new(user_hash) if that isn't present on each element of the array
+
+tweet.mentions.map(&:class) # => [User, User]
+tweet.friends.class # => Set
+```
+
+### Coercing Hashes
+
+```ruby
+class Relation
+  def initialize(string)
+    @relation = string
+  end
+end
+
+class Tweet < Hash
+  include Hashie::Extensions::Coercion
+  coerce_key :relations, Hash[User => Relation]
+end
+
+user_hash = { name: "Bob" }
+relations_hash= { user_hash => "father", user_hash => "friend" }
+tweet = Tweet.new(relations: relations_hash)
+tweet.relations.map { |k,v| [k.class, v.class] } # => [[User, Relation], [User, Relation]]
+tweet.relations.class # => Hash
+
+# => automatically calls User.coerce(user_hash) on each key
+#    and Relation.new on each value since Relation doesn't define the `coerce` class method
+```
+
 ### KeyConversion
 
 The KeyConversion extension gives you the convenience methods of `symbolize_keys` and `stringify_keys` along with their bang counterparts. You can also include just stringify or just symbolize with `Hashie::Extensions::StringifyKeys` or `Hashie::Extensions::SymbolizeKeys`.

data/Rakefile

@@ -10,6 +10,6 @@ RSpec::Core::RakeTask.new do |spec|
 end
 
 require 'rubocop/rake_task'
-Rubocop::RakeTask.new(:rubocop)
+RuboCop::RakeTask.new(:rubocop)
 
 task default: [:rubocop, :spec]

data/lib/hashie.rb

@@ -1,3 +1,5 @@
+require 'hashie/version'
+
 module Hashie
   autoload :Clash,              'hashie/clash'
   autoload :Dash,               'hashie/dash'

data/lib/hashie/extensions/coercion.rb

@@ -2,25 +2,38 @@ module Hashie
   module Extensions
     module Coercion
       def self.included(base)
-        base.extend ClassMethods
         base.send :include, InstanceMethods
+        base.extend ClassMethods # NOTE: we wanna make sure we first define set_value_with_coercion before extending
+
+        base.send :alias_method, :'set_value_without_coercion', :[]=
+        base.send :alias_method, :[]=, :'set_value_with_coercion'
       end
 
       module InstanceMethods
-        def []=(key, value)
+        def set_value_with_coercion(key, value)
           into = self.class.key_coercion(key) || self.class.value_coercion(value)
 
-          if value && into
-            if into.respond_to?(:coerce)
-              value = into.coerce(value)
-            else
-              value = into.new(value)
-            end
+          return set_value_without_coercion(key, value) unless value && into
+          return set_value_without_coercion(key, coerce_or_init(into).call(value)) unless into.is_a?(Enumerable)
+
+          if into.class >= Hash
+            key_coerce = coerce_or_init(into.flatten[0])
+            value_coerce = coerce_or_init(into.flatten[-1])
+            value = Hash[value.map { |k, v| [key_coerce.call(k), value_coerce.call(v)] }]
+          else # Enumerable but not Hash: Array, Set
+            value_coerce = coerce_or_init(into.first)
+            value = into.class.new(value.map { |v| value_coerce.call(v) })
           end
 
-          super(key, value)
+          set_value_without_coercion(key, value)
         end
 
+        def coerce_or_init(type)
+          type.respond_to?(:coerce) ? ->(v) { type.coerce(v) } : ->(v) { type.new(v) }
+        end
+
+        private :coerce_or_init
+
         def custom_writer(key, value, _convert = true)
           self[key] = value
         end

data/lib/hashie/extensions/deep_fetch.rb

@@ -16,7 +16,7 @@ module Hashie
       def deep_fetch(*args, &block)
         args.reduce(self) do |obj, arg|
           begin
-            arg = Integer(arg) if obj.kind_of? Array
+            arg = Integer(arg) if obj.is_a? Array
             obj.fetch(arg)
           rescue ArgumentError, IndexError, NoMethodError => e
             break block.call(arg) if block

data/lib/hashie/extensions/ignore_undeclared.rb

@@ -31,9 +31,8 @@ module Hashie
     module IgnoreUndeclared
       def initialize_attributes(attributes)
         attributes.each_pair do |att, value|
-          if self.class.property?(att) || (self.class.respond_to?(:translations) && self.class.translations.include?(att.to_sym))
-            self[att] = value
-          end
+          next unless self.class.property?(att) || (self.class.respond_to?(:translations) && self.class.translations.include?(att.to_sym))
+          self[att] = value
         end if attributes
       end
 

data/lib/hashie/extensions/indifferent_access.rb

@@ -29,11 +29,11 @@ module Hashie
         end
 
         base.class_eval do
-          alias_method :regular_writer, :[]=
+          alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
           alias_method :[]=, :indifferent_writer
           alias_method :store, :indifferent_writer
           %w(default update replace fetch delete key? values_at).each do |m|
-            alias_method "regular_#{m}", m
+            alias_method "regular_#{m}", m unless method_defined?("regular_#{m}")
             alias_method m, "indifferent_#{m}"
           end
 

data/lib/hashie/extensions/stringify_keys.rb

@@ -35,6 +35,12 @@ module Hashie
           object
         elsif object.respond_to?(:stringify_keys!)
           object.stringify_keys!
+        elsif ::Hash === object
+          object.keys.each do |k|
+            stringify_keys_recursively!(object[k])
+            object[k.to_s] = object.delete(k)
+          end
+          object
         else
           object
         end

data/lib/hashie/mash.rb

@@ -128,6 +128,10 @@ module Hashie
       super(convert_key(key))
     end
 
+    def values_at(*keys)
+      super(*keys.map { |key| convert_key(key) })
+    end
+
     alias_method :regular_dup, :dup
     # Duplicates the current mash as a new mash.
     def dup

data/lib/hashie/rash.rb

@@ -78,21 +78,20 @@ module Hashie
         # see if any of the regexps match the string
         @regexes.each do |regex|
           match = regex.match(query)
-          if match
-            @regex_counts[regex] += 1
-            value = @hash[regex]
-            if value.respond_to? :call
-              yield value.call(match)
-            else
-              yield value
-            end
+          next unless match
+          @regex_counts[regex] += 1
+          value = @hash[regex]
+          if value.respond_to? :call
+            yield value.call(match)
+          else
+            yield value
           end
         end
 
-      when Integer
+      when Numeric
         # see if any of the ranges match the integer
         @ranges.each do |range|
-          yield @hash[range] if range.include? query
+          yield @hash[range] if range.cover? query
         end
 
       when Regexp
@@ -110,10 +109,9 @@ module Hashie
     private
 
     def optimize_if_necessary!
-      if (@lookups += 1) >= @optimize_every
-        @regexes = @regex_counts.sort_by { |_, count| -count }.map { |regex, _| regex }
-        @lookups = 0
-      end
+      return unless (@lookups += 1) >= @optimize_every
+      @regexes = @regex_counts.sort_by { |_, count| -count }.map { |regex, _| regex }
+      @lookups = 0
     end
   end
 end

data/lib/hashie/version.rb

@@ -1,3 +1,3 @@
 module Hashie
-  VERSION = '3.1.0'
+  VERSION = '3.2.0'
 end

data/spec/hashie/extensions/coercion_spec.rb

@@ -50,6 +50,48 @@ describe Hashie::Extensions::Coercion do
       expect(instance[:bar]).to be_coerced
     end
 
+    it 'supports coercion for Array' do
+      subject.coerce_key :foo, Array[Coercable]
+
+      instance[:foo] = %w('bar', 'bar2')
+      expect(instance[:foo]).to all(be_coerced)
+      expect(instance[:foo]).to be_a(Array)
+    end
+
+    it 'supports coercion for Set' do
+      subject.coerce_key :foo, Set[Coercable]
+
+      instance[:foo] = Set.new(%w('bar', 'bar2'))
+      expect(instance[:foo]).to all(be_coerced)
+      expect(instance[:foo]).to be_a(Set)
+    end
+
+    it 'supports coercion for Set of primitive' do
+      subject.coerce_key :foo, Set[Initializable]
+
+      instance[:foo] = %w('bar', 'bar2')
+      expect(instance[:foo].map(&:value)).to all(eq 'String')
+      expect(instance[:foo]).to be_none { |v| v.coerced? }
+      expect(instance[:foo]).to be_a(Set)
+    end
+
+    it 'supports coercion for Hash' do
+      subject.coerce_key :foo, Hash[Coercable => Coercable]
+
+      instance[:foo] = { 'bar_key' => 'bar_value', 'bar2_key' => 'bar2_value' }
+      expect(instance[:foo].keys).to all(be_coerced)
+      expect(instance[:foo].values).to all(be_coerced)
+      expect(instance[:foo]).to be_a(Hash)
+    end
+
+    it 'supports coercion for Hash with primitive as value' do
+      subject.coerce_key :foo, Hash[Coercable => Initializable]
+
+      instance[:foo] = { 'bar_key' => '1', 'bar2_key' => '2' }
+      expect(instance[:foo].values.map(&:value)).to all(eq 'String')
+      expect(instance[:foo].keys).to all(be_coerced)
+    end
+
     it 'calls #new if no coerce method is available' do
       subject.coerce_key :foo, Initializable
 
@@ -114,6 +156,55 @@ describe Hashie::Extensions::Coercion do
         expect(tweet[:user]).to be_a(UserMash)
       end
     end
+
+    context 'when used with a Trash' do
+      class UserTrash < Hashie::Trash
+        property :email
+      end
+      class TweetTrash < Hashie::Trash
+        include Hashie::Extensions::Coercion
+
+        property :user, from: :user_data
+        coerce_key :user, UserTrash
+      end
+
+      it 'coerces with instance initialization' do
+        tweet = TweetTrash.new(user_data: { email: 'foo@bar.com' })
+        expect(tweet[:user]).to be_a(UserTrash)
+      end
+    end
+
+    context 'when used with IndifferentAccess to coerce a Mash' do
+      class MyHash < Hash
+        include Hashie::Extensions::Coercion
+        include Hashie::Extensions::IndifferentAccess
+        include Hashie::Extensions::MergeInitializer
+      end
+
+      class UserHash < MyHash
+      end
+
+      class TweetHash < MyHash
+        coerce_key :user, UserHash
+      end
+
+      it 'coerces with instance initialization' do
+        tweet = TweetHash.new(user: Hashie::Mash.new(email: 'foo@bar.com'))
+        expect(tweet[:user]).to be_a(UserHash)
+      end
+
+      it 'coerces when setting with string index' do
+        tweet = TweetHash.new
+        tweet['user'] = Hashie::Mash.new(email: 'foo@bar.com')
+        expect(tweet[:user]).to be_a(UserHash)
+      end
+
+      it 'coerces when setting with symbol index' do
+        tweet = TweetHash.new
+        tweet[:user] = Hashie::Mash.new(email: 'foo@bar.com')
+        expect(tweet[:user]).to be_a(UserHash)
+      end
+    end
   end
 
   describe '#coerce_value' do

data/spec/hashie/extensions/indifferent_access_with_rails_hwia_spec.rb

@@ -0,0 +1,177 @@
+# This set of tests verifies that Hashie::Extensions::IndifferentAccess works with
+# ActiveSupport HashWithIndifferentAccess hashes. See #164 and #166 for details.
+
+require 'spec_helper'
+require 'active_support/hash_with_indifferent_access'
+
+describe Hashie::Extensions::IndifferentAccess do
+  class IndifferentHashWithMergeInitializer < Hash
+    include Hashie::Extensions::MergeInitializer
+    include Hashie::Extensions::IndifferentAccess
+
+    class << self
+      alias_method :build, :new
+    end
+  end
+
+  class IndifferentHashWithArrayInitializer < Hash
+    include Hashie::Extensions::IndifferentAccess
+
+    class << self
+      alias_method :build, :[]
+    end
+  end
+
+  class IndifferentHashWithTryConvertInitializer < Hash
+    include Hashie::Extensions::IndifferentAccess
+
+    class << self
+      alias_method :build, :try_convert
+    end
+  end
+
+  shared_examples_for 'hash with indifferent access' do
+    it 'is able to access via string or symbol' do
+      indifferent_hash = ActiveSupport::HashWithIndifferentAccess.new(abc: 123)
+      h = subject.build(indifferent_hash)
+      expect(h[:abc]).to eq 123
+      expect(h['abc']).to eq 123
+    end
+
+    describe '#values_at' do
+      it 'indifferently finds values' do
+        indifferent_hash = ActiveSupport::HashWithIndifferentAccess.new(
+          :foo => 'bar', 'baz' => 'qux'
+        )
+        h = subject.build(indifferent_hash)
+        expect(h.values_at('foo', :baz)).to eq %w(bar qux)
+      end
+    end
+
+    describe '#fetch' do
+      it 'works like normal fetch, but indifferent' do
+        indifferent_hash = ActiveSupport::HashWithIndifferentAccess.new(foo: 'bar')
+        h = subject.build(indifferent_hash)
+        expect(h.fetch(:foo)).to eq h.fetch('foo')
+        expect(h.fetch(:foo)).to eq 'bar'
+      end
+    end
+
+    describe '#delete' do
+      it 'deletes indifferently' do
+        indifferent_hash = ActiveSupport::HashWithIndifferentAccess.new(
+          :foo => 'bar',
+          'baz' => 'qux'
+        )
+        h = subject.build(indifferent_hash)
+        h.delete('foo')
+        h.delete(:baz)
+        expect(h).to be_empty
+      end
+    end
+
+    describe '#key?' do
+      let(:h) do
+        indifferent_hash = ActiveSupport::HashWithIndifferentAccess.new(foo: 'bar')
+        subject.build(indifferent_hash)
+      end
+
+      it 'finds it indifferently' do
+        expect(h).to be_key(:foo)
+        expect(h).to be_key('foo')
+      end
+
+      %w(include? member? has_key?).each do |key_alias|
+        it "is aliased as #{key_alias}" do
+          expect(h.send(key_alias.to_sym, :foo)).to be(true)
+          expect(h.send(key_alias.to_sym, 'foo')).to be(true)
+        end
+      end
+    end
+
+    describe '#update' do
+      let(:h) do
+        indifferent_hash = ActiveSupport::HashWithIndifferentAccess.new(foo: 'bar')
+        subject.build(indifferent_hash)
+      end
+
+      it 'allows keys to be indifferent still' do
+        h.update(baz: 'qux')
+        expect(h['foo']).to eq 'bar'
+        expect(h['baz']).to eq 'qux'
+      end
+
+      it 'recursively injects indifference into sub-hashes' do
+        h.update(baz: { qux: 'abc' })
+        expect(h['baz']['qux']).to eq 'abc'
+      end
+
+      it 'does not change the ancestors of the injected object class' do
+        h.update(baz: { qux: 'abc' })
+        expect(Hash.new).not_to be_respond_to(:indifferent_access?)
+      end
+    end
+
+    describe '#replace' do
+      let(:h) do
+        indifferent_hash = ActiveSupport::HashWithIndifferentAccess.new(foo: 'bar')
+        subject.build(indifferent_hash).replace(bar: 'baz', hi: 'bye')
+      end
+
+      it 'returns self' do
+        expect(h).to be_a(subject)
+      end
+
+      it 'removes old keys' do
+        [:foo, 'foo'].each do |k|
+          expect(h[k]).to be_nil
+          expect(h.key?(k)).to be_falsy
+        end
+      end
+
+      it 'creates new keys with indifferent access' do
+        [:bar, 'bar', :hi, 'hi'].each { |k| expect(h.key?(k)).to be_truthy }
+        expect(h[:bar]).to eq 'baz'
+        expect(h['bar']).to eq 'baz'
+        expect(h[:hi]).to eq 'bye'
+        expect(h['hi']).to eq 'bye'
+      end
+    end
+
+    describe '#try_convert' do
+      describe 'with conversion' do
+        let(:h) do
+          indifferent_hash = ActiveSupport::HashWithIndifferentAccess.new(foo: 'bar')
+          subject.try_convert(indifferent_hash)
+        end
+
+        it 'is a subject' do
+          expect(h).to be_a(subject)
+        end
+      end
+
+      describe 'without conversion' do
+        let(:h) { subject.try_convert('{ :foo => bar }') }
+
+        it 'is nil' do
+          expect(h).to be_nil
+        end
+      end
+    end
+  end
+
+  describe 'with merge initializer' do
+    subject { IndifferentHashWithMergeInitializer }
+    it_should_behave_like 'hash with indifferent access'
+  end
+
+  describe 'with array initializer' do
+    subject { IndifferentHashWithArrayInitializer }
+    it_should_behave_like 'hash with indifferent access'
+  end
+
+  describe 'with try convert initializer' do
+    subject { IndifferentHashWithTryConvertInitializer }
+    it_should_behave_like 'hash with indifferent access'
+  end
+end

data/spec/hashie/hash_spec.rb

@@ -13,10 +13,10 @@ describe Hash do
     expect(hash).to eq Hashie::Hash['a' => 'hey', '123' => 'bob']
   end
 
-  it '#stringify_keys! turns all keys into strings non-recursively' do
+  it '#stringify_keys! turns all keys into strings recursively' do
     hash = Hashie::Hash[:a => 'hey', 123 => { 345 => 'hey' }]
     hash.stringify_keys!
-    expect(hash).to eq Hashie::Hash['a' => 'hey', '123' => { 345 => 'hey' }]
+    expect(hash).to eq Hashie::Hash['a' => 'hey', '123' => { '345' => 'hey' }]
   end
 
   it '#stringify_keys returns a hash with stringified keys' do

data/spec/hashie/mash_spec.rb

@@ -476,4 +476,27 @@ describe Hashie::Mash do
       expect(hash).to eq Hashie::Hash['a' => 'hey', '123' => { '345' => 'hey' }]
     end
   end
+
+  describe '#values_at' do
+    let(:hash) { { 'key_one' => 1, :key_two => 2 } }
+    let(:mash) { Hashie::Mash.new(hash) }
+
+    context 'when the original type is given' do
+      it 'returns the values' do
+        expect(mash.values_at('key_one', :key_two)).to eq([1, 2])
+      end
+    end
+
+    context 'when a different, but acceptable type is given' do
+      it 'returns the values' do
+        expect(mash.values_at(:key_one, 'key_two')).to eq([1, 2])
+      end
+    end
+
+    context 'when a key is given that is not in the Mash' do
+      it 'returns nil for that value' do
+        expect(mash.values_at('key_one', :key_three)).to eq([1, nil])
+      end
+    end
+  end
 end

data/spec/hashie/rash_spec.rb

@@ -10,7 +10,7 @@ describe Hashie::Rash do
       1       => 'awesome',
       1..1000 => 'rangey',
       /(bcd)/ => proc { |m| m[1] }
-      # /.+/ => "EVERYTHING"
+    # /.+/ => "EVERYTHING"
     )
   end
 
@@ -37,6 +37,12 @@ describe Hashie::Rash do
     expect(subject[1001]).to be_nil
   end
 
+  it 'finds floats from ranges' do
+    expect(subject[10.1]).to eq 'rangey'
+    expect(subject[1.0]).to eq 'rangey'
+    expect(subject[1000.1]).to be_nil
+  end
+
   it 'evaluates proc values' do
     expect(subject['abcdef']).to eq 'bcd'
     expect(subject['ffffff']).to be_nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hashie
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.2.0
 platform: ruby
 authors:
 - Michael Bleigh
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-25 00:00:00.000000000 Z
+date: 2014-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -89,6 +89,7 @@ files:
 - spec/hashie/extensions/deep_merge_spec.rb
 - spec/hashie/extensions/ignore_undeclared_spec.rb
 - spec/hashie/extensions/indifferent_access_spec.rb
+- spec/hashie/extensions/indifferent_access_with_rails_hwia_spec.rb
 - spec/hashie/extensions/key_conversion_spec.rb
 - spec/hashie/extensions/merge_initializer_spec.rb
 - spec/hashie/extensions/method_access_spec.rb
@@ -118,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.1.11
 signing_key: 
 specification_version: 4
 summary: Your friendly neighborhood hash library.
@@ -131,6 +132,7 @@ test_files:
 - spec/hashie/extensions/deep_merge_spec.rb
 - spec/hashie/extensions/ignore_undeclared_spec.rb
 - spec/hashie/extensions/indifferent_access_spec.rb
+- spec/hashie/extensions/indifferent_access_with_rails_hwia_spec.rb
 - spec/hashie/extensions/key_conversion_spec.rb
 - spec/hashie/extensions/merge_initializer_spec.rb
 - spec/hashie/extensions/method_access_spec.rb