attributor 5.0.2 → 5.1.0

data/spec/types/hash_spec.rb

@@ -1,8 +1,6 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
 
-
 describe Attributor::Hash do
-
   subject(:type) { Attributor::Hash }
 
   its(:native_type) { should be(type) }
@@ -16,45 +14,63 @@ describe Attributor::Hash do
         Class.new(Attributor::Model) do
           attributes do
             raise 'sorry :('
-            attribute :name, String
           end
         end
       end
 
       it 'throws original exception upon first run' do
-        lambda {
+        expect do
           broken_model.attributes
-        }.should raise_error(RuntimeError, 'sorry :(')
+        end.to raise_error(RuntimeError, 'sorry :(')
       end
+      context 'subsequent use' do
+        before do
+          expect do
+            broken_model.attributes
+          end.to raise_error(RuntimeError, 'sorry :(')
+        end
 
-      it 'throws InvalidDefinition for subsequent access' do
-        broken_model.attributes rescue nil
-
-        lambda {
-          broken_model.attributes
-        }.should raise_error(Attributor::InvalidDefinition)
-      end
+        it 'throws InvalidDefinition for subsequent access' do
+          expect do
+            broken_model.attributes
+          end.to raise_error(Attributor::InvalidDefinition)
+        end
 
-      it 'throws for any attempts at using of an instance of it' do
-        broken_model.attributes rescue nil
+        it 'throws for any attempts at using of an instance of it' do
+          instance = broken_model.new
+          expect do
+            instance.name
+          end.to raise_error(Attributor::InvalidDefinition)
+        end
 
-        instance = broken_model.new
-        lambda {
-          instance.name
-        }.should raise_error(Attributor::InvalidDefinition)
+        context 'for a type with a name' do
+          subject(:broken_model) do
+            Class.new(Attributor::Model) do
+              def self.name
+                'BrokenModel'
+              end
+              attributes do
+                raise 'sorry :('
+              end
+            end
+          end
+          it 'includes the correct type.name if applicable' do
+            expect do
+              broken_model.attributes
+            end.to raise_error(Attributor::InvalidDefinition, /BrokenModel/)
+          end
+        end
       end
-
     end
   end
 
   context 'default options' do
     subject(:options) { type.options }
     it 'has allow_extra false' do
-      options[:allow_extra].should be(false)
+      expect(options[:allow_extra]).to be(false)
     end
   end
 
-
   context '.example' do
     context 'for a simple hash' do
       subject(:example) { Attributor::Hash.example }
@@ -65,12 +81,12 @@ describe Attributor::Hash do
     end
 
     context 'for a typed hash' do
-      subject(:example){ Attributor::Hash.of(value: Integer).example}
+      subject(:example) { Attributor::Hash.of(value: Integer).example }
 
       it 'returns a hash with keys and/or values of the right type' do
-        example.should be_kind_of(Attributor::Hash)
-        example.keys.size.should > 0
-        example.values.all? {|v| v.kind_of? Integer}.should be(true)
+        expect(example).to be_kind_of(Attributor::Hash)
+        expect(example.keys.size).to be > 0
+        expect(example.values.all? { |v| v.is_a? Integer }).to be(true)
       end
     end
 
@@ -81,128 +97,129 @@ describe Attributor::Hash do
       subject(:example) { HashWithStrings.example(name: name, something: something) }
 
       context 'resolves a lazy attributes on demand' do
-        before { example.lazy_attributes.keys.should eq [:name, :something] }
-        after { example.lazy_attributes.keys.should eq [:something] }
+        before { expect(example.lazy_attributes.keys).to eq [:name, :something] }
+        after { expect(example.lazy_attributes.keys).to eq [:something] }
 
         it 'using get' do
-          example.get(:name).should be name
+          expect(example.get(:name)).to be name
         end
         it 'using []' do
-          example[:name].should be name
+          expect(example[:name]).to be name
         end
 
         it 'using set' do
           example.set :name, 'not bob'
-          example.get(:name).should == 'not bob'
+          expect(example.get(:name)).to eq 'not bob'
         end
         it 'using []=' do
           example[:name] = 'not bob'
-          example[:name].should == 'not bob'
+          expect(example[:name]).to eq 'not bob'
         end
       end
 
       its(:size) { should eq 2 }
-      its(:values) { should =~ [name, something] }
-      its(:keys) { should =~ [:name, :something] }
+      its(:values) { should match_array [name, something] }
+      its(:keys) { should match_array [:name, :something] }
       it do
         should_not be_empty
       end
 
       it 'responds to key? correctly' do
-        example.key?(:name).should be(true)
-        example.key?(:something).should be(true)
+        expect(example.key?(:name)).to be(true)
+        expect(example.key?(:something)).to be(true)
       end
 
       it 'enumerates the contents' do
-        example.collect {|k,v| k }.should eq [:name, :something ]
+        expect(example.collect { |k, _v| k }).to eq [:name, :something]
       end
 
       it 'enumerates the contents using each_pair' do
         pairs = []
-        example.each_pair {|pair| pairs << pair }
-        pairs.should =~ [ [:name, name], [:something, something] ]
+        example.each_pair { |pair| pairs << pair }
+        expect(pairs).to match_array [[:name, name], [:something, something]]
       end
 
-      its(:contents){ should eq ({name: name, something: something}) }
+      its(:contents) { should eq(name: name, something: something) }
       it 'does not create methods for the keys' do
-        example.should_not respond_to(:name)
-        example.should_not respond_to(:something)
+        expect(example).not_to respond_to(:name)
+        expect(example).not_to respond_to(:something)
       end
