hashie 2.0.5 → 2.1.0

data/lib/hashie/version.rb

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

data/spec/hashie/clash_spec.rb

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

data/spec/hashie/dash_spec.rb

@@ -7,41 +7,45 @@ Hashie::Hash.class_eval do
 end
 
 class DashTest < Hashie::Dash
-  property :first_name, :required => true
+  property :first_name, required: true
   property :email
-  property :count, :default => 0
+  property :count, default: 0
 end
 
 class DashNoRequiredTest < Hashie::Dash
   property :first_name
   property :email
-  property :count, :default => 0
+  property :count, default: 0
+end
+
+class PropertyBangTest < Hashie::Dash
+  property :important!
 end
 
 class Subclassed < DashTest
-  property :last_name, :required => true
+  property :last_name, required: true
 end
 
 class DashDefaultTest < Hashie::Dash
-  property :aliases, :default => ["Snake"]
+  property :aliases, default: ['Snake']
 end
 
 class DeferredTest < Hashie::Dash
-  property :created_at, :default => Proc.new { Time.now }
+  property :created_at, default: proc { Time.now }
 end
 
 describe DashTest do
 
-  subject { DashTest.new(:first_name => 'Bob', :email => 'bob@example.com') }
+  subject { DashTest.new(first_name: 'Bob', email: 'bob@example.com') }
 
   it('subclasses Hashie::Hash') { should respond_to(:to_mash) }
 
-  its(:to_s) { should == '#<DashTest count=0 email="bob@example.com" first_name="Bob">' }
+  its(:to_s) { should eq '#<DashTest count=0 email="bob@example.com" first_name="Bob">' }
 
   it 'lists all set properties in inspect' do
     subject.first_name = 'Bob'
     subject.email = 'bob@example.com'
-    subject.inspect.should == '#<DashTest count=0 email="bob@example.com" first_name="Bob">'
+    subject.inspect.should eq '#<DashTest count=0 email="bob@example.com" first_name="Bob">'
   end
 
   its(:count) { should be_zero }
@@ -59,7 +63,6 @@ describe DashTest do
   end
 
   context 'writing to properties' do
-
     it 'fails writing a required property to nil' do
       lambda { subject.first_name = nil }.should raise_error(ArgumentError)
     end
@@ -74,13 +77,13 @@ describe DashTest do
 
     it 'works for an existing property using []=' do
       subject['first_name'] = 'Bob'
-      subject['first_name'].should == 'Bob'
-      subject[:first_name].should == 'Bob'
+      subject['first_name'].should eq 'Bob'
+      subject[:first_name].should eq 'Bob'
     end
 
     it 'works for an existing property using a method call' do
       subject.first_name = 'Franklin'
-      subject.first_name.should == 'Franklin'
+      subject.first_name.should eq 'Franklin'
     end
   end
 
@@ -89,40 +92,40 @@ describe DashTest do
       lambda { subject['nonexistent'] }.should raise_error(NoMethodError)
     end
 
-    it "should be able to retrieve properties through blocks" do
-      subject["first_name"] = "Aiden"
+    it 'is able to retrieve properties through blocks' do
+      subject['first_name'] = 'Aiden'
       value = nil
-      subject.[]("first_name") { |v| value = v }
-      value.should == "Aiden"
+      subject.[]('first_name') { |v| value = v }
+      value.should eq 'Aiden'
     end
 
-    it "should be able to retrieve properties through blocks with method calls" do
-      subject["first_name"] = "Frodo"
+    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 == "Frodo"
+      value.should eq 'Frodo'
     end
   end
 
   context 'reading from deferred properties' do
-    it 'should evaluate proc after initial read' do
+    it 'evaluates proc after initial read' do
       DeferredTest.new['created_at'].should be_instance_of(Time)
     end
 
-    it "should not evalute proc after subsequent reads" do
+    it 'does not evalute proc after subsequent reads' do
       deferred = DeferredTest.new
