virtus 1.0.1 → 2.0.0

data/spec/integration/hash_attributes_coercion_spec.rb

@@ -23,28 +23,32 @@ describe Package do
   describe '#dimensions' do
     subject { dimensions }
 
-    it { should have(3).keys }
-    it { should have_key :width  }
-    it { should have_key :height }
-    it { should have_key :length }
+    it 'has 3 keys' do
+      expect(subject.keys.size).to eq(3)
+    end
+    it { is_expected.to have_key :width  }
+    it { is_expected.to have_key :height }
+    it { is_expected.to have_key :length }
 
     it 'should be coerced to [Symbol => Float] format' do
-      dimensions[:width].should  be_eql(2.2)
-      dimensions[:height].should be_eql(2.0)
-      dimensions[:length].should be_eql(4.5)
+      expect(dimensions[:width]).to  be_eql(2.2)
+      expect(dimensions[:height]).to be_eql(2.0)
+      expect(dimensions[:length]).to be_eql(4.5)
     end
   end
 
   describe '#meta_info' do
     subject { meta_info }
 
-    it { should have(2).keys }
-    it { should have_key 'from' }
-    it { should have_key 'to'   }
+    it 'has 2 keys' do
+      expect(subject.keys.size).to eq(2)
+    end
+    it { is_expected.to have_key 'from' }
+    it { is_expected.to have_key 'to'   }
 
     it 'should be coerced to [String => String] format' do
-      meta_info['from'].should == 'Me'
-      meta_info['to'].should == 'You'
+      expect(meta_info['from']).to eq('Me')
+      expect(meta_info['to']).to eq('You')
     end
   end
 end

data/spec/integration/mass_assignment_with_accessors_spec.rb

@@ -28,17 +28,17 @@ describe "mass assignment with accessors" do
   subject { Examples::Product.new(:categories => ['Office', 'Printers'], :_id => 100) }
 
   specify 'works uppon instantiation' do
-    subject.category.should == 'Office'
-    subject.subcategory.should == 'Printers'
+    expect(subject.category).to eq('Office')
+    expect(subject.subcategory).to eq('Printers')
   end
 
   specify 'can be set with #attributes=' do
     subject.attributes = {:categories => ['Home', 'Furniture']}
-    subject.category.should == 'Home'
-    subject.subcategory.should == 'Furniture'
+    expect(subject.category).to eq('Home')
+    expect(subject.subcategory).to eq('Furniture')
   end
 
   specify 'respects accessor visibility' do
-    subject.id.should_not == 100
+    expect(subject.id).not_to eq(100)
   end
 end

data/spec/integration/overriding_virtus_spec.rb

@@ -22,11 +22,11 @@ describe 'overriding virtus behavior' do
 
   describe 'overriding an attribute getter' do
     specify 'calls the defined getter' do
-      Examples::Article.new.title.should == '<unknown>'
+      expect(Examples::Article.new.title).to eq('<unknown>')
     end
 
     specify 'super can be used to access the getter defined by virtus' do
-      Examples::Article.new(:title => 'example article').title.should == 'example article'
+      expect(Examples::Article.new(:title => 'example article').title).to eq('example article')
     end
   end
 
@@ -34,13 +34,13 @@ describe 'overriding virtus behavior' do
     specify 'calls the defined setter' do
       article = Examples::Article.new(:title => "can't be changed")
       article.title = 'this will never be assigned'
-      article.title.should == "can't be changed"
+      expect(article.title).to eq("can't be changed")
     end
 
     specify 'super can be used to access the setter defined by virtus' do
       article = Examples::Article.new(:title => 'example article')
       article.title = 'my new title'
-      article.title.should == 'my new title'
+      expect(article.title).to eq('my new title')
     end
   end
 end

data/spec/integration/required_attributes_spec.rb

@@ -13,7 +13,7 @@ describe 'Using required attributes' do
   end
 
   it 'raises coercion error when required attribute is nil' do
-    expect { Examples::User.new(:name => nil) }.to raise_error(Virtus::CoercionError)
+    expect { Examples::User.new(:name => nil) }.to raise_error(Virtus::CoercionError, "Failed to coerce attribute `name' from nil into String")
   end
 
   it 'does not raise coercion error when not required attribute is nil' do

