attrio 0.1.1 → 0.2.0

data/lib/attrio/initialize.rb

@@ -8,18 +8,11 @@ module Attrio
 
     module ClassMethods
       def define_attrio_new(as)
-        # define_singleton_method(:new) do |*args, &block|
-        #   obj = self.allocate
-        #   obj.send "reset_#{as}!"
-        #   obj.send :initialize, *args, &block          
-        #   obj
-        # end
-
         class_eval(<<-EOS, __FILE__, __LINE__ + 1)
           def self.new(*args, &block)
-            obj = self.allocate
-            obj.send "reset_#{as}!"
+            obj = self.allocate            
             obj.send :initialize, *args, &block          
+            obj.send "set_#{as}_defaults"
             obj
           end
         EOS

data/lib/attrio/reset.rb

@@ -8,13 +8,24 @@ module Attrio
 
     module ClassMethods
       def define_attrio_reset(as)
-        define_method "reset_#{as.to_s}" do
-          self.send(as.to_s).values.each do |attribute|                        
-            self.send(attribute.writer_method_name, attribute.default_value)            
-          end
+        define_method "reset_#{as.to_s}" do |attributes = []|          
+          self.send(as.to_s, attributes).values.each{ |attribute| self.send(attribute.writer_method_name, nil) }
+          self.send("set_#{as.to_s}_defaults", attributes)
+        end  
+
+        define_method "reset_#{as.to_s}_defaults" do |attributes = []|
+          self.send(as.to_s, attributes).values.select{ |attribute| !attribute.default_value.nil? }.each { |attribute| self.send(attribute.writer_method_name, nil) }
+          self.send("set_#{as.to_s}_defaults", attributes)          
         end
 
-        self.send(:alias_method, "reset_#{as.to_s}!", "reset_#{as.to_s}")        
+        define_method "set_#{as.to_s}_defaults" do |attributes = []|
+          self.send(as.to_s, attributes).values.select{ |attribute| !attribute.default_value.nil? }.each do |attribute|
+            next if self.send(attribute.reader_method_name).present?
+
+            default_value = attribute.default_value.is_a?(Attrio::DefaultValue::Base) ? attribute.default_value.call(self) : attribute.default_value  
+            self.send(attribute.writer_method_name, default_value)
+          end          
+        end
       end
     end
   end

data/lib/attrio/types/base.rb

@@ -9,10 +9,6 @@ module Attrio
         raise NotImplementedError
       end
 
-      def self._typecast(value, options = {})
-        self.typecasted?(value) ? value : self.typecast(value, options)
-      end
-
       def self.typecasted?(value)
         false
       end

data/lib/attrio/types/date.rb

@@ -3,9 +3,9 @@
 module Attrio
   module Types
     class Date < Base
-      def self.typecast(value, options = {})      
+      def self.typecast(value, options = {})
         begin
-          options[:format].present? ? ::Date.strptime(value, options[:format]) : ::Date.parse(value)
+          options[:format].present? ? ::Date.strptime(value.to_s, options[:format]) : ::Date.parse(value.to_s)
         rescue ArgumentError => e
           nil
         end

data/lib/attrio/types/date_time.rb

@@ -5,7 +5,7 @@ module Attrio
     class DateTime < Base
       def self.typecast(value, options = {})
         begin
-          options[:format].present? ? ::DateTime.strptime(value, options[:format]) : ::DateTime.parse(value)
+          options[:format].present? ? ::DateTime.strptime(value.to_s, options[:format]) : ::DateTime.parse(value.to_s)
         rescue ArgumentError => e
           nil
         end

data/lib/attrio/types/time.rb

@@ -5,7 +5,7 @@ module Attrio
     class Time < Base
       def self.typecast(value, options = {})
         begin
-          options[:format].present? ? ::Time.strptime(value, options[:format]) : ::Time.parse(value)
+          options[:format].present? ? ::Time.strptime(value.to_s, options[:format]) : ::Time.parse(value.to_s)
         rescue ArgumentError => e
           nil
         end      

data/lib/attrio/version.rb

@@ -3,8 +3,8 @@
 module Attrio  
   module Version
     MAJOR = 0
-    MINOR = 1
-    PATCH = 1
+    MINOR = 2
+    PATCH = 0
     BUILD = nil
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')

data/spec/attrio/attrio_spec.rb

@@ -24,16 +24,11 @@ describe Attrio do
         model.respond_to?(:attributes).should be_true
       end
 
-      it 'should respond_to attributes=' do
-        model.respond_to?(:attributes=).should be_true
-      end
-
       describe 'object' do
         let(:object) { model.new }
 
         it 'should respond_to reset_attributes' do
           object.respond_to?(:reset_attributes).should be_true
