remove :equal_to deprecation message

this is instead of value before type to avoid issues with partial value parsing
will be extracted in v3

CHANGELOG

@@ -1,3 +1,61 @@
+= 2.3.2 [2010-11-07]
+- Fixed parser for string with timezone offset (thanks sigi)
+- Support for latest I18n interpolation tokens in locale file
+- Fixed parser allowing an hour over 12 for AM meridian
+
+= 2.3.1 [2010-03-19]
+- Fixed bug where custom attribute writer method for date/times were being overriden
+
+= 2.3.0 [2010-02-04]
+- Backwards incompatible change to :equal_to option. Fixed error message clash with :equal_to option which exists in Rails already. Option is now :is_at.
+- Fixed I18n support so it returns missing translation message instead of error
+- Fixed attribute method bug. Write method was bypassed when method was first generated and used Rails default parser.
+- Fixed date/time selects when using enable_datetime_select_extension! when some values empty
+- Fixed ISO8601 datetime format which is now split into two formats
+- Changed I18n error value format to fallback to global default if missing in locale
+- Refactored date/time select invalid value extension to use param values. Functionality will be extracted from plugin for v3.
+
+= 2.2.2 [2009-09-19]
+- Fixed dummy_time using make_time to respect timezone. Fixes 1.9.1 bug.
+
+= 2.2.1 [2009-09-12]
+- Fixed dummy date part for time types in Validator.type_cast_value
+- No more core extensions! Removed dummy_time methods.
+
+= 2.2.0 [2009-09-12]
+- Ruby 1.9 support!
+- Customise dummy date values for time types. See DUMMY DATE FOR TIME TYPES.
+- Fixed matcher conflict with Shoulda. Load plugin matcher manually now see matcher section in README
+- Fixed :ignore_usec when used with :with_time or :with_date
+- Some clean up and refactoring
+
+= 2.1.0 [2009-06-20]
+- Added ambiguous year threshold setting in Formats class to customize the threshold for 2 digit years (See README)
+- Fixed interpolation values in custom error message for Rails 2.2+
+- Fixed custom I18n local override of en locale
+- Dramatically simplified ActiveRecord monkey patching and hackery
+
+= 2.0.0 [2009-04-12]
+- Error value formats are now specified in the i18n locale file instead of updating plugin hash. See OTHER CUSTOMISATION section in README.
+- Date/time select helper extension is disabled by default. To enable see DISPLAY INVALID VALUES IN DATE HELPERS section in README to enable.
+- Added :format option to limit validation to a single format if desired
+- Matcher now supports :equal_to option
+- Formats.parse can take :include_offset option to include offset value from string in seconds, if string contains an offset. Offset not used in rest of plugin yet.
+- Refactored to remove as much plugin code from ActiveRecord as possible.
+
+= 1.1.7 [2009-03-26]
+- Minor change to multiparameter attributes which I had not properly implemented for chaining
+
+= 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
 

README.rdoc

@@ -1,14 +1,14 @@
 = validates_timeliness
 
 * Source:  http://github.com/adzap/validates_timeliness
-* Bugs:    http://adzap.lighthouseapp.com/projects/14111-validates_timeliness
+* Bugs:    http://github.com/adzap/validates_timeliness/issues
 
 == DESCRIPTION:
 
-Validate dates, times and datetimes for Rails 2.x. Plays nicely with new Rails 2.1
-features such as automatic timezone handling and dirty attributes. Allows you to
-add custom formats or remove defaults easily. This allows you to control what you 
-think should be a valid date or time string.
+Validate dates, times and datetimes for Rails 2.x. Plays nicely with Rails
+automatic timezone handling. Allows you to add custom formats or remove defaults
+easily. This allows you to control what you think should be a valid date or
+time string.
 
 
 == FEATURES:
@@ -22,23 +22,26 @@ think should be a valid date or time string.
 * Restores ability to see raw value entered for date/time attributes with
   _before_type_cast modifier, which was lost in Rails 2.1.
 
-* Respects new timezone features of Rails 2.1.
+* Supports Rails timezone handling
 
-* Supports Rails 2.2 I18n for the error messages
+* Supports Rails I18n for the error messages
 
 * Rspec matcher for testing model validation of dates and times
 
 
 == INSTALLATION:
 
-As plugin (from master)
-
-  ./script/plugin git://github.com/adzap/validates_timeliness.git
-
 As gem
 
-  sudo gem install validates_timeliness
+  gem install validates_timeliness -v '~> 2.3'
 
+  # in environment.rb
+
+  config.gem 'validates_timeliness', :version => '~> 2.3'
+
+As plugin (from master)
+
+  ./script/plugin install git://github.com/adzap/validates_timeliness.git -r v2.3
 
 == USAGE:
 
@@ -51,54 +54,59 @@ validation method
   end
 
 The list of validation methods available are as follows:
-
-  * 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_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
 
 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):  
-    :before       - Attribute must be before this value to be valid
-    :on_or_before - Attribute must be equal to or before this value to be valid
-    :after        - Attribute must be after this value 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
+Temporal options (or restrictions):
+  :is_at        - Attribute must be equal to value to be valid
+  :before       - Attribute must be before this value to be valid
+  :on_or_before - Attribute must be equal to or before this value to be valid
+  :after        - Attribute must be after this value 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:  
-    :allow_nil    - Allow a nil value to be valid
-    :allow_blank  - Allows a nil or empty string value to be valid
-    :if           - Execute validation when :if evaluates true
-    :unless       - Execute validation when :unless evaluates false
+Regular validation options:
+  :allow_nil    - Allow a nil value to be valid
+  :allow_blank  - Allows a nil or empty string value to be valid
+  :if           - Execute validation when :if evaluates true
+  :unless       - Execute validation when :unless evaluates false
 
-  Message options: - Use these to override the default error messages
-    :invalid_date_message
-    :invalid_time_message
-    :invalid_datetime_message
-    :before_message
-    :on_or_before_message
-    :after_message
-    :on_or_after_message
-    :between_message
+Special options:
+  :with_time    - Validate a date attribute value combined with a time value against any temporal restrictions
+  :with_date    - Validate a time attribute value combined with a date value against any temporal restrictions
+  :ignore_usec  - Ignores microsecond value on datetime restrictions
+  :format       - Limit validation to a single format for special cases. Takes plugin format value.
 
-The temporal restrictions can take 4 different value types:
+Message options: - Use these to override the default error messages
+  :invalid_date_message
+  :invalid_time_message
+  :invalid_datetime_message
+  :is_at_message
+  :before_message
+  :on_or_before_message
+  :after_message
+  :on_or_after_message
+  :between_message
 
-  * String value
-  * Date, Time, or DateTime object value
-  * Proc or lambda object
-  * A symbol matching the method name in the model  
-  * Between option takes an array of two values or a range
+The temporal restrictions, with_date and with_time can take 4 different value types:
+* String value
+* Date, Time, or DateTime object value
+* Proc or lambda object which may take an optional parameter being the record object
+* A symbol matching the method name in the model
 
 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:
 
-  validates_date :date_of_birth :before => Proc.new { 18.years.ago },
+  validates_date :date_of_birth :before => lambda { 18.years.ago },
                                 :before_message => "must be at least 18 years old"
 
   validates_time :breakfast_time, :on_or_after => '6:00am',
@@ -106,7 +114,9 @@ values are compared as dates.
                                   :before => :second_breakfast_time,
                                   :allow_nil => true
 
-  validates_datetime :appointment_date, :before => Proc.new { 1.week.from_now }
+  validates_datetime :appointment_date, :before => lambda { 1.week.from_now }
+
+  validates_date :entry_date, :with_time => '17:00', :on_or_before => :competition_closing
 
 
 === DATE/TIME FORMATS:
@@ -120,44 +130,44 @@ 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:  
-    hh:nn:ss
-    hh-nn-ss
-    h:nn
-    h.nn
-    h nn
-    h-nn
-    h:nn_ampm
-    h.nn_ampm 
-    h nn_ampm
-    h-nn_ampm
-    h_ampm
+==== Time formats:
+  hh:nn:ss
+  hh-nn-ss
+  h:nn
+  h.nn
+  h nn
+  h-nn
+  h:nn_ampm
+  h.nn_ampm
+  h nn_ampm
+  h-nn_ampm
+  h_ampm
 
-  NOTE: Any time format without a meridian token (the 'ampm' token) is considered 
-        in 24 hour time.
+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
+==== 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
+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
+==== 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:ssZ  # ISO 8601 without zone offset
+  yyyy-mm-ddThh:nn:sszo # ISO 8601 with zone offset
 
-  NOTE: To use non-US date formats see US/EURO FORMATS section
+NOTE: To use non-US date formats see US/EURO FORMATS section
 
 Here is what each format token means:
 
@@ -180,7 +190,7 @@ Here is what each format token means:
 
   Special Cases:
       yy = 2 or 4 digit year
-   yyyyy = exactly 4 digit year
+    yyyy = exactly 4 digit year
      mmm = month long name (e.g. 'Jul' or 'July')
      ddd = Day name of 3 to 9 letters (e.g. Wed or Wednesday)
        u = microseconds matches 1 to 3 digits
@@ -196,7 +206,7 @@ To see all defined formats look in lib/validates_timeliness/formats.rb.
 
 The perenial problem for non-US developers or applications not primarily for the
 US, is the US date format of m/d/yy. This is ambiguous with the European format
-of d/my/yy. By default the plugin uses the US formats as this is the Ruby default
+of d/m/yy. By default the plugin uses the US formats as this is the Ruby default
 when it does date interpretation, and is in keeping PoLS (principle of least
 surprise).
 
@@ -219,7 +229,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,12 +244,37 @@ 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.
 
 
+=== AMBIGUOUS YEAR THRESHOLD
+
+When dealing with 2 digit year values, by default a year is interpreted as being
+in the last century at or above 30. You can customize this however
+
+  ValidatesTimeliness::Formats.ambiguous_year_threshold = 20
+
+Now you get:
+
+  year of 19 is considered 2019
+  year of 20 is considered 1920
+
+
+=== DUMMY DATE FOR TIME TYPES
+
+Given that Ruby has no support for a time-only type, all time type columns are evaluated
+as a regular Time class objects with a dummy date value set. Rails defines the dummy date as
+2000-01-01. So a time of '12:30' is evaluated as a Time value of '2000-01-01 12:30'. If you
+need to customize this for some reason you can do so as follows
+
+  ValidatesTimeliness::Formats.dummy_date_for_time_type = [2009, 1, 1]
+
+The value should be an array of 3 values being year, month and day in that order.
+
+
 === TEMPORAL RESTRICTION ERRORS:
 
 When using the validation temporal restrictions there are times when the restriction
@@ -257,6 +292,21 @@ corner cases a little harder to test. In general if you are using procs or
 model methods and you only care when they return  a value, then they should
 return nil in all other situations. Restrictions are skipped if they are nil.
 
+
+=== DISPLAY INVALID VALUES IN DATE HELPERS:
+
+The plugin has some extensions to ActionView and ActiveRecord by allowing invalid
+date and time values to be redisplayed to the user as feedback, instead of
+a blank field which happens by default in Rails. Though the date helpers make this a
+pretty rare occurence, given the select dropdowns for each date/time component, but
+it may be something of interest.
+
+To activate it, put this in an initializer:
+
+  ValidatesTimeliness.enable_datetime_select_extension!
+
+This will be removed from v3 as it adds too little to maintain.
+
 === OTHER CUSTOMISATION:
 
 The error messages for each temporal restrictions can also be globally overridden by
@@ -268,6 +318,7 @@ For Rails 2.0/2.1:
     :invalid_date     => "is not a valid date",
     :invalid_time     => "is not a valid time",
     :invalid_datetime => "is not a valid datetime",
+    :is_at            => "must be at %s",
     :before           => "must be before %s",
     :on_or_before     => "must be on or before %s",
     :after            => "must be after %s",
@@ -283,8 +334,14 @@ Rails 2.2+ using the I18n system to define new defaults:
     activerecord:
       errors:
         messages:
-          on_or_before: "must be equal to or before {{restriction}}"
-          on_or_after:  "must be equal to or after {{restriction}}"
+          invalid_date: "is not a valid date"
+          invalid_time: "is not a valid time"
+          invalid_datetime: "is not a valid datetime"
+          is_at: "must be at {{restriction}}"
+          before: "must be before {{restriction}}"
+          on_or_before: "must be on or before {{restriction}}"
+          after: "must be after {{restriction}}"
+          on_or_after: "must be on or after {{restriction}}"
           between: "must be between {{earliest}} and {{latest}}"
 
 The {{restriction}} signifies where the interpolation value for the restriction
@@ -293,12 +350,22 @@ will be inserted.
 And for something a little more specific you can override the format of the interpolation
 values inserted in the error messages for temporal restrictions like so
 
+For Rails 2.0/2.1:
+
   ValidatesTimeliness::Validator.error_value_formats.update(
     :time     => '%H:%M:%S',
     :date     => '%Y-%m-%d',
     :datetime => '%Y-%m-%d %H:%M:%S'
   )
 
+Rails 2.2+ using the I18n system to define new defaults:
+
+  validates_timeliness:
+    error_value_formats:
+      date: '%Y-%m-%d'
+      time: '%H:%M:%S'
+      datetime: '%Y-%m-%d %H:%M:%S'
+
 Those are Ruby strftime formats not the plugin formats.
 
 
@@ -308,9 +375,15 @@ To sweeten the deal that little bit more, you have an Rspec matcher available fo
 you model specs. Now you can easily test the validations you have just written
 with the plugin or better yet *before* you write them! You just use the
 validation options you want as you would with the validation method. Those
-options are then verified and reported if they fail. Use it like so:
+options are then verified and reported if they fail.
 
-   @person.should validate_date(:birth_date, :before => Time.now, :before_message => 'should be before today')
+First require it in your spec_helper.rb
+
+  require 'validates_timeliness/matcher'
+
+Use it like so:
+
+  @person.should validate_date(:birth_date, :before => Time.now, :before_message => 'should be before today')
 
 
 The matcher names are just the singular of the validation methods.
@@ -326,4 +399,4 @@ The matcher names are just the singular of the validation methods.
 
 == LICENSE:
 
-Copyright (c) 2008 Adam Meehan, released under the MIT license
+Copyright (c) 2008-2010 Adam Meehan, released under the MIT license

Rakefile

@@ -3,13 +3,10 @@ require 'rake/gempackagetask'
 require 'rubygems/specification'
 require 'date'
 require 'spec/rake/spectask'
+require 'lib/validates_timeliness/version'
 
 GEM = "validates_timeliness"
