validates_date_time 1.0.0

data/CHANGELOG

@@ -0,0 +1,61 @@
+[5 March 2009]
+
+* Add support for I18N [Roman Shterenzon]
+
+[18 February 2009]
+
+* Fix errors caused by assigning values that don't respond to #strip.
+
+[26 May 2008]
+
+* Fix incorrect validation of 24 hour times including meridian, eg: 18:20 AM.
+
+[2 May 2008]
+
+* Permenently remove old ActiveRecord::Validations::DateTime namespace.
+
+[19 March 2008]
+
+* Fix README typo.
+
+[11 February 2008]
+
+* Make :after add an error if the date is the same as the restriction.
+
+[7 January 2008]
+
+* Add support for ISO8601 formats.
+
+[14 December 2007]
+
+* Allow 1 through 6 digits for microseconds.
+
+[11 December 2007]
+
+* Parse microseconds from time and datetime strings.
+
+[28 September 2007]
+
+* Preserve ActiveRecord::Validations::DateTime.us_date_format for compatibility.
+
+[27 September 2007]
+
+* Improve the handling of multiparameter attributes.
+
+* BACKWARDS INCOMPATIBLE: Change namespace from ActiveRecord::Validations::DateTime to ValidatesDateTime.
+
+[19 September 2007]
+
+* Almost a complete rewrite! API unchanged. Let me know if there are any issues.
+
+[2 Sep 2007]
+
+ * Allow date and time formats like "February 5, 2006" and "September 01, 2007 06:10". [Mark A. Lane]
+
+[7 Jun 07]
+
+ * Datetime restrictions should be parsed as datetimes [Adam Meehan]
+ 
+[Earlier]
+
+ * Remove unused colon separated date format (dd:mm:yy) from parsing

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006 Jonathan Viney
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,94 @@
+validates_date_time
+===================
+This plugin adds the ability to do stricter date and time checking with ActiveRecord.
+
+Install
+=======
+    ./script/plugin install git://github.com/nickstenning/validates_date_time.git
+
+Instructions
+============
+The validators can be used to parse strings into Date and Time objects as well as restrict  
+an attribute based on other dates or times.
+    class Person < ActiveRecord::Base
+      validates_date     :date_of_birth
+      validates_time     :time_of_birth
+      validates_date_time :date_and_time_of_birth
+    end
+  
+Use `:allow_nil` to allow the value to be blank.
+    class Person < ActiveRecord::Base
+      validates_date :date_of_birth, :allow_nil => true
+    end
+  
+Supported formats
+=================
+The default for the plugin is to expect dates in day/month/year format. If you are in the
+US, you will want to change the default to month/day/year by placing the following in config/environment.rb
+    ValidatesDateTime.us_date_format = true
+  
+Date format examples:
+ - 2006-01-01
+ - 1 Jan 06
+ - 1 Jan 2006
+ - 10/1/06
+ - 1/1/2006
+  
+Time format examples:
+ - 1pm
+ - 10:11
+ - 12:30pm
+ - 8am
+
+Datetime format examples:
+ - 1 Jan 2006 2pm
+ - 31/1/06 8:30am
+
+Examples
+========
+If an attribute value can not be parsed correctly, an error is added: 
+    p = Person.new
+    p.date_of_birth = "1 Jan 2006"
+    p.time_of_birth = "5am"
+    p.save # true
+
+    p.date_of_birth = "30 Feb 2006"
+    p.save # false, 30 feb is invalid for obvious reasons
+
+    p.date_of_birth = "java is better than ruby"
+    p.save # false
+  
+In the final example, as I'm sure you are aware, the record failed to save not only
+because "java is better than ruby" is an invalid date, but more importantly, because the statement is blatantly false. ;) 
+
+Restricting date and time ranges
+================================
+Using the `:before` and `:after` options you can restrict a date or time value based on other attribute values  
+and predefined values. You can pass as many value to :before or :after as you like.
+    class Person
+      validates_date :date_of_birth, :before => [:date_of_death, Proc.new { 1.day.from_now_to_date}], :after => '1 Jan 1900'
+      validates_date :date_of_death, :before => Proc.new { 1.day.from_now.to_date }
+    end
+  
+    p = Person.new
+    p.date_of_birth = '1800-01-01'
+    p.save  # false
+    p.errors[:date_of_birth] # must be after 1 Jan 1900
+
+    p.date_of_death = Date.new(2010, 1, 1)
+    p.save  # false
+    p.errors[:date_of_death] # must be before <1 day from now>
+
+    p.date_of_birth = '1960-03-02'
+    p.date_of_death = '2003-06-07'
+    p.save  # true
+  
+You can customise the error messages for dates or times that fall outside the required range. The boundary date will be substituted in for %s. Eg:
+    class Person
+      validates_date :date_of_birth, :after => Date.new(1900, 1, 1), :before => Proc.new { 1.day.from_now.to_date }, :before_message => 'Ensure it is before %s', :after_message => 'Ensure it is after %s'
+    end
+
+Author
+======
+If you find this plugin useful, please consider a donation to [show your support](http://www.paypal.com/cgi-bin/webscr?cmd=_send-money)!
+Suggestions, comments, problems are all welcome. You'll find me at jonathan.viney@gmail.com

data/Rakefile

@@ -0,0 +1,37 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "validates_date_time"
+    gemspec.summary = "A Rails plugin adds the ability to validate dates and times with ActiveRecord."
+    gemspec.description = "A Rails plugin that adds an ActiveRecord validation helper to do range and start/end date checking in."
+    gemspec.email = ["jonathan.viney@gmail.com", "nick@whiteink.com"]
+    gemspec.homepage = "http://github.com/nickstenning/validates_date_time"
+    gemspec.authors = ["Jonathan Viney", "Nick Stenning"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the validates_date_time plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the validates_date_time plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'validates_date_time'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/lib/validates_date_time'

data/lib/multiparameter_attributes.rb

@@ -0,0 +1,47 @@
+module ValidatesDateTime
+  module MultiparameterAttributes
+    def self.included(base)
+      base.alias_method_chain :execute_callstack_for_multiparameter_attributes, :temporal_error_handling
+    end
+    
+    def execute_callstack_for_multiparameter_attributes_with_temporal_error_handling(callstack)
+      errors = []
+      callstack.each do |name, values|
+        klass = (self.class.reflect_on_aggregation(name.to_sym) || column_for_attribute(name)).klass
+        
+        if values.empty?
+          send("#{name}=", nil)
+        else
+          column = column_for_attribute(name)
+          
+          if [:date, :time, :datetime].include?(column.type)
+            values = values.map(&:to_s)
+            
+            result = case column.type
+              when :date
+                extract_date_from_multiparameter_attributes(values)
+              when :time
+                extract_time_from_multiparameter_attributes(values)
+              when :datetime
+                date_values, time_values = values.slice!(0, 3), values
+                extract_date_from_multiparameter_attributes(date_values) + " " + extract_time_from_multiparameter_attributes(time_values)
+            end
+                   
+            send("#{name}=", result)
+          end
+        end
+      end
+      unless errors.empty?
+        raise ActiveRecord::MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes"
+      end
+    end
+    
+    def extract_date_from_multiparameter_attributes(values)
+      [values[0], *values.slice(1, 2).map { |s| s.rjust(2, "0") }].join("-")
+    end
+    
+    def extract_time_from_multiparameter_attributes(values)
+      values.last(3).map { |s| s.rjust(2, "0") }.join(":")
+    end
+  end
+end

data/lib/parser.rb

@@ -0,0 +1,130 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class Column
+      class << self
+        def string_to_date(value)
+          return if value.blank?
+          return value if value.is_a?(Date)
+          return value.to_date if value.is_a?(Time) || value.is_a?(DateTime)
+          
+          year, month, day = case value.to_s.strip
+            # 22/1/06, 22\1\06 or 22.1.06
+            when /\A(\d{1,2})[\\\/\.-](\d{1,2})[\\\/\.-](\d{2}|\d{4})\Z/
+              ValidatesDateTime.us_date_format ? [$3, $1, $2] : [$3, $2, $1]
+            # 22 Feb 06 or 1 jun 2001
+            when /\A(\d{1,2}) (\w{3,9}) (\d{2}|\d{4})\Z/
+              [$3, $2, $1]
+            # July 1 2005
+            when /\A(\w{3,9}) (\d{1,2})\,? (\d{2}|\d{4})\Z/
+              [$3, $1, $2]
+            # 2006-01-01
+            when /\A(\d{4})-(\d{2})-(\d{2})\Z/
+              [$1, $2, $3]
+            # 2006-01-01T10:10:10+13:00
+            when /\A(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})\Z/
+              [$1, $2, $3]
+            # Not a valid date string
+            else
+              return nil
+          end
+          
+          Date.new(unambiguous_year(year), month_index(month), day.to_i) rescue nil
+        end
+        
+        def string_to_dummy_time(value)
+          return if value.blank?
+          return value if value.is_a?(Time) || value.is_a?(DateTime)
+          return value.to_time(ActiveRecord::Base.default_timezone) if value.is_a?(Date)
+          
+          hour, minute, second, microsecond = case value.to_s.strip
+            # 12 hours with minute and second
+            when /\A(\d{1,2})[\. :](\d{2})[\. :](\d{2})\s?(am|pm)\Z/i
+              [full_hour($1, $4), $2, $3]
+            # 12 hour with minute: 7.30pm, 11:20am, 2 20PM
+            when /\A(\d{1,2})[\. :](\d{2})\s?(am|pm)\Z/i
+              return nil unless $1.to_i <= 12
+              [full_hour($1, $3), $2]
+            # 12 hour without minute: 2pm, 11Am, 7 pm
+            when /\A(\d{1,2})\s?(am|pm)\Z/i
+              [full_hour($1, $2)]
+            # 24 hour: 22:30, 03.10, 12 30
+            when /\A(\d{2})[\. :](\d{2})([\. :](\d{2})(\.(\d{1,6}))?)?\Z/
+              [$1, $2, $4, $6]
+            # 2006-01-01T10:10:10+13:00
+            when /\A(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})\Z/
+              [$4, $5, $6]
+            # Not a valid time string
+            else
+              return nil
+          end
+          
+          Time.send(ActiveRecord::Base.default_timezone, 2000, 1, 1, hour.to_i, minute.to_i, second.to_i, microsecond.to_i) rescue nil
+        end
+        
+        def string_to_time(value)
+          return if value.blank?
+          return value if value.is_a?(Time) || value.is_a?(DateTime)
+          return value.to_time(ActiveRecord::Base.default_timezone) if value.is_a?(Date)
+          
+          value = value.to_s.strip
+          
+          if value =~ /\A(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})\Z/
+            time_array = [$1, $2, $3, $4, $5, $6].map!(&:to_i)
+          else
+            # The basic approach is to attempt to parse a date from the front of the string, splitting on spaces.
+            # Once a date has been parsed, a time is extracted from the rest of the string.
+            split_index = date = nil
+            loop do
+              split_index = value.index(' ', split_index ? split_index + 1 : 0)
+              
+              if split_index.nil? or date = string_to_date(value.first(split_index))
+                break
+              end
+            end
+            
+            return if date.nil?
+            
+            time = string_to_dummy_time(value.last(value.size - split_index))
+            return if time.nil?
+            
+            time_array = [date.year, date.month, date.day, time.hour, time.min, time.sec, time.usec]
+          end
+          
+          # From schema_definitions.rb
+          begin
+            Time.send(ActiveRecord::Base.default_timezone, *time_array)
+          rescue
+            zone_offset = if Base.default_timezone == :local then DateTime.now.offset else 0 end
+            # Append zero calendar reform start to account for dates skipped by calendar reform
+            DateTime.new(*time_array[0..5] << zone_offset << 0) rescue nil
+          end
+        end
+        
+        def full_hour(hour, meridian)
+          hour = hour.to_i
+          if meridian.strip.downcase == 'am'
+            hour == 12 ? 0 : hour
+          else
+            hour == 12 ? hour : hour + 12
+          end
+        end
+        
+        def month_index(month)
+          return month.to_i if month.to_i.nonzero?
+          Date::ABBR_MONTHNAMES.index(month.capitalize) || Date::MONTHNAMES.index(month.capitalize)
+        end
+        
+        # Extract a 4-digit year from a 2-digit year.
+        # If the number is less than 20, assume year 20#{number}
+        # otherwise use 19#{number}. Ignore if already 4 digits.
+        #
+        # Eg:
+        #    10 => 2010, 60 => 1960, 00 => 2000, 1963 => 1963
+        def unambiguous_year(year)
+          year = "#{year.to_i < 20 ? '20' : '19'}#{year}" if year.length == 2
+          year.to_i
+        end
+      end
+    end
+  end
+end

