virtus 0.0.3 → 0.0.4

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

@@ -0,0 +1,55 @@
+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 }
+
+    before :all do
+      sub_attribute.accept_options(option)
+      sub_attribute.height(value)
+    end
+
+    context "when new attribute is created" do
+      subject { sub_attribute.new(attribute_name) }
+
+      it "sets the default value" do
+        subject.options[option].should eql(value)
+      end
+    end
+
+    context "when new attribute is created and overrides option's default value" do
+      let(:new_value) { 11 }
+
+      subject { sub_attribute.new(attribute_name, option => new_value) }
+
+      it "sets the new value" do
+        subject.options[option].should eql(new_value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+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
+end

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

@@ -0,0 +1,15 @@
+shared_examples_for 'Attribute#complex?' do
+  let(:attribute) { described_class.new(attribute_name, :complex => complex) }
+
+  subject { attribute.complex? }
+
+  context "when set to true" do
+    let(:complex) { true }
+    it { should be(true) }
+  end
+
+  context "when set to false" do
+    let(:complex) { false }
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,29 @@
+shared_examples_for 'Attribute#get' do
+  let(:model) do
+    Class.new { include Virtus }
+  end
+
+  let(:attribute) do
+    model.attribute(attribute_name, described_class).attributes[attribute_name]
+  end
+
+  let(:object) do
+    model.new
+  end
+
+  context "when a non-nil value is set" do
+    before { attribute.set(object, attribute_value) }
+
+    subject { attribute.get(object) }
+
+    it { should eql(attribute_value) }
+  end
+
+  context "when nil is set" do
+    before { attribute.set(object, nil) }
+
+    subject { attribute.get(object) }
+
+    it { should be(nil) }
+  end
+end

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

@@ -0,0 +1,7 @@
+shared_examples_for 'Attribute.options' do
+  specify { described_class.should respond_to(:options) }
+
+  it 'returns a hash with options' do
+    described_class.options.should be_instance_of(Hash)
+  end
+end

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

@@ -0,0 +1,42 @@
+shared_examples_for 'Attribute#set' do
+  let(:model) do
+    Class.new { include Virtus }
+  end
+
+  let(:attribute) do
+    model.attribute(attribute_name, described_class).attributes[attribute_name]
+  end
+
+  let(:object) do
+    model.new
+  end
+
+  context "with nil" do
+    subject { attribute.set(object, nil) }
+
+    it "doesn't set the ivar" do
+      subject
+      object.instance_variable_defined?(attribute.instance_variable_name).should be(false)
+    end
+
+    it "returns nil" do
+      subject.should be(nil)
+    end
+  end
+
+  context "with a primitive value" do
+    before { attribute.set(object, attribute_value) }
+
+    it "sets the value in an ivar" do
+      object.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) }
+
+    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)
+    end
+  end
+end

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

@@ -24,8 +24,7 @@ describe Virtus::Attribute::Boolean do
   end
 
   describe '#typecast' do
-    let(:model)     { Class.new { include Virtus } }
-    let(:attribute) { model.attribute(:is_admin, Virtus::Attribute::Boolean) }
+    let(:attribute) { Virtus::Attribute::Boolean.new(:is_admin) }
 
     subject { attribute.typecast(value) }
 

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

@@ -8,8 +8,7 @@ describe Virtus::Attribute::Date do
   end
 
   describe '#typecast' do
-    let(:model)     { Class.new { include Virtus } }
-    let(:attribute) { model.attribute(:bday, Virtus::Attribute::Date) }
+    let(:attribute) { Virtus::Attribute::Date.new(:bday) }
 
     let(:year)  { 2011 }
     let(:month) { 4 }

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

@@ -8,8 +8,7 @@ describe Virtus::Attribute::DateTime do
   end
 
   describe '#typecast' do
-    let(:model)     { Class.new { include Virtus } }
-    let(:attribute) { model.attribute(:bday, Virtus::Attribute::DateTime) }
+    let(:attribute) { Virtus::Attribute::DateTime.new(:bday) }
 
     let(:year)  { 2011 }
     let(:month) { 4 }

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

@@ -8,8 +8,7 @@ describe Virtus::Attribute::Decimal do
   end
 
   describe '#typecast' do
-    let(:model)     { Class.new { include Virtus } }
-    let(:attribute) { model.attribute(:price, Virtus::Attribute::Decimal) }
+    let(:attribute) { Virtus::Attribute::Decimal.new(:price) }
 
     subject { attribute.typecast(value) }
 

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

