virtus 0.3.0 → 0.4.0

data/lib/virtus/value_object/equalizer.rb

@@ -24,6 +24,8 @@ module Virtus
         compile
       end
 
+    private
+
       # Compile the equalizer methods based on #keys
       #
       # @return [self]
@@ -37,8 +39,6 @@ module Virtus
         self
       end
 
-    private
-
       # Define an inspect method that reports the values of the instance's keys
       #
       # @return [undefined]
@@ -122,3 +122,4 @@ module Virtus
     end # class Equalizer
   end # module ValueObject
 end # module Virtus
+

data/lib/virtus/version.rb

@@ -1,3 +1,3 @@
 module Virtus
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/spec/shared/options_class_method.rb

@@ -13,7 +13,7 @@ shared_examples_for 'an options class method' do
     it { should equal(object) }
 
     it 'sets the default value for the class method' do
-      expect { subject }.to change { object.send(method) }.from(nil).to(value)
+      expect { subject }.to change { object.send(method) }.from(default).to(value)
     end
   end
 end

data/spec/spec_helper.rb

@@ -13,7 +13,7 @@ require 'virtus'
 ENV['TZ'] = 'UTC'
 
 # require spec support files and shared behavior
-Dir[File.expand_path('../**/shared/**/*.rb', __FILE__)].each { |file| require file }
+Dir[File.expand_path('../shared/**/*.rb', __FILE__)].each { |file| require file }
 
 RSpec.configure do |config|
 

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

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Virtus::Attribute, '.determine_type' do
   let(:object) { described_class }
 
-  described_class.descendants.each do |attribute_class|
+  (described_class.descendants - [ Virtus::Attribute::Collection ]).each do |attribute_class|
     context "with class #{attribute_class.inspect}" do
       subject { object.determine_type(attribute_class) }
 
@@ -16,12 +16,6 @@ describe Virtus::Attribute, '.determine_type' do
     context "with #{attribute_class.inspect} and primitive #{primitive.inspect}" do
       subject { object.determine_type(primitive) }
 
-      before do
-        if [Virtus::Attribute::Collection].include? attribute_class
-          pending
-        end
-      end
-
       it 'returns the corresponding attribute class' do
         should be(attribute_class)
       end

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

@@ -9,7 +9,7 @@ describe Virtus::Attribute, '#coerce' do
   let(:coercion_method) { stub('coercion_method')                                          }
   let(:value)           { mock('value', :class => value_class)                             }
   let(:value_class)     { stub('value_class')                                              }
-  let(:coercer)         { mock('coercer', :send => coerced)                                }
+  let(:coercer)         { mock('coercer', :public_send => coerced)                         }
   let(:coerced)         { stub('coerced')                                                  }
 
   before do
@@ -24,7 +24,7 @@ describe Virtus::Attribute, '#coerce' do
   end
 
   it 'asks the coercer to coerce the value' do
-    coercer.should_receive(:send).with(coercion_method, value)
+    coercer.should_receive(:public_send).with(coercion_method, value)
     subject
   end
 end

data/spec/unit/virtus/attribute/collection/coerce_and_append_member_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Collection, '#coerce_and_append_member' do
+  subject { object.coerce_and_append_member(collection, entry) }
+
+  let(:object)     { described_class.new('stuff') }
+  let(:collection) { mock('collection')           }
+  let(:entry)      { mock('entry')                }
+
+  specify do
+    expect { subject }.to raise_error(
+      NotImplementedError,
+      "Virtus::Attribute::Collection#coerce_and_append_member has not been implemented"
+    )
+  end
+end

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

@@ -1,26 +1,39 @@
 require 'spec_helper'
 
 describe Virtus::Attribute::Collection, '#coerce' do
-  subject { attribute.coerce(value) }
+  subject { object.coerce(value) }
 
-  let(:attribute)   { Class.new(described_class).new(:things, :member_type => member_type) }
-  let(:value)       { [ entry ] }
-  let(:entry)       { mock('entry') }
-  let(:member_type) { Virtus::Attribute::Object }
+  let(:described_class) { Class.new(Virtus::Attribute::Collection) }
+  let(:object)          { described_class.new(:things) }
+  let(:value)           { [ entry ] }
+  let(:entry)           { mock('entry') }
 
   before do
+    described_class.primitive ::Array
     value.should_receive(:respond_to?).with(:inject).and_return(respond_to_inject)
   end
 
   context 'when coerced value responds to #inject' do
     let(:respond_to_inject) { true }
 