data/lib/validates_date_time.rb

@@ -0,0 +1,150 @@
+require File.dirname(__FILE__) + '/parser'
+require File.dirname(__FILE__) + '/multiparameter_attributes'
+
+module ValidatesDateTime
+  def self.included(base)
+    base.class_eval do
+      extend ClassMethods
+      include MultiparameterAttributes
+    end
+  end
+  
+  mattr_accessor :us_date_format
+  self.us_date_format = false
+  
+  DEFAULT_TEMPORAL_VALIDATION_OPTIONS = {
+    :before_message => "must be before %s",
+    :after_message  => "must be after %s",
+    :on => :save
+  }.freeze
+  
+  class ValidatesDateTimeRestriction < Struct.new(:raw_value, :parse_method)
+    def value(record)
+      @last_value = case raw_value
+        when Symbol
+          record.send(raw_value)
+        when Proc
+          raw_value.call(record)
+        else
+          raw_value
+      end
+      
+      @last_value = parse(@last_value)
+    end
+    
+    def parse(string)
+      ActiveRecord::ConnectionAdapters::Column.send("string_to_#{parse_method}", string)
+    end
+    
+    def last_value
+      @last_value
+    end
+    
+    def to_s
+      if raw_value.is_a?(Symbol)
+        raw_value.to_s.humanize
+      else
+        @last_value.to_s
+      end
+    end
+  end
+  
+  
+  module ClassMethods
+    def validates_date(*args)
+      options = temporal_validation_options({ :message => "is an invalid date" }, args)
+      attr_names = args
+      
+      # We must remove this from the configuration that is passed to validates_each because
+      # we want to have our own definition of nil that uses the before_type_cast value
+      allow_nil = options.delete(:allow_nil)
+      
+      prepare_restrictions(options, :date)
+      
+      validates_each(attr_names, options) do |record, attr_name, value|
+        raw_value = record.send("#{attr_name}_before_type_cast")
+        
+        # If value that is unable to be parsed, and a blank value where allow_nil is not set are both invalid
+        if (!raw_value.blank? and !value) || (raw_value.blank? and !allow_nil)
+          record.errors.add(attr_name, options[:message])
+        elsif value
+          validate_before_and_after_restrictions(record, attr_name, value, options)
+        end
+      end
+    end
+    
+    def validates_time(*args)
+      options = temporal_validation_options({ :message => "is an invalid time" }, args)
+      attr_names = args
+      
+      allow_nil = options.delete(:allow_nil)
+      prepare_restrictions(options, :dummy_time)
+      
+      validates_each(attr_names, options) do |record, attr_name, value|
+        raw_value = record.send("#{attr_name}_before_type_cast")
+        
+        if (!raw_value.blank? and !value) || (raw_value.blank? and !allow_nil)
+          record.errors.add(attr_name, options[:message])
+        elsif value
+          validate_before_and_after_restrictions(record, attr_name, value, options)
+        end
+      end
+    end
+    
+    def validates_date_time(*args)
+      options = temporal_validation_options({ :message => "is an invalid date time" }, args)
+      attr_names = args
+      
+      allow_nil = options.delete(:allow_nil)
+      prepare_restrictions(options, :time)
+      
+      validates_each(attr_names, options) do |record, attr_name, value|
+        raw_value = record.send("#{attr_name}_before_type_cast")
+        
+        if (!raw_value.blank? and !value) || (raw_value.blank? and !allow_nil)
+          record.errors.add(attr_name, options[:message])
+        elsif value
+          validate_before_and_after_restrictions(record, attr_name, value, options)
+        end
+      end
+    end
+    
+   private
+    def validate_before_and_after_restrictions(record, attr_name, value, options)
+      if options[:before]
+        options[:before].each do |r|
+          if r.value(record) and value >= r.last_value
+            record.errors.add(attr_name, :before, :value => r, :default => options[:before_message] % r)
+            break
+          end
+        end
+      end
+      
+      if options[:after]
+        options[:after].each do |r|
+          if r.value(record) and value <= r.last_value
+            record.errors.add(attr_name, :after, :value => r, :default => options[:after_message] % r)
+            break
+          end
+        end
+      end
+    end
+    
+    def prepare_restrictions(options, parse_method)
+      options[:before] = [*options[:before]].compact.map { |r| ValidatesDateTimeRestriction.new(r, parse_method) }
+      options[:after] = [*options[:after]].compact.map { |r| ValidatesDateTimeRestriction.new(r, parse_method) }
+    end
+    
+    def temporal_validation_options(options, args)
+      returning options do
+        options.reverse_merge!(DEFAULT_TEMPORAL_VALIDATION_OPTIONS)
+        options.update(args.pop) if args.last.is_a?(Hash)
+        options.assert_valid_keys :message, :before_message, :after_message, :before, :after, :if, :on, :allow_nil
+      end
+    end
+  end
+end
+
+class ActiveRecord::Base
+  include ValidatesDateTime
+end

