hashie 2.0.5 → 2.1.0

data/spec/hashie/extensions/merge_initializer_spec.rb

@@ -1,20 +1,23 @@
 require 'spec_helper'
 
 describe Hashie::Extensions::MergeInitializer do
-  class MergeInitializerHash < Hash; include Hashie::Extensions::MergeInitializer end
-  subject{ MergeInitializerHash }
+  class MergeInitializerHash < Hash
+    include Hashie::Extensions::MergeInitializer
+  end
+
+  subject { MergeInitializerHash }
 
-  it 'should initialize fine with no arguments' do
-    subject.new.should == {}
+  it 'initializes with no arguments' do
+    subject.new.should eq({})
   end
 
-  it 'should initialize with a hash' do
-    subject.new(:abc => 'def').should == {:abc => 'def'}
+  it 'initializes with a hash' do
+    subject.new(abc: 'def').should eq(abc: 'def')
   end
 
-  it 'should initialize with a hash and a default' do
-    h = subject.new({:abc => 'def'}, 'bar')
-    h[:foo].should == 'bar'
-    h[:abc].should == 'def'
+  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'
   end
 end

data/spec/hashie/extensions/method_access_spec.rb

@@ -2,39 +2,43 @@ require 'spec_helper'
 
 describe Hashie::Extensions::MethodReader do
   class ReaderHash < Hash
-    def initialize(hash = {}); self.update(hash) end
     include Hashie::Extensions::MethodReader
+
+    def initialize(hash = {})
+      update(hash)
+    end
   end
-  subject{ ReaderHash }
 
-  it 'should read string keys from the method' do
-    subject.new('awesome' => 'sauce').awesome.should == 'sauce'
+  subject { ReaderHash }
+
+  it 'reads string keys from the method' do
+    subject.new('awesome' => 'sauce').awesome.should eq 'sauce'
   end
 
-  it 'should read symbol keys from the method' do
-    subject.new(:awesome => 'sauce').awesome.should == 'sauce'
+  it 'reads symbol keys from the method' do
+    subject.new(awesome: 'sauce').awesome.should eq 'sauce'
   end
 
-  it 'should read nil and false values out properly' do
-    h = subject.new(:nil => nil, :false => false)
-    h.nil.should == nil
-    h.false.should == false
+  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
   end
 
-  it 'should raise a NoMethodError for undefined keys' do
-    lambda{ subject.new.awesome }.should raise_error(NoMethodError)
+  it 'raises a NoMethodError for undefined keys' do
+    lambda { subject.new.awesome }.should raise_error(NoMethodError)
   end
 
   describe '#respond_to?' do
-    it 'should be true for string keys' do
+    it 'is true for string keys' do
       subject.new('awesome' => 'sauce').should be_respond_to(:awesome)
     end
 
-    it 'should be true for symbol keys' do
-      subject.new(:awesome => 'sauce').should be_respond_to(:awesome)
+    it 'is true for symbol keys' do
+      subject.new(awesome: 'sauce').should be_respond_to(:awesome)
     end
 
-    it 'should be false for non-keys' do
+    it 'is false for non-keys' do
       subject.new.should_not be_respond_to(:awesome)
     end
   end
@@ -44,24 +48,25 @@ describe Hashie::Extensions::MethodWriter do
   class WriterHash < Hash
     include Hashie::Extensions::MethodWriter
   end
-  subject{ WriterHash.new }
 
-  it 'should write from a method call' do
+  subject { WriterHash.new }
+
+  it 'writes from a method call' do
     subject.awesome = 'sauce'
-    subject['awesome'].should == 'sauce'
+    subject['awesome'].should eq 'sauce'
   end
 
-  it 'should convert the key using the #convert_key method' do
+  it 'converts the key using the #convert_key method' do
     subject.stub!(:convert_key).and_return(:awesome)
     subject.awesome = 'sauce'
