virtus 0.0.5 → 0.0.6

data/spec/unit/shared/attribute/accept_options.rb

@@ -2,29 +2,11 @@ shared_examples_for 'Attribute.accept_options' do
   let(:sub_attribute) { Class.new(described_class) }
   let(:new_option)    { :width }
 
-  specify { described_class.should respond_to(:accept_options) }
-
   before :all do
     described_class.accepted_options.should_not include(new_option)
     described_class.accept_options(new_option)
   end
 
-  it "sets new accepted options on itself" do
-    described_class.accepted_options.should include(new_option)
-  end
-
-  it "sets new accepted option on its descendants" do
-    sub_attribute.accepted_options.should include(new_option)
-  end
-
-  it "creates option accessors" do
-    described_class.should respond_to(new_option)
-  end
-
-  it "creates option accessors on descendants" do
-    sub_attribute.should respond_to(new_option)
-  end
-
   context 'with default option value' do
     let(:option) { :height }
     let(:value)  { 10 }

data/spec/unit/shared/attribute/accepted_options.rb

@@ -1,10 +1,4 @@
 shared_examples_for 'Attribute.accepted_options' do
-  specify { described_class.should respond_to(:accepted_options) }
-
-  it "returns an array of accepted options" do
-    described_class.accepted_options.should be_instance_of(Array)
-  end
-
   it "includes base options" do
     described_class.accepted_options.should include(*Virtus::Attribute::OPTIONS)
   end

data/spec/unit/shared/attribute/get.rb

@@ -1,29 +1,44 @@
 shared_examples_for 'Attribute#get' do
-  let(:model) do
-    Class.new { include Virtus }
-  end
+  subject { attribute.get(instance) }
 
-  let(:attribute) do
-    model.attribute(attribute_name, described_class).attributes[attribute_name]
-  end
+  let(:model)     { Class.new }
+  let(:instance)  { model.new }
 
-  let(:object) do
-    model.new
-  end
+  context 'without default value' do
+    let(:attribute) { described_class.new(attribute_name) }
 
-  context "when a non-nil value is set" do
-    before { attribute.set(object, attribute_value) }
+    before { attribute.set(instance, value) }
 
-    subject { attribute.get(object) }
+    context "when a non-nil value is set" do
+      let(:value) { attribute_value }
+      it { should eql(attribute_value) }
+    end
 
-    it { should eql(attribute_value) }
+    context "when nil is set" do
+      let(:value) { nil }
+      it { should be(value) }
+    end
   end
 
-  context "when nil is set" do
-    before { attribute.set(object, nil) }
+  context 'with default value' do
+    context 'set to proc' do
+      let(:attribute) do
+        described_class.new(attribute_name, :default => attribute_default_proc)
+      end
+
+      let(:evaluated_proc_value) do
+        attribute.default.call(instance, attribute)
+      end
+
+      it { should == evaluated_proc_value }
+    end
 
-    subject { attribute.get(object) }
+    context 'not set to proc' do
+      let(:attribute) do
+        described_class.new(attribute_name, :default => attribute_default)
+      end
 
-    it { should be(nil) }
+      it { should == attribute_default }
+    end
   end
 end

data/spec/unit/shared/attribute/inspect.rb

@@ -0,0 +1,7 @@
+shared_examples_for 'Attribute#inspect' do
+  subject { attribute.inspect }
+
+  let(:attribute) { described_class.new(attribute_name) }
+
+  it { should == "#<#{described_class.inspect} @name=#{attribute_name.inspect}>" }
+end

data/spec/unit/shared/attribute/primitive.rb

@@ -0,0 +1,15 @@
+shared_examples_for 'Attribute.primitive?' do
+  subject { described_class.primitive?(value) }
+
+  let(:attribute) { described_class.new(attribute_name) }
+
+  context 'with a primitive value' do
+    let(:value) { attribute_value }
+    it { should be(true) }
+  end
+
+  context 'with a non-primitive value' do
+    let(:value) { nil }
+    it { should be(false) }
+  end
+end

data/spec/unit/shared/attribute/set.rb

@@ -1,42 +1,37 @@
 shared_examples_for 'Attribute#set' do