data/test/abstract_unit.rb

@@ -0,0 +1,59 @@
+require 'test/unit'
+
+begin
+  require File.dirname(__FILE__) + '/../../../../config/boot'
+  Rails::Initializer.run
+rescue LoadError
+  require 'rubygems'
+  gem 'activerecord', '=2.2.2'
+  require 'activerecord'
+end
+
+# Search for fixtures first
+fixture_path = File.dirname(__FILE__) + '/fixtures/'
+ActiveSupport::Dependencies.load_paths.insert(0, fixture_path)
+
+require 'active_record/fixtures'
+
+require File.expand_path(File.dirname(__FILE__) + '/../lib/validates_date_time')
+
+ActiveRecord::Base.configurations = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + '/debug.log')
+ActiveRecord::Base.establish_connection(ENV['DB'] || 'mysql')
+
+load(File.dirname(__FILE__) + '/schema.rb')
+
+Test::Unit::TestCase.fixture_path = File.dirname(__FILE__) + '/fixtures/'
+
+class Test::Unit::TestCase #:nodoc:
+  self.use_transactional_fixtures = true
+  self.use_instantiated_fixtures = false
+  
+  fixtures :people
+  
+  def p
+    people(:jonathan)
+  end
+  
+  def assert_update_and_equal(expected, attributes = {})
+    assert p.update_attributes!(attributes), "#{attributes.inspect} should be valid"
+    assert_equal expected, p.send(attributes.keys.first).to_s
+  end
+  
+  def assert_update_and_match(expected, attributes = {})
+    assert p.update_attributes(attributes), "#{attributes.inspect} should be valid"
+    assert_match expected, p.send(attributes.keys.first).to_s
+  end
+  
+  def assert_invalid_and_errors_match(expected, attributes = {})
+    assert !p.update_attributes(attributes)
+    assert_match expected, p.errors.full_messages.join
+  end
+  
+  def with_us_date_format(&block)
+    ValidatesDateTime.us_date_format = true
+    yield
+  ensure
+    ValidatesDateTime.us_date_format = false
+  end
+end

