virtus 0.0.10 → 0.1.0

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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#name' do
+  subject { object.name }
+
+  let(:object)          { described_class.new(:name, options)                              }
+  let(:options)         { { :primitive => primitive, :coercion_method => coercion_method } }
+  let(:primitive)       { stub('primitive')                                                }
+  let(:coercion_method) { stub('coercion_method')                                          }
+
+  it { should be(:name) }
+end

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

@@ -9,7 +9,7 @@ describe Virtus::Attribute::Numeric, '.descendants' do
       Virtus::Attribute::Decimal ]
   end
 
-  it "should return all known attribute classes" do
+  it 'should return all known attribute classes' do
     subject.should eql(known_descendants)
   end
 end

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

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Numeric, '.max' do
+  let(:object)  { Class.new(described_class) }
+  let(:method)  { :max                       }
+  let(:default) { nil                        }
+
+  it_should_behave_like 'an options class method'
+end

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

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Numeric, '.min' do
+  let(:object)  { Class.new(described_class) }
+  let(:method)  { :min                       }
+  let(:default) { nil                        }
+
+  it_should_behave_like 'an options class method'
+end

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

@@ -4,15 +4,17 @@ describe Virtus::Attribute::Object, '.descendants' do
   subject { described_class.descendants }
 
   let(:known_descendants) do
-    [ 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,   Virtus::Attribute::Class ]
+    [ Virtus::Attribute::EmbeddedValue,
+      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::Set,        Virtus::Attribute::Array,
+      Virtus::Attribute::Collection, Virtus::Attribute::Class ]
   end
 
-  it "should return all known attribute classes" do
+  it 'should return all known attribute classes' do
     subject.should eql(known_descendants)
   end
 end

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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#options' do
+  subject { object.options }
+
+  let(:object)          { described_class.new(:name, options)                              }
+  let(:options)         { { :primitive => primitive, :coercion_method => coercion_method } }
+  let(:primitive)       { stub('primitive')                                                }
+  let(:coercion_method) { stub('coercion_method')                                          }
+
+  it { should be_instance_of(Hash) }
+
+  it { should eql(options.merge(:accessor => :public)) }
+end

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#public_reader?' do
+  subject { object.public_reader? }
+
+  let(:object)          { described_class.new(:name, options)                              }
+  let(:options)         { { :primitive => primitive, :coercion_method => coercion_method } }
+  let(:primitive)       { stub('primitive')                                                }
+  let(:coercion_method) { stub('coercion_method')                                          }
+
+  context 'when :reader is not not specified' do
+    it { should be(true) }
+  end
+
+  { :public => true, :protected => false, :private => false }.each do |value, expected|
+    context "when :reader is #{value.inspect}" do
+      before do
+        options.update(:reader => value)
+      end
+
+      it { should be(expected) }
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#public_writer?' do
+  subject { object.public_writer? }
+
+  let(:object)          { described_class.new(:name, options)                              }
+  let(:options)         { { :primitive => primitive, :coercion_method => coercion_method } }
+  let(:primitive)       { stub('primitive')                                                }
+  let(:coercion_method) { stub('coercion_method')                                          }
+
+  context 'when :writer is not not specified' do
+    it { should be(true) }
+  end
+
+  { :public => true, :protected => false, :private => false }.each do |value, expected|
+    context "when :writer is #{value.inspect}" do
+      before do
+        options.update(:writer => value)
+      end
+
+      it { should be(expected) }
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#reader_visibility' do
+  subject { object.reader_visibility }
+
+  let(:object)          { described_class.new(:name, options)                              }
+  let(:options)         { { :primitive => primitive, :coercion_method => coercion_method } }
+  let(:primitive)       { stub('primitive')                                                }
+  let(:coercion_method) { stub('coercion_method')                                          }
+
+  context 'when not specified' do
+    it { should be(:public) }
+  end
+
+  context 'when specified' do
+    let(:reader) { stub('reader') }
+
+    before do
+      options.update(:reader => reader)
+    end
+
+    it { should be(reader) }
+  end
+end