-    subject[:awesome].should == 'sauce'
+    subject[:awesome].should eq 'sauce'
   end
 
-  it 'should still NoMethodError on non equals-ending methods' do
-    lambda{ subject.awesome }.should raise_error(NoMethodError)
+  it 'raises NoMethodError on non equals-ending methods' do
+    lambda { subject.awesome }.should raise_error(NoMethodError)
   end
 
-  it 'should #respond_to? properly' do
+  it '#respond_to? correctly' do
     subject.should be_respond_to(:abc=)
     subject.should_not be_respond_to(:abc)
   end
@@ -69,44 +74,48 @@ end
 
 describe Hashie::Extensions::MethodQuery do
   class QueryHash < Hash
-    def initialize(hash = {}); self.update(hash) end
     include Hashie::Extensions::MethodQuery
+
+    def initialize(hash = {})
+      update(hash)
+    end
   end
-  subject{ QueryHash }
-  
-  it 'should be true for non-nil string key values' do
+
+  subject { QueryHash }
+
+  it 'is true for non-nil string key values' do
     subject.new('abc' => 123).should be_abc
   end
 
-  it 'should be true for non-nil symbol key values' do
-    subject.new(:abc => 123).should be_abc
+  it 'is true for non-nil symbol key values' do
+    subject.new(abc: 123).should be_abc
   end
 
-  it 'should be false for nil key values' do
-    subject.new(:abc => false).should_not be_abc
+  it 'is false for nil key values' do
+    subject.new(abc: false).should_not be_abc
   end
 
-  it 'should raise a NoMethodError for non-set keys' do
-    lambda{ subject.new.abc? }.should raise_error(NoMethodError)
+  it 'raises a NoMethodError for non-set keys' do
+    lambda { subject.new.abc? }.should raise_error(NoMethodError)
   end
 
-  it 'should respond_to? for existing string keys' do
+  it '#respond_to? for existing string keys' do
     subject.new('abc' => 'def').should be_respond_to('abc?')
   end
 
-  it 'should respond_to? for existing symbol keys' do
-    subject.new(:abc => 'def').should be_respond_to(:abc?)
+  it '#respond_to? for existing symbol keys' do
+    subject.new(abc: 'def').should be_respond_to(:abc?)
   end
 
-  it 'should not respond_to? for non-existent keys' do
+  it 'does not #respond_to? for non-existent keys' do
     subject.new.should_not be_respond_to('abc?')
   end
 end
 
 describe Hashie::Extensions::MethodAccess do
-  it 'should include all of the other method mixins' 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 == 3
+    (klass.ancestors & [Hashie::Extensions::MethodReader, Hashie::Extensions::MethodWriter, Hashie::Extensions::MethodQuery]).size.should eq 3
   end
 end

data/spec/hashie/hash_spec.rb

@@ -1,22 +1,34 @@
 require 'spec_helper'
 
 describe Hash do
-  it "should be convertible to a Hashie::Mash" do
-    mash = Hashie::Hash[:some => "hash"].to_mash
+  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 == "hash"
+    mash.some.should eq 'hash'
   end
-  
-  it "#stringify_keys! should turn all keys into strings" do
-    hash = Hashie::Hash[:a => "hey", 123 => "bob"]
+
+  it '#stringify_keys! turns all keys into strings' do
+    hash = Hashie::Hash[:a => 'hey', 123 => 'bob']
     hash.stringify_keys!
-    hash.should == Hashie::Hash["a" => "hey", "123" => "bob"]
+    hash.should eq Hashie::Hash['a' => 'hey', '123' => 'bob']
   end
-  
-  it "#stringify_keys should return a hash with stringified keys" do
-    hash = Hashie::Hash[:a => "hey", 123 => "bob"]
+
+  it '#stringify_keys returns a hash with stringified keys' do
+    hash = Hashie::Hash[:a => 'hey', 123 => 'bob']
     stringified_hash = hash.stringify_keys
