virtus 0.0.2 → 0.0.3

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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Virtus::Attribute do
+  describe '#typecast_to_primitive' do
+    let(:attribute) { Virtus::Attribute.new(:name) }
+    let(:value)     { 'value' }
+
+    it "returns original value" do
+      attribute.typecast_to_primitive(value).should eql(value)
+    end
+  end
+end

data/spec/unit/virtus/{attributes → attribute}/boolean_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Virtus::Attributes::Boolean do
+describe Virtus::Attribute::Boolean do
   it_should_behave_like 'Attribute' do
     let(:attribute_name)        { :is_admin }
     let(:attribute_value)       { true }
@@ -12,7 +12,7 @@ describe Virtus::Attributes::Boolean do
       Class.new do
         include Virtus
 
-        attribute :is_admin, Virtus::Attributes::Boolean
+        attribute :is_admin, Virtus::Attribute::Boolean
       end
     end
 
@@ -25,7 +25,7 @@ describe Virtus::Attributes::Boolean do
 
   describe '#typecast' do
     let(:model)     { Class.new { include Virtus } }
-    let(:attribute) { model.attribute(:is_admin, Virtus::Attributes::Boolean) }
+    let(:attribute) { model.attribute(:is_admin, Virtus::Attribute::Boolean) }
 
     subject { attribute.typecast(value) }
 
@@ -91,7 +91,7 @@ describe Virtus::Attributes::Boolean do
 
     context "with 'Foo'" do
       let(:value) { 'Foo' }
-      it { should == value }
+      it { should equal(value) }
     end
   end
 end

data/spec/unit/virtus/{attributes → attribute}/date_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Virtus::Attributes::Date do
+describe Virtus::Attribute::Date do
   it_should_behave_like 'Attribute' do
     let(:attribute_name)        { :created_on }
     let(:attribute_value)       { Date.today }
@@ -9,7 +9,7 @@ describe Virtus::Attributes::Date do
 
   describe '#typecast' do
     let(:model)     { Class.new { include Virtus } }
-    let(:attribute) { model.attribute(:bday, Virtus::Attributes::Date) }
+    let(:attribute) { model.attribute(:bday, Virtus::Attribute::Date) }
 
     let(:year)  { 2011 }
     let(:month) { 4 }
@@ -19,9 +19,9 @@ describe Virtus::Attributes::Date do
 
     shared_examples_for "a correct date" do
       it          { should be_kind_of(Date) }
-      its(:year)  { should == year  }
-      its(:month) { should == month }
-      its(:day)   { should == day   }
+      its(:year)  { should eql(year)  }
+      its(:month) { should eql(month) }
+      its(:day)   { should eql(day)   }
     end
 
     context 'with a time' do
@@ -30,6 +30,12 @@ describe Virtus::Attributes::Date do
       end
     end
 
+    context 'with a date time' do
+      it_should_behave_like "a correct date" do
+        let(:value) { DateTime.new(year, month, day) }
+      end
+    end
+
     context 'with a hash' do
       it_should_behave_like "a correct date" do
         let(:value) do
@@ -44,9 +50,9 @@ describe Virtus::Attributes::Date do
       end
     end
 
-    context 'with a on-date value' do
+    context 'with a non-date value' do
       let(:value) { 'non-date' }
-      it { should == value }
+      it { should equal(value) }
     end
   end
 end

data/spec/unit/virtus/{attributes → attribute}/date_time_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Virtus::Attributes::DateTime do
+describe Virtus::Attribute::DateTime do
   it_should_behave_like 'Attribute' do
     let(:attribute_name)        { :created_at }
     let(:attribute_value)       { DateTime.now }
@@ -9,7 +9,7 @@ describe Virtus::Attributes::DateTime do
 
   describe '#typecast' do
     let(:model)     { Class.new { include Virtus } }
