virtus 0.2.0 → 0.3.0

data/lib/virtus/value_object/equalizer.rb

@@ -1,20 +1,8 @@
 module Virtus
   module ValueObject
+
     # A type of Module for dynamically defining and hosting equality methods
     class Equalizer < Module
-      # Name of hosting Class or Module that will be used for #inspect
-      #
-      # @return [String]
-      #
-      # @api private
-      attr_reader :host_name
-
-      # List of methods that will be used to define equality methods
-      #
-      # @return [Array(Symbol)]
-      #
-      # @api private
-      attr_reader :keys
 
       # Initialize an Equalizer with the given keys
       #
@@ -23,8 +11,7 @@ module Virtus
       #
       # @api private
       def initialize(host_name, keys = [])
-        @host_name = host_name
-        @keys      = keys
+        @host_name, @keys = host_name, keys
       end
 
       # Append a key and compile the equality methods
@@ -35,8 +22,6 @@ module Virtus
       def <<(key)
         @keys << key
         compile
-
-        self
       end
 
       # Compile the equalizer methods based on #keys
@@ -49,7 +34,6 @@ module Virtus
         define_eql_method
         define_equivalent_method
         define_hash_method
-
         self
       end
 
@@ -57,20 +41,20 @@ module Virtus
 
       # Define an inspect method that reports the values of the instance's keys
       #
-      # @return [self]
+      # @return [undefined]
       #
       # @api private
       def define_inspect_method
         module_eval <<-RUBY, __FILE__, __LINE__ + 1
           def inspect
-            "#<#{host_name} #{keys.map { |key| "#{key}=\#{#{key}.inspect}" }.join(' ')}>"
+            "#<#{@host_name} #{compile_keys { |key| "#{key}=\#{#{key}.inspect}" }}>"
           end
         RUBY
       end
 
       # Define an #eql? method based on the instance's values identified by #keys
       #
-      # @return [self]
+      # @return [undefined]
       #
       # @api private
       def define_eql_method
@@ -78,14 +62,14 @@ module Virtus
           def eql?(other)
             return true if equal?(other)
             instance_of?(other.class) &&
-            #{keys.map { |key| "#{key}.eql?(other.#{key})" }.join(' && ')}
+            #{compile_keys(' && ') { |key| "#{key}.eql?(other.#{key})" }}
           end
         RUBY
       end
 
       # Define an #== method based on the instance's values identified by #keys
       #
-      # @return [self]
+      # @return [undefined]
       #
       # @api private
       def define_equivalent_method
@@ -101,29 +85,40 @@ module Virtus
 
       # Define a #hash method based on the instance's values identified by #keys
       #
-      # @return [self]
+      # @return [undefined]
       #
       # @api private
       def define_hash_method
         module_eval <<-RUBY, __FILE__, __LINE__ + 1
           def hash
-            self.class.hash ^ #{keys.map { |key| "#{key}.hash" }.join(' ^ ')}
+            self.class.hash ^ #{compile_keys(' ^ ') { |key| "#{key}.hash" }}
           end
         RUBY
       end
 
+      # Return a list of strings containing ruby code for method generation
+      #
+      # @return [Array(Array<String>, Array<String>)]
+      #
       # @api private
       def compile_strings_for_equivalent_method
         respond_to = []
         equivalent = []
 
-        keys.each do |key|
+        @keys.each do |key|
           respond_to << "other.respond_to?(#{key.inspect})"
           equivalent << "#{key} == other.#{key}"
         end
 
         [ respond_to, equivalent ]
       end
+
+      # @api private
+      def compile_keys(separator = ' ', &block)
+        keys_map = @keys.map { |key| yield(key) }
+        keys_map.join(separator)
+      end
+
     end # class Equalizer
   end # module ValueObject
 end # module Virtus

data/lib/virtus/version.rb

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

data/spec/integration/custom_attributes_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe 'custom attribtues' do
+describe 'custom attributes' do
 
   module Virtus
     class Coercion

data/spec/integration/default_values_spec.rb

@@ -7,10 +7,17 @@ describe "default values" do
       class Page
         include Virtus
 
