attributor 5.0.2 → 5.1.0

data/spec/types/ids_spec.rb

@@ -1,9 +1,8 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
 
 describe Attributor::Ids do
-
   context '.for' do
-    let(:chickens) { 10.times.collect { Chicken.example } }
+    let(:chickens) { Array.new(10) { Chicken.example } }
 
     let(:emails) { chickens.collect(&:email) }
     let(:value) { emails.join(',') }
@@ -13,20 +12,19 @@ describe Attributor::Ids do
     its(:member_attribute) { should be(Chicken.attributes[:email]) }
 
     it 'loads' do
-      ids.load(value).should =~ emails
+      expect(ids.load(value)).to match_array emails
     end
 
     it 'generates valid, loadable examples' do
-      ids.validate(ids.load(ids.example)).should be_empty
+      expect(ids.validate(ids.load(ids.example))).to be_empty
     end
-
   end
 
   context 'attempting to define it as a collection using .of(type)' do
     it 'raises an error' do
-      expect{
+      expect do
         Attributor::Ids.of(Chicken)
-      }.to raise_error(/Defining Ids.of\(type\) is not allowed/)
+      end.to raise_error(/Defining Ids.of\(type\) is not allowed/)
     end
   end
 end

data/spec/types/integer_spec.rb

@@ -1,23 +1,21 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
 
 describe Attributor::Integer do
-
   subject(:type) { Attributor::Integer }
 
   it 'it is not Dumpable' do
-    type.new.is_a?(Attributor::Dumpable).should_not be(true)
+    expect(type.new.is_a?(Attributor::Dumpable)).not_to be(true)
   end
 
   context '.example' do
-
     context 'when :min and :max are unspecified' do
       context 'valid cases' do
         it "returns an Integer in the range [0,#{Attributor::Integer::EXAMPLE_RANGE}]" do
           20.times do
             value = type.example
-            value.should be_a(::Integer)
-            value.should <= Attributor::Integer::EXAMPLE_RANGE
-            value.should >= 0
+            expect(value).to be_a(::Integer)
+            expect(value).to be <= Attributor::Integer::EXAMPLE_RANGE
+            expect(value).to be >= 0
           end
         end
       end
@@ -25,13 +23,13 @@ describe Attributor::Integer do
 
     context 'when :min is unspecified' do
       context 'valid cases' do
-        [5, 100000000000000000000, -100000000000000000000].each do |max|
+        [5, 100_000_000_000_000_000_000, -100_000_000_000_000_000_000].each do |max|
           it "returns an Integer in the range [,#{max.inspect}]" do
             20.times do
-              value = type.example(nil, options: {max: max})
-              value.should be_a(::Integer)
-              value.should <= max
-              value.should >= max - Attributor::Integer::EXAMPLE_RANGE
+              value = type.example(nil, options: { max: max })
+              expect(value).to be_a(::Integer)
+              expect(value).to be <= max
+              expect(value).to be >= max - Attributor::Integer::EXAMPLE_RANGE
             end
           end
         end
@@ -40,10 +38,10 @@ describe Attributor::Integer do
       context 'invalid cases' do
         ['invalid', false].each do |max|
           it "raises for the invalid range [,#{max.inspect}]" do
-            expect {
-              value = type.example(nil, options: {max: max})
-              value.should be_a(::Integer)
-            }.to raise_error(Attributor::AttributorException, "Invalid range: [, #{max.inspect}]")
+            expect do
+              value = type.example(nil, options: { max: max })
+              expect(value).to be_a(::Integer)
+            end.to raise_error(Attributor::AttributorException, "Invalid range: [, #{max.inspect}]")
           end
         end
       end
@@ -51,13 +49,13 @@ describe Attributor::Integer do
 
     context 'when :max is unspecified' do
       context 'valid cases' do
-        [1, -100000000000000000000, 100000000000000000000].each do |min|
+        [1, -100_000_000_000_000_000_000, 100_000_000_000_000_000_000].each do |min|
           it "returns an Integer in the range [#{min.inspect},]" do
             20.times do
-              value = type.example(nil, options: {min: min})
-              value.should be_a(::Integer)
-              value.should <= min + Attributor::Integer::EXAMPLE_RANGE
-              value.should >= min
+              value = type.example(nil, options: { min: min })
+              expect(value).to be_a(::Integer)
+              expect(value).to be <= min + Attributor::Integer::EXAMPLE_RANGE
+              expect(value).to be >= min
             end
           end
         end