-
     end
 
     context 'using a non array context' do
       it 'should work for hashes with key/value types' do
-        expect{ Attributor::Hash.of(key:String,value:String).example("Not an Array") }.to_not raise_error
+        expect do
+          Attributor::Hash.of(key: String, value: String)
+                          .example('Not an Array')
+        end.to_not raise_error
       end
       it 'should work for hashes with keys defined' do
         block = proc { key 'a string', String }
-        hash = Attributor::Hash.of(key:String).construct(block)
+        hash = Attributor::Hash.of(key: String).construct(block)
 
-        expect{ hash.example("Not an Array") }.to_not raise_error
+        expect { hash.example('Not an Array') }.to_not raise_error
       end
     end
   end
 
   context '.load' do
-    let(:value) { {one: 'two', three: 4} }
+    let(:value) { { one: 'two', three: 4 } }
     subject(:hash) { type.load(value) }
 
     context 'for nil with recurse: true' do
       let(:value) { nil }
-      subject(:hash) { HashWithModel.load(value, recurse:true) }
+      subject(:hash) { HashWithModel.load(value, recurse: true) }
 
       it 'works' do
-        hash[:name].should eq('Turkey McDucken')
-        hash[:chicken].age.should eq(1)
+        expect(hash[:name]).to eq('Turkey McDucken')
+        expect(hash[:chicken].age).to eq(1)
       end
     end
 
     context 'for a simple hash' do
       it { should eq(value) }
       it 'equals the hash' do
-        hash.should eq value
-        hash[:one].should eq('two')
-        hash[:three].should eq(4)
+        expect(hash).to eq value
+        expect(hash[:one]).to eq('two')
+        expect(hash[:three]).to eq(4)
       end
     end
 
     context 'for a JSON encoded hash' do
-      let(:value_as_hash) { {'one' => 'two', 'three' => 4} }
-      let(:value) { JSON.dump( value_as_hash ) }
+      let(:value_as_hash) { { 'one' => 'two', 'three' => 4 } }
+      let(:value) { JSON.dump(value_as_hash) }
       it 'deserializes and converts it to a real hash' do
-        hash.should eq(value_as_hash)
-        hash['one'].should eq 'two'
+        expect(hash).to eq(value_as_hash)
+        expect(hash['one']).to eq 'two'
       end
     end
 
     context 'for a typed hash' do
-      subject(:type){ Attributor::Hash.of(key: String, value: Integer)}
+      subject(:type) { Attributor::Hash.of(key: String, value: Integer) }
       context 'with good values' do
-        let(:value) { {one: '1', 'three' => 3} }
+        let(:value) { { one: '1', 'three' => 3 } }
         it 'coerces good values into the correct types' do
-          hash.should eq({'one' => 1, 'three' => 3})
-          hash['one'].should eq(1)
+          expect(hash).to eq('one' => 1, 'three' => 3)
+          expect(hash['one']).to eq(1)
         end
       end
 
       context 'with incompatible values' do
-        let(:value) { {one: 'two', three: 4} }
+        let(:value) { { one: 'two', three: 4 } }
         it 'fails' do
-          expect{
+          expect do
             type.load(value)
-          }.to raise_error(/invalid value for Integer/)
+          end.to raise_error(/invalid value for Integer/)
         end
       end
-
     end
 
     context 'for a partially typed hash' do
-      subject(:type){ Attributor::Hash.of(value: Integer) }
+      subject(:type) { Attributor::Hash.of(value: Integer) }
       context 'with good values' do
-        let(:value) { {one: '1', [1,2,3] => 3} }
+        let(:value) { { one: '1', [1, 2, 3] => 3 } }
         it 'coerces only values into the correct types (and leave keys alone)' do
-          hash.should eq({:one => 1, [1,2,3] => 3})
+          expect(hash).to eq(:one => 1, [1, 2, 3] => 3)
         end
       end
     end
@@ -222,20 +239,20 @@ describe Attributor::Hash do
         Class.new(Attributor::Hash) do
           keys do
             key 'id', Integer
-            key 'name', String, default: "unnamed"
+            key 'name', String, default: 'unnamed'
             key 'chicken', Chicken
           end
         end
       end
 
-      let(:value) { {'chicken' => Chicken.example} }
+      let(:value) { { 'chicken' => Chicken.example } }
 
       subject(:hash) { type.load(value) }
 
       it { should_not have_key('id') }
       it 'has the defaulted key' do
-        hash.should have_key('name')
-        hash['name'].should eq('unnamed')
+        expect(hash).to have_key('name')
+        expect(hash['name']).to eq('unnamed')
       end
     end
 
@@ -273,44 +290,39 @@ describe Attributor::Hash do
           end
 
           it 'complains about an unknown key' do
-            expect {
+            expect do
               loader_hash.load(value)
-            }.to raise_error(Attributor::AttributorException,/Unknown key received: :weird_key/)
+            end.to raise_error(Attributor::AttributorException,
+                               /Unknown key received: :weird_key/)
           end
         end
       end
     end
-
-
   end
 
-
   context '.of' do
     context 'specific key and value types' do
-      let(:key_type){ String }
-      let(:value_type){ Integer }
+      let(:key_type) { String }
+      let(:value_type) { Integer }
 
       subject(:type) { Attributor::Hash.of(key: key_type, value: value_type) }
 
       it { should be_a(::Class) }
       its(:ancestors) { should include(Attributor::Hash) }