data/spec/unit/virtus/attribute/set/coerce_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Set, '#coerce' do
+  subject { attribute.coerce(value) }
+
+  let(:attribute) { described_class.new(:colors) }
+
+  context 'with an Array' do
+    let(:value) { [ :foo, 'bar', 'bar', :foo ] }
+
+    it { should eql(Set[:foo, 'bar']) }
+  end
+end

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

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#set' do
+  subject { object.set(instance, value) }
+
+  let(:object)          { described_class.new(:name, options)                              }
+  let(:options)         { { :primitive => primitive, :coercion_method => coercion_method } }
+  let(:primitive)       { stub('primitive')                                                }
+  let(:coercion_method) { stub('coercion_method')                                          }
+  let(:instance)        { Object.new                                                       }
+  let(:value)           { stub('value')                                                    }
+  let(:coerced)         { stub('coerced')                                                  }
+
+  before do
+    object.stub(:coerce).with(value).and_return(coerced)
+    object.stub(:set!).with(instance, coerced).and_return(object)
+  end
+
+  it { should be(object) }
+
+  it 'coerces the value' do
+    object.should_receive(:coerce).with(value)
+    subject
+  end
+
+  it 'sets the instance variable to the coerced value' do
+    object.should_receive(:set!).with(instance, coerced)
+    subject
+  end
+end
+
+describe Virtus::Attribute, '#set!' do
+  subject { object.set!(instance, value) }
+
+  let(:object)          { described_class.new(:name, options)                              }
+  let(:options)         { { :primitive => primitive, :coercion_method => coercion_method } }
+  let(:primitive)       { stub('primitive')                                                }
+  let(:coercion_method) { stub('coercion_method')                                          }
+  let(:instance)        { Object.new                                                       }
+  let(:value)           { stub('value')                                                    }
+
+  it { should be(object) }
+
+  it 'sets the instance variable to the value' do
+    instance.instance_variable_get(:@name).should be_nil
+    subject
+    instance.instance_variable_get(:@name).should be(value)
+  end
+end

data/spec/unit/virtus/attribute/string/coerce_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::String, '#coerce' do
+  subject { attribute.coerce(value) }
+
+  let(:attribute)    { described_class.new(:name) }
+  let(:value)        { 1                          }
+  let(:coerce_value) { '1'                        }
+
+  it { should eql(coerce_value) }
+end

data/spec/unit/virtus/attribute/time/coerce_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+shared_examples_for 'a correct time' do
+  it          { should be_kind_of(Time) }
+  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
+
+describe Virtus::Attribute::Time, '#coerce' do
+  subject { attribute.coerce(value) }
+
+  let(:attribute) { described_class.new(:bday) }
+  let(:year)      { 1983                       }
+  let(:month)     { 11                         }
+  let(:day)       { 18                         }
+  let(:hour)      { 8                          }
+  let(:min)       { 16                         }
+  let(:sec)       { 32                         }
+
+  context 'with a date' do
+    let(:hour)  { 0                                              }
+    let(:min)   { 0                                              }
+    let(:sec)   { 0                                              }
+    let(:value) { DateTime.new(year, month, day, hour, min, sec) }
+
+    it_should_behave_like 'a correct time'
+  end
+
+  context 'with a date time' do
+    let(:value) { DateTime.new(year, month, day, hour, min, sec) }
+
+    it_should_behave_like 'a correct time'
+  end
+
+  context 'with a hash' do
+    let(:value) { { :year => year, :month => month, :day => day, :hour => hour, :min => min, :sec => sec } }
+
+    it_should_behave_like 'a correct time'
+  end
+
+  context 'with a string' do
+    context 'without hour, min and sec' do
+      let(:hour)  { 0                            }
+      let(:min)   { 0                            }
+      let(:sec)   { 0                            }
+      let(:value) { "November #{day}th, #{year}" }
+
+      it_should_behave_like 'a correct time'
+    end
+
+    context 'with hour, min and sec' do
+      let(:value) { "November #{day}th, #{year}, #{hour}:#{min}:#{sec}" }
+
+      it_should_behave_like 'a correct time'
+    end
+  end
+
+  context 'with a non-date value' do
+    let(:value) { '2999' }
+
+    it { should equal(value) }
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#value_coerced?' do
+  subject { object.value_coerced?(value) }
+
+  let(:object) { described_class::String.new(:name) }
+
+  context 'when the value matches the primitive' do
+    let(:value) { 'string' }
+
+    it { should be(true) }
+  end
+
+  context 'when the value does not match the primitive' do
+    let(:value) { 1 }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Virtus::Attribute, '#writer_visibility' do
+  subject { object.writer_visibility }
+
+  let(:object)          { described_class.new(:name, options)                              }
+  let(:options)         { { :primitive => primitive, :coercion_method => coercion_method } }
+  let(:primitive)       { stub('primitive')                                                }
+  let(:coercion_method) { stub('coercion_method')                                          }
+
+  context 'when not specified' do
+    it { should be(:public) }
+  end
+
+  context 'when specified' do
+    let(:writer) { stub('writer') }
+
+    before do
+      options.update(:writer => writer)
+    end
+
+    it { should be(writer) }
+  end
+end

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

