v4.1.0

update changelog
use travis matrix for ruby + rails versions
2026-01-25 15:22:58 +00:00 · 2019-06-11 20:51:42 +10:00 · 2019-06-11 20:51:34 +10:00 · 2019-06-11 20:24:14 +10:00 · 2019-06-11 19:37:18 +10:00 · 2019-06-11 19:28:02 +10:00
46 changed files with 820 additions and 666 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,5 @@ pkg/
 .bundle/
 .rvmrc
 Gemfile.lock
+gemfiles/*.lock
+.byebug_history
--- a/.rspec
+++ b/.rspec
@@ -1,2 +1,4 @@
--format nested
+--format documentation
 --color
+--require spec_helper
+--require byebug
--- a/.travis.yml
+++ b/.travis.yml
@@ -0,0 +1,30 @@
+language: ruby
+before_install:
+  - gem uninstall -v '>= 2' -i $(rvm gemdir)@global -ax bundler || true
+  - gem install bundler -v '< 2'
+before_script:
+  - bundle install
+cache: bundler
+bundler_args: --verbose
+
+matrix:
+  include:
+    - rvm: "2.3.7"
+      gemfile: gemfiles/rails_4_0.gemfile
+    - rvm: "2.3.7"
+      gemfile: gemfiles/rails_4_1.gemfile
+    - rvm: "2.3.7"
+      gemfile: gemfiles/rails_4_2.gemfile
+    - rvm: "2.4.6"
+      gemfile: gemfiles/rails_4_2.gemfile
+    - rvm: "2.5.5"
+      gemfile: gemfiles/rails_4_2.gemfile
+
+script: 'bundle exec rspec'
+
+notifications:
+  email:
+    recipients:
+      - adam.meehan@gmail.com
+    on_failure: change
+    on_success: never
--- a/11
+++ b/11
@@ -0,0 +1,11 @@
+appraise "rails_4_0" do
+  gem "rails", "~> 4.0.13"
+end
+
+appraise "rails_4_1" do
+  gem "rails", "~> 4.1.14"
+end
+
+appraise "rails_4_2" do
+  gem "rails", "~> 4.2.11"
+end
--- a/CHANGELOG.rdoc
+++ b/CHANGELOG.rdoc
@@ -1,3 +1,43 @@
+= 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
+* Upgrade specs to RSpec 3
+* Added travis config
+* Huge thanks to @johncarney for keeping it alive with his fork (https://github.com/johncarney/validates_timeliness)
+
+= 3.0.15 [2015-12-29]
+* Fixes mongoid 3 support and removes mongoid 2 support(johnnyshields)
+* Some documentation/comments tidying
+* Some general tidying up
+
+= 3.0.14 [2012-08-23]
+* Fix for using validates :timeliness => {} form to correctly add attributes to timeliness validated attributes.
+
+= 3.0.13 [2012-08-21]
+* Fix ActiveRecord issues with using plugin parser by using old way of caching values.
+* Allow any ActiveRecord non-column attribute to be validated
+
+= 3.0.12 [2012-06-23]
+* Fix load order issue when relying on Railtie to load ActiveRecord extension
+
+= 3.0.11 [2012-04-01]
+* Change dependency on Timeliness version due to a broken release
+
+= 3.0.10 [2012-03-26]
+* Fix for ActiveRecord shim and validation with :allow_blank => true in AR 3.1+. Fixes issue#52.
+
 = 3.0.9 [2012-03-26]
 * ActiveRecord 3.1+ suport
 * Fixes for multiparameter extension with empty date values (thanks @mogox, @Sharagoz)
--- a/26
+++ b/26
@@ -1,21 +1,13 @@
-source 'http://rubygems.org'
+source 'https://rubygems.org'

 gemspec

-gem 'rails', '~> 3.2.1'
-gem 'rspec', '~> 2.8'
-gem 'rspec-rails', '~> 2.8'
+gem 'rake'
+gem 'rails', '~> 4.2.11.1'
+gem 'rspec'
+gem 'rspec-rails', '~> 3.7'
 gem 'timecop'
-gem 'rspec_tag_matchers'
-gem 'ruby-debug', :platforms => [:ruby_18, :jruby]
-gem 'ruby-debug19', :platforms => [:ruby_19]
-
-group :mongoid do
-  gem 'mongoid', '~> 2.3.0'
-  gem 'bson_ext'
-  gem 'system_timer', :platforms => [:ruby_18]
-end
-
-group :active_record do
-  gem 'sqlite3-ruby', :require => 'sqlite3'
-end
+gem 'byebug'
+gem 'appraisal'
+gem 'sqlite3'
+gem 'nokogiri', '~> 1.8'
--- a/README.rdoc
+++ b/README.rdoc
@@ -1,13 +1,13 @@
 = ValidatesTimeliness

 * Source:  http://github.com/adzap/validates_timeliness
-* Bugs:    http://github.com/adzap/validates_timeliness/issues
+* Issues:  http://github.com/adzap/validates_timeliness/issues

 == Description

-Complete validation of dates, times and datetimes for Rails 3.x and ActiveModel.
+Complete validation of dates, times and datetimes for Rails 4.x and ActiveModel.

-If you a looking for the old version for Rails 2.x go here[http://github.com/adzap/validates_timeliness/tree/v2.3].
+If you a looking for the old version for Rails 3.x go here[http://github.com/adzap/validates_timeliness/tree/v3.x].


 == Features
@@ -18,24 +18,19 @@ If you a looking for the old version for Rails 2.x go here[http://github.com/adz

 * Only Rails date/time validation plugin offering complete validation (See ORM/ODM support)

-* Adds extensions to fix Rails date/time select issues (See Extensions)
-
 * Uses extensible date/time parser (Using {timeliness gem}[http://github.com/adzap/timeliness]. See Plugin Parser)

-* Supports I18n for the error messages
+* 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).

-* Supports Ruby 1.8.x, 1.9.x and Rubinius.

 == Installation

-As plugin (from master)
-
-  rails plugin install git://github.com/adzap/validates_timeliness.git
-
-As gem
-
  # in Gemfile
-  gem 'validates_timeliness', '~> 3.0.2'
+  gem 'validates_timeliness', '~> 4.0'

  # Run bundler
  $ bundle install
@@ -44,7 +39,7 @@ Then run
  
  $ rails generate validates_timeliness:install

-This creates configuration initializer and locale files. In the initializer, you there are a number of config
+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.
@@ -55,12 +50,15 @@ NOTE: You may wish to enable the plugin parser and the extensions to start. Plea
  validates_datetime :occurred_at

  validates_date :date_of_birth, :before => lambda { 18.years.ago },
-                                :before_message => "must be at least 18 years old"
+                                 :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']
+
+  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',
@@ -79,7 +77,7 @@ validation method
    validates :date_of_birth, :timeliness => {:on_or_before => lambda { Date.current }, :type => :date}
  end

-  # or even on a specific record, per ActiveModel API.
+or even on a specific record, per ActiveModel API.

  @person.validates_date :date_of_birth, :on_or_before => lambda { Date.current }

@@ -139,8 +137,8 @@ like so

  ValidatesTimeliness.setup do |config|

-    # Extend ORM/ODMs for full support (:active_record, :mongoid).
-    config.extend_orms = [ :mongoid ]
+    # Extend ORM/ODMs for full support (:active_record).
+    config.extend_orms = [ :active_record ]

  end

@@ -178,8 +176,8 @@ You can also use validation options for custom error messages. The following opt
    :after_message
    :on_or_after_message

-Note: There is no :between_message option. The between error message should be defined using the 
-:on_or_before and :on_or_after messages.
+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.

@@ -298,4 +296,4 @@ To see the generous people who have contributed code, take a look at the {contri

 == License

-Copyright (c) 2008-2010 Adam Meehan, released under the MIT license
+Copyright (c) 2008 Adam Meehan, released under the MIT license
--- a/8
+++ b/8
@@ -1,9 +1,11 @@
 require 'bundler'
+require 'bundler/setup'
+
+require 'appraisal'
+
 Bundler::GemHelper.install_tasks

-Bundler.setup
-
-require 'rake/rdoctask'
+require 'rdoc/task'
 require 'rspec/core/rake_task'

 desc "Run specs"
--- a/autotest/discover.rb
+++ b/autotest/discover.rb
@@ -1 +0,0 @@
-Autotest.add_discovery { "rspec2" }
--- a/gemfiles/rails_4_0.gemfile
+++ b/gemfiles/rails_4_0.gemfile
@@ -0,0 +1,14 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "~> 4.0.13"
+gem "rspec", "~> 3.6.0"
+gem "rspec-rails", "~> 3.6.0"
+gem "timecop"
+gem "byebug"
+gem "appraisal"
+gem "sqlite3", "~> 1.3.0"
+gem "nokogiri", "1.6.7"
+
+gemspec path: "../"
--- a/gemfiles/rails_4_1.gemfile
+++ b/gemfiles/rails_4_1.gemfile
@@ -0,0 +1,14 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "~> 4.1.14"
+gem "rspec", "~> 3.6.0"
+gem "rspec-rails", "~> 3.6.0"
+gem "timecop"
+gem "byebug"
+gem "appraisal"
+gem "sqlite3", "~> 1.3.0"
+gem "nokogiri", "1.6.7"
+
+gemspec path: "../"
--- a/gemfiles/rails_4_2.gemfile
+++ b/gemfiles/rails_4_2.gemfile
@@ -0,0 +1,14 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "~> 4.2.8"
+gem "rspec", "~> 3.6.0"
+gem "rspec-rails", "~> 3.6.0"
+gem "timecop"
+gem "byebug"
+gem "appraisal"
+gem "sqlite3", "~> 1.3.0"
+gem "nokogiri", "1.6.7"
+
+gemspec path: "../"
--- a/lib/generators/validates_timeliness/install_generator.rb
+++ b/lib/generators/validates_timeliness/install_generator.rb
@@ -3,7 +3,6 @@ module ValidatesTimeliness
    class InstallGenerator < Rails::Generators::Base
      desc "Copy ValidatesTimeliness default files"
      source_root File.expand_path('../templates', __FILE__)
-      class_option :template_engine

      def copy_initializers
        copy_file 'validates_timeliness.rb', 'config/initializers/validates_timeliness.rb'
--- a/lib/generators/validates_timeliness/templates/validates_timeliness.rb
+++ b/lib/generators/validates_timeliness/templates/validates_timeliness.rb
@@ -1,6 +1,6 @@
 ValidatesTimeliness.setup do |config|
-  # Extend ORM/ODMs for full support (:active_record, :mongoid).
-  # config.extend_orms = [ :active_record ]
+  # Extend ORM/ODMs for full support (:active_record included).
+  config.extend_orms = [ :active_record ]
  #
  # Default timezone
  # config.default_timezone = :utc
@@ -32,7 +32,7 @@ ValidatesTimeliness.setup do |config|
  # Remove one or more formats making them invalid. e.g. remove_formats(:date, 'dd/mm/yyy')
  # config.parser.remove_formats()
  #
-  # Change the amiguous year threshold when parsing a 2 digit year
+  # Change the ambiguous year threshold when parsing a 2 digit year
  # config.parser.ambiguous_year_threshold =  30
  #
  # Treat ambiguous dates, such as 01/02/1950, as a Non-US date.
--- a/lib/validates_timeliness.rb
+++ b/lib/validates_timeliness.rb
@@ -24,26 +24,24 @@ module ValidatesTimeliness

  class << self
    delegate :default_timezone, :default_timezone=, :dummy_date_for_time_type, :dummy_date_for_time_type=, :to => Timeliness
+
+    attr_accessor :extend_orms, :ignore_restriction_errors, :restriction_shorthand_symbols, :use_plugin_parser
  end

-  # Extend ORM/ODMs for full support (:active_record, :mongoid).
-  mattr_accessor :extend_orms
-  @@extend_orms = []
+  # Extend ORM/ODMs for full support (:active_record).
+  self.extend_orms = []

  # Ignore errors when restriction options are evaluated
-  mattr_accessor :ignore_restriction_errors
-  @@ignore_restriction_errors = false
+  self.ignore_restriction_errors = false

  # Shorthand time and date symbols for restrictions
-  mattr_accessor :restriction_shorthand_symbols
-  @@restriction_shorthand_symbols = {
+  self.restriction_shorthand_symbols = {
    :now   => lambda { Time.current },
    :today => lambda { Date.current }
  }

  # Use the plugin date/time parser which is stricter and extensible
-  mattr_accessor :use_plugin_parser
-  @@use_plugin_parser = false
+  self.use_plugin_parser = false

  # Default timezone
  self.default_timezone = :utc
@@ -51,15 +49,17 @@ module ValidatesTimeliness
  # Set the dummy date part for a time type values.
  self.dummy_date_for_time_type = [ 2000, 1, 1 ]

-  def self.parser
-    Timeliness
-  end
-
  # Setup method for plugin configuration
  def self.setup
    yield self
+    load_orms
+  end
+
+  def self.load_orms
    extend_orms.each {|orm| require "validates_timeliness/orm/#{orm}" }
  end
+
+  def self.parser; Timeliness end
 end

 require 'validates_timeliness/conversion'
--- a/lib/validates_timeliness/attribute_methods.rb
+++ b/lib/validates_timeliness/attribute_methods.rb
@@ -20,13 +20,6 @@ module ValidatesTimeliness
        :datetime
      end

-      def undefine_attribute_methods
-        super
-        undefine_timeliness_attribute_methods
-      end
-
-      protected
-
      def define_timeliness_methods(before_type_cast=false)
        return if timeliness_validated_attributes.blank?
        timeliness_validated_attributes.each do |attr_name|
@@ -34,55 +27,58 @@ module ValidatesTimeliness
        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)
-        method_body, line = <<-EOV, __LINE__ + 1
+        generated_timeliness_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
          def #{attr_name}=(value)
-            original_value = value
-            @timeliness_cache ||= {}
-            @timeliness_cache["#{attr_name}"] = original_value
-            #{ "if value.is_a?(String)\n#{timeliness_type_cast_code(attr_name, 'value')}\nend" if ValidatesTimeliness.use_plugin_parser }
-            
-            super(value)
+            write_timeliness_attribute('#{attr_name}', value)
          end
-        EOV
-        generated_timeliness_methods.module_eval(method_body, __FILE__, line)
+        STR
      end

      def define_timeliness_before_type_cast_method(attr_name)
-        method_body, line = <<-EOV, __LINE__ + 1
+        generated_timeliness_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
          def #{attr_name}_before_type_cast
-            _timeliness_raw_value_for('#{attr_name}') || @attributes['#{attr_name}']
+            read_timeliness_attribute_before_type_cast('#{attr_name}')
          end
-        EOV
-        generated_timeliness_methods.module_eval(method_body, __FILE__, line)
-      end
-
-      def timeliness_type_cast_code(attr_name, var_name)
-        type = timeliness_attribute_type(attr_name)
-        timezone_aware = timeliness_attribute_timezone_aware?(attr_name)
-        timezone = :current if timezone_aware
-
-        "#{var_name} = Timeliness::Parser.parse(#{var_name}, :#{type}, :zone => #{timezone.inspect})"
-      end
-
-      def generated_timeliness_methods
-        @generated_timeliness_methods ||= Module.new.tap { |m| include(m) }
-      end
-
-      def undefine_timeliness_attribute_methods
-        generated_timeliness_methods.module_eval do
-          instance_methods.each { |m| undef_method(m) }
-        end
+        STR
      end
    end

-    def _timeliness_raw_value_for(attr_name)
-      @timeliness_cache && @timeliness_cache[attr_name.to_s]
+    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
--- a/lib/validates_timeliness/conversion.rb
+++ b/lib/validates_timeliness/conversion.rb
@@ -12,6 +12,8 @@ module ValidatesTimeliness
        value.to_date
      when :datetime
        value.is_a?(Time) ? value : value.to_time
+      else
+        value
      end
      if options[:ignore_usec] && value.is_a?(Time)
        Timeliness::Parser.make_time(Array(value).reverse[4..9], (:current if @timezone_aware))
--- a/lib/validates_timeliness/extensions.rb
+++ b/lib/validates_timeliness/extensions.rb
@@ -1,14 +1,13 @@
 module ValidatesTimeliness
  module Extensions
-    autoload :DateTimeSelect,        'validates_timeliness/extensions/date_time_select'
-    autoload :MultiparameterHandler, 'validates_timeliness/extensions/multiparameter_handler'
+    autoload :DateTimeSelect, 'validates_timeliness/extensions/date_time_select'
  end

  def self.enable_date_time_select_extension!
-    ::ActionView::Helpers::InstanceTag.send(:include, ValidatesTimeliness::Extensions::DateTimeSelect)
+    ::ActionView::Helpers::Tags::DateSelect.send(:include, ValidatesTimeliness::Extensions::DateTimeSelect)
  end

  def self.enable_multiparameter_extension!
-    ::ActiveRecord::Base.send(:include, ValidatesTimeliness::Extensions::MultiparameterHandler)
+    require 'validates_timeliness/extensions/multiparameter_handler'
  end
 end
--- a/lib/validates_timeliness/extensions/date_time_select.rb
+++ b/lib/validates_timeliness/extensions/date_time_select.rb
@@ -9,7 +9,6 @@ module ValidatesTimeliness
      # It's a minor usability improvement which is rarely an issue for the user.

      included do
-        alias_method_chain :datetime_selector, :timeliness
        alias_method_chain :value, :timeliness
      end

@@ -33,15 +32,8 @@ module ValidatesTimeliness
        end
      end

-      def datetime_selector_with_timeliness(*args)
-        @timeliness_date_or_time_tag = true
-        datetime_selector_without_timeliness(*args)
-      end
-
      def value_with_timeliness(object)
-        unless @timeliness_date_or_time_tag && @template_object.params[@object_name]
-          return value_without_timeliness(object)
-        end
+        return value_without_timeliness(object) unless @template_object.params[@object_name]

        @template_object.params[@object_name]

@@ -56,6 +48,7 @@ module ValidatesTimeliness

        TimelinessDateTime.new(*values)
      end
+
    end
  end
 end
--- a/lib/validates_timeliness/extensions/multiparameter_handler.rb
+++ b/lib/validates_timeliness/extensions/multiparameter_handler.rb
@@ -1,80 +1,74 @@
-module ValidatesTimeliness
-  module Extensions
-    module MultiparameterHandler
-      extend ActiveSupport::Concern
-
-      # Stricter handling of date and time values from multiparameter 
-      # assignment from the date/time select view helpers
-
-      included do
-        alias_method_chain :instantiate_time_object, :timeliness
-        alias_method :execute_callstack_for_multiparameter_attributes, :execute_callstack_for_multiparameter_attributes_with_timeliness
-        alias_method :read_value_from_parameter, :read_value_from_parameter_with_timeliness
-      end
-
-      private
-
-      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_with_timeliness(name, values)
-        validate_multiparameter_date_values(values) {
-          instantiate_time_object_without_timeliness(name, values)
-        }
-      end
-
-      def instantiate_date_object(name, values)
-        validate_multiparameter_date_values(values) {
-          Date.new(*values)
-        }
-      end
-
-      # Yield if date values are valid
-      def validate_multiparameter_date_values(values)
-        if values[0..2].all?{ |v| v.present? } && Date.valid_civil?(*values[0..2])
-          yield
-        else
-          invalid_multiparameter_date_or_time_as_string(values)
-        end
-      end
-
-      def read_value_from_parameter_with_timeliness(name, values_from_param)
-        klass = (self.class.reflect_on_aggregation(name.to_sym) || column_for_attribute(name)).klass
-        values = values_from_param.is_a?(Hash) ? values_from_param.to_a.sort_by(&:first).map(&:last) : values_from_param
-
-        if values.empty? || values.all?{ |v| v.nil? }
-          nil
-        elsif klass == Time
-          instantiate_time_object(name, values)
-        elsif klass == Date
-          instantiate_date_object(name, values)
-        else
-          if respond_to?(:read_other_parameter_value)
-            read_date_parameter_value(name, values_from_param)
-          else
-            klass.new(*values)
-          end
-        end
-      end
-
-      def execute_callstack_for_multiparameter_attributes_with_timeliness(callstack)
-        errors = []
-        callstack.each do |name, values_with_empty_parameters|
-          begin
-            send(name + "=", read_value_from_parameter(name, values_with_empty_parameters))
-          rescue => ex
-            values = values_with_empty_parameters.is_a?(Hash) ? values_with_empty_parameters.values : values_with_empty_parameters 
-            errors << ActiveRecord::AttributeAssignmentError.new("error on assignment #{values.inspect} to #{name}", ex, name)
-          end
-        end
-        unless errors.empty?
-          raise ActiveRecord::MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes"
-        end
-      end
+ActiveRecord::AttributeAssignment::MultiparameterAttribute.class_eval do
+  private

+  # 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
+    else
+      invalid_multiparameter_date_or_time_as_string(set_values)
    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)
+      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
+      end
+    end
+
+    max_position = extract_max_param(6)
+    set_values   = values.values_at(*(1..max_position))
+
+    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
--- a/lib/validates_timeliness/helper_methods.rb
+++ b/lib/validates_timeliness/helper_methods.rb
@@ -14,12 +14,13 @@ module ActiveModel
        timeliness_validation_for attr_names, :datetime
      end

-      def timeliness_validation_for(attr_names, type)
-        options = _merge_attributes(attr_names).merge(:type => type)
-        if respond_to?(:timeliness_validated_attributes)
-          self.timeliness_validated_attributes ||= []
-          self.timeliness_validated_attributes += (attr_names - self.timeliness_validated_attributes)
-        end
+      def validates_timeliness_of(*attr_names)
+        timeliness_validation_for attr_names
+      end
+
+      def timeliness_validation_for(attr_names, type=nil)
+        options = _merge_attributes(attr_names)
+        options.update(:type => type) if type
        validates_with TimelinessValidator, options
      end
    end
--- a/lib/validates_timeliness/orm/active_model.rb
+++ b/lib/validates_timeliness/orm/active_model.rb
@@ -0,0 +1,20 @@
+module ValidatesTimeliness
+  module ORM
+    module ActiveModel
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        public
+
+        def define_attribute_methods(*attr_names)
+          super.tap { define_timeliness_methods}
+        end
+
+        def undefine_attribute_methods
+          super.tap { undefine_timeliness_attribute_methods }
+        end
+      end
+      
+    end
+  end
+end
--- a/lib/validates_timeliness/orm/active_record.rb
+++ b/lib/validates_timeliness/orm/active_record.rb
@@ -3,75 +3,90 @@ module ValidatesTimeliness
    module ActiveRecord
      extend ActiveSupport::Concern

-      def self.use_plugin_cache?
-        ::ActiveRecord::VERSION::STRING < '3.1.0'
-      end
-
-      included do
-        if ValidatesTimeliness::ORM::ActiveRecord.use_plugin_cache? 
-          include Reload
-        else
-          # Just use the built-in before_type_cast retrieval
-          alias_method :_timeliness_raw_value_for, :read_attribute_before_type_cast
-        end
-      end
-
      module ClassMethods
        public

        def timeliness_attribute_timezone_aware?(attr_name)
-          attr_name = attr_name.to_s
-          create_time_zone_conversion_attribute?(attr_name, columns_hash[attr_name])
+          create_time_zone_conversion_attribute?(attr_name, timeliness_column_for_attribute(attr_name))
        end

        def timeliness_attribute_type(attr_name)
-          columns_hash[attr_name.to_s].type
+          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 do |attribute_methods_generated|
-            use_before_type_cast = ValidatesTimeliness::ORM::ActiveRecord.use_plugin_cache?
-            define_timeliness_methods use_before_type_cast
-          end
-        end
-
-        protected
-
-        def define_attribute_timeliness_methods(attr_name, before_type_cast=false)
-          if before_type_cast
-            define_timeliness_write_method(attr_name)
-            define_timeliness_before_type_cast_method(attr_name)
-          elsif ValidatesTimeliness.use_plugin_parser
-            define_timeliness_write_method_without_cache(attr_name)
-          end
-        end
-
-        def define_timeliness_write_method_without_cache(attr_name)
-          method_body, line = <<-EOV, __LINE__ + 1
-            def #{attr_name}=(value)
-              original_value = value
-              if value.is_a?(String)\n#{timeliness_type_cast_code(attr_name, 'value')}\nend
-              super(value)
-              @attributes['#{attr_name}'] = original_value
+          super.tap { 
+            generated_timeliness_methods.synchronize do
+              return if @timeliness_methods_generated
+              define_timeliness_methods true
+              @timeliness_methods_generated = true
            end
-          EOV
-          generated_timeliness_methods.module_eval(method_body, __FILE__, line)
+          }
        end

-        def timeliness_type_cast_code(attr_name, var_name)
-          type = timeliness_attribute_type(attr_name)
-
-          method_body = super
-          method_body << "\n#{var_name} = #{var_name}.to_date if #{var_name}" if type == :date
-          method_body
+        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

-      module Reload
-        def reload(*args)
-          _clear_timeliness_cache
-          super
+      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
      end

    end
--- a/lib/validates_timeliness/orm/mongoid.rb
+++ b/lib/validates_timeliness/orm/mongoid.rb
@@ -1,63 +0,0 @@
-module ValidatesTimeliness
-  module ORM
-    module Mongoid
-      extend ActiveSupport::Concern
-      # You need define the fields before you define the validations.
-      # It is best to use the plugin parser to avoid errors on a bad
-      # field value in Mongoid. Parser will return nil rather than error.
-
-      module ClassMethods 
-        public
-
-        # Mongoid has no bulk attribute method definition hook. It defines
-        # them with each field definition. So we likewise define them after
-        # each validation is defined.
-        #
-        def timeliness_validation_for(attr_names, type)
-          super
-          attr_names.each { |attr_name| define_timeliness_write_method(attr_name) }
-        end
-
-        def timeliness_attribute_type(attr_name)
-          {
-            Date => :date,
-            Time => :datetime,
-            DateTime => :datetime
-          }[fields[attr_name.to_s].type] || :datetime
-        end
-
-        protected
-
-        def timeliness_type_cast_code(attr_name, var_name)
-          type = timeliness_attribute_type(attr_name)
-
-          "#{var_name} = Timeliness::Parser.parse(value, :#{type})"
-        end
-
-      end
-
-      module Reload
-        def reload(*args)
-          _clear_timeliness_cache
-          super
-        end
-      end
-    end
-  end
-end
- 
-module Mongoid::Document
-  include ValidatesTimeliness::AttributeMethods
-  include ValidatesTimeliness::ORM::Mongoid
-
-  # Pre-2.3 reload
-  if (instance_methods & ['reload', :reload]).present?
-    def reload_with_timeliness
-      _clear_timeliness_cache
-      reload_without_timeliness
-    end
-    alias_method_chain :reload, :timeliness
-  else
-    include ValidatesTimeliness::ORM::Mongoid::Reload
-  end
-end
--- a/lib/validates_timeliness/railtie.rb
+++ b/lib/validates_timeliness/railtie.rb
@@ -3,7 +3,8 @@ module ValidatesTimeliness
    initializer "validates_timeliness.initialize_active_record", :after => 'active_record.initialize_timezone' do
      ActiveSupport.on_load(:active_record) do
        ValidatesTimeliness.default_timezone = ActiveRecord::Base.default_timezone
-        ValidatesTimeliness.extend_orms = [ :active_record ]
+        ValidatesTimeliness.extend_orms << :active_record
+        ValidatesTimeliness.load_orms
      end
    end

--- a/lib/validates_timeliness/validator.rb
+++ b/lib/validates_timeliness/validator.rb
@@ -1,10 +1,11 @@
+require 'active_model'
 require 'active_model/validator'

 module ValidatesTimeliness
  class Validator < ActiveModel::EachValidator
    include Conversion

-    attr_reader :type
+    attr_reader :type, :attributes

    RESTRICTIONS = {
      :is_at        => :==,
@@ -22,17 +23,41 @@ module ValidatesTimeliness

    RESTRICTION_ERROR_MESSAGE = "Error occurred validating %s for %s restriction:\n%s"

+    def self.kind
+      :timeliness
+    end
+
    def initialize(options)
      @type = options.delete(:type) || :datetime
      @allow_nil, @allow_blank = options.delete(:allow_nil), options.delete(:allow_blank)

      if range = options.delete(:between)
        raise ArgumentError, ":between must be a Range or an Array" unless range.is_a?(Range) || range.is_a?(Array)
-        options[:on_or_after], options[:on_or_before] = range.first, range.last
+        options[:on_or_after] = range.first
+        if range.is_a?(Range) && range.exclude_end?
+          options[:before] = range.last
+        else
+          options[:on_or_before] = range.last
+        end
      end

      @restrictions_to_check = RESTRICTIONS.keys & options.keys
+
      super
+
+      setup_timeliness_validated_attributes(options[:class]) if options[:class]
+    end
+
+    def setup_timeliness_validated_attributes(model)
+      if model.respond_to?(:timeliness_validated_attributes)
+        model.timeliness_validated_attributes ||= []
+        model.timeliness_validated_attributes |= attributes
+      end
+    end
+
+    # Rails 4.0 compatibility for old #setup method with class as arg
+    if Gem::Version.new(ActiveModel::VERSION::STRING) <= Gem::Version.new('4.1')
+      alias_method(:setup, :setup_timeliness_validated_attributes) 
    end

    def validate_each(record, attr_name, value)
@@ -66,7 +91,7 @@ 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 }
+      message_options = { :message => options.fetch(:"#{message}_message", options[:message]), :restriction => value }
      record.errors.add(attr_name, message, message_options)
    end

@@ -76,8 +101,8 @@ module ValidatesTimeliness
    end

    def attribute_raw_value(record, attr_name)
-      record.respond_to?(:_timeliness_raw_value_for) &&
-        record._timeliness_raw_value_for(attr_name)
+      record.respond_to?(:read_timeliness_attribute_before_type_cast) &&
+        record.read_timeliness_attribute_before_type_cast(attr_name.to_s)
    end

    def timezone_aware?(record, attr_name)
--- a/lib/validates_timeliness/version.rb
+++ b/lib/validates_timeliness/version.rb
@@ -1,3 +1,3 @@
 module ValidatesTimeliness
-  VERSION = '3.0.9'
+  VERSION = '4.1.0'
 end
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -5,13 +5,14 @@ require 'active_model/validations'
 require 'active_record'
 require 'action_view'
 require 'timecop'
-require 'rspec_tag_matchers'

 require 'validates_timeliness'
+require 'validates_timeliness/orm/active_model'

 require 'support/test_model'
 require 'support/model_helpers'
 require 'support/config_helper'
+require 'support/tag_matcher'

 ValidatesTimeliness.setup do |c|
  c.extend_orms = [ :active_record ]
@@ -24,19 +25,15 @@ Time.zone = 'Australia/Melbourne'

 LOCALE_PATH = File.expand_path(File.dirname(__FILE__) + '/../lib/generators/validates_timeliness/templates/en.yml')
 I18n.load_path.unshift(LOCALE_PATH)
+I18n.available_locales = ['en', 'es']

 # Extend TestModel as you would another ORM/ODM module
 module TestModelShim
  extend ActiveSupport::Concern
  include ValidatesTimeliness::AttributeMethods
+  include ValidatesTimeliness::ORM::ActiveModel

  module ClassMethods
-    # Hook method for attribute method generation
-    def define_attribute_methods(attr_names)
-      super
-      define_timeliness_methods
-    end
-
    # Hook into native time zone handling check, if any
    def timeliness_attribute_timezone_aware?(attr_name)
      false
@@ -57,6 +54,7 @@ class PersonWithShim < Person
  include TestModelShim
 end

+ActiveRecord::Base.default_timezone = :utc
 ActiveRecord::Base.time_zone_aware_attributes = true
 ActiveRecord::Base.establish_connection({:adapter => 'sqlite3', :database => ':memory:'})
 ActiveRecord::Migration.verbose = false
@@ -73,8 +71,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
@@ -84,7 +82,7 @@ end

 RSpec.configure do |c|
  c.mock_with :rspec
-  c.include(RspecTagMatchers)
+  c.include(TagMatcher)
  c.include(ModelHelpers)
  c.include(ConfigHelper)
  c.before do
@@ -92,10 +90,7 @@ RSpec.configure do |c|
    reset_validation_setup_for(PersonWithShim)
  end

-  RSpec.configure do |c|
-    c.filter_run_excluding :active_record => lambda {|version|
-      !(::ActiveRecord::VERSION::STRING.to_s =~ /^#{version.to_s}/)
-    }
-  end
-  
+  c.filter_run_excluding :active_record => lambda {|version|
+    !(::ActiveRecord::VERSION::STRING.to_s =~ /^#{version.to_s}/)
+  }
 end
--- a/spec/support/model_helpers.rb
+++ b/spec/support/model_helpers.rb
@@ -3,15 +3,15 @@ module ModelHelpers
  # Some test helpers from Rails source 
  def invalid!(attr_name, values, error = nil)
    with_each_person_value(attr_name, values) do |record, value|
-      record.should be_invalid
-      record.errors[attr_name].size.should >= 1
-      record.errors[attr_name].first.should == error if error
+      expect(record).to be_invalid
+      expect(record.errors[attr_name].size).to be >= 1
+      expect(record.errors[attr_name].first).to eq(error) if error
    end
  end

  def valid!(attr_name, values)
    with_each_person_value(attr_name, values) do |record, value|
-      record.should be_valid
+      expect(record).to be_valid
    end
  end

--- a/spec/support/tag_matcher.rb
+++ b/spec/support/tag_matcher.rb
@@ -0,0 +1,35 @@
+require 'nokogiri'
+
+module TagMatcher
+  extend RSpec::Matchers::DSL
+
+  matcher :have_tag do |selector|
+    match do |subject|
+      matches = doc(subject).search(selector)
+
+      if @inner_text
+        matches = matches.select { |element| element.inner_text == @inner_text }
+      end
+
+      matches.any?
+    end
+
+    chain :with_inner_text do |inner_text|
+      @inner_text = inner_text
+    end
+
+    private
+
+    def body(subject)
+      if subject.respond_to?(:body)
+        subject.body
+      else
+        subject.to_s
+      end
+    end
+
+    def doc(subject)
+      @doc ||= Nokogiri::HTML(body(subject))
+    end
+  end
+end
--- a/spec/support/test_model.rb
+++ b/spec/support/test_model.rb
@@ -5,7 +5,6 @@ module TestModel
  include ActiveModel::AttributeMethods

  included do
-    attribute_method_suffix ""
    attribute_method_suffix "="
    cattr_accessor :model_attributes
  end
--- a/spec/validates_timeliness/attribute_methods_spec.rb
+++ b/spec/validates_timeliness/attribute_methods_spec.rb
@@ -1,8 +1,6 @@
-require 'spec_helper'
-
-describe ValidatesTimeliness::AttributeMethods do
-  it 'should define _timeliness_raw_value_for instance method' do
-    PersonWithShim.new.should respond_to(:_timeliness_raw_value_for)
+RSpec.describe ValidatesTimeliness::AttributeMethods do
+  it 'should define read_timeliness_attribute_before_type_cast instance method' do
+    expect(PersonWithShim.new).to respond_to(:read_timeliness_attribute_before_type_cast)
  end

  describe ".timeliness_validated_attributes" do
@@ -12,7 +10,7 @@ describe ValidatesTimeliness::AttributeMethods do
      PersonWithShim.validates_time :birth_time
      PersonWithShim.validates_datetime :birth_datetime

-      PersonWithShim.timeliness_validated_attributes.should == [ :birth_date, :birth_time, :birth_datetime ]
+      expect(PersonWithShim.timeliness_validated_attributes).to eq([ :birth_date, :birth_time, :birth_datetime ])
    end
  end
  
@@ -31,13 +29,13 @@ describe ValidatesTimeliness::AttributeMethods do
    it 'should cache attribute raw value' do
      r = PersonWithCache.new
      r.birth_datetime = date_string = '2010-01-01'
-      r._timeliness_raw_value_for('birth_datetime').should == date_string
+      expect(r.read_timeliness_attribute_before_type_cast('birth_datetime')).to eq(date_string)
    end

    it 'should not overwrite user defined methods' do
      e = Employee.new
      e.birth_date = '2010-01-01'
-      e.redefined_birth_date_called.should be_true
+      expect(e.redefined_birth_date_called).to be_truthy
    end

    it 'should be undefined if model class has dynamic attribute methods reset' do
@@ -46,13 +44,13 @@ describe ValidatesTimeliness::AttributeMethods do
      r = PersonWithShim.new
      r.birth_date = Time.now

-      write_method = RUBY_VERSION < '1.9' ? 'birth_date=' : :birth_date=
+      write_method = :birth_date=

-      PersonWithShim.send(:generated_timeliness_methods).instance_methods.should include(write_method)
+      expect(PersonWithShim.send(:generated_timeliness_methods).instance_methods).to include(write_method)

      PersonWithShim.undefine_attribute_methods 

-      PersonWithShim.send(:generated_timeliness_methods).instance_methods.should_not include(write_method)
+      expect(PersonWithShim.send(:generated_timeliness_methods).instance_methods).not_to include(write_method)
    end

    context "with plugin parser" do
@@ -70,7 +68,7 @@ describe ValidatesTimeliness::AttributeMethods do
      end

      it 'should parse a string value' do
-        Timeliness::Parser.should_receive(:parse)
+        expect(Timeliness::Parser).to receive(:parse)
        r = PersonWithParser.new
        r.birth_date = '2010-01-01'
      end
@@ -80,7 +78,7 @@ describe ValidatesTimeliness::AttributeMethods do

  context "before_type_cast method" do
    it 'should not be defined if ORM does not support it' do
-      PersonWithShim.new.should_not respond_to(:birth_datetime_before_type_cast)
+      expect(PersonWithShim.new).not_to respond_to(:birth_datetime_before_type_cast)
    end
  end
 end
--- a/spec/validates_timeliness/conversion_spec.rb
+++ b/spec/validates_timeliness/conversion_spec.rb
@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe ValidatesTimeliness::Conversion do
+RSpec.describe ValidatesTimeliness::Conversion do
  include ValidatesTimeliness::Conversion

  let(:options) { Hash.new }
@@ -12,68 +10,68 @@ describe ValidatesTimeliness::Conversion do
  describe "#type_cast_value" do
    describe "for date type" do
      it "should return same value for date value" do
-        type_cast_value(Date.new(2010, 1, 1), :date).should == Date.new(2010, 1, 1)
+        expect(type_cast_value(Date.new(2010, 1, 1), :date)).to eq(Date.new(2010, 1, 1))
      end

      it "should return date part of time value" do
-        type_cast_value(Time.mktime(2010, 1, 1, 0, 0, 0), :date).should == Date.new(2010, 1, 1)
+        expect(type_cast_value(Time.mktime(2010, 1, 1, 0, 0, 0), :date)).to eq(Date.new(2010, 1, 1))
      end

      it "should return date part of datetime value" do
-        type_cast_value(DateTime.new(2010, 1, 1, 0, 0, 0), :date).should == Date.new(2010, 1, 1)
+        expect(type_cast_value(DateTime.new(2010, 1, 1, 0, 0, 0), :date)).to eq(Date.new(2010, 1, 1))
      end

      it 'should return nil for invalid value types' do
-        type_cast_value(12, :date).should == nil
+        expect(type_cast_value(12, :date)).to eq(nil)
      end
    end

    describe "for time type" do
      it "should return same value for time value matching dummy date part" do
-        type_cast_value(Time.utc(2000, 1, 1, 0, 0, 0), :time).should == Time.utc(2000, 1, 1, 0, 0, 0)
+        expect(type_cast_value(Time.utc(2000, 1, 1, 0, 0, 0), :time)).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
-        type_cast_value(Time.utc(2010, 1, 1, 0, 0, 0), :time).should == Time.utc(2000, 1, 1, 0, 0, 0)
+        expect(type_cast_value(Time.utc(2010, 1, 1, 0, 0, 0), :time)).to eq(Time.utc(2000, 1, 1, 0, 0, 0))
      end

      it "should return dummy time only for date value" do
-        type_cast_value(Date.new(2010, 1, 1), :time).should == Time.utc(2000, 1, 1, 0, 0, 0)
+        expect(type_cast_value(Date.new(2010, 1, 1), :time)).to eq(Time.utc(2000, 1, 1, 0, 0, 0))
      end

      it "should return dummy date with time part for datetime value" do
-        type_cast_value(DateTime.civil_from_format(:utc, 2010, 1, 1, 12, 34, 56), :time).should == Time.utc(2000, 1, 1, 12, 34, 56)
+        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))
      end

      it 'should return nil for invalid value types' do
-        type_cast_value(12, :time).should == nil
+        expect(type_cast_value(12, :time)).to eq(nil)
      end
    end

    describe "for datetime type" do
      it "should return Date as Time value" do
-        type_cast_value(Date.new(2010, 1, 1), :datetime).should == Time.local_time(2010, 1, 1, 0, 0, 0)
+        expect(type_cast_value(Date.new(2010, 1, 1), :datetime)).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)
-        type_cast_value(Time.utc(2010, 1, 1, 12, 34, 56), :datetime).should == value
+        expect(type_cast_value(Time.utc(2010, 1, 1, 12, 34, 56), :datetime)).to eq(value)
      end

      it "should return as Time with same component values" do
-        type_cast_value(DateTime.civil_from_format(:utc, 2010, 1, 1, 12, 34, 56), :datetime).should == Time.utc(2010, 1, 1, 12, 34, 56)
+        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))
      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.should == Time.zone.local(2010, 1, 1, 23, 34, 56)
-        result.zone.should == 'EST'
+        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
-        type_cast_value(12, :datetime).should == nil
+        expect(type_cast_value(12, :datetime)).to eq(nil)
      end
    end

@@ -82,41 +80,41 @@ describe ValidatesTimeliness::Conversion do

      it "should ignore usec on time values when evaluated" do
        value = Time.utc(2010, 1, 1, 12, 34, 56, 10000)
-        type_cast_value(value, :datetime).should == Time.utc(2010, 1, 1, 12, 34, 56)
+        expect(type_cast_value(value, :datetime)).to eq(Time.utc(2010, 1, 1, 12, 34, 56))
      end

      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.should == Time.zone.local(2010, 1, 1, 23, 34, 56)
-        result.zone.should == 'EST'
+        expect(result).to eq(Time.zone.local(2010, 1, 1, 23, 34, 56))
+        expect(result.zone).to eq('AEDT')
      end
    end
  end

  describe "#dummy_time" do
    it 'should return Time with dummy date values but same time components' do
-      dummy_time(Time.utc(2010, 11, 22, 12, 34, 56)).should == Time.utc(2000, 1, 1, 12, 34, 56)
+      expect(dummy_time(Time.utc(2010, 11, 22, 12, 34, 56))).to eq(Time.utc(2000, 1, 1, 12, 34, 56))
    end

    it 'should return same value for Time which already has dummy date values' do
-      dummy_time(Time.utc(2000, 1, 1, 12, 34, 56)).should == Time.utc(2000, 1, 1, 12, 34, 56)
+      expect(dummy_time(Time.utc(2000, 1, 1, 12, 34, 56))).to eq(Time.utc(2000, 1, 1, 12, 34, 56))
    end

    it 'should return time component values shifted to current zone if timezone aware' do
      @timezone_aware = true
-      dummy_time(Time.utc(2000, 1, 1, 12, 34, 56)).should == Time.zone.local(2000, 1, 1, 23, 34, 56)
+      expect(dummy_time(Time.utc(2000, 1, 1, 12, 34, 56))).to eq(Time.zone.local(2000, 1, 1, 23, 34, 56))
    end

    it 'should return base dummy time value for Date value' do
-      dummy_time(Date.new(2010, 11, 22)).should == Time.utc(2000, 1, 1, 0, 0, 0)
+      expect(dummy_time(Date.new(2010, 11, 22))).to eq(Time.utc(2000, 1, 1, 0, 0, 0))
    end

    describe "with custom dummy date" do
      it 'should return dummy time with custom dummy date' do
        with_config(:dummy_date_for_time_type, [2010, 1, 1] ) do
-          dummy_time(Time.utc(1999, 11, 22, 12, 34, 56)).should == Time.utc(2010, 1, 1, 12, 34, 56)
+          expect(dummy_time(Time.utc(1999, 11, 22, 12, 34, 56))).to eq(Time.utc(2010, 1, 1, 12, 34, 56))
        end
      end
    end
@@ -127,56 +125,56 @@ describe ValidatesTimeliness::Conversion do

    it 'should return Date object as is' do
      value = Date.new(2010,1,1)
-      evaluate_option_value(value, person).should == value
+      expect(evaluate_option_value(value, person)).to eq(value)
    end

    it 'should return Time object as is' do
      value = Time.mktime(2010,1,1)
-      evaluate_option_value(value, person).should == value
+      expect(evaluate_option_value(value, person)).to eq(value)
    end

    it 'should return DateTime object as is' do
      value = DateTime.new(2010,1,1,0,0,0)
-      evaluate_option_value(value, person).should == value
+      expect(evaluate_option_value(value, person)).to eq(value)
    end

    it 'should return Time value returned from proc with 0 arity' do
      value = Time.mktime(2010,1,1)
-      evaluate_option_value(lambda { value }, person).should == value
+      expect(evaluate_option_value(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
-      evaluate_option_value(lambda {|r| r.birth_time }, person).should == value
+      expect(evaluate_option_value(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
-      evaluate_option_value(:birth_time, person).should == value
+      expect(evaluate_option_value(:birth_time, 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'
-      evaluate_option_value(value, person).should == Time.utc(2010,1,1,12,0,0)
+      expect(evaluate_option_value(value, person)).to eq(Time.utc(2010,1,1,12,0,0))
    end

    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'
-      evaluate_option_value(value, person).should == Time.zone.local(2010,1,1,12,0,0)
+      expect(evaluate_option_value(value, person)).to eq(Time.zone.local(2010,1,1,12,0,0))
    end

    it 'should return Time value in default zone from proc which returns string time' do
      value = '2010-01-01 12:00:00'
-      evaluate_option_value(lambda { value }, person).should == Time.utc(2010,1,1,12,0,0)
+      expect(evaluate_option_value(lambda { value }, person)).to eq(Time.utc(2010,1,1,12,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'
      person.birth_time = value
-      evaluate_option_value(:birth_time, person).should == Time.utc(2010,1,1,12,0,0)
+      expect(evaluate_option_value(:birth_time, person)).to eq(Time.local(2010,1,1,12,0,0))
    end

    context "restriction shorthand" do
@@ -185,17 +183,17 @@ describe ValidatesTimeliness::Conversion do
      end

      it 'should evaluate :now as current time' do
-        evaluate_option_value(:now, person).should == Time.now
+        expect(evaluate_option_value(:now, person)).to eq(Time.now)
      end

      it 'should evaluate :today as current time' do
-        evaluate_option_value(:today, person).should == Date.today
+        expect(evaluate_option_value(:today, person)).to eq(Date.today)
      end

      it 'should not use shorthand if symbol if is record method' do
        time = 1.day.from_now
-        person.stub!(:now).and_return(time)
-        evaluate_option_value(:now, person).should == time
+        allow(person).to receive(:now).and_return(time)
+        expect(evaluate_option_value(:now, person)).to eq(time)
      end
    end
  end
@@ -205,7 +203,7 @@ describe ValidatesTimeliness::Conversion do
      with_config(:use_plugin_parser, true)

      it 'should use timeliness' do
-        Timeliness::Parser.should_receive(:parse)
+        expect(Timeliness::Parser).to receive(:parse)
        parse('2000-01-01')
      end
    end
@@ -215,20 +213,20 @@ describe ValidatesTimeliness::Conversion do

      it 'should use Time.zone.parse attribute is timezone aware' do
        @timezone_aware = true
-        Time.zone.should_receive(:parse)
+        expect(Time.zone).to 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'
-        value.should_receive(:to_time)
+        expect(value).to receive(:to_time)
        parse(value)
      end
    end

    it 'should return nil if value is nil' do
-      parse(nil).should be_nil
+      expect(parse(nil)).to be_nil
    end
  end
 end
--- a/spec/validates_timeliness/extensions/date_time_select_spec.rb
+++ b/spec/validates_timeliness/extensions/date_time_select_spec.rb
@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe ValidatesTimeliness::Extensions::DateTimeSelect do
+RSpec.describe 'ValidatesTimeliness::Extensions::DateTimeSelect' do
  include ActionView::Helpers::DateHelper
  attr_reader :person, :params

@@ -111,7 +109,7 @@ describe ValidatesTimeliness::Extensions::DateTimeSelect do
      @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)
-      @output.should have_tag("input[id=person_birth_date_3i][type=hidden][value='1']")
+      expect(@output).to have_tag("input[id=person_birth_date_3i][type=hidden][value='1']")
    end
  end

@@ -150,14 +148,15 @@ describe ValidatesTimeliness::Extensions::DateTimeSelect do
  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]
-      @output.should have_tag("select[id=person_#{field}_#{index}i] option[selected=selected]", value.to_s)
+      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]
-      @output.should_not have_tag("select[id=person_#{attribute}_#{index}i] option[selected=selected]")
+      expect(@output).not_to have_tag("select[id=person_#{attribute}_#{index}i] option[selected=selected]")
    end
  end
+  
 end
--- a/spec/validates_timeliness/extensions/multiparameter_handler_spec.rb
+++ b/spec/validates_timeliness/extensions/multiparameter_handler_spec.rb
@@ -1,38 +1,36 @@
-require 'spec_helper'
-
-describe ValidatesTimeliness::Extensions::MultiparameterHandler do
+RSpec.describe 'ValidatesTimeliness::Extensions::MultiparameterHandler' do

  context "time column" do
    it 'should assign a string value for invalid date portion' do
      employee = record_with_multiparameter_attribute(:birth_datetime, [2000, 2, 31, 12, 0, 0])
-      employee.birth_datetime_before_type_cast.should eq '2000-02-31 12:00:00'
+      expect(employee.birth_datetime_before_type_cast).to eq '2000-02-31 12:00:00'
    end
     
    it 'should assign a Time value for valid datetimes' do
      employee = record_with_multiparameter_attribute(:birth_datetime, [2000, 2, 28, 12, 0, 0])
-      employee.birth_datetime_before_type_cast.should eq Time.local(2000, 2, 28, 12, 0, 0)
+      expect(employee.birth_datetime_before_type_cast).to eq Time.zone.local(2000, 2, 28, 12, 0, 0)
    end

    it 'should assign a string value for incomplete time' do
      employee = record_with_multiparameter_attribute(:birth_datetime, [2000, nil, nil])
-      employee.birth_datetime_before_type_cast.should eq '2000-00-00'
+      expect(employee.birth_datetime_before_type_cast).to eq '2000-00-00'
    end
  end

  context "date column" do
    it 'should assign a string value for invalid date' do
      employee = record_with_multiparameter_attribute(:birth_date, [2000, 2, 31])
-      employee.birth_date_before_type_cast.should eq '2000-02-31'
+      expect(employee.birth_date_before_type_cast).to eq '2000-02-31'
    end

    it 'should assign a Date value for valid date' do
      employee = record_with_multiparameter_attribute(:birth_date, [2000, 2, 28])
-      employee.birth_date_before_type_cast.should eq Date.new(2000, 2, 28)
+      expect(employee.birth_date_before_type_cast).to eq Date.new(2000, 2, 28)
    end

    it 'should assign a string value for incomplete date' do
      employee = record_with_multiparameter_attribute(:birth_date, [2000, nil, nil])
-      employee.birth_date_before_type_cast.should eq '2000-00-00'
+      expect(employee.birth_date_before_type_cast).to eq '2000-00-00'
    end
  end

@@ -41,4 +39,5 @@ describe ValidatesTimeliness::Extensions::MultiparameterHandler do
    values.each_with_index {|value, index| hash["#{name}(#{index+1}i)"] = value.to_s }
    Employee.new(hash)
  end
+
 end
--- a/spec/validates_timeliness/helper_methods_spec.rb
+++ b/spec/validates_timeliness/helper_methods_spec.rb
@@ -1,30 +1,28 @@
-require 'spec_helper'
-
-describe ValidatesTimeliness, 'HelperMethods' do
+RSpec.describe ValidatesTimeliness, 'HelperMethods' do
+  let(:record) { Person.new }
+  
  it 'should define class validation methods' do
-    Person.should respond_to(:validates_date)
-    Person.should respond_to(:validates_time)
-    Person.should respond_to(:validates_datetime)
+    expect(Person).to respond_to(:validates_date)
+    expect(Person).to respond_to(:validates_time)
+    expect(Person).to respond_to(:validates_datetime)
  end

  it 'should define instance validation methods' do
-    Person.new.should respond_to(:validates_date)
-    Person.new.should respond_to(:validates_time)
-    Person.new.should respond_to(:validates_datetime)
+    expect(record).to respond_to(:validates_date)
+    expect(record).to respond_to(:validates_time)
+    expect(record).to respond_to(:validates_datetime)
  end

  it 'should validate instance using class validation defined' do
    Person.validates_date :birth_date
-    r = Person.new
-    r.valid?
+    record.valid?

-    r.errors[:birth_date].should_not be_empty
+    expect(record.errors[:birth_date]).not_to be_empty
  end

  it 'should validate instance using instance valiation method' do
-    r = Person.new
-    r.validates_date :birth_date
+    record.validates_date :birth_date

-    r.errors[:birth_date].should_not be_empty
+    expect(record.errors[:birth_date]).not_to be_empty
  end
 end
--- a/spec/validates_timeliness/orm/active_record_spec.rb
+++ b/spec/validates_timeliness/orm/active_record_spec.rb
@@ -1,120 +1,234 @@
-require 'spec_helper'
-
-describe ValidatesTimeliness, 'ActiveRecord' do
+RSpec.describe ValidatesTimeliness, 'ActiveRecord' do

  context "validation methods" do
+    let(:record) { Employee.new }
+
    it 'should be defined for the class' do
-      ActiveRecord::Base.should respond_to(:validates_date)
-      ActiveRecord::Base.should respond_to(:validates_time)
-      ActiveRecord::Base.should respond_to(:validates_datetime)
+      expect(ActiveRecord::Base).to respond_to(:validates_date)
+      expect(ActiveRecord::Base).to respond_to(:validates_time)
+      expect(ActiveRecord::Base).to respond_to(:validates_datetime)
    end

    it 'should defines for the instance' do
-      Employee.new.should respond_to(:validates_date)
-      Employee.new.should respond_to(:validates_time)
-      Employee.new.should respond_to(:validates_datetime)
+      expect(record).to respond_to(:validates_date)
+      expect(record).to respond_to(:validates_time)
+      expect(record).to respond_to(:validates_datetime)
+    end
+
+    it "should validate a valid value string" do
+      record.birth_date = '2012-01-01'
+
+      record.valid?
+      expect(record.errors[:birth_date]).to be_empty
+    end
+
+    it "should validate a invalid value string" do
+      record.birth_date = 'not a date'
+
+      record.valid?
+      expect(record.errors[:birth_date]).not_to be_empty
+    end
+
+    it "should validate a nil value" do
+      record.birth_date = nil
+
+      record.valid?
+      expect(record.errors[:birth_date]).to be_empty
    end
  end

  it 'should determine type for attribute' do
-    Employee.timeliness_attribute_type(:birth_date).should == :date
+    expect(Employee.timeliness_attribute_type(:birth_date)).to eq :date
+  end
+
+  context 'attribute timezone awareness' do
+    let(:klass) {
+      Class.new(ActiveRecord::Base) do
+        self.table_name = 'employees'
+        attr_accessor :some_date
+        attr_accessor :some_time
+        attr_accessor :some_datetime
+        validates_date :some_date
+        validates_time :some_time
+        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
    class EmployeeWithCache < ActiveRecord::Base
-      set_table_name 'employees'
-      validates_datetime :birth_datetime
+      self.table_name = 'employees'
+      validates_date :birth_date, :allow_blank => true
+      validates_time :birth_time, :allow_blank => true
+      validates_datetime :birth_datetime, :allow_blank => true
    end

-    it 'should cache attribute raw value' do
-      r = EmployeeWithCache.new
-      r.birth_datetime = date_string = '2010-01-01'
-      r._timeliness_raw_value_for('birth_datetime').should == date_string
+    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 }

      class EmployeeWithParser < ActiveRecord::Base
-        set_table_name 'employees'
-        validates_date :birth_date
-        validates_datetime :birth_datetime
+        self.table_name = 'employees'
+        validates_date :birth_date, :allow_blank => true
+        validates_time :birth_time, :allow_blank => true
+        validates_datetime :birth_datetime, :allow_blank => true
      end

-      it 'should parse a string value' do
-        Timeliness::Parser.should_receive(:parse)
-        r = EmployeeWithParser.new
-        r.birth_date = '2010-01-01'
+      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'
+        end
+
+        it 'should parse a invalid string value as nil' do
+          expect(Timeliness::Parser).to receive(:parse)
+
+          record.birth_date = 'not valid'
+        end
+
+        it 'should store a Date value after parsing string' do
+          record.birth_date = '2010-01-01'
+
+          expect(record.birth_date).to be_kind_of(Date)
+          expect(record.birth_date).to eq Date.new(2010, 1, 1)
+        end
      end

-      context "for a date column", :active_record => '3.0' do
-        it 'should store a date value after parsing string' do
-          r = EmployeeWithParser.new
-          r.birth_date = '2010-01-01'
+      context "for a time column" do
+        it 'should parse a string value' do
+          expect(Timeliness::Parser).to receive(:parse)

-          r.birth_date.should be_kind_of(Date)
-          r.birth_date.should == Date.new(2010, 1, 1)
+          record.birth_time = '12:30'
+        end
+
+        it 'should parse a invalid string value as nil' do
+          expect(Timeliness::Parser).to receive(:parse)
+
+          record.birth_time = 'not valid'
+        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)
        end
      end

      context "for a datetime column" do
        with_config(:default_timezone, 'Australia/Melbourne')

-        it 'should parse string into Time value' do
-          r = EmployeeWithParser.new
-          r.birth_datetime = '2010-01-01 12:00'
+        it 'should parse a string value' do
+          expect(Timeliness::Parser).to receive(:parse)

-          r.birth_datetime.should be_kind_of(Time)
+          record.birth_datetime = '2010-01-01 12:00'
+        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)
        end

        it 'should parse string as current timezone' do
-          r = EmployeeWithParser.new
-          r.birth_datetime = '2010-06-01 12:00'
+          record.birth_datetime = '2010-06-01 12:00'

-          r.birth_datetime.utc_offset.should == Time.zone.utc_offset
+          expect(record.birth_datetime.utc_offset).to eq Time.zone.utc_offset
        end
      end
    end
  end

-  context "cached value" do
-    it 'should be cleared on reload' do
-      r = Employee.create!
-      r.birth_date = '2010-01-01'
-      r.reload
+  context "reload" do
+    it 'should clear cache value' do
+      record = Employee.create!
+      record.birth_date = '2010-01-01'
+      
+      record.reload

-      r._timeliness_raw_value_for('birth_date').should be_nil
+      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
-      Employee.new.should respond_to(:birth_datetime_before_type_cast)
+      expect(record).to respond_to(:birth_datetime_before_type_cast)
    end

    it 'should return original value' do
-      r = Employee.new
-      r.birth_datetime = date_string = '2010-01-01'
+      record.birth_datetime = date_string = '2010-01-01'

-      r.birth_datetime_before_type_cast.should == date_string
+      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)

-      r = Employee.last
-      r.birth_datetime_before_type_cast.should match(/2010-01-01 00:00:00/)
+      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
-        r = Employee.new
-        r.birth_datetime = date_string = '2010-01-31'
+        record.birth_datetime = date_string = '2010-01-31'

-        r.birth_datetime_before_type_cast.should == date_string
+        expect(record.birth_datetime_before_type_cast).to eq date_string
      end
    end

@@ -122,7 +236,19 @@ describe ValidatesTimeliness, 'ActiveRecord' do

  context "define_attribute_methods" do
    it "returns a falsy value if the attribute methods have already been generated" do
-      Employee.define_attribute_methods.should be_false
+      expect(Employee.define_attribute_methods).to be_falsey
+    end
+  end
+
+  context "undefine_attribute_methods" do
+    it "returns remove attribute methods that have already been generated" do
+      Employee.define_attribute_methods
+
+      expect(Employee.instance_methods).to include(:birth_datetime)
+
+      Employee.undefine_attribute_methods
+
+      expect(Employee.instance_methods).to_not include(:birth_datetime)
    end
  end
 end
--- a/spec/validates_timeliness/orm/mongoid_spec.rb
+++ b/spec/validates_timeliness/orm/mongoid_spec.rb
@@ -1,113 +0,0 @@
-require 'spec_helper'
-
-# Try loading mongoid and connecting. Otherwise, abort and skip spec.
-begin
-
-require 'mongoid'
-require 'validates_timeliness/orm/mongoid'
-Mongoid.configure do |config|
-  name = "validates_timeliness_test"
-  host = "localhost"
-  config.master = Mongo::Connection.new.db(name)
-  config.persist_in_safe_mode = false
-end
-
-describe ValidatesTimeliness, 'Mongoid' do
-
-  class Article
-    include Mongoid::Document
-    ValidatesTimeliness.use_plugin_parser = true
-    field :publish_date, :type => Date
-    field :publish_time, :type => Time
-    field :publish_datetime, :type => DateTime
-    validates_date :publish_date, :allow_nil => true
-    validates_time :publish_time, :allow_nil => true
-    validates_datetime :publish_datetime, :allow_nil => true
-    ValidatesTimeliness.use_plugin_parser = false
-  end
-
-  context "validation methods" do
-    it 'should be defined on the class' do
-      Article.should respond_to(:validates_date)
-      Article.should respond_to(:validates_time)
-      Article.should respond_to(:validates_datetime)
-    end
-
-    it 'should be defined on the instance' do
-      Article.new.should respond_to(:validates_date)
-      Article.new.should respond_to(:validates_time)
-      Article.new.should respond_to(:validates_datetime)
-    end
-  end
-
-  it 'should determine type for attribute' do
-    Article.timeliness_attribute_type(:publish_date).should == :date
-  end
-  
-  context "attribute write method" do
-    it 'should cache attribute raw value' do
-      r = Article.new
-      r.publish_datetime = date_string = '2010-01-01'
-      r._timeliness_raw_value_for(:publish_datetime).should == date_string
-    end
-
-    context "with plugin parser" do
-      with_config(:use_plugin_parser, true)
-
-      it 'should parse a string value' do
-        Timeliness::Parser.should_receive(:parse)
-        r = Article.new
-        r.publish_date = '2010-01-01'
-      end
-
-      it 'should parse an invalid value as nil' do
-        Timeliness::Parser.should_receive(:parse)
-        r = Article.new
-        r.publish_date = 'bad value'
-
-        r.publish_date.should be_nil
-      end
-
-      context "for a date column" do
-        it 'should store a Date value after parsing string' do
-          r = Article.new
-          r.publish_date = '2010-01-01'
-
-          r.publish_date.should be_kind_of(Date)
-          r.publish_date.should == Date.new(2010, 1, 1)
-        end
-      end
-
-      context "for a datetime column" do
-        it 'should parse string into DateTime value' do
-          r = Article.new
-          r.publish_datetime = '2010-01-01 12:00'
-
-          r.publish_datetime.should be_kind_of(DateTime)
-          r.publish_datetime.should == DateTime.new(2010,1,1,12,0)
-        end
-      end
-    end
-  end
-
-  context "cached value" do
-    it 'should be cleared on reload' do
-      r = Article.create!
-      r.publish_date = '2010-01-01'
-      r.reload
-      r._timeliness_raw_value_for(:publish_date).should be_nil
-    end
-  end
-
-  context "before_type_cast method" do
-    it 'should not be defined if ORM does not support it' do
-      Article.new.should_not respond_to(:publish_datetime_before_type_cast)
-    end
-  end
-end
-
-rescue LoadError
-  puts "Mongoid specs skipped. Mongoid not installed"
-rescue StandardError => e
-  puts "Mongoid specs skipped. MongoDB connection failed with error: #{e.message}"
-end
--- a/spec/validates_timeliness/validator/after_spec.rb
+++ b/spec/validates_timeliness/validator/after_spec.rb
@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe ValidatesTimeliness::Validator, ":after option" do
+RSpec.describe ValidatesTimeliness::Validator, ":after option" do
  describe "for date type" do
    before do
      Person.validates_date :birth_date, :after => Date.new(2010, 1, 1)
@@ -25,15 +23,15 @@ describe ValidatesTimeliness::Validator, ":after option" do
    end

    it "should not be valid for same time as restriction" do
-      invalid!(:birth_time, Time.local_time(2000, 1, 1, 12, 0, 0), 'must be after 12:00:00')
+      invalid!(:birth_time, Time.local(2000, 1, 1, 12, 0, 0), 'must be after 12:00:00')
    end

    it "should not be valid for time before restriction" do
-      invalid!(:birth_time, Time.local_time(2000, 1, 1, 11, 59, 59), 'must be after 12:00:00')
+      invalid!(:birth_time, Time.local(2000, 1, 1, 11, 59, 59), 'must be after 12:00:00')
    end

    it "should be valid for time after restriction" do
-      valid!(:birth_time, Time.local_time(2000, 1, 1, 12, 00, 01))
+      valid!(:birth_time, Time.local(2000, 1, 1, 12, 00, 01))
    end
  end

--- a/spec/validates_timeliness/validator/before_spec.rb
+++ b/spec/validates_timeliness/validator/before_spec.rb
@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe ValidatesTimeliness::Validator, ":before option" do
+RSpec.describe ValidatesTimeliness::Validator, ":before option" do
  describe "for date type" do
    before do
      Person.validates_date :birth_date, :before => Date.new(2010, 1, 1)
@@ -25,15 +23,15 @@ describe ValidatesTimeliness::Validator, ":before option" do
    end

    it "should not be valid for time after restriction" do
-      invalid!(:birth_time, Time.local_time(2000, 1, 1, 12, 00, 01), 'must be before 12:00:00')
+      invalid!(:birth_time, Time.local(2000, 1, 1, 12, 00, 01), 'must be before 12:00:00')
    end

    it "should not be valid for same time as restriction" do
-      invalid!(:birth_time, Time.local_time(2000, 1, 1, 12, 0, 0), 'must be before 12:00:00')
+      invalid!(:birth_time, Time.local(2000, 1, 1, 12, 0, 0), 'must be before 12:00:00')
    end

    it "should be valid for time before restriction" do
-      valid!(:birth_time, Time.local_time(2000, 1, 1, 11, 59, 59))
+      valid!(:birth_time, Time.local(2000, 1, 1, 11, 59, 59))
    end
  end

--- a/spec/validates_timeliness/validator/is_at_spec.rb
+++ b/spec/validates_timeliness/validator/is_at_spec.rb
@@ -1,8 +1,6 @@
-require 'spec_helper'
-
-describe ValidatesTimeliness::Validator, ":is_at option" do
+RSpec.describe ValidatesTimeliness::Validator, ":is_at option" do
  before do
-    Timecop.freeze(Time.local_time(2010, 1, 1, 0, 0, 0))
+    Timecop.freeze(Time.local(2010, 1, 1, 0, 0, 0))
  end

  describe "for date type" do
@@ -29,15 +27,15 @@ describe ValidatesTimeliness::Validator, ":is_at option" do
    end

    it "should not be valid for time before restriction" do
-      invalid!(:birth_time, Time.local_time(2000, 1, 1, 11, 59, 59), 'must be at 12:00:00')
+      invalid!(:birth_time, Time.local(2000, 1, 1, 11, 59, 59), 'must be at 12:00:00')
    end

    it "should not be valid for time after restriction" do
-      invalid!(:birth_time, Time.local_time(2000, 1, 1, 12, 00, 01), 'must be at 12:00:00')
+      invalid!(:birth_time, Time.local(2000, 1, 1, 12, 00, 01), 'must be at 12:00:00')
    end

    it "should be valid for same time as restriction" do
-      valid!(:birth_time, Time.local_time(2000, 1, 1, 12, 0, 0))
+      valid!(:birth_time, Time.local(2000, 1, 1, 12, 0, 0))
    end
  end

--- a/spec/validates_timeliness/validator/on_or_after_spec.rb
+++ b/spec/validates_timeliness/validator/on_or_after_spec.rb
@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe ValidatesTimeliness::Validator, ":on_or_after option" do
+RSpec.describe ValidatesTimeliness::Validator, ":on_or_after option" do
  describe "for date type" do
    before do
      Person.validates_date :birth_date, :on_or_after => Date.new(2010, 1, 1)
@@ -25,15 +23,15 @@ describe ValidatesTimeliness::Validator, ":on_or_after option" do
    end

    it "should not be valid for time before restriction" do
-      invalid!(:birth_time, Time.local_time(2000, 1, 1, 11, 59, 59), 'must be on or after 12:00:00')
+      invalid!(:birth_time, Time.local(2000, 1, 1, 11, 59, 59), 'must be on or after 12:00:00')
    end

    it "should be valid for time after restriction" do
-      valid!(:birth_time, Time.local_time(2000, 1, 1, 12, 00, 01))
+      valid!(:birth_time, Time.local(2000, 1, 1, 12, 00, 01))
    end

    it "should be valid for same time as restriction" do
-      valid!(:birth_time, Time.local_time(2000, 1, 1, 12, 0, 0))
+      valid!(:birth_time, Time.local(2000, 1, 1, 12, 0, 0))
    end
  end

--- a/spec/validates_timeliness/validator/on_or_before_spec.rb
+++ b/spec/validates_timeliness/validator/on_or_before_spec.rb
@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe ValidatesTimeliness::Validator, ":on_or_before option" do
+RSpec.describe ValidatesTimeliness::Validator, ":on_or_before option" do
  describe "for date type" do
    before do
      Person.validates_date :birth_date, :on_or_before => Date.new(2010, 1, 1)
@@ -25,15 +23,15 @@ describe ValidatesTimeliness::Validator, ":on_or_before option" do
    end

    it "should not be valid for time after restriction" do
-      invalid!(:birth_time, Time.local_time(2000, 1, 1, 12, 00, 01), 'must be on or before 12:00:00')
+      invalid!(:birth_time, Time.local(2000, 1, 1, 12, 00, 01), 'must be on or before 12:00:00')
    end

    it "should be valid for time before restriction" do
-      valid!(:birth_time, Time.local_time(2000, 1, 1, 11, 59, 59))
+      valid!(:birth_time, Time.local(2000, 1, 1, 11, 59, 59))
    end

    it "should be valid for same time as restriction" do
-      valid!(:birth_time, Time.local_time(2000, 1, 1, 12, 0, 0))
+      valid!(:birth_time, Time.local(2000, 1, 1, 12, 0, 0))
    end
  end

--- a/spec/validates_timeliness/validator_spec.rb
+++ b/spec/validates_timeliness/validator_spec.rb
@@ -1,23 +1,27 @@
-require 'spec_helper'
-
-describe ValidatesTimeliness::Validator do
-  NIL = [nil]
-
+RSpec.describe ValidatesTimeliness::Validator do
  before do
-    Timecop.freeze(Time.local_time(2010, 1, 1, 0, 0, 0))
+    Timecop.freeze(Time.local(2010, 1, 1, 0, 0, 0))
  end

  describe "Model.validates with :timeliness option" do
    it 'should use plugin validator class' do
      Person.validates :birth_date, :timeliness => {:is_at => Date.new(2010,1,1), :type => :date}
-      Person.validators.should have(1).kind_of(ActiveModel::Validations::TimelinessValidator)
+      expect(Person.validators.select { |v| v.is_a?(ActiveModel::Validations::TimelinessValidator) }.size).to eq(1)
      invalid!(:birth_date, Date.new(2010,1,2))
      valid!(:birth_date, Date.new(2010,1,1))
    end

    it 'should use default to :datetime type' do
      Person.validates :birth_datetime, :timeliness => {:is_at => Time.mktime(2010,1,1)}
-      Person.validators.first.type.should == :datetime
+      expect(Person.validators.first.type).to eq(:datetime)
+    end
+
+    it 'should add attribute to timeliness attributes set' do
+      expect(PersonWithShim.timeliness_validated_attributes).not_to include(:birth_time)
+
+      PersonWithShim.validates :birth_time, :timeliness => {:is_at => "12:30"}
+
+      expect(PersonWithShim.timeliness_validated_attributes).to include(:birth_time)
    end
  end

@@ -29,22 +33,22 @@ describe ValidatesTimeliness::Validator do
  it 'should not be valid attribute is type cast to nil but raw value is non-nil invalid value' do
    Person.validates_date :birth_date, :allow_nil => true
    record = Person.new
-    record.stub!(:birth_date).and_return(nil)
-    record.stub!(:_timeliness_raw_value_for).and_return("Not a date")
-    record.should_not be_valid
-    record.errors[:birth_date].first.should == 'is not a valid date'
+    allow(record).to receive(:birth_date).and_return(nil)
+    allow(record).to receive(:read_timeliness_attribute_before_type_cast).and_return("Not a date")
+    expect(record).not_to be_valid
+    expect(record.errors[:birth_date].first).to eq('is not a valid date')
  end

  describe ":allow_nil option" do
    it 'should not allow nil by default' do
      Person.validates_date :birth_date
-      invalid!(:birth_date, NIL, 'is not a valid date')
+      invalid!(:birth_date, [nil], 'is not a valid date')
      valid!(:birth_date, Date.today)
    end

    it 'should allow nil when true' do
      Person.validates_date :birth_date, :allow_nil => true
-      valid!(:birth_date, NIL)
+      valid!(:birth_date, [nil])
    end

    context "with raw value cache" do
@@ -54,7 +58,7 @@ describe ValidatesTimeliness::Validator do
        p = PersonWithShim.new
        p.birth_date = 'bogus'

-        p.should_not be_valid
+        expect(p).not_to be_valid
      end
    end
  end
@@ -78,18 +82,32 @@ describe ValidatesTimeliness::Validator do
        p = PersonWithShim.new
        p.birth_date = 'bogus'

-        p.should_not be_valid
+        expect(p).not_to be_valid
      end
    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
        on_or_after, on_or_before = Date.new(2010,1,1), Date.new(2010,1,2)
        Person.validates_date :birth_date, :between => [on_or_after, on_or_before]
-        Person.validators.first.options[:on_or_after].should == on_or_after
-        Person.validators.first.options[:on_or_before].should == on_or_before
+        expect(Person.validators.first.options[:on_or_after]).to eq(on_or_after)
+        expect(Person.validators.first.options[:on_or_before]).to eq(on_or_before)
        invalid!(:birth_date, on_or_after - 1, "must be on or after 2010-01-01")
        invalid!(:birth_date, on_or_before + 1, "must be on or before 2010-01-02")
        valid!(:birth_date, on_or_after)
@@ -101,14 +119,27 @@ describe ValidatesTimeliness::Validator do
      it 'should be split option into :on_or_after and :on_or_before values' do
        on_or_after, on_or_before = Date.new(2010,1,1), Date.new(2010,1,2)
        Person.validates_date :birth_date, :between => on_or_after..on_or_before
-        Person.validators.first.options[:on_or_after].should == on_or_after
-        Person.validators.first.options[:on_or_before].should == on_or_before
+        expect(Person.validators.first.options[:on_or_after]).to eq(on_or_after)
+        expect(Person.validators.first.options[:on_or_before]).to eq(on_or_before)
        invalid!(:birth_date, on_or_after - 1, "must be on or after 2010-01-01")
        invalid!(:birth_date, on_or_before + 1, "must be on or before 2010-01-02")
        valid!(:birth_date, on_or_after)
        valid!(:birth_date, on_or_before)
      end
    end
+
+    describe "range with excluded end value" do
+      it 'should be split option into :on_or_after and :before values' do
+        on_or_after, before = Date.new(2010,1,1), Date.new(2010,1,3)
+        Person.validates_date :birth_date, :between => on_or_after...before
+        expect(Person.validators.first.options[:on_or_after]).to eq(on_or_after)
+        expect(Person.validators.first.options[:before]).to eq(before)
+        invalid!(:birth_date, on_or_after - 1, "must be on or after 2010-01-01")
+        invalid!(:birth_date, before, "must be before 2010-01-03")
+        valid!(:birth_date, on_or_after)
+        valid!(:birth_date, before - 1)
+      end
+    end
  end

  describe ":ignore_usec option" do
@@ -140,13 +171,13 @@ describe ValidatesTimeliness::Validator do
    it "should be valid when value matches format" do
      person.birth_date = '11-12-1913'
      person.valid?
-      person.errors[:birth_date].should be_empty
+      expect(person.errors[:birth_date]).to be_empty
    end

    it "should not be valid when value does not match format" do
      person.birth_date = '1913-12-11'
      person.valid?
-      person.errors[:birth_date].should include('is not a valid date')
+      expect(person.errors[:birth_date]).to include('is not a valid date')
    end
  end

@@ -160,21 +191,21 @@ describe ValidatesTimeliness::Validator do
    it "should be added when ignore_restriction_errors is false" do
      with_config(:ignore_restriction_errors, false) do
        person.valid?
-        person.errors[:birth_date].first.should match("Error occurred validating birth_date")
+        expect(person.errors[:birth_date].first).to match("Error occurred validating birth_date")
      end
    end

    it "should not be added when ignore_restriction_errors is true" do
      with_config(:ignore_restriction_errors, true) do
        person.valid?
-        person.errors[:birth_date].should be_empty
+        expect(person.errors[:birth_date]).to be_empty
      end
    end

    it 'should exit on first error' do
      with_config(:ignore_restriction_errors, false) do
        person.valid?
-        person.errors[:birth_date].should have(1).items
+        expect(person.errors[:birth_date].size).to eq(1)
      end
    end
  end
@@ -183,17 +214,17 @@ describe ValidatesTimeliness::Validator do
    describe "default" do
      it 'should format date error value as yyyy-mm-dd' do
        validator = ValidatesTimeliness::Validator.new(:attributes => [:birth_date], :type => :date)
-        validator.format_error_value(Date.new(2010,1,1)).should == '2010-01-01'
+        expect(validator.format_error_value(Date.new(2010,1,1))).to eq('2010-01-01')
      end

      it 'should format time error value as hh:nn:ss' do
        validator = ValidatesTimeliness::Validator.new(:attributes => [:birth_time], :type => :time)
-        validator.format_error_value(Time.mktime(2010,1,1,12,34,56)).should == '12:34:56'
+        expect(validator.format_error_value(Time.mktime(2010,1,1,12,34,56))).to eq('12:34:56')
      end

      it 'should format datetime error value as yyyy-mm-dd hh:nn:ss' do
        validator = ValidatesTimeliness::Validator.new(:attributes => [:birth_datetime], :type => :datetime)
-        validator.format_error_value(Time.mktime(2010,1,1,12,34,56)).should == '2010-01-01 12:34:56'
+        expect(validator.format_error_value(Time.mktime(2010,1,1,12,34,56))).to eq('2010-01-01 12:34:56')
      end
    end

@@ -204,7 +235,7 @@ describe ValidatesTimeliness::Validator do

      it 'should use the default format for the type' do
        validator = ValidatesTimeliness::Validator.new(:attributes => [:birth_date], :type => :date)
-        validator.format_error_value(Date.new(2010,1,1)).should == '2010-01-01'
+        expect(validator.format_error_value(Date.new(2010,1,1))).to eq('2010-01-01')
      end

      after :all do
@@ -218,7 +249,7 @@ describe ValidatesTimeliness::Validator do
      Person.validates_date :birth_date, :invalid_date_message => 'custom invalid message'
      invalid!(:birth_date, 'asdf', 'custom invalid message')
    end
-  
+
    it 'should be used for invalid restriction' do
      Person.validates_date :birth_date, :before => Time.now, :before_message => 'custom before message'
      invalid!(:birth_date, Time.now, 'custom before message')
--- a/spec/validates_timeliness_spec.rb
+++ b/spec/validates_timeliness_spec.rb
@@ -1,41 +1,39 @@
-require 'spec_helper'
-
-describe ValidatesTimeliness do
+RSpec.describe ValidatesTimeliness do

  it 'should alias use_euro_formats to remove_us_formats on Timeliness gem' do
-    Timeliness.should respond_to(:remove_us_formats) 
+    expect(Timeliness).to respond_to(:remove_us_formats) 
  end

  it 'should alias to date_for_time_type to dummy_date_for_time_type on Timeliness gem' do
-    Timeliness.should respond_to(:dummy_date_for_time_type) 
+    expect(Timeliness).to respond_to(:dummy_date_for_time_type) 
  end

  describe "config" do
    it 'should delegate default_timezone to Timeliness gem' do
-      Timeliness.should_receive(:default_timezone=)
+      expect(Timeliness).to receive(:default_timezone=)
      ValidatesTimeliness.default_timezone = :utc
    end

    it 'should delegate dummy_date_for_time_type to Timeliness gem' do
-      Timeliness.should_receive(:dummy_date_for_time_type) 
-      Timeliness.should_receive(:dummy_date_for_time_type=) 
+      expect(Timeliness).to receive(:dummy_date_for_time_type) 
+      expect(Timeliness).to receive(:dummy_date_for_time_type=) 
      array = ValidatesTimeliness.dummy_date_for_time_type
      ValidatesTimeliness.dummy_date_for_time_type = array
    end

    context "parser" do
      it 'should delegate add_formats to Timeliness gem' do
-        Timeliness.should_receive(:add_formats)
+        expect(Timeliness).to receive(:add_formats)
        ValidatesTimeliness.parser.add_formats
      end

      it 'should delegate remove_formats to Timeliness gem' do
-        Timeliness.should_receive(:remove_formats)
+        expect(Timeliness).to receive(:remove_formats)
        ValidatesTimeliness.parser.remove_formats
      end

      it 'should delegate remove_us_formats to Timeliness gem' do
-        Timeliness.should_receive(:remove_us_formats)
+        expect(Timeliness).to receive(:remove_us_formats)
        ValidatesTimeliness.parser.remove_us_formats
      end
    end
--- a/validates_timeliness.gemspec
+++ b/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 }
+  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.add_runtime_dependency(%q<timeliness>, ["~> 0.3.4"])
+  s.add_runtime_dependency(%q<timeliness>, [">= 0.3.10", "< 1"])
 end
Author	SHA1	Message	Date
Adam Meehan	93b8b1a70b	v4.1.0	2019-06-11 20:51:42 +10:00
Adam Meehan	e531c8f8ef	update changelog	2019-06-11 20:51:34 +10:00
Adam Meehan	658deca1c8	use travis matrix for ruby + rails versions	2019-06-11 20:24:14 +10:00
Adam Meehan	a6d617e77d	limit all gemfiles sqlite version	2019-06-11 19:37:18 +10:00
Adam Meehan	101bb5d5f7	limit sqlite3 version	2019-06-11 19:28:02 +10:00
Adam Meehan	5e6e5222dc	https on rubygems	2019-06-11 19:25:47 +10:00
Adam Meehan	c81ec5d604	sqlite3 gem issue	2019-06-11 19:13:00 +10:00
Adam Meehan	f3f3d01db7	fix sqlite gem issue	2019-06-11 17:57:38 +10:00
Adam Meehan	acd9fc13e4	add bundle command to travis	2019-06-11 17:24:32 +10:00
Adam Meehan	5743d87bc7	wrangle bundler versions in travis	2019-06-11 17:17:14 +10:00
Adam Meehan	e0790bca9b	bump appraisal rails to 4.2.11	2019-06-11 14:51:12 +10:00
Adam Meehan	39f698feb2	bump travis to ruby 2.5.5	2019-06-11 14:50:51 +10:00
Adam Meehan	bd39aef4fb	Revert "drop rails 4.0 and 4.1 both EOLed" This reverts commit `a05f091a42`.	2019-06-11 14:50:05 +10:00
Adam Meehan	a3431bc91a	relax timeliness dependency	2019-06-11 14:42:11 +10:00
Adam Meehan	fda194584a	bump timeliness version	2019-02-03 11:57:36 +11:00
Adam Meehan	a05f091a42	drop rails 4.0 and 4.1 both EOLed	2018-05-13 21:30:20 +10:00
Adam Meehan	faf708e3be	force nokigiri version up	2018-05-13 21:25:31 +10:00
Adam Meehan	38bb74844d	need travis bundler fix	2018-05-13 21:15:11 +10:00
Adam Meehan	e275b63203	Merge branch 'master' of github.com:adzap/validates_timeliness	2018-05-13 21:01:36 +10:00
Adam Meehan	e73e0eb30f	change travis command to rspec bin	2018-05-13 21:01:12 +10:00
Adam Meehan	43554d8bf0	Merge pull request #152 from aditya-kapoor/allow-generic-msg Allow the validator to take in the `message` option too.	2018-05-13 20:50:08 +10:00
Adam Meehan	da473b7eea	Update validator.rb tweak message key lookup	2018-05-13 20:49:25 +10:00
Adam Meehan	fc2af73656	update travis rubies and appraisal rails	2018-05-13 20:46:53 +10:00
Adam Meehan	936c853fdd	Merge branch 'master' of github.com:adzap/validates_timeliness	2018-05-13 20:39:32 +10:00
Adam Meehan	f27324a404	relax gemfile gem version	2018-05-13 20:38:23 +10:00
Adam Meehan	4221bf7709	Merge pull request #161 from pedrofurtado/patch-1 Update README.rdoc with the suggestion of a gem with i18n translations	2018-05-13 11:54:55 +10:00
Pedro Felipe de Azevedo Furtado	b51a4544ff	Update README.rdoc	2018-05-10 13:12:52 -03:00
pedrofurtado	285bc769ba	Update README.rdoc	2017-12-29 13:45:39 -02:00
Adam Meehan	a0f2759c7a	Merge pull request #160 from reiz/patch-1 Add license info to the gemspec.	2017-10-03 09:42:27 +11:00
Robert Reiz	cc57b1b758	Add license info to the gemspec.	2017-10-02 16:16:36 +02:00
Adam Meehan	d30cebfc7b	Update gemfiles	2017-05-14 20:43:39 +10:00
Adam Meehan	a96c24268d	Update travis ruby versions	2017-05-14 20:33:33 +10:00
Adam Meehan	13fcc32a83	Test model had wrong validation method	2017-05-14 20:12:36 +10:00
Adam Meehan	e8a96fe9b5	Set ruby version in gemfile	2017-05-14 20:12:14 +10:00
Adam Meehan	f9009995fc	Update rspec and rails versions	2017-05-14 19:44:13 +10:00
Adam Meehan	5419a1cc42	Merge branch 'master' of github.com:adzap/validates_timeliness	2017-05-14 19:43:14 +10:00
Adam Meehan	9dd2e87087	Merge pull request #154 from yxf/master Fixed version checking of ActiveModel	2017-05-14 19:35:49 +10:00
yxf	8a04deebfa	Fixed version checking of ActiveModel	2017-05-14 17:07:24 +08:00
Aditya Kapoor	e9c9914c4f	Allow the validator to take in the `message` option too. This is useful in those scenarios where we have a set of generic keys which we need to show. This would eliminate the need to keeping multiple copies for the default keys set defined by gem. The following seems more apt than the later one: ``` validates_date :start_at, on_or_after: :today, message: 'should not be in past' ``` ``` validates_date :start_at, on_or_after: :today, on_or_after_message: 'should not be in past' ```	2017-03-22 13:21:59 +05:30
Adam Meehan	0219c3850d	minimum timeliness 0.3.8	2017-03-07 20:33:46 +11:00
Adam Meehan	35caf3638e	Fix undefine_attribute_methods spec	2016-01-07 20:50:17 +11:00
Adam Meehan	153051730b	Add latest changes	2016-01-07 08:29:49 +11:00
Adam Meehan	5c1406e9b0	v4.0.2	2016-01-07 08:26:19 +11:00
Adam Meehan	32f92cc885	Set @timeliness_methods_generated = false on undefined	2016-01-07 08:25:09 +11:00
Adam Meehan	cb3ac8d445	v4.0.1	2016-01-06 22:20:44 +11:00
Adam Meehan	4e5f5fa695	Return value if not of known type in type cast	2016-01-06 22:20:24 +11:00
Adam Meehan	321834b5ff	Fix thread lock on undefine Move active model methods into active model ORM module to be included manually if not using AR or other ORM	2016-01-06 22:18:54 +11:00
Adam Meehan	ff131415f7	Fix shadowing	2016-01-06 16:36:25 +11:00
Adam Meehan	ad43eb31d6	Return date if date type	2016-01-06 16:35:01 +11:00
Adam Meehan	0f782a4ed5	Latest rails gems in appraisals	2015-12-30 12:07:06 +11:00
Adam Meehan	d57c64dcc2	Getting with the RSpec times	2015-12-30 12:06:42 +11:00
Adam Meehan	244f398cc4	travis gem install failure on 2.2.0 trying 2.2.3	2015-12-29 18:02:18 +11:00
Adam Meehan	0feeb746cd	Fix zone in test	2015-12-29 17:57:54 +11:00
Adam Meehan	6f23e40c25	Remove ruby 2.0 from travis	2015-12-29 17:51:54 +11:00
Adam Meehan	773e816a4d	Use latest rspec	2015-12-29 17:51:42 +11:00
Adam Meehan	80c9df448d	v3.x changelog	2015-12-29 16:30:46 +11:00
Adam Meehan	54ae49b8a0	Update changelog	2015-12-29 16:27:59 +11:00
Adam Meehan	b20b25940e	Update readme to reflect v4.x only	2015-12-29 16:16:08 +11:00
Adam Meehan	51bc0d7d05	Wrong gemfile names in travis	2015-12-29 16:12:37 +11:00
Adam Meehan	c7d87e3fe6	byebug ignore history	2015-12-29 16:11:23 +11:00
Adam Meehan	4dcebde1bc	Not using autotest anymore	2015-12-29 16:11:13 +11:00
Adam Meehan	1a869bfb1f	Was a random change by my back to rvm	2015-12-29 16:05:35 +11:00
Adam Meehan	22ab7f4455	v4.0.0	2015-12-29 16:01:57 +11:00
Adam Meehan	57379fd78a	Just rake in travis i guess	2015-12-29 16:01:30 +11:00
Adam Meehan	2424acc075	Generate default config with AR orm enabled	2015-12-29 15:58:42 +11:00
Adam Meehan	d883758046	Trying travis setup	2015-12-29 15:56:59 +11:00
Adam Meehan	2bcb3ae4dd	update appraisal gemfiles	2015-12-29 15:55:16 +11:00
Adam Meehan	0444bdc650	Datetime select extension fixes with help from @johncarney's fork	2015-12-29 15:49:18 +11:00
Adam Meehan	feb508f171	Validator 4.x compat	2015-12-29 14:57:56 +11:00
Adam Meehan	24f2752c2e	Multiparam extension 4.x changes	2015-12-29 14:57:38 +11:00
Adam Meehan	afa8dee6ab	Rails 4.x attribute assignment compatability	2015-12-29 14:56:58 +11:00
Adam Meehan	08b16f155c	Rspec 3 syntax	2015-12-29 14:55:03 +11:00
Adam Meehan	1ddf0f1b0f	Remove all mongoid stuff and put in validates_timeliness-mongoid	2015-12-28 14:24:24 +11:00
Adam Meehan	6560a09ad2	Change Time.local_time to Time.local	2015-12-28 13:47:11 +11:00
Adam Meehan	2fef0a23d6	v3.0.15	2015-11-10 18:50:02 +11:00
Adam Meehan	d0f2158ae5	Update Gemfile	2015-11-10 18:49:03 +11:00
Adam Meehan	bb830baea2	Rails 4.0 and 4.1 compat for #setup method removal	2015-11-10 17:52:34 +11:00
Adam Meehan	4d48c3578b	Merge pull request #128 from monkbroc/patch-1 Generate attribute methods once instead of on each object creation	2015-09-25 09:13:02 +10:00
Julien Vanier	7d37882327	Generate attribute methods once instead of on each object creation This is a memory and performance improvement change. The attribute methods for timeliness are generated at each object creation instead of once, at first creation like AR attribute methods. Since creating those methods uses `module_eval` it's quite slow when it's done each `Model.new`. For more details on the performance improvement, see the same change on John Carney's fork: https://github.com/johncarney/validates_timeliness/pull/6	2015-09-24 14:58:12 -04:00
Adam Meehan	12f6d2a467	Merge pull request #104 from johnnyshields/mongoid-3 Update to Mongoid 3	2015-09-12 17:23:20 +10:00
Adam Meehan	913bd4ccfa	Merge pull request #123 from obfuscoder/master Fix typo in comment of initializer template	2015-09-12 09:51:44 +10:00
Obfuscoder	f1b8925a36	Fix typo in comment of initializer template	2014-11-02 20:59:50 +01:00
Adam Meehan	f983dcc9dc	Merge pull request #109 from RudyOnRails/patch-1 typo	2013-11-07 09:45:10 -08:00
Kevin Musiorski	7be1539cee	typo	2013-11-06 13:59:17 -06:00
Johnny Shields	99ae8fe7d7	Update for Mongoid 3: - Now requires Mongoid 3.0 as minimum version (this is the only version to support Rails 3.2) - Upgrade specs/helpers for Mongoid 3 - Support Mongoid aliased field names (e.g. field :foo, as: bar, type: String). Includes spec - Support before_type_cast on Mongoid. No code change was required for this, only a spec change. - There was one mongoid spec that was previously marked pending. I've found that it now works on Mongoid 3. - Removed some Mongoid 2.3 and earlier hacks, which simplifies the Mongoid ORM code.	2013-07-24 11:05:01 +09:00
Adam Meehan	00ce472d3e	Merge pull request #99 from softace/fixing_build Fix for running tests in non-Australian timezones	2013-06-16 15:22:33 -07:00
Jarl Friis	0d2c7ce554	Fix for running tests in non-Australian timezones	2013-04-30 19:56:19 +02:00
Adam Meehan	3d798697e1	Merge pull request #98 from 907th/master Range with excluded end passed to :between option should be split into :on_or_after and :before options	2013-04-30 04:45:54 -07:00
Alexey Chernenkov	dc0fdc0340	Range with excluded end passed to :between option should be split into :on_or_after and :before options	2013-04-30 15:37:44 +06:00
Adam Meehan	dd3b6b5514	Merge pull request #95 from will-ob/fix/require-active-model Require 'active_model'	2013-04-25 22:01:51 -07:00
Will O'Brien	609fafe7bb	Require 'active_model' Apparently classes are lazily required when using autoload. Prompted by 'uninitialized constant ActiveModel::Validations'	2013-04-25 22:42:28 -04:00
Adam Meehan	df9677f5bf	timeliness minimum dep 0.3.7	2012-10-15 20:37:05 +11:00
Adam Meehan	b463b4356a	Update rdoc require	2012-10-15 08:46:11 +11:00
Adam Meehan	7dd579b0e0	Get rid of this silly constant for nil array value	2012-10-15 08:45:57 +11:00
Adam Meehan	5becd7886b	Removing silly class variables from config module	2012-09-14 18:44:35 +10:00
Adam Meehan	2225c747e1	DRYing up some specs	2012-08-26 16:38:00 +10:00
Adam Meehan	a1dfbf5d7d	v3.0.14	2012-08-23 18:40:47 +10:00
Adam Meehan	02fbdc6028	Fix for validates :timeliness form to add attributes to plugin set	2012-08-23 18:38:33 +10:00
Adam Meehan	4fe22458d3	Add mongoid appraisals	2012-08-23 18:37:38 +10:00
Adam Meehan	8c698be4c4	v3.0.13	2012-08-21 10:56:46 +10:00
Adam Meehan	091e7ecfa0	Tweak AR specs	2012-08-21 10:53:54 +10:00
Adam Meehan	8168bcbd3a	Ignore more lock files	2012-08-19 22:59:40 +10:00
Adam Meehan	973bbfa82c	Moving back to plugin cache for ActiveRecord This simplifies the code a lot and fixes the issues with date and time colummns when using the plugin parser. Add appraisals for all rails 3 versions	2012-08-19 22:57:19 +10:00
Adam Meehan	62557e7e04	Allow any validated attribute to pass timezone aware check in AR	2012-08-09 12:53:29 +10:00
Adam Meehan	fd73c4eccd	README touch ups	2012-08-09 11:55:53 +10:00
Adam Meehan	7bcdea1738	RSpec config cleanup	2012-07-13 21:43:29 +10:00
Adam Meehan	8898b8686c	v3.0.12	2012-06-23 19:06:38 +10:00
Adam Meehan	aad2db8662	Remove unused cargo culted generator method	2012-06-23 18:58:33 +10:00
Adam Meehan	8e08cbf6e4	Fix load order issue for AR extension using Railite	2012-06-23 18:58:01 +10:00
Adam Meehan	8dd607975b	v3.0.11	2012-04-01 16:48:53 +10:00
Adam Meehan	b6acda539f	v3.0.10	2012-03-29 13:45:40 +11:00
Adam Meehan	4aa20bb002	Stricter method signature for _timeliness_raw_value_for to take string Add basic validation specs to each ORM shim	2012-03-29 13:00:28 +11:00