-GEM_VERSION = "1.1.5"
-AUTHOR = "Adam Meehan"
-EMAIL = "adam.meehan@gmail.com"
-HOMEPAGE = "http://github.com/adzap/validates_timeliness"
-SUMMARY = "Date and time validation plugin for Rails 2.x which allows custom formats"
+GEM_VERSION = ValidatesTimeliness::VERSION
 
 spec = Gem::Specification.new do |s|
   s.name = GEM
@@ -18,14 +15,11 @@ spec = Gem::Specification.new do |s|
   s.rubyforge_project = "validatestime"
   s.has_rdoc = true
   s.extra_rdoc_files = ["README.rdoc", "LICENSE", "TODO", "CHANGELOG"]
-  s.summary = SUMMARY
+  s.summary = "Date and time validation plugin for Rails 2.x which allows custom formats"
   s.description = s.summary
-  s.author = AUTHOR
-  s.email = EMAIL
-  s.homepage = HOMEPAGE
-  
-  # Uncomment this to add a dependency
-  # s.add_dependency "foo"
+  s.author = "Adam Meehan"
+  s.email = "adam.meehan@gmail.com"
+  s.homepage = "http://github.com/adzap/validates_timeliness"
 
   s.require_path = 'lib'
   s.autorequire = GEM
@@ -37,7 +31,7 @@ task :default => :spec
 desc "Run specs"
 Spec::Rake::SpecTask.new do |t|
   t.spec_files = FileList['spec/**/*_spec.rb']
-  t.spec_opts = %w(-fs --color)
+  t.spec_opts = %w(--color)
 end
 
 

TODO

@@ -1,4 +1,8 @@
-- :format option
-- :with_date and :with_time options
 - valid formats could come from locale file
 - add replace_formats instead add_formats :before
+- array of values for all temporal options
+- use tz and zo value from time string?
+- filter valid formats rather than remove for hot swapping without recompilation
+- config generator
+- move all config into top namespace
+- remove action_view stuff

benchmark.rb

@@ -4,73 +4,74 @@ require 'date'
 require 'parsedate'
 require 'benchmark'
 require 'rubygems'
-require 'active_support'
 require 'active_record'
-require 'action_controller'
-require 'rails/version'
 
 require 'validates_timeliness'
 
+def parse(*args)
+  ValidatesTimeliness::Parser.parse(*args) 
+end
+
 n = 10000
 Benchmark.bm do |x|
   x.report('timeliness - datetime') { 
     n.times do
-      ActiveRecord::Base.parse_date_time("2000-01-04 12:12:12", :datetime)
+      parse("2000-01-04 12:12:12", :datetime)
     end 
   }
 
   x.report('timeliness - date') { 
     n.times do
-      ActiveRecord::Base.parse_date_time("2000-01-04", :date)
+      parse("2000-01-04", :date)
     end 
   }
   
   x.report('timeliness - date as datetime') { 
     n.times do
-      ActiveRecord::Base.parse_date_time("2000-01-04", :datetime)
+      parse("2000-01-04", :datetime)
     end 
   }
 
   x.report('timeliness - time') { 
     n.times do
-      ActiveRecord::Base.parse_date_time("12:01:02", :time)
+      parse("12:01:02", :time)
     end 
   }
   
   x.report('timeliness - invalid format datetime') { 
     n.times do
-      ActiveRecord::Base.parse_date_time("20xx-01-04 12:12:12", :datetime)
+      parse("20xx-01-04 12:12:12", :datetime)
     end 
   }
 
   x.report('timeliness - invalid format date') { 
     n.times do
-      ActiveRecord::Base.parse_date_time("20xx-01-04", :date)
+      parse("20xx-01-04", :date)
     end 
   }
 
   x.report('timeliness - invalid format time') { 
     n.times do
-      ActiveRecord::Base.parse_date_time("12:xx:02", :time)
+      parse("12:xx:02", :time)
     end 
   }
   
 
   x.report('timeliness - invalid value datetime') { 
     n.times do
-      ActiveRecord::Base.parse_date_time("2000-01-32 12:12:12", :datetime)
+      parse("2000-01-32 12:12:12", :datetime)
     end 
   }
 
   x.report('timeliness - invalid value date') { 
     n.times do
-      ActiveRecord::Base.parse_date_time("2000-01-32", :date)
+      parse("2000-01-32", :date)
     end 
   }
 
   x.report('timeliness - invalid value time') {
     n.times do
-      ActiveRecord::Base.parse_date_time("12:61:02", :time)
+      parse("12:61:02", :time)
     end 
   }
   x.report('date/time') { 
@@ -96,4 +97,3 @@ Benchmark.bm do |x|
     end 
   }
 end
-

lib/validates_timeliness.rb

@@ -1,66 +1,59 @@
 require 'validates_timeliness/formats'
+require 'validates_timeliness/parser'
 require 'validates_timeliness/validator'
 require 'validates_timeliness/validation_methods'
-require 'validates_timeliness/spec/rails/matchers/validate_timeliness' if ENV['RAILS_ENV'] == 'test'
-
 require 'validates_timeliness/active_record/attribute_methods'
 require 'validates_timeliness/active_record/multiparameter_attributes'
 require 'validates_timeliness/action_view/instance_tag'
-
-require 'validates_timeliness/core_ext/time'
-require 'validates_timeliness/core_ext/date'
-require 'validates_timeliness/core_ext/date_time'
+begin
+  i18n_path = $:.grep(/active_support\/vendor\/i18n-/)
+  if i18n_path.empty?
+    require 'i18n/version'
+  else
+    require i18n_path[0] + '/version'
+  end
+rescue LoadError
+end if defined?(I18n)
 
 module ValidatesTimeliness
 
   mattr_accessor :default_timezone
-
   self.default_timezone = :utc
 
-  LOCALE_PATH = File.expand_path(File.dirname(__FILE__) + '/validates_timeliness/locale/en.yml')
+  mattr_accessor :use_time_zones
+  self.use_time_zones = false
+
+  I18N_LATEST = defined?(I18n::VERSION) && I18n::VERSION >= '0.4.0'
+  locale_file = I18N_LATEST ? 'en.new.yml' : 'en.old.yml'
+  LOCALE_PATH = File.expand_path(File.join(File.dirname(__FILE__),'validates_timeliness','locale',locale_file))
 
   class << self
 
-    def load_error_messages_with_i18n
-      I18n.load_path += [ LOCALE_PATH ]
+    def enable_datetime_select_extension!
+      enable_datetime_select_invalid_value_extension!
+      enable_multiparameter_attributes_extension!
     end
 
-    def load_error_messages_without_i18n
-      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
+    def load_error_messages
+      defaults = YAML::load(IO.read(LOCALE_PATH))['en']
+      ValidatesTimeliness::Validator.error_value_formats = defaults['validates_timeliness']['error_value_formats'].symbolize_keys
 
-    def default_error_messages
-      if Rails::VERSION::STRING < '2.2'
-        ::ActiveRecord::Errors.default_error_messages
+      if defined?(I18n)
+        I18n.load_path.unshift(LOCALE_PATH)
+        I18n.reload!
       else
-        I18n.translate('activerecord.errors.messages')
+        errors = defaults['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 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.default_timezone = ::ActiveRecord::Base.default_timezone
-      self.send("setup_for_rails_#{major}_#{minor}")
-    rescue
-      puts "Rails version #{major}.#{minor}.x not explicitly supported by validates_timeliness plugin. You may encounter some problems."
+      self.use_time_zones = ::ActiveRecord::Base.time_zone_aware_attributes rescue false
+      self.enable_active_record_datetime_parser!
+      load_error_messages
     end
   end
 end
 
 ValidatesTimeliness.setup_for_rails
-
-ValidatesTimeliness::Formats.compile_format_expressions

lib/validates_timeliness/action_view/instance_tag.rb

@@ -1,14 +1,21 @@
+# TODO remove this from the plugin for v3.
 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 
-    # attribute value before type cast to be used as in the select helpers.
-    # This means that an invalid date or time will be redisplayed rather than the
-    # type cast value which would be nil if invalid.
+    # Intercepts the date and time select helpers to reuse the values from the
+    # the params rather than the parsed value. This allows invalid date/time
+    # values to be redisplayed instead of blanks to aid correction by the user.
+    # Its a minor usability improvement which is rarely an issue for the user.
+    #
     module InstanceTag
 
       def self.included(base)
-        selector_method = Rails::VERSION::STRING < '2.2' ? :date_or_time_select : :datetime_selector
+        selector_method = Rails::VERSION::STRING.to_f < 2.2 ? :date_or_time_select : :datetime_selector
         base.class_eval do
           alias_method :datetime_selector_without_timeliness, selector_method
           alias_method selector_method, :datetime_selector_with_timeliness
@@ -24,22 +31,22 @@ module ValidatesTimeliness
       end
 
       def value_with_timeliness(object)
-        return value_without_timeliness(object) unless @timeliness_date_or_time_tag
-        
-        raw_value = value_before_type_cast(object)
-        
-        if raw_value.nil? || raw_value.acts_like?(:time) || raw_value.is_a?(Date)
+        unless @timeliness_date_or_time_tag && @template_object.params[@object_name]
           return value_without_timeliness(object)
         end
 
-        time_array = ParseDate.parsedate(raw_value)
+        pairs = @template_object.params[@object_name].select {|k,v| k =~ /^#{@method_name}\(/ }
+        return value_without_timeliness(object) if pairs.empty?
 
-        TimelinessDateTime.new(*time_array[0..5])
+        values = pairs.map do |(param, value)|
+          position = param.scan(/\(([0-9]*).*\)/).first.first
+          [position, value]
+        end.sort {|a,b| a[0] <=> b[0] }.map {|v| v[1] }
+
+        TimelinessDateTime.new(*values)
       end
 
     end
 
   end
 end
-
-ActionView::Helpers::InstanceTag.send(:include, ValidatesTimeliness::ActionView::InstanceTag)

lib/validates_timeliness/active_record/attribute_methods.rb

@@ -1,137 +1,72 @@
 module ValidatesTimeliness
+
+  def self.enable_active_record_datetime_parser!
+    ::ActiveRecord::Base.send(:include, ValidatesTimeliness::ActiveRecord::AttributeMethods)
+  end
+
   module ActiveRecord
 
-    # Rails 2.1 removed the ability to retrieve the raw value of a time or datetime
-    # attribute. The raw value is necessary to properly validate a string time or 
-    # datetime value instead of the internal Rails type casting which is very limited 
-    # and does not allow custom formats. These methods restore that ability while 
-    # respecting the automatic timezone handling.
+    # Overrides write method for date, time and datetime columns
+    # to use plugin parser. Also adds mechanism to store value
+    # before type cast.
     #
-    # The automatic timezone handling sets the assigned attribute value to the current
-    # zone in Time.zone. To preserve this localised value and capture the raw value 
-    # we cache the localised value on write and store the raw value in the attributes
-    # hash for later retrieval and possibly validation. Any value from the database
-    # will not be in the attribute cache on first read so will be considered in default
-    # timezone and converted to local time. It is then stored back in the attributes
-    # hash and cached to avoid the need for any subsequent differentiation.
     module AttributeMethods
 
       def self.included(base)
         base.extend ClassMethods
-      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)
-        attr_name = attr_name.to_s
-        if !(value = @attributes[attr_name]).nil?
-          if column = column_for_attribute(attr_name)
-            if unserializable_attribute?(attr_name, column)
-              unserialize_attribute(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
+        base.class_eval do
+          alias_method_chain :read_attribute_before_type_cast, :timeliness
+          class << self
+            alias_method_chain :define_attribute_methods, :timeliness
           end
-        else
-          nil
         end
       end
 
-      # If Rails dirty attributes is enabled then the value is added to
-      # changed attributes if changed. Can't use the default dirty checking
-      # 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)
+        @attributes_cache["_#{attr_name}_before_type_cast"] = value
+        value = ValidatesTimeliness::Parser.parse(value, type)
 
-        unless type == :date || new.nil?
-          new = new.to_time rescue new
+        if value && type != :date
+          value = value.to_time
+          value = value.in_time_zone if time_zone_aware
         end
 
-        new = new.in_time_zone if new && time_zone_aware
-        @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
+        write_attribute(attr_name.to_sym, value)
       end
 
-      # If reloading then check if cached, which means its in local time.
-      # If local, convert with parser as local timezone, otherwise use 
-      # read_attribute method for quick default type cast of values from
-      # database using default timezone.
-      def read_date_time_attribute(attr_name, type, time_zone_aware, reload = false)
-        cached = @attributes_cache[attr_name]
-        return cached if @attributes_cache.has_key?(attr_name) && !reload
-
-        if @attributes_cache.has_key?(attr_name)
-          time = read_attribute_before_type_cast(attr_name)
-          time = self.class.parse_date_time(date, type)
-        else
-          time = read_attribute(attr_name)
-          @attributes[attr_name] = time && time_zone_aware ? time.in_time_zone : time
-        end
-        @attributes_cache[attr_name] = time && time_zone_aware ? time.in_time_zone : time
+      def read_attribute_before_type_cast_with_timeliness(attr_name)
+        cached_attr = "_#{attr_name}_before_type_cast"
+        return @attributes_cache[cached_attr] if @attributes_cache.has_key?(cached_attr)
+        read_attribute_before_type_cast_without_timeliness(attr_name)
       end
 
       module ClassMethods
 
-        # Override AR method to define attribute reader and writer method for
-        # date, time and datetime attributes to use plugin parser.
-        def define_attribute_methods
+        def define_attribute_methods_with_timeliness
           return if generated_methods?
+          timeliness_methods = []
+
           columns_hash.each do |name, column|
-            unless instance_method_already_implemented?(name)
-              if self.serialized_attributes[name]
-                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
+            if [:date, :time, :datetime].include?(column.type)
+              method_name = "#{name}="
+              next if instance_method_already_implemented?(method_name)
 
-            unless instance_method_already_implemented?("#{name}=")
-              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)
+              time_zone_aware = create_time_zone_conversion_attribute?(name, column) rescue false
+              define_method(method_name) do |value|
+                 write_date_time_attribute(name, value, column.type, time_zone_aware)
               end
-            end
-
-            unless instance_method_already_implemented?("#{name}?")
-              define_question_method(name)
+              timeliness_methods << method_name
             end
           end
-        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})
-            end
-          EOV
-          evaluate_attribute_method attr_name, method_body, "#{attr_name}="
-        end
+          # Hack to get around instance_method_already_implemented? caching the
+          # methods in the ivar. It then appears to subsequent calls that the
+          # methods defined here, have not been and get defined again.
+          @_defined_class_methods = nil
 