-      its(:key_type) { should == Attributor::String }
-      its(:value_type) { should == Attributor::Integer }
+      its(:key_type) { should eq Attributor::String }
+      its(:value_type) { should eq Attributor::Integer }
 
       context '.load' do
-        let(:value) { {one: '2', 3 => 4} }
+        let(:value) { { one: '2', 3 => 4 } }
 
         subject(:hash) { type.load(value) }
 
         it 'coerces the types properly' do
-          hash['one'].should eq(2)
-          hash['3'].should eq(4)
+          expect(hash['one']).to eq(2)
+          expect(hash['3']).to eq(4)
         end
-
       end
-
     end
-
   end
 
   context '.construct' do
@@ -323,36 +335,35 @@ describe Attributor::Hash do
       end
     end
 
-
     subject(:type) { Attributor::Hash.construct(block) }
 
-    it { should_not be(Attributor::Hash)
-         }
+    it do
+      should_not be(Attributor::Hash)
+    end
 
     context 'loading' do
-      let(:date) { DateTime.parse("2014-07-15") }
+      let(:date) { DateTime.parse('2014-07-15') }
       let(:value) do
-        {'a string' => 12, '1' => '2', :some_date => date.to_s}
+        { 'a string' => 12, '1' => '2', :some_date => date.to_s }
       end
 
-      subject(:hash) { type.load(value)}
+      subject(:hash) { type.load(value) }
 
       it 'loads' do
-        hash['a string'].should eq('12')
-        hash['1'].should eq(2)
-        hash[:some_date].should eq(date)
-        hash['defaulted'].should eq('default value')
+        expect(hash['a string']).to eq('12')
+        expect(hash['1']).to eq(2)
+        expect(hash[:some_date]).to eq(date)
+        expect(hash['defaulted']).to eq('default value')
       end
 
       context 'with unknown keys in input' do
         it 'raises an error' do
-          expect {
-            type.load({'other_key' => :value})
-          }.to raise_error(Attributor::AttributorException)
+          expect do
+            type.load('other_key' => :value)
+          end.to raise_error(Attributor::AttributorException)
         end
       end
 
-
       context 'with a key_type' do
         let(:block) do
           proc do
@@ -365,16 +376,15 @@ describe Attributor::Hash do
 
         subject(:type) { Attributor::Hash.of(key: String).construct(block) }
         let(:value) do
-          {'a string' => 12, 1 => '2', :some_date => date.to_s}
+          { 'a string' => 12, 1 => '2', :some_date => date.to_s }
         end
 
         it 'loads' do
-          hash['a string'].should eq('12')
-          hash['1'].should eq(2)
-          hash['some_date'].should eq(date)
-          hash['defaulted'].should eq('default value')
+          expect(hash['a string']).to eq('12')
+          expect(hash['1']).to eq(2)
+          expect(hash['some_date']).to eq(date)
+          expect(hash['defaulted']).to eq('default value')
         end
-
       end
     end
 
@@ -386,75 +396,73 @@ describe Attributor::Hash do
       end
 
       it 'raises an error' do
-        expect {
-          Attributor::Hash.of(key:String).construct(block).keys
-        }.to raise_error(/Invalid key: :some_date, must be instance of String/)
+        expect do
+          Attributor::Hash.of(key: String).construct(block).keys
+        end.to raise_error(/Invalid key: :some_date, must be instance of String/)
       end
-
     end
   end
 
   context '.check_option!' do
     context ':case_insensitive_load' do
-
       it 'is valid when key_type is a string' do
-        Attributor::Hash.of(key:String).check_option!(:case_insensitive_load, true).should == :ok
+        expect(Attributor::Hash.of(key: String).check_option!(:case_insensitive_load, true)).to eq :ok
       end
 
       it 'is invalid when key_type is non-string' do
-        expect {
-          Attributor::Hash.of(key:Integer).check_option!(:case_insensitive_load, true)
-        }.to raise_error(Attributor::AttributorException, /:case_insensitive_load may not be used/)
+        expect do
+          Attributor::Hash.of(key: Integer).check_option!(:case_insensitive_load, true)
+        end.to raise_error(Attributor::AttributorException,
+                           /:case_insensitive_load may not be used/)
       end
-
     end
-    it 'rejects unknown options'  do
-      subject.check_option!(:bad_option, Object).should == :unknown
+    it 'rejects unknown options' do
+      expect(subject.check_option!(:bad_option, Object)).to eq :unknown
     end
-
   end
 
   context '.add_requirement' do
-    let(:req_type){ :all }
-    let(:req){ double("requirement", type: req_type, attr_names: req_attributes)}
+    let(:req_type) { :all }
+    let(:req) { double('requirement', type: req_type, attr_names: req_attributes) }
     context 'with valid attributes' do
-      let(:req_attributes){ [:name] }
+      let(:req_attributes) { [:name] }
       it 'successfully saves it in the class' do
         HashWithStrings.add_requirement(req)
-        HashWithStrings.requirements.should include(req)
+        expect(HashWithStrings.requirements).to include(req)
       end
     end
     context 'with attributes not defined in the class' do
-      let(:req_attributes){ [:name, :invalid, :notgood] }
+      let(:req_attributes) { [:name, :invalid, :notgood] }
       it 'it complains loudly' do
-        expect{
+        expect do
           HashWithStrings.add_requirement(req)
-        }.to raise_error("Invalid attribute name(s) found (invalid, notgood) when defining a requirement of type all for HashWithStrings .The only existing attributes are [:name, :something]")
+        end.to raise_error(
+          'Invalid attribute name(s) found (invalid, notgood) when defining a requirement of type all for HashWithStrings .The only existing attributes are [:name, :something]'
+        )
       end
     end
   end
 
   context '.dump' do
