attributor 5.0.2 → 5.1.0

data/spec/attributor_spec.rb

@@ -1,6 +1,5 @@
 require File.join(File.dirname(__FILE__), 'spec_helper.rb')
 
-
 describe Attributor do
   context '.resolve_type' do
     context 'given valid types' do
@@ -12,12 +11,12 @@ describe Attributor do
         ::Attributor::DateTime => Attributor::DateTime,
         # FIXME: Boolean doesn't exist in Ruby, thus this causes and error
         # https://github.com/rightscale/attributor/issues/25
-        #Boolean => Attributor::Boolean,
+        # Boolean => Attributor::Boolean,
         Attributor::Boolean => Attributor::Boolean,
         Attributor::Struct => Attributor::Struct
       }.each do |type, expected_type|
         it "resolves #{type} as #{expected_type}" do
-          Attributor.resolve_type(type).should == expected_type
+          expect(Attributor.resolve_type(type)).to eq expected_type
         end
       end
     end
@@ -29,35 +28,32 @@ describe Attributor do
     subject(:humanized) { Attributor.humanize_context(context) }
 
     context 'with string value' do
-      let(:context) { 'some-context'}
-      it { should eq('some-context')}
+      let(:context) { 'some-context' }
+      it { should eq('some-context') }
     end
 
     context 'with array value' do
-      let(:context) { ['a', 'b'] }
+      let(:context) { %w(a b) }
       it { should eq('a.b') }
     end
-
   end
 
-
   context '.type_name' do
     it 'accepts arbtirary classes' do
-      Attributor.type_name(File).should eq 'File'
+      expect(Attributor.type_name(File)).to eq 'File'
     end
 
     it 'accepts instances' do
-      Attributor.type_name('a string').should eq 'String'
+      expect(Attributor.type_name('a string')).to eq 'String'
     end
 
     it 'accepts instances of anonymous types' do
-      type = Class.new(Attributor::Struct) 
-      Attributor.type_name(type).should eq 'Attributor::Struct'
+      type = Class.new(Attributor::Struct)
+      expect(Attributor.type_name(type)).to eq 'Attributor::Struct'
     end
 
     it 'accepts Attributor types' do
-      Attributor.type_name(Attributor::String).should eq 'Attributor::String'
+      expect(Attributor.type_name(Attributor::String)).to eq 'Attributor::String'
     end
-    
   end
-end
+end

data/spec/dsl_compiler_spec.rb

@@ -1,9 +1,7 @@
 require File.join(File.dirname(__FILE__), 'spec_helper.rb')
 
-
 describe Attributor::DSLCompiler do
-
-  let(:target) { double("model", attributes: {}) }
+  let(:target) { double('model', attributes: {}) }
 
   let(:dsl_compiler_options) { {} }
   subject(:dsl_compiler) { Attributor::DSLCompiler.new(target, dsl_compiler_options) }
@@ -14,7 +12,7 @@ describe Attributor::DSLCompiler do
   let!(:reference_attributes) { Turducken.attributes }
   let(:reference_type) { reference_attribute.type }
   let(:reference_attribute_options) { reference_attribute.options }
-  let(:reference_attribute) {reference_attributes[attribute_name] }
+  let(:reference_attribute) { reference_attributes[attribute_name] }
 
   context '#attribute' do
     let(:attribute_options) { {} }
@@ -25,44 +23,40 @@ describe Attributor::DSLCompiler do
     context 'when not not given a block for a sub-definition' do
       context 'without a reference' do
         it 'raises an error for a missing type' do
-          expect {
+          expect do
             dsl_compiler.attribute(attribute_name)
-          }.to raise_error(/type for attribute/)
-
+          end.to raise_error(/type for attribute/)
         end
 
         it 'creates an attribute given a name and type' do
-          Attributor::Attribute.should_receive(:new).with(expected_type, expected_options)
+          expect(Attributor::Attribute).to receive(:new).with(expected_type, expected_options)
           dsl_compiler.attribute(attribute_name, type)
         end
 
-
         it 'creates an attribute given a name, type, and options' do
-          Attributor::Attribute.should_receive(:new).with(expected_type, expected_options)
+          expect(Attributor::Attribute).to receive(:new).with(expected_type, expected_options)
           dsl_compiler.attribute(attribute_name, type, attribute_options)
         end