-  let(:model) do
-    Class.new { include Virtus }
-  end
+  subject { attribute.set(instance, value) }
 
-  let(:attribute) do
-    model.attribute(attribute_name, described_class).attributes[attribute_name]
-  end
+  let(:attribute) { described_class.new(attribute_name) }
+  let(:model)     { Class.new }
+  let(:instance)  { model.new }
 
-  let(:object) do
-    model.new
-  end
+  before { subject }
 
   context "with nil" do
-    subject { attribute.set(object, nil) }
+    let(:value) { nil }
 
-    it "doesn't set the ivar" do
-      subject
-      object.instance_variable_defined?(attribute.instance_variable_name).should be(false)
-    end
+    it { should be(nil) }
 
-    it "returns nil" do
-      subject.should be(nil)
+    it "sets the value in an ivar" do
+      instance.instance_variable_get(attribute.instance_variable_name).should be(nil)
     end
   end
 
   context "with a primitive value" do
-    before { attribute.set(object, attribute_value) }
+    let(:value) { attribute_value }
+
+    it { should == attribute_value }
 
     it "sets the value in an ivar" do
-      object.instance_variable_get(attribute.instance_variable_name).should eql(attribute_value)
+      instance.instance_variable_get(attribute.instance_variable_name).should eql(attribute_value)
     end
   end
 
   context "with a non-primitive value" do
-    before { attribute.set(object, attribute_value_other) }
+    let(:value) { attribute_value_other }
 
-    it "sets the value in an ivar converted to the primitive type" do
-      object.instance_variable_get(attribute.instance_variable_name).should be_kind_of(described_class.primitive)
+    it "sets the value in an ivar coerced to the primitive type" do
+      instance.instance_variable_get(attribute.instance_variable_name).should be_kind_of(described_class.primitive)
     end
   end
 end

data/spec/unit/virtus/attribute/array_spec.rb

@@ -2,8 +2,23 @@ require 'spec_helper'
 
 describe Virtus::Attribute::Array do
   it_should_behave_like 'Attribute' do
-    let(:attribute_name)        { :colors }
-    let(:attribute_value)       { [ 'red', 'green', 'blue' ] }
-    let(:attribute_value_other) { [ 'orange', 'yellow', 'gray' ] }
+    let(:attribute_name)         { :colors }
+    let(:attribute_value)        { [ 'red', 'green', 'blue' ] }
+    let(:attribute_value_other)  { [ 'orange', 'yellow', 'gray' ] }
+    let(:attribute_default)      { [] }
+    let(:attribute_default_proc) { lambda { |instance, attribute| attribute.name == :colors } }
   end
+
+  describe '#coerce' do
+    let(:attribute) { described_class.new(:colors) }
+
+    subject { attribute.coerce(value) }
+
+    context 'with a Hash' do
+      let(:value) { { :foo => 'bar' } }
+
+      it { should == [ [:foo, 'bar'] ] }
+    end
+  end
+
 end

data/spec/unit/virtus/attribute/boolean_spec.rb

@@ -2,9 +2,11 @@ require 'spec_helper'
 
 describe Virtus::Attribute::Boolean do
   it_should_behave_like 'Attribute' do
-    let(:attribute_name)        { :is_admin }
-    let(:attribute_value)       { true }
-    let(:attribute_value_other) { '1' }
+    let(:attribute_name)         { :is_admin }
+    let(:attribute_value)        { true }
+    let(:attribute_value_other)  { '1' }
+    let(:attribute_default)      { true }
+    let(:attribute_default_proc) { lambda { |instance, attribute| attribute.name == :is_admin } }
   end
 
   describe "accessor names" do
@@ -23,10 +25,10 @@ describe Virtus::Attribute::Boolean do
     end
   end
 
-  describe '#typecast' do
-    let(:attribute) { Virtus::Attribute::Boolean.new(:is_admin) }
+  describe '#coerce' do
+    let(:attribute) { described_class.new(:is_admin) }
 
-    subject { attribute.typecast(value) }
+    subject { attribute.coerce(value) }
 
     context "with 1" do
       let(:value) { 1 }

data/spec/unit/virtus/attribute/date_spec.rb