-          object.respond_to?(:reset_attributes!).should be_true
         end
       end
     end
@@ -52,16 +47,11 @@ describe Attrio do
         model.respond_to?(:model_attributes).should be_true
       end
 
-      it 'should respond_to model_attributes=' do
-        model.respond_to?(:model_attributes=).should be_true
-      end
-
       describe 'object' do
         let(:object) { model.new }
 
         it 'should respond_to reset_model_attributes' do
-          object.respond_to?(:reset_model_attributes).should be_true
-          object.respond_to?(:reset_model_attributes!).should be_true
+          object.respond_to?(:reset_model_attributes).should be_true          
         end
       end
     end

data/spec/attrio/default_value/callable_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Attrio::DefaultValue::Callable do
+  subject { described_class.new(object, attribute, default_value) }
+
+  let(:model) do
+    Class.new do
+      include Attrio
+
+      define_attributes do        
+        attr :attribute, DateTime, :default => proc{ DateTime.now }        
+      end
+    end
+  end
+
+  let(:object){ model.new }
+
+  let(:attribute){ mock('attribute')}
+  let(:default_value){ mock('default_value')}
+  let(:response)  { stub('response') }
+
+  before { default_value.stub(:call => response) }
+  it 'should call the value with the object and attribute' do
+    default_value.should_receive(:call).with(object, attribute).and_return(response)
+    subject.call(object)
+  end
+
+  it "should set attribute value to appropriate type" do    
+    object.attribute.should be_instance_of(DateTime)  
+  end
+
+  it "should be evaluate attribute value every time" do
+    another_object = model.new    
+
+    object.attribute.should_not be_equal(another_object.attribute)
+  end
+end

data/spec/attrio/default_value/clonable_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Attrio::DefaultValue::Clonable do
+  subject { described_class.new(object, attribute, default_value) }
+
+  let(:model) do
+    Class.new do
+      include Attrio
+
+      define_attributes do        
+        attr :attribute, Date, :default => Date.today        
+      end      
+    end
+  end
+
+  let(:object){ model.new }
+
+  let(:attribute){ mock('attribute')}
+  let(:default_value){ mock('default_value')}
+  let(:instance)  { mock('instance') }
+  let(:clone)     { mock('clone') }
+
+  before { default_value.stub(:clone => clone) }
+
+  it 'should clone the value' do
+    default_value.should_receive(:clone).with(no_args)
+    subject.call(instance)
+  end
+
+  it 'should be an instance of a cloned value' do
+    subject.call(instance).should be(clone)
+  end
+
+  it "should set attribute value to appropriate type" do
+    object.attribute.should be_instance_of(Date)  
+  end
+
+  it "should not be equal to clonable object" do
+    object.attribute.should_not be_equal(Date.today)
+  end
+
+  it "should have the same value as clonable object" do
+    object.attribute.should == Date.today
+  end  
+end

data/spec/attrio/default_value/handle_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Attrio::DefaultValue::Base, '.handle' do
+  subject { described_class.handle(mock('object'), mock('attribute'), default) }
+
+  context 'when default is a symbol' do
+    let(:default) { :symbol }
+
+    it { should be_instance_of(Attrio::DefaultValue::Symbol)  }
+  end
+
+  context 'when default is a callable' do
+    let(:default) { Proc.new {} }
+
+    it { should be_instance_of(Attrio::DefaultValue::Callable)  }
+  end
+
+  context 'when default is a clonable' do
+    let(:default) { "I can be cloned" }
+
+    it { should be_instance_of(Attrio::DefaultValue::Clonable)  }
+  end
+
+  context 'when default is not clonable' do
+    let(:default) { 1 }
+
+    it { should be_nil }
+  end
+end

data/spec/attrio/default_value/symbol_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Attrio::DefaultValue::Symbol do
+  subject { described_class.new(object, attribute, default_value) }
+
+  let(:model) do
+    Class.new do
+      include Attrio
+
+      define_attributes do 
+        attr :attribute, Date, :default => :today
+        attr :attribute_with_non_existing_method, Symbol, :default => :non_existing_method
+      end
+
+      def today
+        Date.today
+      end
+    end
+  end
+
+  let(:object){ model.new }
+
+  let(:attribute){ mock('attribute')}
+  let(:default_value){ mock('default_value')}
+
+  it "should set attribute value to appropriate type" do
+    object.attribute.should be_instance_of(Date)  
+  end
+
+  it "should have value that is returned by method in class" do
+    object.attribute.should == Date.today
+  end
+end