-
       end
 
-
       context 'with a reference' do
-        let(:dsl_compiler_options) { {:reference => Turducken} }
+        let(:dsl_compiler_options) { { reference: Turducken } }
 
         context 'with no options' do
           let(:expected_options) { reference_attribute_options }
 
           it 'creates an attribute with the inherited type' do
-            Attributor::Attribute.should_receive(:new).with(expected_type, expected_options)
+            expect(Attributor::Attribute).to receive(:new).with(expected_type, expected_options)
             dsl_compiler.attribute(attribute_name)
           end
         end
 
         context 'with options' do
-          let(:attribute_options) { {:description => "some new description", :required => true} }
+          let(:attribute_options) { { description: 'some new description', required: true } }
           let(:expected_options) { reference_attribute_options.merge(attribute_options) }
 
           before do
-            Attributor::Attribute.should_receive(:new).with(expected_type, expected_options)
+            expect(Attributor::Attribute).to receive(:new).with(expected_type, expected_options)
           end
 
           it 'creates an attribute with the inherited type and merged options' do
@@ -72,7 +66,6 @@ describe Attributor::DSLCompiler do
           it 'accepts explicit nil type' do
             dsl_compiler.attribute(attribute_name, nil, attribute_options)
           end
-
         end
 
         context 'for a referenced Model attribute' do
@@ -81,50 +74,43 @@ describe Attributor::DSLCompiler do
           let(:expected_options) { reference_attribute_options.merge(attribute_options) }
 
           it 'creates an attribute with the inherited type' do
-            Attributor::Attribute.should_receive(:new).with(expected_type, expected_options)
+            expect(Attributor::Attribute).to receive(:new).with(expected_type, expected_options)
             dsl_compiler.attribute(attribute_name)
           end
         end
-
       end
-
     end
 
-
     context 'when given a block for sub-attributes' do
-      let(:attribute_block) { Proc.new { } }
+      let(:attribute_block) { proc {} }
       let(:attribute_name) { :turkey }
       let(:type) { Attributor::Struct }
       let(:expected_type) { Attributor::Struct }
 
       context 'without a reference' do
         it 'defaults type to Struct' do
-          Attributor::Attribute.should_receive(:new).with(expected_type, expected_options)
+          expect(Attributor::Attribute).to receive(:new).with(expected_type, expected_options)
           dsl_compiler.attribute(attribute_name, &attribute_block)
         end
       end
 
       context 'with a reference' do
-        let(:dsl_compiler_options) { {:reference => Turducken} }
+        let(:dsl_compiler_options) { { reference: Turducken } }
         let(:expected_options) do
-          attribute_options.merge(:reference => reference_type)
+          attribute_options.merge(reference: reference_type)
         end
 
         it 'sets the type of the attribute to Struct' do
-          Attributor::Attribute.should_receive(:new).
-            with(expected_type, {:description=>"The turkey", :reference=>Turkey})
+          expect(Attributor::Attribute).to receive(:new)
+            .with(expected_type, description: 'The turkey', reference: Turkey)
           dsl_compiler.attribute(attribute_name, attribute_options, &attribute_block)
         end
 
         it 'passes the correct reference to the created attribute' do
-          Attributor::Attribute.should_receive(:new).with(expected_type, expected_options)
-          dsl_compiler.attribute(attribute_name, type,  attribute_options, &attribute_block)
+          expect(Attributor::Attribute).to receive(:new).with(expected_type, expected_options)
+          dsl_compiler.attribute(attribute_name, type, attribute_options, &attribute_block)
         end
-
       end
-
     end
-
   end
-
 end

data/spec/dumpable_spec.rb

@@ -1,30 +1,29 @@
 require File.join(File.dirname(__FILE__), 'spec_helper.rb')
 
 describe 'Dumpable' do
-
   context 'for classes forgetting to implement #dump' do
-    let(:type) {
+    let(:type) do
       Class.new do
         include Attributor::Dumpable
       end
-     }
+    end
 
     it 'gets an exception' do
-      expect{ type.new.dump }.to raise_exception(NotImplementedError)
+      expect { type.new.dump }.to raise_exception(NotImplementedError)
     end
   end
 
   context 'for classes properly implementing #dump' do