-    specify { expect { subject }.to raise_error(NotImplementedError) }
+    context 'when the object has not implemented #coerce_and_append_member' do
+      specify { expect { subject }.to raise_error(NotImplementedError, "#{object.class}#coerce_and_append_member has not been implemented") }
+    end
+
+    context 'when the object has implemented #coerce_and_append_member' do
+      before do
+        def object.coerce_and_append_member(collection, entry)
+          collection << entry
+        end
+      end
+
+      it { should eql(value) }
+    end
   end
 
   context 'when coerced value does not respond to #inject' do
     let(:respond_to_inject) { false }
 
-    specify { should eql(value) }
+    it { should eql(value) }
   end
 end

data/spec/unit/virtus/attribute/collection/member_coercion/coerce_and_append_member_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Collection::MemberCoercion, '#coerce_and_append_member' do
+  subject { object.coerce_and_append_member(collection, entry) }
+
+  let(:attribute_class) do
+    Class.new(Virtus::Attribute::Collection) do
+      include Virtus::Attribute::Collection::MemberCoercion
+      self
+    end
+  end
+
+  let(:object)     { attribute_class.new('stuff', :member_type => Integer) }
+  let(:collection) { []  }
+  let(:entry)      { '1' }
+
+  it { should eql([ 1 ]) }
+end

data/spec/unit/virtus/attribute/collection/member_type_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Collection, '#member_type' do
+  subject { object.member_type }
+
+  context 'when specified' do
+    let(:object) { Virtus::Attribute::Set.new('stuff', :member_type => Integer) }
+
+    it { should be(Integer) }
+  end
+
+  context 'when not specified' do
+    let(:object) { Virtus::Attribute::Set.new('stuff') }
+
+    it { should be(Virtus::Attribute::Object) }
+  end
+end

data/spec/unit/virtus/attribute/collection/new_collection_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::Collection, '#new_collection' do
+  subject { object.new_collection }
+
+  let(:object) { Virtus::Attribute::Set.new('stuff') }
+
+  it { should be_instance_of(Set) }
+end

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

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::DefaultValue, '.build' do
+  subject { described_class.build(attribute, default)  }
+
+  let(:attribute) { mock('attribute')  }
+
+  context 'when default is a symbol' do
+    let(:default) { :symbol }
+
+    it { should be_instance_of(Virtus::Attribute::DefaultValue::FromSymbol)  }
+  end
+
+  context 'when default is a callable' do
+    let(:default) { Proc.new {} }
+
+    it { should be_instance_of(Virtus::Attribute::DefaultValue::FromCallable)  }
+  end
+
+  context 'when default is a clonable' do
+    let(:default) { "I can be cloned" }
+
+    it { should be_instance_of(Virtus::Attribute::DefaultValue::FromClonable)  }
+  end
+end

data/spec/unit/virtus/attribute/default_value/evaluate_spec.rb

@@ -9,49 +9,6 @@ describe Virtus::Attribute::DefaultValue, '#evaluate' do
   let(:instance)  { mock('instance')                        }
   let(:response)  { stub('response')                        }
 
-  context 'when the value is callable' do
-    before { value.stub(:call => response) }
-
-    specify { object.should be_instance_of(Virtus::Attribute::DefaultValue::FromCallable) }
-
-    it { should be(response) }
-
-    it 'calls the value with the instance and attribute' do
-      value.should_receive(:call).with(instance, attribute)
-      subject
-    end
-  end
-
-  context 'when the value is cloneable' do
-    let(:clone) { stub('clone') }
-
-    before { value.stub(:clone => clone) }
-
-    specify { object.should be_instance_of(Virtus::Attribute::DefaultValue::FromClonable) }
-
-    it { should be(clone) }
-
-    it 'clones the value' do
-      value.should_receive(:clone).with(no_args)
-      subject
-    end
-  end
-
-  context 'when the value is a method name' do
-    let(:instance) { mock('instance', value => retval) }
-    let(:value)    { :set_default                      }
-    let(:retval)   { stub('retval')                    }
-
-    specify { object.should be_instance_of(Virtus::Attribute::DefaultValue::FromSymbol) }
-
-    it { should be(retval) }
-
-    it 'calls the method' do
-      instance.should_receive(value).with(no_args)
-      subject
-    end
-  end
-
   # smallest number that is Bignum across major ruby impls
   bignum = 0x7fffffffffffffff + 1
 

data/spec/unit/virtus/attribute/default_value/from_callable/class_methods/handle_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::DefaultValue::FromCallable, '.handle?' do
+  subject { described_class.handle?(attribute, default) }
+
+  let(:attribute) { mock('attribute') }
+
+  context 'with a callable' do
+    let(:default) { Proc.new {}  }
+
+    it { should be(true)  }
+  end
+
+  context 'with a non-callable' do
+    let(:default) { '' }
+
+    it { should be(false)  }
+  end
+end
+

