v3.0.9

This reverts commit 48fd72ae5b.

CHANGELOG.rdoc

@@ -1,3 +1,11 @@
+= 3.0.9 [2012-03-26]
+* ActiveRecord 3.1+ suport
+* Fixes for multiparameter extension with empty date values (thanks @mogox, @Sharagoz)
+
+= 3.0.8 [2011-12-24]
+* Remove deprecated InstanceMethods module when using AS::Concern (carlosantoniodasilva)
+* Update Mongoid shim for v2.3 compatability.
+
 = 3.0.7 [2011-09-21]
 * Fix ActiveRecord before_type_cast extension for non-dirty attributes.
 * Don't override AR before_type_cast for >= 3.1.0 which now has it's own implementation for date/time attributes.

Gemfile

@@ -2,16 +2,16 @@ source 'http://rubygems.org'
 
 gemspec
 
-gem 'rails', '3.1.0'
+gem 'rails', '~> 3.2.1'
-gem 'rspec', '~> 2.6'
+gem 'rspec', '~> 2.8'
-gem 'rspec-rails', '~> 2.6'
+gem 'rspec-rails', '~> 2.8'
 gem 'timecop'
 gem 'rspec_tag_matchers'
 gem 'ruby-debug', :platforms => [:ruby_18, :jruby]
 gem 'ruby-debug19', :platforms => [:ruby_19]
 
 group :mongoid do
-  gem 'mongoid', '2.2.0'
+  gem 'mongoid', '~> 2.3.0'
   gem 'bson_ext'
   gem 'system_timer', :platforms => [:ruby_18]
 end

Rakefile

@@ -1,6 +1,8 @@
 require 'bundler'
 Bundler::GemHelper.install_tasks
 
+Bundler.setup
+
 require 'rake/rdoctask'
 require 'rspec/core/rake_task'
 

lib/validates_timeliness/attribute_methods.rb

@@ -20,24 +20,34 @@ module ValidatesTimeliness
         :datetime
       end
 
+      def undefine_attribute_methods
+        super
+        undefine_timeliness_attribute_methods
+      end
+
       protected
 
       def define_timeliness_methods(before_type_cast=false)
         return if timeliness_validated_attributes.blank?
         timeliness_validated_attributes.each do |attr_name|
-          define_timeliness_write_method(attr_name)
+          define_attribute_timeliness_methods(attr_name, before_type_cast)
-          define_timeliness_before_type_cast_method(attr_name) if before_type_cast
         end
       end
 
+      def define_attribute_timeliness_methods(attr_name, before_type_cast=false)
+        define_timeliness_write_method(attr_name)
+        define_timeliness_before_type_cast_method(attr_name) if before_type_cast
+      end
+
       def define_timeliness_write_method(attr_name)
         method_body, line = <<-EOV, __LINE__ + 1
           def #{attr_name}=(value)
+            original_value = value
             @timeliness_cache ||= {}
-            @timeliness_cache["#{attr_name}"] = value
+            @timeliness_cache["#{attr_name}"] = original_value
-
             #{ "if value.is_a?(String)\n#{timeliness_type_cast_code(attr_name, 'value')}\nend" if ValidatesTimeliness.use_plugin_parser }
-            super
+            
+            super(value)
           end
         EOV
         generated_timeliness_methods.module_eval(method_body, __FILE__, line)
@@ -63,17 +73,20 @@ module ValidatesTimeliness
       def generated_timeliness_methods
         @generated_timeliness_methods ||= Module.new.tap { |m| include(m) }
       end
-    end
 
-    module InstanceMethods
+      def undefine_timeliness_attribute_methods
-      def _timeliness_raw_value_for(attr_name)
+        generated_timeliness_methods.module_eval do
-        @timeliness_cache && @timeliness_cache[attr_name.to_s]
+          instance_methods.each { |m| undef_method(m) }
-      end
+        end
-
-      def _clear_timeliness_cache
-        @timeliness_cache = {}
       end
     end
 
+    def _timeliness_raw_value_for(attr_name)
+      @timeliness_cache && @timeliness_cache[attr_name.to_s]
+    end
+
+    def _clear_timeliness_cache
+      @timeliness_cache = {}
+    end
   end
 end

lib/validates_timeliness/extensions/date_time_select.rb