@@ -2,19 +2,21 @@ require 'spec_helper'
 
 describe Virtus::Attribute::Date do
   it_should_behave_like 'Attribute' do
-    let(:attribute_name)        { :created_on }
-    let(:attribute_value)       { Date.today }
-    let(:attribute_value_other) { (Date.today+1).to_s }
+    let(:attribute_name)         { :created_on }
+    let(:attribute_value)        { Date.today }
+    let(:attribute_value_other)  { (Date.today+1).to_s }
+    let(:attribute_default)      { Date.today-1 }
+    let(:attribute_default_proc) { lambda { |instance, attribute| attribute.name == :created_on } }
   end
 
-  describe '#typecast' do
-    let(:attribute) { Virtus::Attribute::Date.new(:bday) }
+  describe '#coerce' do
+    let(:attribute) { described_class.new(:bday) }
 
     let(:year)  { 2011 }
     let(:month) { 4 }
     let(:day)   { 7 }
 
-    subject { attribute.typecast(value) }
+    subject { attribute.coerce(value) }
 
     shared_examples_for "a correct date" do
       it          { should be_kind_of(Date) }

data/spec/unit/virtus/attribute/date_time_spec.rb

@@ -2,13 +2,15 @@ require 'spec_helper'
 
 describe Virtus::Attribute::DateTime do
   it_should_behave_like 'Attribute' do
-    let(:attribute_name)        { :created_at }
-    let(:attribute_value)       { DateTime.now }
-    let(:attribute_value_other) { DateTime.now.to_s }
+    let(:attribute_name)         { :created_at }
+    let(:attribute_value)        { DateTime.now }
+    let(:attribute_value_other)  { DateTime.now.to_s }
+    let(:attribute_default)      { DateTime.now-1 }
+    let(:attribute_default_proc) { lambda { |instance, attribute| attribute.name == :created_at } }
   end
 
-  describe '#typecast' do
-    let(:attribute) { Virtus::Attribute::DateTime.new(:bday) }
+  describe '#coerce' do
+    let(:attribute) { described_class.new(:bday) }
 
     let(:year)  { 2011 }
     let(:month) { 4 }
@@ -17,7 +19,7 @@ describe Virtus::Attribute::DateTime do
     let(:min)   { 26 }
     let(:sec)   { 49 }
 
-    subject { attribute.typecast(value) }
+    subject { attribute.coerce(value) }
 
     shared_examples_for "a correct date time" do
       it { should be_kind_of(DateTime) }

data/spec/unit/virtus/attribute/decimal_spec.rb

@@ -2,15 +2,17 @@ require 'spec_helper'
 
 describe Virtus::Attribute::Decimal do
   it_should_behave_like 'Attribute' do
-    let(:attribute_name)        { :price }
-    let(:attribute_value)       { BigDecimal("12.3456789") }
-    let(:attribute_value_other) { "12.3456789" }
+    let(:attribute_name)         { :price }
+    let(:attribute_value)        { BigDecimal("12.3456789") }
+    let(:attribute_value_other)  { "12.3456789" }
+    let(:attribute_default)      { BigDecimal('0') }
+    let(:attribute_default_proc) { lambda { |instance, attribute| attribute.name == :price } }
   end
 
-  describe '#typecast' do
-    let(:attribute) { Virtus::Attribute::Decimal.new(:price) }
+  describe '#coerce' do
+    let(:attribute) { described_class.new(:price) }
 
-    subject { attribute.typecast(value) }
+    subject { attribute.coerce(value) }
 
     context "with 24.0 big decimal" do
       let(:value) { BigDecimal('24.0') }
@@ -72,6 +74,16 @@ describe Virtus::Attribute::Decimal do
       it { should eql(BigDecimal('-24.0')) }
     end
 
+    context 'with a positive bignum' do
+      let(:value) { 1311936052 }
+      it { should eql(BigDecimal('1311936052.0')) }
+    end
+
+    context 'with a negative bignum' do
+      let(:value) { -1311936052 }
+      it { should eql(BigDecimal('-1311936052.0')) }
+    end
+
     context 'with a zero float' do
       let(:value) { 0.0 }
       it { should eql(BigDecimal('0.0')) }

data/spec/unit/virtus/attribute/float_spec.rb

