virtus2 2.0.1

data/spec/integration/custom_attributes_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe 'custom attributes' do
+
+  before do
+    module Examples
+      class NoisyString < Virtus::Attribute
+        lazy true
+
+        def coerce(input)
+          input.to_s.upcase
+        end
+      end
+
+      class RegularExpression < Virtus::Attribute
+        primitive Regexp
+      end
+
+      class User
+        include Virtus
+
+        attribute :name, String
+        attribute :scream, NoisyString
+        attribute :expression, RegularExpression
+      end
+    end
+  end
+
+  subject { Examples::User.new }
+
+  specify 'allows you to define custom attributes' do
+    regexp = /awesome/
+    subject.expression = regexp
+    expect(subject.expression).to eq(regexp)
+  end
+
+  specify 'allows you to define coercion methods' do
+    subject.scream = 'welcome'
+    expect(subject.scream).to eq('WELCOME')
+  end
+
+end

data/spec/integration/custom_collection_attributes_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe 'custom collection attributes' do
+  let(:library) { Examples::Library.new }
+  let(:books)   { library.books }
+
+  before do
+    module Examples end
+    Examples.const_set 'BookCollection', book_collection_class
+
+    module Examples
+      class Book
+        include Virtus
+
+        attribute :title, String
+      end
+
+      class BookCollectionAttribute < Virtus::Attribute::Collection
+        primitive BookCollection
+      end
+
+      class Library
+        include Virtus
+
+        attribute :books, BookCollection[Book]
+      end
+    end
+  end
+
+  after do
+    [:BookCollectionAttribute, :BookCollection, :Book, :Library].each do |const|
+      Examples.send(:remove_const, const)
+    end
+  end
+
+  shared_examples_for 'a collection' do
+    it 'can be used as Virtus attributes' do
+      attribute = Examples::Library.attribute_set[:books]
+      expect(attribute).to be_kind_of(Examples::BookCollectionAttribute)
+    end
+
+    it 'defaults to an empty collection' do
+      books_should_be_an_empty_collection
+    end
+
+    it 'coerces nil' do
+      library.books = nil
+      books_should_be_an_empty_collection
+    end
+
+    it 'coerces an empty array' do
+      library.books = []
+      books_should_be_an_empty_collection
+    end
+
+    it 'coerces an array of attribute hashes' do
+      library.books = [{ :title => 'Foo' }]
+      expect(books).to be_kind_of(Examples::BookCollection)
+    end
+
+    it 'coerces its members' do
+      library.books = [{ :title => 'Foo' }]
+      expect(books.count).to eq(1)
+      expect(books.first).to be_kind_of(Examples::Book)
+    end
+
+    def books_should_be_an_empty_collection
+      expect(books).to be_kind_of(Examples::BookCollection)
+      expect(books.count).to eq(0)
+    end
+  end
+
+  context 'with an array subclass' do
+    let(:book_collection_class) { Class.new(Array) }
+
+    it_behaves_like 'a collection'
+  end
+
+  context 'with an enumerable' do
+    require 'forwardable'
+
+    let(:book_collection_class) {
+      Class.new do
+        extend Forwardable
+        include Enumerable
+
+        def_delegators :@array, :each, :<<
+
+        def initialize(*args)
+          @array = Array[*args]
+        end
+
+        def self.[](*args)
+          new(*args)
+        end
+      end
+    }
+
+    it_behaves_like 'a collection'
+  end
+end