data/spec/attrio/default_value/value_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Attrio::DefaultValue do
+  let(:model) do
+    Class.new do
+      include Attrio
+
+      define_attributes do
+        attr :attribute_without_default_value, Date
+        attr :attribute_with_default_value, Integer, :default => 1
+        # attr :attribute_with_callable_default_value, DateTime, :default => lambda{ DateTime.now }
+        # attr :attribute_with_clonable_default_value, Date, :default => Date.today
+        # attr :attribute_with_symbol_default_value, Date, :default => :today
+        # attr :attribute_with_non_existing_method_default_value, Symbol, :default => :non_existing_method
+      end
+
+      def today
+        Date.today
+      end
+    end
+  end
+
+  let(:object){ model.new }
+  
+  context 'default value is not set' do
+    it "should set attribute to nil" do
+      object.attribute_without_default_value.should be_nil
+    end
+  end
+
+  context 'default value is set as a not clonable object' do
+    it "should set attribute value to appropriate type" do
+      object.attribute_with_default_value.should be_instance_of(Fixnum)
+    end
+
+    it "should be equal to attribute value" do
+      object.attribute_with_default_value.should be_equal(1)
+    end
+  end
+
+  # context 'default value is set as a callable' do
+  #   it "should set attribute value to appropriate type" do    
+  #     object.attribute_with_callable_default_value.should be_instance_of(DateTime)  
+  #   end
+
+  #   it "should be evaluate attribute value every time" do      
+  #     object.attribute_with_callable_default_value.should < another_object.attribute_with_callable_default_value
+  #   end
+  # end
+
+  # context 'default value is set as a clonable object' do
+  #   it "should set attribute value to appropriate type" do
+  #     object.attribute_with_clonable_default_value.should be_instance_of(Date)  
+  #   end
+
+  #   it "should not be equal to clonable object" do
+  #     object.attribute_with_clonable_default_value.should_not be_equal(Date.today)
+  #   end
+
+  #   it "should have the same value as clonable object" do
+  #     object.attribute_with_clonable_default_value.should == Date.today
+  #   end
+  # end
+
+  # context 'default value is set as a symbol' do
+  #   it "should set attribute value to appropriate type" do
+  #     object.attribute_with_clonable_default_value.should be_instance_of(Date)  
+  #   end
+
+  #   it "should have value that is returned by method in class" do
+  #     object.attribute_with_clonable_default_value.should == Date.today
+  #   end
+  # end
+end

data/spec/attrio/embed_value_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe 'Embedded Value' do
+  before do
+    module MassAssignment
+      def initialize(attributes = {})
+        self.attributes = attributes
+      end
+
+      def attributes=(attributes = {})
+        attributes.each do |attr,value|
+          self.send("#{attr}=", value) if self.respond_to?("#{attr}=")
+        end
+      end
+    end
+
+    class City  
+      include Attrio
+      include MassAssignment
+
+      define_attributes do
+        attr :name, String
+      end
+    end
+
+    class Address
+      include Attrio
+      include MassAssignment
+
+      define_attributes do
+        attr :street,  String
+        attr :zipcode, String
+        attr :city,    City
+      end
+    end
+
+    class User
+      include Attrio
+      include MassAssignment
+
+      define_attributes do
+        attr :name,    String
+        attr :address, Address
+      end
+    end
+  end
+
+  let(:address_attributes) do
+      { :street => 'Sklizkova 6A', :zipcode => '170000', :city => { :name => 'Tver' } }
+  end
+
+  it 'should allow to pass a hash for the embedded value' do
+    user = User.new
+    user.address = address_attributes
+    user.address.street.should == 'Sklizkova 6A'
+    user.address.zipcode.should == '170000'
+    user.address.city.name.should == 'Tver'
+  end
+end

data/spec/attrio/inspect_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Attrio::Inspect do
-  context '' do
+  context 'without options' do
     let(:model) do
       Class.new do
         include Attrio
@@ -13,12 +13,12 @@ describe Attrio::Inspect do
 
     let(:object) { model.new }
 
-    it 'should' do
+    it 'should have inspect defined by attrio' do
       object.method(:inspect).source_location.first.should match(/lib\/attrio\/inspect.rb/)
     end
   end
 
-  context '' do
+  context ':inspect option passed' do
     let(:model) do
       Class.new do
         include Attrio
@@ -30,7 +30,7 @@ describe Attrio::Inspect do
 
     let(:object) { model.new }
 
-    it 'should' do
+    it 'should not have inspect defined by attrio' do
       if RUBY_ENGINE == 'rbx'
         object.method(:inspect).source_location.first.should_not match(/attrio/)
       else