Convert README to markdown

Also:
- Highlight syntax
- Change http to https
- Update License
- Fix default value of today (Date.current)

.travis.yml

@@ -1,16 +1,54 @@
+dist: focal
+os: linux
 language: ruby
+before_install: gem install bundler
 cache: bundler
 
 gemfile:
-  - gemfiles/rails_4_0.gemfile
-  - gemfiles/rails_4_1.gemfile
-  - gemfiles/rails_4_2.gemfile
+  - gemfiles/rails_5_0.gemfile
+  - gemfiles/rails_5_1.gemfile
+  - gemfiles/rails_5_2.gemfile
+  - gemfiles/rails_6_0.gemfile
+  - gemfiles/rails_6_1.gemfile
+  - gemfiles/rails_edge.gemfile
 
 rvm:
-  - "2.2.3"
-  - "2.3.0"
+  - "2.5.8"
+  - "2.6.6"
+  - "2.7.2"
+  - "3.0.0"
+  - ruby-head
 
-script: 'bundle exec rake'
+jobs:
+  allow_failures:
+    - rvm: ruby-head
+    - gemfile: gemfiles/rails_edge.gemfile
+  exclude:
+    - rvm: 2.5.8
+      gemfile: gemfiles/rails_edge.gemfile
+    - rvm: 2.6.6
+      gemfile: gemfiles/rails_edge.gemfile
+    - rvm: 2.7.2
+      gemfile: gemfiles/rails_5_0.gemfile
+    - rvm: 2.7.2
+      gemfile: gemfiles/rails_5_1.gemfile
+    - rvm: 2.7.2
+      gemfile: gemfiles/rails_5_2.gemfile
+    - rvm: 3.0.0
+      gemfile: gemfiles/rails_5_0.gemfile
+    - rvm: 3.0.0
+      gemfile: gemfiles/rails_5_1.gemfile
+    - rvm: 3.0.0
+      gemfile: gemfiles/rails_5_2.gemfile
+    - rvm: ruby-head
+      gemfile: gemfiles/rails_5_0.gemfile
+    - rvm: ruby-head
+      gemfile: gemfiles/rails_5_1.gemfile
+    - rvm: ruby-head
+      gemfile: gemfiles/rails_5_2.gemfile
+  fast_finish: true
+
+script: 'bundle exec rspec'
 
 notifications:
   email:

Appraisals

@@ -1,11 +1,24 @@
-appraise "rails_4_0" do
-  gem "rails", "~> 4.0.13"
+appraise "rails_5_0" do
+  gem "rails", "~> 5.0.0"
+  gem 'sqlite3', '~> 1.3.6'
 end
 
-appraise "rails_4_1" do
-  gem "rails", "~> 4.1.14"
+appraise "rails_5_1" do
+  gem "rails", "~> 5.1.0"
 end
 
-appraise "rails_4_2" do
-  gem "rails", "~> 4.2.5"
+appraise "rails_5_2" do
+  gem "rails", "~> 5.2.0"
+end
+
+appraise "rails_6_0" do
+  gem "rails", "~> 6.0.0"
+end
+
+appraise "rails_6_1" do
+  gem "rails", "~> 6.1.0"
+end
+
+appraise "rails_edge" do
+  gem "rails", git: "https://github.com/rails/rails.git", branch: "main"
 end

CHANGELOG.rdoc