data/test/database.yml

@@ -0,0 +1,6 @@
+mysql:
+  :adapter: mysql
+  :host: localhost
+  :username: rails
+  :password: 
+  :database: rails_plugin_test

data/test/date_test.rb

@@ -0,0 +1,133 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+
+class DateTest < Test::Unit::TestCase
+  def test_valid_when_nil
+    assert p.update_attributes!(:date_of_birth => nil, :date_of_death => nil)
+  end
+  
+  def test_date_required
+    assert_invalid_and_errors_match /invalid/, :required_date => ""
+  end
+  
+  # Test 1/1/06 format
+  def test_first_format
+    { '1/1/01'  => '2001-01-01', '29/10/2005' => '2005-10-29', '8\12\63' => '1963-12-08',
+      '07/06/2006' => '2006-06-07', '11\1\06' => '2006-01-11', '10.6.05' => '2005-06-10' }.each do |value, result|
+      assert_update_and_equal result, :date_of_birth => value
+    end
+  end
+  
+  # Test 1 Jan 06 and 1 January 06 formats
+  def test_second_format
+    { '19 Mar 60'    => '1960-03-19', '22 dec 1985'      => '1985-12-22',
+      '24 August 00' => '2000-08-24', '25 December 1960' => '1960-12-25'}.each do |value, result|
+      assert_update_and_equal result, :date_of_birth => value
+    end
+  end
+  
+  # Test February 4 2006 formats
+  def test_third_format
+    { 'february 4 06' => '2006-02-04', 'DECember 25 1850' => '1850-12-25', 'February 5, 2006' => '2006-02-05' }.each do |value, result|
+      assert_update_and_equal result, :date_of_birth => value
+    end
+  end
+  
+  def test_iso_format
+    { '2006-01-01' => '2006-01-01', '1900-04-22' => '1900-04-22',
+      '2008-03-04T20:33:41' => '2008-03-04' }.each do |value, result|
+      assert_update_and_equal result, :date_of_birth => value
+    end
+  end
+  
+  def test_format_without_validation
+    assert_equal Date.new(2005, 12, 11).to_s, Person.new(:date_of_birth => "11/12/05").date_of_birth.to_s
+  end
+  
+  def test_invalid_formats
+    ['aksjhdaksjhd', 'meow', 'chocolate',
+     '221 jan 05', '21 JAN 001', '1 Jaw 00', '1 Febrarary 2003', '30/2/06',
+     '1/2/3/4', '11/22/33', '10/10/990', '189 /1 /9', '12\ f m', 100].each do |value|
+      assert_invalid_and_errors_match /invalid/,  :date_of_birth => value
+    end
+  end
+  
+  def test_date_objects
+    assert_update_and_equal '1963-04-05', :date_of_birth => Date.new(1963, 4, 5)
+  end
+  
+  def test_before_and_after
+    p.update_attributes!(:date_of_death => '1950-01-01')
+    assert_invalid_and_errors_match /before/, :date_of_death => (Date.today + 1).to_s
+    assert_invalid_and_errors_match /before/, :date_of_death => Date.new(2030, 1, 1)
+    
+    p.update_attributes!(:date_of_birth => '1950-01-01', :date_of_death => nil)
+    assert_invalid_and_errors_match /after/, :date_of_death => '1950-01-01'
+    assert p.update_attributes!(:date_of_death => Date.new(1951, 1, 1))
+  end
+  
+  def test_before_and_after_with_custom_message
+    assert_invalid_and_errors_match /avant/, :date_of_arrival => 2.years.from_now, :date_of_departure => 2.years.ago
+    assert_invalid_and_errors_match /apres/, :date_of_arrival => '1792-03-03'
+  end
+
+  def test_before_and_after_with_i18n
+    original_load_path = I18n.load_path
+    
+    I18n.load_path = [File.join(File.dirname(__FILE__),'fixtures/en.yml')]
+    I18n.reload!
+    
+    assert_invalid_and_errors_match /i18n_before/, :date_of_death => (Date.today + 1).to_s
+    assert_invalid_and_errors_match /i18n_after/, :date_of_birth => (Date.today + 1).to_s
+  ensure
+    I18n.load_path = original_load_path
+    I18n.reload!
+  end
+  
+  def test_dates_with_unknown_year
+    assert p.update_attributes!(:date_of_birth => '9999-12-11')
+    assert p.update_attributes!(:date_of_birth => Date.new(9999, 1, 1))
+  end
+  
+  def test_us_date_format
+    with_us_date_format do
+      {'1/31/06'  => '2006-01-31', '28 Feb 01'  => '2001-02-28',
+       '10/10/80' => '1980-10-10', 'July 4 1960' => '1960-07-04',
+       '2006-03-20' => '2006-03-20'}.each do |value, result|
+        assert_update_and_equal result, :date_of_birth => value
+      end
+    end
+  end
+  
+  def test_blank
+    assert p.update_attributes!(:date_of_birth => " ")
+    assert_nil p.date_of_birth
+  end
+  
+  def test_conversion_of_restriction_result
+    assert_invalid_and_errors_match /Date of birth/, :date_of_death => Date.new(2001, 1, 1), :date_of_birth => Date.new(2005, 1, 1)
+  end
+  
+  def test_multi_parameter_attribute_assignment_with_valid_date
+    assert_nothing_raised do
+      p.update_attributes!('date_of_birth(1i)' => '2006', 'date_of_birth(2i)' => '2', 'date_of_birth(3i)' => '10')
+    end
+    
+    assert_equal Date.new(2006, 2, 10), p.date_of_birth
+  end
+  
+  def test_multi_parameter_attribute_assignment_with_invalid_date
+    assert_nothing_raised do
+      assert !p.update_attributes('date_of_birth(1i)' => '2006', 'date_of_birth(2i)' => '2', 'date_of_birth(3i)' => '30')
+    end
+    
+    assert p.errors[:date_of_birth]
+  end
+  
+  def test_incomplete_multi_parameter_attribute_assignment
+    assert_nothing_raised do
+      assert !p.update_attributes('date_of_birth(1i)' => '2006', 'date_of_birth(2i)' => '1', 'date_of_birth(3i)' => '')
+    end
+    
+    assert p.errors[:date_of_birth]
+  end
+end