-        def define_read_method_for_dates_and_times(attr_name, type, time_zone_aware)
-          method_body = <<-EOV
-            def #{attr_name}(reload = false)
-              read_date_time_attribute('#{attr_name}', #{type.inspect}, #{time_zone_aware}, reload)
-            end
-          EOV
-          evaluate_attribute_method attr_name, method_body
+          define_attribute_methods_without_timeliness
+          # add generated methods which is a Set object hence no += method
+          timeliness_methods.each {|attr| generated_methods << attr }
         end
 
       end
@@ -140,5 +75,3 @@ module ValidatesTimeliness
 
   end
 end
-
-ActiveRecord::Base.send(:include, ValidatesTimeliness::ActiveRecord::AttributeMethods)

lib/validates_timeliness/active_record/multiparameter_attributes.rb

@@ -1,29 +1,57 @@
 module ValidatesTimeliness
+
+  def self.enable_multiparameter_attributes_extension!
+    ::ActiveRecord::Base.send(:include, ValidatesTimeliness::ActiveRecord::MultiparameterAttributes)
+  end
+
   module ActiveRecord
 
+    class << self
+
+      def time_array_to_string(values, type)
+        values.collect! {|v| v.to_s }
+
+        case type
+        when :date
+          extract_date_from_multiparameter_attributes(values)
+        when :time
+          extract_time_from_multiparameter_attributes(values)
+        when :datetime
+          extract_date_from_multiparameter_attributes(values) + " " + extract_time_from_multiparameter_attributes(values)
+        end
+      end
+
+      def extract_date_from_multiparameter_attributes(values)
+        year = values[0].blank? ? nil : ValidatesTimeliness::Formats.unambiguous_year(values[0].rjust(2, "0"))
+        [year, *values.slice(1, 2).map { |s| s.blank? ? nil : s.rjust(2, "0") }].join("-")
+      end
+
+      def extract_time_from_multiparameter_attributes(values)
+        values[3..5].map { |s| s.blank? ? nil : s.rjust(2, "0") }.join(":")
+      end
+
+    end
+
     module MultiparameterAttributes
 
       def self.included(base)
         base.alias_method_chain :execute_callstack_for_multiparameter_attributes, :timeliness
       end
 
-      # Overrides AR method to store multiparameter time and dates as string
-      # allowing validation later.
+      # Assign dates and times as formatted strings to force the use of the plugin parser
       def execute_callstack_for_multiparameter_attributes_with_timeliness(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)
+          column = column_for_attribute(name)
+          if column && [:date, :time, :datetime].include?(column.type)
             begin
-              value = if [:date, :time, :datetime].include?(column.type)
-                time_array_to_string(values, column.type)  
+              callstack.delete(name)
+              if values.empty? || values.all?(&:nil?)
+                send("#{name}=", nil)
               else
-                klass.new(*values)
+                value = ValidatesTimeliness::ActiveRecord.time_array_to_string(values, column.type)
+                send("#{name}=", value)
               end
-              send(name + "=", value)
             rescue => ex
               errors << ::ActiveRecord::AttributeAssignmentError.new("error on assignment #{values.inspect} to #{name}", ex, name)
             end
@@ -32,33 +60,10 @@ module ValidatesTimeliness
         unless errors.empty?
           raise ::ActiveRecord::MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes"
         end
-      end
-      
-      def time_array_to_string(values, type)
-        values = values.map(&:to_s)
-                
-        case 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
-      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(":")
+        execute_callstack_for_multiparameter_attributes_without_timeliness(callstack)
       end
 
     end
 
   end
 end
-
-ActiveRecord::Base.send(:include, ValidatesTimeliness::ActiveRecord::MultiparameterAttributes)

lib/validates_timeliness/core_ext/date.rb

@@ -1,13 +0,0 @@
-module ValidatesTimeliness
-  module CoreExtensions
-    module Date
-    
-      def to_dummy_time
-        ::Time.send(ValidatesTimeliness.default_timezone, 2000, 1, 1, 0, 0, 0)
-      end
-
-    end
-  end
-end
-
-Date.send(:include, ValidatesTimeliness::CoreExtensions::Date)

lib/validates_timeliness/core_ext/date_time.rb

@@ -1,13 +0,0 @@
-module ValidatesTimeliness
-  module CoreExtensions
-    module DateTime
-
-      def to_dummy_time
-        ::Time.send(ValidatesTimeliness.default_timezone, 2000, 1, 1, hour, min, sec)
-      end
-
-    end
-  end
-end
-
-DateTime.send(:include, ValidatesTimeliness::CoreExtensions::DateTime)

lib/validates_timeliness/core_ext/time.rb

@@ -1,13 +0,0 @@
-module ValidatesTimeliness
-  module CoreExtensions
-    module Time 
-
-      def to_dummy_time
-        self.class.send(ValidatesTimeliness.default_timezone, 2000, 1, 1, hour, min, sec) 
-      end
-
-    end
-  end
-end
-
-Time.send(:include, ValidatesTimeliness::CoreExtensions::Time)

lib/validates_timeliness/formats.rb

@@ -2,11 +2,9 @@ require 'date'
 
 module ValidatesTimeliness
 
-  # A date and time format regular expression generator. Allows you to 
-  # construct a date, time or datetime format using predefined tokens in 
-  # a string. This makes it much easier to catalogue and customize the formats
-  # rather than dealing directly with regular expressions. The formats are then
-  # compiled into regular expressions for use validating date or time strings. 
+  # A date and time parsing library which allows you to add custom formats using
+  # simple predefined tokens. This makes it much easier to catalogue and customize
+  # the formats rather than dealing directly with regular expressions.
   #
   # Formats can be added or removed to customize the set of valid date or time
   # string values.
@@ -21,6 +19,26 @@ module ValidatesTimeliness
                    :format_tokens,
                    :format_proc_args
 
+
+    # Set the threshold value for a two digit year to be considered last century
+    #
+    # Default: 30
+    #
+    #   Example:
+    #     year = '29' is considered 2029
+    #     year = '30' is considered 1930
+    #
+    cattr_accessor :ambiguous_year_threshold
+    self.ambiguous_year_threshold = 30
+
+    # Set the dummy date part for a time type value. Should be an array of 3 values
+    # being year, month and day in that order.
+    #
+    # Default: [ 2000, 1, 1 ] same as ActiveRecord
+    #
+    cattr_accessor :dummy_date_for_time_type
+    self.dummy_date_for_time_type = [ 2000, 1, 1 ]
+
     # Format tokens:
     #       y = year
     #       m = month
@@ -46,7 +64,7 @@ module ValidatesTimeliness
     #
     # Special Cases:
     #      yy = 2 or 4 digit year
-    #   yyyyy = exactly 4 digit year
+    #    yyyy = exactly 4 digit year
     #     mmm = month long name (e.g. 'Jul' or 'July')
     #     ddd = Day name of 3 to 9 letters (e.g. Wed or Wednesday)
     #       u = microseconds matches 1 to 6 digits
@@ -85,6 +103,7 @@ module ValidatesTimeliness
     @@datetime_formats = [
       'yyyy-mm-dd hh:nn:ss',
       'yyyy-mm-dd h:nn',
+      'yyyy-mm-dd h:nn_ampm',
       'yyyy-mm-dd hh:nn:ss.u',
       'm/d/yy h:nn:ss',
       'm/d/yy h:nn_ampm',
@@ -94,7 +113,8 @@ module ValidatesTimeliness
       'd/m/yy h:nn',
       'ddd, dd mmm yyyy hh:nn:ss (zo|tz)', # RFC 822
       'ddd mmm d hh:nn:ss zo yyyy', # Ruby time string
-      'yyyy-mm-ddThh:nn:ss(?:Z|zo)' # iso 8601
+      'yyyy-mm-ddThh:nn:ssZ', # iso 8601 without zone offset
+      'yyyy-mm-ddThh:nn:sszo' # iso 8601 with zone offset
     ]
 
 
@@ -124,13 +144,13 @@ module ValidatesTimeliness
       { 's'    => [ /s{1}/,  '(\d{1,2})', :sec ] },
       { 'u'    => [ /u{1,}/, '(\d{1,6})', :usec ] },
       { 'ampm' => [ /ampm/,  '((?:[aApP])\.?[mM]\.?)', :meridian ] },
-      { 'zo'   => [ /zo/,    '(?:[+-]\d{2}:?\d{2})'] },
+      { 'zo'   => [ /zo/,    '([+-]\d{2}:?\d{2})', :offset ] },
       { 'tz'   => [ /tz/,    '(?:[A-Z]{1,4})' ] },
       { '_'    => [ /_/,     '\s?' ] }
     ]
 
-    # Arguments whichs will be passed to the format proc if matched in the 
-    # time string. The key must should the key from the format tokens. The array 
+    # Arguments which will be passed to the format proc if matched in the
+    # time string. The key must be the key from the format tokens. The array
     # consists of the arry position of the arg, the arg name, and the code to
     # place in the time array slot. The position can be nil which means the arg
     # won't be placed in the array.
@@ -146,6 +166,7 @@ module ValidatesTimeliness
       :min      => [4,   'n', 'n'],
       :sec      => [5,   's', 's'],
       :usec     => [6,   'u', 'microseconds(u)'],
+      :offset   => [7,   'z', 'offset_in_seconds(z)'],
       :meridian => [nil, 'md', nil]
     }
 
@@ -160,21 +181,36 @@ module ValidatesTimeliness
       # Loop through format expressions for type and call proc on matches. Allow
       # pre or post match strings to exist if strict is false. Otherwise wrap
       # regexp in start and end anchors.
-      # Returns 7 part time array.
-      def parse(string, type, strict=true)
+      # Returns time array if matches a format, nil otherwise.
+      def parse(string, type, options={})
         return string unless string.is_a?(String)
+        options.reverse_merge!(:strict => true)
+
+        sets = if options[:format]
+          options[:strict] = true
+          [ send("#{type}_expressions").assoc(options[:format]) ]
+        else
+          expression_set(type, string)
+        end
 
         matches = nil
-        exp, processor = expression_set(type, string).find do |regexp, proc|
-          full = /\A#{regexp}\Z/ if strict
+        processor = sets.each do |format, regexp, proc|
+          full = /\A#{regexp}\Z/ if options[:strict]
           full ||= case type
-            when :datetime then /\A#{regexp}\Z/
-            when :date     then /\A#{regexp}/
-            else                /#{regexp}\Z/
+          when :date     then /\A#{regexp}/
+          when :time     then /#{regexp}\Z/
+          when :datetime then /\A#{regexp}\Z/
           end
-          matches = full.match(string.strip)
+          break(proc) if matches = full.match(string.strip)
         end
-        processor.call(*matches[1..7]) if matches
+        last = options[:include_offset] ? 8 : 7
+        if matches
+          values = processor.call(*matches[1..last])
+          values[0..2] = dummy_date_for_time_type if type == :time
+          return values
+        end
+      rescue
+        nil
       end
 
       # Delete formats of specified type. Error raised if format not found.
@@ -207,7 +243,6 @@ module ValidatesTimeliness
         compile_format_expressions
       end
 
-      
       # Removes formats where the 1 or 2 digit month comes first, to eliminate
       # formats which are ambiguous with the European style of day then month.
       # The mmm token is ignored as its not ambigous.
@@ -218,10 +253,54 @@ module ValidatesTimeliness
         compile_format_expressions
       end
 
+      def full_hour(hour, meridian)
+        hour = hour.to_i
+        return hour if meridian.nil?
+        if meridian.delete('.').downcase == 'am'
+          raise if hour == 0 || hour > 12
+          hour == 12 ? 0 : hour
+        else
+          hour == 12 ? hour : hour + 12
+        end
+      end
+
+      def unambiguous_year(year)
+        if year.length <= 2
+          century = Time.now.year.to_s[0..1].to_i
+          century -= 1 if year.to_i >= ambiguous_year_threshold
+          year = "#{century}#{year.rjust(2,'0')}"
+        end
+        year.to_i
+      end
+
+      def month_index(month)
+        return month.to_i if month.to_i.nonzero?
+        abbr_month_names.index(month.capitalize) || month_names.index(month.capitalize)
+      end
+
+      def month_names
+        defined?(I18n) ? I18n.t('date.month_names') : Date::MONTHNAMES
+      end
+
+      def abbr_month_names
+        defined?(I18n) ? I18n.t('date.abbr_month_names') : Date::ABBR_MONTHNAMES
+      end
+
+      def microseconds(usec)
+        (".#{usec}".to_f * 1_000_000).to_i
+      end
+
+      def offset_in_seconds(offset)
+        sign = offset =~ /^-/ ? -1 : 1
+        parts = offset.scan(/\d\d/).map {|p| p.to_f }
+        parts[1] = parts[1].to_f / 60
+        (parts[0] + parts[1]) * sign * 3600
+      end
+
     private
 
-      # Compile formats into validation regexps and format procs    
-      def format_expression_generator(string_format)
+      # Generate regular expression and processor from format string
+      def generate_format_expression(string_format)
         regexp = string_format.dup
         order  = {}
         regexp.gsub!(/([\.\\])/, '\\\\\1') # escapes dots and backslashes
@@ -246,73 +325,44 @@ module ValidatesTimeliness
       # argument in the position indicated by the first element of the proc arg
       # array.
       #
-      # Examples:
-      #
-      #   'yyyy-mm-dd hh:nn'     => lambda {|y,m,d,h,n| md||=0; [unambiguous_year(y),month_index(m),d,full_hour(h,md),n,nil,nil].map {|i| i.to_i } }
-      #   'dd/mm/yyyy h:nn_ampm' => lambda {|d,m,y,h,n,md| md||=0; [unambiguous_year(y),month_index(m),d,full_hour(h,md),n,nil,nil].map {|i| i.to_i } }
-      #
       def format_proc(order)
         arg_map = format_proc_args
         args = order.invert.sort.map {|p| arg_map[p[1]][1] }
         arr = [nil] * 7
         order.keys.each {|k| i = arg_map[k][0]; arr[i] = arg_map[k][2] unless i.nil? }