data/spec/integration/struct_as_embedded_value_spec.rb

@@ -19,10 +19,10 @@ describe 'Using Struct as an embedded value attribute' do
   end
 
   specify 'initialize a struct object with correct attributes' do
-    subject.top_left.x.should be(3)
-    subject.top_left.y.should be(5)
+    expect(subject.top_left.x).to be(3)
+    expect(subject.top_left.y).to be(5)
 
-    subject.bottom_right.x.should be(8)
-    subject.bottom_right.y.should be(7)
+    expect(subject.bottom_right.x).to be(8)
+    expect(subject.bottom_right.y).to be(7)
   end
 end

data/spec/integration/using_modules_spec.rb

@@ -33,15 +33,15 @@ describe 'I can define attributes within a module' do
   end
 
   specify 'including a module with attributes into a class' do
-    Examples::User.attribute_set[:name].should be_instance_of(Virtus::Attribute)
-    Examples::User.attribute_set[:gamer].should be_instance_of(Virtus::Attribute::Boolean)
+    expect(Examples::User.attribute_set[:name]).to be_instance_of(Virtus::Attribute)
+    expect(Examples::User.attribute_set[:gamer]).to be_instance_of(Virtus::Attribute::Boolean)
 
-    Examples::Admin.attribute_set[:name].should be_instance_of(Virtus::Attribute)
-    Examples::Admin.attribute_set[:age].should be_instance_of(Virtus::Attribute)
+    expect(Examples::Admin.attribute_set[:name]).to be_instance_of(Virtus::Attribute)
+    expect(Examples::Admin.attribute_set[:age]).to be_instance_of(Virtus::Attribute)
 
     user = Examples::Admin.new(:name => 'Piotr', :age => 29)
-    user.name.should eql('Piotr')
-    user.age.should eql(29)
+    expect(user.name).to eql('Piotr')
+    expect(user.age).to eql(29)
   end
 
   specify 'including a module with attributes into an instance' do
@@ -49,7 +49,7 @@ describe 'I can define attributes within a module' do
     moderator.extend(Examples::Name, Examples::Age)
 
     moderator.attributes = { :name => 'John', :age => 21 }
-    moderator.name.should eql('John')
-    moderator.age.should eql(21)
+    expect(moderator.name).to eql('John')
+    expect(moderator.age).to eql(21)
   end
 end

data/spec/integration/value_object_with_custom_constructor_spec.rb

@@ -33,10 +33,10 @@ describe "Defining a ValueObject with a custom constructor" do
   end
 
   specify "initialize a value object attribute with correct attributes" do
-    subject.top_left.x.should be(3)
-    subject.top_left.y.should be(4)
+    expect(subject.top_left.x).to be(3)
+    expect(subject.top_left.y).to be(4)
 
-    subject.bottom_right.x.should be(5)
-    subject.bottom_right.y.should be(8)
+    expect(subject.bottom_right.x).to be(5)
+    expect(subject.bottom_right.y).to be(8)
   end
 end

data/spec/integration/virtus/instance_level_attributes_spec.rb

@@ -17,7 +17,7 @@ describe Virtus, 'instance level attributes' do
     it 'allows setting the attribute value on the instance' do
       attribute
       subject.name = 'foo'
-      subject.name.should eql('foo')
+      expect(subject.name).to eql('foo')
     end
   end
 end

data/spec/integration/virtus/value_object_spec.rb

@@ -26,21 +26,21 @@ describe Virtus::ValueObject do
 
   describe 'initialization' do
     it 'sets the attribute values provided to Class.new' do
-      class_under_test.new(:latitude => 10000.001).latitude.should == 10000.001
-      subject.latitude.should eql(attribute_values[:latitude])
+      expect(class_under_test.new(:latitude => 10000.001).latitude).to eq(10000.001)
+      expect(subject.latitude).to eql(attribute_values[:latitude])
     end
   end
 
   describe 'writer visibility' do
     it 'attributes are configured for private writers' do
-      class_under_test.attribute_set[:latitude].public_reader?.should be(true)
-      class_under_test.attribute_set[:longitude].public_writer?.should be(false)
+      expect(class_under_test.attribute_set[:latitude].public_reader?).to be(true)
+      expect(class_under_test.attribute_set[:longitude].public_writer?).to be(false)
     end
 
     it 'writer methods are set to private' do
       private_methods = class_under_test.private_instance_methods
       private_methods.map! { |m| m.to_s }