data/test/date_time_test.rb

@@ -0,0 +1,77 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+
+class DateTimeTest < Test::Unit::TestCase
+  def test_various_formats
+    formats = {
+      '2006-01-01 01:01:01' => /Jan 01 01:01:01 [\+-]?[\w ]+ 2006/,
+      '2/2/06 7pm'          => /Feb 02 19:00:00 [\+-]?[\w ]+ 2006/,
+      '10 AUG 04 6.23am'    => /Aug 10 06:23:00 [\+-]?[\w ]+ 2004/,
+      '6 June 1981 10 10'   => /Jun 06 10:10:00 [\+-]?[\w ]+ 1981/,
+      'September 01, 2007 06:10' => /Sep 01 06:10:00 [\+-]?[\w ]+ 2007/,
+      '2007-02-23T12:03:28' => /Feb 23 12:03:28 [\+-]?[\w ]+ 2007/
+    }
+    
+    formats.each do |value, result|
+      assert_update_and_match result, :date_and_time_of_birth => value
+    end
+    
+    with_us_date_format do
+      formats.each do |value, result|
+        assert_update_and_match result, :date_and_time_of_birth => value
+      end
+    end
+  end
+  
+  def test_date_time_with_microseconds
+    assert_update_and_match /Mar 20 09:22:50 [\+-]?[\w ]+ 2007/, :date_and_time_of_birth => "20 Mar 07 09:22:50.987654"
+    assert_equal 987654, p.date_and_time_of_birth.usec
+  end
+  
+  def test_invalid_formats
+    ['29 Feb 06 1am', '1 Jan 06', '7pm', 6].each do |value|
+      assert_invalid_and_errors_match /date time/, :date_and_time_of_birth => value
+    end
+  end
+  
+  def test_before_and_after_restrictions_parsed_as_date_times    
+    assert_invalid_and_errors_match /before/, :date_and_time_of_birth => '2008-01-02 00:00:00'
+    assert p.update_attributes!(:date_and_time_of_birth => '2008-01-01 01:01:00')
+    
+    assert_invalid_and_errors_match /after/, :date_and_time_of_birth => '1981-01-01 01:00am'
+    assert p.update_attributes!(:date_and_time_of_birth => '1981-01-01 01:02am')
+  end
+  
+  def test_multi_parameter_attribute_assignment_with_valid_date_times
+    assert_nothing_raised do
+      p.update_attributes!('date_and_time_of_birth(1i)' => '2006', 'date_and_time_of_birth(2i)' => '2', 'date_and_time_of_birth(3i)' => '20',
+        'date_and_time_of_birth(4i)' => '23', 'date_and_time_of_birth(5i)' => '10', 'date_and_time_of_birth(6i)' => '40')
+    end
+    
+    assert_equal Time.local(2006, 2, 20, 23, 10, 40), p.date_and_time_of_birth
+    
+    # Without second parameter
+    assert_nothing_raised do
+      p.update_attributes!('date_and_time_of_birth(1i)' => '2004', 'date_and_time_of_birth(2i)' => '3', 'date_and_time_of_birth(3i)' => '14',
+        'date_and_time_of_birth(4i)' => '22', 'date_and_time_of_birth(5i)' => '20')
+    end
+    
+    assert_equal Time.local(2004, 3, 14, 22, 20), p.date_and_time_of_birth
+  end
+  
+  def test_multi_parameter_attribute_assignment_with_invalid_date_time
+    assert_nothing_raised do
+      assert !p.update_attributes('date_and_time_of_birth(1i)' => '2006', 'date_and_time_of_birth(2i)' => '2', 'time_of_birth(3i)' => '10',
+        'date_and_time_of_birth(4i)' => '30', 'date_and_time_of_birth(5i)' => '88', 'date_and_time_of_birth(6i)' => '100')
+    end
+    
+    assert p.errors[:date_and_time_of_birth]
+  end
+  
+  def test_incomplete_multi_parameter_attribute_assignment
+    assert_nothing_raised do
+      assert !p.update_attributes('date_and_time_of_birth(1i)' => '2006', 'date_and_time_of_birth(2i)' => '1')
+    end
+    
+    assert p.errors[:date_and_time_of_birth]
+  end
+end

