hashie 2.1.0 → 2.1.1

data/spec/hashie/mash_spec.rb

@@ -5,123 +5,123 @@ describe Hashie::Mash do
   subject { Hashie::Mash.new }
 
   it 'inherits from Hash' do
-    subject.is_a?(Hash).should be_true
+    expect(subject.is_a?(Hash)).to be_true
   end
 
   it 'sets hash values through method= calls' do
     subject.test = 'abc'
-    subject['test'].should eq 'abc'
+    expect(subject['test']).to eq 'abc'
   end
 
   it 'retrieves set values through method calls' do
     subject['test'] = 'abc'
-    subject.test.should eq 'abc'
+    expect(subject.test).to eq 'abc'
   end
 
   it 'retrieves set values through blocks' do
     subject['test'] = 'abc'
     value = nil
     subject.[]('test') { |v| value = v }
-    value.should eq 'abc'
+    expect(value).to eq 'abc'
   end
 
   it 'retrieves set values through blocks with method calls' do
     subject['test'] = 'abc'
     value = nil
     subject.test { |v| value = v }
-    value.should eq 'abc'
+    expect(value).to eq 'abc'
   end
 
   it 'tests for already set values when passed a ? method' do
-    subject.test?.should be_false
+    expect(subject.test?).to be_false
     subject.test = 'abc'
-    subject.test?.should be_true
+    expect(subject.test?).to be_true
   end
 
   it 'returns false on a ? method if a value has been set to nil or false' do
     subject.test = nil
-    subject.should_not be_test
+    expect(subject).not_to be_test
     subject.test = false
-    subject.should_not be_test
+    expect(subject).not_to be_test
   end
 
   it 'makes all [] and []= into strings for consistency' do
     subject['abc'] = 123
-    subject.key?('abc').should be_true
-    subject['abc'].should eq 123
+    expect(subject.key?('abc')).to be_true
+    expect(subject['abc']).to eq 123
   end
 
   it 'has a to_s that is identical to its inspect' do
     subject.abc = 123
-    subject.to_s.should eq subject.inspect
+    expect(subject.to_s).to eq subject.inspect
   end
 
   it 'returns nil instead of raising an error for attribute-esque method calls' do
-    subject.abc.should be_nil
+    expect(subject.abc).to be_nil
   end
 
   it 'returns the default value if set like Hash' do
     subject.default = 123
-    subject.abc.should eq 123
+    expect(subject.abc).to eq 123
   end
 
   it 'gracefully handles being accessed with arguments' do
-    subject.abc('foobar').should eq nil
+    expect(subject.abc('foobar')).to eq nil
     subject.abc = 123
-    subject.abc('foobar').should eq 123
+    expect(subject.abc('foobar')).to eq 123
   end
 
   it 'returns a Hashie::Mash when passed a bang method to a non-existenct key' do
-    subject.abc!.is_a?(Hashie::Mash).should be_true
+    expect(subject.abc!.is_a?(Hashie::Mash)).to be_true
   end
 
   it 'returns the existing value when passed a bang method for an existing key' do
     subject.name = 'Bob'
-    subject.name!.should eq 'Bob'
+    expect(subject.name!).to eq 'Bob'
   end
 
   it 'returns a Hashie::Mash when passed an under bang method to a non-existenct key' do
-    subject.abc_.is_a?(Hashie::Mash).should be_true
+    expect(subject.abc_.is_a?(Hashie::Mash)).to be_true
   end
 
   it 'returns the existing value when passed an under bang method for an existing key' do
     subject.name = 'Bob'
-    subject.name_.should eq 'Bob'
+    expect(subject.name_).to eq 'Bob'
   end
 
   it '#initializing_reader returns a Hashie::Mash when passed a non-existent key' do
-    subject.initializing_reader(:abc).is_a?(Hashie::Mash).should be_true
+    expect(subject.initializing_reader(:abc).is_a?(Hashie::Mash)).to be_true
   end
 
   it 'allows for multi-level assignment through bang methods' do
     subject.author!.name = 'Michael Bleigh'
