version 1.1.6

renamed enable action view extension method and enable both extensions in the one method as they are needed together

CHANGELOG

@@ -1,3 +1,16 @@
+= 1.1.6 [2009-03-19]
+- Rail 2.3 support
+- Added :with_date and :with_time options. They allow an attribute to be combined with another attribute or value to make a datetime value for validation against the temporal restrictions
+- Added :equal_to option
+- Option key validation
+- Better behaviour with other plugins using alias_method_chain on read_attribute and define_attribute_methods
+- Added option to enable datetime_select extension for future use to optionally enable. Enabled by default until version 2.
+- Added :ignore_usec option for datetime restrictions to be compared without microsecond
+- some refactoring
+
+= 1.1.5 [2009-01-21]
+- Fixed regex for 'yy' format token which wasn't greedy enough for date formats ending with year when a datetime string parsed as date with a 4 digit year
+
 = 1.1.4 [2009-01-13]
 - Make months names respect i18n in Formats
 

README.rdoc

@@ -33,12 +33,16 @@ think should be a valid date or time string.
 
 As plugin (from master)
 
-  ./script/plugin git://github.com/adzap/validates_timeliness.git
+  ./script/plugin install git://github.com/adzap/validates_timeliness.git
 
 As gem
 
   sudo gem install validates_timeliness
 
+  # in environment.rb
+
+  config.gem 'validates_timeliness'
+
 
 == USAGE:
 
@@ -51,50 +55,54 @@ validation method
   end
   
 The list of validation methods available are as follows:
-
+  validates_date     - validate value as date
-  * validates_date     - validate value as date
+  validates_time     - validate value as time only i.e. '12:20pm'
-  
+  validates_datetime - validate value as a full date and time
-  * validates_time     - validate value as time only i.e. '12:20pm'
-  
-  * validates_datetime - validate value as a full date and time
   
 The validation methods take the usual options plus some specific ones to restrict
 the valid range of dates or times allowed
 
-  Temporal options (or restrictions):  
+Temporal options (or restrictions):
-    :before       - Attribute must be before this value to be valid
+  :equal_to     - Attribute must be equal to value to be valid
-    :on_or_before - Attribute must be equal to or before this value to be valid
+  :before       - Attribute must be before this value to be valid
-    :after        - Attribute must be after this value to be valid
+  :on_or_before - Attribute must be equal to or before this value to be valid
-    :on_or_after  - Attribute must be equal to or after this value to be valid
+  :after        - Attribute must be after this value to be valid
-    :between      - Attribute must be between the values to be valid
+  :on_or_after  - Attribute must be equal to or after this value to be valid
+  :between      - Attribute must be between the values to be valid. Takes an array of two values or a range
 
-  Regular validation options:  
+Regular validation options:
-    :allow_nil    - Allow a nil value to be valid
+  :allow_nil    - Allow a nil value to be valid
-    :allow_blank  - Allows a nil or empty string value to be valid
+  :allow_blank  - Allows a nil or empty string value to be valid
-    :if           - Execute validation when :if evaluates true
+  :if           - Execute validation when :if evaluates true
-    :unless       - Execute validation when :unless evaluates false
+  :unless       - Execute validation when :unless evaluates false
 
-  Message options: - Use these to override the default error messages
+Special options:
-    :invalid_date_message
+  :with_time    - Validate a date attribute value combined with a time value against any temporal restrictions
-    :invalid_time_message
+  :with_date    - Validate a time attribute value combined with a date value against any temporal restrictions 
-    :invalid_datetime_message
+  :ignore_usec  - Ignores microsecond value on datetime restrictions
-    :before_message
+  
-    :on_or_before_message
+Message options: - Use these to override the default error messages
-    :after_message
+  :invalid_date_message
-    :on_or_after_message
+  :invalid_time_message
-    :between_message
+  :invalid_datetime_message
+  :equal_to_message
+  :before_message
+  :on_or_before_message
+  :after_message
+  :on_or_after_message
+  :between_message
 
-The temporal restrictions can take 4 different value types:
+The temporal restrictions, with_date and with_time can take 4 different value types:
-
+* String value
-  * String value
+* Date, Time, or DateTime object value
-  * Date, Time, or DateTime object value
+* Proc or lambda object which may take an optional parameter being the record object
-  * Proc or lambda object
+* A symbol matching the method name in the model
-  * A symbol matching the method name in the model  
-  * Between option takes an array of two values or a range
 
 When an attribute value is compared to temporal restrictions, they are compared as 
 the same type as the validation method type. So using validates_date means all
-values are compared as dates.
+values are compared as dates. This is except in the case of with_time and with_date
+options which effectively force the value to validated as a datetime against the
+temporal options.
 
 == EXAMPLES:
 
@@ -107,6 +115,8 @@ values are compared as dates.
                                   :allow_nil => true
 
   validates_datetime :appointment_date, :before => Proc.new { 1.week.from_now }
+
+  validates_date :entry_date, :with_time => '17:00', :on_or_before => :competition_closing
  
 
 === DATE/TIME FORMATS:
@@ -120,44 +130,43 @@ be happy to know that is exactly the format you can use to define your own if
 you want. No complex regular expressions or duck punching (monkey patching) the
 plugin is needed.
 