-    let(:attribute) { model.attribute(:bday, Virtus::Attributes::DateTime) }
+    let(:attribute) { model.attribute(:bday, Virtus::Attribute::DateTime) }
 
     let(:year)  { 2011 }
     let(:month) { 4 }
@@ -21,13 +21,34 @@ describe Virtus::Attributes::DateTime do
     subject { attribute.typecast(value) }
 
     shared_examples_for "a correct date time" do
-      it          { should be_kind_of(DateTime) }
-      its(:year)  { should == year  }
-      its(:month) { should == month }
-      its(:day)   { should == day   }
-      its(:hour)  { should == hour  }
-      its(:min)   { should == min   }
-      its(:sec)   { should == sec   }
+      it { should be_kind_of(DateTime) }
+
+      its(:year)  { should eql(year)  }
+      its(:month) { should eql(month) }
+      its(:day)   { should eql(day)   }
+      its(:hour)  { should eql(hour)  }
+      its(:min)   { should eql(min)   }
+      its(:sec)   { should eql(sec)   }
+    end
+
+    context 'with a date' do
+      it_should_behave_like "a correct date time" do
+        let(:hour) { 0 }
+        let(:min)  { 0 }
+        let(:sec)  { 0 }
+
+        let(:value) do
+          Date.new(year, month, day)
+        end
+      end
+    end
+
+    context 'with a time' do
+      it_should_behave_like "a correct date time" do
+        let(:value) do
+          Time.local(year, month, day, hour, min, sec)
+        end
+      end
     end
 
     context 'with a hash' do
@@ -59,7 +80,7 @@ describe Virtus::Attributes::DateTime do
 
     context 'with a on-date value' do
       let(:value) { 'non-date' }
-      it { should == value }
+      it { should equal(value) }
     end
   end
 end

data/spec/unit/virtus/{attributes → attribute}/decimal_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Virtus::Attributes::Decimal do
+describe Virtus::Attribute::Decimal do
   it_should_behave_like 'Attribute' do
     let(:attribute_name)        { :price }
     let(:attribute_value)       { BigDecimal("12.3456789") }
@@ -9,89 +9,89 @@ describe Virtus::Attributes::Decimal do
 
   describe '#typecast' do
     let(:model)     { Class.new { include Virtus } }
-    let(:attribute) { model.attribute(:price, Virtus::Attributes::Decimal) }
+    let(:attribute) { model.attribute(:price, Virtus::Attribute::Decimal) }
 
     subject { attribute.typecast(value) }
 
     context "with 24.0 big decimal" do
       let(:value) { BigDecimal('24.0') }
-      it { should == value }
+      it { should eql(value) }
     end
 
     context 'with a zero string integer' do
       let(:value) { '0' }
-      it { should == BigDecimal('0.0') }
+      it { should eql(BigDecimal('0.0')) }
     end
 
     context 'with a positive string integer' do
       let(:value) { '24' }
-      it { should == BigDecimal('24.0') }
+      it { should eql(BigDecimal('24.0')) }
     end
 
     context 'with a negative string integer' do
       let(:value) { '-24' }
-      it { should == BigDecimal('-24.0') }
+      it { should eql(BigDecimal('-24.0')) }
     end
 
     context 'with a zero string float' do
       let(:value) { '0.0' }
-      it { should == BigDecimal('0.0') }
+      it { should eql(BigDecimal('0.0')) }
     end
 
     context 'with a positive string float' do
       let(:value) { '24.35' }
-      it { should == BigDecimal('24.35') }
+      it { should eql(BigDecimal('24.35')) }
     end
 
     context 'with a negative string float' do
       let(:value) { '-24.35' }
-      it { should == BigDecimal('-24.35') }
+      it { should eql(BigDecimal('-24.35')) }
     end
 
     context 'with a zero string float, with no leading digits' do
       let(:value) { '.0' }
-      it { should == BigDecimal('0.0') }
+      it { should eql(BigDecimal('0.0')) }
     end
 
     context 'with a positive string float, with no leading digits' do
       let(:value) { '0.41' }