-    subject.author.should eq Hashie::Mash.new(name: 'Michael Bleigh')
+    expect(subject.author).to eq Hashie::Mash.new(name: 'Michael Bleigh')
     subject.author!.website!.url = 'http://www.mbleigh.com/'
-    subject.author.website.should eq Hashie::Mash.new(url: 'http://www.mbleigh.com/')
+    expect(subject.author.website).to eq Hashie::Mash.new(url: 'http://www.mbleigh.com/')
   end
 
   it 'allows for multi-level under bang testing' do
-    subject.author_.website_.url.should be_nil
-    subject.author_.website_.url?.should eq false
-    subject.author.should be_nil
+    expect(subject.author_.website_.url).to be_nil
+    expect(subject.author_.website_.url?).to eq false
+    expect(subject.author).to be_nil
   end
 
   it 'does not call super if id is not a key' do
-    subject.id.should eq nil
+    expect(subject.id).to eq nil
   end
 
   it 'returns the value if id is a key' do
     subject.id = 'Steve'
-    subject.id.should eq 'Steve'
+    expect(subject.id).to eq 'Steve'
   end
 
   it 'does not call super if type is not a key' do
-    subject.type.should eq nil
+    expect(subject.type).to eq nil
   end
 
   it 'returns the value if type is a key' do
     subject.type = 'Steve'
-    subject.type.should eq 'Steve'
+    expect(subject.type).to eq 'Steve'
   end
 
   context 'updating' do
@@ -138,10 +138,10 @@ describe Hashie::Mash do
     describe '#deep_update' do
       it 'recursively Hashie::Mash Hashie::Mashes and hashes together' do
         subject.deep_update(details: { email: 'michael@intridea.com', city: 'Imagineton' })
-        subject.first_name.should eq 'Michael'
-        subject.details.email.should eq 'michael@intridea.com'
-        subject.details.address.should eq 'Nowhere road'
-        subject.details.city.should eq 'Imagineton'
+        expect(subject.first_name).to eq 'Michael'
+        expect(subject.details.email).to eq 'michael@intridea.com'
+        expect(subject.details.address).to eq 'Nowhere road'
+        expect(subject.details.city).to eq 'Imagineton'
       end
 
       it 'converts values only once' do
@@ -149,60 +149,59 @@ describe Hashie::Mash do
         end
 
         rhs = ConvertedMash.new(email: 'foo@bar.com')
-        subject.should_receive(:convert_value).exactly(1).times
+        expect(subject).to receive(:convert_value).exactly(1).times
         subject.deep_update(rhs)
       end
 
       it 'makes #update deep by default' do
-        subject.update(details: { address: 'Fake street' }).should eql(subject)
-        subject.details.address.should eq 'Fake street'
-        subject.details.email.should eq 'michael@asf.com'
+        expect(subject.update(details: { address: 'Fake street' })).to eql(subject)
+        expect(subject.details.address).to eq 'Fake street'
+        expect(subject.details.email).to eq 'michael@asf.com'
       end
 
       it 'clones before a #deep_merge' do
         duped = subject.deep_merge(details: { address: 'Fake street' })
-        duped.should_not eql(subject)
-        duped.details.address.should eq 'Fake street'
-        subject.details.address.should eq 'Nowhere road'
-        duped.details.email.should eq 'michael@asf.com'
+        expect(duped).not_to eql(subject)
+        expect(duped.details.address).to eq 'Fake street'
+        expect(subject.details.address).to eq 'Nowhere road'
+        expect(duped.details.email).to eq 'michael@asf.com'
       end
 
       it 'default #merge is deep' do
         duped = subject.merge(details: { email: 'michael@intridea.com' })