-    let(:type) {
+    let(:type) do
       Class.new do
         include Attributor::Dumpable
         def dump
         end
       end
-     }
+    end
 
     it 'do not get the base exception' do
-      expect{ type.new.dump }.to_not raise_exception
+      expect { type.new.dump }.to_not raise_error
     end
   end
 end

data/spec/extras/field_selector/field_selector_spec.rb

@@ -29,7 +29,7 @@ describe Attributor::FieldSelector do
     cases.each do |fields, result|
       it "loads #{fields.inspect}" do
         loaded = subject.load(fields)
-        loaded.should eq result
+        expect(loaded).to eq result
       end
     end
   end

data/spec/families_spec.rb

@@ -1,14 +1,12 @@
 require File.join(File.dirname(__FILE__), 'spec_helper.rb')
 
 describe 'Type families' do
-
   let(:types) { ObjectSpace.each_object(Class).select { |k| k < Attributor::Type } }
 
   it 'are set on all types' do
     types.each do |type|
       next if type == Attributor::Object # object has no set family
-      type.should_not be_in_family('attributor')
+      expect(type).not_to be_in_family('attributor')
     end
   end
-
 end

data/spec/hash_dsl_compiler_spec.rb

@@ -1,176 +1,167 @@
 require File.join(File.dirname(__FILE__), 'spec_helper.rb')
 
-
 describe Attributor::HashDSLCompiler do
-
-  let(:target) { double("model", attributes: {}) }
+  let(:target) { double('model', attributes: {}) }
 
   let(:dsl_compiler_options) { {} }
   subject(:dsl_compiler) { Attributor::HashDSLCompiler.new(target, dsl_compiler_options) }
 
   it 'returns the requirements DSL attached to the right target' do
     req_dsl = dsl_compiler._requirements_dsl
-    req_dsl.should be_kind_of( Attributor::HashDSLCompiler::RequiresDSL )
-    req_dsl.target.should be(target)
+    expect(req_dsl).to be_kind_of(Attributor::HashDSLCompiler::RequiresDSL)
+    expect(req_dsl.target).to be(target)
   end
 
   context 'requires' do
-
     context 'without any arguments' do
       it 'without params returns the underlying compiler to chain internal methods' do
-        subject.requires.should be_kind_of( Attributor::HashDSLCompiler::RequiresDSL )
+        expect(subject.requires).to be_kind_of(Attributor::HashDSLCompiler::RequiresDSL)
       end
     end
 
     context 'with params only (and some options)' do
       it 'takes then array to mean all attributes are required' do
-        target.should_receive(:add_requirement)
-        requirement = subject.requires :one, :two , description: "These are very required"
-        requirement.should be_kind_of( Attributor::HashDSLCompiler::Requirement )
-        requirement.type.should be(:all)
+        expect(target).to receive(:add_requirement)
+        requirement = subject.requires :one, :two, description: 'These are very required'
+        expect(requirement).to be_kind_of(Attributor::HashDSLCompiler::Requirement)
+        expect(requirement.type).to be(:all)
       end
     end
     context 'with a block only (and some options)' do
       it 'evals it in the context of the Compiler' do
-        proc = Proc.new {}
+        proc = proc {}
         dsl = dsl_compiler._requirements_dsl
-        dsl.should_receive(:instance_eval)#.with(&proc) << Does rspec 2.99 support block args?
-        subject.requires description: "These are very required", &proc
+        expect(dsl).to receive(:instance_eval) # .with(&proc) << Does rspec 2.99 support block args?
+        subject.requires description: 'These are very required', &proc
       end
     end
-
-
   end
 
   context 'RequiresDSL' do
-
-    subject(:dsl){ Attributor::HashDSLCompiler::RequiresDSL.new(target) }
+    subject(:dsl) { Attributor::HashDSLCompiler::RequiresDSL.new(target) }
     it 'stores the received target' do
-      subject.target.should be(target)
+      expect(subject.target).to be(target)
     end
 
     context 'has DSL methods' do
-      let(:req){ double("requirement") }
-      let(:attr_names){ [:one, :two, :tree] }
-      let(:number){ 2 }
-      let(:req_class){ Attributor::HashDSLCompiler::Requirement }
+      let(:req) { double('requirement') }
+      let(:attr_names) { [:one, :two, :tree] }
+      let(:number) { 2 }
+      let(:req_class) { Attributor::HashDSLCompiler::Requirement }
       before do