-    hash.should == Hashie::Hash[:a => "hey", 123 => "bob"]
-    stringified_hash.should == Hashie::Hash["a" => "hey", "123" => "bob"]
+    hash.should eq Hashie::Hash[:a => 'hey', 123 => 'bob']
+    stringified_hash.should 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])
+  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])
   end
-end
+end

data/spec/hashie/mash_spec.rb

@@ -2,207 +2,232 @@ require 'spec_helper'
 require 'delegate'
 
 describe Hashie::Mash do
-  before(:each) do
-    @mash = Hashie::Mash.new
-  end
+  subject { Hashie::Mash.new }
 
-  it "should inherit from hash" do
-    @mash.is_a?(Hash).should be_true
+  it 'inherits from Hash' do
+    subject.is_a?(Hash).should be_true
   end
 
-  it "should be able to set hash values through method= calls" do
-    @mash.test = "abc"
-    @mash["test"].should == "abc"
+  it 'sets hash values through method= calls' do
+    subject.test = 'abc'
+    subject['test'].should eq 'abc'
   end
 
-  it "should be able to retrieve set values through method calls" do
-    @mash["test"] = "abc"
-    @mash.test.should == "abc"
+  it 'retrieves set values through method calls' do
+    subject['test'] = 'abc'
+    subject.test.should eq 'abc'
   end
 
-  it "should be able to retrieve set values through blocks" do
-    @mash["test"] = "abc"
+  it 'retrieves set values through blocks' do
+    subject['test'] = 'abc'
     value = nil
-    @mash.[]("test") { |v| value = v }
-    value.should == "abc"
+    subject.[]('test') { |v| value = v }
+    value.should eq 'abc'
   end
 
-  it "should be able to retrieve set values through blocks with method calls" do
-    @mash["test"] = "abc"
+  it 'retrieves set values through blocks with method calls' do
+    subject['test'] = 'abc'
     value = nil
-    @mash.test { |v| value = v }
-    value.should == "abc"
+    subject.test { |v| value = v }
+    value.should eq 'abc'
+  end
+
+  it 'tests for already set values when passed a ? method' do
+    subject.test?.should be_false
+    subject.test = 'abc'
+    subject.test?.should be_true
   end
 
-  it "should test for already set values when passed a ? method" do
-    @mash.test?.should be_false
-    @mash.test = "abc"
-    @mash.test?.should be_true
+  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
+    subject.test = false
+    subject.should_not be_test
   end
 
-  it "should return false on a ? method if a value has been set to nil or false" do
-    @mash.test = nil
-    @mash.should_not be_test
-    @mash.test = false
-    @mash.should_not be_test
+  it 'makes all [] and []= into strings for consistency' do
+    subject['abc'] = 123
+    subject.key?('abc').should be_true
+    subject['abc'].should eq 123
   end
 
-  it "should make all [] and []= into strings for consistency" do
-    @mash["abc"] = 123
-    @mash.key?('abc').should be_true
-    @mash["abc"].should == 123
+  it 'has a to_s that is identical to its inspect' do
+    subject.abc = 123
+    subject.to_s.should eq subject.inspect
   end
 
-  it "should have a to_s that is identical to its inspect" do
-    @mash.abc = 123
-    @mash.to_s.should == @mash.inspect
+  it 'returns nil instead of raising an error for attribute-esque method calls' do
+    subject.abc.should be_nil
   end
 
-  it "should return nil instead of raising an error for attribute-esque method calls" do
-    @mash.abc.should be_nil
+  it 'returns the default value if set like Hash' do
+    subject.default = 123
+    subject.abc.should eq 123
   end
 
-  it "should return a Hashie::Mash when passed a bang method to a non-existenct key" do
-    @mash.abc!.is_a?(Hashie::Mash).should be_true
+  it 'gracefully handles being accessed with arguments' do
+    subject.abc('foobar').should eq nil
+    subject.abc = 123
+    subject.abc('foobar').should eq 123
   end
 