data/spec/unit/virtus/attribute/default_value/from_callable/evaluate_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::DefaultValue::FromCallable, '#evaluate' do
+  subject { object.evaluate(instance) }
+
+  let(:object)    { described_class.new(attribute, value) }
+  let(:attribute) { mock('attribute')                     }
+  let(:value)     { mock('value')                         }
+  let(:instance)  { mock('instance')                      }
+  let(:response)  { stub('response')                      }
+
+  before { value.stub(:call => response) }
+
+  it { should be(response) }
+
+  it 'calls the value with the instance and attribute' do
+    value.should_receive(:call).with(instance, attribute)
+    subject
+  end
+end
+

data/spec/unit/virtus/attribute/default_value/from_clonable/class_methods/handle_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::DefaultValue::FromClonable, '.handle?' do
+  subject { described_class.handle?(attribute, default) }
+
+  let(:attribute) { mock('attribute') }
+
+  context 'with a clonable' do
+    let(:default) { 'clonable'  }
+
+    it { should be(true)  }
+  end
+
+  context 'with a non-clonable' do
+    let(:default) { 1 }
+
+    it { should be(false)  }
+  end
+end
+

data/spec/unit/virtus/attribute/default_value/from_clonable/evaluate_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::DefaultValue::FromClonable, '#evaluate' do
+  subject { object.evaluate(instance) }
+
+  let(:object)    { described_class.new(attribute, value) }
+  let(:attribute) { mock('attribute')                       }
+  let(:value)     { mock('value')                           }
+  let(:instance)  { mock('instance')                        }
+  let(:response)  { mock('response')                        }
+  let(:clone)     { mock('clone')                           }
+
+  before { value.stub(:clone => clone) }
+
+  it { should be(clone) }
+
+  it 'clones the value' do
+    value.should_receive(:clone).with(no_args)
+    subject
+  end
+end
+

data/spec/unit/virtus/attribute/default_value/from_symbol/class_methods/handle_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::DefaultValue::FromSymbol, '.handle?' do
+  subject { described_class.handle?(attribute, default) }
+
+  let(:attribute) { mock('attribute') }
+
+  context 'with a symbol' do
+    let(:default) { :method_name  }
+
+    it { should be(true)  }
+  end
+
+  context 'with a non-symbol' do
+    let(:default) { 'method_name' }
+
+    it { should be(false)  }
+  end
+end
+

data/spec/unit/virtus/attribute/default_value/from_symbol/evaluate_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Virtus::Attribute::DefaultValue::FromSymbol, '#evaluate' do
+  subject { object.evaluate(instance) }
+
+  let(:object)    { described_class.new(attribute, value) }
+  let(:attribute) { mock('attribute')                       }
+  let(:instance)  { mock('instance', value => retval)       }
+  let(:value)     { :set_default                            }
+  let(:retval)    { mock('retval')                          }
+
+  it { should be(retval) }
+
+  it 'calls the method' do
+    instance.should_receive(value).with(no_args)
+    subject
+  end
+end

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

@@ -31,8 +31,9 @@ describe Virtus::AttributeSet, '#[]=' do
   end
 
   context 'with a duplicate attribute' do
-    let(:attributes) { [ mock('original', :name => name) ] }
-    let(:attribute)  { mock('attribute', :name => name)    }
+    let(:original)   { mock('original', :name => name)  }
+    let(:attributes) { [ original ]                     }
+    let(:attribute)  { mock('attribute', :name => name) }
 
     it { should equal(attribute) }
 
@@ -41,11 +42,11 @@ describe Virtus::AttributeSet, '#[]=' do
     end
 
     it 'allows #[] to access the attribute with a symbol' do
-      expect { subject }.to change { object['name'] }.from(nil).to(attribute)
+      expect { subject }.to change { object['name'] }.from(original).to(attribute)
     end
 
     it 'allows #[] to access the attribute with a string' do
-      expect { subject }.to change { object[:name] }.from(nil).to(attribute)
+      expect { subject }.to change { object[:name] }.from(original).to(attribute)
     end
 
     it 'allows #reset to track overridden attributes' do

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

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Virtus::AttributesAccessor, '#define_reader_method' do
+  subject { described_class.new('Test') }
+
+  let(:attribute) { mock('attribute') }
+
+  if RUBY_VERSION < '1.9'
+    let(:method_name) { 'foo_bar' }
+  else
+    let(:method_name) { :foo_bar }
+  end
+
+  before do
+    subject.define_reader_method(attribute, method_name, visibility)
+  end
+
+  context "with public visibility" do
+    let(:visibility) { :public }
+
+    its(:public_instance_methods) { should include(method_name) }
+  end
+
+  context "with private visibility" do
+    let(:visibility) { :private }
+
+    its(:private_instance_methods) { should include(method_name) }
+  end
+
+  context "with protected visibility" do
+    let(:visibility) { :protected }
+
+    its(:protected_instance_methods) { should include(method_name) }
+  end
+end
+