-        duped.should_not eql(subject)
-        duped.details.email.should eq 'michael@intridea.com'
-        duped.details.address.should eq 'Nowhere road'
+        expect(duped).not_to eql(subject)
+        expect(duped.details.email).to eq 'michael@intridea.com'
+        expect(duped.details.address).to eq 'Nowhere road'
       end
 
       # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-update
       it 'accepts a block' do
         duped = subject.merge(details: { address: 'Pasadena CA' }) { |key, oldv, newv| [oldv, newv].join(', ') }
-        duped.details.address.should eq 'Nowhere road, Pasadena CA'
+        expect(duped.details.address).to eq 'Nowhere road, Pasadena CA'
       end
     end
 
     describe 'shallow update' do
       it 'shallowly Hashie::Mash Hashie::Mashes and hashes together' do
-        subject.shallow_update(details: {
-                                 email: 'michael@intridea.com', city: 'Imagineton'
-        }).should eql(subject)
-
-        subject.first_name.should eq 'Michael'
-        subject.details.email.should eq 'michael@intridea.com'
-        subject.details.address.should be_nil
-        subject.details.city.should eq 'Imagineton'
+        expect(subject.shallow_update(details: {  email: 'michael@intridea.com',
+                                                  city: 'Imagineton' })).to eql(subject)
+
+        expect(subject.first_name).to eq 'Michael'
+        expect(subject.details.email).to eq 'michael@intridea.com'
+        expect(subject.details.address).to be_nil
+        expect(subject.details.city).to eq 'Imagineton'
       end
 
       it 'clones before a #regular_merge' do
         duped = subject.shallow_merge(details: { address: 'Fake street' })
-        duped.should_not eql(subject)
+        expect(duped).not_to eql(subject)
       end
 
       it 'default #merge is shallow' do
         duped = subject.shallow_merge(details: { address: 'Fake street' })
-        duped.details.address.should eq 'Fake street'
-        subject.details.address.should eq 'Nowhere road'
-        duped.details.email.should be_nil
+        expect(duped.details.address).to eq 'Fake street'
+        expect(subject.details.address).to eq 'Nowhere road'
+        expect(duped.details.email).to be_nil
       end
     end
 
@@ -215,45 +214,45 @@ describe Hashie::Mash do
       end
 
       it 'returns self' do
-        subject.replace(foo: 'bar').to_hash.should eq('foo' => 'bar')
+        expect(subject.replace(foo: 'bar').to_hash).to eq('foo' => 'bar')
       end
 
       it 'sets all specified keys to their corresponding values' do
-        subject.middle_name?.should be_true
-        subject.details?.should be_true
-        subject.middle_name.should eq 'Cain'
-        subject.details.city?.should be_true
-        subject.details.city.should eq 'Imagination'
+        expect(subject.middle_name?).to be_true
+        expect(subject.details?).to be_true
+        expect(subject.middle_name).to eq 'Cain'
+        expect(subject.details.city?).to be_true
+        expect(subject.details.city).to eq 'Imagination'
       end
 
       it 'leaves only specified keys' do
-        subject.keys.sort.should eq %w(details middle_name)
-        subject.first_name?.should be_false
-        subject.should_not respond_to(:first_name)
-        subject.last_name?.should be_false
-        subject.should_not respond_to(:last_name)
+        expect(subject.keys.sort).to eq %w(details middle_name)
+        expect(subject.first_name?).to be_false
+        expect(subject).not_to respond_to(:first_name)
+        expect(subject.last_name?).to be_false
+        expect(subject).not_to respond_to(:last_name)
       end
     end
 
     describe 'delete' do
       it 'deletes with String key' do
         subject.delete('details')
-        subject.details.should be_nil
-        subject.should_not be_respond_to :details
+        expect(subject.details).to be_nil
+        expect(subject).not_to be_respond_to :details
       end
 
       it 'deletes with Symbol key' do
         subject.delete(:details)
-        subject.details.should be_nil
-        subject.should_not be_respond_to :details
+        expect(subject.details).to be_nil
+        expect(subject).not_to be_respond_to :details
       end
     end
   end
 
   it 'converts hash assignments into Hashie::Mashes' do
     subject.details = { email: 'randy@asf.com', address: { state: 'TX' } }
