virtus 1.0.1 → 2.0.0

data/lib/virtus/module_extensions.rb

@@ -15,7 +15,9 @@ module Virtus
     # @api private
     def self.setup(mod, inclusions = [Model], attribute_definitions = [])
       mod.instance_variable_set('@inclusions', inclusions)
-      mod.instance_variable_set('@attribute_definitions', attribute_definitions)
+      existing_attributes = mod.instance_variable_get('@attribute_definitions')
+      new_attributes = (existing_attributes || []) + attribute_definitions
+      mod.instance_variable_set('@attribute_definitions', new_attributes)
     end
 
     # Define an attribute in the module
@@ -57,7 +59,11 @@ module Virtus
       super
 
       if Class === object
-        @inclusions.each { |mod| object.send(:include, mod) }
+        @inclusions.reject do |mod|
+          object.ancestors.include?(mod)
+        end.each do |mod|
+          object.send(:include, mod)
+        end
         define_attributes(object)
       else
         object.extend(ModuleExtensions)

data/lib/virtus/support/equalizer.rb

@@ -65,7 +65,7 @@ module Virtus
     def define_hash_method
       keys = @keys
       define_method(:hash) do
-        keys.map { |key| send(key).hash }.reduce(self.class.hash, :^)
+        keys.map { |key| send(key) }.push(self.class).hash
       end
     end
 

data/lib/virtus/support/options.rb

@@ -37,7 +37,7 @@ module Virtus
     # Defines which options are valid for a given attribute class
     #
     # @example
-    #   class MyAttribute < Virtus::Attribute::Object
+    #   class MyAttribute < Virtus::Attribute
     #     accept_options :foo, :bar
     #   end
     #
@@ -61,6 +61,7 @@ module Virtus
     def define_option_method(option)
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def self.#{option}(value = Undefined)           # def self.primitive(value = Undefined)
+          @#{option} = nil unless defined?(@#{option})  #   @primitive = nil unless defined?(@primitive)
           return @#{option} if value.equal?(Undefined)  #   return @primitive if value.equal?(Undefined)
           @#{option} = value                            #   @primitive = value
           self                                          #   self

data/lib/virtus/support/type_lookup.rb

@@ -48,7 +48,7 @@ module Virtus
 
     # @api private
     def determine_type_and_cache(class_or_name)
-      type = case class_or_name
+      case class_or_name
       when singleton_class
         determine_type_from_descendant(class_or_name)
       when Class

data/lib/virtus/version.rb

@@ -1,3 +1,3 @@
 module Virtus
-  VERSION = '1.0.1'
+  VERSION = '2.0.0'.freeze
 end

data/spec/integration/attributes_attribute_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe "Adding attribute called 'attributes'" do
+
+  context "when mass assignment is disabled" do
+    before do
+      module Examples
+        class User
+          include Virtus.model(mass_assignment: false)
+
+          attribute :attributes
+        end
+      end
+    end
+
+    it "allows model to use `attributes` attribute" do
+      user = Examples::User.new
+      expect(user.attributes).to eq(nil)
+      user.attributes = "attributes string"
+      expect(user.attributes).to eq("attributes string")
+    end
+
+    it "doesn't accept `attributes` key in initializer" do
+      user = Examples::User.new(attributes: 'attributes string')
+      expect(user.attributes).to eq(nil)
+    end
+  end
+end

data/spec/integration/building_module_spec.rb

@@ -19,6 +19,10 @@ describe 'I can create a Virtus module' do
         config.strict = true
       }
 
+      BlankModule = Virtus.model { |config|
+        config.nullify_blank = true
+      }
+
       class NoncoercedUser
         include NoncoercingModule
 
@@ -39,6 +43,13 @@ describe 'I can create a Virtus module' do
         attribute :stuff, Hash
         attribute :happy, Boolean, :strict => false
       end
+
+      class BlankModel
+        include BlankModule
+
+        attribute :stuff, Hash
+        attribute :happy, Boolean, :nullify_blank => false
+      end
     end
   end
 
@@ -65,4 +76,15 @@ describe 'I can create a Virtus module' do
 
     expect(model.happy).to eql('foo')
   end
+
+  specify 'including a custom module with nullify blank enabled' do
+    model = Examples::BlankModel.new
+
+    model.stuff = ''
+    expect(model.stuff).to be_nil
+
+    model.happy = 'foo'
+
+    expect(model.happy).to eql('foo')
+  end
 end

data/spec/integration/collection_member_coercion_spec.rb

@@ -25,10 +25,10 @@ class User
 end
 
 describe User do