@@ -2,15 +2,17 @@ require 'spec_helper'
 
 describe Virtus::Attribute::Float do
   it_should_behave_like 'Attribute' do
-    let(:attribute_name)        { :score }
-    let(:attribute_value)       { 12.34 }
-    let(:attribute_value_other) { "12.34" }
+    let(:attribute_name)         { :score }
+    let(:attribute_value)        { 12.34 }
+    let(:attribute_value_other)  { "12.34" }
+    let(:attribute_default)      { 0.0 }
+    let(:attribute_default_proc) { lambda { |instance, attribute| attribute.name == :score } }
   end
 
-  describe '#typecast' do
-    let(:attribute) { Virtus::Attribute::Float.new(:score) }
+  describe '#coerce' do
+    let(:attribute) { described_class.new(:score) }
 
-    subject { attribute.typecast(value) }
+    subject { attribute.coerce(value) }
 
     context "with a float" do
       let(:value) { 24.0 }
@@ -72,6 +74,16 @@ describe Virtus::Attribute::Float do
       it { should eql(-24.0) }
     end
 
+    context 'with a positive bignum' do
+      let(:value) { 1311935550 }
+      it { should eql(1311935550.0) }
+    end
+
+    context 'with a negative bignum' do
+      let(:value) { -1311935550 }
+      it { should eql(-1311935550.0) }
+    end
+
     context 'with a zero decimal' do
       let(:value) { BigDecimal('0.0') }
       it { should eql(0.0) }
@@ -88,7 +100,7 @@ describe Virtus::Attribute::Float do
     end
 
     [ Object.new, true, '00.0', '0.', '-.0', 'string' ].each do |non_num_value|
-      context "does not typecast non-numeric value #{non_num_value.inspect}" do
+      context "does not coerce non-numeric value #{non_num_value.inspect}" do
         let(:value) { non_num_value }
         it { should equal(non_num_value) }
       end

data/spec/unit/virtus/attribute/hash_spec.rb

@@ -2,8 +2,10 @@ require 'spec_helper'
 
 describe Virtus::Attribute::Hash do
   it_should_behave_like 'Attribute' do
-    let(:attribute_name)        { :settings }
-    let(:attribute_value)       { Hash[:one => 1] }
-    let(:attribute_value_other) { Hash[:two => 2] }
+    let(:attribute_name)         { :settings }
+    let(:attribute_value)        { Hash[:one => 1] }
+    let(:attribute_value_other)  { Hash[:two => 2] }
+    let(:attribute_default)      { Hash.new }
+    let(:attribute_default_proc) { lambda { |instance, attribute| attribute.name == :settings } }
   end
 end

data/spec/unit/virtus/attribute/integer_spec.rb

@@ -2,15 +2,17 @@ require 'spec_helper'
 
 describe Virtus::Attribute::Integer do
   it_should_behave_like 'Attribute' do
-    let(:attribute_name)        { :age }
-    let(:attribute_value)       { 28 }
-    let(:attribute_value_other) { "28" }
+    let(:attribute_name)         { :age }
+    let(:attribute_value)        { 28 }
+    let(:attribute_value_other)  { "28" }
+    let(:attribute_default)      { 0 }
+    let(:attribute_default_proc) { lambda { |instance, attribute| attribute.name == :age } }
   end
 
-  describe '#typecast' do
-    let(:attribute) { Virtus::Attribute::Integer.new(:age) }
+  describe '#coerce' do
+    let(:attribute) { described_class.new(:age) }
 
-    subject { attribute.typecast(value) }
+    subject { attribute.coerce(value) }
 
     context "with an integer" do
       let(:value) { 24 }
@@ -87,8 +89,8 @@ describe Virtus::Attribute::Integer do
       it { should eql(-24) }
     end
 
-    [ Object.new, true, '00.0', '0.', '-.0', 'string' ].each do |non_num_value|
-      context "does not typecast non-numeric value #{non_num_value.inspect}" do
+    [ Object.new, true, false, '00.0', '0.', '-.0', 'string' ].each do |non_num_value|
+      context "does not coerce non-numeric value #{non_num_value.inspect}" do
         let(:value) { non_num_value }
         it { should equal(non_num_value) }
       end