-      deferred['created_at'].object_id.should == deferred['created_at'].object_id
+      deferred['created_at'].object_id.should eq deferred['created_at'].object_id
     end
   end
 
-  describe '.new' do
+  describe '#new' do
     it 'fails with non-existent properties' do
-      lambda { described_class.new(:bork => '') }.should raise_error(NoMethodError)
+      lambda { described_class.new(bork: '') }.should raise_error(NoMethodError)
     end
 
-    it 'should set properties that it is able to' do
-      obj = described_class.new :first_name => 'Michael'
-      obj.first_name.should == 'Michael'
+    it 'sets properties that it is able to' do
+      obj = described_class.new first_name: 'Michael'
+      obj.first_name.should eq 'Michael'
     end
 
     it 'accepts nil' do
@@ -131,25 +134,83 @@ describe DashTest do
 
     it 'accepts block to define a global default' do
       obj = described_class.new { |hash, key| key.to_s.upcase }
-      obj.first_name.should == 'FIRST_NAME'
+      obj.first_name.should eq 'FIRST_NAME'
       obj.count.should be_zero
     end
 
-    it "fails when required values are missing" do
+    it 'fails when required values are missing' do
       expect { DashTest.new }.to raise_error(ArgumentError)
     end
 
-    it "does not overwrite default values" do
+    it 'does not overwrite default values' do
       obj1 = DashDefaultTest.new
-      obj1.aliases << "El Rey"
+      obj1.aliases << 'El Rey'
       obj2 = DashDefaultTest.new
-      obj2.aliases.should_not include "El Rey"
+      obj2.aliases.should_not 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
+    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'
+    end
+
+    it 'fails with non-existent properties' do
+      expect { subject.merge(middle_name: 'James') }.to raise_error(NoMethodError)
+    end
+
+    it 'errors out when attempting to set a required property to nil' do
+      expect { subject.merge(first_name: nil) }.to raise_error(ArgumentError)
+    end
+
+    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|
+          "#{key}: #{newval} #{oldval}"
+        end.first_name.should eq 'first_name: Jim Bob'
+      end
+    end
+  end
+
+  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
+    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'
+    end
+
+    it 'fails with non-existent properties' do
+      expect { subject.merge!(middle_name: 'James') }.to raise_error(NoMethodError)
+    end
+
+    it 'errors out when attempting to set a required property to nil' do
+      expect { subject.merge!(first_name: nil) }.to raise_error(ArgumentError)
+    end
+
+    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|
+          "#{key}: #{newval} #{oldval}"
+        end.first_name.should eq 'first_name: Jim Bob'
+      end
     end
   end
 
   describe 'properties' do
     it 'lists defined properties' do
-      described_class.properties.should == Set.new([:first_name, :email, :count])
+      described_class.properties.should eq Set.new([:first_name, :email, :count])
     end
 
     it 'checks if a property exists' do
@@ -167,33 +228,36 @@ describe DashTest do
     end
 
     it 'lists declared defaults' do
-      described_class.defaults.should == { :count => 0 }
+      described_class.defaults.should eq(count: 0)
+    end
+
+    it 'allows properties that end in bang' do
+      PropertyBangTest.property?(:important!).should be_true
     end
   end
 
   describe '#replace' do
-    before { subject.replace(:first_name => "Cain") }
+    before { subject.replace(first_name: 'Cain') }
 
     it 'return self' do
-      subject.replace(:email => "bar").to_hash.
-        should == {"email" => "bar", "count" => 0}
+      subject.replace(email: 'bar').to_hash.should eq('email' => 'bar', 'count' => 0)
     end
 
     it 'sets all specified keys to their corresponding values' do
-      subject.first_name.should == "Cain"
+      subject.first_name.should eq 'Cain'
     end
 
     it 'leaves only specified keys and keys with default values' do
