hashie 3.4.0 → 3.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea2ab0de9a0b73bb6f212ed67075c27c287bd4dc
-  data.tar.gz: 25fd352d7cf79e9b45aca7f00c1ee399d50b42a8
+  metadata.gz: baf45b7b9cc1092c508f33cb545eb5abeb80fbb1
+  data.tar.gz: a4ec3c9ca8c979fdaf484ecdcf3afc61c7f024ed
 SHA512:
-  metadata.gz: e2c88e593d475002121b7f5129b03f3675d23f09d06d2b828595f4e7c2e67b08a1d8ebcaf37e15539744e53f83ff932e25e45239c0375e82098608f57cbbe663
-  data.tar.gz: 5531b32d1b26fee4d63a41db2b96ceabc53821e783af229131fc78f3746362577c690997c3789b7f682ca42cde6c0280efe22f48145f2c63f9969e81ca48ab2f
+  metadata.gz: 0fccd3accf920a79b1f0085cf12a3d6c6b972338b153c296af295f5462fa56a15e18b5a0bebd950861a26fac4160e60b830ca66c15edcfcd1a7717b426c8c4c3
+  data.tar.gz: a68c79809154aeab6320943e7239a441ca62f328936e774b5b4219c9a68764481f4251a91586a4d88764ed6b23b41870d58dc1ca33b52003bff559aa0f319965

data/CHANGELOG.md

@@ -1,22 +1,24 @@
-## Next Release
+## 3.4.1
 
