virtus 0.5.5 → 1.0.0.beta3

data/lib/virtus/version.rb

@@ -1,3 +1,3 @@
 module Virtus
-  VERSION = '0.5.5'
+  VERSION = '1.0.0.beta3'
 end

data/spec/integration/building_module_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe 'I can create a Virtus module' do
+  before do
+    module Examples
+      NoncoercingModule = Virtus.model { |config|
+        config.coerce = false
+      }
+
+      CoercingModule = Virtus.model { |config|
+        config.coerce = true
+
+        config.coercer do |coercer|
+          coercer.string.boolean_map = { 'yup' => true, 'nope' => false }
+        end
+      }
+
+      StrictModule = Virtus.model { |config|
+        config.strict = true
+      }
+
+      class NoncoercedUser
+        include NoncoercingModule
+
+        attribute :name, String
+        attribute :happy, String
+      end
+
+      class CoercedUser
+        include CoercingModule
+
+        attribute :name, String
+        attribute :happy, Boolean
+      end
+
+      class StrictModel
+        include StrictModule
+
+        attribute :stuff, Hash
+        attribute :happy, Boolean, :strict => false
+      end
+    end
+  end
+
+  specify 'including a custom module with coercion disabled' do
+    user = Examples::NoncoercedUser.new(:name => :Giorgio, :happy => 'yes')
+
+    expect(user.name).to be(:Giorgio)
+    expect(user.happy).to eql('yes')
+  end
+
+  specify 'including a custom module with coercion enabled' do
+    user = Examples::CoercedUser.new(:name => 'Paul', :happy => 'nope')
+
+    expect(user.name).to eql('Paul')
+    expect(user.happy).to be(false)
+  end
+
+  specify 'including a custom module with strict enabled' do
+    model = Examples::StrictModel.new
+
+    expect { model.stuff = 'foo' }.to raise_error(ArgumentError)
+
+    model.happy = 'foo'
+
+    expect(model.happy).to eql('foo')
+  end
+end

data/spec/integration/custom_attributes_spec.rb

@@ -2,24 +2,17 @@ require 'spec_helper'
 
 describe 'custom attributes' do
 
-  module Virtus
-    class Coercion
-      class String < Virtus::Coercion::Object
-        def self.to_upcase(value)
-          value.upcase
-        end
-      end
-    end
-  end
-
   before do
     module Examples
-      class UpperCase < Virtus::Attribute::Object
-        primitive String
-        coercion_method :to_upcase
+      class NoisyString < Virtus::Attribute
+        lazy true
+
+        def coerce(input)
+          input.to_s.upcase
+        end
       end
 
-      class RegularExpression < Virtus::Attribute::Object
+      class RegularExpression < Virtus::Attribute
         primitive Regexp
       end
 
@@ -27,7 +20,7 @@ describe 'custom attributes' do
         include Virtus
 
         attribute :name, String
-        attribute :scream, UpperCase
+        attribute :scream, NoisyString
         attribute :expression, RegularExpression
       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]
+      attribute.should 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' }]
+      books.should 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)
+    end
+
+    def books_should_be_an_empty_collection
+      books.should be_kind_of(Examples::BookCollection)
+      books.count.should == 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

@@ -15,10 +15,10 @@ describe "default values" do
         include Virtus
 
         attribute :title,        String
-        attribute :slug,         String,  :default => lambda { |post, attribute| post.title.downcase.gsub(' ', '-') }
+        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
+        attribute :editor_title, String,  :default => :default_editor_title, :lazy => true
         attribute :reference,    String,  :default => Reference.new
         attribute :revisions,    Array
         attribute :index,        Hash
@@ -52,6 +52,13 @@ describe "default values" do
     subject.editor_title.should == '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

data/spec/integration/defining_attributes_spec.rb

@@ -10,7 +10,7 @@ describe "virtus attribute definitions" do
         attribute :name, String
         attribute :age, Integer
         attribute :doctor, Boolean
-        attribute :salery, Decimal
+        attribute :salary, Decimal
       end
 
       class Manager < Person