-        target.should_receive(:add_requirement).with(req)
+        expect(target).to receive(:add_requirement).with(req)
       end
       it 'responds to .all' do
-        req_class.should_receive(:new).with( all: attr_names ).and_return(req)
+        expect(req_class).to receive(:new).with(all: attr_names).and_return(req)
         subject.all(*attr_names)
       end
       it 'responds to .at_most(n)' do
-        req_class.should_receive(:new).with( at_most: number ).and_return(req)
+        expect(req_class).to receive(:new).with(at_most: number).and_return(req)
         subject.at_most(number)
       end
       it 'responds to .at_least(n)' do
-        req_class.should_receive(:new).with( at_least: number ).and_return(req)
+        expect(req_class).to receive(:new).with(at_least: number).and_return(req)
         subject.at_least(number)
       end
       it 'responds to .exactly(n)' do
-        req_class.should_receive(:new).with( exactly: number ).and_return(req)
+        expect(req_class).to receive(:new).with(exactly: number).and_return(req)
         subject.exactly(number)
       end
       it 'responds to .exclusive' do
-        req_class.should_receive(:new).with( exclusive: attr_names ).and_return(req)
+        expect(req_class).to receive(:new).with(exclusive: attr_names).and_return(req)
         subject.exclusive(*attr_names)
       end
-
     end
   end
 
   context 'Requirement' do
-
-    let(:attr_names){ [:one, :two, :tree] }
-    let(:req_class){ Attributor::HashDSLCompiler::Requirement }
+    let(:attr_names) { [:one, :two, :tree] }
+    let(:req_class) { Attributor::HashDSLCompiler::Requirement }
 
     context 'initialization' do
       it 'calls .of for exclusive' do
-        req_class.any_instance.should_receive(:of).with(*attr_names)
+        expect_any_instance_of(req_class).to receive(:of).with(*attr_names)
         req_class.new(exclusive: attr_names)
       end
       it 'calls .of for all' do
-        req_class.any_instance.should_receive(:of).with(*attr_names)
+        expect_any_instance_of(req_class).to receive(:of).with(*attr_names)
         req_class.new(all: attr_names)
       end
       it 'saves the number for the rest' do
-        req_class.new(exactly:  1).number.should be(1)
-        req_class.new(exactly:  1).type.should be(:exactly)
-        req_class.new(at_most:  2).number.should be(2)
-        req_class.new(at_most:  2).type.should be(:at_most)
-        req_class.new(at_least: 3).number.should be(3)
-        req_class.new(at_least: 3).type.should be(:at_least)
+        expect(req_class.new(exactly:  1).number).to be(1)
+        expect(req_class.new(exactly:  1).type).to be(:exactly)
+        expect(req_class.new(at_most:  2).number).to be(2)
+        expect(req_class.new(at_most:  2).type).to be(:at_most)
+        expect(req_class.new(at_least: 3).number).to be(3)
+        expect(req_class.new(at_least: 3).type).to be(:at_least)
       end
       it 'understands and saves a :description' do
-        req = req_class.new(exactly:  1, description: "Hello")
-        req.number.should be(1)
-        req.description.should eq("Hello")
+        req = req_class.new(exactly:  1, description: 'Hello')
+        expect(req.number).to be(1)
+        expect(req.description).to eq('Hello')
       end
     end
 
     context 'Requirement#validate' do
-      let(:requirement){ req_class.new(arguments) }
-      let(:subject){ requirement.validate(value,["$"],nil)}
+      let(:requirement) { req_class.new(arguments) }
+      let(:subject) { requirement.validate(value, ['$'], nil) }
 
       context 'for :all' do
-        let(:arguments){ { all: [:one, :two, :three] } }
-        let(:value){ [:one] }
-        let(:validation_error){ ["Key two is required for $.", "Key three is required for $."] }
-        it { subject.should include(*validation_error) }
+        let(:arguments) { { all: [:one, :two, :three] } }
+        let(:value) { [:one] }
+        let(:validation_error) { ['Key two is required for $.', 'Key three is required for $.'] }
+        it { expect(subject).to include(*validation_error) }
       end
       context 'for :exactly' do