-  it "should return the existing value when passed a bang method for an existing key" do
-    @mash.name = "Bob"
-    @mash.name!.should == "Bob"
+  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
   end
 
-  it "should return a Hashie::Mash when passed an under bang method to a non-existenct key" do
-    @mash.abc_.is_a?(Hashie::Mash).should be_true
+  it 'returns the existing value when passed a bang method for an existing key' do
+    subject.name = 'Bob'
+    subject.name!.should eq 'Bob'
   end
 
-  it "should return the existing value when passed an under bang method for an existing key" do
-    @mash.name = "Bob"
-    @mash.name_.should == "Bob"
+  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
   end
 
-  it "#initializing_reader should return a Hashie::Mash when passed a non-existent key" do
-    @mash.initializing_reader(:abc).is_a?(Hashie::Mash).should be_true
+  it 'returns the existing value when passed an under bang method for an existing key' do
+    subject.name = 'Bob'
+    subject.name_.should eq 'Bob'
   end
 
-  it "should allow for multi-level assignment through bang methods" do
-    @mash.author!.name = "Michael Bleigh"
-    @mash.author.should == Hashie::Mash.new(:name => "Michael Bleigh")
-    @mash.author!.website!.url = "http://www.mbleigh.com/"
-    @mash.author.website.should == Hashie::Mash.new(:url => "http://www.mbleigh.com/")
+  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
   end
 
-  it "should allow for multi-level under bang testing" do
-    @mash.author_.website_.url.should be_nil
-    @mash.author_.website_.url?.should == false
-    @mash.author.should be_nil
+  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')
+    subject.author!.website!.url = 'http://www.mbleigh.com/'
+    subject.author.website.should eq Hashie::Mash.new(url: 'http://www.mbleigh.com/')
   end
 
-  it "should not call super if id is not a key" do
-    @mash.id.should == nil
+  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
   end
 
-  it "should return the value if id is a key" do
-    @mash.id = "Steve"
-    @mash.id.should == "Steve"
+  it 'does not call super if id is not a key' do
+    subject.id.should eq nil
   end
 
-  it "should not call super if type is not a key" do
-    @mash.type.should == nil
+  it 'returns the value if id is a key' do
+    subject.id = 'Steve'
+    subject.id.should eq 'Steve'
   end
 
-  it "should return the value if type is a key" do
-    @mash.type = "Steve"
-    @mash.type.should == "Steve"
+  it 'does not call super if type is not a key' do
+    subject.type.should eq nil
   end
 
-  context "updating" do
-    subject {
-      described_class.new :first_name => "Michael", :last_name => "Bleigh",
-        :details => {:email => "michael@asf.com", :address => "Nowhere road"}
-    }
+  it 'returns the value if type is a key' do
+    subject.type = 'Steve'
+    subject.type.should eq 'Steve'
+  end
 
-    describe "#deep_update" do
-      it "should recursively Hashie::Mash Hashie::Mashes and hashes together" do
-        subject.deep_update(:details => {:email => "michael@intridea.com", :city => "Imagineton"})
-        subject.first_name.should == "Michael"
-        subject.details.email.should == "michael@intridea.com"
-        subject.details.address.should == "Nowhere road"
-        subject.details.city.should == "Imagineton"
+  context 'updating' do
+    subject do
+      described_class.new(
+        first_name: 'Michael',
+        last_name: 'Bleigh',
+        details: {
+          email: 'michael@asf.com',
+          address: 'Nowhere road'
+        })
+    end
+
+    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'
       end
 
-      it "should make #update deep by default" do
-        subject.update(:details => {:address => "Fake street"}).should eql(subject)
-        subject.details.address.should == "Fake street"
-        subject.details.email.should == "michael@asf.com"
+      it 'converts values only once' do
+        class ConvertedMash < Hashie::Mash
+        end
+
+        rhs = ConvertedMash.new(email: 'foo@bar.com')
+        subject.should_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'
       end
 