-      subject.keys.sort.should == ['count', 'first_name']
+      subject.keys.sort.should eq %w(count first_name)
       subject.email.should be_nil
-      subject.count.should == 0
+      subject.count.should eq 0
     end
 
     context 'when replacing keys with default values' do
-      before { subject.replace(:count => 3) }
+      before { subject.replace(count: 3) }
 
       it 'sets all specified keys to their corresponding values' do
-        subject.count.should == 3
+        subject.count.should eq 3
       end
     end
   end
@@ -225,29 +289,28 @@ describe Hashie::Dash, 'inheritance' do
 
   it 'allows overriding a default on an existing property' do
     @top.property :echo
-    @middle.property :echo, :default => 123
-    @bottom.properties.to_a.should == [:echo]
-    @bottom.new.echo.should == 123
+    @middle.property :echo, default: 123
+    @bottom.properties.to_a.should eq [:echo]
+    @bottom.new.echo.should eq 123
   end
 
   it 'allows clearing an existing default' do
     @top.property :echo
-    @middle.property :echo, :default => 123
+    @middle.property :echo, default: 123
     @bottom.property :echo
-    @bottom.properties.to_a.should == [:echo]
+    @bottom.properties.to_a.should eq [:echo]
     @bottom.new.echo.should be_nil
   end
 
-  it 'should allow nil defaults' do
-    @bottom.property :echo, :default => nil
+  it 'allows nil defaults' do
+    @bottom.property :echo, default: nil
     @bottom.new.should have_key('echo')
   end
 
 end
 
 describe Subclassed do
-
-  subject { Subclassed.new(:first_name => 'Bob', :last_name => 'McNob', :email => 'bob@example.com') }
+  subject { Subclassed.new(first_name: 'Bob', last_name: 'McNob', email: 'bob@example.com') }
 
   its(:count) { should be_zero }
 
@@ -263,5 +326,4 @@ describe Subclassed do
   it "didn't override superclass inheritance logic" do
     described_class.instance_variable_get('@inheritance_test').should be_true
   end
-
 end

data/spec/hashie/extensions/coercion_spec.rb

@@ -2,12 +2,16 @@ require 'spec_helper'
 
 describe Hashie::Extensions::Coercion do
   class Initializable
+    attr_reader :coerced, :value
+
     def initialize(obj, coerced = false)
       @coerced = coerced
       @value = obj.class.to_s
     end
-    def coerced?; @coerced end
-    attr_reader :value
+
+    def coerced?
+      !!@coerced
+    end
   end
 
   class Coercable < Initializable
@@ -22,39 +26,41 @@ describe Hashie::Extensions::Coercion do
       include Hashie::Extensions::MergeInitializer
     end
   end
+
   subject { ExampleCoercableHash }
-  let(:instance){ subject.new }
 
-  describe '.coerce_key' do
+  let(:instance) { subject.new }
+
+  describe '#coerce_key' do
     it { subject.should be_respond_to(:coerce_key) }
 
-    it 'should run through coerce on a specified key' do
+    it 'runs through coerce on a specified key' do
       subject.coerce_key :foo, Coercable
 
-      instance[:foo] = "bar"
+      instance[:foo] = 'bar'
       instance[:foo].should be_coerced
     end
 
-    it "should support an array of keys" do
+    it 'supports an array of keys' do
       subject.coerce_keys :foo, :bar, Coercable
 
-      instance[:foo] = "bar"
-      instance[:bar] = "bax"
+      instance[:foo] = 'bar'
+      instance[:bar] = 'bax'
       instance[:foo].should be_coerced
       instance[:bar].should be_coerced
     end
 
-    it 'should just call #new if no coerce method is available' do
+    it 'calls #new if no coerce method is available' do
       subject.coerce_key :foo, Initializable
 
-      instance[:foo] = "bar"
-      instance[:foo].value.should == "String"
+      instance[:foo] = 'bar'
+      instance[:foo].value.should eq 'String'
       instance[:foo].should_not be_coerced
     end
 