-    subject.details.email.should eq 'randy@asf.com'
-    subject.details.address.state.should eq 'TX'
+    expect(subject.details.email).to eq 'randy@asf.com'
+    expect(subject.details.address.state).to eq 'TX'
   end
 
   it 'does not convert the type of Hashie::Mashes childs to Hashie::Mash' do
@@ -262,7 +261,7 @@ describe Hashie::Mash do
 
     record = MyMash.new
     record.son = MyMash.new
-    record.son.class.should eq MyMash
+    expect(record.son.class).to eq MyMash
   end
 
   it 'does not change the class of Mashes when converted' do
@@ -272,35 +271,35 @@ describe Hashie::Mash do
     record = Hashie::Mash.new
     son = SubMash.new
     record['submash'] = son
-    record['submash'].should be_kind_of(SubMash)
+    expect(record['submash']).to be_kind_of(SubMash)
   end
 
   it 'respects the class when passed a bang method for a non-existent key' do
     record = Hashie::Mash.new
-    record.non_existent!.should be_kind_of(Hashie::Mash)
+    expect(record.non_existent!).to be_kind_of(Hashie::Mash)
 
     class SubMash < Hashie::Mash
     end
 
     son = SubMash.new
-    son.non_existent!.should be_kind_of(SubMash)
+    expect(son.non_existent!).to be_kind_of(SubMash)
   end
 
   it 'respects the class when passed an under bang method for a non-existent key' do
     record = Hashie::Mash.new
-    record.non_existent_.should be_kind_of(Hashie::Mash)
+    expect(record.non_existent_).to be_kind_of(Hashie::Mash)
 
     class SubMash < Hashie::Mash
     end
 
     son = SubMash.new
-    son.non_existent_.should be_kind_of(SubMash)
+    expect(son.non_existent_).to be_kind_of(SubMash)
   end
 
   it 'respects the class when converting the value' do
     record = Hashie::Mash.new
     record.details = Hashie::Mash.new(email: 'randy@asf.com')
-    record.details.should be_kind_of(Hashie::Mash)
+    expect(record.details).to be_kind_of(Hashie::Mash)
   end
 
   it 'respects another subclass when converting the value' do
@@ -311,84 +310,84 @@ describe Hashie::Mash do
 
     son = SubMash.new(email: 'foo@bar.com')
     record.details = son
-    record.details.should be_kind_of(SubMash)
+    expect(record.details).to be_kind_of(SubMash)
   end
 
   describe '#respond_to?' do
     it 'responds to a normal method' do
-      Hashie::Mash.new.should be_respond_to(:key?)
+      expect(Hashie::Mash.new).to be_respond_to(:key?)
     end
 
     it 'responds to a set key' do
-      Hashie::Mash.new(abc: 'def').should be_respond_to(:abc)
+      expect(Hashie::Mash.new(abc: 'def')).to be_respond_to(:abc)
     end
 
     it 'responds to a set key with a suffix' do
       %w(= ? ! _).each do |suffix|
-        Hashie::Mash.new(abc: 'def').should be_respond_to(:"abc#{suffix}")
+        expect(Hashie::Mash.new(abc: 'def')).to be_respond_to(:"abc#{suffix}")
       end
     end
 
     it 'does not respond to an unknown key with a suffix' do
       %w(= ? ! _).each do |suffix|
-        Hashie::Mash.new(abc: 'def').should_not be_respond_to(:"xyz#{suffix}")
+        expect(Hashie::Mash.new(abc: 'def')).not_to be_respond_to(:"xyz#{suffix}")
       end
     end
 
     it 'does not respond to an unknown key without a suffix' do
-      Hashie::Mash.new(abc: 'def').should_not be_respond_to(:xyz)
+      expect(Hashie::Mash.new(abc: 'def')).not_to be_respond_to(:xyz)
     end
 
     it 'does not respond to permitted?' do