-      private_methods.should include('latitude=', 'longitude=', 'attributes=')
+      expect(private_methods).to include('latitude=', 'longitude=', 'attributes=')
     end
 
     it 'attempts to call attribute writer methods raises NameError' do
@@ -52,48 +52,48 @@ describe Virtus::ValueObject do
   describe 'equality' do
     describe '#==' do
       it 'returns true for different objects with the same state' do
-        subject.should == instance_with_equal_state
+        expect(subject).to eq(instance_with_equal_state)
       end
 
       it 'returns false for different objects with different state' do
-        subject.should_not == instance_with_different_state
+        expect(subject).not_to eq(instance_with_different_state)
       end
     end
 
     describe '#eql?' do
       it 'returns true for different objects with the same state' do
-        subject.should eql(instance_with_equal_state)
+        expect(subject).to eql(instance_with_equal_state)
       end
 
       it 'returns false for different objects with different state' do
-        subject.should_not eql(instance_with_different_state)
+        expect(subject).not_to eql(instance_with_different_state)
       end
     end
 
     describe '#equal?' do
       it 'returns false for different objects with the same state' do
-        subject.should_not equal(instance_with_equal_state)
+        expect(subject).not_to equal(instance_with_equal_state)
       end
 
       it 'returns false for different objects with different state' do
-        subject.should_not equal(instance_with_different_state)
+        expect(subject).not_to equal(instance_with_different_state)
       end
     end
 
     describe '#hash' do
       it 'returns the same value for different objects with the same state' do
-        subject.hash.should eql(instance_with_equal_state.hash)
+        expect(subject.hash).to eql(instance_with_equal_state.hash)
       end
 
       it 'returns different values for different objects with different state' do
-        subject.hash.should_not eql(instance_with_different_state.hash)
+        expect(subject.hash).not_to eql(instance_with_different_state.hash)
       end
     end
   end
 
   describe '#inspect' do
     it 'includes the class name and attribute values' do
-      subject.inspect.should == '#<GeoLocation latitude=10.0 longitude=20.0>'
+      expect(subject.inspect).to eq('#<GeoLocation latitude=10.0 longitude=20.0>')
     end
   end
 end

data/spec/shared/freeze_method_behavior.rb

@@ -20,7 +20,7 @@ shared_examples_for 'a #freeze method' do
   it_should_behave_like 'an idempotent method'
 
   it 'returns object' do
-    should be(object)
+    is_expected.to be(object)
   end
 
   it 'prevents future modifications' do
@@ -29,9 +29,12 @@ shared_examples_for 'a #freeze method' do
     expect { object.instance_variable_set(:@foo, :bar) }.to(expectation)
   end
 
-  its(:frozen?) { should be(true) }
+  describe '#frozen?' do
+    subject { super().frozen? }
+    it { is_expected.to be(true) }
+  end
 
   it 'allows to access attribute' do
-    subject.name.should eql('John')
+    expect(subject.name).to eql('John')
   end
 end

data/spec/shared/idempotent_method_behaviour.rb

@@ -1,5 +1,5 @@
 shared_examples_for 'an idempotent method' do
   it 'is idempotent' do
-    should equal(subject)
+    is_expected.to equal(subject)
   end
 end

data/spec/shared/options_class_method.rb

@@ -2,15 +2,15 @@ shared_examples_for 'an options class method' do
   context 'with no argument' do
     subject { object.send(method) }
 
-    it { should be(default) }
+    it { is_expected.to be(default) }
   end
 
   context 'with a default value' do
     subject { object.send(method, value) }
 
-    let(:value) { double('value') }
+    let(:value) { mock('value') }
 
-    it { should equal(object) }
+    it { is_expected.to equal(object) }
 
     it 'sets the default value for the class method' do
       expect { subject }.to change { object.send(method) }.from(default).to(value)

data/spec/spec_helper.rb

@@ -1,25 +1,11 @@
-if ENV['COVERAGE'] == 'true'
+if RUBY_ENGINE == 'ruby' && RUBY_VERSION >= '3.0'
   require 'simplecov'
