hashie 2.1.0 → 2.1.1

data/spec/hashie/extensions/indifferent_access_spec.rb

@@ -29,22 +29,22 @@ describe Hashie::Extensions::IndifferentAccess do
   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
+      expect(h[:abc]).to eq 123
+      expect(h['abc']).to eq 123
     end
 
     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)
+        expect(h.values_at('foo', :baz)).to eq %w(bar qux)
       end
     end
 
     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'
+        expect(h.fetch(:foo)).to eq h.fetch('foo')
+        expect(h.fetch(:foo)).to eq 'bar'
       end
     end
 
@@ -53,7 +53,7 @@ describe Hashie::Extensions::IndifferentAccess do
         h = subject.build(:foo => 'bar', 'baz' => 'qux')
         h.delete('foo')
         h.delete(:baz)
-        h.should be_empty
+        expect(h).to be_empty
       end
     end
 
@@ -61,14 +61,14 @@ describe Hashie::Extensions::IndifferentAccess do
       let(:h) { subject.build(foo: 'bar') }
 
       it 'finds it indifferently' do
-        h.should be_key(:foo)
-        h.should be_key('foo')
+        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
-          h.send(key_alias.to_sym, :foo).should be(true)
-          h.send(key_alias.to_sym, 'foo').should be(true)
+          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
@@ -78,18 +78,18 @@ describe Hashie::Extensions::IndifferentAccess do
 
       it 'allows keys to be indifferent still' do
         h.update(baz: 'qux')
-        h['foo'].should eq 'bar'
-        h['baz'].should eq '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' })
-        h['baz']['qux'].should eq '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' })
-        Hash.new.should_not be_respond_to(:indifferent_access?)
+        expect(Hash.new).not_to be_respond_to(:indifferent_access?)
       end
     end
 
@@ -97,22 +97,22 @@ describe Hashie::Extensions::IndifferentAccess do
       let(:h) { subject.build(foo: 'bar').replace(bar: 'baz', hi: 'bye') }
 
       it 'returns self' do
-        h.should be_a(subject)
+        expect(h).to 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
+          expect(h[k]).to be_nil
+          expect(h.key?(k)).to 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'
+        [:bar, 'bar', :hi, 'hi'].each { |k| expect(h.key?(k)).to be_true }
+        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
 
@@ -121,7 +121,7 @@ describe Hashie::Extensions::IndifferentAccess do
         let(:h) { subject.try_convert(foo: 'bar') }
 
         it 'is a subject' do
-          h.should be_a(subject)
+          expect(h).to be_a(subject)
         end
       end
 
@@ -129,7 +129,7 @@ describe Hashie::Extensions::IndifferentAccess do
         let(:h) { subject.try_convert('{ :foo => bar }') }
 
         it 'is nil' do
-          h.should be_nil
+          expect(h).to be_nil
         end
       end
     end

data/spec/hashie/extensions/key_conversion_spec.rb

@@ -14,7 +14,7 @@ describe Hashie::Extensions::KeyConversion do
       instance[:abc] = 'abc'
       instance[123] = '123'
       instance.stringify_keys!
-      (instance.keys & %w(abc 123)).size.should eq 2
+      expect((instance.keys & %w(abc 123)).size).to eq 2
     end
 
     it 'performs deep conversion within nested hashes' do
@@ -22,7 +22,7 @@ describe Hashie::Extensions::KeyConversion do
       instance[:ab][:cd] = subject.new
       instance[:ab][:cd][:ef] = 'abcdef'
       instance.stringify_keys!
-      instance.should eq('ab' => { 'cd' => { 'ef' => 'abcdef' } })
+      expect(instance).to eq('ab' => { 'cd' => { 'ef' => 'abcdef' } })
     end
 
     it 'performs deep conversion within nested arrays' do