-      Hashie::Mash.new.should_not be_respond_to(:permitted?)
+      expect(Hashie::Mash.new).not_to be_respond_to(:permitted?)
     end
   end
 
   context '#initialize' do
     it 'converts an existing hash to a Hashie::Mash' do
       converted = Hashie::Mash.new(abc: 123, name: 'Bob')
-      converted.abc.should eq 123
-      converted.name.should eq 'Bob'
+      expect(converted.abc).to eq 123
+      expect(converted.name).to eq 'Bob'
     end
 
     it 'converts hashes recursively into Hashie::Mashes' do
       converted = Hashie::Mash.new(a: { b: 1, c: { d: 23 } })
-      converted.a.is_a?(Hashie::Mash).should be_true
-      converted.a.b.should eq 1
-      converted.a.c.d.should eq 23
+      expect(converted.a.is_a?(Hashie::Mash)).to be_true
+      expect(converted.a.b).to eq 1
+      expect(converted.a.c.d).to eq 23
     end
 
     it 'converts hashes in arrays into Hashie::Mashes' do
       converted = Hashie::Mash.new(a: [{ b: 12 }, 23])
-      converted.a.first.b.should eq 12
-      converted.a.last.should eq 23
+      expect(converted.a.first.b).to eq 12
+      expect(converted.a.last).to eq 23
     end
 
     it 'converts an existing Hashie::Mash into a Hashie::Mash' do
       initial = Hashie::Mash.new(name: 'randy', address: { state: 'TX' })
       copy = Hashie::Mash.new(initial)
-      initial.name.should eq copy.name
-      initial.__id__.should_not eq copy.__id__
-      copy.address.state.should eq 'TX'
+      expect(initial.name).to eq copy.name
+      expect(initial.__id__).not_to eq copy.__id__
+      expect(copy.address.state).to eq 'TX'
       copy.address.state = 'MI'
-      initial.address.state.should eq 'TX'
-      copy.address.__id__.should_not eq initial.address.__id__
+      expect(initial.address.state).to eq 'TX'
+      expect(copy.address.__id__).not_to eq initial.address.__id__
     end
 
     it 'accepts a default block' do
       initial = Hashie::Mash.new { |h, i| h[i] = [] }
-      initial.default_proc.should_not be_nil
-      initial.default.should be_nil
-      initial.test.should eq []
-      initial.test?.should be_true
+      expect(initial.default_proc).not_to be_nil
+      expect(initial.default).to be_nil
+      expect(initial.test).to eq []
+      expect(initial.test?).to be_true
     end
 
     it 'converts Hashie::Mashes within Arrays back to Hashes' do
       initial_hash = { 'a' => [{ 'b' => 12, 'c' => ['d' => 50, 'e' => 51] }, 23] }
       converted = Hashie::Mash.new(initial_hash)
-      converted.to_hash['a'].first.is_a?(Hashie::Mash).should be_false
-      converted.to_hash['a'].first.is_a?(Hash).should be_true
-      converted.to_hash['a'].first['c'].first.is_a?(Hashie::Mash).should be_false
+      expect(converted.to_hash['a'].first.is_a?(Hashie::Mash)).to be_false
+      expect(converted.to_hash['a'].first.is_a?(Hash)).to be_true
+      expect(converted.to_hash['a'].first['c'].first.is_a?(Hashie::Mash)).to be_false
     end
   end
 
@@ -398,16 +397,16 @@ describe Hashie::Mash do
 
     context 'when key exists' do
       it 'returns the value' do
-        mash.fetch(:one).should eql(1)
+        expect(mash.fetch(:one)).to eql(1)
       end
 
       it 'returns the value even if the value is falsy' do
-        mash.fetch(:other).should eql(false)
+        expect(mash.fetch(:other)).to eql(false)
       end
 
       context 'when key has other than original but acceptable type' do
         it 'returns the value' do
-          mash.fetch('one').should eql(1)
+          expect(mash.fetch('one')).to eql(1)
         end
       end
     end
@@ -420,19 +419,19 @@ describe Hashie::Mash do
 
       context 'with default value given' do
         it 'returns default value' do