@@ -66,10 +64,10 @@ describe Attributor::Integer do
       context 'invalid cases' do
         ['invalid', false].each do |min|
           it "raises for the invalid range [#{min.inspect},]" do
-            expect {
-              value = type.example(nil, options: {min: min})
-              value.should be_a(::Integer)
-            }.to raise_error(Attributor::AttributorException, "Invalid range: [#{min.inspect},]")
+            expect do
+              value = type.example(nil, options: { min: min })
+              expect(value).to be_a(::Integer)
+            end.to raise_error(Attributor::AttributorException, "Invalid range: [#{min.inspect},]")
           end
         end
       end
@@ -78,33 +76,32 @@ describe Attributor::Integer do
     context 'when :min and :max are specified' do
       context 'valid cases' do
         [
-          [1,1],
-          [1,5],
-          [-2,-2],
-          [-3,2],
-          [-1000000000000000,1000000000000000]
+          [1, 1],
+          [1, 5],
+          [-2, -2],
+          [-3, 2],
+          [-1_000_000_000_000_000, 1_000_000_000_000_000]
         ].each do |min, max|
           it "returns an Integer in the range [#{min.inspect},#{max.inspect}]" do
             20.times do
-              value = type.example(nil, options: {max: max, min: min})
-              value.should <= max
-              value.should >= min
+              value = type.example(nil, options: { max: max, min: min })
+              expect(value).to be <= max
+              expect(value).to be >= min
             end
           end
         end
       end
 
       context 'invalid cases' do
-        [[1,-1], [1,"5"], ["-2",4], [false, false], [true, true]].each do |min, max|
+        [[1, -1], [1, '5'], ['-2', 4], [false, false], [true, true]].each do |min, max|
           it "raises for the invalid range [#{min.inspect}, #{max.inspect}]" do
-            opts = {options: {max: max, min: min}}
-            expect {
+            opts = { options: { max: max, min: min } }
+            expect do
               type.example(nil, opts)
-            }.to raise_error(Attributor::AttributorException, "Invalid range: [#{min.inspect}, #{max.inspect}]")
+            end.to raise_error(Attributor::AttributorException, "Invalid range: [#{min.inspect}, #{max.inspect}]")
           end
         end
       end
-
     end
   end
 
@@ -112,29 +109,26 @@ describe Attributor::Integer do
     let(:value) { nil }
 
     it 'returns nil for nil' do
-      type.load(nil).should be(nil)
+      expect(type.load(nil)).to be(nil)
     end
 
     context 'for incoming integer values' do
       let(:value) { 1 }
 
       it 'returns the incoming value' do
-        type.load(value).should be(value)
+        expect(type.load(value)).to be(value)
       end
     end
 
     context 'for incoming string values' do
-
-
       context 'that are valid integers' do
         let(:value) { '1024' }
         it 'decodes it if the string represents an integer' do
-          type.load(value).should == 1024
+          expect(type.load(value)).to eq 1024
         end
       end
 
       context 'that are not valid integers' do
-
         context 'with simple alphanumeric text' do
           let(:value) { 'not an integer' }
 
@@ -149,10 +143,7 @@ describe Attributor::Integer do
             expect { type.load(value) }.to raise_error(/invalid value/)
           end
         end
-
       end
-
     end
   end
 end
-

data/spec/types/model_spec.rb

@@ -11,46 +11,52 @@ describe Attributor::Model 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
 
       it 'throws InvalidDefinition for subsequent access' do
-        broken_model.attributes rescue nil
+        begin
+          broken_model.attributes
+        rescue
+          nil
+        end
 
-        lambda {
+        expect do
           broken_model.attributes
-        }.should raise_error(Attributor::InvalidDefinition)
+        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
+        begin
+          broken_model.attributes
+        rescue
+          nil
+        end
 
         instance = broken_model.new
-        lambda {
+        expect do
           instance.name
-        }.should raise_error(Attributor::InvalidDefinition)
+        end.to raise_error(Attributor::InvalidDefinition)
       end
-
     end
   end
 
   context 'class methods' do
-    let(:context){ ["root","subattr"] }
+    let(:context) { %w(root subattr) }
 
     its(:native_type) { should eq(Chicken) }
 
     context '.example'  do
       subject(:chicken) { Chicken.example }
 