@@ -32,11 +32,11 @@ describe Hashie::Extensions::KeyConversion do
       instance[:ab][0][:cd] = 'abcd'
       instance[:ab][1][:ef] = 'abef'
       instance.stringify_keys!
-      instance.should eq('ab' => [{ 'cd' => 'abcd' }, { 'ef' => 'abef' }])
+      expect(instance).to eq('ab' => [{ 'cd' => 'abcd' }, { 'ef' => 'abef' }])
     end
 
     it 'returns itself' do
-      instance.stringify_keys!.should eq instance
+      expect(instance.stringify_keys!).to eq instance
     end
   end
 
@@ -44,14 +44,14 @@ describe Hashie::Extensions::KeyConversion do
     it 'converts keys to strings' do
       instance[:abc] = 'def'
       copy = instance.stringify_keys
-      copy['abc'].should eq 'def'
+      expect(copy['abc']).to eq 'def'
     end
 
     it 'does not alter the original' do
       instance[:abc] = 'def'
       copy = instance.stringify_keys
-      instance.keys.should eq [:abc]
-      copy.keys.should eq %w(abc)
+      expect(instance.keys).to eq [:abc]
+      expect(copy.keys).to eq %w(abc)
     end
   end
 
@@ -60,7 +60,7 @@ describe Hashie::Extensions::KeyConversion do
       instance['abc'] = 'abc'
       instance['def'] = 'def'
       instance.symbolize_keys!
-      (instance.keys & [:abc, :def]).size.should eq 2
+      expect((instance.keys & [:abc, :def]).size).to eq 2
     end
 
     it 'performs deep conversion within nested hashes' do
@@ -68,7 +68,7 @@ describe Hashie::Extensions::KeyConversion do
       instance['ab']['cd'] = subject.new
       instance['ab']['cd']['ef'] = 'abcdef'
       instance.symbolize_keys!
-      instance.should eq(ab: { cd: { ef: 'abcdef' } })
+      expect(instance).to eq(ab: { cd: { ef: 'abcdef' } })
     end
 
     it 'performs deep conversion within nested arrays' do
@@ -78,11 +78,11 @@ describe Hashie::Extensions::KeyConversion do
       instance['ab'][0]['cd'] = 'abcd'
       instance['ab'][1]['ef'] = 'abef'
       instance.symbolize_keys!
-      instance.should eq(ab: [{ cd: 'abcd' }, { ef: 'abef' }])
+      expect(instance).to eq(ab: [{ cd: 'abcd' }, { ef: 'abef' }])
     end
 
     it 'returns itself' do
-      instance.symbolize_keys!.should eq instance
+      expect(instance.symbolize_keys!).to eq instance
     end
   end
 
@@ -90,14 +90,14 @@ describe Hashie::Extensions::KeyConversion do
     it 'converts keys to symbols' do
       instance['abc'] = 'def'
       copy = instance.symbolize_keys
-      copy[:abc].should eq 'def'
+      expect(copy[:abc]).to eq 'def'
     end
 
     it 'does not alter the original' do
       instance['abc'] = 'def'
       copy = instance.symbolize_keys
-      instance.keys.should eq ['abc']
-      copy.keys.should eq [:abc]
+      expect(instance.keys).to eq ['abc']
+      expect(copy.keys).to eq [:abc]
     end
   end
 end

data/spec/hashie/extensions/merge_initializer_spec.rb

@@ -8,16 +8,16 @@ describe Hashie::Extensions::MergeInitializer do
   subject { MergeInitializerHash }
 
   it 'initializes with no arguments' do
-    subject.new.should eq({})
+    expect(subject.new).to eq({})
   end
 
   it 'initializes with a hash' do
-    subject.new(abc: 'def').should eq(abc: 'def')
+    expect(subject.new(abc: 'def')).to eq(abc: 'def')
   end
 
   it 'initializes with a hash and a default' do
     h = subject.new({ abc: 'def' }, 'bar')