-        proc_string = "lambda {|#{args.join(',')}| md||=nil; [#{arr.map {|i| i.nil? ? 'nil' : i }.join(',')}].map {|i| i.to_i } }"
+        proc_string = <<-EOL
+          lambda {|#{args.join(',')}|
+              md ||= nil
+              [#{arr.map {|i| i.nil? ? 'nil' : i }.join(',')}].map {|i| i.is_a?(Float) ? i : i.to_i }
+          }
+        EOL
         eval proc_string
       end
 
       def compile_formats(formats)
-        formats.map { |format| regexp, format_proc = format_expression_generator(format) }
+        formats.map { |format| [ format, *generate_format_expression(format) ] }
       end
 
       # Pick expression set and combine date and datetimes for
       # datetime attributes to allow date string as datetime
       def expression_set(type, string)
         case type
-          when :date
-            date_expressions
-          when :time
-            time_expressions
-          when :datetime
-            # gives a speed-up for date string as datetime attributes
-            if string.length < 11
-              date_expressions + datetime_expressions
-            else
-              datetime_expressions + date_expressions
-            end
+        when :date
+          date_expressions
+        when :time
+          time_expressions
+        when :datetime
+          # gives a speed-up for date string as datetime attributes
+          if string.length < 11
+            date_expressions + datetime_expressions
+          else
+            datetime_expressions + date_expressions
+          end
         end
       end
 
-      def full_hour(hour, meridian)
-        hour = hour.to_i
-        return hour if meridian.nil?
-        if meridian.delete('.').downcase == 'am'
-          hour == 12 ? 0 : hour
-        else
-          hour == 12 ? hour : hour + 12
-        end
-      end
-      
-      def unambiguous_year(year, threshold=30)
-        year = "#{year.to_i < threshold ? '20' : '19'}#{year}" if year.length == 2
-        year.to_i
-      end
-      
-      def month_index(month)
-        return month.to_i if month.to_i.nonzero?
-        abbr_month_names.index(month.capitalize) || month_names.index(month.capitalize)
-      end
-
-      def month_names
-        defined?(I18n) ? I18n.t('date.month_names') : Date::MONTHNAMES
-      end
-
-      def abbr_month_names
-        defined?(I18n) ? I18n.t('date.abbr_month_names') : Date::ABBR_MONTHNAMES
-      end
-
-      def microseconds(usec)
-        (".#{usec}".to_f * 1_000_000).to_i
-      end
     end
   end
 end
+
+ValidatesTimeliness::Formats.compile_format_expressions

lib/validates_timeliness/locale/en.new.yml

@@ -0,0 +1,18 @@
+en:
+  activerecord:
+    errors:
+      messages:
+        invalid_date: "is not a valid date"
+        invalid_time: "is not a valid time"
+        invalid_datetime: "is not a valid datetime"
+        is_at: "must be at %{restriction}"
+        before: "must be before %{restriction}"
+        on_or_before: "must be on or before %{restriction}"
+        after: "must be after %{restriction}"
+        on_or_after: "must be on or after %{restriction}"
+        between: "must be between %{earliest} and %{latest}"
+  validates_timeliness:
+    error_value_formats:
+      date: '%Y-%m-%d'
+      time: '%H:%M:%S'
+      datetime: '%Y-%m-%d %H:%M:%S'

lib/validates_timeliness/locale/en.old.yml

@@ -5,8 +5,14 @@ en:
         invalid_date: "is not a valid date"
         invalid_time: "is not a valid time"
         invalid_datetime: "is not a valid datetime"
+        is_at: "must be at {{restriction}}"
         before: "must be before {{restriction}}"
         on_or_before: "must be on or before {{restriction}}"
         after: "must be after {{restriction}}"
         on_or_after: "must be on or after {{restriction}}"
         between: "must be between {{earliest}} and {{latest}}"
+  validates_timeliness:
+    error_value_formats:
+      date: '%Y-%m-%d'
+      time: '%H:%M:%S'
+      datetime: '%Y-%m-%d %H:%M:%S'

lib/validates_timeliness/matcher.rb

@@ -0,0 +1 @@
+require 'validates_timeliness/spec/rails/matchers/validate_timeliness'

lib/validates_timeliness/parser.rb

@@ -0,0 +1,44 @@
+module ValidatesTimeliness
+  module Parser
+
+    class << self
+
+      def parse(raw_value, type, options={})
+        return nil if raw_value.blank?
+        return raw_value if raw_value.acts_like?(:time) || raw_value.is_a?(Date)
+        
+        time_array = ValidatesTimeliness::Formats.parse(raw_value, type, options.reverse_merge(:strict => true))
+        return nil if time_array.nil?
+        
+        if type == :date
+          Date.new(*time_array[0..2]) rescue nil
+        else
+          make_time(time_array[0..6])
+        end
+      end
+
+      def make_time(time_array)
+        # Enforce date part validity which Time class does not
+        return nil unless Date.valid_civil?(*time_array[0..2])
+
+        if Time.respond_to?(:zone) && ValidatesTimeliness.use_time_zones
+          Time.zone.local(*time_array)
+        else
+          # Older AR way of handling times with datetime fallback
+          begin
+            time_zone = ValidatesTimeliness.default_timezone
+            Time.send(time_zone, *time_array)
+          rescue ArgumentError, TypeError
+            zone_offset = time_zone == :local ? DateTime.local_offset : 0
+            time_array.pop # remove microseconds
+            DateTime.civil(*(time_array << zone_offset))
+          end
+        end
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+    end
+
+  end
+end

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

@@ -10,6 +10,7 @@ module Spec
         }
 
         OPTION_TEST_SETTINGS = {
+          :is_at        => { :method => :+, :modify_on => :invalid },
           :before       => { :method => :-, :modify_on => :valid },
           :after        => { :method => :+, :modify_on => :valid },
           :on_or_before => { :method => :+, :modify_on => :invalid },
@@ -27,13 +28,12 @@ module Spec
 
           valid = test_validity
 
-          valid = test_option(:before) if @options[:before] && valid
-          valid = test_option(:after) if @options[:after] && valid
-          
-          valid = test_option(:on_or_before) if @options[:on_or_before] && valid
-          valid = test_option(:on_or_after) if @options[:on_or_after] && valid
-
-          valid = test_between if @options[:between] && valid
+          valid = test_option(:is_at)        if valid && @options[:is_at]
+          valid = test_option(:before)       if valid && @options[:before]
+          valid = test_option(:after)        if valid && @options[:after]
+          valid = test_option(:on_or_before) if valid && @options[:on_or_before]
+          valid = test_option(:on_or_after)  if valid && @options[:on_or_after]
+          valid = test_between               if valid && @options[:between]
 
           return valid
         end
@@ -92,8 +92,8 @@ module Spec
         end
 
         def parse_and_cast(value)
-          value = @validator.send(:restriction_value, value, @record)
-          @validator.send(:type_cast_value, value)
+          value = @validator.class.send(:evaluate_option_value, value, @type, @record)
+          @validator.class.send(:type_cast_value, value, @type)
         end
 
         def error_matching(value, option)
@@ -115,27 +115,31 @@ module Spec
           pass
         end
 
-        def error_message_for(option)
-          msg = @validator.send(:error_messages)[option]
-          restriction = @validator.send(:restriction_value, @validator.configuration[option], @record)
+        def error_message_for(message)
+          restriction = @validator.class.send(:evaluate_option_value, @validator.configuration[message], @type, @record)
 
           if restriction
-            restriction = [restriction] unless restriction.is_a?(Array)
-            restriction.map! {|r| @validator.send(:type_cast_value, r) }
-            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)
-              msg = @record.errors.generate_message(@expected, option, interpolate)
-            else
-              msg = msg % interpolate
-            end
+            restriction = @validator.class.send(:type_cast_value, restriction, @type)
+            interpolate = @validator.send(:interpolation_values, message, restriction)
+          end
+
+          if defined?(I18n)
+            interpolate ||= {}
+            options = interpolate.merge(:default => @validator.send(:custom_error_messages)[message])
+            if defined?(ActiveRecord::Error)
+              ActiveRecord::Error.new(@record, @expected, message, options).message
+            else
+              @record.errors.generate_message(@expected, message, options)
+            end
+          else
+            interpolate ||= nil
+            @validator.error_messages[message] % interpolate
           end
-          msg
         end
 
         def format_value(value)
           return value if value.is_a?(String)
-          value.strftime(ValidatesTimeliness::Validator.error_value_formats[@type])
+          value.strftime(@validator.class.error_value_formats[@type])
         end
       end
 

lib/validates_timeliness/validation_methods.rb

@@ -7,27 +7,6 @@ module ValidatesTimeliness
 
     module ClassMethods
 
-      def parse_date_time(raw_value, type, strict=true)
-        return nil if raw_value.blank?
-        return raw_value if raw_value.acts_like?(:time) || raw_value.is_a?(Date)
-        
-        time_array = ValidatesTimeliness::Formats.parse(raw_value, type, strict)
-        raise if time_array.nil?
-        
-        # Rails dummy time date part is defined as 2000-01-01
-        time_array[0..2] = 2000, 1, 1 if type == :time
-  
-        # Date.new enforces days per month, unlike Time
-        date = Date.new(*time_array[0..2]) unless type == :time
-        
-        return date if type == :date
-        
-        # Create time object which checks time part, and return time object
-        make_time(time_array)
-      rescue
-        nil
-      end
-
       def validates_time(*attr_names)
         configuration = attr_names.extract_options!
         configuration[:type] = :time
@@ -49,28 +28,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)
-        end
-      end
-
-      # Time.zone. Rails 2.0 should be default_timezone.
-      def make_time(time_array)
-        if Time.respond_to?(:zone) && time_zone_aware_attributes
-          Time.zone.local(*time_array)
-        else
-          begin
-            Time.send(::ActiveRecord::Base.default_timezone, *time_array)
-          rescue ArgumentError, TypeError
-            zone_offset = ::ActiveRecord::Base.default_timezone == :local ? DateTime.local_offset : 0
-            time_array.pop # remove microseconds
-            DateTime.civil(*(time_array << zone_offset))
-          end
+          validator.call(record, attr_name, value)
         end
       end
 

lib/validates_timeliness/validator.rb

@@ -1,17 +1,12 @@
 module ValidatesTimeliness
 
   class Validator
-    cattr_accessor :ignore_restriction_errors
     cattr_accessor :error_value_formats
-
+    cattr_accessor :ignore_restriction_errors
     self.ignore_restriction_errors = false
-    self.error_value_formats = {
-      :time     => '%H:%M:%S',
-      :date     => '%Y-%m-%d',
-      :datetime => '%Y-%m-%d %H:%M:%S'
-    }
 
     RESTRICTION_METHODS = {
+      :is_at        => :==,
       :before       => :<,
       :after        => :>,
       :on_or_before => :<=,
@@ -19,43 +14,63 @@ module ValidatesTimeliness
       :between      => lambda {|v, r| (r.first..r.last).include?(v) }
     }
 
+    VALID_OPTION_KEYS = [
+      :on, :if, :unless, :allow_nil, :empty, :allow_blank,
+      :with_time, :with_date, :ignore_usec, :format,
+      :invalid_time_message, :invalid_date_message, :invalid_datetime_message
+    ] + RESTRICTION_METHODS.keys.map {|option| [option, "#{option}_message".to_sym] }.flatten
+
+    DEFAULT_OPTIONS = { :on => :save, :type => :datetime, :allow_nil => false, :allow_blank => false, :ignore_usec => false }
+
     attr_reader :configuration, :type
 
     def initialize(configuration)
-      defaults = { :on => :save, :type => :datetime, :allow_nil => false, :allow_blank => false }
-      @configuration = defaults.merge(configuration)
+      @configuration = DEFAULT_OPTIONS.merge(configuration)
       @type = @configuration.delete(:type)
+      validate_options(@configuration)
     end
 
-    def call(record, attr_name)
-      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)
+    def call(record, attr_name, value)
+      raw_value = raw_value(record, attr_name) || value
+
+      if value.is_a?(String) || configuration[:format]
+        value = ValidatesTimeliness::Parser.parse(raw_value, type, :strict => false, :format => configuration[:format])
+      end
 
       return if (raw_value.nil? && configuration[:allow_nil]) || (raw_value.blank? && configuration[:allow_blank])
 
-      add_error(record, attr_name, :blank) and return if raw_value.blank?
-       
-      add_error(record, attr_name, "invalid_#{type}".to_sym) and return unless value
+      return add_error(record, attr_name, :blank) if raw_value.blank?
+      return add_error(record, attr_name, "invalid_#{type}".to_sym) if value.nil?
 
       validate_restrictions(record, attr_name, value)
     end
 
+    def error_messages
+      @error_messages ||= ::ActiveRecord::Errors.default_error_messages.merge(custom_error_messages)
+    end
+
    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)
+      if configuration[:with_time] || configuration[:with_date]
+        value = combine_date_and_time(value, record)
+        return if value.nil?
+      end
+
+      value = self.class.type_cast_value(value, implied_type, configuration[:ignore_usec])
+
+      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, implied_type, record)
           next if restriction.nil?
-          restriction = type_cast_value(restriction)
+          restriction = self.class.type_cast_value(restriction, implied_type, configuration[:ignore_usec])
 
           unless evaluate_restriction(restriction, value, method)
             add_error(record, attr_name, option, interpolation_values(option, restriction))
@@ -69,14 +84,13 @@ module ValidatesTimeliness
     end
 
     def interpolation_values(option, restriction)
-      format = self.class.error_value_formats[type]
+      format = self.class.error_value_format_for(type)
       restriction = [restriction] unless restriction.is_a?(Array)
 
       if defined?(I18n)
-        message = custom_error_messages[option] || I18n.translate('activerecord.errors.messages')[option]
-        subs = message.scan(/\{\{([^\}]*)\}\}/)
         interpolations = {}
-        subs.each_with_index {|s, i| interpolations[s[0].to_sym] = restriction[i].strftime(format) }
+        keys = restriction.size == 1 ? [:restriction] : [:earliest, :latest]
+        keys.each_with_index {|key, i| interpolations[key] = restriction[i].strftime(format) }
         interpolations
       else
         restriction.map {|r| r.strftime(format) }
@@ -87,33 +101,25 @@ module ValidatesTimeliness
       return true if restriction.nil?
 
       case comparator
-        when Symbol
-          value.send(comparator, restriction)
-        when Proc
-          comparator.call(value, restriction)
+      when Symbol
+        value.send(comparator, restriction)
+      when Proc
+        comparator.call(value, restriction)
       end
     end
 
     def add_error(record, attr_name, message, interpolate=nil)
       if defined?(I18n)
-        # use i18n support in AR for message or use custom message passed to validation method
         custom = custom_error_messages[message]
-        record.errors.add(attr_name, custom || message, interpolate || {})
+        record.errors.add(attr_name, message, { :default => custom }.merge(interpolate || {}))
       else
         message = error_messages[message] if message.is_a?(Symbol)
-        message = message % interpolate
-        record.errors.add(attr_name, message)
+        record.errors.add(attr_name, message % interpolate)
       end
     end
 
-    def error_messages
-      return @error_messages if defined?(@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 +127,96 @@ module ValidatesTimeliness
       }
     end
 
-    def restriction_value(restriction, record)
-      case restriction
-        when Time, Date, DateTime
-          restriction
-        when Symbol
-          restriction_value(record.send(restriction), record)
-        when Proc
-          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)
+    def combine_date_and_time(value, record)
+      if type == :date
+        date = value
+        time = configuration[:with_time]
+      else
+        date = configuration[:with_date]
+        time = value
       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?
+      ValidatesTimeliness::Parser.make_time([date.year, date.month, date.day, time.hour, time.min, time.sec, time.usec])
     end
 