-      it "should clone before a #deep_merge" do
-        duped = subject.deep_merge(:details => {:address => "Fake street"})
+      it 'clones before a #deep_merge' do
+        duped = subject.deep_merge(details: { address: 'Fake street' })
         duped.should_not eql(subject)
-        duped.details.address.should == "Fake street"
-        subject.details.address.should == "Nowhere road"
-        duped.details.email.should == "michael@asf.com"
+        duped.details.address.should eq 'Fake street'
+        subject.details.address.should eq 'Nowhere road'
+        duped.details.email.should eq 'michael@asf.com'
       end
 
-      it "regular #merge should be deep" do
-        duped = subject.merge(:details => {:email => "michael@intridea.com"})
+      it 'default #merge is deep' do
+        duped = subject.merge(details: { email: 'michael@intridea.com' })
         duped.should_not eql(subject)
-        duped.details.email.should == "michael@intridea.com"
-        duped.details.address.should == "Nowhere road"
+        duped.details.email.should eq 'michael@intridea.com'
+        duped.details.address.should 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 == 'Nowhere road, Pasadena CA'
+      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'
       end
     end
 
-    describe "shallow update" do
-      it "should shallowly Hashie::Mash Hashie::Mashes and hashes together" do
-        subject.shallow_update(:details => {
-          :email => "michael@intridea.com", :city => "Imagineton"
+    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 == "Michael"
-        subject.details.email.should == "michael@intridea.com"
+        subject.first_name.should eq 'Michael'
+        subject.details.email.should eq 'michael@intridea.com'
         subject.details.address.should be_nil
-        subject.details.city.should == "Imagineton"
+        subject.details.city.should eq 'Imagineton'
       end
 
-      it "should clone before a #regular_merge" do
-        duped = subject.shallow_merge(:details => {:address => "Fake street"})
+      it 'clones before a #regular_merge' do
+        duped = subject.shallow_merge(details: { address: 'Fake street' })
         duped.should_not eql(subject)
       end
 
-      it "regular merge should be shallow" do
-        duped = subject.shallow_merge(:details => {:address => "Fake street"})
-        duped.details.address.should == "Fake street"
-        subject.details.address.should == "Nowhere road"
+      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
       end
     end
 
     describe '#replace' do
       before do
-        subject.replace(:middle_name => "Cain",
-          :details => {:city => "Imagination"})
+        subject.replace(
+          middle_name: 'Cain',
+          details: { city: 'Imagination' }
+        )
       end
 
-      it 'return self' do
-        subject.replace(:foo => "bar").to_hash.should == {"foo" => "bar"}
+      it 'returns self' do
+        subject.replace(foo: 'bar').to_hash.should 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 == "Cain"
+        subject.middle_name.should eq 'Cain'
         subject.details.city?.should be_true
-        subject.details.city.should == "Imagination"
+        subject.details.city.should eq 'Imagination'
       end
 
       it 'leaves only specified keys' do
-        subject.keys.sort.should == ['details', 'middle_name']
+        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
@@ -211,13 +236,13 @@ describe Hashie::Mash do
     end
 
     describe 'delete' do
-      it 'should delete with String key' do
+      it 'deletes with String key' do
         subject.delete('details')
         subject.details.should be_nil
         subject.should_not be_respond_to :details
       end
 
-      it 'should delete with Symbol key' do
+      it 'deletes with Symbol key' do
         subject.delete(:details)
         subject.details.should be_nil
         subject.should_not be_respond_to :details
@@ -225,22 +250,22 @@ describe Hashie::Mash do
     end
   end
 
-  it "should convert hash assignments into Hashie::Mashes" do
-    @mash.details = {:email => 'randy@asf.com', :address => {:state => 'TX'} }
-    @mash.details.email.should == 'randy@asf.com'
-    @mash.details.address.state.should == 'TX'
+  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'
   end
 
-  it "should not convert the type of Hashie::Mashes childs to Hashie::Mash" do
+  it 'does not convert the type of Hashie::Mashes childs to Hashie::Mash' do
     class MyMash < Hashie::Mash
     end
 
     record = MyMash.new
     record.son = MyMash.new
-    record.son.class.should == MyMash
+    record.son.class.should eq MyMash
   end
 
-  it "should not change the class of Mashes when converted" do
+  it 'does not change the class of Mashes when converted' do
     class SubMash < Hashie::Mash
     end
 
@@ -250,7 +275,7 @@ describe Hashie::Mash do
     record['submash'].should be_kind_of(SubMash)
   end
 
-  it "should respect the class when passed a bang method for a non-existent key" do
+  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)
 
@@ -261,7 +286,7 @@ describe Hashie::Mash do
     son.non_existent!.should be_kind_of(SubMash)
   end
 
-  it "should respect the class when passed an under bang method for a non-existent key" do
+  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)
 