-
-    let(:value) { {one: 1, two: 2} }
+    let(:value) { { one: 1, two: 2 } }
     let(:opts) { {} }
 
     it 'it is Dumpable' do
-      type.new.is_a?(Attributor::Dumpable).should be(true)
+      expect(type.new.is_a?(Attributor::Dumpable)).to be(true)
     end
 
     context 'for a simple (untyped) hash' do
       it 'returns the untouched hash value' do
-        type.dump(value, opts).should eq(value)
+        expect(type.dump(value, opts)).to eq(value)
       end
     end
 
     context 'for a typed hash' do
       before do
-        subtype.should_receive(:dump).exactly(2).times.and_call_original
+        expect(subtype).to receive(:dump).exactly(2).times.and_call_original
       end
-      let(:value1) { {first: "Joe", last: "Moe"} }
-      let(:value2) { {first: "Mary", last: "Foe"} }
+      let(:value1) { { first: 'Joe', last: 'Moe' } }
+      let(:value2) { { first: 'Mary', last: 'Foe' } }
       let(:value) { { id1: subtype.new(value1), id2: subtype.new(value2) } }
       let(:subtype) do
         Class.new(Attributor::Model) do
@@ -468,11 +476,11 @@ describe Attributor::Hash do
 
       it 'returns a hash with the dumped values and keys' do
         dumped_value = type.dump(value, opts)
-        dumped_value.should be_kind_of(::Hash)
-        dumped_value.keys.should =~ ['id1','id2']
-        dumped_value.values.should have(2).items
-        dumped_value['id1'].should == value1
-        dumped_value['id2'].should == value2
+        expect(dumped_value).to be_kind_of(::Hash)
+        expect(dumped_value.keys).to match_array %w(id1 id2)
+        expect(dumped_value.values).to have(2).items
+        expect(dumped_value['id1']).to eq value1
+        expect(dumped_value['id2']).to eq value2
       end
 
       context 'that has nil attribute values' do
@@ -480,31 +488,29 @@ describe Attributor::Hash do
 
         it 'correctly returns nil rather than trying to dump their contents' do
           dumped_value = type.dump(value, opts)
-          dumped_value.should be_kind_of(::Hash)
-          dumped_value.keys.should =~ ['id1','id2']
-          dumped_value['id1'].should == nil
-          dumped_value['id2'].should == value2
+          expect(dumped_value).to be_kind_of(::Hash)
+          expect(dumped_value.keys).to match_array %w(id1 id2)
+          expect(dumped_value['id1']).to be nil
+          expect(dumped_value['id2']).to eq value2
         end
       end
     end
-
   end
 
   context '#validate' do
     context 'for a key and value typed hash' do
-      let(:key_type){ Integer }
-      let(:value_type){ DateTime }
+      let(:key_type) { Integer }
+      let(:value_type) { DateTime }
 
       let(:type) { Attributor::Hash.of(key: key_type, value: value_type) }
       subject(:hash) { type.new('one' => :two) }
 
       it 'returns errors for key and value' do
         errors = hash.validate
-        errors.should have(2).items
-
-        errors.should include("Attribute $.key(\"one\") received value: \"one\" is of the wrong type (got: String, expected: Attributor::Integer)")
-        errors.should include("Attribute $.value(:two) received value: :two is of the wrong type (got: Symbol, expected: Attributor::DateTime)")
+        expect(errors).to have(2).items
 
+        expect(errors).to include('Attribute $.key("one") received value: "one" is of the wrong type (got: String, expected: Attributor::Integer)')
+        expect(errors).to include('Attribute $.value(:two) received value: :two is of the wrong type (got: Symbol, expected: Attributor::DateTime)')
       end
     end
 
@@ -519,18 +525,16 @@ describe Attributor::Hash do
 
       let(:type) { Attributor::Hash.construct(block) }
 
-      let(:values) { {'integer' => 'one', 'datetime' => 'now' } }
+      let(:values) { { 'integer' => 'one', 'datetime' => 'now' } }
       subject(:hash) { type.new(values) }
 
       it 'validates the keys' do
         errors = hash.validate
-        errors.should have(3).items
-        errors.should include("Attribute $.key(\"not-optional\") is required")
+        expect(errors).to have(3).items
+        expect(errors).to include('Attribute $.key("not-optional") is required')
       end
-
     end
 
-
     context 'with requirements defined' do
       let(:type) { Attributor::Hash.construct(block) }
 
@@ -548,9 +552,9 @@ describe Attributor::Hash do
 
         it 'complains not all the listed elements are set (false or true)' do
           errors = type.new('name' => 'CAP').validate
-          errors.should have(2).items
-          ['consistency','availability'].each do |name|
-            errors.should include("Key #{name} is required for $.")
+          expect(errors).to have(2).items
+          %w(consistency availability).each do |name|
+            expect(errors).to include("Key #{name} is required for $.")
           end
         end
       end
@@ -568,9 +572,9 @@ describe Attributor::Hash do
 
         it 'complains if less than 2 in the group are set (false or true)' do
           errors = type.new('name' => 'CAP', 'consistency' => false).validate
