hashie 2.0.5 → 2.1.0

data/spec/hashie/extensions/deep_fetch_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+module Hashie
+  module Extensions
+    describe DeepFetch do
+      subject { Class.new(Hash) { include Hashie::Extensions::DeepFetch } }
+      let(:hash) do
+        {
+          library: {
+            books: [
+              { title: 'Call of the Wild' },
+              { title: 'Moby Dick' }
+            ],
+            location: {
+              address: '123 Library St.'
+            }
+          }
+        }
+      end
+      let(:instance) { subject.new.update(hash) }
+
+      describe '#deep_fetch' do
+        it 'extracts a value from a nested hash' do
+          instance.deep_fetch(:library, :location, :address).should eq('123 Library St.')
+        end
+
+        it 'extracts a value from a nested array' do
+          instance.deep_fetch(:library, :books, 1, :title).should eq('Moby Dick')
+        end
+
+        context 'when one of the keys is not present' do
+          context 'when a block is provided' do
+            it 'returns the value of the block' do
+              value = instance.deep_fetch(:library, :unknown_key, :location) { 'block value' }
+              value.should eq('block value')
+            end
+          end
+
+          context 'when a block is not provided' do
+            context 'when the nested object is an array' do
+              it 'raises an UndefinedPathError' do
+                lambda do
+                  instance.deep_fetch(:library, :books, 2)
+                end.should(
+                  raise_error(
+                    DeepFetch::UndefinedPathError,
+                    'Could not fetch path (library > books > 2) at 2'
+                  )
+                )
+              end
+            end
+
+            context 'when the nested object is a hash' do
+              it 'raises a UndefinedPathError' do
+                lambda do
+                  instance.deep_fetch(:library, :location, :unknown_key)
+                end.should(
+                  raise_error(
+                    DeepFetch::UndefinedPathError,
+                    'Could not fetch path (library > location > unknown_key) at unknown_key'
+                  )
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/hashie/extensions/deep_merge_spec.rb

@@ -1,20 +1,22 @@
 require 'spec_helper'
 
 describe Hashie::Extensions::DeepMerge do
-  class DeepMergeHash < Hash; include Hashie::Extensions::DeepMerge end
+  class DeepMergeHash < Hash
+    include Hashie::Extensions::DeepMerge
+  end
 
-  subject{ DeepMergeHash }
+  subject { DeepMergeHash }
 
-  let(:h1) { subject.new.merge(:a => "a", :b => "b", :c => { :c1 => "c1", :c2 => "c2", :c3 => { :d1 => "d1" } }) }
-  let(:h2) { { :a => 1, :c => { :c1 => 2, :c3 => { :d2 => "d2" } } } }
-  let(:expected_hash) { { :a => 1, :b => "b", :c => { :c1 => 2, :c2 => "c2", :c3 => { :d1 => "d1", :d2 => "d2" } } } }
+  let(:h1) { subject.new.merge(a: 'a', a1: 42, b: 'b', c: { c1: 'c1', c2: { a: 'b' }, c3: { d1: 'd1' } }) }
+  let(:h2) { { a: 1, a1: 1, c: { c1: 2, c2: 'c2', c3: { d2: 'd2' } } } }
+  let(:expected_hash) { { a: 1, a1: 1, b: 'b', c: { c1: 2, c2: 'c2', c3: { d1: 'd1', d2: 'd2' } } } }
 
-  it 'should deep merge two hashes' do
-    h1.deep_merge(h2).should == expected_hash
+  it 'deep merges two hashes' do
+    h1.deep_merge(h2).should eq expected_hash
   end
 
-  it 'should deep merge two hashes with bang method' do
+  it 'deep merges another hash in place via bang method' do
     h1.deep_merge!(h2)
-    h1.should == expected_hash
+    h1.should eq expected_hash
   end
 end

data/spec/hashie/extensions/ignore_undeclared_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Hashie::Extensions::IgnoreUndeclared do
+  class ForgivingTrash < Hashie::Trash
+    include Hashie::Extensions::IgnoreUndeclared
+    property :city
+    property :state, from: :provence
+  end
+
+  subject { ForgivingTrash }
+
+  it 'silently ignores undeclared properties on initialization' do
+    expect { subject.new(city: 'Toronto', provence: 'ON', country: 'Canada') }.to_not raise_error
+  end
+
+  it 'works with translated properties (with symbol keys)' do
+    expect(subject.new(provence: 'Ontario').state).to eq('Ontario')
+  end
+
+  it 'works with translated properties (with string keys)' do
+    expect(subject.new(provence: 'Ontario').state).to eq('Ontario')
+  end
+end

data/spec/hashie/extensions/indifferent_access_spec.rb

@@ -1,99 +1,152 @@
 require 'spec_helper'
 
 describe Hashie::Extensions::IndifferentAccess do
-  class IndifferentHash < Hash
+  class IndifferentHashWithMergeInitializer < Hash
     include Hashie::Extensions::MergeInitializer
     include Hashie::Extensions::IndifferentAccess
-  end
-  subject{ IndifferentHash }
-
-  it 'should be able to access via string or symbol' do
-    h = subject.new(:abc => 123)
-    h[:abc].should == 123
-    h['abc'].should == 123
-  end
 
-  describe '#values_at' do
-    it 'should indifferently find values' do
-      h = subject.new(:foo => 'bar', 'baz' => 'qux')
-      h.values_at('foo', :baz).should == %w(bar qux)
+    class << self
+      alias_method :build, :new
     end
   end
 
-  describe '#fetch' do
-    it 'should work like normal fetch, but indifferent' do
-      h = subject.new(:foo => 'bar')
-      h.fetch(:foo).should == h.fetch('foo')
-      h.fetch(:foo).should == 'bar'
+  class IndifferentHashWithArrayInitializer < Hash
+    include Hashie::Extensions::IndifferentAccess
+
+    class << self
+      alias_method :build, :[]
     end
   end
 
-  describe '#delete' do
-    it 'should delete indifferently' do
-      h = subject.new(:foo => 'bar', 'baz' => 'qux')
-      h.delete('foo')
-      h.delete(:baz)
-      h.should be_empty
+  class IndifferentHashWithTryConvertInitializer < Hash
+    include Hashie::Extensions::IndifferentAccess
+
+    class << self
+      alias_method :build, :try_convert
     end
   end
 
-  describe '#key?' do
-    let(:h) { subject.new(:foo => 'bar') }
-
-    it 'should find it indifferently' do
-      h.should be_key(:foo)
-      h.should be_key('foo')
+  shared_examples_for 'hash with indifferent access' do
+    it 'is able to access via string or symbol' do
+      h = subject.build(abc: 123)
+      h[:abc].should eq 123
+      h['abc'].should eq 123
     end
 
-    %w(include? member? has_key?).each do |key_alias|
-      it "should be aliased as #{key_alias}" do
-        h.send(key_alias.to_sym, :foo).should be(true)
-        h.send(key_alias.to_sym, 'foo').should be(true)
+    describe '#values_at' do
+      it 'indifferently finds values' do
+        h = subject.build(:foo => 'bar', 'baz' => 'qux')
+        h.values_at('foo', :baz).should eq %w(bar qux)
       end
     end
-  end
 
-  describe '#update' do
-    subject{ IndifferentHash.new(:foo => 'bar') }
-    it 'should allow keys to be indifferent still' do
-      subject.update(:baz => 'qux')
-      subject['foo'].should == 'bar'
-      subject['baz'].should == 'qux'
+    describe '#fetch' do
+      it 'works like normal fetch, but indifferent' do
+        h = subject.build(foo: 'bar')
+        h.fetch(:foo).should eq h.fetch('foo')
+        h.fetch(:foo).should eq 'bar'
+      end
     end
 
-    it 'should recursively inject indifference into sub-hashes' do
-      subject.update(:baz => {:qux => 'abc'})
-      subject['baz']['qux'].should == 'abc'
+    describe '#delete' do
+      it 'deletes indifferently' do
+        h = subject.build(:foo => 'bar', 'baz' => 'qux')
+        h.delete('foo')
+        h.delete(:baz)
+        h.should be_empty
+      end
     end
 
-    it 'should not change the ancestors of the injected object class' do
-      subject.update(:baz => {:qux => 'abc'})
-      Hash.new.should_not be_respond_to(:indifferent_access?)
-    end
-  end
+    describe '#key?' do
+      let(:h) { subject.build(foo: 'bar') }
+
+      it 'finds it indifferently' do
+        h.should be_key(:foo)
+        h.should be_key('foo')
+      end
 
-  describe '#replace' do
-    subject do
-      IndifferentHash.new(:foo => 'bar').replace(:bar => 'baz', :hi => 'bye')
+      %w(include? member? has_key?).each do |key_alias|
+        it "is aliased as #{key_alias}" do
+          h.send(key_alias.to_sym, :foo).should be(true)
+          h.send(key_alias.to_sym, 'foo').should be(true)
+        end
+      end
     end
 
-    it 'returns self' do
-      subject.should be_a(IndifferentHash)
+    describe '#update' do
+      let(:h) { subject.build(foo: 'bar') }
+
+      it 'allows keys to be indifferent still' do
+        h.update(baz: 'qux')
+        h['foo'].should eq 'bar'
+        h['baz'].should eq 'qux'
+      end
+
+      it 'recursively injects indifference into sub-hashes' do
+        h.update(baz: { qux: 'abc' })
+        h['baz']['qux'].should eq 'abc'
+      end
+
+      it 'does not change the ancestors of the injected object class' do
+        h.update(baz: { qux: 'abc' })
+        Hash.new.should_not be_respond_to(:indifferent_access?)
+      end
     end
 
-    it 'should remove old keys' do
-      [:foo, 'foo'].each do |k|
-        subject[k].should be_nil
-        subject.key?(k).should be_false
+    describe '#replace' do
+      let(:h) { subject.build(foo: 'bar').replace(bar: 'baz', hi: 'bye') }
+
+      it 'returns self' do
+        h.should be_a(subject)
+      end
+
+      it 'removes old keys' do
+        [:foo, 'foo'].each do |k|
+          h[k].should be_nil
+          h.key?(k).should be_false
+        end
+      end
+
+      it 'creates new keys with indifferent access' do
+        [:bar, 'bar', :hi, 'hi'].each { |k| h.key?(k).should be_true }
+        h[:bar].should eq 'baz'
+        h['bar'].should eq 'baz'
+        h[:hi].should eq 'bye'
+        h['hi'].should eq 'bye'
       end
     end
 
-    it 'creates new keys with indifferent access' do
-      [:bar, 'bar', :hi, 'hi'].each { |k| subject.key?(k).should be_true }
-      subject[:bar].should  == 'baz'
-      subject['bar'].should == 'baz'
-      subject[:hi].should   == 'bye'
-      subject['hi'].should  == 'bye'
+    describe '#try_convert' do
+      describe 'with conversion' do
+        let(:h) { subject.try_convert(foo: 'bar') }
+
+        it 'is a subject' do
+          h.should be_a(subject)
+        end
+      end
+
+      describe 'without conversion' do
+        let(:h) { subject.try_convert('{ :foo => bar }') }
+
+        it 'is nil' do
+          h.should 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/extensions/key_conversion_spec.rb

@@ -6,97 +6,98 @@ describe Hashie::Extensions::KeyConversion do
     klass.send :include, Hashie::Extensions::KeyConversion
     klass
   end
-  let(:instance){ subject.new }
+
+  let(:instance) { subject.new }
 
   describe '#stringify_keys!' do
-    it 'should convert keys to strings' do
+    it 'converts keys to strings' do
       instance[:abc] = 'abc'
       instance[123] = '123'
       instance.stringify_keys!
-      (instance.keys & %w(abc 123)).size.should == 2
+      (instance.keys & %w(abc 123)).size.should eq 2
     end
 
-    it 'should do deep conversion within nested hashes' do
+    it 'performs deep conversion within nested hashes' do
       instance[:ab] = subject.new
       instance[:ab][:cd] = subject.new
       instance[:ab][:cd][:ef] = 'abcdef'
       instance.stringify_keys!
-      instance.should == {'ab' => {'cd' => {'ef' => 'abcdef'}}}
+      instance.should eq('ab' => { 'cd' => { 'ef' => 'abcdef' } })
     end
 
-    it 'should do deep conversion within nested arrays' do
+    it 'performs deep conversion within nested arrays' do
       instance[:ab] = []
       instance[:ab] << subject.new
       instance[:ab] << subject.new
       instance[:ab][0][:cd] = 'abcd'
       instance[:ab][1][:ef] = 'abef'
       instance.stringify_keys!
-      instance.should == {'ab' => [{'cd' => 'abcd'}, {'ef' => 'abef'}]}
+      instance.should eq('ab' => [{ 'cd' => 'abcd' }, { 'ef' => 'abef' }])
     end
 
-    it 'should return itself' do
-      instance.stringify_keys!.should == instance
+    it 'returns itself' do
+      instance.stringify_keys!.should eq instance
     end
   end
 
   describe '#stringify_keys' do
-    it 'should convert keys to strings' do
+    it 'converts keys to strings' do
       instance[:abc] = 'def'
       copy = instance.stringify_keys
-      copy['abc'].should == 'def'
+      copy['abc'].should eq 'def'
     end
 
-    it 'should not alter the original' do
+    it 'does not alter the original' do
       instance[:abc] = 'def'
       copy = instance.stringify_keys
-      instance.keys.should == [:abc]
-      copy.keys.should == %w(abc)
+      instance.keys.should eq [:abc]
+      copy.keys.should eq %w(abc)
     end
   end
 
   describe '#symbolize_keys!' do
-    it 'should convert keys to symbols' do
+    it 'converts keys to symbols' do
       instance['abc'] = 'abc'
       instance['def'] = 'def'
       instance.symbolize_keys!
-      (instance.keys & [:abc, :def]).size.should == 2
+      (instance.keys & [:abc, :def]).size.should eq 2
     end
 
-    it 'should do deep conversion within nested hashes' do
+    it 'performs deep conversion within nested hashes' do
       instance['ab'] = subject.new
       instance['ab']['cd'] = subject.new
       instance['ab']['cd']['ef'] = 'abcdef'
       instance.symbolize_keys!
-      instance.should == {:ab => {:cd => {:ef => 'abcdef'}}}
+      instance.should eq(ab: { cd: { ef: 'abcdef' } })
     end
 
-    it 'should do deep conversion within nested arrays' do
+    it 'performs deep conversion within nested arrays' do
       instance['ab'] = []
       instance['ab'] << subject.new
       instance['ab'] << subject.new
       instance['ab'][0]['cd'] = 'abcd'
       instance['ab'][1]['ef'] = 'abef'
       instance.symbolize_keys!
-      instance.should == {:ab => [{:cd => 'abcd'}, {:ef => 'abef'}]}
+      instance.should eq(ab: [{ cd: 'abcd' }, { ef: 'abef' }])
     end
 
-    it 'should return itself' do
-      instance.symbolize_keys!.should == instance
+    it 'returns itself' do
+      instance.symbolize_keys!.should eq instance
     end
   end
 
   describe '#symbolize_keys' do
-    it 'should convert keys to symbols' do
+    it 'converts keys to symbols' do
       instance['abc'] = 'def'
       copy = instance.symbolize_keys
-      copy[:abc].should == 'def'
+      copy[:abc].should eq 'def'
     end
 
-    it 'should not alter the original' do
+    it 'does not alter the original' do
       instance['abc'] = 'def'
       copy = instance.symbolize_keys
-      instance.keys.should == ['abc']
-      copy.keys.should == [:abc]
+      instance.keys.should eq ['abc']
+      copy.keys.should eq [:abc]
     end
   end
 end