data/test/fixtures/en.yml

@@ -0,0 +1,12 @@
+en:
+  activerecord:
+    errors:
+      models:
+        person:
+          attributes:
+            date_of_birth:
+              after: 'i18n_after {{value}}'
+              before: 'i18n_before {{value}}'
+            date_of_death:
+              after: 'i18n_after {{value}}'
+              before: 'i18n_before {{value}}'

data/test/fixtures/people.yml

@@ -0,0 +1,4 @@
+jonathan:
+  id: 1
+  required_date: 2006-01-01
+  

data/test/fixtures/person.rb

@@ -0,0 +1,13 @@
+class Person < ActiveRecord::Base
+  validates_date :date_of_birth, :allow_nil => true
+  validates_date :date_of_death, :allow_nil => true, :before => Proc.new { 1.day.from_now }, :after => :date_of_birth
+  
+  validates_date :date_of_arrival, :allow_nil => true, :before => :date_of_departure, :after => '1 Jan 1800', :before_message => "avant %s", :after_message => "apres %s"
+  
+  validates_time :time_of_birth, :allow_nil => true, :before => [Proc.new { Time.now }]
+  validates_time :time_of_death, :allow_nil => true, :after => [:time_of_birth, '7pm'], :before => [Proc.new { 10.years.from_now }]
+  
+  validates_date_time :date_and_time_of_birth, :allow_nil => true, :before => '2008-01-01 01:01:01', :after => '1981-01-01 01:01am'
+  
+  validates_date :required_date
+end