-  Time formats:  
+==== Time formats:
-    hh:nn:ss
+  hh:nn:ss
-    hh-nn-ss
+  hh-nn-ss
-    h:nn
+  h:nn
-    h.nn
+  h.nn
-    h nn
+  h nn
-    h-nn
+  h-nn
-    h:nn_ampm
+  h:nn_ampm
-    h.nn_ampm 
+  h.nn_ampm
-    h nn_ampm
+  h nn_ampm
-    h-nn_ampm
+  h-nn_ampm
-    h_ampm
+  h_ampm
-  
-  NOTE: Any time format without a meridian token (the 'ampm' token) is considered 
-        in 24 hour time.
-  
-  Date formats:  
-    yyyy/mm/dd
-    yyyy-mm-dd
-    yyyy.mm.dd
-    m/d/yy  OR  d/m/yy
-    m\d\yy  OR  d\m\yy
-    d-m-yy
-    d.m.yy
-    d mmm yy
-  
-  NOTE: To use non-US date formats see US/EURO FORMATS section
-  
-  Datetime formats:  
-    m/d/yy h:nn:ss   OR  d/m/yy hh:nn:ss
-    m/d/yy h:nn      OR  d/m/yy h:nn
-    m/d/yy h:nn_ampm OR  d/m/yy h:nn_ampm
-    yyyy-mm-dd hh:nn:ss
-    yyyy-mm-dd h:nn
-    ddd mmm d hh:nn:ss zo yyyy # Ruby time string
-    yyyy-mm-ddThh:nn:ss(?:Z|zo) # ISO 8601
 
-  NOTE: To use non-US date formats see US/EURO FORMATS section
+NOTE: Any time format without a meridian token (the 'ampm' token) is considered in 24 hour time.
+
+==== Date formats:
+  yyyy/mm/dd
+  yyyy-mm-dd
+  yyyy.mm.dd
+  m/d/yy  OR  d/m/yy
+  m\d\yy  OR  d\m\yy
+  d-m-yy
+  d.m.yy
+  d mmm yy
+
+NOTE: To use non-US date formats see US/EURO FORMATS section
+
+==== Datetime formats:
+  m/d/yy h:nn:ss   OR  d/m/yy hh:nn:ss
+  m/d/yy h:nn      OR  d/m/yy h:nn
+  m/d/yy h:nn_ampm OR  d/m/yy h:nn_ampm
+  yyyy-mm-dd hh:nn:ss
+  yyyy-mm-dd h:nn
+  ddd mmm d hh:nn:ss zo yyyy # Ruby time string
+  yyyy-mm-ddThh:nn:ss(?:Z|zo) # ISO 8601
+
+NOTE: To use non-US date formats see US/EURO FORMATS section
 
 Here is what each format token means:
 
@@ -219,7 +228,7 @@ Done! That format is no longer considered valid. Easy!
 Ok, now I hear you say "Well I have format that I want to use but you don't have it".
 Ahh, then add it yourself. Again stick this in an initializer file
 
-    ValidatesTimeliness::Formats.add_formats(:time, "d o'clock")
+  ValidatesTimeliness::Formats.add_formats(:time, "d o'clock")
 
 Now "10 o'clock" will be a valid value. So easy, no more whingeing!
 
@@ -234,7 +243,7 @@ with an existing format, will mean your format is ignored. If you need to make
 your new format higher precedence than an existing format, you can include the 
 before option like so
 
-    ValidatesTimeliness::Formats.add_formats(:time, 'ss:nn:hh', :before => 'hh:nn:ss')
+  ValidatesTimeliness::Formats.add_formats(:time, 'ss:nn:hh', :before => 'hh:nn:ss')
 
 Now a time of '59:30:23' will be interpreted as 11:30:59 pm. This option saves
 you adding a new one and deleting an old one to get it to work.

Rakefile

@@ -5,7 +5,7 @@ require 'date'
 require 'spec/rake/spectask'
 
 GEM = "validates_timeliness"
-GEM_VERSION = "1.1.4"
+GEM_VERSION = "1.1.6"
 AUTHOR = "Adam Meehan"
 EMAIL = "adam.meehan@gmail.com"
 HOMEPAGE = "http://github.com/adzap/validates_timeliness"
@@ -24,9 +24,6 @@ spec = Gem::Specification.new do |s|
   s.email = EMAIL
   s.homepage = HOMEPAGE
   
-  # Uncomment this to add a dependency
-  # s.add_dependency "foo"
-  
   s.require_path = 'lib'
   s.autorequire = GEM
   s.files = %w(LICENSE README.rdoc Rakefile TODO CHANGELOG) + Dir.glob("{lib,spec}/**/*")

TODO

@@ -1,4 +1,3 @@
 - :format option
-- :with_date and :with_time options
 - valid formats could come from locale file
 - add replace_formats instead add_formats :before

lib/validates_timeliness.rb

@@ -21,14 +21,20 @@ module ValidatesTimeliness
 
   class << self
 
-    def load_error_messages_with_i18n
+    def enable_datetime_select_extension!
-      I18n.load_path += [ LOCALE_PATH ]
+      enable_datetime_select_invalid_value_extension!
+      enable_multiparameter_attributes_extension!
     end
 
