hashie 2.1.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1fd1f73bdb3a592938fb9e274e7306c16c2410b8
-  data.tar.gz: 545f19b3a9989433f31c047af0fdf477789f8d10
+  metadata.gz: 669a459e63fb50152c48b98abf0bce58e5e138e5
+  data.tar.gz: 49b29974978742dab0b2c228dd2c473df1d89732
 SHA512:
-  metadata.gz: 4a96ffb374b4560d0276412d43ceaa5717aa963e5c8e596343c6cf484081cc2f1b49b7725b97eb9c64baf33631e96f8ccecc1ee95dc470c2fe677334f3c38a45
-  data.tar.gz: e67465dc21d6a9eef56e3eb7b603d41471a926c42e2a4f687d4e2c4ead92522e04dc03408b6854f7d594b7a9510d517d432208e94287a1f77c13008d4a5a40f8
+  metadata.gz: 513d09bc3690cfa9a3913354c80bb9bb34321013ba46a710c8a4649ff3967218f4ed04a45bb79451623fadc2d340bb174b260ab8f9b424733c2d16f334f1d9d6
+  data.tar.gz: aea99e5db0b7c58499b45b6ca806fe99bb94a4e8e5c74df22af74a56844104778ba8a328d8e024a7f090daceaf092ed0eb25ae1d302dc901f4b05268ec851756

data/CHANGELOG.md