-    it "should coerce when the merge initializer is used" do
+    it 'coerces when the merge initializer is used' do
       subject.coerce_key :foo, Coercable
-      instance = subject.new(:foo => "bar")
+      instance = subject.new(foo: 'bar')
 
       instance[:foo].should be_coerced
     end
@@ -63,22 +69,21 @@ describe Hashie::Extensions::Coercion do
       before { subject.coerce_key :foo, :bar, Coercable }
 
       let(:instance) do
-        subject.new(:foo => "bar").
-          replace(:foo => "foz", :bar => "baz", :hi => "bye")
+        subject.new(foo: 'bar').replace(foo: 'foz', bar: 'baz', hi: 'bye')
       end
 
-      it "should coerce relevant keys" do
+      it 'coerces relevant keys' do
         instance[:foo].should be_coerced
         instance[:bar].should be_coerced
         instance[:hi].should_not respond_to(:coerced?)
       end
 
-      it "should set correct values" do
-        instance[:hi].should == "bye"
+      it 'sets correct values' do
+        instance[:hi].should eq 'bye'
       end
     end
 
-    context "when used with a Mash" do
+    context 'when used with a Mash' do
       class UserMash < Hashie::Mash
       end
       class TweetMash < Hashie::Mash
@@ -86,58 +91,58 @@ describe Hashie::Extensions::Coercion do
         coerce_key :user, UserMash
       end
 
-      it "should coerce with instance initialization" do
-        tweet = TweetMash.new(:user => {:email => 'foo@bar.com'})
+      it 'coerces with instance initialization' do
+        tweet = TweetMash.new(user: { email: 'foo@bar.com' })
         tweet[:user].should be_a(UserMash)
       end
 
-      it "should coerce when setting with attribute style" do
+      it 'coerces when setting with attribute style' do
         tweet = TweetMash.new
-        tweet.user = {:email => 'foo@bar.com'}
+        tweet.user = { email: 'foo@bar.com' }
         tweet[:user].should be_a(UserMash)
       end
 
-      it "should coerce when setting with string index" do
+      it 'coerces when setting with string index' do
         tweet = TweetMash.new
-        tweet['user'] = {:email => 'foo@bar.com'}
+        tweet['user'] = { email: 'foo@bar.com' }
         tweet[:user].should be_a(UserMash)
       end
 
-      it "should coerce when setting with symbol index" do
+      it 'coerces when setting with symbol index' do
         tweet = TweetMash.new
-        tweet[:user] = {:email => 'foo@bar.com'}
+        tweet[:user] = { email: 'foo@bar.com' }
         tweet[:user].should be_a(UserMash)
       end
     end
   end
 
-  describe '.coerce_value' do
-    context 'with :strict => true' do
-      it 'should coerce any value of the exact right class' do
+  describe '#coerce_value' do
+    context 'with strict: true' do
+      it 'coerces any value of the exact right class' do
         subject.coerce_value String, Coercable
 
-        instance[:foo] = "bar"
-        instance[:bar] = "bax"
+        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?)
       end
 
-      it 'should coerce values from a #replace call' do
+      it 'coerces values from a #replace call' do
         subject.coerce_value String, Coercable
 
         instance[:foo] = :bar
-        instance.replace(:foo => "bar", :bar => "bax")
+        instance.replace(foo: 'bar', bar: 'bax')
         instance[:foo].should be_coerced
         instance[:bar].should be_coerced
       end
 
-      it 'should not coerce superclasses' do
+      it 'does not coerce superclasses' do
         klass = Class.new(String)
         subject.coerce_value klass, Coercable
 
-        instance[:foo] = "bar"
+        instance[:foo] = 'bar'
         instance[:foo].should_not be_kind_of(Coercable)
         instance[:foo] = klass.new
         instance[:foo].should be_kind_of(Coercable)