-    def load_error_messages_without_i18n
+    def load_error_messages
-      messages = YAML::load(IO.read(LOCALE_PATH))
+      if defined?(I18n)
-      errors = messages['en']['activerecord']['errors']['messages'].inject({}) {|h,(k,v)| h[k.to_sym] = v.gsub(/\{\{\w*\}\}/, '%s');h }
+        I18n.load_path += [ LOCALE_PATH ]
-      ::ActiveRecord::Errors.default_error_messages.update(errors)
+        I18n.reload!
+      else
+        messages = YAML::load(IO.read(LOCALE_PATH))
+        errors = messages['en']['activerecord']['errors']['messages'].inject({}) {|h,(k,v)| h[k.to_sym] = v.gsub(/\{\{\w*\}\}/, '%s');h }
+        ::ActiveRecord::Errors.default_error_messages.update(errors)
+      end
     end
     
     def default_error_messages
@@ -39,29 +45,13 @@ module ValidatesTimeliness
       end
     end
 
-    def setup_for_rails_2_0
-      load_error_messages_without_i18n
-    end
-
-    def setup_for_rails_2_1
-      load_error_messages_without_i18n
-    end
-
-    def setup_for_rails_2_2
-      load_error_messages_with_i18n
-    end
-
     def setup_for_rails
       major, minor = Rails::VERSION::MAJOR, Rails::VERSION::MINOR
-      self.send("setup_for_rails_#{major}_#{minor}")
       self.default_timezone = ::ActiveRecord::Base.default_timezone
-    rescue
+      self.enable_datetime_select_extension!
-      puts "Rails version #{Rails::VERSION::STRING} not explicitly supported by validates_timeliness plugin. You may encounter some problems."
+      self.load_error_messages
-      resume
     end
   end
 end
 
 ValidatesTimeliness.setup_for_rails
-
-ValidatesTimeliness::Formats.compile_format_expressions

lib/validates_timeliness/action_view/instance_tag.rb

@@ -1,4 +1,9 @@
 module ValidatesTimeliness
+
+  def self.enable_datetime_select_invalid_value_extension!
+    ::ActionView::Helpers::InstanceTag.send(:include, ValidatesTimeliness::ActionView::InstanceTag)
+  end
+
   module ActionView
 
     # Intercepts the date and time select helpers to allow the 
@@ -41,5 +46,3 @@ module ValidatesTimeliness
 
   end   
 end
-
-ActionView::Helpers::InstanceTag.send(:include, ValidatesTimeliness::ActionView::InstanceTag)

lib/validates_timeliness/active_record/attribute_methods.rb

@@ -18,29 +18,27 @@ module ValidatesTimeliness
 
       def self.included(base)
         base.extend ClassMethods
+        base.class_eval do
+          alias_method_chain :read_attribute, :timeliness
+          class << self
+            alias_method_chain :define_attribute_methods, :timeliness
+          end
+        end
       end
 
       # Adds check for cached date/time attributes which have been type cast already
       # and value can be used from cache. This prevents the raw date/time value from
       # being type cast using default Rails type casting when writing values
       # to the database.
-      def read_attribute(attr_name)
+      def read_attribute_with_timeliness(attr_name)
         attr_name = attr_name.to_s
         if !(value = @attributes[attr_name]).nil?
-          if column = column_for_attribute(attr_name)
+          column = column_for_attribute(attr_name)
-            if unserializable_attribute?(attr_name, column)
+          if column && [:date, :time, :datetime].include?(column.type) && @attributes_cache.has_key?(attr_name)
-              unserialize_attribute(attr_name)
+            return @attributes_cache[attr_name]
-            elsif [:date, :time, :datetime].include?(column.type) && @attributes_cache.has_key?(attr_name)
-              @attributes_cache[attr_name]
-            else
-              column.type_cast(value)
-            end
-          else
-            value
           end
-        else
-          nil
         end
+        read_attribute_without_timeliness(attr_name)
       end
 
       # If Rails dirty attributes is enabled then the value is added to
@@ -48,19 +46,20 @@ module ValidatesTimeliness
       # implementation as it chains the write_attribute method which deletes
       # the attribute from the cache.
       def write_date_time_attribute(attr_name, value, type, time_zone_aware)
-        old = read_attribute(attr_name) if defined?(::ActiveRecord::Dirty)
         new = self.class.parse_date_time(value, type)
 
-        unless type == :date || new.nil?
+        if new && type != :date
-          new = new.to_time rescue new
+          new = new.to_time
+          new = new.in_time_zone if time_zone_aware
         end
 
-        new = new.in_time_zone if new && time_zone_aware
+        if defined?(::ActiveRecord::Dirty) && !changed_attributes.include?(attr_name)
+          old = read_attribute(attr_name)
+          if old != new
+            changed_attributes[attr_name] = (old.duplicable? ? old.clone : old)
+          end
+        end
         @attributes_cache[attr_name] = new
-
-        if defined?(::ActiveRecord::Dirty) && !changed_attributes.include?(attr_name) && old != new
-          changed_attributes[attr_name] = (old.duplicable? ? old.clone : old)
-        end
         @attributes[attr_name] = value
       end
 
@@ -74,7 +73,7 @@ module ValidatesTimeliness
 
         if @attributes_cache.has_key?(attr_name)
           time = read_attribute_before_type_cast(attr_name)
-          time = self.class.parse_date_time(date, type)
+          time = self.class.parse_date_time(time, type)
         else
           time = read_attribute(attr_name)
           @attributes[attr_name] = time && time_zone_aware ? time.in_time_zone : time
@@ -84,19 +83,15 @@ module ValidatesTimeliness
 
       module ClassMethods
 