@@ -1,4 +1,8 @@
-## Next Release
+## 2.1.1 (4/12/2014)
+
+* [#144](https://github.com/intridea/hashie/issues/144): Fixed regression invoking `to_hash` with no parameters - [@mbleigh](https://github.com/mbleigh).
+
+## 2.1.0 (4/6/2014)
 
 * [#134](https://github.com/intridea/hashie/pull/134): Add deep_fetch extension for nested access - [@tylerdooling](https://github.com/tylerdooling).
 * Removed support for Ruby 1.8.7 - [@dblock](https://github.com/dblock).

data/lib/hashie/hash.rb

@@ -16,18 +16,28 @@ module Hashie
         if self[k].is_a?(Array)
           out[assignment_key] ||= []
           self[k].each do |array_object|
-            out[assignment_key] << (Hash === array_object ? array_object.to_hash(options) : array_object)
+            out[assignment_key] << (Hash === array_object ? flexibly_convert_to_hash(array_object, options) : array_object)
           end
         else
-          out[assignment_key] = Hash === self[k] ? self[k].to_hash(options) : self[k]
+          out[assignment_key] = Hash === self[k] ? flexibly_convert_to_hash(self[k], options) : self[k]
         end
       end
       out
     end
 
-    # The C geneartor for the json gem doesn't like mashies
+    # The C generator for the json gem doesn't like mashies
     def to_json(*args)
       to_hash.to_json(*args)
     end
+
+    private
+
+    def flexibly_convert_to_hash(object, options = {})
+      if object.method(:to_hash).arity == 0
+        object.to_hash
+      else
+        object.to_hash(options)
+      end
+    end
   end
 end

data/lib/hashie/version.rb

@@ -1,3 +1,3 @@
 module Hashie
-  VERSION = '2.1.0'
+  VERSION = '2.1.1'
 end

data/spec/hashie/clash_spec.rb

@@ -5,44 +5,44 @@ describe Hashie::Clash do
 
   it 'is able to set an attribute via method_missing' do
     subject.foo('bar')
-    subject[:foo].should eq 'bar'
+    expect(subject[:foo]).to eq 'bar'
   end
 
   it 'is able to set multiple attributes' do
     subject.foo('bar').baz('wok')
-    subject.should eq(foo: 'bar', baz: 'wok')
+    expect(subject).to eq(foo: 'bar', baz: 'wok')
   end
 
   it 'converts multiple arguments into an array' do
     subject.foo(1, 2, 3)
-    subject[:foo].should eq [1, 2, 3]
+    expect(subject[:foo]).to eq [1, 2, 3]
   end
 
   it 'is able to use bang notation to create a new Clash on a key' do
     subject.foo!
-    subject[:foo].should be_kind_of(Hashie::Clash)
+    expect(subject[:foo]).to be_kind_of(Hashie::Clash)
   end
 
   it 'is able to chain onto the new Clash when using bang notation' do
     subject.foo!.bar('abc').baz(123)
-    subject.should eq(foo: { bar: 'abc', baz: 123 })
+    expect(subject).to eq(foo: { bar: 'abc', baz: 123 })
   end
 
   it 'is able to jump back up to the parent in the chain with #_end!' do
     subject.foo!.bar('abc')._end!.baz(123)
-    subject.should eq(foo: { bar: 'abc' }, baz: 123)
+    expect(subject).to eq(foo: { bar: 'abc' }, baz: 123)
   end
 
   it 'merges rather than replaces existing keys' do
     subject.where(abc: 'def').where(hgi: 123)
-    subject.should eq(where: { abc: 'def', hgi: 123 })
+    expect(subject).to eq(where: { abc: 'def', hgi: 123 })
   end
 
   it 'is able to replace all of its own keys with #replace' do
     subject.foo(:bar).hello(:world)
-    subject.replace(baz: 123, hgi: 123).should eq(baz: 123, hgi: 123)
-    subject.should eq(baz: 123, hgi: 123)
-    subject[:foo].should be_nil
-    subject[:hello].should be_nil
+    expect(subject.replace(baz: 123, hgi: 123)).to eq(baz: 123, hgi: 123)
+    expect(subject).to eq(baz: 123, hgi: 123)
+    expect(subject[:foo]).to be_nil
+    expect(subject[:hello]).to be_nil
   end
 end

data/spec/hashie/dash_spec.rb

@@ -40,102 +40,108 @@ describe DashTest do
 
   it('subclasses Hashie::Hash') { should respond_to(:to_mash) }
 
-  its(:to_s) { should eq '#<DashTest count=0 email="bob@example.com" first_name="Bob">' }
+  describe '#to_s' do
+    subject { super().to_s }
+    it { should eq '#<DashTest count=0 email="bob@example.com" first_name="Bob">' }
+  end
 
   it 'lists all set properties in inspect' do
     subject.first_name = 'Bob'
     subject.email = 'bob@example.com'
-    subject.inspect.should eq '#<DashTest count=0 email="bob@example.com" first_name="Bob">'
+    expect(subject.inspect).to eq '#<DashTest count=0 email="bob@example.com" first_name="Bob">'
   end
 
-  its(:count) { should be_zero }
+  describe '#count' do
+    subject { super().count }
+    it { should be_zero }
+  end
 
   it { should respond_to(:first_name) }
   it { should respond_to(:first_name=) }
   it { should_not respond_to(:nonexistent) }
 
   it 'errors out for a non-existent property' do
-    lambda { subject['nonexistent'] }.should raise_error(NoMethodError)
+    expect { subject['nonexistent'] }.to raise_error(NoMethodError)
   end
 
   it 'errors out when attempting to set a required property to nil' do
-    lambda { subject.first_name = nil }.should raise_error(ArgumentError)
+    expect { subject.first_name = nil }.to raise_error(ArgumentError)
   end
 
   context 'writing to properties' do
     it 'fails writing a required property to nil' do
-      lambda { subject.first_name = nil }.should raise_error(ArgumentError)
+      expect { subject.first_name = nil }.to raise_error(ArgumentError)
     end
 
     it 'fails writing a required property to nil using []=' do
-      lambda { subject['first_name'] = nil }.should raise_error(ArgumentError)
+      expect { subject['first_name'] = nil }.to raise_error(ArgumentError)
     end
 
     it 'fails writing to a non-existent property using []=' do
-      lambda { subject['nonexistent'] = 123 }.should raise_error(NoMethodError)
+      expect { subject['nonexistent'] = 123 }.to raise_error(NoMethodError)
     end
 
     it 'works for an existing property using []=' do
       subject['first_name'] = 'Bob'
-      subject['first_name'].should eq 'Bob'
-      subject[:first_name].should eq 'Bob'
+      expect(subject['first_name']).to eq 'Bob'
+      expect(subject[:first_name]).to eq 'Bob'
     end
 
     it 'works for an existing property using a method call' do
       subject.first_name = 'Franklin'
-      subject.first_name.should eq 'Franklin'
+      expect(subject.first_name).to eq 'Franklin'
     end
   end
 
   context 'reading from properties' do
     it 'fails reading from a non-existent property using []' do
-      lambda { subject['nonexistent'] }.should raise_error(NoMethodError)
+      expect { subject['nonexistent'] }.to raise_error(NoMethodError)
     end
 
     it 'is able to retrieve properties through blocks' do
       subject['first_name'] = 'Aiden'
       value = nil
       subject.[]('first_name') { |v| value = v }
-      value.should eq 'Aiden'
+      expect(value).to eq 'Aiden'
     end
 
     it 'is able to retrieve properties through blocks with method calls' do
       subject['first_name'] = 'Frodo'
       value = nil
       subject.first_name { |v| value = v }
-      value.should eq 'Frodo'
+      expect(value).to eq 'Frodo'
     end
   end
 
   context 'reading from deferred properties' do
     it 'evaluates proc after initial read' do
-      DeferredTest.new['created_at'].should be_instance_of(Time)
+      expect(DeferredTest.new['created_at']).to be_instance_of(Time)
     end
 
     it 'does not evalute proc after subsequent reads' do
       deferred = DeferredTest.new
-      deferred['created_at'].object_id.should eq deferred['created_at'].object_id
+      expect(deferred['created_at'].object_id).to eq deferred['created_at'].object_id
     end
   end
 
   describe '#new' do
     it 'fails with non-existent properties' do
-      lambda { described_class.new(bork: '') }.should raise_error(NoMethodError)
+      expect { described_class.new(bork: '') }.to raise_error(NoMethodError)
     end
 
     it 'sets properties that it is able to' do
       obj = described_class.new first_name: 'Michael'
-      obj.first_name.should eq 'Michael'
+      expect(obj.first_name).to eq 'Michael'
     end
 
     it 'accepts nil' do
-      lambda { DashNoRequiredTest.new(nil) }.should_not raise_error
+      expect { DashNoRequiredTest.new(nil) }.not_to raise_error
     end
 
     it 'accepts block to define a global default' do
       obj = described_class.new { |hash, key| key.to_s.upcase }
-      obj.first_name.should eq 'FIRST_NAME'
-      obj.count.should be_zero
+      expect(obj.first_name).to eq 'FIRST_NAME'
+      expect(obj.count).to be_zero
     end
 
     it 'fails when required values are missing' do
@@ -146,20 +152,20 @@ describe DashTest do
       obj1 = DashDefaultTest.new
       obj1.aliases << 'El Rey'
       obj2 = DashDefaultTest.new
-      obj2.aliases.should_not include 'El Rey'
+      expect(obj2.aliases).not_to include 'El Rey'
     end
   end
 
   describe '#merge' do
     it 'creates a new instance of the Dash' do
       new_dash = subject.merge(first_name: 'Robert')
-      subject.object_id.should_not eq new_dash.object_id
+      expect(subject.object_id).not_to eq new_dash.object_id
     end
 
     it 'merges the given hash' do
       new_dash = subject.merge(first_name: 'Robert', email: 'robert@example.com')
-      new_dash.first_name.should eq 'Robert'
-      new_dash.email.should eq 'robert@example.com'
+      expect(new_dash.first_name).to eq 'Robert'
+      expect(new_dash.email).to eq 'robert@example.com'
     end
 
     it 'fails with non-existent properties' do
@@ -172,9 +178,9 @@ describe DashTest do
 
     context 'given a block' do
       it "sets merged key's values to the block's return value" do
-        subject.merge(first_name: 'Jim') do |key, oldval, newval|
+        expect(subject.merge(first_name: 'Jim') do |key, oldval, newval|
           "#{key}: #{newval} #{oldval}"
-        end.first_name.should eq 'first_name: Jim Bob'
+        end.first_name).to eq 'first_name: Jim Bob'
       end
     end
   end
@@ -182,13 +188,13 @@ describe DashTest do
   describe '#merge!' do
     it 'modifies the existing instance of the Dash' do
       original_dash = subject.merge!(first_name: 'Robert')
-      subject.object_id.should eq original_dash.object_id
+      expect(subject.object_id).to eq original_dash.object_id
     end
 
     it 'merges the given hash' do
       subject.merge!(first_name: 'Robert', email: 'robert@example.com')
-      subject.first_name.should eq 'Robert'
-      subject.email.should eq 'robert@example.com'
+      expect(subject.first_name).to eq 'Robert'
+      expect(subject.email).to eq 'robert@example.com'
     end
 
     it 'fails with non-existent properties' do
@@ -201,38 +207,38 @@ describe DashTest do
 
     context 'given a block' do
       it "sets merged key's values to the block's return value" do
-        subject.merge!(first_name: 'Jim') do |key, oldval, newval|
+        expect(subject.merge!(first_name: 'Jim') do |key, oldval, newval|
           "#{key}: #{newval} #{oldval}"
-        end.first_name.should eq 'first_name: Jim Bob'
+        end.first_name).to eq 'first_name: Jim Bob'
       end
     end
   end
 
   describe 'properties' do
     it 'lists defined properties' do
-      described_class.properties.should eq Set.new([:first_name, :email, :count])
+      expect(described_class.properties).to eq Set.new([:first_name, :email, :count])
     end
 
     it 'checks if a property exists' do
-      described_class.property?('first_name').should be_true
-      described_class.property?(:first_name).should be_true
+      expect(described_class.property?('first_name')).to be_true
+      expect(described_class.property?(:first_name)).to be_true
     end
 
     it 'checks if a property is required' do
-      described_class.required?('first_name').should be_true
-      described_class.required?(:first_name).should be_true
+      expect(described_class.required?('first_name')).to be_true
+      expect(described_class.required?(:first_name)).to be_true
     end
 
     it 'doesnt include property from subclass' do
-      described_class.property?(:last_name).should be_false
+      expect(described_class.property?(:last_name)).to be_false
     end
 
     it 'lists declared defaults' do
-      described_class.defaults.should eq(count: 0)
+      expect(described_class.defaults).to eq(count: 0)
     end
 
     it 'allows properties that end in bang' do
-      PropertyBangTest.property?(:important!).should be_true
+      expect(PropertyBangTest.property?(:important!)).to be_true
     end
   end
 
@@ -240,24 +246,24 @@ describe DashTest do
     before { subject.replace(first_name: 'Cain') }
 
     it 'return self' do
-      subject.replace(email: 'bar').to_hash.should eq('email' => 'bar', 'count' => 0)
+      expect(subject.replace(email: 'bar').to_hash).to eq('email' => 'bar', 'count' => 0)
     end
 
     it 'sets all specified keys to their corresponding values' do
-      subject.first_name.should eq 'Cain'
+      expect(subject.first_name).to eq 'Cain'
     end
 
     it 'leaves only specified keys and keys with default values' do
-      subject.keys.sort.should eq %w(count first_name)
-      subject.email.should be_nil
-      subject.count.should eq 0
+      expect(subject.keys.sort).to eq %w(count first_name)
+      expect(subject.email).to be_nil
+      expect(subject.count).to eq 0
     end
 
     context 'when replacing keys with default values' do
       before { subject.replace(count: 3) }
 
       it 'sets all specified keys to their corresponding values' do
-        subject.count.should eq 3
+        expect(subject.count).to eq 3
       end
     end
   end
@@ -271,40 +277,40 @@ describe Hashie::Dash, 'inheritance' do
   end
 
   it 'reports empty properties when nothing defined' do
-    @top.properties.should be_empty
-    @top.defaults.should be_empty
+    expect(@top.properties).to be_empty
+    expect(@top.defaults).to be_empty
   end
 
   it 'inherits properties downwards' do
     @top.property :echo
-    @middle.properties.should include(:echo)
-    @bottom.properties.should include(:echo)
+    expect(@middle.properties).to include(:echo)
+    expect(@bottom.properties).to include(:echo)
   end
 
   it 'doesnt inherit properties upwards' do
     @middle.property :echo
-    @top.properties.should_not include(:echo)
-    @bottom.properties.should include(:echo)
+    expect(@top.properties).not_to include(:echo)
+    expect(@bottom.properties).to include(:echo)
   end
 
   it 'allows overriding a default on an existing property' do
     @top.property :echo
     @middle.property :echo, default: 123
-    @bottom.properties.to_a.should eq [:echo]
-    @bottom.new.echo.should eq 123
+    expect(@bottom.properties.to_a).to eq [:echo]
+    expect(@bottom.new.echo).to eq 123
   end
 
   it 'allows clearing an existing default' do
     @top.property :echo
     @middle.property :echo, default: 123
     @bottom.property :echo
-    @bottom.properties.to_a.should eq [:echo]
-    @bottom.new.echo.should be_nil
+    expect(@bottom.properties.to_a).to eq [:echo]
+    expect(@bottom.new.echo).to be_nil
   end
 
   it 'allows nil defaults' do
     @bottom.property :echo, default: nil
-    @bottom.new.should have_key('echo')
+    expect(@bottom.new).to have_key('echo')
   end
 
 end
@@ -312,7 +318,10 @@ end
 describe Subclassed do
   subject { Subclassed.new(first_name: 'Bob', last_name: 'McNob', email: 'bob@example.com') }
 
-  its(:count) { should be_zero }
+  describe '#count' do
+    subject { super().count }
+    it { should be_zero }
+  end
 
   it { should respond_to(:first_name) }
   it { should respond_to(:first_name=) }
@@ -320,10 +329,10 @@ describe Subclassed do
   it { should respond_to(:last_name=) }
 
   it 'has one additional property' do
-    described_class.property?(:last_name).should be_true
+    expect(described_class.property?(:last_name)).to be_true
   end
 
   it "didn't override superclass inheritance logic" do
-    described_class.instance_variable_get('@inheritance_test').should be_true
+    expect(described_class.instance_variable_get('@inheritance_test')).to be_true
   end
 end

data/spec/hashie/extensions/coercion_spec.rb

@@ -32,13 +32,13 @@ describe Hashie::Extensions::Coercion do
   let(:instance) { subject.new }
 
   describe '#coerce_key' do
-    it { subject.should be_respond_to(:coerce_key) }
+    it { expect(subject).to be_respond_to(:coerce_key) }
 
     it 'runs through coerce on a specified key' do
       subject.coerce_key :foo, Coercable
 
       instance[:foo] = 'bar'
-      instance[:foo].should be_coerced
+      expect(instance[:foo]).to be_coerced
     end
 
     it 'supports an array of keys' do
@@ -46,23 +46,23 @@ describe Hashie::Extensions::Coercion do
 
       instance[:foo] = 'bar'
       instance[:bar] = 'bax'
-      instance[:foo].should be_coerced
-      instance[:bar].should be_coerced
+      expect(instance[:foo]).to be_coerced
+      expect(instance[:bar]).to be_coerced
     end
 
     it 'calls #new if no coerce method is available' do
       subject.coerce_key :foo, Initializable
 
       instance[:foo] = 'bar'
-      instance[:foo].value.should eq 'String'
-      instance[:foo].should_not be_coerced
+      expect(instance[:foo].value).to eq 'String'
+      expect(instance[:foo]).not_to be_coerced
     end
 
     it 'coerces when the merge initializer is used' do
       subject.coerce_key :foo, Coercable
       instance = subject.new(foo: 'bar')
 
-      instance[:foo].should be_coerced
+      expect(instance[:foo]).to be_coerced
     end
 
     context 'when #replace is used' do
@@ -73,13 +73,13 @@ describe Hashie::Extensions::Coercion do
       end
 
       it 'coerces relevant keys' do
-        instance[:foo].should be_coerced
-        instance[:bar].should be_coerced
-        instance[:hi].should_not respond_to(:coerced?)
+        expect(instance[:foo]).to be_coerced
+        expect(instance[:bar]).to be_coerced
+        expect(instance[:hi]).not_to respond_to(:coerced?)
       end
 
       it 'sets correct values' do
-        instance[:hi].should eq 'bye'
+        expect(instance[:hi]).to eq 'bye'
       end
     end
 
@@ -93,25 +93,25 @@ describe Hashie::Extensions::Coercion do
 
       it 'coerces with instance initialization' do
         tweet = TweetMash.new(user: { email: 'foo@bar.com' })
-        tweet[:user].should be_a(UserMash)
+        expect(tweet[:user]).to be_a(UserMash)
       end
 
       it 'coerces when setting with attribute style' do
         tweet = TweetMash.new
         tweet.user = { email: 'foo@bar.com' }
-        tweet[:user].should be_a(UserMash)
+        expect(tweet[:user]).to be_a(UserMash)
       end
 
       it 'coerces when setting with string index' do
         tweet = TweetMash.new
         tweet['user'] = { email: 'foo@bar.com' }
-        tweet[:user].should be_a(UserMash)
+        expect(tweet[:user]).to be_a(UserMash)
       end
 
       it 'coerces when setting with symbol index' do
         tweet = TweetMash.new
         tweet[:user] = { email: 'foo@bar.com' }
-        tweet[:user].should be_a(UserMash)
+        expect(tweet[:user]).to be_a(UserMash)
       end
     end
   end
@@ -124,9 +124,9 @@ describe Hashie::Extensions::Coercion do
         instance[:foo] = 'bar'
         instance[:bar] = 'bax'
         instance[:hi]  = :bye
-        instance[:foo].should be_coerced
-        instance[:bar].should be_coerced
-        instance[:hi].should_not respond_to(:coerced?)
+        expect(instance[:foo]).to be_coerced
+        expect(instance[:bar]).to be_coerced
+        expect(instance[:hi]).not_to respond_to(:coerced?)
       end
 
       it 'coerces values from a #replace call' do
@@ -134,8 +134,8 @@ describe Hashie::Extensions::Coercion do
 
         instance[:foo] = :bar
         instance.replace(foo: 'bar', bar: 'bax')
-        instance[:foo].should be_coerced
-        instance[:bar].should be_coerced
+        expect(instance[:foo]).to be_coerced
+        expect(instance[:bar]).to be_coerced
       end
 
       it 'does not coerce superclasses' do
@@ -143,9 +143,9 @@ describe Hashie::Extensions::Coercion do
         subject.coerce_value klass, Coercable
 
         instance[:foo] = 'bar'
-        instance[:foo].should_not be_kind_of(Coercable)
+        expect(instance[:foo]).not_to be_kind_of(Coercable)
         instance[:foo] = klass.new
-        instance[:foo].should be_kind_of(Coercable)
+        expect(instance[:foo]).to be_kind_of(Coercable)
       end
     end
   end

data/spec/hashie/extensions/deep_fetch_spec.rb

@@ -21,27 +21,27 @@ module Hashie
 
       describe '#deep_fetch' do
         it 'extracts a value from a nested hash' do
-          instance.deep_fetch(:library, :location, :address).should eq('123 Library St.')
+          expect(instance.deep_fetch(:library, :location, :address)).to 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')
+          expect(instance.deep_fetch(:library, :books, 1, :title)).to 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')
+              expect(value).to 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
+                expect do
                   instance.deep_fetch(:library, :books, 2)
-                end.should(
+                end.to(
                   raise_error(
                     DeepFetch::UndefinedPathError,
                     'Could not fetch path (library > books > 2) at 2'
@@ -52,9 +52,9 @@ module Hashie
 
             context 'when the nested object is a hash' do
               it 'raises a UndefinedPathError' do
-                lambda do
+                expect do
                   instance.deep_fetch(:library, :location, :unknown_key)
-                end.should(
+                end.to(
                   raise_error(
                     DeepFetch::UndefinedPathError,
                     'Could not fetch path (library > location > unknown_key) at unknown_key'

data/spec/hashie/extensions/deep_merge_spec.rb

@@ -12,11 +12,11 @@ describe Hashie::Extensions::DeepMerge do
   let(:expected_hash) { { a: 1, a1: 1, b: 'b', c: { c1: 2, c2: 'c2', c3: { d1: 'd1', d2: 'd2' } } } }
 
   it 'deep merges two hashes' do
-    h1.deep_merge(h2).should eq expected_hash
+    expect(h1.deep_merge(h2)).to eq expected_hash
   end
 
   it 'deep merges another hash in place via bang method' do
     h1.deep_merge!(h2)
-    h1.should eq expected_hash
+    expect(h1).to eq expected_hash
   end
 end