-      it { should == BigDecimal('0.41') }
+      it { should eql(BigDecimal('0.41')) }
     end
 
     context 'with a zero integer' do
       let(:value) { 0 }
-      it { should == BigDecimal('0.0') }
+      it { should eql(BigDecimal('0.0')) }
     end
 
     context 'with a positive integer' do
       let(:value) { 24 }
-      it { should == BigDecimal('24.0') }
+      it { should eql(BigDecimal('24.0')) }
     end
 
     context 'with a negative integer' do
       let(:value) { -24 }
-      it { should == BigDecimal('-24.0') }
+      it { should eql(BigDecimal('-24.0')) }
     end
 
     context 'with a zero float' do
       let(:value) { 0.0 }
-      it { should == BigDecimal('0.0') }
+      it { should eql(BigDecimal('0.0')) }
     end
 
     context 'with a positive float' do
       let(:value) { 24.35 }
-      it { should == BigDecimal('24.35') }
+      it { should eql(BigDecimal('24.35')) }
     end
 
     context 'with a negative float' do
       let(:value) { -24.35 }
-      it { should == BigDecimal('-24.35') }
+      it { should eql(BigDecimal('-24.35')) }
     end
 
     [ Object.new, true, '00.0', '0.', '-.0', 'string' ].each do |non_num_value|
       context "with a non-numeric value = #{non_num_value.inspect}" do
         let(:value) { non_num_value }
-        it { should == non_num_value }
+        it { should equal(non_num_value) }
       end
     end
   end

data/spec/unit/virtus/{attributes → attribute}/float_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Virtus::Attributes::Float do
+describe Virtus::Attribute::Float do
   it_should_behave_like 'Attribute' do
     let(:attribute_name)        { :score }
     let(:attribute_value)       { 12.34 }
@@ -9,89 +9,89 @@ describe Virtus::Attributes::Float do
 
   describe '#typecast' do
     let(:model)     { Class.new { include Virtus } }
-    let(:attribute) { model.attribute(:score, Virtus::Attributes::Float) }
+    let(:attribute) { model.attribute(:score, Virtus::Attribute::Float) }
 
     subject { attribute.typecast(value) }
 
     context "with a float" do
       let(:value) { 24.0 }
-      it { should == value }
+      it { should eql(value) }
     end
 
     context 'with a zero string integer' do
       let(:value) { '0' }
-      it { should == 0.0 }
+      it { should eql(0.0) }
     end
 
     context 'with a positive string integer' do
       let(:value) { '24' }
-      it { should == 24.0 }
+      it { should eql(24.0) }
     end
 
     context 'with a negative string integer' do
       let(:value) { '-24' }
-      it { should == -24.0 }
+      it { should eql(-24.0) }
     end
 
     context 'with a zero string float' do
       let(:value) { '0.0' }
-      it { should == 0.0 }
+      it { should eql(0.0) }
     end
 
     context 'with a positive string float' do
       let(:value) { '24.35' }
-      it { should == 24.35 }
+      it { should eql(24.35) }
     end
 
     context 'with a negative string float' do
       let(:value) { '-24.35' }
-      it { should == -24.35 }
+      it { should eql(-24.35) }
     end
 
     context 'with a zero string float, with no leading digits' do
       let(:value) { '.0' }
-      it { should == 0.0 }
+      it { should eql(0.0) }
     end
 
     context 'with a positive string float, with no leading digits' do
       let(:value) { '.41' }
-      it { should == 0.41 }
+      it { should eql(0.41) }
     end
 
     context 'with a zero integer' do
       let(:value) { 0 }
-      it { should == 0.0 }
+      it { should eql(0.0) }
     end
 
     context 'with a positive integer' do
       let(:value) { 24 }
-      it { should == 24.0 }
+      it { should eql(24.0) }
     end
 
     context 'with a negative integer' do
       let(:value) { -24 }