-        # Override AR method to define attribute reader and writer method for
+        # Define attribute reader and writer method for date, time and
-        # date, time and datetime attributes to use plugin parser.
+        # datetime attributes to use plugin parser.
-        def define_attribute_methods
+        def define_attribute_methods_with_timeliness
           return if generated_methods?
           columns_hash.each do |name, column|
             unless instance_method_already_implemented?(name)
-              if self.serialized_attributes[name]
+              if [:date, :time, :datetime].include?(column.type)
-                define_read_method_for_serialized_attribute(name)
-              elsif [:date, :time, :datetime].include?(column.type)
                 time_zone_aware = create_time_zone_conversion_attribute?(name, column) rescue false
                 define_read_method_for_dates_and_times(name, column.type, time_zone_aware)
-              else
-                define_read_method(name.to_sym, name, column)
               end
             end
 
@@ -104,22 +99,17 @@ module ValidatesTimeliness
               if [:date, :time, :datetime].include?(column.type)
                 time_zone_aware = create_time_zone_conversion_attribute?(name, column) rescue false
                 define_write_method_for_dates_and_times(name, column.type, time_zone_aware)
-              else
-                define_write_method(name.to_sym)
               end
             end
-
-            unless instance_method_already_implemented?("#{name}?")
-              define_question_method(name)
-            end
           end
+          define_attribute_methods_without_timeliness
         end
 
         # Define write method for date, time and datetime columns
         def define_write_method_for_dates_and_times(attr_name, type, time_zone_aware)
           method_body = <<-EOV
             def #{attr_name}=(value)