-* Your contribution here
+* [#269](https://github.com/intridea/hashie/pull/272): Added Hashie::Extensions::DeepLocate - [@msievers](https://github.com/msievers).
+* [#270](https://github.com/intridea/hashie/pull/277): Fixed ArgumentError raised when using IndifferentAccess and HashWithIndifferentAccess - [@gardenofwine](https://github.com/gardenofwine).
+* [#281](https://github.com/intridea/hashie/pull/281): Added #reverse_merge to Mash to override ActiveSupport's version - [@mgold](https://github.com/mgold).
+* [#282](https://github.com/intridea/hashie/pull/282): Fixed coercions in a subclass accumulating in the superclass - [@maxlinc](https://github.com/maxlinc), [@martinstreicher](https://github.com/martinstreicher).
 
-## 3.4.0 (02/02/2014)
+## 3.4.0 (02/02/2015)
 
 * [#271](https://github.com/intridea/hashie/pull/271): Added ability to define defaults based on current hash - [@gregory](https://github.com/gregory).
 * [#247](https://github.com/intridea/hashie/pull/247): Fixed #stringify_keys and #symbolize_keys collision with ActiveSupport - [@bartoszkopinski](https://github.com/bartoszkopinski).
 * [#249](https://github.com/intridea/hashie/pull/249): SafeAssignment will now also protect hash-style assignments - [@jrochkind](https://github.com/jrochkind).
 * [#251](https://github.com/intridea/hashie/pull/251): Added block support to indifferent access #fetch - [@jgraichen](https://github.com/jgraichen).
-* [#252](https://github.com/intridia/hashie/pull/252): Added support for conditionally required Hashie::Dash attributes - [@ccashwell](https://github.com/ccashwell).
-* [#256](https://github.com/intridia/hashie/pull/256): Inherit key coercions - [@Erol](https://github.com/Erol).
-* [#259](https://github.com/intridia/hashie/pull/259): Fixed handling of default proc values in Mash - [@Erol](https://github.com/Erol).
-* [#260](https://github.com/intridia/hashie/pull/260): Added block support to Extensions::DeepMerge - [@galathius](https://github.com/galathius).
+* [#252](https://github.com/intridea/hashie/pull/252): Added support for conditionally required Hashie::Dash attributes - [@ccashwell](https://github.com/ccashwell).
+* [#256](https://github.com/intridea/hashie/pull/256): Inherit key coercions - [@Erol](https://github.com/Erol).
+* [#259](https://github.com/intridea/hashie/pull/259): Fixed handling of default proc values in Mash - [@Erol](https://github.com/Erol).
+* [#260](https://github.com/intridea/hashie/pull/260): Added block support to Extensions::DeepMerge - [@galathius](https://github.com/galathius).
 * [#254](https://github.com/intridea/hashie/pull/254): Added public utility methods for stringify and symbolize keys - [@maxlinc](https://github.com/maxlinc).
-* [#261](https://github.com/intridea/hashie/pull/261): Fixed bug where Dash.property modifies argument object - [@d_tw](https://github.com/d_tw).
+* [#261](https://github.com/intridea/hashie/pull/261): Fixed bug where Dash.property modifies argument object - [@d-tw](https://github.com/d-tw).
 * [#264](https://github.com/intridea/hashie/pull/264): Methods such as abc? return true/false with Hashie::Extensions::MethodReader - [@Zloy](https://github.com/Zloy).
 * [#269](https://github.com/intridea/hashie/pull/269): Add #extractable_options? so ActiveSupport Array#extract_options! can extract it - [@ridiculous](https://github.com/ridiculous).
-* Your contribution here.
 
 ## 3.3.2 (11/26/2014)
 

data/README.md

@@ -1,5 +1,7 @@
 # Hashie
 
+[![Join the chat at https://gitter.im/intridea/hashie](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/intridea/hashie?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
 [![Gem Version](http://img.shields.io/gem/v/hashie.svg)](http://badge.fury.io/rb/hashie)
 [![Build Status](http://img.shields.io/travis/intridea/hashie.svg)](https://travis-ci.org/intridea/hashie)
 [![Dependency Status](https://gemnasium.com/intridea/hashie.svg)](https://gemnasium.com/intridea/hashie)
@@ -313,6 +315,48 @@ user.deep_find_all(:name) #=> [{ first: 'Bob', last: 'Boberts' }, 'Rubyists', 'O
 user.deep_select(:name)   #=> [{ first: 'Bob', last: 'Boberts' }, 'Rubyists', 'Open source enthusiasts']
 ```
 
+### DeepLocate
+
+This extension can be mixed in to provide a depth first search based search for enumerables matching a given comparator callable.
+
+It returns all enumerables which contain at least one element, for which the given comparator returns ```true```.
+
+Because the container objects are returned, the result elements can be modified in place. This way, one can perform modifications on deeply nested hashes without the need to know the exact paths.
+
+```ruby
+
+books = [
+  {
+    title: "Ruby for beginners",
+    pages: 120
+  },
+  {
+    title: "CSS for intermediates",
+    pages: 80
+  },
+  {
+    title: "Collection of ruby books",
+    books: [
+      {
+        title: "Ruby for the rest of us",
+        pages: 576
+      }
+    ]
+  }
+]
+
+books.extend(Hashie::Extensions::DeepLocate)
+
+# for ruby 1.9 leave *no* space between the lambda rocket and the braces
+# http://ruby-journal.com/becareful-with-space-in-lambda-hash-rocket-syntax-between-ruby-1-dot-9-and-2-dot-0/
+
+books.deep_locate -> (key, value, object) { key == :title && value.include?("Ruby") }
+# => [{:title=>"Ruby for beginners", :pages=>120}, {:title=>"Ruby for the rest of us", :pages=>576}]
+
+books.deep_locate -> (key, value, object) { key == :pages && value <= 120 }
+# => [{:title=>"Ruby for beginners", :pages=>120}, {:title=>"CSS for intermediates", :pages=>80}]
+```
+
 ## Mash
 
 Mash is an extended Hash that gives simple pseudo-object functionality that can be built from hashes and easily extended. It is intended to give the user easier access to the objects within the Mash through a property-like syntax, while still retaining all Hash functionality.

data/lib/hashie.rb

@@ -22,6 +22,7 @@ module Hashie
     autoload :SymbolizeKeys,     'hashie/extensions/symbolize_keys'
     autoload :DeepFetch,         'hashie/extensions/deep_fetch'
     autoload :DeepFind,          'hashie/extensions/deep_find'
+    autoload :DeepLocate,        'hashie/extensions/deep_locate'
     autoload :PrettyInspect,     'hashie/extensions/pretty_inspect'
     autoload :KeyConversion,     'hashie/extensions/key_conversion'
     autoload :MethodAccessWithOverride, 'hashie/extensions/method_access'

data/lib/hashie/extensions/coercion.rb

@@ -178,7 +178,7 @@ module Hashie
         def inherited(klass)
           super
 
-          klass.key_coercions = key_coercions
+          klass.key_coercions = key_coercions.dup
         end
       end
     end

data/lib/hashie/extensions/deep_find.rb

@@ -27,32 +27,15 @@ module Hashie
       private
 
       def _deep_find(key, object = self)
-        if object.respond_to?(:key?)
-          return object[key] if object.key?(key)
-
-          reduce_to_match(key, object.values)
-        elsif object.is_a?(Enumerable)
-          reduce_to_match(key, object)
-        end
+        _deep_find_all(key, object).first
       end
 
       def _deep_find_all(key, object = self, matches = [])
-        if object.respond_to?(:key?)
-          matches << object[key] if object.key?(key)
-          object.values.each { |v| _deep_find_all(key, v, matches) }
-        elsif object.is_a?(Enumerable)
-          object.each { |v| _deep_find_all(key, v, matches) }
+        deep_locate_result = Hashie::Extensions::DeepLocate.deep_locate(key, object).tap do |result|
+          result.map! { |element| element[key] }
         end
 
-        matches
-      end
-
-      def reduce_to_match(key, enumerable)
-        enumerable.reduce(nil) do |found, value|
-          return found if found
-
-          _deep_find(key, value)
-        end
+        matches.concat(deep_locate_result)
       end
     end
   end

data/lib/hashie/extensions/deep_locate.rb

@@ -0,0 +1,94 @@
+module Hashie
+  module Extensions
+    module DeepLocate
+      # The module level implementation of #deep_locate, incase you do not want
+      # to include/extend the base datastructure. For further examples please
+      # see #deep_locate.
+      #
+      # @example
+      #   books = [
+      #     {
+      #       title: "Ruby for beginners",
+      #       pages: 120
+      #     },
+      #     ...
+      #   ]
+      #
+      #   Hashie::Extensions::DeepLocate.deep_locate -> (key, value, object) { key == :title }, books
+      #   # => [{:title=>"Ruby for beginners", :pages=>120}, ...]
+      def self.deep_locate(comparator, object)
+        # ensure comparator is a callable
+        unless comparator.respond_to?(:call)
+          comparator = lambda do |non_callable_object|
+            ->(key, _, _) { key == non_callable_object }
+          end.call(comparator)
+        end
+
+        _deep_locate(comparator, object)
+      end
+
+      # Performs a depth-first search on deeply nested data structures for a
+      # given comparator callable and returns each Enumerable, for which the
+      # callable returns true for at least one the its elements.
+      #
+      # @example
+      #   books = [
+      #     {
+      #       title: "Ruby for beginners",
+      #       pages: 120
+      #     },
+      #     {
+      #       title: "CSS for intermediates",
+      #       pages: 80
+      #     },
+      #     {
+      #       title: "Collection of ruby books",
+      #       books: [
+      #         {
+      #           title: "Ruby for the rest of us",
+      #           pages: 576
+      #         }
+      #       ]
+      #     }
+      #   ]
+      #
+      #   books.extend(Hashie::Extensions::DeepLocate)
+      #
+      #   # for ruby 1.9 leave *no* space between the lambda rocket and the braces
+      #   # http://ruby-journal.com/becareful-with-space-in-lambda-hash-rocket-syntax-between-ruby-1-dot-9-and-2-dot-0/
+      #
+      #   books.deep_locate -> (key, value, object) { key == :title && value.include?("Ruby") }
+      #   # => [{:title=>"Ruby for beginners", :pages=>120}, {:title=>"Ruby for the rest of us", :pages=>576}]
+      #
+      #   books.deep_locate -> (key, value, object) { key == :pages && value <= 120 }
+      #   # => [{:title=>"Ruby for beginners", :pages=>120}, {:title=>"CSS for intermediates", :pages=>80}]
+      def deep_locate(comparator)
+        Hashie::Extensions::DeepLocate.deep_locate(comparator, self)
+      end
+
+      private
+
+      def self._deep_locate(comparator, object, result = [])
+        if object.is_a?(::Enumerable)
+          if object.any? do |value|
+            if object.is_a?(::Hash)
+              key, value = value
+            else
+              key = nil
+            end
+
+            comparator.call(key, value, object)
+          end
+            result.push object
+          else
+            (object.respond_to?(:values) ? object.values : object.entries).each do |value|
+              _deep_locate(comparator, value, result)
+            end
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/hashie/extensions/indifferent_access.rb

@@ -76,16 +76,16 @@ module Hashie
       # is injecting itself into member hashes.
       def convert!
         keys.each do |k|
-          regular_writer convert_key(k), convert_value(regular_delete(k))
+          regular_writer convert_key(k), indifferent_value(regular_delete(k))
         end
         self
       end
 
-      def convert_value(value)
+      def indifferent_value(value)
         if hash_lacking_indifference?(value)
           IndifferentAccess.inject!(value)
         elsif value.is_a?(::Array)
-          value.replace(value.map { |e| convert_value(e) })
+          value.replace(value.map { |e| indifferent_value(e) })
         else
           value
         end
@@ -104,7 +104,7 @@ module Hashie
       end
 
       def indifferent_writer(key, value)
-        regular_writer convert_key(key), convert_value(value)
+        regular_writer convert_key(key), indifferent_value(value)
       end
 
       def indifferent_fetch(key, *args, &block)

data/lib/hashie/mash.rb

@@ -255,6 +255,11 @@ module Hashie
       true
     end
 
+    # another ActiveSupport method, see issue #270
+    def reverse_merge(other_hash)
+      Hashie::Mash.new(other_hash).merge(self)
+    end
+
     protected
 
     def method_suffix(method_name)

data/lib/hashie/version.rb

@@ -1,3 +1,3 @@
 module Hashie
-  VERSION = '3.4.0'
+  VERSION = '3.4.1'
 end

data/spec/hashie/extensions/coercion_spec.rb

@@ -47,8 +47,13 @@ describe Hashie::Extensions::Coercion do
         coerce_key :bar, Integer
       end
 
+      class OtherNestedCoercableHash < BaseCoercableHash
+        coerce_key :foo, Symbol
+      end
+
       class RootCoercableHash < BaseCoercableHash
         coerce_key :nested, NestedCoercableHash
+        coerce_key :other, OtherNestedCoercableHash
         coerce_key :nested_list, Array[NestedCoercableHash]
         coerce_key :nested_hash, Hash[String => NestedCoercableHash]
       end
@@ -62,6 +67,13 @@ describe Hashie::Extensions::Coercion do
       subject { RootCoercableHash }
       let(:instance) { subject.new }
 
+      it 'does not add coercions to superclass' do
+        instance[:nested] = { foo: 'bar' }
+        instance[:other]  = { foo: 'bar' }
+        expect(instance[:nested][:foo]).to be_a String
+        expect(instance[:other][:foo]).to be_a Symbol
+      end
+
       it 'coerces nested objects' do
         instance[:nested] = { foo: 123, bar: '456' }
         test_nested_object(instance[:nested])
@@ -406,17 +418,23 @@ describe Hashie::Extensions::Coercion do
     end
 
     context 'when subclassing' do
-      class MyHash < Hash
+      class MyOwnBase < Hash
         include Hashie::Extensions::Coercion
+      end
 
+      class MyOwnHash < MyOwnBase
         coerce_key :value, Integer
       end
 
-      class MySubclass < MyHash
+      class MyOwnSubclass < MyOwnHash
       end
 
       it 'inherits key coercions' do
-        expect(MyHash.key_coercions).to eql(MySubclass.key_coercions)
+        expect(MyOwnHash.key_coercions).to eql(MyOwnSubclass.key_coercions)
+      end
+
+      it 'the superclass does not accumulate coerced attributes from subclasses' do
+        expect(MyOwnBase.key_coercions).to eq({})
       end
     end
   end

data/spec/hashie/extensions/deep_locate_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe Hashie::Extensions::DeepLocate do
+  let(:hash) do
+    {
+      from: 0,
+      size: 25,
+      query: {
+        bool: {
+          must: [
+            {
+              query_string: {
+                query: 'foobar',
+                default_operator: 'AND',
+                fields: [
+                  'title^2',
+                  '_all'
+                ]
+              }
+            },
+            {
+              match: {
+                field_1: 'value_1'
+              }
+            },
+            {
+              range: {
+                lsr09: {
+                  gte: 2014
+                }
+              }
+            }
+          ],
+          should: [
+            {
+              match: {
+                field_2: 'value_2'
+              }
+            }
+          ],
+          must_not: [
+            {
+              range: {
+                lsr10: {
+                  gte: 2014
+                }
+              }
+            }
+          ]
+        }
+      }
+    }
+  end
+
+  describe '.deep_locate' do
+    context 'if called with a non-callable comparator' do
+      it 'creates a key comparator on-th-fly' do
+        expect(described_class.deep_locate(:lsr10, hash)).to eq([hash[:query][:bool][:must_not][0][:range]])
+      end
+    end
+
+    it 'locates enumerables for which the given comparator returns true for at least one element' do
+      examples = [
+        [
+          ->(key, _value, _object) { key == :fields },
+          [
+            hash[:query][:bool][:must].first[:query_string]
+          ]
+        ],
+        [
+          ->(_key, value, _object) { value.is_a?(String) && value.include?('value') },
+          [
+            hash[:query][:bool][:must][1][:match],
+            hash[:query][:bool][:should][0][:match]
+          ]
+        ],
+        [
+          lambda do |_key, _value, object|
+            object.is_a?(Array) &&
+            !object.extend(described_class).deep_locate(:match).empty?
+          end,
+          [
+            hash[:query][:bool][:must],
+            hash[:query][:bool][:should]
+          ]
+        ]
+      ]
+
+      examples.each do |comparator, expected_result|
+        expect(described_class.deep_locate(comparator, hash)).to eq(expected_result)
+      end
+    end
+
+    it 'returns an empty array if nothing was found' do
+      expect(described_class.deep_locate(:muff, foo: 'bar')).to eq([])
+    end
+  end
+
+  context 'if extending an existing object' do
+    let(:extended_hash) do
+      hash.extend(described_class)
+    end
+
+    it 'adds #deep_locate' do
+      expect(extended_hash.deep_locate(:bool)).to eq([hash[:query]])
+    end
+  end
+
+  context 'if included in a hash' do
+    let(:derived_hash_with_extension_included) do
+      Class.new(Hash) do
+        include Hashie::Extensions::DeepLocate
+      end
+    end
+
+    let(:instance) do
+      derived_hash_with_extension_included.new.update(hash)
+    end
+
+    it 'adds #deep_locate' do
+      expect(instance.deep_locate(:bool)).to eq([hash[:query]])
+    end
+  end
+end

data/spec/hashie/extensions/indifferent_access_with_rails_hwia_spec.rb

@@ -1,8 +1,9 @@
 # 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'
+require 'active_support/core_ext/hash'
+require 'spec_helper'
 
 describe Hashie::Extensions::IndifferentAccess do
   class IndifferentHashWithMergeInitializer < Hash
@@ -35,6 +36,10 @@ describe Hashie::Extensions::IndifferentAccess do
     include Hashie::Extensions::MergeInitializer
   end
 
+  class MashWithIndifferentAccess < Hashie::Mash
+    include Hashie::Extensions::IndifferentAccess
+  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)
@@ -193,4 +198,11 @@ describe Hashie::Extensions::IndifferentAccess do
       expect(instance[:foo]).to be_a(ActiveSupport::HashWithIndifferentAccess)
     end
   end
+
+  describe 'Mash with indifferent access' do
+    it 'is able to be created for a deep nested HashWithIndifferentAccess' do
+      indifferent_hash = ActiveSupport::HashWithIndifferentAccess.new(abc: { def: 123 })
+      MashWithIndifferentAccess.new(indifferent_hash)
+    end
+  end
 end

data/spec/hashie/mash_spec.rb

@@ -651,4 +651,17 @@ describe Hashie::Mash do
       expect(args).to eq [101, 'bar']
     end
   end
+
+  describe '#reverse_merge' do
+    subject { described_class.new(a: 1, b: 2) }
+
+    it 'unifies strings and symbols' do
+      expect(subject.reverse_merge(a: 2).length).to eq 2
+      expect(subject.reverse_merge('a' => 2).length).to eq 2
+    end
+
+    it 'does not overwrite values' do
+      expect(subject.reverse_merge(a: 5).a).to eq subject.a
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hashie
 version: !ruby/object:Gem::Version
-  version: 3.4.0
+  version: 3.4.1
 platform: ruby
 authors:
 - Michael Bleigh
@@ -9,34 +9,34 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-03 00:00:00.000000000 Z
+date: 2015-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
 description: Hashie is a collection of classes and mixins that make hashes more powerful.
@@ -47,20 +47,22 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .yardopts
+- ".yardopts"
 - CHANGELOG.md
 - CONTRIBUTING.md
 - LICENSE
 - README.md
-- UPGRADING.md
 - Rakefile
+- UPGRADING.md
 - hashie.gemspec
+- lib/hashie.rb
 - lib/hashie/clash.rb
 - lib/hashie/dash.rb
 - lib/hashie/extensions/coercion.rb
 - lib/hashie/extensions/dash/indifferent_access.rb
 - lib/hashie/extensions/deep_fetch.rb
 - lib/hashie/extensions/deep_find.rb
+- lib/hashie/extensions/deep_locate.rb
 - lib/hashie/extensions/deep_merge.rb
 - lib/hashie/extensions/ignore_undeclared.rb
 - lib/hashie/extensions/indifferent_access.rb
@@ -77,7 +79,6 @@ files:
 - lib/hashie/rash.rb
 - lib/hashie/trash.rb
 - lib/hashie/version.rb
-- lib/hashie.rb
 - spec/hashie/clash_spec.rb
 - spec/hashie/dash_spec.rb
 - spec/hashie/extensions/autoload_spec.rb
@@ -85,6 +86,7 @@ files:
 - spec/hashie/extensions/dash/indifferent_access_spec.rb
 - spec/hashie/extensions/deep_fetch_spec.rb
 - spec/hashie/extensions/deep_find_spec.rb
+- spec/hashie/extensions/deep_locate_spec.rb
 - spec/hashie/extensions/deep_merge_spec.rb
 - spec/hashie/extensions/ignore_undeclared_spec.rb
 - spec/hashie/extensions/indifferent_access_spec.rb
@@ -113,17 +115,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Your friendly neighborhood hash library.
@@ -135,6 +137,7 @@ test_files:
 - spec/hashie/extensions/dash/indifferent_access_spec.rb
 - spec/hashie/extensions/deep_fetch_spec.rb
 - spec/hashie/extensions/deep_find_spec.rb
+- spec/hashie/extensions/deep_locate_spec.rb
 - spec/hashie/extensions/deep_merge_spec.rb
 - spec/hashie/extensions/ignore_undeclared_spec.rb
 - spec/hashie/extensions/indifferent_access_spec.rb