@@ -272,141 +297,172 @@ describe Hashie::Mash do
     son.non_existent_.should be_kind_of(SubMash)
   end
 
-  it "should respect the class when converting the value" do
+  it 'respects the class when converting the value' do
     record = Hashie::Mash.new
-    record.details = Hashie::Mash.new({:email => "randy@asf.com"})
+    record.details = Hashie::Mash.new(email: 'randy@asf.com')
     record.details.should be_kind_of(Hashie::Mash)
   end
 
-  it "should respect another subclass when converting the value" do
+  it 'respects another subclass when converting the value' do
     record = Hashie::Mash.new
 
     class SubMash < Hashie::Mash
     end
 
-    son = SubMash.new({:email => "foo@bar.com"})
+    son = SubMash.new(email: 'foo@bar.com')
     record.details = son
     record.details.should be_kind_of(SubMash)
   end
 
-  describe "#respond_to?" do
-    it 'should respond to a normal method' do
+  describe '#respond_to?' do
+    it 'responds to a normal method' do
       Hashie::Mash.new.should be_respond_to(:key?)
     end
 
-    it 'should respond to a set key' do
-      Hashie::Mash.new(:abc => 'def').should be_respond_to(:abc)
+    it 'responds to a set key' do
+      Hashie::Mash.new(abc: 'def').should be_respond_to(:abc)
     end
 
-    it 'should respond to a set key with a suffix' do
+    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}")
+        Hashie::Mash.new(abc: 'def').should be_respond_to(:"abc#{suffix}")
       end
     end
 
-    it 'should respond to an unknown key with a suffix' do
+    it 'does not respond to an unknown key with a suffix' do
       %w(= ? ! _).each do |suffix|
-        Hashie::Mash.new(:abc => 'def').should be_respond_to(:"xyz#{suffix}")
+        Hashie::Mash.new(abc: 'def').should_not be_respond_to(:"xyz#{suffix}")
       end
     end
 
-    it "should not respond to an unknown key without a suffix" do
-      Hashie::Mash.new(:abc => 'def').should_not be_respond_to(:xyz)
+    it 'does not respond to an unknown key without a suffix' do
+      Hashie::Mash.new(abc: 'def').should_not be_respond_to(:xyz)
+    end
+
+    it 'does not respond to permitted?' do
+      Hashie::Mash.new.should_not be_respond_to(:permitted?)
     end
   end
 
-  context "#initialize" do
-    it "should convert an existing hash to a Hashie::Mash" do
-      converted = Hashie::Mash.new({:abc => 123, :name => "Bob"})
-      converted.abc.should == 123
-      converted.name.should == "Bob"
+  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'
     end
 