-          mash.fetch(:two, 8).should eql(8)
+          expect(mash.fetch(:two, 8)).to eql(8)
         end
 
         it 'returns default value even if it is falsy' do
-          mash.fetch(:two, false).should eql(false)
+          expect(mash.fetch(:two, false)).to eql(false)
         end
       end
 
       context 'with block given' do
         it 'returns default value' do
-          mash.fetch(:two) do |key|
+          expect(mash.fetch(:two) do |key|
             'block default value'
-          end.should eql('block default value')
+          end).to eql('block default value')
         end
       end
     end
@@ -443,26 +442,26 @@ describe Hashie::Mash do
     let(:mash) { Hashie::Mash.new(hash) }
 
     it 'returns a standard Hash' do
-      mash.to_hash.should be_a(::Hash)
+      expect(mash.to_hash).to be_a(::Hash)
     end
 
     it 'includes all keys' do
-      mash.to_hash.keys.should eql(%w(outer testing))
+      expect(mash.to_hash.keys).to eql(%w(outer testing))
     end
 
     it 'converts keys to symbols when symbolize_keys option is true' do
-      mash.to_hash(symbolize_keys: true).keys.should include(:outer)
-      mash.to_hash(symbolize_keys: true).keys.should_not include('outer')
+      expect(mash.to_hash(symbolize_keys: true).keys).to include(:outer)
+      expect(mash.to_hash(symbolize_keys: true).keys).not_to include('outer')
     end
 
     it 'leaves keys as strings when symbolize_keys option is false' do
-      mash.to_hash(symbolize_keys: false).keys.should include('outer')
-      mash.to_hash(symbolize_keys: false).keys.should_not include(:outer)
+      expect(mash.to_hash(symbolize_keys: false).keys).to include('outer')
+      expect(mash.to_hash(symbolize_keys: false).keys).not_to include(:outer)
     end
 
     it 'symbolizes keys recursively' do
-      mash.to_hash(symbolize_keys: true)[:outer].keys.should include(:inner)
-      mash.to_hash(symbolize_keys: true)[:outer].keys.should_not include('inner')
+      expect(mash.to_hash(symbolize_keys: true)[:outer].keys).to include(:inner)
+      expect(mash.to_hash(symbolize_keys: true)[:outer].keys).not_to include('inner')
     end
   end
 end

data/spec/hashie/rash_spec.rb

@@ -15,30 +15,30 @@ describe Hashie::Rash do
   end
 
   it 'finds strings' do
-    subject['other'].should eq 'whee'
-    subject['well hello there'].should eq 'hello'
-    subject['the world is round'].should eq 'world'
-    subject.all('hello world').sort.should eq %w(hello world)
+    expect(subject['other']).to eq 'whee'
+    expect(subject['well hello there']).to eq 'hello'
+    expect(subject['the world is round']).to eq 'world'
+    expect(subject.all('hello world').sort).to eq %w(hello world)
   end
 
   it 'finds regexps' do
-    subject[/other/].should eq 'whee'
+    expect(subject[/other/]).to eq 'whee'
   end
 
   it 'finds other objects' do
-    subject[true].should eq false
-    subject[1].should eq 'awesome'
+    expect(subject[true]).to eq false
+    expect(subject[1]).to eq 'awesome'
   end
 
   it 'finds numbers from ranges' do
-    subject[250].should eq 'rangey'
-    subject[999].should eq 'rangey'
-    subject[1000].should eq 'rangey'
-    subject[1001].should be_nil
+    expect(subject[250]).to eq 'rangey'
+    expect(subject[999]).to eq 'rangey'
+    expect(subject[1000]).to eq 'rangey'
+    expect(subject[1001]).to be_nil
   end
 
   it 'evaluates proc values' do
-    subject['abcdef'].should eq 'bcd'
-    subject['ffffff'].should be_nil
+    expect(subject['abcdef']).to eq 'bcd'
+    expect(subject['ffffff']).to be_nil
   end
 end