-        attribute :title,      String
-        attribute :slug,       String,  :default => lambda { |post, attribute| post.title.downcase.gsub(' ', '-') }
-        attribute :view_count, Integer, :default => 0
+        attribute :title,        String
+        attribute :slug,         String,  :default => lambda { |post, attribute| post.title.downcase.gsub(' ', '-') }
+        attribute :view_count,   Integer, :default => 0
+        attribute :published,    Boolean, :default => false, :accessor => :private
+        attribute :editor_title, String,  :default => :default_editor_title
+
+        def default_editor_title
+          published? ? title : "UNPUBLISHED: #{title}"
+        end
       end
+
     end
   end
 
@@ -29,4 +36,9 @@ describe "default values" do
     subject.slug.should == 'example-blog-post'
   end
 
+  specify 'you can set defaults for private attributes' do
+    subject.title = 'Top Secret'
+    subject.editor_title.should == 'UNPUBLISHED: Top Secret'
+  end
+
 end

data/spec/integration/defining_attributes_spec.rb

@@ -52,7 +52,7 @@ describe "virtus attribute definitions" do
   end
 
   context 'inheritance' do
-    specify 'inherits all the attribtues from the base class' do
+    specify 'inherits all the attributes from the base class' do
       fred = Examples::Manager.new(:name => 'Fred', :age => 29)
       fred.name.should == 'Fred'
       fred.age.should == 29

data/spec/integration/mass_assignment_with_accessors_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe "mass assignment with accessors" do
+
+  before do
+    module Examples
+      class Product
+        include Virtus
+
+        attribute :id,          Integer
+        attribute :category,    String
+        attribute :subcategory, String
+
+        def categories=(categories)
+          self.category = categories.first
+          self.subcategory = categories.last
+        end
+
+      private
+
+        def _id=(value)
+          self.id = value
+        end
+      end
+    end
+  end
+
+  subject { Examples::Product.new(:categories => ['Office', 'Printers'], :_id => 100) }
+
+  specify 'works uppon instantiation' do
+    subject.category.should == 'Office'
+    subject.subcategory.should == 'Printers'
+  end
+
+  specify 'can be set with #attributes=' do
+    subject.attributes = {:categories => ['Home', 'Furniture']}
+    subject.category.should == 'Home'
+    subject.subcategory.should == 'Furniture'
+  end
+
+  specify 'respects accessor visibility' do
+    subject.id.should_not == 100
+  end
+end

data/spec/integration/virtus/value_object_spec.rb

@@ -29,8 +29,8 @@ describe Virtus::ValueObject do
 
   describe 'writer visibility' do
     it 'attributes are configured for private writers' do
-      class_under_test.attributes[:latitude].writer_visibility.should  == :private
-      class_under_test.attributes[:longitude].writer_visibility.should == :private
+      class_under_test.attributes[:latitude].public_reader?.should be(true)
+      class_under_test.attributes[:longitude].public_writer?.should be(false)
     end
 
     it 'writer methods are set to private' do

data/spec/spec_helper.rb

@@ -1,5 +1,5 @@
-require 'backports'
 require 'rubygems'
+require 'backports'
 
 begin
   require 'rspec'  # try for RSpec 2
@@ -38,3 +38,10 @@ RSpec.configure do |config|
   end
 
 end
+
+# change the heckle timeout to be 5 seconds
+if defined?(::Heckle)
+  class ::Heckle
+    @@timeout = 5
+  end
+end

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

@@ -17,7 +17,7 @@ describe Virtus::Attribute, '.determine_type' do
       subject { object.determine_type(primitive) }
 
       before do
-        if [Virtus::Attribute::EmbeddedValue, Virtus::Attribute::Collection].include? attribute_class
+        if [Virtus::Attribute::Collection].include? attribute_class
           pending
         end
       end

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

@@ -23,7 +23,7 @@ describe Virtus::Attribute, '#default' do
       options.update(:default => default)
     end
 
-    it { should be_instance_of(Virtus::Attribute::DefaultValue) }
+    it { should be_instance_of(Virtus::Attribute::DefaultValue::FromClonable) }
 
     its(:attribute) { should be(object) }
 

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

@@ -3,17 +3,16 @@ require 'spec_helper'
 describe Virtus::Attribute::DefaultValue, '#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(:object)    { described_class.build(attribute, value) }
+  let(:attribute) { mock('attribute')                       }
+  let(:value)     { mock('value')                           }
+  let(:instance)  { mock('instance')                        }
+  let(:response)  { stub('response')                        }
 
   context 'when the value is callable' do