@@ -1,3 +1,30 @@
+= [UNRELEASED]
+* Fix DateTimeSelect extension support (AquisTech)
+* Relaxed Timeliness dependency version which allows for >= 0.4.0 with
+  threadsafety fix for use_us_formats and use_euro_formats for hot switching
+	in a request.
+* Add initializer to ensure Timeliness v0.4+ ambiguous date config is set
+  correctly when using `use_euro_formats` or `remove_use_formats'.
+* Add Ruby 3 compatibility
+* Add Rails 6.1 compatibility
+
+Breaking Changes
+* Update Multiparameter extension to use ActiveRecord type classes with multiparameter handling
+  which stores a hash of multiparamter values as the value before type cast, no longer a mushed datetime string
+* Removed all custom plugin attribute methods and method overrides in favour using ActiveModel type system
+
+= 4.1.0 [2019-06-11]
+* Relaxed Timeliness dependency version to >= 0.3.10 and < 1, which allows
+  version 0.4 with threadsafety fix for use_us_formats and use_euro_formats
+  hot switching in a request.
+
+= 4.0.2 [2016-01-07]
+* Fix undefine_generated_methods ivar guard setting to false
+
+= 4.0.1 [2016-01-06]
+* Fix undefine_generated_methods thread locking bug
+* Created an ActiveModel ORM, for manual require if using without any full blown ORM
+
 = 4.0.0 [2015-12-29]
 * Extracted mongoid support into https://github.com/adzap/validates_timeliness-mongoid which is broken (not supported anymore).
 * Fixed Rails 4.0, 4.1 and 4.2 compatability issues

Gemfile

@@ -2,15 +2,11 @@ source 'http://rubygems.org'
 
 gemspec
 
-gem 'rails', '~> 4.0.13'
-gem 'rspec', '~> 3.4.0'
-gem 'rspec-rails', '~> 3.4.0'
+gem 'rails', '~> 6.1.0'
+gem 'rspec'
+gem 'rspec-rails', '~> 3.7'
+gem 'sqlite3'
 gem 'timecop'
 gem 'byebug'
 gem 'appraisal'
-gem 'sqlite3'
-gem 'nokogiri', '1.6.7'
-
-group :active_record do
-  gem 'sqlite3-ruby', :require => 'sqlite3'
-end
+gem 'nokogiri', '~> 1.8'

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008-2010 Adam Meehan
+Copyright (c) 2008-2021 Adam Meehan
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

README.md

@@ -0,0 +1,353 @@
+# ValidatesTimeliness [![Build Status](https://travis-ci.org/adzap/validates_timeliness.svg?branch=master)](https://travis-ci.org/adzap/validates_timeliness)
+
+* Source:  https://github.com/adzap/validates_timeliness
+* Issues:  https://github.com/adzap/validates_timeliness/issues
+
+
+## Description
+
+Complete validation of dates, times and datetimes for Rails 5.x, 6.x, and
+ActiveModel.
+
+If you a looking for the old version for Rails 4.x go here
+[https://github.com/adzap/validates_timeliness/tree/4-0-stable].
+
+## Features
+
+* Adds validation for dates, times and datetimes to ActiveModel
+* Handles timezones and type casting of values for you
+* Only Rails date/time validation plugin offering complete validation (See
+  ORM/ODM support)
+* Uses extensible date/time parser (Using [timeliness
+  gem](https://github.com/adzap/timeliness). See Plugin Parser)
+* Adds extensions to fix Rails date/time select issues (See Extensions)
+* Supports I18n for the error messages. For multi-language support try
+  [timeliness-i18n gem](https://github.com/pedrofurtado/timeliness-i18n).
+* Supports all the Rubies (that any sane person would be using in
+  production).
+
+
+## Installation
+
+```
+# in Gemfile
+gem 'validates_timeliness', '~> 5.0.0.beta1'
+
+# Run bundler
+$ bundle install
+```
+
+Then run
+
+```sh
+$ rails generate validates_timeliness:install
+```
+
+This creates configuration initializer and locale files. In the initializer,
+there are a number of config options to customize the plugin.
+
+NOTE: You may wish to enable the plugin parser and the extensions to start.
+Please read those sections first.
+
+## Examples
+
+```ruby
+validates_datetime :occurred_at
+
+validates_date :date_of_birth, before: lambda { 18.years.ago },
+                               before_message: "must be at least 18 years old"
+
+validates_datetime :finish_time, after: :start_time # Method symbol
+
+validates_date :booked_at, on: :create, on_or_after: :today # See Restriction Shorthand.
+
+validates_time :booked_at, between: ['9:00am', '5:00pm'] # On or after 9:00AM and on or before 5:00PM
+validates_time :booked_at, between: '9:00am'..'5:00pm' # The same as previous example
+validates_time :booked_at, between: '9:00am'...'5:00pm' # On or after 9:00AM and strictly before 5:00PM
+
+validates_time :breakfast_time, on_or_after: '6:00am',
+                                on_or_after_message: 'must be after opening time',
+                                before: :lunchtime,
+                                before_message: 'must be before lunch time'
+```
+
+## Usage
+
+To validate a model with a date, time or datetime attribute you just use the
+validation method
+
+```ruby
+class Person < ActiveRecord::Base
+  validates_date :date_of_birth, on_or_before: lambda { Date.current }
+  # or
+  validates :date_of_birth, timeliness: { on_or_before: lambda { Date.current }, type: :date }
+end
+```
+
+or even on a specific record, per ActiveModel API.
+
+```ruby
+@person.validates_date :date_of_birth, on_or_before: lambda { Date.current }
+```
+
+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          - use the :timeliness key and set the type in the hash.
+```
+
+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):
+
+```
+: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. Range or Array of 2 values.
+```
+
+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
+:on           - Specify validation context e.g :save, :create or :update. Default is :save.
+```
+
+Special options:
+
+```
+:ignore_usec  - Ignores microsecond value on datetime restrictions
+:format       - Limit validation to a single format for special cases. Requires plugin parser.
+```
+
+The temporal restrictions can take 4 different value types:
+
+* Date, Time, or DateTime object value
+* Proc or lambda object which may take an optional parameter, being the
+  record object
+* A symbol matching a method name in the model
+* String value
+
+
+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.
+
+## Configuration
+
+### ORM/ODM Support
+
+The plugin adds date/time validation to ActiveModel for any ORM/ODM that
+supports the ActiveModel validations component. However, there is an issue
+with most ORM/ODMs which does not allow 100% date/time validation by default.
+Specifically, when you assign an invalid date/time value to an attribute, most
+ORM/ODMs will only store a nil value for the attribute. This causes an issue
+for date/time validation, since we need to know that a value was assigned but
+was invalid. To fix this, we need to cache the original invalid value to know
+that the attribute is not just nil.
+
+Each ORM/ODM requires a specific shim to fix it. The plugin includes a shim
+for ActiveRecord and Mongoid. You can activate them like so
+
+```ruby
+ValidatesTimeliness.setup do |config|
+  # Extend ORM/ODMs for full support (:active_record).
+  config.extend_orms = [ :active_record ]
+end
+```
+
+By default the plugin extends ActiveRecord if loaded. If you wish to extend
+another ORM then look at the [wiki
+page](https://github.com/adzap/validates_timeliness/wiki/ORM-Support) for more
+information.
+
+It is not required that you use a shim, but you will not catch errors when the
+attribute value is invalid and evaluated to nil.
+
+### Error Messages
+
+Using the I18n system to define new defaults:
+
+```yaml
+en:
+  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}"
+```
+
+The `%{restriction}` signifies where the interpolation value for the restriction
+will be inserted.
+
+You can also use validation options for custom error messages. The following
+option keys are available:
+
+```ruby
+:invalid_date_message
+:invalid_time_message
+:invalid_datetime_message
+:is_at_message
+:before_message
+:on_or_before_message
+:after_message
+:on_or_after_message
+```
+
+Note: There is no `:between_message` option. The between error message should be
+defined using the `:on_or_after` and `:on_or_before` (`:before` in case when
+`:between` argument is a Range with excluded high value, see Examples) messages.
+
+It is highly recommended you use the I18n system for error messages.
+
+### Plugin Parser
+
+The plugin uses the [timeliness gem](https://github.com/adzap/timeliness) as a
+fast, configurable and extensible date and time parser. You can add or remove
+valid formats for dates, times, and datetimes. It is also more strict than the
+Ruby parser, which means it won't accept day of the month if it's not a valid
+number for the month.
+
+By default the parser is disabled. To enable it:
+
+```ruby
+# in the setup block
+config.use_plugin_parser = true
+```
+
+Enabling the parser will mean that strings assigned to attributes validated
+with the plugin will be parsed using the gem. See the
+[wiki](https://github.com/adzap/validates_timeliness/wiki/Plugin-Parser) for
+more details about the parser configuration.
+
+### Restriction Shorthand
+
+It is common to restrict an attribute to being on or before the current time
+or current day. To specify this you need to use a lambda as an option value
+e.g. `lambda { Time.current }`. This can be tedious noise amongst your
+validations for something so common. To combat this the plugin allows you to
+use shorthand symbols for often used relative times or dates.
+
+Just provide the symbol as the option value like so:
+
+```ruby
+validates_date :birth_date, on_or_before: :today
+```
+
+The `:today` symbol is evaluated as `lambda { Date.current }`. The `:now` and
+`:today` symbols are pre-configured. Configure your own like so:
+
+```ruby
+# in the setup block
+config.restriction_shorthand_symbols.update(
+  yesterday: lambda { 1.day.ago }
+)
+```
+
+### Default Timezone
+
+The plugin needs to know the default timezone you are using when parsing or
+type casting values. If you are using ActiveRecord then the default is
+automatically set to the same default zone as ActiveRecord. If you are using
+another ORM you may need to change this setting.
+
+```ruby
+# in the setup block
+config.default_timezone = :utc
+```
+
+By default it will be UTC if ActiveRecord is not loaded.
+
+### 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
+
+```ruby
+# in the setup block
+config.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 option value itself may be invalid. This will add an error to the
+model such as 'Error occurred validating birth_date for :before restriction'.
+These can be annoying in development or production as you most likely just
+want to skip the option if no valid value was returned. By default these
+errors are displayed in Rails test mode.
+
+To turn them on/off:
+
+```ruby
+# in the setup block
+config.ignore_restriction_errors = true
+```
+
+## Extensions
+
+### Strict Parsing for Select Helpers
+
+When using date/time select helpers, the component values are handled by
+ActiveRecord using the Time class to instantiate them into a time value. This
+means that some invalid dates, such as 31st June, are shifted forward and
+treated as valid. To handle these cases in a strict way, you can enable the
+plugin extension to treat them as invalid dates.
+
+To activate it, uncomment this line in the initializer:
+
+```ruby
+# in the setup block
+config.enable_multiparameter_extension!
+```
+
+### Display Invalid Values in Select Helpers
+
+The plugin offers an extension for ActionView to 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 occurrence, given the select dropdowns for each date/time
+component, but it may be something of interest.
+
+To activate it, uncomment this line in the initializer:
+
+```ruby
+# in the setup block
+config.enable_date_time_select_extension!
+```
+
+## Contributors
+
+To see the generous people who have contributed code, take a look at the
+[contributors
+list](https://github.com/adzap/validates_timeliness/contributors).
+
+## Maintainers
+
+* [Adam Meehan](https://github.com/adzap)
+
+
+## License
+
+Copyright (c) 2008 Adam Meehan, released under the MIT license

README.rdoc

@@ -1,299 +0,0 @@
-= ValidatesTimeliness
-
-* Source:  http://github.com/adzap/validates_timeliness
-* Issues:  http://github.com/adzap/validates_timeliness/issues
-
-== Description
-
-Complete validation of dates, times and datetimes for Rails 4.x and ActiveModel.
-
-If you a looking for the old version for Rails 3.x go here[http://github.com/adzap/validates_timeliness/tree/v3.x].
-
-
-== Features
-
-* Adds validation for dates, times and datetimes to ActiveModel
-
-* Handles timezones and type casting of values for you
-
-* Only Rails date/time validation plugin offering complete validation (See ORM/ODM support)
-
-* Uses extensible date/time parser (Using {timeliness gem}[http://github.com/adzap/timeliness]. See Plugin Parser)
-
-* Adds extensions to fix Rails date/time select issues (See Extensions)
-
-* Supports I18n for the error messages
-
-* Supports all the Rubies (that any sane person would be using in production).
-
-
-== Installation
-
-  # in Gemfile
-  gem 'validates_timeliness', '~> 4.0'
-
-  # Run bundler
-  $ bundle install
-
-Then run
-  
-  $ rails generate validates_timeliness:install
-
-This creates configuration initializer and locale files. In the initializer, there are a number of config
-options to customize the plugin.
-
-NOTE: You may wish to enable the plugin parser and the extensions to start. Please read those sections first.
-
-
-== Examples
-
-  validates_datetime :occurred_at
-
-  validates_date :date_of_birth, :before => lambda { 18.years.ago },
-                                 :before_message => "must be at least 18 years old"
-
-  validates_datetime :finish_time, :after => :start_time # Method symbol
-
-  validates_date :booked_at, :on => :create, :on_or_after => :today # See Restriction Shorthand.
-
-  validates_time :booked_at, :between => ['9:00am', '5:00pm'] # On or after 9:00AM and on or before 5:00PM
-  validates_time :booked_at, :between => '9:00am'..'5:00pm' # The same as previous example
-  validates_time :booked_at, :between => '9:00am'...'5:00pm' # On or after 9:00AM and strictly before 5:00PM
-
-  validates_time :breakfast_time, :on_or_after => '6:00am',
-                                  :on_or_after_message => 'must be after opening time',
-                                  :before => :lunchtime,
-                                  :before_message => 'must be before lunch time'
-
-
-== Usage
-
-To validate a model with a date, time or datetime attribute you just use the
-validation method
-
-  class Person < ActiveRecord::Base
-    validates_date :date_of_birth, :on_or_before => lambda { Date.current }
-    # or
-    validates :date_of_birth, :timeliness => {:on_or_before => lambda { Date.current }, :type => :date}
-  end
-
-or even on a specific record, per ActiveModel API.
-
-  @person.validates_date :date_of_birth, :on_or_before => lambda { Date.current }
-
-
-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          - use the :timeliness key and set the type in the hash.
-
-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):
-  :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. Range or Array of 2 values. 
-
-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
-  :on           - Specify validation context e.g :save, :create or :update. Default is :save.
-
-Special options:
-  :ignore_usec  - Ignores microsecond value on datetime restrictions
-  :format       - Limit validation to a single format for special cases. Requires plugin parser.
-
-The temporal restrictions can take 4 different value types:
-
-* Date, Time, or DateTime object value
-* Proc or lambda object which may take an optional parameter, being the record object
-* A symbol matching a method name in the model
-* String value
-
-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.
-
-
-== Configuration
-
-=== ORM/ODM Support
-
-The plugin adds date/time validation to ActiveModel for any ORM/ODM that supports the ActiveModel validations component.
-However, there is an issue with most ORM/ODMs which does not allow 100% date/time validation by default. Specifically, when you
-assign an invalid date/time value to an attribute, most ORM/ODMs will only store a nil value for the attribute. This causes an
-issue for date/time validation, since we need to know that a value was assigned but was invalid. To fix this, we need to cache
-the original invalid value to know that the attribute is not just nil.
-
-Each ORM/ODM requires a specific shim to fix it. The plugin includes a shim for ActiveRecord and Mongoid. You can activate them
-like so
-
-  ValidatesTimeliness.setup do |config|
-
-    # Extend ORM/ODMs for full support (:active_record).
-    config.extend_orms = [ :active_record ]
-
-  end
-
-By default the plugin extends ActiveRecord if loaded. If you wish to extend another ORM then look at the {wiki page}[http://github.com/adzap/validates_timeliness/wiki/ORM-Support] for more information.
-
-It is not required that you use a shim, but you will not catch errors when the attribute value is invalid and evaluated to nil.
-
-
-=== Error Messages
-
-Using the I18n system to define new defaults:
-
-  en:
-    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}"
-
-The %{restriction} signifies where the interpolation value for the restriction will be inserted.
-
-You can also use validation options for custom error messages. The following option keys are available:
-
-    :invalid_date_message
-    :invalid_time_message
-    :invalid_datetime_message
-    :is_at_message
-    :before_message
-    :on_or_before_message
-    :after_message
-    :on_or_after_message
-
-Note: There is no :between_message option. The between error message should be defined using the :on_or_after and :on_or_before
-(:before in case when :between argument is a Range with excluded high value, see Examples) messages.
-
-It is highly recommended you use the I18n system for error messages.
-
-
-=== Plugin Parser
-
-The plugin uses the {timeliness gem}[http://github.com/adzap/timeliness] as a fast, configurable and extensible date and time parser.
-You can add or remove valid formats for dates, times, and datetimes. It is also more strict than the
-Ruby parser, which means it won't accept day of the month if it's not a valid number for the month.
-
-By default the parser is disabled. To enable it:
-
-  # in the setup block
-  config.use_plugin_parser = true
-
-Enabling the parser will mean that strings assigned to attributes validated with the plugin will be parsed
-using the gem. See the wiki[http://github.com/adzap/validates_timeliness/wiki/Plugin-Parser] for more details about the parser configuration.
-
-
-=== Restriction Shorthand
-
-It is common to restrict an attribute to being on or before the current time or current day. 
-To specify this you need to use a lambda as an option value e.g. <tt>lambda { Time.current }</tt>.
-This can be tedious noise amongst your validations for something so common. To combat this the
-plugin allows you to use shorthand symbols for often used relative times or dates.
-
-Just provide the symbol as the option value like so:
-
-  validates_date :birth_date, :on_or_before => :today
-
-The :today symbol is evaluated as <tt>lambda { Date.today }</tt>. The :now and :today
-symbols are pre-configured. Configure your own like so:
-
-  # in the setup block
-  config.restriction_shorthand_symbols.update(
-    :yesterday => lambda { 1.day.ago }
-  )
-
-
-=== Default Timezone
-
-The plugin needs to know the default timezone you are using when parsing or type casting values. If you are using
-ActiveRecord then the default is automatically set to the same default zone as ActiveRecord. If you are using 
-another ORM you may need to change this setting.
-
-  # in the setup block
-  config.default_timezone = :utc
-
-By default it will be UTC if ActiveRecord is not loaded.
-
-
-=== 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
-
-  # in the setup block
-  config.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
-option value itself may be invalid. This will add an error to the model such as
-'Error occurred validating birth_date for :before restriction'. These can be annoying
-in development or production as you most likely just want to skip the option if no
-valid value was returned. By default these errors are displayed in Rails test mode.
-
-To turn them on/off:
-
-  # in the setup block
-  config.ignore_restriction_errors = true
-
-
-== Extensions
-
-=== Strict Parsing for Select Helpers
-
-When using date/time select helpers, the component values are handled by ActiveRecord using
-the Time class to instantiate them into a time value. This means that some invalid dates,
-such as 31st June, are shifted forward and treated as valid. To handle these cases in a strict
-way, you can enable the plugin extension to treat them as invalid dates.
-
-To activate it, uncomment this line in the initializer:
-
-  # in the setup block
-  config.enable_multiparameter_extension!
-
-
-=== Display Invalid Values in Select Helpers
-
-The plugin offers an extension for ActionView to 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 occurrence, given the select dropdowns
-for each date/time component, but it may be something of interest.
-
-To activate it, uncomment this line in the initializer:
-
-  # in the setup block
-  config.enable_date_time_select_extension!
-
-
-== Contributors
-
-To see the generous people who have contributed code, take a look at the {contributors list}[http://github.com/adzap/validates_timeliness/contributors].
-
-
-== Maintainers
-
-* {Adam Meehan}[http://github.com/adzap]
-
-
-== License
-
-Copyright (c) 2008 Adam Meehan, released under the MIT license

Rakefile

@@ -19,10 +19,11 @@ end
 
 desc 'Generate documentation for plugin.'
 Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.main = 'README.md'
   rdoc.rdoc_dir = 'rdoc'
   rdoc.title    = 'ValidatesTimeliness'
   rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('README.md')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 

gemfiles/rails_4_0.gemfile

@@ -1,19 +0,0 @@
-# This file was generated by Appraisal
-
-source "http://rubygems.org"
-
-gem "rails", "~> 4.0.0"
-gem "rspec", "~> 3.0.0"
-gem "rspec-rails", "~> 3.0.0"
-gem "timecop"
-gem "rspec_tag_matchers"
-gem "byebug"
-gem "appraisal"
-gem "sqlite3"
-gem "nokogiri", "1.6.7"
-
-group :active_record do
-  gem "sqlite3-ruby", :require => "sqlite3"
-end
-
-gemspec :path => "../"

gemfiles/rails_4_1.gemfile

@@ -1,19 +0,0 @@
-# This file was generated by Appraisal
-
-source "http://rubygems.org"
-
-gem "rails", "~> 4.1.0"
-gem "rspec", "~> 3.0.0"
-gem "rspec-rails", "~> 3.0.0"
-gem "timecop"
-gem "rspec_tag_matchers"
-gem "byebug"
-gem "appraisal"
-gem "sqlite3"
-gem "nokogiri", "1.6.7"
-
-group :active_record do
-  gem "sqlite3-ruby", :require => "sqlite3"
-end
-
-gemspec :path => "../"

gemfiles/rails_4_2.gemfile

@@ -1,19 +0,0 @@
-# This file was generated by Appraisal
-
-source "http://rubygems.org"
-
-gem "rails", "~> 4.2.0"
-gem "rspec", "~> 3.0.0"
-gem "rspec-rails", "~> 3.0.0"
-gem "timecop"
-gem "rspec_tag_matchers"
-gem "byebug"
-gem "appraisal"
-gem "sqlite3"
-gem "nokogiri", "1.6.7"
-
-group :active_record do
-  gem "sqlite3-ruby", :require => "sqlite3"
-end
-
-gemspec :path => "../"

gemfiles/rails_5_0.gemfile

@@ -0,0 +1,14 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", "~> 5.0.0"
+gem "rspec"
+gem "rspec-rails", "~> 3.7"
+gem "sqlite3", "~> 1.3.6"
+gem "timecop"
+gem "byebug"
+gem "appraisal"
+gem "nokogiri", "~> 1.8"
+
+gemspec path: "../"

gemfiles/rails_5_1.gemfile

@@ -0,0 +1,14 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", "~> 5.1.0"
+gem "rspec"
+gem "rspec-rails", "~> 3.7"
+gem "sqlite3"
+gem "timecop"
+gem "byebug"
+gem "appraisal"
+gem "nokogiri", "~> 1.8"
+
+gemspec path: "../"

gemfiles/rails_5_2.gemfile

@@ -0,0 +1,14 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", "~> 5.2.0"
+gem "rspec"
+gem "rspec-rails", "~> 3.7"
+gem "sqlite3"
+gem "timecop"
+gem "byebug"
+gem "appraisal"
+gem "nokogiri", "~> 1.8"
+
+gemspec path: "../"

gemfiles/rails_6_0.gemfile

@@ -0,0 +1,14 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", "~> 6.0.0"
+gem "rspec"
+gem "rspec-rails", "~> 3.7"
+gem "sqlite3"
+gem "timecop"
+gem "byebug"
+gem "appraisal"
+gem "nokogiri", "~> 1.8"
+
+gemspec path: "../"

gemfiles/rails_6_1.gemfile

@@ -0,0 +1,14 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", "~> 6.1.0"
+gem "rspec"
+gem "rspec-rails", "~> 3.7"
+gem "sqlite3"
+gem "timecop"
+gem "byebug"
+gem "appraisal"
+gem "nokogiri", "~> 1.8"
+
+gemspec path: "../"

gemfiles/rails_edge.gemfile

@@ -0,0 +1,14 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", git: "https://github.com/rails/rails.git", branch: "main"
+gem "rspec"
+gem "rspec-rails", "~> 3.7"
+gem "sqlite3"
+gem "timecop"
+gem "byebug"
+gem "appraisal"
+gem "nokogiri", "~> 1.8"
+
+gemspec path: "../"

lib/validates_timeliness.rb

@@ -36,8 +36,8 @@ module ValidatesTimeliness
 
   # Shorthand time and date symbols for restrictions
   self.restriction_shorthand_symbols = {
-    :now   => lambda { Time.current },
-    :today => lambda { Date.current }
+    now:   proc { Time.current },
+    today: proc { Date.current }
   }
 
   # Use the plugin date/time parser which is stricter and extensible
@@ -62,7 +62,7 @@ module ValidatesTimeliness
   def self.parser; Timeliness end
 end
 
-require 'validates_timeliness/conversion'
+require 'validates_timeliness/converter'
 require 'validates_timeliness/validator'
 require 'validates_timeliness/helper_methods'
 require 'validates_timeliness/attribute_methods'

lib/validates_timeliness/attribute_methods.rb

@@ -6,83 +6,44 @@ module ValidatesTimeliness
       class_attribute :timeliness_validated_attributes
       self.timeliness_validated_attributes = []
     end
-
-    module ClassMethods
-
-      public
-      # Override in ORM shim
-      def timeliness_attribute_timezone_aware?(attr_name)
-        false
-      end
-
-      # Override in ORM shim
-      def timeliness_attribute_type(attr_name)
-        :datetime
-      end
-
-      def define_timeliness_methods(before_type_cast=false)
-        return if timeliness_validated_attributes.blank?
-        timeliness_validated_attributes.each do |attr_name|
-          define_attribute_timeliness_methods(attr_name, before_type_cast)
-        end
-      end
-
-      def generated_timeliness_methods
-        @generated_timeliness_methods ||= Module.new { |m| 
-          extend Mutex_m
-        }.tap { |mod| include mod }
-      end
-
-      def undefine_timeliness_attribute_methods
-        generated_timeliness_methods.module_eval do
-          instance_methods.each { |m| undef_method(m) } 
-        end
-      end
-
-      protected
-
-      def define_attribute_timeliness_methods(attr_name, before_type_cast=false)
-        define_timeliness_write_method(attr_name)
-        define_timeliness_before_type_cast_method(attr_name) if before_type_cast
-      end
-
-      def define_timeliness_write_method(attr_name)
-        generated_timeliness_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
-          def #{attr_name}=(value)
-            write_timeliness_attribute('#{attr_name}', value)
-          end
-        STR
-      end
-
-      def define_timeliness_before_type_cast_method(attr_name)
-        generated_timeliness_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
-          def #{attr_name}_before_type_cast
-            read_timeliness_attribute_before_type_cast('#{attr_name}')
-          end
-        STR
-      end
-    end
-
-    def write_timeliness_attribute(attr_name, value)
-      @timeliness_cache ||= {}
-      @timeliness_cache[attr_name] = value
-
-      if ValidatesTimeliness.use_plugin_parser
-        type = self.class.timeliness_attribute_type(attr_name)
-        timezone = :current if self.class.timeliness_attribute_timezone_aware?(attr_name)
-        value = Timeliness::Parser.parse(value, type, :zone => timezone)
-        value = value.to_date if value && type == :date
-      end
-
-      @attributes[attr_name] = value
-    end
-
-    def read_timeliness_attribute_before_type_cast(attr_name)
-      @timeliness_cache && @timeliness_cache[attr_name] || @attributes[attr_name]
-    end
-
-    def _clear_timeliness_cache
-      @timeliness_cache = {}
-    end
   end
 end
+
+ActiveModel::Type::Date.prepend Module.new {
+  def cast_value(value)
+    return super unless ValidatesTimeliness.use_plugin_parser
+
+    if value.is_a?(::String)
+      return if value.empty?
+      value = Timeliness::Parser.parse(value, :date)
+      value.to_date if value
+    elsif value.respond_to?(:to_date)
+      value.to_date
+    else
+      value
+    end
+  end
+}
+
+ActiveModel::Type::Time.prepend Module.new {
+  def user_input_in_time_zone(value)
+    return super unless ValidatesTimeliness.use_plugin_parser
+
+    if value.is_a?(String)
+      dummy_time_value = value.sub(/\A(\d\d\d\d-\d\d-\d\d |)/, Date.current.to_s + ' ')
+      Timeliness::Parser.parse(dummy_time_value, :datetime, zone: :current)
+    else
+      value.in_time_zone
+    end
+  end
+}
+
+ActiveModel::Type::DateTime.prepend Module.new {
+  def user_input_in_time_zone(value)
+    if value.is_a?(String) && ValidatesTimeliness.use_plugin_parser
+      Timeliness::Parser.parse(value, :datetime, zone: :current)
+    else
+      value.in_time_zone
+    end
+  end
+}

lib/validates_timeliness/converter.rb

@@ -1,10 +1,18 @@
 module ValidatesTimeliness
-  module Conversion
+  class Converter
+    attr_reader :type, :format, :ignore_usec
 
-    def type_cast_value(value, type)
+    def initialize(type:, format: nil, ignore_usec: false, time_zone_aware: false)
+      @type = type
+      @format = format
+      @ignore_usec = ignore_usec
+      @time_zone_aware = time_zone_aware
+    end
+
+    def type_cast_value(value)
       return nil if value.nil? || !value.respond_to?(:to_time)
 
-      value = value.in_time_zone if value.acts_like?(:time) && @timezone_aware
+      value = value.in_time_zone if value.acts_like?(:time) && time_zone_aware?
       value = case type
       when :time
         dummy_time(value)
@@ -15,8 +23,8 @@ module ValidatesTimeliness
       else
         value
       end
-      if options[:ignore_usec] && value.is_a?(Time)
-        Timeliness::Parser.make_time(Array(value).reverse[4..9], (:current if @timezone_aware))
+      if ignore_usec && value.is_a?(Time)
+        Timeliness::Parser.make_time(Array(value).reverse[4..9], (:current if time_zone_aware?))
       else
         value
       end
@@ -24,30 +32,30 @@ module ValidatesTimeliness
 
     def dummy_time(value)
       time = if value.acts_like?(:time)
-        value = value.in_time_zone if @timezone_aware
+        value = value.in_time_zone if time_zone_aware?
         [value.hour, value.min, value.sec]
       else
         [0,0,0]
       end
       values = ValidatesTimeliness.dummy_date_for_time_type + time
-      Timeliness::Parser.make_time(values, (:current if @timezone_aware))
+      Timeliness::Parser.make_time(values, (:current if time_zone_aware?))
     end
 
-    def evaluate_option_value(value, record)
+    def evaluate(value, scope=nil)
       case value
       when Time, Date
         value
       when String
         parse(value)
       when Symbol
-        if !record.respond_to?(value) && restriction_shorthand?(value)
+        if !scope.respond_to?(value) && restriction_shorthand?(value)
           ValidatesTimeliness.restriction_shorthand_symbols[value].call
         else
-          evaluate_option_value(record.send(value), record)
+          evaluate(scope.send(value))
         end
       when Proc
-        result = value.arity > 0 ? value.call(record) : value.call
-        evaluate_option_value(result, record)
+        result = value.arity > 0 ? value.call(scope) : value.call
+        evaluate(result, scope)
       else
         value
       end
@@ -59,14 +67,18 @@ module ValidatesTimeliness
 
     def parse(value)
       return nil if value.nil?
+
       if ValidatesTimeliness.use_plugin_parser
-        Timeliness::Parser.parse(value, @type, :zone => (:current if @timezone_aware), :format => options[:format], :strict => false)
+        Timeliness::Parser.parse(value, type, zone: (:current if time_zone_aware?), format: format, strict: false)
       else
-        @timezone_aware ? Time.zone.parse(value) : value.to_time(ValidatesTimeliness.default_timezone)
+        time_zone_aware? ? Time.zone.parse(value) : value.to_time(ValidatesTimeliness.default_timezone)
       end
     rescue ArgumentError, TypeError
       nil
     end
 
+    def time_zone_aware?
+      @time_zone_aware
+    end
   end
 end

lib/validates_timeliness/extensions.rb

@@ -1,10 +1,10 @@
 module ValidatesTimeliness
   module Extensions
-    autoload :DateTimeSelect, 'validates_timeliness/extensions/date_time_select'
+    autoload :TimelinessDateTimeSelect, 'validates_timeliness/extensions/date_time_select'
   end
 
   def self.enable_date_time_select_extension!
-    ::ActionView::Helpers::Tags::DateSelect.send(:include, ValidatesTimeliness::Extensions::DateTimeSelect)
+    ::ActionView::Helpers::Tags::DateSelect.send(:prepend, ValidatesTimeliness::Extensions::TimelinessDateTimeSelect)
   end
 
   def self.enable_multiparameter_extension!

lib/validates_timeliness/extensions/date_time_select.rb

@@ -1,54 +1,50 @@
 module ValidatesTimeliness
   module Extensions
-    module DateTimeSelect
-      extend ActiveSupport::Concern
-
+    module TimelinessDateTimeSelect
       # Intercepts the date and time select helpers to reuse the values from
       # 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.
       # It's a minor usability improvement which is rarely an issue for the user.
+      attr_accessor :object_name, :method_name, :template_object, :options, :html_options
 
-      included do
-        alias_method_chain :value, :timeliness
-      end
+      POSITION = {
+        :year => 1, :month => 2, :day => 3, :hour => 4, :min => 5, :sec => 6
+      }.freeze
 
-      class TimelinessDateTime
+      class DateTimeValue
         attr_accessor :year, :month, :day, :hour, :min, :sec
 
-        def initialize(year, month, day, hour, min, sec)
+        def initialize(year:, month:, day: nil, hour: nil, min: nil, sec: nil)
           @year, @month, @day, @hour, @min, @sec = year, month, day, hour, min, sec
         end
 
-        # adapted from activesupport/lib/active_support/core_ext/date_time/calculations.rb, line 36 (3.0.7)
         def change(options)
-          TimelinessDateTime.new(
-            options[:year]  || year,
-            options[:month] || month,
-            options[:day]   || day,
-            options[:hour]  || hour,
-            options[:min]   || (options[:hour] ? 0 : min),
-            options[:sec]   || ((options[:hour] || options[:min]) ? 0 : sec)
+          self.class.new(
+            year:  options.fetch(:year, year),
+            month: options.fetch(:month, month),
+            day:   options.fetch(:day, day),
+            hour:  options.fetch(:hour, hour),
+            min:   options.fetch(:min) { options[:hour] ? 0 : min },
+            sec:   options.fetch(:sec) { options[:hour] || options[:min] ? 0 : sec }
           )
         end
       end
 
-      def value_with_timeliness(object)
-        return value_without_timeliness(object) unless @template_object.params[@object_name]
-
-        @template_object.params[@object_name]
+      # Splat args to support Rails 5.0 which expects object, and 5.2 which doesn't
+      def value(*object)
+        return super unless @template_object.params[@object_name]
 
         pairs = @template_object.params[@object_name].select {|k,v| k =~ /^#{@method_name}\(/ }
-        return value_without_timeliness(object) if pairs.empty?
+        return super if pairs.empty?
 
-        values = [nil] * 6
-        pairs.map do |(param, value)|
-          position = param.scan(/\((\d+)\w+\)/).first.first
-          values[position.to_i-1] = value.to_i
+        values = {}
+        pairs.each_pair do |key, value|
+          position = key[/\((\d+)\w+\)/, 1]
+          values[POSITION.key(position.to_i)] = value.to_i
         end
 
-        TimelinessDateTime.new(*values)
+        DateTimeValue.new(**values)
       end
-
     end
   end
 end

lib/validates_timeliness/extensions/multiparameter_handler.rb

@@ -1,74 +1,55 @@
-ActiveRecord::AttributeAssignment::MultiparameterAttribute.class_eval do
-  private
+module ValidatesTimeliness
+  module Extensions
+    class AcceptsMultiparameterTime < Module
 
-  # Yield if date values are valid
-  def validate_multiparameter_date_values(set_values)
-    if set_values[0..2].all?{ |v| v.present? } && Date.valid_civil?(*set_values[0..2])
-      yield
+      def initialize(defaults: {})
+
+        define_method(:cast) do |value|
+          if value.is_a?(Hash)
+            value_from_multiparameter_assignment(value)
           else
-      invalid_multiparameter_date_or_time_as_string(set_values)
+            super(value)
           end
         end
 
-  def invalid_multiparameter_date_or_time_as_string(values)
-    value =  [values[0], *values[1..2].map {|s| s.to_s.rjust(2,"0")} ].join("-")
-    value += ' ' + values[3..5].map {|s| s.to_s.rjust(2, "0") }.join(":") unless values[3..5].empty?
-    value
-  end
-
-  def instantiate_time_object(set_values)
-    raise if set_values.any?(&:nil?)
-
-    validate_multiparameter_date_values(set_values) {
-      set_values = set_values.map {|v| v.is_a?(String) ? v.strip : v }
-
-      if object.class.send(:create_time_zone_conversion_attribute?, name, cast_type_or_column)
-        Time.zone.local(*set_values)
+        define_method(:assert_valid_value) do |value|
+          if value.is_a?(Hash)
+            value_from_multiparameter_assignment(value)
           else
-        Time.send(object.class.default_timezone, *set_values)
-      end
-    }
-  rescue
-    invalid_multiparameter_date_or_time_as_string(set_values)
-  end
-
-  def read_time
-    # If column is a :time (and not :date or :timestamp) there is no need to validate if
-    # there are year/month/day fields
-    if cast_type_or_column.type == :time
-      # if the column is a time set the values to their defaults as January 1, 1970, but only if they're nil
-      { 1 => 1970, 2 => 1, 3 => 1 }.each do |key,value|
-        values[key] ||= value
+            super(value)
           end
         end
 
-    max_position = extract_max_param(6)
-    set_values   = values.values_at(*(1..max_position))
+        define_method(:value_from_multiparameter_assignment) do |values_hash|
+          defaults.each do |k, v|
+            values_hash[k] ||= v
+          end
+          return unless values_hash.values_at(1,2,3).all?{ |v| v.present? } &&
+                          Date.valid_civil?(*values_hash.values_at(1,2,3))
+
+          values = values_hash.sort.map(&:last)
+          ::Time.send(default_timezone, *values)
+        end
+        private :value_from_multiparameter_assignment
 
-    instantiate_time_object(set_values)
       end
 
-  def read_date
-    set_values = values.values_at(1,2,3).map {|v| v.is_a?(String) ? v.strip : v }
-    
-    if set_values.any? { |v| v.is_a?(String) }
-      Timeliness.parse(set_values.join('-'), :date).try(:to_date) or raise TypeError
-    else
-      Date.new(*set_values)
     end
-  rescue TypeError, ArgumentError, NoMethodError => ex # if Date.new raises an exception on an invalid date
-    # Date.new with nil values throws NoMethodError
-    raise ex if ex.is_a?(NoMethodError) && ex.message !~ /undefined method `div' for/
-    invalid_multiparameter_date_or_time_as_string(set_values)
   end
-
-  # Cast type is v4.2 and column before
-  def cast_type_or_column
-    @cast_type || @column
-  end
-
-  def timezone_conversion_attribute?
-    object.class.send(:create_time_zone_conversion_attribute?, name, column)
-  end
-
+end
+
+ActiveModel::Type::Date.class_eval do
+  include ValidatesTimeliness::Extensions::AcceptsMultiparameterTime.new
+end
+
+ActiveModel::Type::Time.class_eval do
+  include ValidatesTimeliness::Extensions::AcceptsMultiparameterTime.new(
+    defaults: { 1 => 1970, 2 => 1, 3 => 1, 4 => 0, 5 => 0 }
+  )
+end
+
+ActiveModel::Type::DateTime.class_eval do
+  include ValidatesTimeliness::Extensions::AcceptsMultiparameterTime.new(
+    defaults: { 4 => 0, 5 => 0 }
+  )
 end

lib/validates_timeliness/orm/active_model.rb

@@ -7,12 +7,63 @@ module ValidatesTimeliness
         public
 
         def define_attribute_methods(*attr_names)
-          super.tap { define_timeliness_methods}
+          super.tap { define_timeliness_methods }
         end
 
         def undefine_attribute_methods
           super.tap { undefine_timeliness_attribute_methods }
         end
+
+        def define_timeliness_methods(before_type_cast=false)
+          return if timeliness_validated_attributes.blank?
+          timeliness_validated_attributes.each do |attr_name|
+            define_attribute_timeliness_methods(attr_name, before_type_cast)
+          end
+        end
+
+        def generated_timeliness_methods
+          @generated_timeliness_methods ||= Module.new { |m|
+            extend Mutex_m
+          }.tap { |mod| include mod }
+        end
+
+        def undefine_timeliness_attribute_methods
+          generated_timeliness_methods.module_eval do
+            instance_methods.each { |m| undef_method(m) }
+          end
+        end
+
+        def define_attribute_timeliness_methods(attr_name, before_type_cast=false)
+          define_timeliness_write_method(attr_name)
+          define_timeliness_before_type_cast_method(attr_name) if before_type_cast
+        end
+
+        def define_timeliness_write_method(attr_name)
+          generated_timeliness_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            def #{attr_name}=(value)
+              @timeliness_cache ||= {}
+              @timeliness_cache['#{attr_name}'] = value
+
+              @attributes['#{attr_name}'] = super
+            end
+          STR
+        end
+
+        def define_timeliness_before_type_cast_method(attr_name)
+          generated_timeliness_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            def #{attr_name}_before_type_cast
+              read_timeliness_attribute_before_type_cast('#{attr_name}')
+            end
+          STR
+        end
+      end
+
+      def read_timeliness_attribute_before_type_cast(attr_name)
+        @timeliness_cache && @timeliness_cache[attr_name] || @attributes[attr_name]
+      end
+
+      def _clear_timeliness_cache
+        @timeliness_cache = {}
       end
 
     end

lib/validates_timeliness/orm/active_record.rb

@@ -3,97 +3,15 @@ module ValidatesTimeliness
     module ActiveRecord
       extend ActiveSupport::Concern
 
-      module ClassMethods
-        public
-
-        def timeliness_attribute_timezone_aware?(attr_name)
-          create_time_zone_conversion_attribute?(attr_name, timeliness_column_for_attribute(attr_name))
-        end
-
-        def timeliness_attribute_type(attr_name)
-          timeliness_column_for_attribute(attr_name).type
-        end
-
-        if ::ActiveModel.version >= Gem::Version.new('4.2')
-          def timeliness_column_for_attribute(attr_name)
-            columns_hash.fetch(attr_name.to_s) do |key|
-              validation_type = _validators[key.to_sym].find {|v| v.kind == :timeliness }.type.to_s
-              ::ActiveRecord::ConnectionAdapters::Column.new(key, nil, lookup_cast_type(validation_type), validation_type)
-            end
-          end
-          
-          def lookup_cast_type(sql_type)
-            case sql_type
-            when 'datetime' then ::ActiveRecord::Type::DateTime.new
-            when 'date' then ::ActiveRecord::Type::Date.new
-            when 'time' then ::ActiveRecord::Type::Time.new
-            end
-          end
-        else
-          def timeliness_column_for_attribute(attr_name)
-            columns_hash.fetch(attr_name.to_s) do |key|
-              validation_type = _validators[key.to_sym].find {|v| v.kind == :timeliness }.type.to_s
-              ::ActiveRecord::ConnectionAdapters::Column.new(key, nil, validation_type)
-            end
-          end
-        end
-
-        def define_attribute_methods
-          super.tap { 
-            generated_timeliness_methods.synchronize do
-              return if @timeliness_methods_generated
-              define_timeliness_methods true
-              @timeliness_methods_generated = true
-            end
-          }
-        end
-
-        def undefine_attribute_methods
-          super.tap { 
-            generated_timeliness_methods.synchronize do
-              return unless @timeliness_methods_generated
-              undefine_timeliness_attribute_methods 
-              @timeliness_methods_generated = false
-            end
-          }
-        end
-        # Override to overwrite methods in ActiveRecord attribute method module because in AR 4+
-        # there is curious code which calls the method directly from the generated methods module
-        # via bind inside method_missing. This means our method in the formerly custom timeliness
-        # methods module was never reached.
-        def generated_timeliness_methods
-          generated_attribute_methods
-        end
-      end
-
-      def write_timeliness_attribute(attr_name, value)
-        @timeliness_cache ||= {}
-        @timeliness_cache[attr_name] = value
-
-        if ValidatesTimeliness.use_plugin_parser
-          type = self.class.timeliness_attribute_type(attr_name)
-          timezone = :current if self.class.timeliness_attribute_timezone_aware?(attr_name)
-          value = Timeliness::Parser.parse(value, type, :zone => timezone)
-          value = value.to_date if value && type == :date
-        end
-
-        write_attribute(attr_name, value)
-      end
-      
       def read_timeliness_attribute_before_type_cast(attr_name)
-        @timeliness_cache && @timeliness_cache[attr_name] || read_attribute_before_type_cast(attr_name)
-      end
-
-      def reload(*args)
-        _clear_timeliness_cache
-        super
+        read_attribute_before_type_cast(attr_name)
       end
 
     end
   end
 end
 
-class ActiveRecord::Base
+ActiveSupport.on_load(:active_record) do
   include ValidatesTimeliness::AttributeMethods
   include ValidatesTimeliness::ORM::ActiveRecord
 end

lib/validates_timeliness/railtie.rb

@@ -11,5 +11,13 @@ module ValidatesTimeliness
     initializer "validates_timeliness.initialize_restriction_errors" do
       ValidatesTimeliness.ignore_restriction_errors = !Rails.env.test?
     end
+
+    initializer "validates_timeliness.initialize_timeliness_ambiguous_date_format", :after => :load_config_initializers do
+      if Timeliness.respond_to?(:ambiguous_date_format) # i.e. v0.4+
+        # Set default for each new thread if you have changed the default using
+        # the format switching methods.
+        Timeliness.configuration.ambiguous_date_format = Timeliness::Definitions.current_date_format
+      end
+    end
   end
 end

lib/validates_timeliness/validator.rb

@@ -3,9 +3,7 @@ require 'active_model/validator'
 
 module ValidatesTimeliness
   class Validator < ActiveModel::EachValidator
-    include Conversion
-
-    attr_reader :type, :attributes
+    attr_reader :type, :attributes, :converter
 
     RESTRICTIONS = {
       :is_at        => :==,
@@ -55,18 +53,14 @@ module ValidatesTimeliness
       end
     end
 
-    # Rails 4.0 compatibility for old #setup method with class as arg
-    if ActiveModel.version <= Gem::Version.new('4.1')
-      alias_method(:setup, :setup_timeliness_validated_attributes) 
-    end
-
     def validate_each(record, attr_name, value)
       raw_value = attribute_raw_value(record, attr_name) || value
       return if (@allow_nil && raw_value.nil?) || (@allow_blank && raw_value.blank?)
 
-      @timezone_aware = timezone_aware?(record, attr_name)
-      value = parse(raw_value) if value.is_a?(String) || options[:format]
-      value = type_cast_value(value, @type)
+      @converter = initialize_converter(record, attr_name)
+
+      value = @converter.parse(raw_value) if value.is_a?(String) || options[:format]
+      value = @converter.type_cast_value(value)
 
       add_error(record, attr_name, :"invalid_#{@type}") and return if value.blank?
 
@@ -76,7 +70,7 @@ module ValidatesTimeliness
     def validate_restrictions(record, attr_name, value)
       @restrictions_to_check.each do |restriction|
         begin
-          restriction_value = type_cast_value(evaluate_option_value(options[restriction], record), @type)
+          restriction_value = @converter.type_cast_value(@converter.evaluate(options[restriction], record))
           unless value.send(RESTRICTIONS[restriction], restriction_value)
             add_error(record, attr_name, restriction, restriction_value) and break
           end
@@ -91,8 +85,8 @@ module ValidatesTimeliness
 
     def add_error(record, attr_name, message, value=nil)
       value = format_error_value(value) if value
-      message_options = { :message => options[:"#{message}_message"], :restriction => value }
-      record.errors.add(attr_name, message, message_options)
+      message_options = { :message => options.fetch(:"#{message}_message", options[:message]), :restriction => value }
+      record.errors.add(attr_name, message, **message_options)
     end
 
     def format_error_value(value)
@@ -105,9 +99,18 @@ module ValidatesTimeliness
         record.read_timeliness_attribute_before_type_cast(attr_name.to_s)
     end
 
-    def timezone_aware?(record, attr_name)
-      record.class.respond_to?(:timeliness_attribute_timezone_aware?) &&
-        record.class.timeliness_attribute_timezone_aware?(attr_name)
+    def time_zone_aware?(record, attr_name)
+      record.class.respond_to?(:skip_time_zone_conversion_for_attributes) &&
+        !record.class.skip_time_zone_conversion_for_attributes.include?(attr_name.to_sym)
+    end
+
+    def initialize_converter(record, attr_name)
+      ValidatesTimeliness::Converter.new(
+        type: @type,
+        time_zone_aware: time_zone_aware?(record, attr_name),
+        format: options[:format],
+        ignore_usec: options[:ignore_usec]
+      )
     end
 
   end

lib/validates_timeliness/version.rb

@@ -1,3 +1,3 @@
 module ValidatesTimeliness
-  VERSION = '4.0.2'
+  VERSION = '5.0.0.beta2'
 end

spec/spec_helper.rb

@@ -1,5 +1,6 @@
 require 'rspec'
 
+require 'byebug'
 require 'active_model'
 require 'active_model/validations'
 require 'active_record'
@@ -9,6 +10,8 @@ require 'timecop'
 require 'validates_timeliness'
 require 'validates_timeliness/orm/active_model'
 
+require 'rails/railtie'
+
 require 'support/test_model'
 require 'support/model_helpers'
 require 'support/config_helper'
@@ -57,6 +60,7 @@ end
 ActiveRecord::Base.default_timezone = :utc
 ActiveRecord::Base.time_zone_aware_attributes = true
 ActiveRecord::Base.establish_connection({:adapter => 'sqlite3', :database => ':memory:'})
+ActiveRecord::Base.time_zone_aware_types = [:datetime, :time]
 ActiveRecord::Migration.verbose = false
 ActiveRecord::Schema.define(:version => 1) do
   create_table :employees, :force => true do |t|
@@ -71,8 +75,8 @@ end
 class Employee < ActiveRecord::Base
   attr_accessor :redefined_birth_date_called
   validates_date :birth_date, :allow_nil => true
-  validates_date :birth_time, :allow_nil => true
-  validates_date :birth_datetime, :allow_nil => true
+  validates_time :birth_time, :allow_nil => true
+  validates_datetime :birth_datetime, :allow_nil => true
 
   def birth_date=(value)
     self.redefined_birth_date_called = true

spec/support/model_helpers.rb

@@ -17,8 +17,7 @@ module ModelHelpers
 
   def with_each_person_value(attr_name, values)
     record = Person.new
-    values = [values] unless values.is_a?(Array)
-    values.each do |value|
+    Array.wrap(values).each do |value|
       record.send("#{attr_name}=", value)
       yield record, value
     end

spec/support/test_model.rb

@@ -15,17 +15,19 @@ module TestModel
       self.model_attributes[name] = type
     end
 
-    def define_method_attribute=(attr_name)
+    def define_method_attribute=(attr_name, owner: nil)
       generated_attribute_methods.module_eval("def #{attr_name}=(new_value); @attributes['#{attr_name}']=self.class.type_cast('#{attr_name}', new_value); end", __FILE__, __LINE__)
     end
 
-    def define_method_attribute(attr_name)
+    def define_method_attribute(attr_name, owner: nil)
       generated_attribute_methods.module_eval("def #{attr_name}; @attributes['#{attr_name}']; end", __FILE__, __LINE__)
     end
 
     def type_cast(attr_name, value)
       return value unless value.is_a?(String)
-      value.send("to_#{model_attributes[attr_name.to_sym]}") rescue nil
+      type_name = model_attributes[attr_name.to_sym]
+      type = ActiveModel::Type.lookup(type_name)
+      type.cast(value)
     end
   end
 
@@ -48,7 +50,7 @@ module TestModel
   end
 
   def method_missing(method_id, *args, &block)
-    if match_attribute_method?(method_id.to_s)
+    if !matched_attribute_method(method_id.to_s).nil?
       self.class.define_attribute_methods self.class.model_attributes.keys
       send(method_id, *args, &block)
     else

spec/validates_timeliness/attribute_methods_spec.rb

@@ -38,21 +38,6 @@ RSpec.describe ValidatesTimeliness::AttributeMethods do
       expect(e.redefined_birth_date_called).to be_truthy
     end
 
-    it 'should be undefined if model class has dynamic attribute methods reset' do
-      # Force method definitions
-      PersonWithShim.validates_date :birth_date
-      r = PersonWithShim.new
-      r.birth_date = Time.now
-
-      write_method = :birth_date=
-
-      expect(PersonWithShim.send(:generated_timeliness_methods).instance_methods).to include(write_method)
-
-      PersonWithShim.undefine_attribute_methods 
-
-      expect(PersonWithShim.send(:generated_timeliness_methods).instance_methods).not_to include(write_method)
-    end
-
     context "with plugin parser" do
       with_config(:use_plugin_parser, true)
 

spec/validates_timeliness/converter_spec.rb

@@ -1,97 +1,112 @@
-RSpec.describe ValidatesTimeliness::Conversion do
-  include ValidatesTimeliness::Conversion
+RSpec.describe ValidatesTimeliness::Converter do
+  subject(:converter) { described_class.new(type: type, time_zone_aware: time_zone_aware, ignore_usec: ignore_usec) }
 
   let(:options) { Hash.new }
+  let(:type) { :date }
+  let(:time_zone_aware) { false }
+  let(:ignore_usec) { false }
 
   before do
     Timecop.freeze(Time.mktime(2010, 1, 1, 0, 0, 0))
   end
 
+  delegate :type_cast_value, :evaluate, :parse, :dummy_time, to: :converter
+
   describe "#type_cast_value" do
     describe "for date type" do
+      let(:type) { :date }
+
       it "should return same value for date value" do
-        expect(type_cast_value(Date.new(2010, 1, 1), :date)).to eq(Date.new(2010, 1, 1))
+        expect(type_cast_value(Date.new(2010, 1, 1))).to eq(Date.new(2010, 1, 1))
       end
 
       it "should return date part of time value" do
-        expect(type_cast_value(Time.mktime(2010, 1, 1, 0, 0, 0), :date)).to eq(Date.new(2010, 1, 1))
+        expect(type_cast_value(Time.mktime(2010, 1, 1, 0, 0, 0))).to eq(Date.new(2010, 1, 1))
       end
 
       it "should return date part of datetime value" do
-        expect(type_cast_value(DateTime.new(2010, 1, 1, 0, 0, 0), :date)).to eq(Date.new(2010, 1, 1))
+        expect(type_cast_value(DateTime.new(2010, 1, 1, 0, 0, 0))).to eq(Date.new(2010, 1, 1))
       end
 
       it 'should return nil for invalid value types' do
-        expect(type_cast_value(12, :date)).to eq(nil)
+        expect(type_cast_value(12)).to eq(nil)
       end
     end
 
     describe "for time type" do
+      let(:type) { :time }
+
       it "should return same value for time value matching dummy date part" do
-        expect(type_cast_value(Time.utc(2000, 1, 1, 0, 0, 0), :time)).to eq(Time.utc(2000, 1, 1, 0, 0, 0))
+        expect(type_cast_value(Time.utc(2000, 1, 1, 0, 0, 0))).to eq(Time.utc(2000, 1, 1, 0, 0, 0))
       end
 
       it "should return dummy time value with same time part for time value with different date" do
-        expect(type_cast_value(Time.utc(2010, 1, 1, 0, 0, 0), :time)).to eq(Time.utc(2000, 1, 1, 0, 0, 0))
+        expect(type_cast_value(Time.utc(2010, 1, 1, 0, 0, 0))).to eq(Time.utc(2000, 1, 1, 0, 0, 0))
       end
 
       it "should return dummy time only for date value" do
-        expect(type_cast_value(Date.new(2010, 1, 1), :time)).to eq(Time.utc(2000, 1, 1, 0, 0, 0))
+        expect(type_cast_value(Date.new(2010, 1, 1))).to eq(Time.utc(2000, 1, 1, 0, 0, 0))
       end
 
       it "should return dummy date with time part for datetime value" do
-        expect(type_cast_value(DateTime.civil_from_format(:utc, 2010, 1, 1, 12, 34, 56), :time)).to eq(Time.utc(2000, 1, 1, 12, 34, 56))
+        expect(type_cast_value(DateTime.civil_from_format(:utc, 2010, 1, 1, 12, 34, 56))).to eq(Time.utc(2000, 1, 1, 12, 34, 56))
       end
 
       it 'should return nil for invalid value types' do
-        expect(type_cast_value(12, :time)).to eq(nil)
+        expect(type_cast_value(12)).to eq(nil)
       end
     end
 
     describe "for datetime type" do
+      let(:type) { :datetime }
+      let(:time_zone_aware) { true }
+
       it "should return Date as Time value" do
-        expect(type_cast_value(Date.new(2010, 1, 1), :datetime)).to eq(Time.local(2010, 1, 1, 0, 0, 0))
+        expect(type_cast_value(Date.new(2010, 1, 1))).to eq(Time.local(2010, 1, 1, 0, 0, 0))
       end
 
       it "should return same Time value" do
         value = Time.utc(2010, 1, 1, 12, 34, 56)
-        expect(type_cast_value(Time.utc(2010, 1, 1, 12, 34, 56), :datetime)).to eq(value)
+        expect(type_cast_value(Time.utc(2010, 1, 1, 12, 34, 56))).to eq(value)
       end
 
       it "should return as Time with same component values" do
-        expect(type_cast_value(DateTime.civil_from_format(:utc, 2010, 1, 1, 12, 34, 56), :datetime)).to eq(Time.utc(2010, 1, 1, 12, 34, 56))
+        expect(type_cast_value(DateTime.civil_from_format(:utc, 2010, 1, 1, 12, 34, 56))).to eq(Time.utc(2010, 1, 1, 12, 34, 56))
       end
 
       it "should return same Time in correct zone if timezone aware" do
-        @timezone_aware = true
         value = Time.utc(2010, 1, 1, 12, 34, 56)
-        result = type_cast_value(value, :datetime)
+        result = type_cast_value(value)
         expect(result).to eq(Time.zone.local(2010, 1, 1, 23, 34, 56))
         expect(result.zone).to eq('AEDT')
       end
 
       it 'should return nil for invalid value types' do
-        expect(type_cast_value(12, :datetime)).to eq(nil)
+        expect(type_cast_value(12)).to eq(nil)
       end
     end
 
     describe "ignore_usec option" do
-      let(:options) { {:ignore_usec => true} }
+      let(:type) { :datetime }
+      let(:ignore_usec) { true }
 
       it "should ignore usec on time values when evaluated" do
         value = Time.utc(2010, 1, 1, 12, 34, 56, 10000)
-        expect(type_cast_value(value, :datetime)).to eq(Time.utc(2010, 1, 1, 12, 34, 56))
+        expect(type_cast_value(value)).to eq(Time.utc(2010, 1, 1, 12, 34, 56))
       end
 
+      context do
+        let(:time_zone_aware) { true }
+
         it "should ignore usec and return time in correct zone if timezone aware" do
-        @timezone_aware = true
           value = Time.utc(2010, 1, 1, 12, 34, 56, 10000)
-        result = type_cast_value(value, :datetime)
+          result = type_cast_value(value)
           expect(result).to eq(Time.zone.local(2010, 1, 1, 23, 34, 56))
           expect(result.zone).to eq('AEDT')
         end
       end
     end
+  end
 
   describe "#dummy_time" do
     it 'should return Time with dummy date values but same time components' do
@@ -103,7 +118,6 @@ RSpec.describe ValidatesTimeliness::Conversion do
     end
 
     it 'should return time component values shifted to current zone if timezone aware' do
-      @timezone_aware = true
       expect(dummy_time(Time.utc(2000, 1, 1, 12, 34, 56))).to eq(Time.zone.local(2000, 1, 1, 23, 34, 56))
     end
 
@@ -120,61 +134,64 @@ RSpec.describe ValidatesTimeliness::Conversion do
     end
   end
 
-  describe "#evaluate_option_value" do
+  describe "#evaluate" do
     let(:person) { Person.new }
 
     it 'should return Date object as is' do
       value = Date.new(2010,1,1)
-      expect(evaluate_option_value(value, person)).to eq(value)
+      expect(evaluate(value, person)).to eq(value)
     end
 
     it 'should return Time object as is' do
       value = Time.mktime(2010,1,1)
-      expect(evaluate_option_value(value, person)).to eq(value)
+      expect(evaluate(value, person)).to eq(value)
     end
 
     it 'should return DateTime object as is' do
       value = DateTime.new(2010,1,1,0,0,0)
-      expect(evaluate_option_value(value, person)).to eq(value)
+      expect(evaluate(value, person)).to eq(value)
     end
 
     it 'should return Time value returned from proc with 0 arity' do
       value = Time.mktime(2010,1,1)
-      expect(evaluate_option_value(lambda { value }, person)).to eq(value)
+      expect(evaluate(lambda { value }, person)).to eq(value)
     end
 
     it 'should return Time value returned by record attribute call in proc arity of 1' do
       value = Time.mktime(2010,1,1)
       person.birth_time = value
-      expect(evaluate_option_value(lambda {|r| r.birth_time }, person)).to eq(value)
+      expect(evaluate(lambda {|r| r.birth_time }, person)).to eq(value)
     end
 
     it 'should return Time value for attribute method symbol which returns Time' do
       value = Time.mktime(2010,1,1)
-      person.birth_time = value
-      expect(evaluate_option_value(:birth_time, person)).to eq(value)
+      person.birth_datetime = value
+      expect(evaluate(:birth_datetime, person)).to eq(value)
     end
 
     it 'should return Time value is default zone from string time value' do
       value = '2010-01-01 12:00:00'
-      expect(evaluate_option_value(value, person)).to eq(Time.utc(2010,1,1,12,0,0))
+      expect(evaluate(value, person)).to eq(Time.utc(2010,1,1,12,0,0))
     end
 
+    context do
+      let(:converter) { described_class.new(type: :date, time_zone_aware: true) }
+
       it 'should return Time value is current zone from string time value if timezone aware' do
-      @timezone_aware = true
         value = '2010-01-01 12:00:00'
-      expect(evaluate_option_value(value, person)).to eq(Time.zone.local(2010,1,1,12,0,0))
+        expect(evaluate(value, person)).to eq(Time.zone.local(2010,1,1,12,0,0))
+      end
     end
 
     it 'should return Time value in default zone from proc which returns string time' do
-      value = '2010-01-01 12:00:00'
-      expect(evaluate_option_value(lambda { value }, person)).to eq(Time.utc(2010,1,1,12,0,0))
+      value = '2010-11-12 13:00:00'
+      expect(evaluate(lambda { value }, person)).to eq(Time.utc(2010,11,12,13,0,0))
     end
 
     it 'should return Time value for attribute method symbol which returns string time value' do
-      value = '2010-01-01 12:00:00'
+      value = '13:00:00'
       person.birth_time = value
-      expect(evaluate_option_value(:birth_time, person)).to eq(Time.local(2010,1,1,12,0,0))
+      expect(evaluate(:birth_time, person)).to eq(Time.utc(2000,1,1,13,0,0))
     end
 
     context "restriction shorthand" do
@@ -183,17 +200,17 @@ RSpec.describe ValidatesTimeliness::Conversion do
       end
 
       it 'should evaluate :now as current time' do
-        expect(evaluate_option_value(:now, person)).to eq(Time.now)
+        expect(evaluate(:now, person)).to eq(Time.now)
       end
 
       it 'should evaluate :today as current time' do
-        expect(evaluate_option_value(:today, person)).to eq(Date.today)
+        expect(evaluate(:today, person)).to eq(Date.today)
       end
 
       it 'should not use shorthand if symbol if is record method' do
         time = 1.day.from_now
         allow(person).to receive(:now).and_return(time)
-        expect(evaluate_option_value(:now, person)).to eq(time)
+        expect(evaluate(:now, person)).to eq(time)
       end
     end
   end
@@ -212,13 +229,11 @@ RSpec.describe ValidatesTimeliness::Conversion do
       with_config(:use_plugin_parser, false)
 
       it 'should use Time.zone.parse attribute is timezone aware' do
-        @timezone_aware = true
-        expect(Time.zone).to receive(:parse)
+        expect(Timeliness::Parser).to_not receive(:parse)
         parse('2000-01-01')
       end
 
       it 'should use value#to_time if use_plugin_parser setting is false and attribute is not timezone aware' do
-        @timezone_aware = false
         value = '2000-01-01'
         expect(value).to receive(:to_time)
         parse(value)

spec/validates_timeliness/extensions/date_time_select_spec.rb

@@ -20,8 +20,8 @@ RSpec.describe 'ValidatesTimeliness::Extensions::DateTimeSelect' do
         "birth_datetime(6i)" => '14',
       }
       person.birth_datetime = nil
-      @output = datetime_select(:person, :birth_datetime, :include_blank => true, :include_seconds => true)
-      should_have_datetime_selected(:birth_datetime, :year => 2009, :month => 'February', :day => 29, :hour => 12, :min => 13, :sec => 14)
+      @output = datetime_select(:person, :birth_datetime, include_blank: true, include_seconds: true)
+      should_have_datetime_selected(:birth_datetime, year: 2009, month: 'February', day: 29, hour: 12, min: 13, sec: 14)
     end
 
     it "should override object values and use params if present" do
@@ -34,26 +34,26 @@ RSpec.describe 'ValidatesTimeliness::Extensions::DateTimeSelect' do
         "birth_datetime(6i)" => '14',
       }
       person.birth_datetime = "2010-01-01 15:16:17"
-      @output = datetime_select(:person, :birth_datetime, :include_blank => true, :include_seconds => true)
-      should_have_datetime_selected(:birth_datetime, :year => 2009, :month => 'February', :day => 29, :hour => 12, :min => 13, :sec => 14)
+      @output = datetime_select(:person, :birth_datetime, include_blank: true, include_seconds: true)
+      should_have_datetime_selected(:birth_datetime, year: 2009, month: 'February', day: 29, hour: 12, min: 13, sec: 14)
     end
 
     it "should use attribute values from object if no params" do
       person.birth_datetime = "2009-01-02 12:13:14"
-      @output = datetime_select(:person, :birth_datetime, :include_blank => true, :include_seconds => true)
-      should_have_datetime_selected(:birth_datetime, :year => 2009, :month => 'January', :day => 2, :hour => 12, :min => 13, :sec => 14)
+      @output = datetime_select(:person, :birth_datetime, include_blank: true, include_seconds: true)
+      should_have_datetime_selected(:birth_datetime, year: 2009, month: 'January', day: 2, hour: 12, min: 13, sec: 14)
     end
 
     it "should use attribute values if params does not contain attribute params" do
       person.birth_datetime = "2009-01-02 12:13:14"
       @params["person"] = { }
-      @output = datetime_select(:person, :birth_datetime, :include_blank => true, :include_seconds => true)
-      should_have_datetime_selected(:birth_datetime, :year => 2009, :month => 'January', :day => 2, :hour => 12, :min => 13, :sec => 14)
+      @output = datetime_select(:person, :birth_datetime, include_blank: true, include_seconds: true)
+      should_have_datetime_selected(:birth_datetime, year: 2009, month: 'January', day: 2, hour: 12, min: 13, sec: 14)
     end
 
     it "should not select values when attribute value is nil and has no param values" do
       person.birth_datetime = nil
-      @output = datetime_select(:person, :birth_datetime, :include_blank => true, :include_seconds => true)
+      @output = datetime_select(:person, :birth_datetime, include_blank: true, include_seconds: true)
       should_not_have_datetime_selected(:birth_datetime, :year, :month, :day, :hour, :min, :sec)
     end
   end
@@ -66,8 +66,8 @@ RSpec.describe 'ValidatesTimeliness::Extensions::DateTimeSelect' do
         "birth_date(3i)" => '29',
       }
       person.birth_date = nil
-      @output = date_select(:person, :birth_date, :include_blank => true)
-      should_have_datetime_selected(:birth_date, :year => 2009, :month => 'February', :day => 29)
+      @output = date_select(:person, :birth_date, include_blank: true)
+      should_have_datetime_selected(:birth_date, year: 2009, month: 'February', day: 29)
     end
 
     it "should override object values and use params if present" do
@@ -77,26 +77,26 @@ RSpec.describe 'ValidatesTimeliness::Extensions::DateTimeSelect' do
         "birth_date(3i)" => '29',
       }
       person.birth_date = "2009-03-01"
-      @output = date_select(:person, :birth_date, :include_blank => true)
-      should_have_datetime_selected(:birth_date, :year => 2009, :month => 'February', :day => 29)
+      @output = date_select(:person, :birth_date, include_blank: true)
+      should_have_datetime_selected(:birth_date, year: 2009, month: 'February', day: 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)
-      should_have_datetime_selected(:birth_date, :year => 2009, :month => 'January', :day => 2)
+      @output = date_select(:person, :birth_date, include_blank: true)
+      should_have_datetime_selected(:birth_date, year: 2009, month: 'January', day: 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)
-      should_have_datetime_selected(:birth_date, :year => 2009, :month => 'January', :day => 2)
+      @output = date_select(:person, :birth_date, include_blank: true)
+      should_have_datetime_selected(:birth_date, year: 2009, month: 'January', day: 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)
+      @output = date_select(:person, :birth_date, include_blank: true)
       should_not_have_datetime_selected(:birth_time, :year, :month, :day)
     end
 
@@ -106,8 +106,8 @@ RSpec.describe 'ValidatesTimeliness::Extensions::DateTimeSelect' do
         "birth_date(2i)" => '2',
       }
 
-      @output = date_select(:person, :birth_date, :include_blank => true, :discard_day => true)
-      should_have_datetime_selected(:birth_date, :year => 2009, :month => 'February')
+      @output = date_select(:person, :birth_date, include_blank: true, discard_day: true)
+      should_have_datetime_selected(:birth_date, year: 2009, month: 'February')
       should_not_have_datetime_selected(:birth_time, :day)
       expect(@output).to have_tag("input[id=person_birth_date_3i][type=hidden][value='1']")
     end
@@ -128,33 +128,33 @@ RSpec.describe 'ValidatesTimeliness::Extensions::DateTimeSelect' do
         "birth_time(6i)" => '14',
       }
       person.birth_time = nil
-      @output = time_select(:person, :birth_time, :include_blank => true, :include_seconds => true)
-      should_have_datetime_selected(:birth_time, :hour => 12, :min => 13, :sec => 14)
+      @output = time_select(:person, :birth_time, include_blank: true, include_seconds: true)
+      should_have_datetime_selected(:birth_time, hour: 12, min: 13, sec: 14)
     end
 
     it "should select attribute values from object if no params" do
       person.birth_time = "2000-01-01 12:13:14"
-      @output = time_select(:person, :birth_time, :include_blank => true, :include_seconds => true)
-      should_have_datetime_selected(:birth_time, :hour => 12, :min => 13, :sec => 14)
+      @output = time_select(:person, :birth_time, include_blank: true, include_seconds: true)
+      should_have_datetime_selected(:birth_time, hour: 12, min: 13, sec: 14)
     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 = time_select(:person, :birth_time, include_blank: true, include_seconds: true)
       should_not_have_datetime_selected(:birth_time, :hour, :min, :sec)
     end
   end
 
   def should_have_datetime_selected(field, datetime_hash)
     datetime_hash.each do |key, value|
-      index = {:year => 1, :month => 2, :day => 3, :hour => 4, :min => 5, :sec => 6}[key]
+      index = {year: 1, month: 2, day: 3, hour: 4, min: 5, sec: 6}[key]
       expect(@output).to have_tag("select[id=person_#{field}_#{index}i] option[selected=selected]", value.to_s)
     end
   end
 
   def should_not_have_datetime_selected(field, *attributes)
     attributes.each do |attribute|
-      index = {:year => 1, :month => 2, :day => 3, :hour => 4, :min => 5, :sec => 6}[attribute]
+      index = {year: 1, month: 2, day: 3, hour: 4, min: 5, sec: 6}[attribute]
       expect(@output).not_to have_tag("select[id=person_#{attribute}_#{index}i] option[selected=selected]")
     end
   end

spec/validates_timeliness/extensions/multiparameter_handler_spec.rb

@@ -1,36 +1,36 @@
 RSpec.describe 'ValidatesTimeliness::Extensions::MultiparameterHandler' do
 
   context "time column" do
-    it 'should assign a string value for invalid date portion' do
+    it 'should be nil invalid date portion' do
       employee = record_with_multiparameter_attribute(:birth_datetime, [2000, 2, 31, 12, 0, 0])
-      expect(employee.birth_datetime_before_type_cast).to eq '2000-02-31 12:00:00'
+      expect(employee.birth_datetime).to be_nil
     end
      
     it 'should assign a Time value for valid datetimes' do
       employee = record_with_multiparameter_attribute(:birth_datetime, [2000, 2, 28, 12, 0, 0])
-      expect(employee.birth_datetime_before_type_cast).to eq Time.zone.local(2000, 2, 28, 12, 0, 0)
+      expect(employee.birth_datetime).to eq Time.zone.local(2000, 2, 28, 12, 0, 0)
     end
 
-    it 'should assign a string value for incomplete time' do
+    it 'should be nil for incomplete date portion' do
       employee = record_with_multiparameter_attribute(:birth_datetime, [2000, nil, nil])
-      expect(employee.birth_datetime_before_type_cast).to eq '2000-00-00'
+      expect(employee.birth_datetime).to be_nil
     end
   end
 
   context "date column" do
-    it 'should assign a string value for invalid date' do
+    it 'should assign nil for invalid date' do
       employee = record_with_multiparameter_attribute(:birth_date, [2000, 2, 31])
-      expect(employee.birth_date_before_type_cast).to eq '2000-02-31'
+      expect(employee.birth_date).to be_nil
     end
 
     it 'should assign a Date value for valid date' do
       employee = record_with_multiparameter_attribute(:birth_date, [2000, 2, 28])
-      expect(employee.birth_date_before_type_cast).to eq Date.new(2000, 2, 28)
+      expect(employee.birth_date).to eq Date.new(2000, 2, 28)
     end
 
-    it 'should assign a string value for incomplete date' do
+    it 'should assign hash values for incomplete date' do
       employee = record_with_multiparameter_attribute(:birth_date, [2000, nil, nil])
-      expect(employee.birth_date_before_type_cast).to eq '2000-00-00'
+      expect(employee.birth_date).to be_nil
     end
   end
 

spec/validates_timeliness/orm/active_record_spec.rb

@@ -1,5 +1,4 @@
 RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
-
   context "validation methods" do
     let(:record) { Employee.new }
 
@@ -26,6 +25,7 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
       record.birth_date = 'not a date'
 
       record.valid?
+      expect(record.birth_date_before_type_cast).to eq 'not a date'
       expect(record.errors[:birth_date]).not_to be_empty
     end
 
@@ -37,10 +37,6 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
     end
   end
 
-  it 'should determine type for attribute' do
-    expect(Employee.timeliness_attribute_type(:birth_date)).to eq :date
-  end
-
   context 'attribute timezone awareness' do
     let(:klass) {
       Class.new(ActiveRecord::Base) do
@@ -53,22 +49,6 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
         validates_datetime :some_datetime
       end
     }
-
-    context 'for column attribute' do
-      it 'should be detected from column type' do
-        expect(klass.timeliness_attribute_timezone_aware?(:birth_date)).to be_falsey
-        expect(klass.timeliness_attribute_timezone_aware?(:birth_time)).to be_falsey
-        expect(klass.timeliness_attribute_timezone_aware?(:birth_datetime)).to be_truthy
-      end
-    end
-
-    context 'for non-column attribute' do
-      it 'should be detected from the validation type' do
-        expect(klass.timeliness_attribute_timezone_aware?(:some_date)).to be_falsey
-        expect(klass.timeliness_attribute_timezone_aware?(:some_time)).to be_falsey
-        expect(klass.timeliness_attribute_timezone_aware?(:some_datetime)).to be_truthy
-      end
-    end
   end
   
   context "attribute write method" do
@@ -79,34 +59,6 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
       validates_datetime :birth_datetime, :allow_blank => true
     end
 
-    context 'value cache' do
-      let(:record) { EmployeeWithCache.new }
-
-      context 'for datetime column' do
-        it 'should store raw value' do
-          record.birth_datetime = datetime_string = '2010-01-01 12:30'
-
-          expect(record.read_timeliness_attribute_before_type_cast('birth_datetime')).to eq datetime_string
-        end
-      end
-
-      context 'for date column' do
-        it 'should store raw value' do
-          record.birth_date = date_string = '2010-01-01'
-
-          expect(record.read_timeliness_attribute_before_type_cast('birth_date')).to eq date_string
-        end
-      end
-
-      context 'for time column' do
-        it 'should store raw value' do
-          record.birth_time = time_string = '12:12'
-
-          expect(record.read_timeliness_attribute_before_type_cast('birth_time')).to eq time_string
-        end
-      end
-    end
-
     context "with plugin parser" do
       with_config(:use_plugin_parser, true)
       let(:record) { EmployeeWithParser.new }
@@ -118,17 +70,23 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
         validates_datetime :birth_datetime, :allow_blank => true
       end
 
+      before do
+        allow(Timeliness::Parser).to receive(:parse).and_call_original
+      end
+
       context "for a date column" do
         it 'should parse a string value' do
-          expect(Timeliness::Parser).to receive(:parse)
-
           record.birth_date = '2010-01-01'
+          expect(record.birth_date).to eq(Date.new(2010, 1, 1))
+
+          expect(Timeliness::Parser).to have_received(:parse)
         end
 
         it 'should parse a invalid string value as nil' do
-          expect(Timeliness::Parser).to receive(:parse)
-
           record.birth_date = 'not valid'
+          expect(record.birth_date).to be_nil
+
+          expect(Timeliness::Parser).to have_received(:parse)
         end
 
         it 'should store a Date value after parsing string' do
@@ -140,45 +98,85 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
       end
 
       context "for a time column" do
-        it 'should parse a string value' do
-          expect(Timeliness::Parser).to receive(:parse)
+        around do |example|
+          time_zone_aware_types = ActiveRecord::Base.time_zone_aware_types.dup
+          example.call
+          ActiveRecord::Base.time_zone_aware_types = time_zone_aware_types
+        end
 
+        context 'timezone aware' do
+          with_config(:default_timezone, 'Australia/Melbourne')
+
+          before do
+            unless ActiveRecord::Base.time_zone_aware_types.include?(:time)
+              ActiveRecord::Base.time_zone_aware_types.push(:time)
+            end
+          end
+
+          it 'should parse a string value' do
             record.birth_time = '12:30'
+
+            expect(record.birth_time).to eq('12:30'.in_time_zone)
+            expect(Timeliness::Parser).to have_received(:parse)
           end
 
           it 'should parse a invalid string value as nil' do
-          expect(Timeliness::Parser).to receive(:parse)
-
             record.birth_time = 'not valid'
+
+            expect(record.birth_time).to be_nil
+            expect(Timeliness::Parser).to have_received(:parse)
           end
 
           it 'should store a Time value after parsing string' do
             record.birth_time = '12:30'
 
-          expect(record.birth_time).to be_kind_of(Time)
-          expect(record.birth_time).to eq Time.utc(2000, 1, 1, 12, 30)
+            expect(record.birth_time).to eq('12:30'.in_time_zone)
+            expect(record.birth_time.utc_offset).to eq '12:30'.in_time_zone.utc_offset
+          end
+        end
+
+        skip 'not timezone aware' do
+          before do
+            ActiveRecord::Base.time_zone_aware_types.delete(:time)
+          end
+
+          it 'should parse a string value' do
+            record.birth_time = '12:30'
+
+            expect(record.birth_time).to eq(Time.utc(2000,1,1,12,30))
+            expect(Timeliness::Parser).to have_received(:parse)
+          end
+
+          it 'should parse a invalid string value as nil' do
+            record.birth_time = 'not valid'
+
+            expect(record.birth_time).to be_nil
+            expect(Timeliness::Parser).to have_received(:parse)
+          end
+
+          it 'should store a Time value in utc' do
+            record.birth_time = '12:30'
+
+            expect(record.birth_time.utc_offset).to eq Time.now.utc.utc_offset
+          end
         end
       end
 
       context "for a datetime column" do
         with_config(:default_timezone, 'Australia/Melbourne')
 
-        it 'should parse a string value' do
-          expect(Timeliness::Parser).to receive(:parse)
-
+        it 'should parse a string value into Time value' do
           record.birth_datetime = '2010-01-01 12:00'
+
+          expect(record.birth_datetime).to eq Time.zone.local(2010,1,1,12,00)
+          expect(Timeliness::Parser).to have_received(:parse)
         end
 
         it 'should parse a invalid string value as nil' do
-          expect(Timeliness::Parser).to receive(:parse)
-
           record.birth_datetime = 'not valid'
-        end
 
-        it 'should parse string into Time value' do
-          record.birth_datetime = '2010-01-01 12:00'
-
-          expect(record.birth_datetime).to be_kind_of(Time)
+          expect(record.birth_datetime).to be_nil
+          expect(Timeliness::Parser).to have_received(:parse)
         end
 
         it 'should parse string as current timezone' do
@@ -189,60 +187,4 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
       end
     end
   end
-
-  context "reload" do
-    it 'should clear cache value' do
-      record = Employee.create!
-      record.birth_date = '2010-01-01'
-      
-      record.reload
-
-      expect(record.read_timeliness_attribute_before_type_cast('birth_date')).to be_nil
-    end
-  end
-
-  context "before_type_cast method" do
-    let(:record) { Employee.new }
-
-    it 'should be defined on class if ORM supports it' do
-      expect(record).to respond_to(:birth_datetime_before_type_cast)
-    end
-
-    it 'should return original value' do
-      record.birth_datetime = date_string = '2010-01-01'
-
-      expect(record.birth_datetime_before_type_cast).to eq date_string
-    end
-
-    it 'should return attribute if no attribute assignment has been made' do
-      datetime = Time.zone.local(2010,01,01)
-      Employee.create(:birth_datetime => datetime)
-
-      record = Employee.last
-      expect(record.birth_datetime_before_type_cast).to match(/#{datetime.utc.to_s[0...-4]}/)
-    end
-
-    context "with plugin parser" do
-      with_config(:use_plugin_parser, true)
-
-      it 'should return original value' do
-        record.birth_datetime = date_string = '2010-01-31'
-
-        expect(record.birth_datetime_before_type_cast).to eq date_string
-      end
-    end
-
-  end
-
-  context "define_attribute_methods" do
-    it "returns a falsy value if the attribute methods have already been generated" do
-      expect(Employee.define_attribute_methods).to be_falsey
-    end
-  end
-
-  context "undefine_attribute_methods" do
-    it "returns a falsy value if the attribute methods have already been generated" do
-      expect { Employee.undefine_attribute_methods }.to_not raise_error
-    end
-  end
 end

spec/validates_timeliness/railtie_spec.rb

@@ -0,0 +1,22 @@
+require 'validates_timeliness/railtie'
+
+RSpec.describe ValidatesTimeliness::Railtie do
+  context "intializers" do
+    context "validates_timeliness.initialize_timeliness_ambiguous_date_format" do
+      it 'should set the timeliness default ambiguous date format from the current format' do
+        expect(Timeliness.configuration.ambiguous_date_format).to eq :us
+        ValidatesTimeliness.parser.use_euro_formats
+
+        initializer("validates_timeliness.initialize_timeliness_ambiguous_date_format").run
+
+        expect(Timeliness.configuration.ambiguous_date_format).to eq :euro
+      end
+    end if Timeliness.respond_to?(:ambiguous_date_format)
+
+    def initializer(name)
+      ValidatesTimeliness::Railtie.initializers.find { |i|
+        i.name == name
+      } || raise("Initializer #{name} not found")
+    end
+  end
+end

spec/validates_timeliness/validator_spec.rb

@@ -87,6 +87,20 @@ RSpec.describe ValidatesTimeliness::Validator do
     end
   end
 
+  describe ':message options' do
+    it 'should allow message option too' do
+      Person.validates_date :birth_date, on_or_after: :today, message: 'cannot be in past'
+      invalid!(:birth_date, Date.today - 5.days, 'cannot be in past')
+      valid!(:birth_date, Date.today)
+    end
+
+    it 'should first allow the defined message' do
+      Person.validates_date :birth_date, on_or_after: :today, on_or_after_message: 'cannot be in past', message: 'dummy message'
+      invalid!(:birth_date, Date.today - 5.days, 'cannot be in past')
+      valid!(:birth_date, Date.today)
+    end
+  end
+
   describe ":between option" do
     describe "array value" do
       it 'should be split option into :on_or_after and :on_or_before values' do

validates_timeliness.gemspec

@@ -10,11 +10,12 @@ Gem::Specification.new do |s|
   s.description = %q{Adds validation methods to ActiveModel for validating dates and times. Works with multiple ORMS.}
   s.email       = %q{adam.meehan@gmail.com}
   s.homepage    = %q{http://github.com/adzap/validates_timeliness}
+  s.license     = "MIT"
 
   s.require_paths    = ["lib"]
   s.files            = `git ls-files`.split("\n") - %w{ .gitignore .rspec Gemfile Gemfile.lock autotest/discover.rb Appraisals Travis.yml } - Dir['gemsfiles/*']
   s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.extra_rdoc_files = ["README.rdoc", "CHANGELOG.rdoc", "LICENSE"]
+  s.extra_rdoc_files = ["README.md", "CHANGELOG.rdoc", "LICENSE"]
 
-  s.add_runtime_dependency(%q<timeliness>, ["~> 0.3.7"])
+  s.add_runtime_dependency(%q<timeliness>, [">= 0.3.10", "< 1"])
 end