@@ -39,7 +39,7 @@ describe "virtus attribute definitions" do
   end
 
   context 'with attributes' do
-    let(:attributes) { {:name => 'Jane', :age => 45, :doctor => true, :salery => 4500} }
+    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

data/spec/integration/using_modules_spec.rb

@@ -11,6 +11,7 @@ describe 'I can define attributes within a module' do
         include Common
 
         attribute :name, String
+        attribute :gamer, Boolean
       end
 
       module Age
@@ -32,10 +33,11 @@ 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::String)
+    Examples::User.attribute_set[:name].should be_instance_of(Virtus::Attribute)
+    Examples::User.attribute_set[:gamer].should be_instance_of(Virtus::Attribute::Boolean)
 
-    Examples::Admin.attribute_set[:name].should be_instance_of(Virtus::Attribute::String)
-    Examples::Admin.attribute_set[:age].should be_instance_of(Virtus::Attribute::Integer)
+    Examples::Admin.attribute_set[:name].should be_instance_of(Virtus::Attribute)
+    Examples::Admin.attribute_set[:age].should be_instance_of(Virtus::Attribute)
 
     user = Examples::Admin.new(:name => 'Piotr', :age => 29)
     user.name.should eql('Piotr')

data/spec/shared/freeze_method_behavior.rb

@@ -1,7 +1,7 @@
 shared_examples_for 'a #freeze method' do
   let(:sample_exception) do
     begin
-      object.dup.freeze.instance_variable_set(:@foo,:bar)
+      object.dup.freeze.instance_variable_set(:@foo, :bar)
     rescue => exception
       exception
     end
@@ -26,7 +26,7 @@ shared_examples_for 'a #freeze method' do
   it 'prevents future modifications' do
     subject
     expectation = raise_error(expected_exception_class,expected_exception_message)
-    expect { object.instance_variable_set(:@foo,:bar) }.to(expectation)
+    expect { object.instance_variable_set(:@foo, :bar) }.to(expectation)
   end
 
   its(:frozen?) { should be(true) }

data/spec/shared/options_class_method.rb

@@ -8,7 +8,7 @@ shared_examples_for 'an options class method' do
   context 'with a default value' do
     subject { object.send(method, value) }
 
-    let(:value) { stub('value') }
+    let(:value) { double('value') }
 
     it { should equal(object) }
 

data/spec/spec_helper.rb

@@ -1,13 +1,33 @@
+if ENV['COVERAGE'] == 'true'
+  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 99
+  end
+end
+
 require 'rspec'
+require 'bogus/rspec'
 require 'virtus'
 
-ENV['TZ'] = 'UTC'
-
-if ENV['COVERAGE']
-  require 'simplecov'
-  SimpleCov.start
+module Virtus
+  def self.warn(*)
+    # shut up in tests
+  end
 end
 
+ENV['TZ'] = 'UTC'
+
 # require spec support files and shared behavior
 Dir[File.expand_path('../shared/**/*.rb', __FILE__)].each { |file| require file }
 

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

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Boolean, '#value_coerced?' do
+  subject { object.value_coerced?(input) }
+
+  let(:object) { described_class.build('Boolean') }
+
+  context 'when input is true' do
+    let(:input) { true }
+
+    it { should be(true) }
+  end
+
+  context 'when input is false' do
+    let(:input) { false }
+
+    it { should be(true) }
+  end
+
+  context 'when input is not coerced' do
+    let(:input) { 1 }
+
+    it { should be(false) }
+  end
+end

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

@@ -1,47 +1,140 @@
 require 'spec_helper'
 
 describe Virtus::Attribute, '.build' do
-  let(:object) { described_class }
-  let(:name)   { :name           }
-  let(:type)   { String          }
+  subject { described_class.build(type, options.merge(:name => name)) }
+
+  let(:name)    { :test }
+  let(:type)    { String }
+  let(:options) { {} }
+
+  share_examples_for 'a valid attribute instance' do
+    it { should be_instance_of(Virtus::Attribute) }
+
+    it { should be_frozen }
+  end
 
   context 'without options' do