-    def type_cast_value(value)
-      if value.is_a?(Array)
-        value.map {|v| type_cast_value(v) }
-      else 
-        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
+    def validate_options(options)
+      invalid_for_type = ([:time, :date, :datetime] - [type]).map {|k| "invalid_#{k}_message".to_sym }
+      invalid_for_type << :with_date unless type == :time
+      invalid_for_type << :with_time unless type == :date
+      options.assert_valid_keys(VALID_OPTION_KEYS - invalid_for_type)
+    end
+
+    def implied_type
+      @implied_type ||= configuration[:with_date] || configuration[:with_time] ? :datetime : type
+    end
+
+    # class methods
+    class << self
+
+      def error_value_format_for(type)
+        if defined?(I18n)
+          # work around for syntax check in vendored I18n for Rails <= 2.3.3
+          I18n.t('validates_timeliness.error_value_formats')[type] || error_value_formats[type]
         else
-          nil
+          error_value_formats[type]
         end
       end
+
+      def evaluate_option_value(value, type, record)
+        case value
+        when Time, Date
+          value
+        when Symbol
+          evaluate_option_value(record.send(value), type, record)
+        when Proc
+          result = value.arity > 0 ? value.call(record) : value.call
+          evaluate_option_value(result, 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
+          ValidatesTimeliness::Parser.parse(value, type, :strict => 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
+            dummy_time(value)
+          when :date
+            value.to_date
+          when :datetime
+            if value.is_a?(Time) || value.is_a?(DateTime)
+              value.to_time
+            else
+              value.to_time(ValidatesTimeliness.default_timezone)
+            end
+          else
+            nil
+          end
+          if ignore_usec && value.is_a?(Time)
+            ValidatesTimeliness::Parser.make_time(Array(value).reverse[4..9])
+          else
+            value
+          end
+        end
+      end
+
+      def dummy_time(value)
+        if value.is_a?(Time) || value.is_a?(DateTime)
+          time = [value.hour, value.min, value.sec]
+        else
+          time = [0,0,0]
+        end
+        dummy_date = ValidatesTimeliness::Formats.dummy_date_for_time_type
+        ValidatesTimeliness::Parser.make_time(dummy_date + time)
+      end
+
     end
 
   end

lib/validates_timeliness/version.rb

@@ -0,0 +1,3 @@
+module ValidatesTimeliness
+  VERSION = "2.3.2"
+end

spec/action_view/instance_tag_spec.rb

@@ -1,38 +1,194 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe ValidatesTimeliness::ActionView::InstanceTag, :type => :helper do
+describe 'ValidatesTimeliness::ActionView::InstanceTag' do
+  include ActionView::Helpers::DateHelper
+  include ActionController::Assertions::SelectorAssertions
 
   before do
     @person = Person.new
   end
 
-  it "should display invalid datetime as datetime_select values" do
-    @person.birth_date_and_time = "2008-02-30 12:00:22"
-    output = datetime_select(:person, :birth_date_and_time, :include_blank => true, :include_seconds => true)
+  def params
+    @params ||= {}
+  end
 
-    output.should have_tag('select[id=person_birth_date_and_time_1i]') do
-      with_tag('option[selected=selected]', '2008')
+  describe "datetime_select" do
+    it "should use param values when attribute is nil" do
+      params["person"] = {
+        "birth_date_and_time(1i)" => 2009,
+        "birth_date_and_time(2i)" => 2,
+        "birth_date_and_time(3i)" => 29,
+        "birth_date_and_time(4i)" => 12,
+        "birth_date_and_time(5i)" => 13,
+        "birth_date_and_time(6i)" => 14,
+      }
+      @person.birth_date_and_time = nil
+      output = datetime_select(:person, :birth_date_and_time, :include_blank => true, :include_seconds => true)
+      output.should have_tag('select[id=person_birth_date_and_time_1i] option[selected=selected]', '2009')
+      output.should have_tag('select[id=person_birth_date_and_time_2i] option[selected=selected]', 'February')
+      output.should have_tag('select[id=person_birth_date_and_time_3i] option[selected=selected]', '29')
+      output.should have_tag('select[id=person_birth_date_and_time_4i] option[selected=selected]', '12')
+      output.should have_tag('select[id=person_birth_date_and_time_5i] option[selected=selected]', '13')
+      output.should have_tag('select[id=person_birth_date_and_time_6i] option[selected=selected]', '14')
     end
-    output.should have_tag('select[id=person_birth_date_and_time_2i]') do
-      with_tag('option[selected=selected]', 'February')
+
+    it "should override object values and use params if present" do
+      params["person"] = {
+        "birth_date_and_time(1i)" => 2009,
+        "birth_date_and_time(2i)" => 2,
+        "birth_date_and_time(3i)" => 29,
+        "birth_date_and_time(4i)" => 13,
+        "birth_date_and_time(5i)" => 14,
+        "birth_date_and_time(6i)" => 15,
+      }
+      @person.birth_date_and_time = "2009-03-01 13:14:15"
+      output = datetime_select(:person, :birth_date_and_time, :include_blank => true, :include_seconds => true)
+      output.should have_tag('select[id=person_birth_date_and_time_1i] option[selected=selected]', '2009')
+      output.should have_tag('select[id=person_birth_date_and_time_2i] option[selected=selected]', 'February')
+      output.should have_tag('select[id=person_birth_date_and_time_3i] option[selected=selected]', '29')
+      output.should have_tag('select[id=person_birth_date_and_time_4i] option[selected=selected]', '13')
+      output.should have_tag('select[id=person_birth_date_and_time_5i] option[selected=selected]', '14')
+      output.should have_tag('select[id=person_birth_date_and_time_6i] option[selected=selected]', '15')
     end
-    output.should have_tag('select[id=person_birth_date_and_time_3i]') do
-      with_tag('option[selected=selected]', '30')
+
+    it "should select attribute values from object if no params" do
+      @person.birth_date_and_time = "2009-01-02 13:14:15"
+      output = datetime_select(:person, :birth_date_and_time, :include_blank => true, :include_seconds => true)
+      output.should have_tag('select[id=person_birth_date_and_time_1i] option[selected=selected]', '2009')
+      output.should have_tag('select[id=person_birth_date_and_time_2i] option[selected=selected]', 'January')
+      output.should have_tag('select[id=person_birth_date_and_time_3i] option[selected=selected]', '2')
+      output.should have_tag('select[id=person_birth_date_and_time_4i] option[selected=selected]', '13')
+      output.should have_tag('select[id=person_birth_date_and_time_5i] option[selected=selected]', '14')
+      output.should have_tag('select[id=person_birth_date_and_time_6i] option[selected=selected]', '15')
     end
-    output.should have_tag('select[id=person_birth_date_and_time_4i]') do
-      with_tag('option[selected=selected]', '12')
+
+    it "should select attribute values if params does not contain attribute params" do
+      @person.birth_date_and_time = "2009-01-02 13:14:15"
+      params["person"] = { }
+      output = datetime_select(:person, :birth_date_and_time, :include_blank => true, :include_seconds => true)
+      output.should have_tag('select[id=person_birth_date_and_time_1i] option[selected=selected]', '2009')
+      output.should have_tag('select[id=person_birth_date_and_time_2i] option[selected=selected]', 'January')
+      output.should have_tag('select[id=person_birth_date_and_time_3i] option[selected=selected]', '2')
+      output.should have_tag('select[id=person_birth_date_and_time_4i] option[selected=selected]', '13')
+      output.should have_tag('select[id=person_birth_date_and_time_5i] option[selected=selected]', '14')
+      output.should have_tag('select[id=person_birth_date_and_time_6i] option[selected=selected]', '15')
     end
-    output.should have_tag('select[id=person_birth_date_and_time_5i]') do
-      with_tag('option[selected=selected]', '00')
-    end
-    output.should have_tag('select[id=person_birth_date_and_time_6i]') do
-      with_tag('option[selected=selected]', '22')
+
+    it "should not select values when attribute value is nil and has no param values" do
+      @person.birth_date_and_time = nil
+      output = datetime_select(:person, :birth_date_and_time, :include_blank => true, :include_seconds => true)
+      output.should_not have_tag('select[id=person_birth_date_and_time_1i] option[selected=selected]')
+      output.should_not have_tag('select[id=person_birth_date_and_time_2i] option[selected=selected]')
+      output.should_not have_tag('select[id=person_birth_date_and_time_3i] option[selected=selected]')
+      output.should_not have_tag('select[id=person_birth_date_and_time_4i] option[selected=selected]')
+      output.should_not have_tag('select[id=person_birth_date_and_time_5i] option[selected=selected]')
+      output.should_not have_tag('select[id=person_birth_date_and_time_6i] option[selected=selected]')
     end
   end
 
-  it "should display datetime_select when datetime value is nil" do
-    @person.birth_date_and_time = nil
-    output = datetime_select(:person, :birth_date_and_time, :include_blank => true, :include_seconds => true)
-    output.should have_tag('select', 6)
+  describe "date_select" do
+    it "should use param values when attribute is nil" do
+      params["person"] = {
+        "birth_date(1i)" => 2009,
+        "birth_date(2i)" => 2,
+        "birth_date(3i)" => 29,
+      }
+      @person.birth_date = nil
+      output = date_select(:person, :birth_date, :include_blank => true, :include_seconds => true)
+      output.should have_tag('select[id=person_birth_date_1i] option[selected=selected]', '2009')
+      output.should have_tag('select[id=person_birth_date_2i] option[selected=selected]', 'February')
+      output.should have_tag('select[id=person_birth_date_3i] option[selected=selected]', '29')
+    end
+
+    it "should override object values and use params if present" do
+      params["person"] = {
+        "birth_date(1i)" => 2009,
+        "birth_date(2i)" => 2,
+        "birth_date(3i)" => 29,
+      }
+      @person.birth_date = "2009-03-01"
+      output = date_select(:person, :birth_date, :include_blank => true, :include_seconds => true)
+      output.should have_tag('select[id=person_birth_date_1i] option[selected=selected]', '2009')
+      output.should have_tag('select[id=person_birth_date_2i] option[selected=selected]', 'February')
+      output.should have_tag('select[id=person_birth_date_3i] option[selected=selected]', '29')
+    end
+
+    it "should select attribute values from object if no params" do
+      @person.birth_date = "2009-01-02"
+      output = date_select(:person, :birth_date, :include_blank => true, :include_seconds => true)
+      output.should have_tag('select[id=person_birth_date_1i] option[selected=selected]', '2009')
+      output.should have_tag('select[id=person_birth_date_2i] option[selected=selected]', 'January')
+      output.should have_tag('select[id=person_birth_date_3i] option[selected=selected]', '2')
+    end
+
+    it "should select attribute values if params does not contain attribute params" do
+      @person.birth_date = "2009-01-02"
+      params["person"] = { }
+      output = date_select(:person, :birth_date, :include_blank => true, :include_seconds => true)
+      output.should have_tag('select[id=person_birth_date_1i] option[selected=selected]', '2009')
+      output.should have_tag('select[id=person_birth_date_2i] option[selected=selected]', 'January')
+      output.should have_tag('select[id=person_birth_date_3i] option[selected=selected]', '2')
+    end
+
+    it "should not select values when attribute value is nil and has no param values" do
+      @person.birth_date = nil
+      output = date_select(:person, :birth_date, :include_blank => true, :include_seconds => true)
+      output.should_not have_tag('select[id=person_birth_date_1i] option[selected=selected]')
+      output.should_not have_tag('select[id=person_birth_date_2i] option[selected=selected]')
+      output.should_not have_tag('select[id=person_birth_date_3i] option[selected=selected]')
+    end
   end
+
+  describe "time_select" do
+    before :all do
+      Time.now = Time.mktime(2009,1,1)
+    end
+
+    it "should use param values when attribute is nil" do
+      params["person"] = {
+        "birth_time(1i)" => 2000,
+        "birth_time(2i)" => 1,
+        "birth_time(3i)" => 1,
+        "birth_time(4i)" => 12,
+        "birth_time(5i)" => 13,
+        "birth_time(6i)" => 14,
+      }
+      @person.birth_time = nil
+      output = time_select(:person, :birth_time, :include_blank => true, :include_seconds => true)
+      output.should have_tag('input[id=person_birth_time_1i][value=2000]')
+      output.should have_tag('input[id=person_birth_time_2i][value=1]')
+      output.should have_tag('input[id=person_birth_time_3i][value=1]')
+      output.should have_tag('select[id=person_birth_time_4i] option[selected=selected]', '12')
+      output.should have_tag('select[id=person_birth_time_5i] option[selected=selected]', '13')
+      output.should have_tag('select[id=person_birth_time_6i] option[selected=selected]', '14')
+    end
+
+    it "should select attribute values from object if no params" do
+      @person.birth_time = "13:14:15"
+      output = time_select(:person, :birth_time, :include_blank => true, :include_seconds => true)
+      output.should have_tag('input[id=person_birth_time_1i][value=2000]')
+      output.should have_tag('input[id=person_birth_time_2i][value=1]')
+      output.should have_tag('input[id=person_birth_time_3i][value=1]')
+      output.should have_tag('select[id=person_birth_time_4i] option[selected=selected]', '13')
+      output.should have_tag('select[id=person_birth_time_5i] option[selected=selected]', '14')
+      output.should have_tag('select[id=person_birth_time_6i] option[selected=selected]', '15')
+    end
+
+    it "should not select values when attribute value is nil and has no param values" do
+      @person.birth_time = nil
+      output = time_select(:person, :birth_time, :include_blank => true, :include_seconds => true)
+      output.should have_tag('input[id=person_birth_time_1i][value=""]')
+      # Annoyingly these may or not have value attribute depending on rails version.
+      # output.should have_tag('input[id=person_birth_time_2i][value=""]')
+      # output.should have_tag('input[id=person_birth_time_3i][value=""]')
+      output.should_not have_tag('select[id=person_birth_time_4i] option[selected=selected]')
+      output.should_not have_tag('select[id=person_birth_time_5i] option[selected=selected]')
+      output.should_not have_tag('select[id=person_birth_time_6i] option[selected=selected]')
+    end
+
+    after :all do
+      Time.now = nil
+    end
+  end
+
 end

spec/active_record/attribute_methods_spec.rb

@@ -1,16 +1,16 @@
 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
 
-  it "should call write_date_time_attribute when date attribute assigned value" do
-    @person.should_receive(:write_date_time_attribute)
-    @person.birth_date = "2000-01-01"
+  it "should define and call write method on first assign" do
+    Person.class_eval { @generated_methods = Set.new; @_defined_class_methods = nil }
+    Person.send(:undef_method, :birth_date=) if Person.instance_methods.include?('birth_date=')
+    person = Person.new
+    person.should_receive(:write_date_time_attribute)
+    person.birth_date = "2000-01-01"
   end
 
   it "should call write_date_time_attribute when time attribute assigned value" do
@@ -23,36 +23,18 @@ describe ValidatesTimeliness::ActiveRecord::AttributeMethods do
     @person.birth_date_and_time = "2000-01-01 12:00"
   end
 
-  it "should call read_date_time_attribute when date attribute is retrieved" do
-    @person.should_receive(:read_date_time_attribute)
-    @person.birth_date = "2000-01-01"
-    @person.birth_date
-  end
-
-  it "should call read_date_time_attribute when time attribute is retrieved" do
-    @person.should_receive(:read_date_time_attribute)
-    @person.birth_time = "12:00"
-    @person.birth_time
-  end
-
-  it "should call rea_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
-  end
-
   it "should call parser on write for datetime attribute" do
-    @person.class.should_receive(:parse_date_time).once
+    ValidatesTimeliness::Parser.should_receive(:parse).once
     @person.birth_date_and_time = "2000-01-01 02:03:04"
   end
 
   it "should call parser on write for date attribute" do
-    @person.class.should_receive(:parse_date_time).once
+    ValidatesTimeliness::Parser.should_receive(:parse).once
     @person.birth_date = "2000-01-01"
   end
 
   it "should call parser on write for time attribute" do
-    @person.class.should_receive(:parse_date_time).once
+    ValidatesTimeliness::Parser.should_receive(:parse).once
     @person.birth_time = "12:00"
   end
 
@@ -72,6 +54,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)
@@ -94,14 +81,25 @@ describe ValidatesTimeliness::ActiveRecord::AttributeMethods do
 
   it "should not save invalid date value to database" do
     time_string = "2000-01-32 02:03:04"
-    @person = Person.new
     @person.birth_date_and_time = time_string
     @person.save
     @person.reload
     @person.birth_date_and_time_before_type_cast.should be_nil
   end
 
-  unless RAILS_VER < '2.1'
+  if RAILS_VER < '2.1'
+
+    it "should return time object from database in default timezone" do
+      ActiveRecord::Base.default_timezone = :utc
+      time_string = "2000-01-01 09:00:00"
+      @person.birth_date_and_time = time_string
+      @person.save
+      @person.reload
+      @person.birth_date_and_time.strftime('%Y-%m-%d %H:%M:%S %Z').should == time_string + ' UTC'
+    end
+
+  else
+
     it "should return stored time string as Time with correct timezone" do
       Time.zone = 'Melbourne'
       time_string = "2000-06-01 02:03:04"
@@ -112,97 +110,17 @@ describe ValidatesTimeliness::ActiveRecord::AttributeMethods do
     it "should return time object from database in correct timezone" do
       Time.zone = 'Melbourne'
       time_string = "2000-06-01 09:00:00"
-      @person = Person.new
       @person.birth_date_and_time = time_string
       @person.save
       @person.reload
       @person.birth_date_and_time.strftime('%Y-%m-%d %H:%M:%S %Z %z').should == time_string + ' EST +1000'
     end
 
-    describe "dirty attributes" do
-    
-      it "should return true for attribute changed? when value updated" do
-        time_string = "2000-01-01 02:03:04"
-        @person.birth_date_and_time = time_string
-        @person.birth_date_and_time_changed?.should be_true
-      end
-    
-      it "should show changes when time attribute changed from nil to Time object" do
-        time_string = "2000-01-01 02:03:04"
-        @person.birth_date_and_time = time_string
-        time = @person.birth_date_and_time
-        @person.changes.should == {"birth_date_and_time" => [nil, time]}
-      end
-      
-      it "should show changes when time attribute changed from Time object to nil" do
-        time_string = "2020-01-01 02:03:04"
-        @person.birth_date_and_time = time_string
-        @person.save false
-        @person.reload
-        time = @person.birth_date_and_time
-        @person.birth_date_and_time = nil
-        @person.changes.should == {"birth_date_and_time" => [time, nil]}
-      end
-      
-      it "should show no changes when assigned same value as Time object" do
-        time_string = "2020-01-01 02:03:04"
-        @person.birth_date_and_time = time_string
-        @person.save false
-        @person.reload
-        time = @person.birth_date_and_time
-        @person.birth_date_and_time = time
-        @person.changes.should == {}
-      end
-      
-      it "should show no changes when assigned same value as time string" do
-        time_string = "2020-01-01 02:03:04"
-        @person.birth_date_and_time = time_string
-        @person.save false
-        @person.reload
-        @person.birth_date_and_time = time_string
-        @person.changes.should == {}
-      end
-      
-    end
-  else
-    
-    it "should return time object from database in default timezone" do        
-      ActiveRecord::Base.default_timezone = :utc
-      time_string = "2000-01-01 09:00:00"
-      @person = Person.new
-      @person.birth_date_and_time = time_string
-      @person.save
-      @person.reload
-      @person.birth_date_and_time.strftime('%Y-%m-%d %H:%M:%S %Z').should == time_string + ' GMT'
-    end
-      
-  end
-  
-  it "should return same time object on repeat reads on existing object" do
-    Time.zone = 'Melbourne' unless RAILS_VER < '2.1'
-    time_string = "2000-01-01 09:00:00"
-    @person = Person.new
-    @person.birth_date_and_time = time_string
-    @person.save!
-    @person.reload
-    time = @person.birth_date_and_time
-    @person.birth_date_and_time.should == time
-  end
-  
-  it "should return same date object on repeat reads on existing object" do
-    date_string = Date.today
-    @person = Person.new
-    @person.birth_date = date_string
-    @person.save!
-    @person.reload
-    date = @person.birth_date
-    @person.birth_date.should == date
   end
 
   it "should return correct date value after new value assigned" do
     today = Date.today
     tomorrow = Date.today + 1.day
-    @person = Person.new
     @person.birth_date = today
     @person.birth_date.should == today
     @person.birth_date = tomorrow
@@ -212,11 +130,28 @@ describe ValidatesTimeliness::ActiveRecord::AttributeMethods do
   it "should update date attribute on existing object" do
     today = Date.today
     tomorrow = Date.today + 1.day
-    @person = Person.create(:birth_date => today)
-    @person.birth_date = tomorrow
-    @person.save!
-    @person.reload
-    @person.birth_date.should == tomorrow
+    person = Person.create(:birth_date => today)
+    person.birth_date = tomorrow
+    person.save!
+    person.reload
+    person.birth_date.should == tomorrow
+  end
+
+  describe "attribute writer" do
+
+    it "should be able to be overridden in class" do
+      Person.class_eval { attr_accessor :birth_date }
+      person = Person.new
+      person.birth_date = 'overriden'
+      person.birth_date.should == 'overriden'
+    end
+
+    after do
+      Person.class_eval do
+        undef_method(:birth_date)
+        undef_method(:birth_date=)
+      end
+    end
   end
 
 end

spec/active_record/multiparameter_attributes_spec.rb

@@ -6,43 +6,113 @@ describe ValidatesTimeliness::ActiveRecord::MultiparameterAttributes do
   end
 
   it "should convert array for datetime type into datetime string" do
-    time_string = obj.time_array_to_string([2000,2,1,9,10,11], :datetime)
+    time_string = time_array_to_string([2000,2,1,9,10,11], :datetime)
     time_string.should == "2000-02-01 09:10:11"
   end
 
   it "should convert array for date type into date string" do
-    time_string = obj.time_array_to_string([2000,2,1], :date)
+    time_string = time_array_to_string([2000,2,1], :date)
     time_string.should == "2000-02-01"
   end
 
   it "should convert array for time type into time string" do
-    time_string = obj.time_array_to_string([2000,1,1,9,10,11], :time)
+    time_string = time_array_to_string([2000,1,1,9,10,11], :time)
     time_string.should == "09:10:11"
   end
 
   describe "execute_callstack_for_multiparameter_attributes" do
-    before do      
-      @callstack = {
-        'birth_date_and_time' => [2000,2,1,9,10,11],
-        'birth_date' => [2000,2,1,9,10,11],
-        'birth_time' => [2000,2,1,9,10,11]
-      }
+
+    describe "for valid values" do
+      before do
+        @callstack = {
+          'birth_date_and_time' => [2000,2,1,9,10,11],
+          'birth_date' => [2000,2,1,9,10,11],
+          'birth_time' => [2000,2,1,9,10,11]
+        }
+      end
+
+      it "should store datetime string for datetime column" do
+        obj.should_receive(:birth_date_and_time=).once.with("2000-02-01 09:10:11")
+        obj.send(:execute_callstack_for_multiparameter_attributes, @callstack)
+      end
+
+      it "should store date string for a date column" do
+        obj.should_receive(:birth_date=).once.with("2000-02-01")
+        obj.send(:execute_callstack_for_multiparameter_attributes, @callstack)
+      end
+
+      it "should store time string for a time column" do
+        obj.should_receive(:birth_time=).once.with("09:10:11")
+        obj.send(:execute_callstack_for_multiparameter_attributes, @callstack)
+      end
     end
 
-    it "should store datetime string for datetime column" do      
-      obj.should_receive(:birth_date_and_time=).once.with("2000-02-01 09:10:11")
-      obj.send(:execute_callstack_for_multiparameter_attributes, @callstack)
+    describe "for invalid values" do
+      before do
+        @callstack = {
+          'birth_date_and_time' => [2000,13,1,9,10,11],
+          'birth_date' => [2000,2,41,9,10,11],
+          'birth_time' => [2000,2,1,25,10,11]
+        }
+      end
+
+      it "should store invalid datetime string for datetime column" do
+        obj.should_receive(:birth_date_and_time=).once.with("2000-13-01 09:10:11")
+        obj.send(:execute_callstack_for_multiparameter_attributes, @callstack)
+      end
+
+      it "should store invalid date string for a date column" do
+        obj.should_receive(:birth_date=).once.with("2000-02-41")
+        obj.send(:execute_callstack_for_multiparameter_attributes, @callstack)
+      end
+
+      it "should store invalid time string for a time column" do
+        obj.should_receive(:birth_time=).once.with("25:10:11")
+        obj.send(:execute_callstack_for_multiparameter_attributes, @callstack)
+      end
     end
 
-    it "should store date string for a date column" do
-      obj.should_receive(:birth_date=).once.with("2000-02-01")
-      obj.send(:execute_callstack_for_multiparameter_attributes, @callstack)
-    end
+    describe "for missing values" do
+      it "should store nil if all datetime values nil" do
+        obj.should_receive(:birth_date_and_time=).once.with(nil)
+        callstack = { 'birth_date_and_time' => [nil,nil,nil,nil,nil,nil] }
+        obj.send(:execute_callstack_for_multiparameter_attributes, callstack)
+      end
 
-    it "should store time string for a time column" do
-      obj.should_receive(:birth_time=).once.with("09:10:11")
-      obj.send(:execute_callstack_for_multiparameter_attributes, @callstack)
+      it "should store nil year as empty value in string" do
+        obj.should_receive(:birth_date_and_time=).once.with("-02-01 09:10:11")
+        callstack = { 'birth_date_and_time' => [nil,2,1,9,10,11] }
+        obj.send(:execute_callstack_for_multiparameter_attributes, callstack)
+      end
+
+      it "should store nil month as empty value in string" do
+        obj.should_receive(:birth_date_and_time=).once.with("2000--01 09:10:11")
+        callstack = { 'birth_date_and_time' => [2000,nil,1,9,10,11] }
+        obj.send(:execute_callstack_for_multiparameter_attributes, callstack)
+      end
+
+      it "should store nil day as empty value in string" do
+        obj.should_receive(:birth_date_and_time=).once.with("2000-02- 09:10:11")
+        callstack = { 'birth_date_and_time' => [2000,2,nil,9,10,11] }
+        obj.send(:execute_callstack_for_multiparameter_attributes, callstack)
+      end
+
+      it "should store nil hour as empty value in string" do
+        obj.should_receive(:birth_date_and_time=).once.with("2000-02-01 :10:11")
+        callstack = { 'birth_date_and_time' => [2000,2,1,nil,10,11] }
+        obj.send(:execute_callstack_for_multiparameter_attributes, callstack)
+      end
+
+      it "should store nil minute as empty value in string" do
+        obj.should_receive(:birth_date_and_time=).once.with("2000-02-01 09:10:")
+        callstack = { 'birth_date_and_time' => [2000,2,1,9,10,nil] }
+        obj.send(:execute_callstack_for_multiparameter_attributes, callstack)
+      end
     end
   end
 
+  def time_array_to_string(*args)
+    ValidatesTimeliness::ActiveRecord.time_array_to_string(*args)
+  end
+
 end

spec/core_ext/dummy_time_spec.rb

@@ -1,31 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe ValidatesTimeliness::CoreExtensions::Date do  
-  before do
-    @a_date = Date.new(2008, 7, 1)
-  end
-  
-  it "should make a date value into a dummy time value" do
-    @a_date.to_dummy_time.should == Time.utc(2000,1,1,0,0,0)
-  end
-end
-
-describe ValidatesTimeliness::CoreExtensions::Time do
-  before do
-    @a_time = Time.mktime(2008, 7, 1, 2, 3, 4)
-  end
-  
-  it "should make a time value into a dummy time value" do
-    @a_time.to_dummy_time.should == Time.utc(2000,1,1,2,3,4)
-  end
-end
-
-describe ValidatesTimeliness::CoreExtensions::DateTime do
-  before do
-    @a_datetime = DateTime.new(2008, 7, 1, 2, 3, 4)
-  end
-  
-  it "should make a datetime value into a dummy time value" do
-    @a_datetime.to_dummy_time.should == Time.utc(2000,1,1,2,3,4)
-  end
-end

spec/formats_spec.rb

@@ -1,56 +1,11 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe ValidatesTimeliness::Formats do
-  attr_reader :formats
-  
-  before do
-   @formats = ValidatesTimeliness::Formats
-  end
-  
-  describe "expression generator" do
-    it "should generate regexp for time" do
-      generate_regexp_str('hh:nn:ss').should == '/(\d{2}):(\d{2}):(\d{2})/'
-    end
-    
-    it "should generate regexp for time with meridian" do
-      generate_regexp_str('hh:nn:ss ampm').should == '/(\d{2}):(\d{2}):(\d{2}) ((?:[aApP])\.?[mM]\.?)/'
-    end
-    
-    it "should generate regexp for time with meridian and optional space between" do
-      generate_regexp_str('hh:nn:ss_ampm').should == '/(\d{2}):(\d{2}):(\d{2})\s?((?:[aApP])\.?[mM]\.?)/'
-    end
-    
-    it "should generate regexp for time with single or double digits" do
-      generate_regexp_str('h:n:s').should == '/(\d{1,2}):(\d{1,2}):(\d{1,2})/'
-    end
-    
-    it "should generate regexp for date" do
-      generate_regexp_str('yyyy-mm-dd').should == '/(\d{4})-(\d{2})-(\d{2})/'
-    end
-    
-    it "should generate regexp for date with slashes" do
-      generate_regexp_str('dd/mm/yyyy').should == '/(\d{2})\/(\d{2})\/(\d{4})/'
-    end
-   
-    it "should generate regexp for date with dots" do
-      generate_regexp_str('dd.mm.yyyy').should == '/(\d{2})\.(\d{2})\.(\d{4})/'
-    end
-   
-    it "should generate regexp for Ruby time string" do
-      expected = '/(\w{3,9}) (\w{3,9}) (\d{2}):(\d{2}):(\d{2}) (?:[+-]\d{2}:?\d{2}) (\d{4})/'
-      generate_regexp_str('ddd mmm hh:nn:ss zo yyyy').should == expected
-    end
-    
-    it "should generate regexp for iso8601 datetime" do
-      expected = '/(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:Z|(?:[+-]\d{2}:?\d{2}))/'
-      generate_regexp_str('yyyy-mm-ddThh:nn:ss(?:Z|zo)').should == expected
-    end
-  end
 
   describe "format proc generator" do
     it "should generate proc which outputs date array with values in correct order" do
       generate_proc('yyyy-mm-dd').call('2000', '1', '2').should == [2000,1,2,0,0,0,0]
-    end
+   end
 
     it "should generate proc which outputs date array from format with different order" do
       generate_proc('dd/mm/yyyy').call('2', '1', '2000').should == [2000,1,2,0,0,0,0]
@@ -71,9 +26,13 @@ describe ValidatesTimeliness::Formats do
     it "should generate proc which outputs time array with microseconds" do
       generate_proc('hh:nn:ss.u').call('01', '02', '03', '99').should == [0,0,0,1,2,3,990000]
     end
+
+    it "should generate proc which outputs datetime array with zone offset" do
+      generate_proc('yyyy-mm-dd hh:nn:ss.u zo').call('2001', '02', '03', '04', '05', '06', '99', '+10:00').should == [2001,2,3,4,5,6,990000,36000]
+    end
   end
 
-  describe "validation regexps" do
+  describe "validate regexps" do
 
     describe "for time formats" do
       format_tests = {
@@ -136,49 +95,119 @@ describe ValidatesTimeliness::Formats do
     end
   end
 
-  describe "extracting values" do
+  describe "parse" do
 
     it "should return time array from date string" do
-      time_array = formats.parse('12:13:14', :time, true)
-      time_array.should == [0,0,0,12,13,14,0]
+      time_array = formats.parse('12:13:14', :time, :strict => true)
+      time_array.should == [2000,1,1,12,13,14,0]
+    end
+
+    it "should return nil if time hour is out of range for AM meridian" do
+      time_array = formats.parse('13:14 am', :time, :strict => true)
+      time_array.should == nil
+      time_array = formats.parse('00:14 am', :time, :strict => true)
+      time_array.should == nil
     end
 
     it "should return date array from time string" do
-      time_array = formats.parse('2000-02-01', :date, true)
+      time_array = formats.parse('2000-02-01', :date, :strict => true)
       time_array.should == [2000,2,1,0,0,0,0]
     end
 
     it "should return datetime array from string value" do
-      time_array = formats.parse('2000-02-01 12:13:14', :datetime, true)
+      time_array = formats.parse('2000-02-01 12:13:14', :datetime, :strict => true)
       time_array.should == [2000,2,1,12,13,14,0]
     end
 
     it "should parse date string when type is datetime" do
-      time_array = formats.parse('2000-02-01', :datetime, false)
+      time_array = formats.parse('2000-02-01', :datetime, :strict => 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 = formats.parse('2000-02-01 12:13', :date, :strict => 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 = formats.parse('01-02-2000 12:13', :date, :strict => 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)
-      time_array.should == [0,0,0,12,12,0,0]
+      time_array = formats.parse('2000-02-01 12:13', :time, :strict => false)
+      time_array.should == [2000,1,1,12,13,0,0]
+    end
+
+    it "should return zone offset when :include_offset option is true" do
+      time_array = formats.parse('2000-02-01T12:13:14-10:30', :datetime, :include_offset => true)
+      time_array.should == [2000,2,1,12,13,14,0,-37800]
+    end
+  end
+
+  describe "parse with format option" do
+    it "should return values if string matches specified format" do
+      time_array = formats.parse('2000-02-01 12:13:14', :datetime, :format => 'yyyy-mm-dd hh:nn:ss')
+      time_array.should == [2000,2,1,12,13,14,0]
+    end
+
+    it "should return nil if string does not match specified format" do
+      time_array = formats.parse('2000-02-01 12:13', :datetime, :format => 'yyyy-mm-dd hh:nn:ss')
+      time_array.should be_nil
+    end
+  end
+
+  describe "parsing date with ambiguous year" do
+    it "should return year in current century if year below threshold" do
+      time_array = formats.parse('01-02-29', :date)
+      time_array.should == [2029,2,1,0,0,0,0]
+    end
+
+    it "should return year in last century if year at or above threshold" do
+      time_array = formats.parse('01-02-30', :date)
+      time_array.should == [1930,2,1,0,0,0,0]
+    end
+
+    it "should allow custom threshold" do
+      default = ValidatesTimeliness::Formats.ambiguous_year_threshold
+      ValidatesTimeliness::Formats.ambiguous_year_threshold = 40
+      time_array = formats.parse('01-02-39', :date)
+      time_array.should == [2039,2,1,0,0,0,0]
+      time_array = formats.parse('01-02-40', :date)
+      time_array.should == [1940,2,1,0,0,0,0]
+      ValidatesTimeliness::Formats.ambiguous_year_threshold = default
+    end
+  end
+
+  describe "parse with custom dummy date values" do
+    before(:all) do
+      @old_dummy_date = formats.dummy_date_for_time_type
+      formats.dummy_date_for_time_type = [2009,1,1]
+    end
+
+    it "should return time array with custom dummy date" do
+      time_array = formats.parse('12:13:14', :time, :strict => true)
+      time_array.should == [2009,1,1,12,13,14,0]
+    end
+
+    after(:all) do
+      formats.dummy_date_for_time_type = @old_dummy_date
+    end
+  end
+
+  describe "parse ISO8601 datetime" do
+    it "should return array without zone offset when no offset in string" do
+      time_array = formats.parse('2000-02-01T12:13:14Z', :datetime, :strict => true)
+      time_array.should == [2000,2,1,12,13,14,0]
+    end
+
+    it "should return array with zone offset when offset in string" do
+      time_array = formats.parse('2000-02-01T12:13:14+10:00', :datetime, :strict => true)
+      time_array.should == [2000,2,1,12,13,14,0,36000]
     end
   end
 
   describe "removing formats" do
-    before do
-      formats.compile_format_expressions
-    end
-    
     it "should remove format from format array" do
       formats.remove_formats(:time, 'h.nn_ampm')
       formats.time_formats.should_not include("h o'clock")
@@ -196,7 +225,7 @@ describe ValidatesTimeliness::Formats do
 
     after do
       formats.time_formats << 'h.nn_ampm'
-      # reload class instead
+      formats.compile_format_expressions
     end
   end
 
@@ -220,7 +249,7 @@ describe ValidatesTimeliness::Formats do
       formats.add_formats(:time, "ss:hh:nn", :before => 'hh:nn:ss')
       validate("59:23:58", :time).should be_true
       time_array = formats.parse('59:23:58', :time)
-      time_array.should == [0,0,0,23,58,59,0]
+      time_array.should == [2000,1,1,23,58,59,0]
     end
 
     it "should raise error if format exists" do
@@ -252,9 +281,14 @@ describe ValidatesTimeliness::Formats do
     end
   end
 
+
+  def formats
+    ValidatesTimeliness::Formats
+  end
+
   def validate(time_string, type)
     valid = false
-    formats.send("#{type}_expressions").each do |(regexp, processor)|
+    formats.send("#{type}_expressions").each do |format, regexp, processor|
         valid = true and break if /\A#{regexp}\Z/ =~ time_string
     end
     valid
@@ -262,15 +296,15 @@ describe ValidatesTimeliness::Formats do
 
   def generate_regexp(format)
     # wrap in line start and end anchors to emulate extract values method
-    /\A#{formats.send(:format_expression_generator, format)[0]}\Z/
+    /\A#{formats.send(:generate_format_expression, format)[0]}\Z/
   end
 
   def generate_regexp_str(format)
-    formats.send(:format_expression_generator, format)[0].inspect
+    formats.send(:generate_format_expression, format)[0].inspect
   end
 
   def generate_proc(format)
-    formats.send(:format_expression_generator, format)[1]
+    formats.send(:generate_format_expression, format)[1]
   end
 
   def delete_format(type, format)

spec/ginger_scenarios.rb

@@ -2,17 +2,17 @@
 #
 # To use ginger:
 #
-#    sudo gem install freelancing-god-ginger --source=http://gems.github.com
+#   gem install ginger
 #
 # Then run
 #
 #   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.3', '2.3.4', '2.3.5', '2.3.6', '2.3.9']
 
   rails_versions.each do |v|
-    g = Ginger::Scenario.new
+    g = Ginger::Scenario.new("Rails #{v}")
     g['rails'] = v
     config.scenarios << g.dup
   end

spec/parser_spec.rb

@@ -1,39 +1,43 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe ValidatesTimeliness::ValidationMethods do
+describe ValidatesTimeliness::Parser do
   attr_accessor :person
 
-  describe "parse_date_time" do
+  describe "parse" do
     it "should return time object for valid time string" do
-      parse_method("2000-01-01 12:13:14", :datetime).should be_kind_of(Time)
+      parse("2000-01-01 12:13:14", :datetime).should be_kind_of(Time)
+    end
+
+    it "should return Time object for ISO 8601 string with time zone" do
+      parse("2000-01-01T12:23:42+09:00", :datetime).should be_kind_of(Time)
     end
     
     it "should return nil for time string with invalid date part" do
-      parse_method("2000-02-30 12:13:14", :datetime).should be_nil
+      parse("2000-02-30 12:13:14", :datetime).should be_nil
     end
     
     it "should return nil for time string with invalid time part" do
-      parse_method("2000-02-01 25:13:14", :datetime).should be_nil      
+      parse("2000-02-01 25:13:14", :datetime).should be_nil      
     end
     
     it "should return Time object when passed a Time object" do
-      parse_method(Time.now, :datetime).should be_kind_of(Time)
+      parse(Time.now, :datetime).should be_kind_of(Time)
     end
 
     if RAILS_VER >= '2.1'
       it "should convert time string into current timezone" do
         Time.zone = 'Melbourne'
-        time = parse_method("2000-01-01 12:13:14", :datetime)
-        Time.zone.utc_offset.should == 10.hours
+        time = parse("2000-06-01 12:13:14", :datetime)
+        time.utc_offset.should == 10.hours
       end
     end
 
     it "should return nil for invalid date string" do
-      parse_method("2000-02-30", :date).should be_nil      
+      parse("2000-02-30", :date).should be_nil      
     end
         
-    def parse_method(*args)
-      ActiveRecord::Base.parse_date_time(*args)
+    def parse(*args)
+      ValidatesTimeliness::Parser.parse(*args)
     end
   end
 
@@ -43,14 +47,14 @@ describe ValidatesTimeliness::ValidationMethods do
 
       it "should create time using current timezone" do
         Time.zone = 'Melbourne'
-        time = ActiveRecord::Base.send(:make_time, [2000,1,1,12,0,0])
+        time = ValidatesTimeliness::Parser.make_time([2000,1,1,12,0,0])
         time.zone.should == "EST"
       end
 
     else
 
       it "should create time using default timezone" do
-        time = ActiveRecord::Base.send(:make_time, [2000,1,1,12,0,0])
+        time = ValidatesTimeliness::Parser.make_time([2000,1,1,12,0,0])
         time.zone.should == "UTC"
       end
 

spec/spec/rails/matchers/validate_timeliness_spec.rb

@@ -1,10 +1,12 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+require 'validates_timeliness/matcher'
 
 class NoValidation < Person
 end
 
 class WithValidation < Person
   validates_date :birth_date,
+    :is_at        => '2000-01-01',
     :before       => '2000-01-10',
     :after        => '2000-01-01',
     :on_or_before => '2000-01-09',
@@ -12,6 +14,7 @@ class WithValidation < Person
     :between      => ['2000-01-01', '2000-01-03']
 
   validates_time :birth_time,
+    :is_at        => '09:00',
     :before       => '23:00',
     :after        => '09:00',
     :on_or_before => '22:00',
@@ -19,6 +22,7 @@ class WithValidation < Person
     :between      => ['09:00', '17:00']
 
   validates_datetime :birth_date_and_time,
+    :is_at        => '2000-01-01 09:00',
     :before       => '2000-01-10 23:00',
     :after        => '2000-01-01 09:00',
     :on_or_before => '2000-01-09 23:00',
@@ -61,6 +65,29 @@ describe "ValidateTimeliness matcher" do
     end
   end
 
+  describe "with is_at option" do
+    test_values = {
+      :date     => ['2000-01-01', '2000-01-02'],
+      :time     => ['09:00', '09:01'],
+      :datetime => ['2000-01-01 09:00', '2000-01-01 09:01']
+    }
+
+    [:date, :time, :datetime].each do |type|
+
+      it "should report that #{type} is validated" do
+        with_validation.should self.send("validate_#{type}", attribute_for_type(type), :is_at => test_values[type][0])
+      end
+
+      it "should report that #{type} is not validated when option value is incorrect" do
+        with_validation.should_not self.send("validate_#{type}", attribute_for_type(type), :is_at => test_values[type][1])
+      end
+
+      it "should report that #{type} is not validated with option" do
+        no_validation.should_not self.send("validate_#{type}", attribute_for_type(type), :is_at => test_values[type][0])
+      end
+    end
+  end
+
   describe "with before option" do
     test_values = {
       :date     => ['2000-01-10', '2000-01-11'],

spec/spec_helper.rb

@@ -2,10 +2,10 @@ $:.unshift(File.dirname(__FILE__) + '/../lib')
 $:.unshift(File.dirname(__FILE__))
 $:.unshift(File.dirname(__FILE__) + '/resources')
 
-ENV['RAILS_ENV'] = 'test'
+RAILS_ENV = ENV['RAILS_ENV'] = 'test'
 
 require 'rubygems'
-require 'spec'
+require 'spec/autorun'
 
 vendored_rails = File.dirname(__FILE__) + '/../../../../vendor/rails'
 
@@ -30,6 +30,7 @@ require 'active_record'
 require 'active_record/version'
 require 'action_controller'
 require 'action_view'
+require 'action_mailer'
 
 require 'spec/rails'
 require 'time_travel/time_travel'
@@ -38,13 +39,16 @@ ActiveRecord::Base.default_timezone = :utc
 RAILS_VER = Rails::VERSION::STRING
 puts "Using #{vendored ? 'vendored' : 'gem'} Rails version #{RAILS_VER} (ActiveRecord version #{ActiveRecord::VERSION::STRING})"
 
-require 'validates_timeliness'
-
 if RAILS_VER >= '2.1'
   Time.zone_default = ActiveSupport::TimeZone['UTC']
   ActiveRecord::Base.time_zone_aware_attributes = true
 end
 
+require 'validates_timeliness'
+require 'validates_timeliness/matcher'
+
+ValidatesTimeliness.enable_datetime_select_extension!
+
 ActiveRecord::Migration.verbose = false
 ActiveRecord::Base.establish_connection({:adapter => 'sqlite3', :database => ':memory:'})
 

spec/validator_spec.rb

@@ -3,6 +3,14 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 describe ValidatesTimeliness::Validator do
   attr_accessor :person, :validator
 
+  if ValidatesTimeliness::I18N_LATEST
+    I18N_REGEXP = /\%\{\w*\}/
+    I18N_INTERPOLATION = '%{%s}'
+  else
+    I18N_REGEXP = /\{\{\w*\}\}/
+    I18N_INTERPOLATION = '{{%s}}'
+  end
+
   before :all do
     # freezes time using time_travel plugin
     Time.now = Time.utc(2000, 1, 1, 0, 0, 0)
@@ -12,59 +20,75 @@ describe ValidatesTimeliness::Validator do
     Time.now = nil
   end
 
-  before :each do
-    @person = Person.new
+  def person
+    @person ||= Person.new
   end
 
-  describe "restriction_value" do
+  describe "option keys validation" do
+    before do
+      keys = ValidatesTimeliness::Validator::VALID_OPTION_KEYS - [: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 == [parse(time2, :datetime), parse(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 == [parse(time2, :datetime), parse(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 +354,120 @@ describe ValidatesTimeliness::Validator do
     end
   end
 
+  describe "instance with :is_at restriction" do
+
+    describe "for datetime type" do
+      before do
+        configure_validator(:is_at => Time.now)
+      end
+
+      it "should have error when value not equal to :is_at restriction" do
+        validate_with(:birth_date_and_time, Time.now + 1)
+        should_have_error(:birth_date_and_time, :is_at)
+      end
+
+      it "should be valid when value is equal to :is_at restriction" do
+        validate_with(:birth_date_and_time, Time.now)
+        should_have_no_error(:birth_date_and_time, :is_at)
+      end
+    end
+
+    describe "for date type" do
+      before do
+        configure_validator(:type => :date, :is_at => Date.today)
+      end
+
+      it "should have error when value is not equal to :is_at restriction" do
+        validate_with(:birth_date, Date.today + 1)
+        should_have_error(:birth_date, :is_at)
+      end
+
+      it "should be valid when value is equal to :is_at restriction" do
+        validate_with(:birth_date, Date.today)
+        should_have_no_error(:birth_date, :is_at)
+      end
+    end
+
+    describe "for time type" do
+      before do
+        configure_validator(:type => :time, :is_at => "09:00:00")
+      end
+
+      it "should have error when value is not equal to :is_at restriction" do
+        validate_with(:birth_time, "09:00:01")
+        should_have_error(:birth_time, :is_at)
+      end
+
+      it "should be valid when value is equal to :is_at restriction" do
+        validate_with(:birth_time, "09:00:00")
+        should_have_no_error(:birth_time, :is_at)
+      end
+    end
+  end
+
+  describe "instance with :ignore_usec option" do
+
+    it "should ignore usec on time values when evaluated" do
+      configure_validator(:is_at => 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, :is_at)
+    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
+
+    it "should skip restriction validation if :with_time value evaluates to nil" do
+      configure_validator(:type => :date, :with_time => lambda { 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
+
+    it "should should ignore usec value on combined value if :ignore_usec option is true" do
+      configure_validator(:type => :date, :with_time => Time.mktime(2000,1,1,12,30,0,500), :is_at => Time.mktime(2000,1,1,12,30), :ignore_usec => true)
+      validate_with(:birth_date, "2000-01-01")
+      should_have_no_error(:birth_date, :is_at)
+    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_time, "12:30")
+      should_have_error(:birth_time, :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_time, "12:30")
+      should_have_no_error(:birth_time, :on_or_before)
+    end
+
+    it "should skip restriction validation if :with_date value is nil" do
+      configure_validator(:type => :time, :with_date => lambda { nil }, :on_or_before => Time.mktime(2000,1,1,12,30))
+      validate_with(:birth_time, "12:30")
+      should_have_no_error(:birth_time, :on_or_before)
+    end
+
+    it "should should ignore usec value on combined value if :ignore_usec option is true" do
+      configure_validator(:type => :time, :with_date => Date.new(2000,1,1), :on_or_before => Time.mktime(2000,1,1,12,30), :ignore_usec => true)
+      validate_with(:birth_time, Time.mktime(2000,1,1,12,30,0,50))
+      should_have_no_error(:birth_time, :on_or_before)
+    end
+  end
+
   describe "instance with mixed value and restriction types" do
 
     it "should validate datetime attribute with Date restriction" do
@@ -363,6 +501,53 @@ describe ValidatesTimeliness::Validator do
     end
   end
 
+  describe "instance with format option" do
+    it "should validate attribute when value matches format" do
+      configure_validator(:type => :time, :format => 'hh:nn:ss')
+      validate_with(:birth_time, "12:00:00")
+      should_have_no_error(:birth_time, :invalid_time)
+    end
+
+    it "should not validate attribute when value does not match format" do
+      configure_validator(:type => :time, :format => 'hh:nn:ss')
+      validate_with(:birth_time, "12:00")
+      should_have_error(:birth_time, :invalid_time)
+    end
+  end
+
+  if defined?(I18n)
+
+    describe "localized error messages" do
+      before(:all) do
+        message = "retfa #{I18N_INTERPOLATION}" % 'restriction'
+        translations = {
+          :activerecord => {:errors => {:messages => { :after => message }}},
+          :validates_timeliness => {:error_value_formats => {}}
+        }
+        I18n.backend.store_translations 'zz', translations
+        I18n.locale = :zz
+      end
+
+      it "should be used if defined" do
+        configure_validator(:type => :date, :after => Date.today)
+        validate_with(:birth_date, 1.day.ago)
+        person.errors.on(:birth_date).should match(/retfa/)
+      end
+
+      it "should use I18n translation missing message when not defined" do
+        configure_validator(:type => :date, :on_or_after => Date.today)
+        validate_with(:birth_date, 1.day.ago)
+        person.errors.on(:birth_date).should match(/translation missing/)
+      end
+
+      after(:all) do
+        I18n.locale = :en
+      end
+
+    end
+
+  end
+
   describe "custom_error_messages" do
     it "should return hash of custom error messages from configuration with _message truncated from keys" do
       configure_validator(:type => :date, :invalid_date_message => 'thats no date')
@@ -382,12 +567,6 @@ describe ValidatesTimeliness::Validator do
         configure_validator(:type => :date, :before => before)
         validator.send(:interpolation_values, :before, before.to_date).should == {:restriction => before}
       end
-
-      it "should return empty hash if no interpolation keys are in message" do
-        before = '1900-01-01'
-        configure_validator(:type => :date, :before => before, :before_message => 'too late')
-        validator.send(:interpolation_values, :before, before.to_date).should be_empty
-      end
     else
       it "should return array of interpolation values" do
         before = '1900-01-01'
@@ -439,17 +618,42 @@ describe ValidatesTimeliness::Validator do
         validate_with(:birth_time, '11:59')
         person.errors.on(:birth_time).should match(/after \d{2}:\d{2}:\d{2}\Z/)
       end
+
+      if defined?(I18n)
+
+        describe "I18n" do
+          it "should use global default if locale format missing" do
+            message = "after #{I18N_INTERPOLATION}" % 'restriction'
+            I18n.backend.store_translations 'zz', :activerecord => {:errors => {:messages => { :after => message }}}
+            I18n.locale = :zz
+            configure_validator(:type => :datetime, :after => 1.day.from_now)
+            validate_with(:birth_date_and_time, Time.now)
+            person.errors.on(:birth_date_and_time).should match(/after \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\Z/)
+          end
+
+          after do
+            I18n.locale = :en
+          end
+        end
+
+      end
     end
 
     describe "custom formats" do
 
       before :all do
-        @@formats = ValidatesTimeliness::Validator.error_value_formats
-        ValidatesTimeliness::Validator.error_value_formats = {
+        custom = {
           :time     => '%H:%M %p',
           :date     => '%d-%m-%Y',
           :datetime => '%d-%m-%Y %H:%M %p'
         }
+
+        if defined?(I18n)
+          I18n.backend.store_translations 'en', :validates_timeliness => { :error_value_formats => custom }
+        else
+          @@formats = ValidatesTimeliness::Validator.error_value_formats
+          ValidatesTimeliness::Validator.error_value_formats = custom
+        end
       end
 
       it "should format datetime value of restriction" do
@@ -471,19 +675,27 @@ describe ValidatesTimeliness::Validator do
       end
 
       after :all do
-        ValidatesTimeliness::Validator.error_value_formats = @@formats
+        if defined?(I18n)
+          I18n.reload!
+        else
+          ValidatesTimeliness::Validator.error_value_formats = @@formats
+        end
       end
     end
 
   end
 
+  def parse(*args)
+    ValidatesTimeliness::Parser.parse(*args)
+  end
+
   def configure_validator(options={})
     @validator = ValidatesTimeliness::Validator.new(options)
   end
 
   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)
@@ -503,7 +715,7 @@ describe ValidatesTimeliness::Validator do
 
   def error_messages
     return @error_messages if defined?(@error_messages)
-    messages = validator.send(:error_messages)
-    @error_messages = messages.inject({}) {|h, (k, v)| h[k] = v.sub(/ (\%s|\{\{\w*\}\}).*/, ''); h }
+    messages = defined?(I18n) ? I18n.t('activerecord.errors.messages') : validator.send(:error_messages)
+    @error_messages = messages.inject({}) {|h, (k, v)| h[k] = v.sub(/ (\%s|#{I18N_REGEXP}).*/, ''); h }
   end
 end

validates_timeliness.gemspec

@@ -2,28 +2,27 @@
 
 Gem::Specification.new do |s|
   s.name = %q{validates_timeliness}
-  s.version = "1.1.5"
+  s.version = "2.3.2"
 
   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-21}
+  s.date = %q{2010-11-07}
   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"]
-  s.files = ["LICENSE", "README.rdoc", "Rakefile", "TODO", "CHANGELOG", "lib/validates_timeliness", "lib/validates_timeliness/core_ext", "lib/validates_timeliness/core_ext/date.rb", "lib/validates_timeliness/core_ext/date_time.rb", "lib/validates_timeliness/core_ext/time.rb", "lib/validates_timeliness/action_view", "lib/validates_timeliness/action_view/instance_tag.rb", "lib/validates_timeliness/locale", "lib/validates_timeliness/locale/en.yml", "lib/validates_timeliness/validation_methods.rb", "lib/validates_timeliness/active_record", "lib/validates_timeliness/active_record/attribute_methods.rb", "lib/validates_timeliness/active_record/multiparameter_attributes.rb", "lib/validates_timeliness/formats.rb", "lib/validates_timeliness/validator.rb", "lib/validates_timeliness/spec", "lib/validates_timeliness/spec/rails", "lib/validates_timeliness/spec/rails/matchers", "lib/validates_timeliness/spec/rails/matchers/validate_timeliness.rb", "lib/validates_timeliness.rb", "spec/core_ext", "spec/core_ext/dummy_time_spec.rb", "spec/validator_spec.rb", "spec/action_view", "spec/action_view/instance_tag_spec.rb", "spec/ginger_scenarios.rb", "spec/validation_methods_spec.rb", "spec/spec_helper.rb", "spec/formats_spec.rb", "spec/active_record", "spec/active_record/attribute_methods_spec.rb", "spec/active_record/multiparameter_attributes_spec.rb", "spec/time_travel", "spec/time_travel/time_travel.rb", "spec/time_travel/time_extensions.rb", "spec/time_travel/MIT-LICENSE", "spec/spec", "spec/spec/rails", "spec/spec/rails/matchers", "spec/spec/rails/matchers/validate_timeliness_spec.rb", "spec/resources", "spec/resources/person.rb", "spec/resources/sqlite_patch.rb", "spec/resources/schema.rb", "spec/resources/application.rb"]
-  s.has_rdoc = true
+  s.files = ["LICENSE", "README.rdoc", "Rakefile", "TODO", "CHANGELOG", "lib/validates_timeliness", "lib/validates_timeliness/action_view", "lib/validates_timeliness/action_view/instance_tag.rb", "lib/validates_timeliness/active_record", "lib/validates_timeliness/active_record/attribute_methods.rb", "lib/validates_timeliness/active_record/multiparameter_attributes.rb", "lib/validates_timeliness/formats.rb", "lib/validates_timeliness/locale", "lib/validates_timeliness/locale/en.new.yml", "lib/validates_timeliness/locale/en.old.yml", "lib/validates_timeliness/matcher.rb", "lib/validates_timeliness/parser.rb", "lib/validates_timeliness/spec", "lib/validates_timeliness/spec/rails", "lib/validates_timeliness/spec/rails/matchers", "lib/validates_timeliness/spec/rails/matchers/validate_timeliness.rb", "lib/validates_timeliness/validation_methods.rb", "lib/validates_timeliness/validator.rb", "lib/validates_timeliness/version.rb", "lib/validates_timeliness.rb", "spec/action_view", "spec/action_view/instance_tag_spec.rb", "spec/active_record", "spec/active_record/attribute_methods_spec.rb", "spec/active_record/multiparameter_attributes_spec.rb", "spec/formats_spec.rb", "spec/ginger_scenarios.rb", "spec/parser_spec.rb", "spec/resources", "spec/resources/application.rb", "spec/resources/person.rb", "spec/resources/schema.rb", "spec/resources/sqlite_patch.rb", "spec/spec", "spec/spec/rails", "spec/spec/rails/matchers", "spec/spec/rails/matchers/validate_timeliness_spec.rb", "spec/spec_helper.rb", "spec/time_travel", "spec/time_travel/MIT-LICENSE", "spec/time_travel/time_extensions.rb", "spec/time_travel/time_travel.rb", "spec/validator_spec.rb"]
   s.homepage = %q{http://github.com/adzap/validates_timeliness}
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{validatestime}
-  s.rubygems_version = %q{1.3.1}
+  s.rubygems_version = %q{1.3.7}
   s.summary = %q{Date and time validation plugin for Rails 2.x which allows custom formats}
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 2
+    s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
     else
     end
   else