-        let(:requirement) { req_class.new(exactly: 1).of(:one,:two) }
-        let(:value){ [:one, :two] }
-        let(:validation_error){ "Exactly 1 of the following keys [:one, :two] are required for $. Found 2 instead: [:one, :two]" }
-        it { subject.should include(validation_error) }
+        let(:requirement) { req_class.new(exactly: 1).of(:one, :two) }
+        let(:value) { [:one, :two] }
+        let(:validation_error) { 'Exactly 1 of the following keys [:one, :two] are required for $. Found 2 instead: [:one, :two]' }
+        it { expect(subject).to include(validation_error) }
       end
       context 'for :at_least' do
-        let(:requirement) { req_class.new(at_least: 2).of(:one,:two,:three) }
-        let(:value){ [:one] }
-        let(:validation_error){ "At least 2 keys out of [:one, :two, :three] are required to be passed in for $. Found [:one]" }
-        it { subject.should include(validation_error) }
+        let(:requirement) { req_class.new(at_least: 2).of(:one, :two, :three) }
+        let(:value) { [:one] }
+        let(:validation_error) { 'At least 2 keys out of [:one, :two, :three] are required to be passed in for $. Found [:one]' }
+        it { expect(subject).to include(validation_error) }
       end
       context 'for :at_most' do
-        let(:requirement) { req_class.new(at_most: 1).of(:one,:two,:three) }
-        let(:value){ [:one, :two] }
-        let(:validation_error){ "At most 1 keys out of [:one, :two, :three] can be passed in for $. Found [:one, :two]" }
-        it { subject.should include(validation_error) }
+        let(:requirement) { req_class.new(at_most: 1).of(:one, :two, :three) }
+        let(:value) { [:one, :two] }
+        let(:validation_error) { 'At most 1 keys out of [:one, :two, :three] can be passed in for $. Found [:one, :two]' }
+        it { expect(subject).to include(validation_error) }
       end
       context 'for :exclusive' do
-        let(:arguments){ { exclusive: [:one, :two] } }
-        let(:value){ [:one, :two] }
-        let(:validation_error){ "keys [:one, :two] are mutually exclusive for $." }
-        it { subject.should include(validation_error) }
+        let(:arguments) { { exclusive: [:one, :two] } }
+        let(:value) { [:one, :two] }
+        let(:validation_error) { 'keys [:one, :two] are mutually exclusive for $.' }
+        it { expect(subject).to include(validation_error) }
       end
     end
 
     context 'Requirement#describe' do
-
       it 'should work for :all' do
         req = req_class.new(all: attr_names).describe
-        req.should eq( type: :all, attributes: [:one, :two, :tree] )
+        expect(req).to eq(type: :all, attributes: [:one, :two, :tree])
       end
       it 'should work for :exclusive n' do
         req = req_class.new(exclusive: attr_names).describe
-        req.should eq( type: :exclusive, attributes: [:one, :two, :tree] )
+        expect(req).to eq(type: :exclusive, attributes: [:one, :two, :tree])
       end
       it 'should work for :exactly' do
         req = req_class.new(exactly: 1).of(*attr_names).describe
-        req.should include( type: :exactly,  count: 1, attributes: [:one, :two, :tree] )
+        expect(req).to include(type: :exactly, count: 1, attributes: [:one, :two, :tree])
       end
       it 'should work for :at_most n' do
         req = req_class.new(at_most: 1).of(*attr_names).describe
-        req.should include( type: :at_most,  count: 1, attributes: [:one, :two, :tree] )
+        expect(req).to include(type: :at_most, count: 1, attributes: [:one, :two, :tree])
       end
       it 'should work for :at_least n' do
         req = req_class.new(at_least: 1).of(*attr_names).describe
-        req.should include( type: :at_least,  count: 1, attributes: [:one, :two, :tree] )
+        expect(req).to include(type: :at_least, count: 1, attributes: [:one, :two, :tree])
       end
       it 'should report a description' do
-        req = req_class.new(at_least: 1, description: "no more than 1").of(*attr_names).describe
-        req.should include( type: :at_least,  count: 1, attributes: [:one, :two, :tree], description: "no more than 1" )
+        req = req_class.new(at_least: 1, description: 'no more than 1').of(*attr_names).describe
+        expect(req).to include(type: :at_least, count: 1, attributes: [:one, :two, :tree], description: 'no more than 1')
       end
     end
   end