-    subject { object.build(name, type) }
+    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 'sets up a coercer' do
+      expect(subject.options[:coerce]).to be(true)
+      expect(subject.coercer).to be_instance_of(Virtus::Attribute::Coercer)
+    end
+  end
+
+  context 'when name is passed as a string' do
+    let(:name) { 'something' }
+
+    its(:name) { should be(:something) }
+  end
+
+  context 'when coercion is turned off in options' do
+    let(:options) { { :coerce => false } }
+
+    it_behaves_like 'a valid attribute instance'
+
+    it { should_not be_coercible }
+  end
+
+  context 'when options specify reader visibility' do
+    let(:options) { { :reader => :private } }
+
+    it_behaves_like 'a valid attribute instance'
+
+    it { should_not be_public_reader }
+    it { should be_public_writer }
+  end
+
+  context 'when options specify writer visibility' do
+    let(:options) { { :writer => :private } }
 
-    it { should be_instance_of(Virtus::Attribute::String) }
+    it_behaves_like 'a valid attribute instance'
 
-    its(:name) { should be(name) }
+    it { should be_public_reader }
+    it { should_not be_public_writer }
+  end
+
+  context 'when options specify lazy accessor' do
+    let(:options) { { :lazy => true } }
+
+    it_behaves_like 'a valid attribute instance'
 
-    its(:options) { should == Virtus::Attribute::String.options }
+    it { should be_lazy }
   end
 
-  context 'with options' do
-    subject { object.build(name, type, options) }
+  context 'when options specify strict mode' do
+    let(:options) { { :strict => true } }
 
-    let(:options) { {} }
+    it_behaves_like 'a valid attribute instance'
+
+    it { should be_strict }
+  end
 
-    it { should be_instance_of(Virtus::Attribute::String) }
+  context 'when type is a string' do
+    let(:type) { 'Integer' }
 
-    its(:name) { should be(name) }
+    it_behaves_like 'a valid attribute instance'
 
-    its(:options) { should == Virtus::Attribute::String.options }
+    its(:type) { should be(Axiom::Types::Integer) }
   end
 
-  context 'without a type' do
-    subject { object.build(name) }
+  context 'when type is a symbol of an existing class constant' do
+    let(:type) { :String }
 
-    it { should be_instance_of(Virtus::Attribute::Object) }
+    it_behaves_like 'a valid attribute instance'
 
-    its(:name) { should be(name) }
+    its(:type) { should be(Axiom::Types::String) }
+  end
+
+  context 'when type is an axiom type' do
+    let(:type) { Axiom::Types::Integer }
+
+    it_behaves_like 'a valid attribute instance'
 
-    its(:options) { should == Virtus::Attribute::Object.options }
+    its(:type) { should be(type) }
   end
 
-  context 'with an invalid type' do
-    subject { object.build(name, type) }
+  context 'when custom attribute class exists for a given primitive' do
+    let(:type)      { Class.new }
+    let(:attribute) { Class.new(Virtus::Attribute) }
+
+    before do
+      attribute.primitive(type)
+    end
+
+    it { should be_instance_of(attribute) }
+
+    its(:type) { should be(Axiom::Types::Object) }
+  end
+
+  context 'when custom attribute class exists for a given array with member coercion defined' do
+    let(:type)      { Class.new(Array)[String] }
+    let(:attribute) { Class.new(Virtus::Attribute) }
+
+    before do
+      attribute.primitive(type.class)
+    end
+
+    it { should be_instance_of(attribute) }
+
+    its(:type) { should be < Axiom::Types::Collection }
+  end
+
+  context 'when custom collection-like attribute class exists for a given enumerable primitive' do
+    let(:type)      { Class.new { include Enumerable } }
+    let(:attribute) { Class.new(Virtus::Attribute::Collection) }
+
+    before do
+      attribute.primitive(type)
+    end
 
-    let(:type) { 'test' }
+    it { should be_instance_of(attribute) }
 
-    specify { expect { subject }.to raise_error(ArgumentError, '"test" does not map to an attribute type') }
+    its(:type) { should be < Axiom::Types::Collection }
   end
 end