data/test/schema.rb

@@ -0,0 +1,16 @@
+ActiveRecord::Schema.define :version => 0 do
+  create_table :people, :force => true do |t|
+    t.column :date_of_birth,          :date
+    t.column :date_of_death,          :date
+    
+    t.column :date_of_arrival,        :date
+    t.column :date_of_departure,      :date
+  
+    t.column :time_of_birth,          :time
+    t.column :time_of_death,          :time
+    
+    t.column :date_and_time_of_birth, :datetime
+    
+    t.column :required_date,          :date
+  end
+end

data/test/time_test.rb

@@ -0,0 +1,103 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+
+class TimeTest < Test::Unit::TestCase
+  def test_valid_when_nil
+    assert p.update_attributes!(:time_of_birth => nil, :time_of_death => nil, :time_of_death => nil)
+  end
+  
+  def test_with_seconds
+    { '03:45:22' => /03:45:22/, '09:10:27' => /09:10:27/ }.each do |value, result|
+      assert_update_and_match result, :time_of_birth => value
+    end
+  end
+  
+  def test_12_hour_with_minute
+    { '7.20pm' => /19:20:00/, ' 1:33 AM' => /01:33:00/, '11 28am' => /11:28:00/ }.each do |value, result|
+      assert_update_and_match result, :time_of_birth => value
+    end
+  end
+  
+  def test_12_hour_without_minute
+    { '11 am' => /11:00:00/, '7PM ' => /19:00:00/, ' 1Am' => /01:00:00/, '12pm' => /12:00:00/, '12.00pm' => /12:00:00/, '12am' => /00:00:00/ }.each do |value, result|
+      assert_update_and_match result, :time_of_birth => value
+    end
+  end
+  
+  def test_24_hour
+    { '22:00' => /22:00:00/, '10 23' => /10:23:00/, '01 01' => /01:01:00/ }.each do |value, result|
+      assert_update_and_match result, :time_of_birth => value
+    end
+  end
+  
+  def test_24_hour_with_microseconds
+    assert_update_and_match /12:23:56/, :time_of_birth => "12:23:56.169732"
+    assert_equal 169732, p.time_of_birth.usec
+    
+    assert_update_and_match /12:23:56/, :time_of_birth => "12:23:56.15"
+    assert_equal 15, p.time_of_birth.usec
+  end
+  
+  def test_iso8601
+    assert_update_and_match /12:03:28/, :time_of_birth => "2008-02-23T12:03:28"
+  end
+  
+  def test_24_hour_with_invalid_microseconds
+    assert_invalid_and_errors_match /invalid/, :time_of_birth => "12:23:11.1234567"
+  end
+  
+  def test_time_objects
+    { Time.gm(2006, 2, 2, 22, 30) => /22:30:00/, '2pm' => /14:00:00/, Time.gm(2006, 2, 2, 1, 3) => /01:03:00/ }.each do |value, result|
+      assert_update_and_match result, :time_of_birth => value
+    end
+  end
+  
+  def test_invalid_formats
+    ['1 PPM', 'lunchtime', '8..30', 'chocolate', '29am', '18:20 AM', '18:20 PM', 2].each do |value|
+      assert !p.update_attributes(:time_of_birth => value)
+    end
+    assert_match /time/, p.errors[:time_of_birth]
+  end
+  
+  def test_after
+    assert_invalid_and_errors_match /must be after/, :time_of_death => '6pm'
+    
+    assert p.update_attributes!(:time_of_death => '8pm')
+    assert p.update_attributes!(:time_of_death => nil, :time_of_birth => Time.gm(2001, 1, 1, 9))
+    
+    assert_invalid_and_errors_match /must be after/, :time_of_death => '7am'
+  end
+  
+  def test_before
+    assert_invalid_and_errors_match /must be before/, :time_of_birth => Time.now + 1.day
+    assert p.update_attributes!(:time_of_birth => Time.now - 1)
+  end
+  
+  def test_blank
+    assert p.update_attributes!(:time_of_birth => " ")
+    assert_nil p.time_of_birth
+  end
+  
+  def test_multi_parameter_attribute_assignment_with_valid_time
+    assert_nothing_raised do
+      p.update_attributes!('time_of_birth(1i)' => '3', 'time_of_birth(2i)' => '2', 'time_of_birth(3i)' => '10')
+    end
+    
+    assert_equal Time.local(2000, 1, 1, 3, 2, 10), p.time_of_birth
+  end
+  
+  def test_multi_parameter_attribute_assignment_with_invalid_time
+    assert_nothing_raised do
+      assert !p.update_attributes('time_of_birth(1i)' => '23', 'time_of_birth(2i)' => '2', 'time_of_birth(3i)' => '77')
+    end
+    
+    assert p.errors[:time_of_birth]
+  end
+  
+  def test_incomplete_multi_parameter_attribute_assignment
+    assert_nothing_raised do
+      assert !p.update_attributes('time_of_birth(1i)' => '10')
+    end
+    
+    assert p.errors[:time_of_birth]
+  end
+end

