Merge pull request #7 from Sage/feature_indifferent_bug_fix

added bugfix to indifferent! method

Author: vaughanbrittonsage

lib/hash_kit/helper.rb

@@ -3,6 +3,10 @@ class Helper
 
     #This method is called to make a hash allow indifferent access (it will accept both strings & symbols for a valid key).
     def indifferent!(hash)
+      unless hash.is_a?(Hash)
+        return
+      end
+
       #set the default proc to allow the key to be either string or symbol if a matching key is found.
       hash.default_proc = proc do |h, k|
         if h.key?(k.to_s)
@@ -16,14 +20,32 @@ def indifferent!(hash)
 
       #recursively process any child hashes
       hash.each do |key,value|
-        if hash[key] != nil && hash[key].is_a?(Hash)
-          indifferent(hash[key])
+        if hash[key] != nil
+          if hash[key].is_a?(Hash)
+            indifferent!(hash[key])
+          elsif hash[key].is_a?(Array)
+            indifferent_array!(hash[key])
+          end
         end
       end
 
       hash
     end
 
+    def indifferent_array!(array)
+      unless array.is_a?(Array)
+        return
+      end
+
+      array.each do |i|
+        if i.is_a?(Hash)
+          indifferent!(i)
+        elsif i.is_a?(Array)
+          indifferent_array!(i)
+        end
+      end
+    end
+
     #This method is called to convert all the keys of a hash into symbols to allow consistent usage of hashes within your Ruby application.
     def symbolize(hash)
       {}.tap do |h|

spec/hash_kit/helper_spec.rb

@@ -335,16 +335,34 @@
     let(:hash) do
       {
           'key1' => 'value1',
-          key2: 'value2'
+          key2: 'value2',
+          key3: [
+              {
+                  key4: 'value4',
+                  'key5' => 'value5'
+              }
+          ],
+          key6: {
+              key7: 'value7',
+              'key8' => 'value8'
+          }
       }
     end
     it 'should allow access to a string key from a symbol' do
       subject.indifferent!(hash)
-      expect(hash[:key1]).to eq hash['key1']
+      expect(hash[:key1]).to eq 'value1'
     end
     it 'should allow access to a symbol key from a string' do
       subject.indifferent!(hash)
-      expect(hash['key2']).to eq hash[:key2]
+      expect(hash['key2']).to eq 'value2'
+    end
+    it 'should allow indifferent access to a key within an array' do
+      subject.indifferent!(hash)
+      expect(hash[:key3][0]['key4']).to eq 'value4'
+    end
+    it 'should allow indifferent access to a key within an nested hash' do
+      subject.indifferent!(hash)
+      expect(hash[:key6]['key7']).to eq 'value7'
     end
   end
 end