@@ -18,6 +18,18 @@ describe Virtus::AttributeSet, '#<<' do
         from(attributes).
         to([ attribute ])
     end
+
+    it 'indexes the new attribute under its #name property' do
+      expect { subject }.to change { object[name] }.
+        from(nil).
+        to(attribute)
+    end
+
+    it 'indexes the new attribute under the string version of its #name property' do
+      expect { subject }.to change { object[name.to_s] }.
+        from(nil).
+        to(attribute)
+    end
   end
 
   context 'with a duplicate attribute' do

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

@@ -10,4 +10,8 @@ describe Virtus::AttributeSet, '#[]' do
   let(:object)     { described_class.new(parent, attributes) }
 
   it { should equal(attribute) }
+
+  it 'allows indexed access to attributes by the string representation of their name' do
+    object[name.to_s].should equal(attribute)
+  end
 end

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

@@ -9,27 +9,47 @@ describe Virtus::AttributeSet, '#[]=' do
   let(:name)       { :name                                   }
 
   context 'with a new attribute' do
-    let(:attribute) { mock('Attribute', :name => name) }
+    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 ])
+      expect { subject }.to change { object.to_a }.from(attributes).to([ attribute ])
+    end
+
+    it 'allows #[] to access the attribute with a symbol' do
+      expect { subject }.to change { object['name'] }.from(nil).to(attribute)
+    end
+
+    it 'allows #[] to access the attribute with a string' do
+      expect { subject }.to change { object[:name] }.from(nil).to(attribute)
+    end
+
+    it 'allows #reset to track overridden attributes' do
+      expect { subject }.to change { object.reset.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)     }
+    let(:attributes) { [ mock('original', :name => name) ] }
+    let(:attribute)  { mock('attribute', :name => name)    }
 
     it { should equal(attribute) }
 
     it 'replaces the original attribute' do
-      expect { subject }.to change { object.to_a }.
-        from(attributes).
-        to([ attribute ])
+      expect { subject }.to change { object.to_a }.from(attributes).to([ attribute ])
+    end
+
+    it 'allows #[] to access the attribute with a symbol' do
+      expect { subject }.to change { object['name'] }.from(nil).to(attribute)
+    end
+
+    it 'allows #[] to access the attribute with a string' do
+      expect { subject }.to change { object[:name] }.from(nil).to(attribute)
+    end
+
+    it 'allows #reset to track overridden attributes' do
+      expect { subject }.to change { object.reset.to_a }.from(attributes).to([ attribute ])
     end
   end
 end

data/spec/unit/virtus/attributes_accessor/inspect_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Virtus::AttributesAccessor, '#inspect' do
+  subject { object.inspect }
+
+  let(:object) { described_class.new('Test') }
+
+  it { should eql('Test::AttributesAccessor') }
+end