-          errors.should have(1).items
-          errors.should include(
-            "At least 2 keys out of [\"consistency\", \"availability\", \"partitioning\"] are required to be passed in for $. Found [\"consistency\"]"
+          expect(errors).to have(1).items
+          expect(errors).to include(
+            'At least 2 keys out of ["consistency", "availability", "partitioning"] are required to be passed in for $. Found ["consistency"]'
           )
         end
       end
@@ -588,8 +592,8 @@ describe Attributor::Hash do
 
         it 'complains if more than 2 in the group are set (false or true)' do
           errors = type.new('name' => 'CAP', 'consistency' => false, 'availability' => true, 'partitioning' => false).validate
-          errors.should have(1).items
-          errors.should include("At most 2 keys out of [\"consistency\", \"availability\", \"partitioning\"] can be passed in for $. Found [\"consistency\", \"availability\", \"partitioning\"]")
+          expect(errors).to have(1).items
+          expect(errors).to include('At most 2 keys out of ["consistency", "availability", "partitioning"] can be passed in for $. Found ["consistency", "availability", "partitioning"]')
         end
       end
 
@@ -606,13 +610,13 @@ describe Attributor::Hash do
 
         it 'complains if less than 1 in the group are set (false or true)' do
           errors = type.new('name' => 'CAP').validate
-          errors.should have(1).items
-          errors.should include("Exactly 1 of the following keys [\"consistency\", \"availability\", \"partitioning\"] are required for $. Found 0 instead: []")
+          expect(errors).to have(1).items
+          expect(errors).to include('Exactly 1 of the following keys ["consistency", "availability", "partitioning"] are required for $. Found 0 instead: []')
         end
         it 'complains if more than 1 in the group are set (false or true)' do
           errors = type.new('name' => 'CAP', 'consistency' => false, 'availability' => true).validate
-          errors.should have(1).items
-          errors.should include("Exactly 1 of the following keys [\"consistency\", \"availability\", \"partitioning\"] are required for $. Found 2 instead: [\"consistency\", \"availability\"]")
+          expect(errors).to have(1).items
+          expect(errors).to include('Exactly 1 of the following keys ["consistency", "availability", "partitioning"] are required for $. Found 2 instead: ["consistency", "availability"]')
         end
       end
 
@@ -629,8 +633,8 @@ describe Attributor::Hash do
 
         it 'complains if two or more in the group are set (false or true)' do
           errors = type.new('name' => 'CAP', 'consistency' => false, 'availability' => true).validate
-          errors.should have(1).items
-          errors.should include("keys [\"consistency\", \"availability\"] are mutually exclusive for $.")
+          expect(errors).to have(1).items
+          expect(errors).to include('keys ["consistency", "availability"] are mutually exclusive for $.')
         end
       end
 
@@ -653,38 +657,36 @@ describe Attributor::Hash do
 
         it 'complains not all the listed elements are set (false or true)' do
           errors = type.new('name' => 'CAP').validate
-          errors.should have(1).items
-          errors.should include(
-            "At least 1 keys out of [\"consistency\", \"availability\", \"partitioning\"] are required to be passed in for $. Found none"
+          expect(errors).to have(1).items
+          expect(errors).to include(
+            'At least 1 keys out of ["consistency", "availability", "partitioning"] are required to be passed in for $. Found none'
           )
         end
       end
     end
-
   end
 
   context 'in an Attribute' do
     let(:options) { {} }
-    subject(:attribute) { Attributor::Attribute.new(Attributor::Hash, options)}
+    subject(:attribute) { Attributor::Attribute.new(Attributor::Hash, options) }
 
     context 'with an example option that is a proc' do
-      let(:example_hash) { {:key => "value"} }
+      let(:example_hash) { { key: 'value' } }
       let(:options) { { example: proc { example_hash } } }
       it 'uses the hash' do
-        attribute.example.should eq(example_hash)
+        expect(attribute.example).to eq(example_hash)
       end
     end
-
   end
 
   context '.describe' do
-    let(:example){ nil }
+    let(:example) { nil }
     subject(:description) { type.describe(example: example) }
     context 'for hashes with key and value types' do
       it 'describes the type correctly' do
-        description[:name].should eq('Hash')
-        description[:key].should eq(type:{name: 'Object', id: 'Attributor-Object', family: 'any'})
-        description[:value].should eq(type:{name: 'Object', id: 'Attributor-Object', family: 'any'})
+        expect(description[:name]).to eq('Hash')
+        expect(description[:key]).to eq(type: { name: 'Object', id: 'Attributor-Object', family: 'any' })
+        expect(description[:value]).to eq(type: { name: 'Object', id: 'Attributor-Object', family: 'any' })
       end
     end
 
@@ -696,7 +698,7 @@ describe Attributor::Hash do
           key 'some_date', DateTime
           key 'defaulted', String, default: 'default value'
           requires do
-            all.of '1','some_date'
+            all.of '1', 'some_date'
             exclusive 'some_date', 'defaulted'
             at_least(1).of 'a string', 'some_date'
             at_most(2).of 'a string', 'some_date'
@@ -708,30 +710,29 @@ describe Attributor::Hash do
       let(:type) { Attributor::Hash.of(key: String).construct(block) }
 
       it 'describes the type correctly' do
-        description[:name].should eq('Hash')
-        description[:key].should eq(type:{name: 'String', id: 'Attributor-String', family: 'string'})
-        description.should_not have_key(:value)
+        expect(description[:name]).to eq('Hash')
+        expect(description[:key]).to eq(type: { name: 'String', id: 'Attributor-String', family: 'string' })
+        expect(description).not_to have_key(:value)
       end
 
       it 'describes the type attributes correctly' do
         attrs = description[:attributes]
 
-        attrs['a string'].should eq(type: {name: 'String', id: 'Attributor-String', family: 'string'} )
-        attrs['1'].should eq(type: {name: 'Integer', id: 'Attributor-Integer', family: 'numeric'}, options: {min: 1, max: 20}  )
-        attrs['some_date'].should eq(type: {name: 'DateTime', id: 'Attributor-DateTime', family: 'temporal'})
-        attrs['defaulted'].should eq(type: {name: 'String', id: 'Attributor-String', family: 'string'}, default: 'default value')
+        expect(attrs['a string']).to eq(type: { name: 'String', id: 'Attributor-String', family: 'string' })
+        expect(attrs['1']).to eq(type: { name: 'Integer', id: 'Attributor-Integer', family: 'numeric' }, options: { min: 1, max: 20 })
+        expect(attrs['some_date']).to eq(type: { name: 'DateTime', id: 'Attributor-DateTime', family: 'temporal' })
+        expect(attrs['defaulted']).to eq(type: { name: 'String', id: 'Attributor-String', family: 'string' }, default: 'default value')
       end
 
       it 'describes the type requirements correctly' do
-
         reqs = description[:requirements]
-        reqs.should be_kind_of(Array)
-        reqs.size.should be(5)
-        reqs.should include( type: :all, attributes: ['1','some_date'] )
-        reqs.should include( type: :exclusive, attributes: ['some_date','defaulted'] )
-        reqs.should include( type: :at_least, attributes: ['a string','some_date'], count: 1 )
-        reqs.should include( type: :at_most, attributes: ['a string','some_date'], count: 2 )
-        reqs.should include( type: :exactly, attributes: ['a string','some_date'], count: 1 )
+        expect(reqs).to be_kind_of(Array)
+        expect(reqs.size).to be(5)
+        expect(reqs).to include(type: :all, attributes: %w(1 some_date))
+        expect(reqs).to include(type: :exclusive, attributes: %w(some_date defaulted))
+        expect(reqs).to include(type: :at_least, attributes: ['a string', 'some_date'], count: 1)
+        expect(reqs).to include(type: :at_most, attributes: ['a string', 'some_date'], count: 2)
+        expect(reqs).to include(type: :exactly, attributes: ['a string', 'some_date'], count: 1)
       end
 
       context 'merging requires.all with attribute required: true' do
@@ -746,8 +747,8 @@ describe Attributor::Hash do
           end
         end
         it 'includes attributes with required: true into the :all requirements' do
-          req_all = description[:requirements].select{|r| r[:type] == :all}.first
-          req_all[:attributes].should include( 'required string','some_date' )
+          req_all = description[:requirements].select { |r| r[:type] == :all }.first
+          expect(req_all[:attributes]).to include('required string', 'some_date')
         end
       end
 
@@ -759,21 +760,21 @@ describe Attributor::Hash do
           end
         end
         it 'includes attributes with required: true into the :all requirements' do
-          req_all = description[:requirements].select{|r| r[:type] == :all}.first
-          req_all.should_not be(nil)
-          req_all[:attributes].should include( 'required string','required integer' )
+          req_all = description[:requirements].select { |r| r[:type] == :all }.first
+          expect(req_all).not_to be(nil)
+          expect(req_all[:attributes]).to include('required string', 'required integer')
         end
       end
 
       context 'with an example' do
-        let(:example){ type.example }
+        let(:example) { type.example }
 
         it 'should have the matching example for each leaf key' do
-          description[:attributes].keys.should =~ type.keys.keys
-          description[:attributes].each do |name,sub_description|
-            sub_description.should have_key(:example)
+          expect(description[:attributes].keys).to match_array type.keys.keys
+          description[:attributes].each do |name, sub_description|
+            expect(sub_description).to have_key(:example)
             val = type.attributes[name].dump(example[name])
-            sub_description[:example].should eq val
+            expect(sub_description[:example]).to eq val
           end
         end
       end
@@ -781,17 +782,17 @@ describe Attributor::Hash do
   end
 
   context '#dump' do
-    let(:key_type){ String }
-    let(:value_type){ Integer }
-    let(:hash) { {one: '2', 3 => 4} }
+    let(:key_type) { String }
+    let(:value_type) { Integer }
+    let(:hash) { { one: '2', 3 => 4 } }
     let(:type) { Attributor::Hash.of(key: key_type, value: value_type) }
     let(:value) { type.load(hash) }
 
     subject(:output) { value.dump }
 
     it 'dumps the contents properly' do
-      output.should be_kind_of(::Hash)
-      output.should eq('one' => 2, '3' => 4)
+      expect(output).to be_kind_of(::Hash)
+      expect(output).to eq('one' => 2, '3' => 4)
     end
 
     context 'with a model as value type' do
@@ -803,17 +804,16 @@ describe Attributor::Hash do
           end
         end
       end
-      let(:hash) { {one: value_type.example} }
-
+      let(:hash) { { one: value_type.example } }
     end
     context 'will always return a top level hash' do
-      subject(:type_dump){ type.dump(value) }
-      let(:key_type){ Attributor::Object }
-      let(:value_type){ Attributor::Object }
+      subject(:type_dump) { type.dump(value) }
+      let(:key_type) { Attributor::Object }
+      let(:value_type) { Attributor::Object }
 
       it 'even when key/types are object' do
-        subject.should be_kind_of(::Hash)
-        subject.should eq( hash )
+        expect(subject).to be_kind_of(::Hash)
+        expect(subject).to eq(hash)
       end
     end
 
@@ -827,13 +827,13 @@ describe Attributor::Hash do
         end
       end
 
-      let(:chicken) { {'name' => 'bob'} }
+      let(:chicken) { { 'name' => 'bob' } }
 
-      let(:value) { {'id' => '1', 'chicken' => chicken  } }
-      let(:expected) { {'id' => 1, 'chicken' => Chicken.dump(chicken) } }
+      let(:value) { { 'id' => '1', 'chicken' => chicken } }
+      let(:expected) { { 'id' => 1, 'chicken' => Chicken.dump(chicken) } }
 
       it 'properly dumps the values' do
-        type.dump(value).should eq(expected)
+        expect(type.dump(value)).to eq(expected)
       end
 
       context 'with allow_extra: true' do
@@ -846,10 +846,10 @@ describe Attributor::Hash do
           end
         end
 
-        let(:value) { {'id' => '1', 'chicken' => chicken, 'rank' => 'bob rank'} }
-        let(:expected) { {'id' => 1, 'chicken' => Chicken.dump(chicken), 'rank' => 'bob rank' } }
+        let(:value) { { 'id' => '1', 'chicken' => chicken, 'rank' => 'bob rank' } }
+        let(:expected) { { 'id' => 1, 'chicken' => Chicken.dump(chicken), 'rank' => 'bob rank' } }
         it 'preserves the extra keys at the top level' do
-          type.dump(value).should eq(expected)
+          expect(type.dump(value)).to eq(expected)
         end
 
         context 'with extra option' do
@@ -863,9 +863,9 @@ describe Attributor::Hash do
             end
           end
 
-          let(:expected) { {'id' => 1, 'chicken' => Chicken.dump(chicken), 'other' => {'rank' => 'bob rank' }} }
+          let(:expected) { { 'id' => 1, 'chicken' => Chicken.dump(chicken), 'other' => { 'rank' => 'bob rank' } } }
           it 'dumps the extra keys inside the subhash' do
-            type.dump(value).should eq(expected)
+            expect(type.dump(value)).to eq(expected)
           end
         end
       end
@@ -873,7 +873,6 @@ describe Attributor::Hash do
   end
 
   context '.from_hash' do
-
     context 'without allowing extra keys' do
       let(:type) do
         Class.new(Attributor::Hash) do
@@ -885,29 +884,29 @@ describe Attributor::Hash do
           end
         end
       end
-      subject(:input){ {} }
+      subject(:input) { {} }
       subject(:output) { type.load(input) }
 
-      its(:class){ should be(type) }
+      its(:class) { should be(type) }
 
-      let(:load_context) { "$.some_root" }
+      let(:load_context) { '$.some_root' }
       it 'complains about the extra, with the right context' do
-        expect{
-          type.load( {one: 'one', three: 3} , load_context )
-        }.to raise_error(Attributor::AttributorException,/Unknown key received: :three while loading \$\.some_root.key\(:three\)/)
+        expect do
+          type.load({ one: 'one', three: 3 }, load_context)
+        end.to raise_error(Attributor::AttributorException, /Unknown key received: :three while loading \$\.some_root.key\(:three\)/)
       end
       context 'properly sets them (and loads them) in the created instance' do
-        let(:input){ {one: 'one', two: 2 } }
+        let(:input) { { one: 'one', two: 2 } }
 
-        its(:keys){ should eq([:one, :two])}
-        its([:one]){ should eq('one') }
-        its([:two]){ should eq('2') } #loaded as a string
+        its(:keys) { should eq([:one, :two]) }
+        its([:one]) { should eq('one') }
+        its([:two]) { should eq('2') } # loaded as a string
       end
       context 'properly sets the default values when not passed in' do
-        let(:input){ {one: 'one'} }
+        let(:input) { { one: 'one' } }
 
-        its([:one]){ should eq('one') }
-        its([:two]){ should eq('two') }
+        its([:one]) { should eq('one') }
+        its([:two]) { should eq('two') }
       end
     end
 
@@ -920,10 +919,10 @@ describe Attributor::Hash do
             end
           end
         end
-        let(:input){ {one: 'one', three: 'tres' } }
+        let(:input) { { one: 'one', three: 'tres' } }
         subject(:output) { type.load(input) }
 
-        its(:keys){ should eq([:one,:three])}
+        its(:keys) { should eq([:one, :three]) }
       end
       context 'inside an :other subkey' do
         let(:type) do
@@ -934,12 +933,12 @@ describe Attributor::Hash do
             end
           end
         end
-        let(:input){ {one: 'one', three: 'tres' } }
+        let(:input) { { one: 'one', three: 'tres' } }
         subject(:output) { type.load(input) }
 
-        its(:keys){ should =~ [:one,:other] }
+        its(:keys) { should match_array [:one, :other] }
         it 'has the key inside the :other hash' do
-          expect(output[:other]).to eq({three: 'tres'})
+          expect(output[:other]).to eq(three: 'tres')
         end
       end
     end
@@ -955,20 +954,19 @@ describe Attributor::Hash do
         key 'CamelCase', Integer
       end
     end
-    let(:input) { {'DOWNCASE' => 1, 'upcase' => 2, 'CamelCase' => 3} }
+    let(:input) { { 'DOWNCASE' => 1, 'upcase' => 2, 'CamelCase' => 3 } }
     subject(:output) { type.load(input) }
 
     context 'when defined' do
-
       it 'maps the incoming keys to defined keys, regardless of case' do
-        output['downcase'].should eq(1)
-        output['UPCASE'].should eq(2)
-        output['CamelCase'].should eq(3)
+        expect(output['downcase']).to eq(1)
+        expect(output['UPCASE']).to eq(2)
+        expect(output['CamelCase']).to eq(3)
       end
       it 'has loaded the (internal) insensitive_map upon building the definition' do
         type.definition
-        type.insensitive_map.should be_kind_of(::Hash)
-        type.insensitive_map.keys.should =~ ["downcase","upcase","camelcase"]
+        expect(type.insensitive_map).to be_kind_of(::Hash)
+        expect(type.insensitive_map.keys).to match_array %w(downcase upcase camelcase)
       end
     end
 
@@ -977,7 +975,7 @@ describe Attributor::Hash do
 
       it 'skips the loading of the (internal) insensitive_map' do
         type.definition
-        type.insensitive_map.should be_nil
+        expect(type.insensitive_map).to be_nil
       end
     end
   end
@@ -994,19 +992,19 @@ describe Attributor::Hash do
       end
     end
 
-    let(:input) { {one: 'one', three: 3} }
+    let(:input) { { one: 'one', three: 3 } }
     subject(:output) { type.load(input) }
 
     context 'that should be saved at the top level' do
-      its(:keys) { should =~ [:one, :two, :three] }
+      its(:keys) { should match_array [:one, :two, :three] }
 
       it 'loads the extra keys' do
-        output[:one].should eq('one')
-        output[:two].should eq('two')
-        output[:three].should eq('3')
+        expect(output[:one]).to eq('one')
+        expect(output[:two]).to eq('two')
+        expect(output[:three]).to eq('3')
       end
 
-      its( :validate ){ should be_empty }
+      its(:validate) { should be_empty }
     end
 
     context 'that should be grouped into a sub-hash' do
@@ -1016,25 +1014,24 @@ describe Attributor::Hash do
         end
       end
 
-      its(:keys) { should =~ [:one, :two, :options] }
+      its(:keys) { should match_array [:one, :two, :options] }
       it 'loads the extra keys into :options sub-hash' do
-        output[:one].should eq('one')
-        output[:two].should eq('two')
-        output[:options].should eq({three: 3})
+        expect(output[:one]).to eq('one')
+        expect(output[:two]).to eq('two')
+        expect(output[:options]).to eq(three: 3)
       end
-      its( :validate ){ should be_empty }
+      its(:validate) { should be_empty }
 
       context 'with an options value already provided' do
-        its(:keys) { should =~ [:one, :two, :options] }
-        let(:input) { {one: 'one', three: 3, options: {four: 4}} }
+        its(:keys) { should match_array [:one, :two, :options] }
+        let(:input) { { one: 'one', three: 3, options: { four: 4 } } }
 
         it 'loads the extra keys into :options sub-hash' do
-          output[:one].should eq('one')
-          output[:two].should eq('two')
-          output[:options].should eq({three: 3, four: 4})
+          expect(output[:one]).to eq('one')
+          expect(output[:two]).to eq('two')
+          expect(output[:options]).to eq(three: 3, four: 4)
         end
-        its( :validate ){ should be_empty }
-
+        its(:validate) { should be_empty }
       end
     end
 
@@ -1049,53 +1046,50 @@ describe Attributor::Hash do
         end
       end
 
-      let(:chicken) { {name: 'bob'} }
+      let(:chicken) { { name: 'bob' } }
       subject(:hash) { type.new }
 
       context '#set' do
         it 'sets values into "extra" keys if appplicable' do
-          hash.should_not have_key('others')
+          expect(hash).not_to have_key('others')
           hash.set 'foo', 'bar'
-          hash['others'].should have_key('foo')
-          hash.should have_key('others')
-          hash['others']['foo'].should eq('bar')
+          expect(hash['others']).to have_key('foo')
+          expect(hash).to have_key('others')
+          expect(hash['others']['foo']).to eq('bar')
         end
 
         it 'loads values before saving into the contents' do
           hash.set 'chicken', chicken
-          hash['chicken'].should be_a(Chicken)
+          expect(hash['chicken']).to be_a(Chicken)
         end
       end
 
       context '#get' do
         before do
           hash['chicken'] = chicken
-          hash['chicken'].should eq(chicken)
+          expect(hash['chicken']).to eq(chicken)
         end
 
         it 'loads and updates the saved value' do
-          hash.get('chicken').should be_a(Chicken)
-          hash['chicken'].should be_a(Chicken)
+          expect(hash.get('chicken')).to be_a(Chicken)
+          expect(hash['chicken']).to be_a(Chicken)
         end
 
         it 'retrieves values from an "extra" key' do
           bar = double('bar')
           hash.set 'foo', bar
-          hash.get('others').get('foo').should be(bar)
+          expect(hash.get('others').get('foo')).to be(bar)
 
-          hash.get('foo').should be(bar)
+          expect(hash.get('foo')).to be(bar)
         end
 
         it 'does not set a key that is unset' do
-          hash.should_not have_key('id')
-          hash.get('id').should be(nil)
-          hash.should_not have_key('id')
+          expect(hash).not_to have_key('id')
+          expect(hash.get('id')).to be(nil)
+          expect(hash).not_to have_key('id')
         end
-
       end
-
     end
-
   end
 
   context '#merge' do
@@ -1120,6 +1114,8 @@ describe Attributor::Hash do
     it 'merges' do
       expect(merger.merge(good_mergee)).to eq(result)
     end
+  end
 
+  context Attributor::InvalidDefinition do
   end
 end