-               write_date_time_attribute('#{attr_name}', value, #{type.inspect}, #{time_zone_aware})
+              write_date_time_attribute('#{attr_name}', value, #{type.inspect}, #{time_zone_aware})
             end
           EOV
           evaluate_attribute_method attr_name, method_body, "#{attr_name}="

lib/validates_timeliness/active_record/multiparameter_attributes.rb

@@ -1,6 +1,10 @@
 module ValidatesTimeliness
-  module ActiveRecord
 
+  def self.enable_multiparameter_attributes_extension!
+    ::ActiveRecord::Base.send(:include, ValidatesTimeliness::ActiveRecord::MultiparameterAttributes)
+  end
+
+  module ActiveRecord
     module MultiparameterAttributes
       
       def self.included(base)
@@ -38,13 +42,13 @@ module ValidatesTimeliness
         values = values.map(&:to_s)
                 
         case type
-          when :date
+        when :date
-            extract_date_from_multiparameter_attributes(values)
+          extract_date_from_multiparameter_attributes(values)
-          when :time
+        when :time
-            extract_time_from_multiparameter_attributes(values)
+          extract_time_from_multiparameter_attributes(values)
-          when :datetime
+        when :datetime
-            date_values, time_values = values.slice!(0, 3), values
+          date_values, time_values = values.slice!(0, 3), values
-            extract_date_from_multiparameter_attributes(date_values) + " " + extract_time_from_multiparameter_attributes(time_values)
+          extract_date_from_multiparameter_attributes(date_values) + " " + extract_time_from_multiparameter_attributes(time_values)
         end
       end   
          
@@ -60,5 +64,3 @@ module ValidatesTimeliness
 
   end
 end
-
-ActiveRecord::Base.send(:include, ValidatesTimeliness::ActiveRecord::MultiparameterAttributes)

lib/validates_timeliness/formats.rb

@@ -115,7 +115,7 @@ module ValidatesTimeliness
       { 'mm'   => [ /m{2}/,  '(\d{2})',   :month ] },
       { 'm'    => [ /(\A|[^ap])m{1}/, '(\d{1,2})', :month ] },
       { 'yyyy' => [ /y{4,}/, '(\d{4})',   :year ] },
-      { 'yy'   => [ /y{2,}/, '(\d{2}|\d{4})', :year ] },
+      { 'yy'   => [ /y{2,}/, '(\d{4}|\d{2})', :year ] },
       { 'hh'   => [ /h{2,}/, '(\d{2})',   :hour ] },
       { 'h'    => [ /h{1}/,  '(\d{1,2})', :hour ] },
       { 'nn'   => [ /n{2,}/, '(\d{2})',   :min ]  },
@@ -168,9 +168,9 @@ module ValidatesTimeliness
         exp, processor = expression_set(type, string).find do |regexp, proc|
           full = /\A#{regexp}\Z/ if strict
           full ||= case type
-            when :datetime then /\A#{regexp}\Z/
+          when :date     then /\A#{regexp}/
-            when :date     then /\A#{regexp}/
+          when :time     then /#{regexp}\Z/
-            else                /#{regexp}\Z/
+          when :datetime then /\A#{regexp}\Z/
           end
           matches = full.match(string.strip)
         end
@@ -268,17 +268,17 @@ module ValidatesTimeliness
       # datetime attributes to allow date string as datetime
       def expression_set(type, string)
         case type
-          when :date
+        when :date
-            date_expressions
+          date_expressions
-          when :time
+        when :time
-            time_expressions
+          time_expressions
-          when :datetime
+        when :datetime
-            # gives a speed-up for date string as datetime attributes
+          # gives a speed-up for date string as datetime attributes
-            if string.length < 11
+          if string.length < 11
-              date_expressions + datetime_expressions
+            date_expressions + datetime_expressions
-            else
+          else
-              datetime_expressions + date_expressions
+            datetime_expressions + date_expressions
-            end
+          end
         end
       end
  
@@ -316,3 +316,5 @@ module ValidatesTimeliness
     end
   end
 end
+
+ValidatesTimeliness::Formats.compile_format_expressions

lib/validates_timeliness/locale/en.yml

@@ -5,6 +5,7 @@ en:
         invalid_date: "is not a valid date"
         invalid_time: "is not a valid time"
         invalid_datetime: "is not a valid datetime"
+        equal_to: "must be equal to {{restriction}}"
         before: "must be before {{restriction}}"
         on_or_before: "must be on or before {{restriction}}"
         after: "must be after {{restriction}}"

lib/validates_timeliness/spec/rails/matchers/validate_timeliness.rb

@@ -92,8 +92,8 @@ module Spec
         end
        
         def parse_and_cast(value)
-          value = @validator.send(:restriction_value, value, @record)
+          value = @validator.class.send(:evaluate_option_value, value, @type, @record)
-          @validator.send(:type_cast_value, value)
+          @validator.class.send(:type_cast_value, value, @type)
         end
 
         def error_matching(value, option)
@@ -117,11 +117,11 @@ module Spec
 
         def error_message_for(option)
           msg = @validator.send(:error_messages)[option]
-          restriction = @validator.send(:restriction_value, @validator.configuration[option], @record)
+          restriction = @validator.class.send(:evaluate_option_value, @validator.configuration[option], @type, @record)
 
           if restriction 
             restriction = [restriction] unless restriction.is_a?(Array)
-            restriction.map! {|r| @validator.send(:type_cast_value, r) }
+            restriction.map! {|r| @validator.class.send(:type_cast_value, r, @type) }
             interpolate = @validator.send(:interpolation_values, option, restriction )
             # get I18n message if defined and has interpolation keys in msg
             if defined?(I18n) && !@validator.send(:custom_error_messages).include?(option)

lib/validates_timeliness/validation_methods.rb

@@ -49,13 +49,13 @@ module ValidatesTimeliness
       private
 
       def validates_timeliness_of(attr_names, configuration)
-        validator = ValidatesTimeliness::Validator.new(configuration)
+        validator = ValidatesTimeliness::Validator.new(configuration.symbolize_keys)
         
         # bypass handling of allow_nil and allow_blank to validate raw value
         configuration.delete(:allow_nil)
         configuration.delete(:allow_blank)
         validates_each(attr_names, configuration) do |record, attr_name, value|
-          validator.call(record, attr_name)
+          validator.call(record, attr_name, value)
         end
       end
 

lib/validates_timeliness/validator.rb

@@ -12,6 +12,7 @@ module ValidatesTimeliness
     }
 
     RESTRICTION_METHODS = {
+      :equal_to     => :==,
       :before       => :<, 
       :after        => :>, 
       :on_or_before => :<=,
@@ -19,18 +20,24 @@ module ValidatesTimeliness
       :between      => lambda {|v, r| (r.first..r.last).include?(v) } 
     }
 
+    VALID_OPTIONS = [
+      :on, :if, :unless, :allow_nil, :empty, :allow_blank, :blank,
+      :with_time, :with_date, :ignore_usec,
+      :invalid_time_message, :invalid_date_message, :invalid_datetime_message
+    ] + RESTRICTION_METHODS.keys.map {|option| [option, "#{option}_message".to_sym] }.flatten
+
     attr_reader :configuration, :type
 
     def initialize(configuration)
-      defaults = { :on => :save, :type => :datetime, :allow_nil => false, :allow_blank => false }
+      defaults = { :on => :save, :type => :datetime, :allow_nil => false, :allow_blank => false, :ignore_usec => false }
       @configuration = defaults.merge(configuration)
       @type = @configuration.delete(:type)
+      validate_options(@configuration)
     end
       
-    def call(record, attr_name)
+    def call(record, attr_name, value)
-      value     = record.send(attr_name)
       value     = record.class.parse_date_time(value, type, false) if value.is_a?(String)
-      raw_value = raw_value(record, attr_name)
+      raw_value = raw_value(record, attr_name) || value
 
       return if (raw_value.nil? && configuration[:allow_nil]) || (raw_value.blank? && configuration[:allow_blank])
 
@@ -44,18 +51,25 @@ module ValidatesTimeliness
    private
 
     def raw_value(record, attr_name)
-      record.send("#{attr_name}_before_type_cast")
+      record.send("#{attr_name}_before_type_cast") rescue nil
     end
    
     def validate_restrictions(record, attr_name, value)
-      value = type_cast_value(value)
+      value = if @configuration[:with_time] || @configuration[:with_date]
-      
+        restriction_type = :datetime
+        combine_date_and_time(value, record)
+      else
+        restriction_type = type
+        self.class.type_cast_value(value, type, @configuration[:ignore_usec])
+      end
+      return if value.nil?
+
       RESTRICTION_METHODS.each do |option, method|
         next unless restriction = configuration[option]
         begin
-          restriction = restriction_value(restriction, record)
+          restriction = self.class.evaluate_option_value(restriction, restriction_type, record)
           next if restriction.nil?
-          restriction = type_cast_value(restriction)
+          restriction = self.class.type_cast_value(restriction, restriction_type, @configuration[:ignore_usec])
 
           unless evaluate_restriction(restriction, value, method)
             add_error(record, attr_name, option, interpolation_values(option, restriction))
@@ -87,10 +101,10 @@ module ValidatesTimeliness
       return true if restriction.nil?
 
       case comparator
-        when Symbol
+      when Symbol
-          value.send(comparator, restriction)
+        value.send(comparator, restriction)
-        when Proc
+      when Proc
-          comparator.call(value, restriction)
+        comparator.call(value, restriction)
       end
     end
     
@@ -107,13 +121,11 @@ module ValidatesTimeliness
     end
 
     def error_messages
-      return @error_messages if defined?(@error_messages)
+      @error_messages ||= ValidatesTimeliness.default_error_messages.merge(custom_error_messages)
-      @error_messages = ValidatesTimeliness.default_error_messages.merge(custom_error_messages)
     end
     
     def custom_error_messages
-      return @custom_error_messages if defined?(@custom_error_messages)
+      @custom_error_messages ||= configuration.inject({}) {|msgs, (k, v)|
-      @custom_error_messages = configuration.inject({}) {|msgs, (k, v)|
         if md = /(.*)_message$/.match(k.to_s) 
           msgs[md[1].to_sym] = v
         end
@@ -121,42 +133,72 @@ module ValidatesTimeliness
       }
     end
     
-    def restriction_value(restriction, record)
+    def combine_date_and_time(value, record)
-      case restriction
+      if type == :date
-        when Time, Date, DateTime
+        date = value
-          restriction
+        time = @configuration[:with_time]
-        when Symbol
+      else
-          restriction_value(record.send(restriction), record)
+        date = @configuration[:with_date]
-        when Proc
+        time = value
-          restriction_value(restriction.call(record), record)
-        when Array
-          restriction.map {|r| restriction_value(r, record) }.sort
-        when Range
-          restriction_value([restriction.first, restriction.last], record)
-        else
-         record.class.parse_date_time(restriction, type, false)
       end
+      date, time = self.class.evaluate_option_value(date, :date, record), self.class.evaluate_option_value(time, :time, record)
+      return if date.nil? || time.nil?
+      record.class.send(:make_time, [date.year, date.month, date.day, time.hour, time.min, time.sec, time.usec]) 
     end
-    
+
-    def type_cast_value(value)
+    def validate_options(options)
-      if value.is_a?(Array)
+      invalid_for_type = ([:time, :date, :datetime] - [@type]).map {|k| "invalid_#{k}_message".to_sym }
-        value.map {|v| type_cast_value(v) }
+      invalid_for_type << :with_date unless @type == :time
-      else 
+      invalid_for_type << :with_time unless @type == :date
-        case type
+      options.assert_valid_keys(VALID_OPTIONS - invalid_for_type)
-        when :time
+    end
-          value.to_dummy_time
+
-        when :date
+    # class methods
-          value.to_date
+    class << self
-        when :datetime
+
-          if value.is_a?(DateTime) || value.is_a?(Time)
+      def evaluate_option_value(value, type, record)
-            value.to_time
+        case value
-          else
+        when Time, Date, DateTime
-            value.to_time(ValidatesTimeliness.default_timezone)
+          value
-          end
+        when Symbol
+          evaluate_option_value(record.send(value), type, record)
+        when Proc
+          evaluate_option_value(value.call(record), type, record)
+        when Array
+          value.map {|r| evaluate_option_value(r, type, record) }.sort
+        when Range
+          evaluate_option_value([value.first, value.last], type, record)
         else
-          nil
+          record.class.parse_date_time(value, type, false)
         end
       end
+
+      def type_cast_value(value, type, ignore_usec=false)
+        if value.is_a?(Array)
+          value.map {|v| type_cast_value(v, type, ignore_usec) }
+        else
+          value = case type
+          when :time
+            value.to_dummy_time
+          when :date
+            value.to_date
+          when :datetime
+            if value.is_a?(DateTime) || value.is_a?(Time)
+              value.to_time
+            else
+              value.to_time(ValidatesTimeliness.default_timezone)
+            end
+          else
+            nil
+          end
+          if ignore_usec && value.is_a?(Time)
+            ::ActiveRecord::Base.send(:make_time, Array(value).reverse[4..9])
+          else
+            value
+          end
+        end
+      end
+
     end
 
   end

spec/active_record/attribute_methods_spec.rb

@@ -1,9 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe ValidatesTimeliness::ActiveRecord::AttributeMethods do
-  include ValidatesTimeliness::ActiveRecord::AttributeMethods
-  include ValidatesTimeliness::ValidationMethods
-  
   before do
     @person = Person.new
   end
@@ -35,7 +32,7 @@ describe ValidatesTimeliness::ActiveRecord::AttributeMethods do
     @person.birth_time
   end
 
-  it "should call rea_date_time_attribute when datetime attribute is retrieved" do
+  it "should call read_date_time_attribute when datetime attribute is retrieved" do
     @person.should_receive(:read_date_time_attribute)
     @person.birth_date_and_time = "2000-01-01 12:00"
     @person.birth_date_and_time
@@ -72,6 +69,11 @@ describe ValidatesTimeliness::ActiveRecord::AttributeMethods do
     @person.birth_date_and_time.should be_kind_of(Time)
   end
 
+  it "should return Time object for datetime attribute read method when assigned Date object" do
+    @person.birth_date_and_time = Date.today
+    @person.birth_date_and_time.should be_kind_of(Time)
+  end
+
   it "should return Time object for datetime attribute read method when assigned string" do
     @person.birth_date_and_time = "2000-01-01 02:03:04"
     @person.birth_date_and_time.should be_kind_of(Time)

spec/formats_spec.rb

@@ -157,11 +157,16 @@ describe ValidatesTimeliness::Formats do
       time_array = formats.parse('2000-02-01', :datetime, false)
       time_array.should == [2000,2,1,0,0,0,0]
     end
-    
+
     it "should ignore time when extracting date and strict is false" do
       time_array = formats.parse('2000-02-01 12:12', :date, false)
       time_array.should == [2000,2,1,0,0,0,0]
     end
+
+    it "should ignore time when extracting date from format with trailing year and strict is false" do
+      time_array = formats.parse('01-02-2000 12:12', :date, false)
+      time_array.should == [2000,2,1,0,0,0,0]
+    end
     
     it "should ignore date when extracting time and strict is false" do
       time_array = formats.parse('2000-02-01 12:12', :time, false)

spec/ginger_scenarios.rb

@@ -9,7 +9,7 @@
 #   ginger spec
 #
 Ginger.configure do |config|
-  rails_versions = ['2.0.2', '2.1.2', '2.2.2']
+  rails_versions = ['2.0.2', '2.1.2', '2.2.2', '2.3.2']
 
   rails_versions.each do |v|
     g = Ginger::Scenario.new

spec/validator_spec.rb

@@ -16,55 +16,71 @@ describe ValidatesTimeliness::Validator do
     @person = Person.new
   end
 
-  describe "restriction_value" do
+  describe "option keys validation" do
+    before do
+      keys = ValidatesTimeliness::Validator::VALID_OPTIONS - [:invalid_date_message, :invalid_time_message, :with_date, :with_time]
+      @valid_options = keys.inject({}) {|hash, opt| hash[opt] = nil; hash }
+    end
+
+    it "should raise error if invalid option key passed" do
+      @valid_options.update(:invalid_key => 'will not open lock')
+      lambda { Person.validates_datetime(@valid_options) }.should raise_error(ArgumentError)
+    end
+
+    it "should not raise error if option keys are valid" do
+      lambda { Person.validates_datetime(@valid_options) }.should_not raise_error(ArgumentError)
+    end
+  end
+
+  describe "evaluate_option_value" do
     it "should return Time object when restriction is Time object" do
-      restriction_value(Time.now, :datetime).should be_kind_of(Time)
+      evaluate_option_value(Time.now, :datetime).should be_kind_of(Time)
     end
 
     it "should return Time object when restriction is string" do
-      restriction_value("2007-01-01 12:00", :datetime).should be_kind_of(Time)
+      evaluate_option_value("2007-01-01 12:00", :datetime).should be_kind_of(Time)
     end
 
     it "should return Time object when restriction is method and method returns Time object" do
       person.stub!(:datetime_attr).and_return(Time.now)
-      restriction_value(:datetime_attr, :datetime).should be_kind_of(Time)
+      evaluate_option_value(:datetime_attr, :datetime).should be_kind_of(Time)
     end
 
     it "should return Time object when restriction is method and method returns string" do
       person.stub!(:datetime_attr).and_return("2007-01-01 12:00")
-      restriction_value(:datetime_attr, :datetime).should be_kind_of(Time)
+      evaluate_option_value(:datetime_attr, :datetime).should be_kind_of(Time)
     end
 
     it "should return Time object when restriction is proc which returns Time object" do
-      restriction_value(lambda { Time.now }, :datetime).should be_kind_of(Time)
+      evaluate_option_value(lambda { Time.now }, :datetime).should be_kind_of(Time)
     end
 
     it "should return Time object when restriction is proc which returns string" do
-      restriction_value(lambda {"2007-01-01 12:00"}, :datetime).should be_kind_of(Time)
+      evaluate_option_value(lambda {"2007-01-01 12:00"}, :datetime).should be_kind_of(Time)
     end
 
     it "should return array of Time objects when restriction is array of Time objects" do
       time1, time2 = Time.now, 1.day.ago
-      restriction_value([time1, time2], :datetime).should == [time2, time1]
+      evaluate_option_value([time1, time2], :datetime).should == [time2, time1]
     end
 
     it "should return array of Time objects when restriction is array of strings" do
       time1, time2 = "2000-01-02", "2000-01-01"
-      restriction_value([time1, time2], :datetime).should == [Person.parse_date_time(time2, :datetime), Person.parse_date_time(time1, :datetime)]
+      evaluate_option_value([time1, time2], :datetime).should == [Person.parse_date_time(time2, :datetime), Person.parse_date_time(time1, :datetime)]
     end
 
     it "should return array of Time objects when restriction is Range of Time objects" do
       time1, time2 = Time.now, 1.day.ago
-      restriction_value(time1..time2, :datetime).should == [time2, time1]
+      evaluate_option_value(time1..time2, :datetime).should == [time2, time1]
     end
 
     it "should return array of Time objects when restriction is Range of time strings" do
       time1, time2 = "2000-01-02", "2000-01-01"
-      restriction_value(time1..time2, :datetime).should == [Person.parse_date_time(time2, :datetime), Person.parse_date_time(time1, :datetime)]
+      evaluate_option_value(time1..time2, :datetime).should == [Person.parse_date_time(time2, :datetime), Person.parse_date_time(time1, :datetime)]
     end
-    def restriction_value(restriction, type)
+    def evaluate_option_value(restriction, type)
       configure_validator(:type => type)
-      validator.send(:restriction_value, restriction, person)
+      validator.class.send(:evaluate_option_value, restriction, type, person)
     end
   end
 
@@ -330,6 +346,100 @@ describe ValidatesTimeliness::Validator do
     end
   end
 
+  describe "instance with :equal_to restriction" do
+
+    describe "for datetime type" do
+      before do
+        configure_validator(:equal_to => Time.now)
+      end
+
+      it "should have error when value not equal to :equal_to restriction" do
+        validate_with(:birth_date_and_time, Time.now + 1)
+        should_have_error(:birth_date_and_time, :equal_to)
+      end
+
+      it "should have error when value is equal to :equal_to restriction for all values except microscond, and microsecond is not ignored" do
+        configure_validator(:equal_to => Time.utc(2000, 1, 1, 0, 0, 0, 0), :ignore_usec => false)
+        validate_with(:birth_date_and_time, Time.utc(2000, 1, 1, 0, 0, 0, 500))
+        should_have_error(:birth_date_and_time, :equal_to)
+      end
+
+      it "should be valid when value is equal to :equal_to restriction for all values except microscond, and microsecond is ignored" do
+        configure_validator(:equal_to => Time.utc(2000, 1, 1, 0, 0, 0, 0), :ignore_usec => true)
+        validate_with(:birth_date_and_time, Time.utc(2000, 1, 1, 0, 0, 0, 500))
+        should_have_no_error(:birth_date_and_time, :equal_to)
+      end
+
+      it "should be valid when value is equal to :equal_to restriction" do
+        validate_with(:birth_date_and_time, Time.now)
+        should_have_no_error(:birth_date_and_time, :equal_to)
+      end
+    end
+
+    describe "for date type" do
+      before do
+        configure_validator(:type => :date, :equal_to => Date.today)
+      end
+
+      it "should have error when value is not equal to :equal_to restriction" do
+        validate_with(:birth_date, Date.today + 1)
+        should_have_error(:birth_date, :equal_to)
+      end
+
+      it "should be valid when value is equal to :equal_to restriction" do
+        validate_with(:birth_date, Date.today)
+        should_have_no_error(:birth_date, :equal_to)
+      end
+    end
+
+    describe "for time type" do
+      before do
+        configure_validator(:type => :time, :equal_to => "09:00:00")
+      end
+
+      it "should have error when value is not equal to :equal_to restriction" do
+        validate_with(:birth_time, "09:00:01")
+        should_have_error(:birth_time, :equal_to)
+      end
+
+      it "should be valid when value is equal to :equal_to restriction" do
+        validate_with(:birth_time, "09:00:00")
+        should_have_no_error(:birth_time, :equal_to)
+      end
+    end
+  end
+
+  describe "instance with :with_time option" do
+
+    it "should validate date attribute as datetime combining value of :with_time against restrictions " do
+      configure_validator(:type => :date, :with_time => '12:31', :on_or_before => Time.mktime(2000,1,1,12,30))
+      validate_with(:birth_date, "2000-01-01")
+      should_have_error(:birth_date, :on_or_before)
+    end
+
+    it "should skip restriction validation if :with_time value is nil" do
+      configure_validator(:type => :date, :with_time => nil, :on_or_before => Time.mktime(2000,1,1,12,30))
+      validate_with(:birth_date, "2000-01-01")
+      should_have_no_error(:birth_date, :on_or_before)
+    end
+
+  end
+
+  describe "instance with :with_date option" do
+
+    it "should validate time attribute as datetime combining value of :with_date against restrictions " do
+      configure_validator(:type => :time, :with_date => '2009-01-01', :on_or_before => Time.mktime(2000,1,1,12,30))
+      validate_with(:birth_date, "12:30")
+      should_have_error(:birth_date, :on_or_before)
+    end
+
+    it "should skip restriction validation if :with_date value is nil" do
+      configure_validator(:type => :time, :with_date => nil, :on_or_before => Time.mktime(2000,1,1,12,30))
+      validate_with(:birth_date, "12:30")
+      should_have_no_error(:birth_date, :on_or_before)
+    end
+  end
+
   describe "instance with mixed value and restriction types" do
 
     it "should validate datetime attribute with Date restriction" do
@@ -483,7 +593,7 @@ describe ValidatesTimeliness::Validator do
 
   def validate_with(attr_name, value)
     person.send("#{attr_name}=", value)
-    validator.call(person, attr_name)
+    validator.call(person, attr_name, value)
   end
 
   def should_have_error(attr_name, error)

validates_timeliness.gemspec

@@ -2,12 +2,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{validates_timeliness}
-  s.version = "1.1.4"
+  s.version = "1.1.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Adam Meehan"]
   s.autorequire = %q{validates_timeliness}
-  s.date = %q{2009-01-13}
+  s.date = %q{2009-03-19}
   s.description = %q{Date and time validation plugin for Rails 2.x which allows custom formats}
   s.email = %q{adam.meehan@gmail.com}
   s.extra_rdoc_files = ["README.rdoc", "LICENSE", "TODO", "CHANGELOG"]