-  require 'coveralls'
-
-  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-    SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
-  ]
-
-  SimpleCov.start do
-    command_name     'spec:unit'
-    add_filter       'config/'
-    add_filter       'spec'
-    add_filter       '.bundle'
-    minimum_coverage 98
-  end
+  SimpleCov.start
 end
 
 require 'rspec'
 require 'bogus/rspec'
 require 'virtus'
-require 'inflecto' # for resolving namespaced constant names
 
 module Virtus
   def self.warn(*)
@@ -33,7 +19,6 @@ ENV['TZ'] = 'UTC'
 Dir[File.expand_path('../shared/**/*.rb', __FILE__)].each { |file| require file }
 
 RSpec.configure do |config|
-
   # Remove anonymous- and example- Attribute classes from Attribute descendants
   config.after :all do
     stack = [ Virtus::Attribute ]
@@ -53,5 +38,4 @@ RSpec.configure do |config|
       end
     end
   end
-
 end

data/spec/unit/virtus/attribute/boolean/coerce_spec.rb

@@ -10,13 +10,13 @@ describe Virtus::Attribute::Boolean, '#coerce' do
     context 'with a truthy value' do
       let(:input) { 1 }
 
-      it { should be(true) }
+      it { is_expected.to be(true) }
     end
 
     context 'with a falsy value' do
       let(:input) { 0 }
 
-      it { should be(false) }
+      it { is_expected.to be(false) }
     end
   end
 
@@ -26,7 +26,7 @@ describe Virtus::Attribute::Boolean, '#coerce' do
     context 'with a coercible input' do
       let(:input) { 1 }
 
-      it { should be(true) }
+      it { is_expected.to be(true) }
     end
 
     context 'with a non-coercible input' do

data/spec/unit/virtus/attribute/boolean/value_coerced_predicate_spec.rb

@@ -8,18 +8,18 @@ describe Virtus::Attribute::Boolean, '#value_coerced?' do
   context 'when input is true' do
     let(:input) { true }
 
-    it { should be(true) }
+    it { is_expected.to be(true) }
   end
 
   context 'when input is false' do
     let(:input) { false }
 
-    it { should be(true) }
+    it { is_expected.to be(true) }
   end
 
   context 'when input is not coerced' do
     let(:input) { 1 }
 
-    it { should be(false) }
+    it { is_expected.to be(false) }
   end
 end

data/spec/unit/virtus/attribute/class_methods/build_spec.rb

@@ -7,19 +7,19 @@ describe Virtus::Attribute, '.build' do
   let(:type)    { String }
   let(:options) { {} }
 
-  share_examples_for 'a valid attribute instance' do
-    it { should be_instance_of(Virtus::Attribute) }
+  shared_examples_for 'a valid attribute instance' do
+    it { is_expected.to be_instance_of(Virtus::Attribute) }
 
-    it { should be_frozen }
+    it { is_expected.to be_frozen }
   end
 
   context 'without options' do
     it_behaves_like 'a valid attribute instance'
 
-    it { should be_coercible }
-    it { should be_public_reader }
-    it { should be_public_writer }
-    it { should_not be_lazy }
+    it { is_expected.to be_coercible }
+    it { is_expected.to be_public_reader }
+    it { is_expected.to be_public_writer }
+    it { is_expected.not_to be_lazy }
 
     it 'sets up a coercer' do
       expect(subject.options[:coerce]).to be(true)
@@ -30,7 +30,10 @@ describe Virtus::Attribute, '.build' do
   context 'when name is passed as a string' do
     let(:name) { 'something' }
 
-    its(:name) { should be(:something) }
+    describe '#name' do
+      subject { super().name }
+      it { is_expected.to be(:something) }
+    end
   end
 
   context 'when coercion is turned off in options' do
@@ -38,7 +41,7 @@ describe Virtus::Attribute, '.build' do
 
     it_behaves_like 'a valid attribute instance'
 
-    it { should_not be_coercible }
+    it { is_expected.not_to be_coercible }
   end
 
   context 'when options specify reader visibility' do
@@ -46,8 +49,8 @@ describe Virtus::Attribute, '.build' do
 
     it_behaves_like 'a valid attribute instance'
 