-    it "should convert hashes recursively into Hashie::Mashes" do
-      converted = Hashie::Mash.new({:a => {:b => 1, :c => {:d => 23}}})
+    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 == 1
-      converted.a.c.d.should == 23
+      converted.a.b.should eq 1
+      converted.a.c.d.should eq 23
     end
 
-    it "should convert hashes in arrays into Hashie::Mashes" do
-      converted = Hashie::Mash.new({:a => [{:b => 12}, 23]})
-      converted.a.first.b.should == 12
-      converted.a.last.should == 23
+    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
     end
 
-    it "should convert an existing Hashie::Mash into a Hashie::Mash" do
-      initial = Hashie::Mash.new(:name => 'randy', :address => {:state => 'TX'})
+    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 == copy.name
-      initial.__id__.should_not == copy.__id__
-      copy.address.state.should == 'TX'
+      initial.name.should eq copy.name
+      initial.__id__.should_not eq copy.__id__
+      copy.address.state.should eq 'TX'
       copy.address.state = 'MI'
-      initial.address.state.should == 'TX'
-      copy.address.__id__.should_not == initial.address.__id__
+      initial.address.state.should eq 'TX'
+      copy.address.__id__.should_not eq initial.address.__id__
     end
 
-    it "should accept a default block" do
-      initial = Hashie::Mash.new { |h,i| h[i] = []}
+    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 == []
+      initial.test.should eq []
       initial.test?.should be_true
     end
 
-    it "should convert Hashie::Mashes within Arrays back to Hashes" do
-      initial_hash = {"a" => [{"b" => 12, "c" =>["d" => 50, "e" => 51]}, 23]}
+    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
-      converted.to_hash({:symbolize_keys => true}).keys[0].should == :a
+      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
     end
   end
 
-  describe "#fetch" do
-    let(:hash) { {:one => 1, :other => false} }
+  describe '#fetch' do
+    let(:hash) { { one: 1, other: false } }
     let(:mash) { Hashie::Mash.new(hash) }
 
-    context "when key exists" do
-      it "returns the value" do
+    context 'when key exists' do
+      it 'returns the value' do
         mash.fetch(:one).should eql(1)
       end
 
-      it "returns the value even if the value is falsy" do
+      it 'returns the value even if the value is falsy' do
         mash.fetch(:other).should eql(false)
       end
 
-      context "when key has other than original but acceptable type" do
-        it "returns the value" do
+      context 'when key has other than original but acceptable type' do
+        it 'returns the value' do
           mash.fetch('one').should eql(1)
         end
       end
     end
 
-    context "when key does not exist" do
-      it "should raise KeyError" do
+    context 'when key does not exist' do
+      it 'raises KeyError' do
         error = RUBY_VERSION =~ /1.8/ ? IndexError : KeyError
         expect { mash.fetch(:two) }.to raise_error(error)
       end
 
-      context "with default value given" do
-        it "returns default value" do
+      context 'with default value given' do
+        it 'returns default value' do
           mash.fetch(:two, 8).should eql(8)
         end
 
-        it "returns default value even if it is falsy" do
+        it 'returns default value even if it is falsy' do
           mash.fetch(:two, false).should eql(false)
         end
       end
 
-      context "with block given" do
-        it "returns default value" do
-          mash.fetch(:two) {|key|
-            "block default value"
-          }.should eql("block default value")
+      context 'with block given' do
+        it 'returns default value' do
+          mash.fetch(:two) do |key|
+            'block default value'
+          end.should eql('block default value')
         end
       end
     end
   end
+
+  describe '#to_hash' do
+    let(:hash) { { 'outer' => { 'inner' => 42 }, 'testing' => [1, 2, 3] } }
+    let(:mash) { Hashie::Mash.new(hash) }
+
+    it 'returns a standard Hash' do
+      mash.to_hash.should be_a(::Hash)
+    end
+
+    it 'includes all keys' do
+      mash.to_hash.keys.should 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')
+    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)
+    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')
+    end
+  end
 end