-  it { should respond_to(:phone_numbers)  }
-  it { should respond_to(:phone_numbers=) }
-  it { should respond_to(:addresses)  }
-  it { should respond_to(:addresses=) }
+  it { is_expected.to respond_to(:phone_numbers)  }
+  it { is_expected.to respond_to(:phone_numbers=) }
+  it { is_expected.to respond_to(:addresses)  }
+  it { is_expected.to respond_to(:addresses=) }
 
   let(:instance) do
     described_class.new(:phone_numbers => phone_numbers_attributes,
@@ -48,28 +48,49 @@ describe User do
     describe 'first entry' do
       subject { instance.phone_numbers.first }
 
-      it { should be_instance_of(PhoneNumber) }
+      it { is_expected.to be_instance_of(PhoneNumber) }
 
-      its(:number)  { should eql('212-555-1212') }
+      describe '#number' do
+        subject { super().number }
+        it { is_expected.to eql('212-555-1212') }
+      end
     end
 
     describe 'last entry' do
       subject { instance.phone_numbers.last }
 
-      it { should be_instance_of(PhoneNumber) }
+      it { is_expected.to be_instance_of(PhoneNumber) }
 
-      its(:number)  { should eql('919-444-3265') }
+      describe '#number' do
+        subject { super().number }
+        it { is_expected.to eql('919-444-3265') }
+      end
     end
   end
 
   describe '#addresses' do
     subject { instance.addresses.first }
 
-    it { should be_instance_of(Address) }
+    it { is_expected.to be_instance_of(Address) }
 
-    its(:address)     { should eql('1234 Any St.') }
-    its(:locality)    { should eql('Anytown')      }
-    its(:region)      { should eql('DC')           }
-    its(:postal_code) { should eql('21234')        }
+    describe '#address' do
+      subject { super().address }
+      it { is_expected.to eql('1234 Any St.') }
+    end
+
+    describe '#locality' do
+      subject { super().locality }
+      it { is_expected.to eql('Anytown')      }
+    end
+
+    describe '#region' do
+      subject { super().region }
+      it { is_expected.to eql('DC')           }
+    end
+
+    describe '#postal_code' do
+      subject { super().postal_code }
+      it { is_expected.to eql('21234')        }
+    end
   end
 end

data/spec/integration/custom_attributes_spec.rb

@@ -31,12 +31,12 @@ describe 'custom attributes' do
   specify 'allows you to define custom attributes' do
     regexp = /awesome/
     subject.expression = regexp
-    subject.expression.should == regexp
+    expect(subject.expression).to eq(regexp)
   end
 
   specify 'allows you to define coercion methods' do
     subject.scream = 'welcome'
-    subject.scream.should == 'WELCOME'
+    expect(subject.scream).to eq('WELCOME')
   end
 
 end

data/spec/integration/custom_collection_attributes_spec.rb

@@ -36,7 +36,7 @@ describe 'custom collection attributes' do
   shared_examples_for 'a collection' do
     it 'can be used as Virtus attributes' do
       attribute = Examples::Library.attribute_set[:books]
-      attribute.should be_kind_of(Examples::BookCollectionAttribute)
+      expect(attribute).to be_kind_of(Examples::BookCollectionAttribute)
     end
 
     it 'defaults to an empty collection' do
@@ -55,18 +55,18 @@ describe 'custom collection attributes' do
 
     it 'coerces an array of attribute hashes' do
       library.books = [{ :title => 'Foo' }]
-      books.should be_kind_of(Examples::BookCollection)
+      expect(books).to be_kind_of(Examples::BookCollection)
     end
 
     it 'coerces its members' do
       library.books = [{ :title => 'Foo' }]
-      books.count.should == 1
-      books.first.should be_kind_of(Examples::Book)
+      expect(books.count).to eq(1)
+      expect(books.first).to be_kind_of(Examples::Book)
     end
 
     def books_should_be_an_empty_collection
-      books.should be_kind_of(Examples::BookCollection)
-      books.count.should == 0
+      expect(books).to be_kind_of(Examples::BookCollection)
+      expect(books.count).to eq(0)
     end
   end
 

data/spec/integration/default_values_spec.rb

@@ -35,21 +35,21 @@ describe "default values" do
   subject { Examples::Page.new }
 
   specify 'without a default the value is nil' do
-    subject.title.should be_nil
+    expect(subject.title).to be_nil
   end
 
   specify 'can be supplied with the :default option' do
-    subject.view_count.should == 0
+    expect(subject.view_count).to eq(0)
   end
 
   specify "you can pass a 'callable-object' to the :default option" do
     subject.title = 'Example Blog Post'
-    subject.slug.should == 'example-blog-post'
+    expect(subject.slug).to eq('example-blog-post')
   end
 
   specify 'you can set defaults for private attributes' do
     subject.title = 'Top Secret'
-    subject.editor_title.should == 'UNPUBLISHED: Top Secret'
+    expect(subject.editor_title).to eq('UNPUBLISHED: Top Secret')
   end
 
   specify 'you can reset attribute to its default' do
@@ -63,25 +63,25 @@ describe "default values" do
     it 'does not duplicate the ValueObject' do
       page1 = Examples::Page.new
       page2 = Examples::Page.new
-      page1.reference.should equal(page2.reference)
+      expect(page1.reference).to equal(page2.reference)
     end
   end
 
   context 'an Array' do
     specify 'without a default the value is an empty Array' do
-      subject.revisions.should eql([])
+      expect(subject.revisions).to eql([])
     end
   end
 
   context 'a Hash' do
     specify 'without a default the value is an empty Hash' do
-      subject.index.should eql({})
+      expect(subject.index).to eql({})
     end
   end
 
   context 'a Set' do
     specify 'without a default the value is an empty Set' do
-      subject.authors.should eql(Set.new)
+      expect(subject.authors).to eql(Set.new)
     end
   end
 end

data/spec/integration/defining_attributes_spec.rb

@@ -19,61 +19,68 @@ describe "virtus attribute definitions" do
     end
   end
 
-  subject { Examples::Person.new }
+  subject(:person) { Examples::Person.new(attributes) }
+
+  let(:attributes) { {} }
 
   specify 'virtus creates accessor methods' do
-    subject.name = 'Peter'
-    subject.name.should == 'Peter'
+    person.name = 'Peter'
+    expect(person.name).to eq('Peter')
   end
 
   specify 'the constructor accepts a hash for mass-assignment' do
     john = Examples::Person.new(:name => 'John', :age => 13)
-    john.name.should == 'John'
-    john.age.should == 13
+    expect(john.name).to eq('John')
+    expect(john.age).to eq(13)
   end
 
-  specify 'Boolean attributes have a getter with questionmark' do
-    subject.doctor?.should be_false
-    subject.doctor = true
-    subject.doctor?.should be_true
+  specify 'Boolean attributes have a predicate method' do
+    expect(person).not_to be_doctor
+    person.doctor = true
+    expect(person).to be_doctor
   end
 
   context 'with attributes' do
     let(:attributes) { {:name => 'Jane', :age => 45, :doctor => true, :salary => 4500} }
-    subject { Examples::Person.new(attributes) }
 
     specify "#attributes returns the object's attributes as a hash" do
-      subject.attributes.should == attributes
+      expect(person.attributes).to eq(attributes)
     end
 
     specify "#to_hash returns the object's attributes as a hash" do
-      subject.to_hash.should == attributes
+      expect(person.to_hash).to eq(attributes)
+    end
+
+    specify "#to_h returns the object's attributes as a hash" do
+      expect(person.to_h).to eql(attributes)
     end
   end
 
   context 'inheritance' do
     specify 'inherits all the attributes from the base class' do
       fred = Examples::Manager.new(:name => 'Fred', :age => 29)
-      fred.name.should == 'Fred'
-      fred.age.should == 29
+      expect(fred.name).to eq('Fred')
+      expect(fred.age).to eq(29)
     end
 
     specify 'lets you add attributes to the base class at runtime' do
       frank = Examples::Manager.new(:name => 'Frank')
       Examples::Person.attribute :just_added, String
       frank.just_added = 'it works!'
-      frank.just_added.should == 'it works!'
+      expect(frank.just_added).to eq('it works!')
     end
 
     specify 'lets you add attributes to the subclass at runtime' do
       person_jack = Examples::Person.new(:name => 'Jack')
       manager_frank = Examples::Manager.new(:name => 'Frank')
+
       Examples::Manager.attribute :just_added, String
 
       manager_frank.just_added = 'awesome!'
-      manager_frank.just_added.should == 'awesome!'
-      person_jack.should_not respond_to(:just_added)
-      person_jack.should_not respond_to(:just_added=)
+
+      expect(manager_frank.just_added).to eq('awesome!')
+      expect(person_jack).not_to respond_to(:just_added)
+      expect(person_jack).not_to respond_to(:just_added=)
     end
   end
 end

data/spec/integration/embedded_value_spec.rb

@@ -33,18 +33,18 @@ describe 'embedded values' do
   end
 
   specify '#attributes returns instances of the embedded values' do
-    subject.attributes.should == {
+    expect(subject.attributes).to eq({
       :name => 'the guy',
       :address => subject.address
-    }
+    })
   end
 
   specify 'allows you to pass a hash for the embedded value' do
     user = Examples::User.new
     user.address = address_attributes
-    user.address.street.should == 'Street 1/2'
-    user.address.zipcode.should == '12345'
-    user.address.city.name.should == 'NYC'
+    expect(user.address.street).to eq('Street 1/2')
+    expect(user.address.zipcode).to eq('12345')
+    expect(user.address.city.name).to eq('NYC')
   end
 
 end

data/spec/integration/extending_objects_spec.rb

@@ -21,15 +21,15 @@ describe 'I can extend objects' do
     admin.name = 'John'
     admin.age  = 29
 
-    admin.name.should eql('John')
-    admin.age.should eql(29)
+    expect(admin.name).to eql('John')
+    expect(admin.age).to eql(29)
 
-    admin.attributes.should eql(attributes)
+    expect(admin.attributes).to eql(attributes)
 
     new_attributes   = { :name => 'Jane', :age => 28 }
     admin.attributes = new_attributes
 
-    admin.name.should eql('Jane')
-    admin.age.should eql(28)
+    expect(admin.name).to eql('Jane')
+    expect(admin.age).to eql(28)
   end
 end