-    h[:foo].should eq 'bar'
-    h[:abc].should eq 'def'
+    expect(h[:foo]).to eq 'bar'
+    expect(h[:abc]).to eq 'def'
   end
 end

data/spec/hashie/extensions/method_access_spec.rb

@@ -12,34 +12,34 @@ describe Hashie::Extensions::MethodReader do
   subject { ReaderHash }
 
   it 'reads string keys from the method' do
-    subject.new('awesome' => 'sauce').awesome.should eq 'sauce'
+    expect(subject.new('awesome' => 'sauce').awesome).to eq 'sauce'
   end
 
   it 'reads symbol keys from the method' do
-    subject.new(awesome: 'sauce').awesome.should eq 'sauce'
+    expect(subject.new(awesome: 'sauce').awesome).to eq 'sauce'
   end
 
   it 'reads nil and false values out properly' do
     h = subject.new(nil: nil, false: false)
-    h.nil.should eq nil
-    h.false.should eq false
+    expect(h.nil).to eq nil
+    expect(h.false).to eq false
   end
 
   it 'raises a NoMethodError for undefined keys' do
-    lambda { subject.new.awesome }.should raise_error(NoMethodError)
+    expect { subject.new.awesome }.to raise_error(NoMethodError)
   end
 
   describe '#respond_to?' do
     it 'is true for string keys' do
-      subject.new('awesome' => 'sauce').should be_respond_to(:awesome)
+      expect(subject.new('awesome' => 'sauce')).to be_respond_to(:awesome)
     end
 
     it 'is true for symbol keys' do
-      subject.new(awesome: 'sauce').should be_respond_to(:awesome)
+      expect(subject.new(awesome: 'sauce')).to be_respond_to(:awesome)
     end
 
     it 'is false for non-keys' do
-      subject.new.should_not be_respond_to(:awesome)
+      expect(subject.new).not_to be_respond_to(:awesome)
     end
   end
 end
@@ -53,22 +53,22 @@ describe Hashie::Extensions::MethodWriter do
 
   it 'writes from a method call' do
     subject.awesome = 'sauce'
-    subject['awesome'].should eq 'sauce'
+    expect(subject['awesome']).to eq 'sauce'
   end
 
   it 'converts the key using the #convert_key method' do
-    subject.stub!(:convert_key).and_return(:awesome)
+    allow(subject).to receive(:convert_key).and_return(:awesome)
     subject.awesome = 'sauce'
-    subject[:awesome].should eq 'sauce'
+    expect(subject[:awesome]).to eq 'sauce'
   end
 
   it 'raises NoMethodError on non equals-ending methods' do
-    lambda { subject.awesome }.should raise_error(NoMethodError)
+    expect { subject.awesome }.to raise_error(NoMethodError)
   end
 
   it '#respond_to? correctly' do
-    subject.should be_respond_to(:abc=)
-    subject.should_not be_respond_to(:abc)
+    expect(subject).to be_respond_to(:abc=)
+    expect(subject).not_to be_respond_to(:abc)
   end
 end
 
@@ -84,31 +84,31 @@ describe Hashie::Extensions::MethodQuery do
   subject { QueryHash }
 
   it 'is true for non-nil string key values' do
-    subject.new('abc' => 123).should be_abc
+    expect(subject.new('abc' => 123)).to be_abc
   end
 
   it 'is true for non-nil symbol key values' do
-    subject.new(abc: 123).should be_abc
+    expect(subject.new(abc: 123)).to be_abc
   end
 
   it 'is false for nil key values' do
-    subject.new(abc: false).should_not be_abc
+    expect(subject.new(abc: false)).not_to be_abc
   end
 
   it 'raises a NoMethodError for non-set keys' do
-    lambda { subject.new.abc? }.should raise_error(NoMethodError)
+    expect { subject.new.abc? }.to raise_error(NoMethodError)
   end
 
   it '#respond_to? for existing string keys' do