data/spec/integration/default_values_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe "default values" do
+
+  before do
+    module Examples
+
+      class Reference
+        include Virtus::ValueObject
+
+        attribute :ref, String
+      end
+
+      class Page
+        include Virtus
+
+        attribute :title,        String
+        attribute :slug,         String,  :default => lambda { |post, attribute| post.title.downcase.gsub(' ', '-') }, :lazy => true
+        attribute :view_count,   Integer, :default => 0
+        attribute :published,    Boolean, :default => false, :accessor => :private
+        attribute :editor_title, String,  :default => :default_editor_title, :lazy => true
+        attribute :reference,    String,  :default => Reference.new
+        attribute :revisions,    Array
+        attribute :index,        Hash
+        attribute :authors,      Set
+
+        def default_editor_title
+          published? ? title : "UNPUBLISHED: #{title}"
+        end
+      end
+
+    end
+  end
+
+  subject { Examples::Page.new }
+
+  specify 'without a default the value is nil' do
+    expect(subject.title).to be_nil
+  end
+
+  specify 'can be supplied with the :default option' do
+    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'
+    expect(subject.slug).to eq('example-blog-post')
+  end
+
+  specify 'you can set defaults for private attributes' do
+    subject.title = 'Top Secret'
+    expect(subject.editor_title).to eq('UNPUBLISHED: Top Secret')
+  end
+
+  specify 'you can reset attribute to its default' do
+    subject.view_count = 10
+    expect do
+      subject.reset_attribute(:view_count)
+    end.to change { subject.view_count }.to(0)
+  end
+
+  context 'a ValueObject' do
+    it 'does not duplicate the ValueObject' do
+      page1 = Examples::Page.new
+      page2 = Examples::Page.new
+      expect(page1.reference).to equal(page2.reference)
+    end
+  end
+
+  context 'an Array' do
+    specify 'without a default the value is an empty Array' do
+      expect(subject.revisions).to eql([])
+    end
+  end
+
+  context 'a Hash' do
+    specify 'without a default the value is an empty Hash' do
+      expect(subject.index).to eql({})
+    end
+  end
+
+  context 'a Set' do
+    specify 'without a default the value is an empty Set' do
+      expect(subject.authors).to eql(Set.new)
+    end
+  end
+end

data/spec/integration/defining_attributes_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe "virtus attribute definitions" do
+
+  before do
+    module Examples
+      class Person
+        include Virtus
+
+        attribute :name, String
+        attribute :age, Integer
+        attribute :doctor, Boolean
+        attribute :salary, Decimal
+      end
+
+      class Manager < Person
+
+      end
+    end
+  end
+
+  subject(:person) { Examples::Person.new(attributes) }
+
+  let(:attributes) { {} }
+
+  specify 'virtus creates accessor methods' do
+    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)
+    expect(john.name).to eq('John')
+    expect(john.age).to eq(13)
+  end
+
+  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} }
+
+    specify "#attributes returns the object's attributes as a hash" do
+      expect(person.attributes).to eq(attributes)
+    end
+
+    specify "#to_hash returns the object's attributes as a hash" do
+      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)
+      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!'
+      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!'
+
+      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

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe 'embedded values' do
+  before do
+    module Examples
+      class City
+        include Virtus.model
+
+        attribute :name, String
+      end
+
+      class Address
+        include Virtus.model
+
+        attribute :street,  String
+        attribute :zipcode, String
+        attribute :city,    City
+      end
+
+      class User
+        include Virtus.model
+
+        attribute :name,    String
+        attribute :address, Address
+      end
+    end
+  end
+
+  subject { Examples::User.new(:name => 'the guy',
+                               :address => address_attributes) }
+  let(:address_attributes) do
+      { :street => 'Street 1/2', :zipcode => '12345', :city => { :name => 'NYC' } }
+  end
+
+  specify '#attributes returns instances of the embedded values' do
+    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
+    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

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe 'I can extend objects' do
+  before do
+    module Examples
+      class User; end
+
+      class Admin; end
+    end
+  end
+
+  specify 'defining attributes on an object' do
+    attributes = { :name => 'John', :age => 29 }
+
+    admin = Examples::Admin.new
+    admin.extend(Virtus)
+
+    admin.attribute :name, String
+    admin.attribute :age,  Integer
+
+    admin.name = 'John'
+    admin.age  = 29
+
+    expect(admin.name).to eql('John')
+    expect(admin.age).to eql(29)
+
+    expect(admin.attributes).to eql(attributes)
+
+    new_attributes   = { :name => 'Jane', :age => 28 }
+    admin.attributes = new_attributes
+
+    expect(admin.name).to eql('Jane')
+    expect(admin.age).to eql(28)
+  end
+end

data/spec/integration/hash_attributes_coercion_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+
+class Package
+  include Virtus
+
+  attribute :dimensions, Hash[Symbol => Float]
+  attribute :meta_info , Hash[String => String]
+end
+
+
+describe Package do
+  let(:instance) do
+    described_class.new(
+      :dimensions => { 'width' => "2.2", :height => 2, "length" => 4.5 },
+      :meta_info  => { 'from'  => :Me  , :to => 'You' }
+    )
+  end
+
+  let(:dimensions) { instance.dimensions }
+  let(:meta_info)  { instance.meta_info  }
+
+  describe '#dimensions' do
+    subject { dimensions }
+
+    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
+      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 '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
+      expect(meta_info['from']).to eq('Me')
+      expect(meta_info['to']).to eq('You')
+    end
+  end
+end