-    let(:response) { stub('response') }
+    before { value.stub(:call => response) }
 
-    before do
-      value.stub(:call => response)
-    end
+    specify { object.should be_instance_of(Virtus::Attribute::DefaultValue::FromCallable) }
 
     it { should be(response) }
 
@@ -26,9 +25,9 @@ describe Virtus::Attribute::DefaultValue, '#evaluate' do
   context 'when the value is cloneable' do
     let(:clone) { stub('clone') }
 
-    before do
-      value.stub(:clone => clone)
-    end
+    before { value.stub(:clone => clone) }
+
+    specify { object.should be_instance_of(Virtus::Attribute::DefaultValue::FromClonable) }
 
     it { should be(clone) }
 
@@ -38,6 +37,21 @@ describe Virtus::Attribute::DefaultValue, '#evaluate' do
     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/embedded_value/class_methods/merge_options_spec.rb

@@ -12,6 +12,6 @@ describe Virtus::Attribute::EmbeddedValue, '.merge_options' do
   it { should_not equal(options) }
 
   it 'merges the type in as the model' do
-    should eql(:model => type)
+    should eql(:primitive => type)
   end
 end

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

@@ -11,7 +11,7 @@ describe Virtus::Attribute::EmbeddedValue, '#coerce' do
     let(:value) { Hash[:foo => 'bar'] }
 
     context 'when the options include the model' do
-      let(:object)         { described_class.new(attribute_name, :model => model) }
+      let(:object)         { described_class.new(attribute_name, :primitive => model) }
       let(:model)          { mock('model')                                        }
       let(:model_instance) { mock('model_instance') }
 

data/spec/unit/virtus/class_methods/allowed_writer_methods_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Virtus::ClassMethods, '#allowed_writer_methods' do
+  subject { object.allowed_writer_methods }
+
+  let(:object) do
+    Class.new do
+      include Virtus
+      attribute :virtus_attribute, String
+      attr_accessor :some_other_attribute
+    private
+      attr_accessor :private_attribute
+    end
+  end
+
+  it { should include('virtus_attribute=') }
+  it { should include('some_other_attribute=') }
+  it { should_not include('private_attribute=') }
+
+  %w[ == != === []= attributes= ].each do |invalid_method|
+    it { should_not include(invalid_method) }
+  end
+
+  it { should be_frozen }
+end

data/spec/unit/virtus/coercion/object/class_methods/to_array_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Virtus::Coercion::Object, '.to_array' do
+  subject { object.to_array(value) }
+
+  let(:object)  { described_class }
+  let(:value)   { Object.new      }
+  let(:coerced) { [ value ]       }
+
+  context 'when the value responds to #to_ary' do
+    before do
+      value.should_receive(:to_ary).with().and_return(coerced)
+    end
+
+    it { should be(coerced) }
+
+    it 'does not call #to_a if #to_ary is available' do
+      value.should_not_receive(:to_a)
+      subject
+    end
+  end
+
+  context 'when the value responds to #to_a but not #to_ary' do
+    before do
+      value.should_receive(:to_a).with().and_return(coerced)
+    end
+
+    it { should be(coerced) }
+  end
+
+  context 'when the value does not respond to #to_ary or #to_a' do
+    it { should be_instance_of(Array) }
+
+    it { should == coerced }
+  end
+
+  context 'when the value returns nil from #to_ary' do
+    before do
+      value.should_receive(:to_ary).with().and_return(nil)
+    end
+
+    it 'calls #to_a as a fallback' do
+      value.should_receive(:to_a).with().and_return(coerced)
+      should be(coerced)
+    end
+
+    it 'wraps the value in an Array if #to_a is not available' do
+      should == coerced
+    end
+  end
+end

data/spec/unit/virtus/coercion/object/class_methods/to_hash_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Virtus::Coercion::Object, '.to_hash' do
+  subject { object.to_hash(value) }
+
+  let(:object) { described_class }
+  let(:value)  { stub('value')   }
+
+  context 'when the value responds to #to_hash' do
+    let(:coerced) { stub('coerced') }
+
+    before do
+      value.should_receive(:to_hash).with().and_return(coerced)
+    end
+
+    it { should be(coerced) }
+  end
+
+  context 'when the value does not respond to #to_hash' do
+    it { should be(value) }
+  end
+end