-    subject.new('abc' => 'def').should be_respond_to('abc?')
+    expect(subject.new('abc' => 'def')).to be_respond_to('abc?')
   end
 
   it '#respond_to? for existing symbol keys' do
-    subject.new(abc: 'def').should be_respond_to(:abc?)
+    expect(subject.new(abc: 'def')).to be_respond_to(:abc?)
   end
 
   it 'does not #respond_to? for non-existent keys' do
-    subject.new.should_not be_respond_to('abc?')
+    expect(subject.new).not_to be_respond_to('abc?')
   end
 end
 
@@ -116,6 +116,6 @@ describe Hashie::Extensions::MethodAccess do
   it 'includes all of the other method mixins' do
     klass = Class.new(Hash)
     klass.send :include, Hashie::Extensions::MethodAccess
-    (klass.ancestors & [Hashie::Extensions::MethodReader, Hashie::Extensions::MethodWriter, Hashie::Extensions::MethodQuery]).size.should eq 3
+    expect((klass.ancestors & [Hashie::Extensions::MethodReader, Hashie::Extensions::MethodWriter, Hashie::Extensions::MethodQuery]).size).to eq 3
   end
 end

data/spec/hashie/hash_spec.rb

@@ -3,32 +3,44 @@ require 'spec_helper'
 describe Hash do
   it 'is convertible to a Hashie::Mash' do
     mash = Hashie::Hash[some: 'hash'].to_mash
-    mash.is_a?(Hashie::Mash).should be_true
-    mash.some.should eq 'hash'
+    expect(mash.is_a?(Hashie::Mash)).to be_true
+    expect(mash.some).to eq 'hash'
   end
 
   it '#stringify_keys! turns all keys into strings' do
     hash = Hashie::Hash[:a => 'hey', 123 => 'bob']
     hash.stringify_keys!
-    hash.should eq Hashie::Hash['a' => 'hey', '123' => 'bob']
+    expect(hash).to eq Hashie::Hash['a' => 'hey', '123' => 'bob']
   end
 
   it '#stringify_keys returns a hash with stringified keys' do
     hash = Hashie::Hash[:a => 'hey', 123 => 'bob']
     stringified_hash = hash.stringify_keys
-    hash.should eq Hashie::Hash[:a => 'hey', 123 => 'bob']
-    stringified_hash.should eq Hashie::Hash['a' => 'hey', '123' => 'bob']
+    expect(hash).to eq Hashie::Hash[:a => 'hey', 123 => 'bob']
+    expect(stringified_hash).to eq Hashie::Hash['a' => 'hey', '123' => 'bob']
   end
 
   it '#to_hash returns a hash with stringified keys' do
     hash = Hashie::Hash['a' => 'hey', 123 => 'bob', 'array' => [1, 2, 3]]
     stringified_hash = hash.to_hash
-    stringified_hash.should eq('a' => 'hey', '123' => 'bob', 'array' => [1, 2, 3])
+    expect(stringified_hash).to eq('a' => 'hey', '123' => 'bob', 'array' => [1, 2, 3])
   end
 
   it '#to_hash with symbolize_keys set to true returns a hash with symbolized keys' do
     hash = Hashie::Hash['a' => 'hey', 123 => 'bob', 'array' => [1, 2, 3]]
     symbolized_hash = hash.to_hash(symbolize_keys: true)
-    symbolized_hash.should eq(:a => 'hey', :"123" => 'bob', :array => [1, 2, 3])
+    expect(symbolized_hash).to eq(:a => 'hey', :"123" => 'bob', :array => [1, 2, 3])
+  end
+
+  it "#to_hash should not blow up when #to_hash doesn't accept arguments" do
+    class BareCustomMash < Hashie::Mash
+      def to_hash
+        {}
+      end
+    end
+
+    h = Hashie::Hash.new
+    h[:key] = BareCustomMash.new
+    expect { h.to_hash }.not_to raise_error
   end
 end