@@ -15,11 +15,11 @@ module ValidatesTimeliness
 
       class TimelinessDateTime
         attr_accessor :year, :month, :day, :hour, :min, :sec
-        
+
         def initialize(year, month, day, hour, min, sec)
           @year, @month, @day, @hour, @min, @sec = year, month, day, hour, min, sec
         end
-        
+
         # adapted from activesupport/lib/active_support/core_ext/date_time/calculations.rb, line 36 (3.0.7)
         def change(options)
           TimelinessDateTime.new(
@@ -30,35 +30,32 @@ module ValidatesTimeliness
             options[:min]   || (options[:hour] ? 0 : min),
             options[:sec]   || ((options[:hour] || options[:min]) ? 0 : sec)
           )
-        end        
-      end
-
-      module InstanceMethods
-        def datetime_selector_with_timeliness(*args)
-          @timeliness_date_or_time_tag = true
-          datetime_selector_without_timeliness(*args)
-        end
-
-        def value_with_timeliness(object)
-          unless @timeliness_date_or_time_tag && @template_object.params[@object_name]
-            return value_without_timeliness(object)
-          end
-          
-          @template_object.params[@object_name]
-
-          pairs = @template_object.params[@object_name].select {|k,v| k =~ /^#{@method_name}\(/ }
-          return value_without_timeliness(object) if pairs.empty?
-
-          values = [nil] * 6
-          pairs.map do |(param, value)|
-            position = param.scan(/\((\d+)\w+\)/).first.first
-            values[position.to_i-1] = value.to_i
-          end
-
-          TimelinessDateTime.new(*values)
         end
       end
 
+      def datetime_selector_with_timeliness(*args)
+        @timeliness_date_or_time_tag = true
+        datetime_selector_without_timeliness(*args)
+      end
+
+      def value_with_timeliness(object)
+        unless @timeliness_date_or_time_tag && @template_object.params[@object_name]
+          return value_without_timeliness(object)
+        end
+
+        @template_object.params[@object_name]
+
+        pairs = @template_object.params[@object_name].select {|k,v| k =~ /^#{@method_name}\(/ }
+        return value_without_timeliness(object) if pairs.empty?
+
+        values = [nil] * 6
+        pairs.map do |(param, value)|
+          position = param.scan(/\((\d+)\w+\)/).first.first
+          values[position.to_i-1] = value.to_i
+        end
+
+        TimelinessDateTime.new(*values)
+      end
     end
   end
 end

lib/validates_timeliness/extensions/multiparameter_handler.rb

@@ -8,7 +8,8 @@ module ValidatesTimeliness
 
       included do
         alias_method_chain :instantiate_time_object, :timeliness
-        alias_method_chain :execute_callstack_for_multiparameter_attributes, :timeliness
+        alias_method :execute_callstack_for_multiparameter_attributes, :execute_callstack_for_multiparameter_attributes_with_timeliness
+        alias_method :read_value_from_parameter, :read_value_from_parameter_with_timeliness
       end
 
       private
@@ -20,42 +21,52 @@ module ValidatesTimeliness
       end
 
       def instantiate_time_object_with_timeliness(name, values)
-        if Date.valid_civil?(*values[0..2])
+        validate_multiparameter_date_values(values) {
           instantiate_time_object_without_timeliness(name, values)
+        }
+      end
+
+      def instantiate_date_object(name, values)
+        validate_multiparameter_date_values(values) {
+          Date.new(*values)
+        }
+      end
+
+      # Yield if date values are valid
+      def validate_multiparameter_date_values(values)
+        if values[0..2].all?{ |v| v.present? } && Date.valid_civil?(*values[0..2])
+          yield
         else
           invalid_multiparameter_date_or_time_as_string(values)
         end
       end
 
-      def instantiate_date_object(name, values)
+      def read_value_from_parameter_with_timeliness(name, values_from_param)
-        values = values.map { |v| v.nil? ? 1 : v }
+        klass = (self.class.reflect_on_aggregation(name.to_sym) || column_for_attribute(name)).klass
-        Date.new(*values)
+        values = values_from_param.is_a?(Hash) ? values_from_param.to_a.sort_by(&:first).map(&:last) : values_from_param
-      rescue ArgumentError => ex
+
-        invalid_multiparameter_date_or_time_as_string(values)
+        if values.empty? || values.all?{ |v| v.nil? }
+          nil
+        elsif klass == Time
+          instantiate_time_object(name, values)
+        elsif klass == Date
+          instantiate_date_object(name, values)
+        else
+          if respond_to?(:read_other_parameter_value)
+            read_date_parameter_value(name, values_from_param)
+          else
+            klass.new(*values)
+          end
+        end
       end
 
       def execute_callstack_for_multiparameter_attributes_with_timeliness(callstack)
         errors = []
         callstack.each do |name, values_with_empty_parameters|
           begin
-            klass = (self.class.reflect_on_aggregation(name.to_sym) || column_for_attribute(name)).klass
+            send(name + "=", read_value_from_parameter(name, values_with_empty_parameters))
-            values = values_with_empty_parameters.reject { |v| v.nil? }
-
-            if values.empty?
-              send(name + "=", nil)
-            else
-
-              value = if Time == klass
-                instantiate_time_object(name, values)
-              elsif Date == klass
-                instantiate_date_object(name, values_with_empty_parameters)
-              else
-                klass.new(*values)
-              end
-
-              send(name + "=", value)
-            end
           rescue => ex
+            values = values_with_empty_parameters.is_a?(Hash) ? values_with_empty_parameters.values : values_with_empty_parameters 
             errors << ActiveRecord::AttributeAssignmentError.new("error on assignment #{values.inspect} to #{name}", ex, name)
           end
         end

lib/validates_timeliness/orm/active_record.rb

@@ -3,13 +3,21 @@ module ValidatesTimeliness
     module ActiveRecord
       extend ActiveSupport::Concern
 
-      module ClassMethods
+      def self.use_plugin_cache?
-        def define_attribute_methods
+        ::ActiveRecord::VERSION::STRING < '3.1.0'
-          super
+      end
-          # Define write method and before_type_cast method
+
-          use_before_type_cast = ::ActiveRecord::VERSION::STRING < '3.1.0'
+      included do
-          define_timeliness_methods(use_before_type_cast)
+        if ValidatesTimeliness::ORM::ActiveRecord.use_plugin_cache? 
+          include Reload
+        else
+          # Just use the built-in before_type_cast retrieval
+          alias_method :_timeliness_raw_value_for, :read_attribute_before_type_cast
         end
+      end
+
+      module ClassMethods
+        public
 
         def timeliness_attribute_timezone_aware?(attr_name)
           attr_name = attr_name.to_s
@@ -20,17 +28,46 @@ module ValidatesTimeliness
           columns_hash[attr_name.to_s].type
         end
 
+        def define_attribute_methods
+          super.tap do |attribute_methods_generated|
+            use_before_type_cast = ValidatesTimeliness::ORM::ActiveRecord.use_plugin_cache?
+            define_timeliness_methods use_before_type_cast
+          end
+        end
+
+        protected
+
+        def define_attribute_timeliness_methods(attr_name, before_type_cast=false)
+          if before_type_cast
+            define_timeliness_write_method(attr_name)
+            define_timeliness_before_type_cast_method(attr_name)
+          elsif ValidatesTimeliness.use_plugin_parser
+            define_timeliness_write_method_without_cache(attr_name)
+          end
+        end
+
+        def define_timeliness_write_method_without_cache(attr_name)
+          method_body, line = <<-EOV, __LINE__ + 1
+            def #{attr_name}=(value)
+              original_value = value
+              if value.is_a?(String)\n#{timeliness_type_cast_code(attr_name, 'value')}\nend
+              super(value)
+              @attributes['#{attr_name}'] = original_value
+            end
+          EOV
+          generated_timeliness_methods.module_eval(method_body, __FILE__, line)
+        end
+
         def timeliness_type_cast_code(attr_name, var_name)
           type = timeliness_attribute_type(attr_name)
 
-          <<-END
+          method_body = super
-            #{super}
+          method_body << "\n#{var_name} = #{var_name}.to_date if #{var_name}" if type == :date
-            #{var_name} = #{var_name}.to_date if #{var_name} && :#{type} == :date
+          method_body
-          END
         end
       end
 
-      module InstanceMethods
+      module Reload
         def reload(*args)
           _clear_timeliness_cache
           super

lib/validates_timeliness/orm/mongoid.rb

@@ -7,6 +7,8 @@ module ValidatesTimeliness
       # field value in Mongoid. Parser will return nil rather than error.
 
       module ClassMethods 
+        public
+
         # Mongoid has no bulk attribute method definition hook. It defines
         # them with each field definition. So we likewise define them after
         # each validation is defined.
@@ -16,12 +18,6 @@ module ValidatesTimeliness
           attr_names.each { |attr_name| define_timeliness_write_method(attr_name) }
         end
 
-        def timeliness_type_cast_code(attr_name, var_name)
-          type = timeliness_attribute_type(attr_name)
-
-          "#{var_name} = Timeliness::Parser.parse(value, :#{type})"
-        end
-
         def timeliness_attribute_type(attr_name)
           {
             Date => :date,
@@ -29,8 +25,23 @@ module ValidatesTimeliness
             DateTime => :datetime
           }[fields[attr_name.to_s].type] || :datetime
         end
+
+        protected
+
+        def timeliness_type_cast_code(attr_name, var_name)
+          type = timeliness_attribute_type(attr_name)
+
+          "#{var_name} = Timeliness::Parser.parse(value, :#{type})"
+        end
+
       end
 
+      module Reload
+        def reload(*args)
+          _clear_timeliness_cache
+          super
+        end
+      end
     end
   end
 end
@@ -39,9 +50,14 @@ module Mongoid::Document
   include ValidatesTimeliness::AttributeMethods
   include ValidatesTimeliness::ORM::Mongoid
 
-  def reload_with_timeliness
+  # Pre-2.3 reload
-    _clear_timeliness_cache
+  if (instance_methods & ['reload', :reload]).present?
-    reload_without_timeliness
+    def reload_with_timeliness
+      _clear_timeliness_cache
+      reload_without_timeliness
+    end
+    alias_method_chain :reload, :timeliness
+  else
+    include ValidatesTimeliness::ORM::Mongoid::Reload
   end
-  alias_method_chain :reload, :timeliness
 end

lib/validates_timeliness/version.rb

@@ -1,3 +1,3 @@
 module ValidatesTimeliness
-  VERSION = '3.0.7'
+  VERSION = '3.0.9'
 end

spec/spec_helper.rb

@@ -88,8 +88,14 @@ RSpec.configure do |c|
   c.include(ModelHelpers)
   c.include(ConfigHelper)
   c.before do
-    Person.reset_callbacks(:validate)
+    reset_validation_setup_for(Person)
-    PersonWithShim.timeliness_validated_attributes = []
+    reset_validation_setup_for(PersonWithShim)
-    Person._validators.clear
   end
+
+  RSpec.configure do |c|
+    c.filter_run_excluding :active_record => lambda {|version|
+      !(::ActiveRecord::VERSION::STRING.to_s =~ /^#{version.to_s}/)
+    }
+  end
+  
 end

spec/support/config_helper.rb

@@ -10,6 +10,16 @@ module ConfigHelper
     ValidatesTimeliness.send(:"#{preference_name}=", old_value)
   end
 
+  def reset_validation_setup_for(model_class)
+    model_class.reset_callbacks(:validate)
+    model_class._validators.clear
+    model_class.timeliness_validated_attributes = [] if model_class.respond_to?(:timeliness_validated_attributes)
+    model_class.undefine_attribute_methods
+    # This is a hack to avoid a disabled super method error message after an undef
+    model_class.instance_variable_set(:@generated_attribute_methods, nil)
+    model_class.instance_variable_set(:@generated_timeliness_methods, nil)
+  end
+
   module ClassMethods
     def with_config(preference_name, temporary_value)
       original_config_value = ValidatesTimeliness.send(preference_name)

spec/validates_timeliness/attribute_methods_spec.rb

@@ -31,7 +31,7 @@ describe ValidatesTimeliness::AttributeMethods do
     it 'should cache attribute raw value' do
       r = PersonWithCache.new
       r.birth_datetime = date_string = '2010-01-01'
-      r._timeliness_raw_value_for(:birth_datetime).should == date_string
+      r._timeliness_raw_value_for('birth_datetime').should == date_string
     end
 
     it 'should not overwrite user defined methods' do
@@ -40,6 +40,21 @@ describe ValidatesTimeliness::AttributeMethods do
       e.redefined_birth_date_called.should be_true
     end
 
+    it 'should be undefined if model class has dynamic attribute methods reset' do
+      # Force method definitions
+      PersonWithShim.validates_date :birth_date
+      r = PersonWithShim.new
+      r.birth_date = Time.now
+
+      write_method = RUBY_VERSION < '1.9' ? 'birth_date=' : :birth_date=
+
+      PersonWithShim.send(:generated_timeliness_methods).instance_methods.should include(write_method)
+
+      PersonWithShim.undefine_attribute_methods 
+
+      PersonWithShim.send(:generated_timeliness_methods).instance_methods.should_not include(write_method)
+    end
+
     context "with plugin parser" do
       with_config(:use_plugin_parser, true)
 

spec/validates_timeliness/extensions/multiparameter_handler_spec.rb

@@ -1,33 +1,44 @@
 require 'spec_helper'
 
 describe ValidatesTimeliness::Extensions::MultiparameterHandler do
-  let(:employee) { Employee.new }
 
   context "time column" do
-    it 'should return string value for invalid date portion' do
+    it 'should assign a string value for invalid date portion' do
-      multiparameter_attribute(:birth_datetime, [2000, 2, 31, 12, 0, 0])
+      employee = record_with_multiparameter_attribute(:birth_datetime, [2000, 2, 31, 12, 0, 0])
-      employee.birth_datetime_before_type_cast.should == '2000-02-31 12:00:00'
+      employee.birth_datetime_before_type_cast.should eq '2000-02-31 12:00:00'
     end
      
-    it 'should return Time value for valid datetimes' do
+    it 'should assign a Time value for valid datetimes' do
-      multiparameter_attribute(:birth_datetime, [2000, 2, 28, 12, 0, 0])
+      employee = record_with_multiparameter_attribute(:birth_datetime, [2000, 2, 28, 12, 0, 0])
-      employee.birth_datetime_before_type_cast.should be_kind_of(Time)
+      employee.birth_datetime_before_type_cast.should eq Time.local(2000, 2, 28, 12, 0, 0)
+    end
+
+    it 'should assign a string value for incomplete time' do
+      employee = record_with_multiparameter_attribute(:birth_datetime, [2000, nil, nil])
+      employee.birth_datetime_before_type_cast.should eq '2000-00-00'
     end
   end
 
   context "date column" do
-    it 'should return string value for invalid date' do
+    it 'should assign a string value for invalid date' do
-      multiparameter_attribute(:birth_date, [2000, 2, 31])
+      employee = record_with_multiparameter_attribute(:birth_date, [2000, 2, 31])
-      employee.birth_date_before_type_cast.should == '2000-02-31'
+      employee.birth_date_before_type_cast.should eq '2000-02-31'
     end
 
-    it 'should return Date value for valid date' do
+    it 'should assign a Date value for valid date' do
-      multiparameter_attribute(:birth_date, [2000, 2, 28])
+      employee = record_with_multiparameter_attribute(:birth_date, [2000, 2, 28])
-      employee.birth_date_before_type_cast.should be_kind_of(Date)
+      employee.birth_date_before_type_cast.should eq Date.new(2000, 2, 28)
+    end
+
+    it 'should assign a string value for incomplete date' do
+      employee = record_with_multiparameter_attribute(:birth_date, [2000, nil, nil])
+      employee.birth_date_before_type_cast.should eq '2000-00-00'
     end
   end
 
-  def multiparameter_attribute(name, values)
+  def record_with_multiparameter_attribute(name, values)
-    employee.send(:execute_callstack_for_multiparameter_attributes, name.to_s => values)
+    hash = {}
+    values.each_with_index {|value, index| hash["#{name}(#{index+1}i)"] = value.to_s }
+    Employee.new(hash)
   end
 end

spec/validates_timeliness/orm/active_record_spec.rb

@@ -29,7 +29,7 @@ describe ValidatesTimeliness, 'ActiveRecord' do
     it 'should cache attribute raw value' do
       r = EmployeeWithCache.new
       r.birth_datetime = date_string = '2010-01-01'
-      r._timeliness_raw_value_for(:birth_datetime).should == date_string
+      r._timeliness_raw_value_for('birth_datetime').should == date_string
     end
 
     context "with plugin parser" do
@@ -47,7 +47,7 @@ describe ValidatesTimeliness, 'ActiveRecord' do
         r.birth_date = '2010-01-01'
       end
 
-      context "for a date column" do
+      context "for a date column", :active_record => '3.0' do
         it 'should store a date value after parsing string' do
           r = EmployeeWithParser.new
           r.birth_date = '2010-01-01'
@@ -83,7 +83,7 @@ describe ValidatesTimeliness, 'ActiveRecord' do
       r.birth_date = '2010-01-01'
       r.reload
 
-      r._timeliness_raw_value_for(:birth_date).should be_nil
+      r._timeliness_raw_value_for('birth_date').should be_nil
     end
   end
 
@@ -106,5 +106,23 @@ describe ValidatesTimeliness, 'ActiveRecord' do
       r = Employee.last
       r.birth_datetime_before_type_cast.should match(/2010-01-01 00:00:00/)
     end
+
+    context "with plugin parser" do
+      with_config(:use_plugin_parser, true)
+
+      it 'should return original value' do
+        r = Employee.new
+        r.birth_datetime = date_string = '2010-01-31'
+
+        r.birth_datetime_before_type_cast.should == date_string
+      end
+    end
+
+  end
+
+  context "define_attribute_methods" do
+    it "returns a falsy value if the attribute methods have already been generated" do
+      Employee.define_attribute_methods.should be_false
+    end
   end
 end

spec/validates_timeliness/orm/mongoid_spec.rb

@@ -69,22 +69,22 @@ describe ValidatesTimeliness, 'Mongoid' do
       end
 
       context "for a date column" do
-        it 'should store a Time value after parsing string' do
+        it 'should store a Date value after parsing string' do
           r = Article.new
           r.publish_date = '2010-01-01'
 
-          r.publish_date.should be_kind_of(Time)
+          r.publish_date.should be_kind_of(Date)
           r.publish_date.should == Date.new(2010, 1, 1)
         end
       end
 
       context "for a datetime column" do
-        it 'should parse string into Time value' do
+        it 'should parse string into DateTime value' do
           r = Article.new
           r.publish_datetime = '2010-01-01 12:00'
 
-          r.publish_datetime.should be_kind_of(Time)
+          r.publish_datetime.should be_kind_of(DateTime)
-          r.publish_datetime.should == Time.utc(2010,1,1,12,0)
+          r.publish_datetime.should == DateTime.new(2010,1,1,12,0)
         end
       end
     end
@@ -108,6 +108,6 @@ end
 
 rescue LoadError
   puts "Mongoid specs skipped. Mongoid not installed"
-rescue StandardError
+rescue StandardError => e
-  puts "Mongoid specs skipped. MongoDB connection failed."
+  puts "Mongoid specs skipped. MongoDB connection failed with error: #{e.message}"
 end

spec/validates_timeliness/validator_spec.rb

@@ -46,6 +46,17 @@ describe ValidatesTimeliness::Validator do
       Person.validates_date :birth_date, :allow_nil => true
       valid!(:birth_date, NIL)
     end
+
+    context "with raw value cache" do
+      it "should not be valid with an invalid format" do
+        PersonWithShim.validates_date :birth_date, :allow_nil => true
+
+        p = PersonWithShim.new
+        p.birth_date = 'bogus'
+
+        p.should_not be_valid
+      end
+    end
   end
 
   describe ":allow_blank option" do
@@ -59,6 +70,17 @@ describe ValidatesTimeliness::Validator do
       Person.validates_date :birth_date, :allow_blank => true
       valid!(:birth_date, '')
     end
+
+    context "with raw value cache" do
+      it "should not be valid with an invalid format" do
+        PersonWithShim.validates_date :birth_date, :allow_blank => true
+
+        p = PersonWithShim.new
+        p.birth_date = 'bogus'
+
+        p.should_not be_valid
+      end
+    end
   end
 
   describe ":between option" do

validates_timeliness.gemspec

@@ -16,5 +16,5 @@ Gem::Specification.new do |s|
   s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.extra_rdoc_files = ["README.rdoc", "CHANGELOG.rdoc", "LICENSE"]
 
-  s.add_runtime_dependency(%q<timeliness>, ["~> 0.3.3"])
+  s.add_runtime_dependency(%q<timeliness>, ["~> 0.3.4"])
 end