@@ -8,8 +8,7 @@ describe Virtus::Attribute::Float do
   end
 
   describe '#typecast' do
-    let(:model)     { Class.new { include Virtus } }
-    let(:attribute) { model.attribute(:score, Virtus::Attribute::Float) }
+    let(:attribute) { Virtus::Attribute::Float.new(:score) }
 
     subject { attribute.typecast(value) }
 

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

@@ -8,8 +8,7 @@ describe Virtus::Attribute::Integer do
   end
 
   describe '#typecast' do
-    let(:model)     { Class.new { include Virtus } }
-    let(:attribute) { model.attribute(:age, Virtus::Attribute::Integer) }
+    let(:attribute) { Virtus::Attribute::Integer.new(:age) }
 
     subject { attribute.typecast(value) }
 

data/spec/unit/virtus/attribute/numeric/class_methods/descendants_spec.rb

@@ -4,9 +4,9 @@ describe Virtus::Attribute::Numeric, '.descendants' do
   subject { described_class.descendants }
 
   let(:known_descendants) do
-    [ Virtus::Attribute::Decimal,
+    [ Virtus::Attribute::Integer,
       Virtus::Attribute::Float,
-      Virtus::Attribute::Integer ]
+      Virtus::Attribute::Decimal ]
   end
 
   it "should return all known attribute classes" do

data/spec/unit/virtus/attribute/object/class_methods/descendants_spec.rb

@@ -4,10 +4,12 @@ describe Virtus::Attribute::Object, '.descendants' do
   subject { described_class.descendants }
 
   let(:known_descendants) do
-    [ Virtus::Attribute::Array,   Virtus::Attribute::Boolean,
-      Virtus::Attribute::Date,    Virtus::Attribute::DateTime,
-      Virtus::Attribute::Numeric, Virtus::Attribute::Hash,
-      Virtus::Attribute::String,  Virtus::Attribute::Time ]
+    [ Virtus::Attribute::Time,    Virtus::Attribute::String,
+      Virtus::Attribute::Integer, Virtus::Attribute::Hash,
+      Virtus::Attribute::Float,   Virtus::Attribute::Decimal,
+      Virtus::Attribute::Numeric, Virtus::Attribute::DateTime,
+      Virtus::Attribute::Date,    Virtus::Attribute::Boolean,
+      Virtus::Attribute::Array ]
   end
 
   it "should return all known attribute classes" do

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

@@ -8,8 +8,7 @@ describe Virtus::Attribute::String do
   end
 
   describe '#typecast' do
-    let(:model)          { Class.new { include Virtus } }
-    let(:attribute)      { model.attribute(:name, String) }
+    let(:attribute)      { Virtus::Attribute::String.new(:name) }
     let(:value)          { 1 }
     let(:typecast_value) { '1' }
 

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

@@ -8,8 +8,7 @@ describe Virtus::Attribute::Time do
   end
 
   describe '#typecast' do
-    let(:model)     { Class.new { include Virtus } }
-    let(:attribute) { model.attribute(:birthday, Virtus::Attribute::Time) }
+    let(:attribute) { Virtus::Attribute::Time.new(:bday) }
 
     let(:year)  { 1983 }
     let(:month) { 11 }

data/spec/unit/virtus/attribute_set/append_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Virtus::AttributeSet, '#<<' do
+  subject { object << attribute }
+
+  let(:attributes) { []                                      }
+  let(:parent)     { described_class.new                     }
+  let(:object)     { described_class.new(parent, attributes) }
+  let(:name)       { :name                                   }
+
+  context 'with a new attribute' do
+    let(:attribute) { mock('Attribute', :name => name) }
+
+    it { should equal(object) }
+
+    it 'adds an attribute' do
+      expect { subject }.to change { object.to_a }.
+        from(attributes).
+        to([ attribute ])
+    end
+  end
+
+  context 'with a duplicate attribute' do
+    let(:attributes) { [ mock('Attribute', :name => name) ] }
+    let(:attribute)  { mock('Duplicate', :name => name)     }
+
+    it { should equal(object) }
+
+    it 'replaces the original attribute' do
+      expect { subject }.to change { object.to_a }.
+        from(attributes).
+        to([ attribute ])
+    end
+  end
+end