-      let(:age_opts) { {options: Chicken.attributes[:age].options } }
+      let(:age_opts) { { options: Chicken.attributes[:age].options } }
       let(:age) { /\d{2}/.gen.to_i }
 
       context 'for a simple model' do
@@ -58,25 +64,25 @@ describe Attributor::Model do
 
         context 'and attribute without :example option' do
           before do
-            Attributor::Integer.should_receive(:example).with(kind_of(Array), age_opts).and_return(age)
+            expect(Attributor::Integer).to receive(:example).with(kind_of(Array), age_opts).and_return(age)
           end
 
-          its(:age) { should == age }
+          its(:age) { should eq age }
         end
 
         context 'and attribute with :example options' do
           before do
-            Attributor::Integer.should_not_receive(:example) # due to lazy-evaluation of examples
-            Attributor::String.should_not_receive(:example) # due to the :example option on the attribute
+            expect(Attributor::Integer).not_to receive(:example) # due to lazy-evaluation of examples
+            expect(Attributor::String).not_to receive(:example) # due to the :example option on the attribute
           end
-          its(:email) { should =~ /\w+@.*\.example\.org/ }
+          its(:email) { should match(/\w+@.*\.example\.org/) }
         end
 
         context 'with given values' do
           let(:name) { 'Sir Clucksalot' }
-          subject(:example) { Chicken.example(name: name)}
+          subject(:example) { Chicken.example(name: name) }
 
-          its(:name) {should eq(name) }
+          its(:name) { should eq(name) }
         end
       end
 
@@ -92,14 +98,13 @@ describe Attributor::Model do
 
           its(:attributes) { should eq(some_chicken.attributes) }
         end
-
       end
 
       context 'with attributes that are also models' do
         subject(:turducken) { Turducken.example }
 
         its(:attributes) { should have_key(:chicken) }
-        its(:chicken) { should be_kind_of(Chicken)}
+        its(:chicken) { should be_kind_of(Chicken) }
       end
 
       context 'with infinitely-expanding sub-attributes' do
@@ -117,20 +122,17 @@ describe Attributor::Model do
 
         it 'terminates example generation at MAX_EXAMPLE_DEPTH' do
           # call .child on example MAX_EXAMPLE_DEPTH times
-          terminal_child = Attributor::Model::MAX_EXAMPLE_DEPTH.times.inject(example) do |object, i|
+          terminal_child = Attributor::Model::MAX_EXAMPLE_DEPTH.times.inject(example) do |object, _i|
             object.child
           end
           # after which .child will return nil
-          terminal_child.child.should be(nil)
+          expect(terminal_child.child).to be(nil)
           # but simple attributes will be generated
-          terminal_child.name.should_not be(nil)
+          expect(terminal_child.name).not_to be(nil)
         end
-
-
       end
     end
 
-
     context '.definition' do
       subject(:definition) { Chicken.definition }
 
@@ -141,48 +143,46 @@ describe Attributor::Model do
       end
     end
 
-
     context '.load' do
       let(:age) { 1 }
-      let(:email) { "cluck@example.org" }
-      let(:hash) { {:age => age, :email => email} }
+      let(:email) { 'cluck@example.org' }
+      let(:hash) { { age: age, email: email } }
 
       subject(:model) { Chicken.load(hash) }
 
       context 'with an instance of the model' do
         it 'returns the instance' do
-          Chicken.load(model).should be(model)
+          expect(Chicken.load(model)).to be(model)
         end
       end
 
       context 'with a nil value' do
         it 'returns nil' do
-          Chicken.load(nil).should be_nil
+          expect(Chicken.load(nil)).to be_nil
         end
 
         context 'with recurse: true' do
           subject(:turducken) { Turducken.load(nil, [], recurse: true) }
 
           it 'loads with default values' do
-            turducken.name.should eq("Turkey McDucken")
-            turducken.chicken.age.should be(1)
+            expect(turducken.name).to eq('Turkey McDucken')
+            expect(turducken.chicken.age).to be(1)
           end
-
         end
       end
 
       context 'with a JSON-serialized hash' do
-        let(:context){ ['root','subattr'] }
-        let(:expected_hash) { {"age" => age, "email" => email} }
+        let(:context) { %w(root subattr) }
+        let(:expected_hash) { { 'age' => age, 'email' => email } }
         let(:json) { hash.to_json }
         before do