-    it { should_not be_public_reader }
-    it { should be_public_writer }
+    it { is_expected.not_to be_public_reader }
+    it { is_expected.to be_public_writer }
   end
 
   context 'when options specify writer visibility' do
@@ -55,8 +58,8 @@ describe Virtus::Attribute, '.build' do
 
     it_behaves_like 'a valid attribute instance'
 
-    it { should be_public_reader }
-    it { should_not be_public_writer }
+    it { is_expected.to be_public_reader }
+    it { is_expected.not_to be_public_writer }
   end
 
   context 'when options specify lazy accessor' do
@@ -64,7 +67,7 @@ describe Virtus::Attribute, '.build' do
 
     it_behaves_like 'a valid attribute instance'
 
-    it { should be_lazy }
+    it { is_expected.to be_lazy }
   end
 
   context 'when options specify strict mode' do
@@ -72,7 +75,15 @@ describe Virtus::Attribute, '.build' do
 
     it_behaves_like 'a valid attribute instance'
 
-    it { should be_strict }
+    it { is_expected.to be_strict }
+  end
+
+  context 'when options specify nullify blank mode' do
+    let(:options) { { :nullify_blank => true } }
+
+    it_behaves_like 'a valid attribute instance'
+
+    it { is_expected.to be_nullify_blank }
   end
 
   context 'when type is a string' do
@@ -80,7 +91,21 @@ describe Virtus::Attribute, '.build' do
 
     it_behaves_like 'a valid attribute instance'
 
-    its(:type) { should be(Axiom::Types::Integer) }
+    describe '#type' do
+      subject { super().type }
+      it { is_expected.to be(Axiom::Types::Integer) }
+    end
+  end
+
+  context 'when type is a range' do
+    let(:type) { 0..10 }
+
+    it_behaves_like 'a valid attribute instance'
+
+    describe '#type' do
+      subject { super().type }
+      it { is_expected.to be(Axiom::Types.infer(Range)) }
+    end
   end
 
   context 'when type is a symbol of an existing class constant' do
@@ -88,7 +113,10 @@ describe Virtus::Attribute, '.build' do
 
     it_behaves_like 'a valid attribute instance'
 
-    its(:type) { should be(Axiom::Types::String) }
+    describe '#type' do
+      subject { super().type }
+      it { is_expected.to be(Axiom::Types::String) }
+    end
   end
 
   context 'when type is an axiom type' do
@@ -96,7 +124,10 @@ describe Virtus::Attribute, '.build' do
 
     it_behaves_like 'a valid attribute instance'
 
-    its(:type) { should be(type) }
+    describe '#type' do
+      subject { super().type }
+      it { is_expected.to be(type) }
+    end
   end
 
   context 'when custom attribute class exists for a given primitive' do
@@ -107,9 +138,12 @@ describe Virtus::Attribute, '.build' do
       attribute.primitive(type)
     end
 
-    it { should be_instance_of(attribute) }
+    it { is_expected.to be_instance_of(attribute) }
 
-    its(:type) { should be(Axiom::Types::Object) }
+    describe '#type' do
+      subject { super().type }
+      it { is_expected.to be(Axiom::Types::Object) }
+    end
   end
 
   context 'when custom attribute class exists for a given array with member coercion defined' do
@@ -120,9 +154,12 @@ describe Virtus::Attribute, '.build' do
       attribute.primitive(type.class)
     end
 
-    it { should be_instance_of(attribute) }
+    it { is_expected.to be_instance_of(attribute) }
 
-    its(:type) { should be < Axiom::Types::Collection }
+    describe '#type' do
+      subject { super().type }
+      it { is_expected.to be < Axiom::Types::Collection }
+    end
   end
 
   context 'when custom collection-like attribute class exists for a given enumerable primitive' do
@@ -133,8 +170,11 @@ describe Virtus::Attribute, '.build' do
       attribute.primitive(type)
     end
 
-    it { should be_instance_of(attribute) }
+    it { is_expected.to be_instance_of(attribute) }
 
-    its(:type) { should be < Axiom::Types::Collection }
+    describe '#type' do
+      subject { super().type }
+      it { is_expected.to be < Axiom::Types::Collection }
+    end
   end
 end