-      it { should == -24.0 }
+      it { should eql(-24.0) }
     end
 
     context 'with a zero decimal' do
       let(:value) { BigDecimal('0.0') }
-      it { should == 0.0 }
+      it { should eql(0.0) }
     end
 
     context 'with a positive decimal' do
       let(:value) { BigDecimal('24.35') }
-      it { should == 24.35 }
+      it { should eql(24.35) }
     end
 
     context 'with a negative decimal' do
       let(:value) { BigDecimal('-24.35') }
-      it { should == -24.35 }
+      it { should eql(-24.35) }
     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
         let(:value) { non_num_value }
-        it { should == non_num_value }
+        it { should equal(non_num_value) }
       end
     end
   end

data/spec/unit/virtus/{attributes → attribute}/hash_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Virtus::Attributes::Hash do
+describe Virtus::Attribute::Hash do
   it_should_behave_like 'Attribute' do
     let(:attribute_name)        { :settings }
     let(:attribute_value)       { Hash[:one => 1] }

data/spec/unit/virtus/{attributes → attribute}/integer_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Virtus::Attributes::Integer do
+describe Virtus::Attribute::Integer do
   it_should_behave_like 'Attribute' do
     let(:attribute_name)        { :age }
     let(:attribute_value)       { 28 }
@@ -9,89 +9,89 @@ describe Virtus::Attributes::Integer do
 
   describe '#typecast' do
     let(:model)     { Class.new { include Virtus } }
-    let(:attribute) { model.attribute(:age, Virtus::Attributes::Integer) }
+    let(:attribute) { model.attribute(:age, Virtus::Attribute::Integer) }
 
     subject { attribute.typecast(value) }
 
     context "with an integer" do
       let(:value) { 24 }
-      it { should == value }
+      it { should eql(value) }
     end
 
     context 'with a zero string integer' do
       let(:value) { 24 }
-      it { should == value }
+      it { should eql(value) }
     end
 
     context 'with a positive string integer' do
       let(:value) { '24' }
-      it { should == 24 }
+      it { should eql(24) }
     end
 
     context 'with a negative string integer' do
       let(:value) { '-24' }
-      it { should == -24 }
+      it { should eql(-24) }
     end
 
     context 'with a zero string float' do
       let(:value) { 0.0 }
-      it { should == 0 }
+      it { should eql(0) }
     end
 
     context 'with a positive string float' do
       let(:value) { '24.35' }
-      it { should == 24 }
+      it { should eql(24) }
     end
 
     context 'with a negative string float' do
       let(:value) { '-24.35' }
-      it { should == -24 }
+      it { should eql(-24) }
     end
 
     context 'with a zero string float, with no leading digits' do
       let(:value) { '.0' }
-      it { should == 0 }
+      it { should eql(0) }
     end
 
     context 'with a positive string float, with no leading digits' do
       let(:value) { '.41' }
-      it { should == 0 }
+      it { should eql(0) }
     end
 
     context 'with a zero float' do
       let(:value) { 0.0 }
-      it { should == 0 }
+      it { should eql(0) }
     end
 
     context 'with a positive float' do
       let(:value) { 24.35 }
-      it { should == 24 }
+      it { should eql(24) }
     end
 
     context 'with a negative float' do
       let(:value) { -24.35 }
-      it { should == -24 }
+      it { should eql(-24) }
     end
 
     context 'with a zero decimal' do
       let(:value) { BigDecimal('0.0') }
-      it { should == 0 }
+      it { should eql(0) }
     end
 
     context 'with a positive decimal' do
       let(:value) { BigDecimal('24.35') }
-      it { should == 24 }
+      it { should eql(24) }
     end
 
     context 'with a negative decimal' do
       let(:value) { BigDecimal('-24.35') }
-      it { should == -24 }
+      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
         let(:value) { non_num_value }
-        it { should == non_num_value }
+        it { should equal(non_num_value) }
       end
     end
   end