-          Chicken.should_receive(:from_hash).
-            with(expected_hash,context, recurse: false)
-          JSON.should_receive(:parse).with(json).and_call_original
+          expect(Chicken).to receive(:from_hash)
+            .with(expected_hash, context, recurse: false)
+          expect(JSON).to receive(:parse).with(json).and_call_original
         end
 
         it 'deserializes and calls from_hash' do
-          Chicken.load(json,context)
+          Chicken.load(json, context)
         end
       end
 
@@ -190,36 +190,37 @@ describe Attributor::Model do
         let(:json) { "{'invalid'}" }
 
         it 'catches the error and reports it correctly' do
-          JSON.should_receive(:parse).with(json).and_call_original
-          expect {
-            Chicken.load(json,context)
-          }.to raise_error(Attributor::DeserializationError, /Error deserializing a String using JSON.*#{context.join('.')}/)
+          expect(JSON).to receive(:parse).with(json).and_call_original
+          expect do
+            Chicken.load(json, context)
+          end.to raise_error(Attributor::DeserializationError,
+                             /Error deserializing a String using JSON.*#{context.join('.')}/)
         end
       end
 
-
       context 'with an invalid object type' do
         it 'raises some sort of error' do
-          expect {
+          expect do
             Chicken.load(Object.new, context)
-          }.to raise_error(Attributor::IncompatibleTypeError, /Type Chicken cannot load values of type Object.*#{context.join('.')}/)
+          end.to raise_error(Attributor::IncompatibleTypeError,
+                             /Type Chicken cannot load values of type Object.*#{context.join('.')}/)
         end
       end
 
       context 'with an instance of different model' do
         it 'raises some sort of error' do
-          expect {
+          expect do
             turducken = Turducken.example
-            chicken = Chicken.load(turducken,context)
-          }.to raise_error(Attributor::AttributorException, /Unknown key received/)
+            Chicken.load(turducken, context)
+          end.to raise_error(Attributor::AttributorException, /Unknown key received/)
         end
       end
 
-      context "with a hash" do
+      context 'with a hash' do
         context 'for a complete set of attributes' do
           it 'loads the given attributes' do
-            model.age.should == age
-            model.email.should == email
+            expect(model.age).to eq age
+            expect(model.email).to eq email
           end
         end
 
@@ -227,52 +228,47 @@ describe Attributor::Model do
           let(:hash) { Hash.new }
 
           it 'sets the defaults' do
-            model.age.should == 1
-            model.email.should == nil
+            expect(model.age).to eq 1
+            expect(model.email).to be nil
           end
         end
 
         context 'for a superset of attributes' do
-          let(:hash) { {"invalid_attribute" => "value"} }
+          let(:hash) { { 'invalid_attribute' => 'value' } }
 
           it 'raises an error' do
-            expect {
+            expect do
               Chicken.load(hash, context)
-            }.to raise_error(Attributor::AttributorException, /Unknown key received/)
-            #raise_error(Attributor::AttributorException, /Unknown attributes.*#{context.join('.')}/)
+            end.to raise_error(Attributor::AttributorException, /Unknown key received/)
+            # raise_error(Attributor::AttributorException, /Unknown attributes.*#{context.join('.')}/)
           end
         end
 
         context 'loading with default values' do
           let(:reference) { Post }
-          let(:options) { {reference: reference} }
+          let(:options) { { reference: reference } }
 
           let(:attribute_definition) do
             proc do
               attribute :title
-              attribute :tags, default: ['stuff', 'things']
+              attribute :tags, default: %w(stuff things)
             end
           end
 
-          let(:struct) { Attributor::Struct.construct(attribute_definition, options)}
-
-          let(:data) { {title: 'my post'} }
+          let(:struct) { Attributor::Struct.construct(attribute_definition, options) }
 
-          subject(:loaded)  { struct.load(data) }
+          let(:data) { { title: 'my post' } }
 
+          subject(:loaded) { struct.load(data) }
 
           it 'validates' do
             expect(loaded.validate).to be_empty
           end
-
         end
       end
-
     end
-
   end
 
-
   context 'instance methods' do
     subject(:chicken) { Chicken.new }
 
@@ -283,36 +279,39 @@ describe Attributor::Model do
     end
 
     context 'initialize' do
-
       subject(:chicken) { Chicken.new(attributes_data) }
       context 'supports passing an initial hash object for attribute values' do
-        let(:attributes_data){ {age: '1', email:'rooster@coup.com'} }
+        let(:attributes_data) { { age: '1', email: 'rooster@coup.com' } }
         it 'and sets them in loaded format onto the instance attributes' do
-          Chicken.should_receive(:load).with(attributes_data).and_call_original
+          expect(Chicken).to receive(:load).with(attributes_data).and_call_original
           attributes_data.keys.each do |attr_name|
-            Chicken.attributes[attr_name].should_receive(:load).with(attributes_data[attr_name],instance_of(Array), recurse: false).and_call_original
+            expect(Chicken.attributes[attr_name]).to receive(:load)
+              .with(attributes_data[attr_name], instance_of(Array), recurse: false)
+              .and_call_original
           end
-          subject.age.should be(1)
-          subject.email.should be(attributes_data[:email])
+          expect(subject.age).to be(1)
+          expect(subject.email).to be(attributes_data[:email])
         end
       end
       context 'supports passing a JSON encoded data object' do
-        let(:attributes_hash){ {age: 1, email:'rooster@coup.com'} }
-        let(:attributes_data){ JSON.dump(attributes_hash) }
+        let(:attributes_hash) { { age: 1, email: 'rooster@coup.com' } }
+        let(:attributes_data) { JSON.dump(attributes_hash) }
         it 'and sets them in loaded format onto the instance attributes' do
-          Chicken.should_receive(:load).with(attributes_data).and_call_original
+          expect(Chicken).to receive(:load).with(attributes_data).and_call_original
           attributes_hash.keys.each do |attr_name|
-            Chicken.attributes[attr_name].should_receive(:load).with(attributes_hash[attr_name],instance_of(Array), recurse: false).and_call_original
+            expect(Chicken.attributes[attr_name]).to receive(:load)
+              .with(attributes_hash[attr_name], instance_of(Array), recurse: false)
+              .and_call_original
           end
-          subject.age.should be(1)
-          subject.email.should == attributes_hash[:email]
+          expect(subject.age).to be(1)
+          expect(subject.email).to eq attributes_hash[:email]
         end
       end
       context 'supports passing a native model for the data object' do
-        let(:attributes_data){ Chicken.example }
+        let(:attributes_data) { Chicken.example }
         it 'sets a new instance pointing to the exact same attributes (careful about modifications!)' do
           attributes_data.attributes.each do |attr_name, attr_value|
-            subject.send(attr_name).should be(attr_value)
+            expect(subject.send(attr_name)).to be(attr_value)
           end
         end
       end
@@ -323,48 +322,45 @@ describe Attributor::Model do
         let(:age) { 1 }
         it 'gets and sets attributes' do
           chicken.age = age
-          chicken.age.should == age
+          expect(chicken.age).to eq age
         end
       end
 
       context 'setting nil' do
         it 'assigns the default value if there is one' do
           chicken.age = nil
-          chicken.age.should == 1
+          expect(chicken.age).to eq 1
         end
 
         it 'sets the value to nil if there is no default' do
           chicken.email = nil
-          chicken.email.should == nil
+          expect(chicken.email).to be nil
         end
-
       end
 
       context 'for unknown attributes' do
         it 'raises an exception' do
-          expect {
-            chicken.invalid_attribute =  'value'
-          }.to raise_error(NoMethodError, /undefined method/)
+          expect do
+            chicken.invalid_attribute = 'value'
+          end.to raise_error(NoMethodError, /undefined method/)
         end
       end
 
       context 'for false attributes' do
         subject(:person) { Person.example(okay: false) }
         it 'properly memoizes the value' do
-          person.okay.should be(false)
-          person.okay.should be(false) # second call to ensure we hit the memoized value
+          expect(person.okay).to be(false)
+          expect(person.okay).to be(false) # second call to ensure we hit the memoized value
         end
       end
     end
-
   end
 
-
   context 'validation' do
     context 'for simple models' do
       context 'that are valid' do
-        subject(:chicken)  { Chicken.example }
-        its(:validate) { should be_empty}
+        subject(:chicken) { Chicken.example }
+        its(:validate) { should be_empty }
       end
       context 'that are invalid' do
         subject(:chicken) { Chicken.example(age: 150) }
@@ -375,17 +371,17 @@ describe Attributor::Model do
     context 'for models using the "requires" DSL' do
       subject(:address) { Address.load(state: 'CA') }
       its(:validate) { should_not be_empty }
-      its(:validate) { should include "Key name is required for $." }
+      its(:validate) { should include 'Key name is required for $.' }
     end
     context 'for models with circular sub-attributes' do
       context 'that are valid' do
         subject(:person) { Person.example }
-        its(:validate) { should be_empty}
+        its(:validate) { should be_empty }
       end
 
       context 'that are both invalid' do
-        subject(:person){ Person.load( name: 'Joe', title: 'dude', okay: true )}
-        let(:address){ Address.load( name: '1 Main St', state: 'ME' )}
+        subject(:person) { Person.load(name: 'Joe', title: 'dude', okay: true) }
+        let(:address) { Address.load(name: '1 Main St', state: 'ME') }
         before do
           person.address = address
           address.person = person
@@ -395,35 +391,29 @@ describe Attributor::Model do
 
         it 'recursively-validates sub-attributes with the right context' do
           title_error, state_error = person.validate('person')
-          title_error.should =~ /^Attribute person\.title:/
-          state_error.should =~ /^Attribute person\.address\.state:/
+          expect(title_error).to match(/^Attribute person\.title:/)
+          expect(state_error).to match(/^Attribute person\.address\.state:/)
         end
       end
-
     end
   end
 
-
   context '#dump' do
-
-
     context 'with circular references' do
       subject(:person) { Person.example }
       let(:output) { person.dump }
 
       it 'terminates' do
-        expect {
+        expect do
           Person.example.dump
-        }.to_not raise_error
+        end.to_not raise_error
       end
 
       it 'outputs "..." for circular references' do
-        person.address.person.should be(person)
-        output[:address][:person].should eq(Attributor::Model::CIRCULAR_REFERENCE_MARKER)
+        expect(person.address.person).to be(person)
+        expect(output[:address][:person]).to eq(Attributor::Model::CIRCULAR_REFERENCE_MARKER)
       end
-
     end
-
   end
 
   context 'extending' do
@@ -446,9 +436,8 @@ describe Attributor::Model do
       end
 
       it 'adds the attribute' do
-        model.attributes.keys.should =~ [:id, :name, :timestamps]
+        expect(model.attributes.keys).to match_array [:id, :name, :timestamps]
       end
-
     end
 
     context 'adding to an inner-Struct' do
@@ -461,7 +450,7 @@ describe Attributor::Model do
       end
 
       it 'merges with sub-attributes' do
-        model.attributes[:timestamps].attributes.keys.should =~ [:created_at, :updated_at]
+        expect(model.attributes[:timestamps].attributes.keys).to match_array [:created_at, :updated_at]
       end
     end
 
@@ -477,12 +466,12 @@ describe Attributor::Model do
       subject(:struct) { Attributor::Struct.construct(attributes_block, reference: Cormorant) }
 
       it 'supports defining sub-attributes using the proper reference' do
-        struct.attributes[:neighbors].options[:required].should be true
-        struct.attributes[:neighbors].type.member_attribute.type.attributes.keys.should =~ [:name, :age]
+        expect(struct.attributes[:neighbors].options[:required]).to be true
+        expect(struct.attributes[:neighbors].type.member_attribute.type.attributes.keys).to match_array [:name, :age]
 
         name_options = struct.attributes[:neighbors].type.member_attribute.type.attributes[:name].options
-        name_options[:required].should be true
-        name_options[:description].should eq 'Name of the Cormorant'
+        expect(name_options[:required]).to be true
+        expect(name_options[:description]).to eq 'Name of the Cormorant'
       end
     end
 
@@ -495,14 +484,10 @@ describe Attributor::Model do
         end
 
         it 'updates the type properly' do
-          model.attributes[:id].type.should be(Attributor::String)
+          expect(model.attributes[:id].type).to be(Attributor::String)
         end
-
       end
-
-
     end
-
   end
 
   context 'with no defined attributes' do
@@ -518,9 +503,7 @@ describe Attributor::Model do
     its(:attributes) { should be_empty }
 
     it 'dumps as an empty hash' do
-      example.dump.should eq({})
+      expect(example.dump).to eq({})
     end
-
   end
-
 end