data/validates_date_time.gemspec

@@ -0,0 +1,63 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{validates_date_time}
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jonathan Viney", "Nick Stenning"]
+  s.date = %q{2010-04-07}
+  s.description = %q{A Rails plugin that adds an ActiveRecord validation helper to do range and start/end date checking in.}
+  s.email = ["jonathan.viney@gmail.com", "nick@whiteink.com"]
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    "CHANGELOG",
+     "MIT-LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "init.rb",
+     "lib/multiparameter_attributes.rb",
+     "lib/parser.rb",
+     "lib/validates_date_time.rb",
+     "test/abstract_unit.rb",
+     "test/database.yml",
+     "test/date_test.rb",
+     "test/date_time_test.rb",
+     "test/fixtures/en.yml",
+     "test/fixtures/people.yml",
+     "test/fixtures/person.rb",
+     "test/schema.rb",
+     "test/time_test.rb",
+     "validates_date_time.gemspec"
+  ]
+  s.homepage = %q{http://github.com/nickstenning/validates_date_time}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{A Rails plugin adds the ability to validate dates and times with ActiveRecord.}
+  s.test_files = [
+    "test/abstract_unit.rb",
+     "test/date_test.rb",
+     "test/date_time_test.rb",
+     "test/fixtures/person.rb",
+     "test/schema.rb",
+     "test/time_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: validates_date_time
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Jonathan Viney
+- Nick Stenning
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-07 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: A Rails plugin that adds an ActiveRecord validation helper to do range and start/end date checking in.
+email: 
+- jonathan.viney@gmail.com
+- nick@whiteink.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- CHANGELOG
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- init.rb
+- lib/multiparameter_attributes.rb
+- lib/parser.rb
+- lib/validates_date_time.rb
+- test/abstract_unit.rb
+- test/database.yml
+- test/date_test.rb
+- test/date_time_test.rb
+- test/fixtures/en.yml
+- test/fixtures/people.yml
+- test/fixtures/person.rb
+- test/schema.rb
+- test/time_test.rb
+- validates_date_time.gemspec
+has_rdoc: true
+homepage: http://github.com/nickstenning/validates_date_time
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A Rails plugin adds the ability to validate dates and times with ActiveRecord.
+test_files: 
+- test/abstract_unit.rb
+- test/date_test.rb
+- test/date_time_test.rb
+- test/fixtures/person.rb
+- test/schema.rb
+- test/time_test.rb