data/spec/unit/virtus/attribute_set/each_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Virtus::AttributeSet, '#each' do
+  let(:name)       { :name                                   }
+  let(:attribute)  { mock('Attribute', :name => name)        }
+  let(:attributes) { [ attribute ]                           }
+  let(:parent)     { described_class.new                     }
+  let(:object)     { described_class.new(parent, attributes) }
+  let(:yields)     { Set[]                                   }
+
+  context 'with no block' do
+    subject { object.each }
+
+    it { should be_instance_of(to_enum.class) }
+
+    it 'yields the expected attributes' do
+      subject.to_a.should eql(object.to_a)
+    end
+  end
+
+  context 'with a block' do
+    subject { object.each { |attribute| yields << attribute } }
+
+    context 'when the parent has no attributes' do
+      it { should equal(object) }
+
+      it 'yields the expected attributes' do
+        expect { subject }.to change { yields.dup }.
+          from(Set[]).
+          to(attributes.to_set)
+      end
+    end
+
+    context 'when the parent has attributes that are not duplicates' do
+      let(:parent_attribute) { mock('Parent Attribute', :name => :parent_name) }
+      let(:parent)           { described_class.new([ parent_attribute ])       }
+
+      it { should equal(object) }
+
+      it 'yields the expected attributes' do
+        expect { subject }.to change { yields.dup }.
+          from(Set[]).
+          to(Set[ attribute, parent_attribute ])
+      end
+    end
+
+    context 'when the parent has attributes that are duplicates' do
+      let(:parent_attribute) { mock('Parent Attribute', :name => name)   }
+      let(:parent)           { described_class.new([ parent_attribute ]) }
+
+      it { should equal(object) }
+
+      it 'yields the expected attributes' do
+        expect { subject }.to change { yields.dup }.
+          from(Set[]).
+          to(Set[ attribute ])
+      end
+    end
+  end
+end

data/spec/unit/virtus/attribute_set/element_reference_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Virtus::AttributeSet, '#[]' do
+  subject { object[name] }
+
+  let(:name)       { :name                                   }
+  let(:attribute)  { mock('Attribute', :name => name)        }
+  let(:attributes) { [ attribute ]                           }
+  let(:parent)     { described_class.new                     }
+  let(:object)     { described_class.new(parent, attributes) }
+
+  it { should equal(attribute) }
+end

data/spec/unit/virtus/attribute_set/element_set_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Virtus::AttributeSet, '#[]=' do
+  subject { object[name] = attribute }
+
+  let(:attributes) { []                                      }
+  let(:parent)     { described_class.new                     }
+  let(:object)     { described_class.new(parent, attributes) }
+  let(:name)       { :name                                   }
+
+  context 'with a new attribute' do
+    let(:attribute) { mock('Attribute', :name => name) }
+
+    it { should equal(attribute) }
+
+    it 'adds an attribute' do
+      expect { subject }.to change { object.to_a }.
+        from(attributes).
+        to([ attribute ])
+    end
+  end
+
+  context 'with a duplicate attribute' do
+    let(:attributes) { [ mock('Attribute', :name => name) ] }
+    let(:attribute)  { mock('Duplicate', :name => name)     }
+
+    it { should equal(attribute) }
+
+    it 'replaces the original attribute' do
+      expect { subject }.to change { object.to_a }.
+        from(attributes).
+        to([ attribute ])
+    end
+  end
+end

data/spec/unit/virtus/attribute_set/merge_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Virtus::AttributeSet, '#merge' do
+  subject { object.merge(other) }
+
+  let(:attributes) { []                                      }
+  let(:parent)     { described_class.new                     }
+  let(:object)     { described_class.new(parent, attributes) }
+  let(:name)       { :name                                   }
+  let(:other)      { [ attribute ]                           }
+
+  context 'with a new attribute' do
+    let(:attribute) { mock('Attribute', :name => name) }
+
+    it { should equal(object) }
+
+    it 'adds an attribute' do
+      expect { subject }.to change { object.to_a }.
+        from(attributes).
+        to([ attribute ])
+    end
+  end
+
+  context 'with a duplicate attribute' do
+    let(:attributes) { [ mock('Attribute', :name => name) ] }
+    let(:attribute)  { mock('Duplicate', :name => name)     }
+
+    it { should equal(object) }
+
+    it 'replaces the original attribute' do
+      expect { subject }.to change { object.to_a }.
+        from(attributes).
+        to([ attribute ])
+    end
+  end
+end