Merge pull request #190 from AleBL/patch-1

Update README.rdoc

.gitignore

@@ -2,3 +2,5 @@ pkg/
 .bundle/
 .rvmrc
 Gemfile.lock
+gemfiles/*.lock
+.byebug_history

.rspec

@@ -1,2 +1,4 @@
---format nested
+--format documentation
 --color
+--require spec_helper
+--require byebug

.travis.yml

@@ -0,0 +1,20 @@
+language: ruby
+before_install: gem install bundler
+cache: bundler
+
+gemfile:
+  - gemfiles/rails_5_0.gemfile
+  - gemfiles/rails_5_1.gemfile
+  - gemfiles/rails_5_2.gemfile
+
+rvm:
+  - "2.5.3"
+
+script: 'bundle exec rspec'
+
+notifications:
+  email:
+    recipients:
+      - adam.meehan@gmail.com
+    on_failure: change
+    on_success: never

Appraisals

@@ -0,0 +1,11 @@
+appraise "rails_5_0" do
+  gem "rails", "~> 5.0.0"
+end
+
+appraise "rails_5_1" do
+  gem "rails", "~> 5.1.0"
+end
+
+appraise "rails_5_2" do
+  gem "rails", "~> 5.2.0"
+end

CHANGELOG.rdoc

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

Gemfile

@@ -2,20 +2,11 @@ source 'http://rubygems.org'
 
 gemspec
 
-gem 'rails', '~> 3.2.1'
+gem 'rails', '~> 5.2.4'
-gem 'rspec', '~> 2.8'
+gem 'rspec'
-gem 'rspec-rails', '~> 2.8'
+gem 'rspec-rails', '~> 3.7'
 gem 'timecop'
-gem 'rspec_tag_matchers'
+gem 'byebug'
-gem 'ruby-debug', :platforms => [:ruby_18, :jruby]
+gem 'appraisal'
-gem 'ruby-debug19', :platforms => [:ruby_19]
+gem 'sqlite3', '~> 1.3.6'
-
+gem 'nokogiri', '~> 1.8'
-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

README.rdoc

@@ -1,13 +1,13 @@
-= ValidatesTimeliness
+= ValidatesTimeliness {<img src="https://travis-ci.org/adzap/validates_timeliness.svg?branch=master" alt="Build Status" />}[https://travis-ci.org/adzap/validates_timeliness]
 
 * 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 5.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 4.x go here [https://github.com/adzap/validates_timeliness/tree/4-0-stable].
 
 
 == 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', '~> 5.0.0.beta1'
 
   # 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.
@@ -54,18 +49,21 @@ 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 },
+  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_datetime :finish_time, after: :start_time # Method symbol
 
-  validates_date :booked_at, :on => :create, :on_or_after => :today # See Restriction Shorthand.
+  validates_date :booked_at, on: :create, on_or_after: :today # See Restriction Shorthand.
-  validates_time :booked_at, :between => ['9.00am', '5:00pm']
 
-  validates_time :breakfast_time, :on_or_after => '6:00am',
+  validates_time :booked_at, between: ['9:00am', '5:00pm'] # On or after 9:00AM and on or before 5:00PM
-                                  :on_or_after_message => 'must be after opening time',
+  validates_time :booked_at, between: '9:00am'..'5:00pm' # The same as previous example
-                                  :before => :lunchtime,
+  validates_time :booked_at, between: '9:00am'...'5:00pm' # On or after 9:00AM and strictly before 5:00PM
-                                  :before_message => 'must be before lunch time'
+
+  validates_time :breakfast_time, on_or_after: '6:00am',
+                                  on_or_after_message: 'must be after opening time',
+                                  before: :lunchtime,
+                                  before_message: 'must be before lunch time'
 
 
 == Usage
@@ -74,14 +72,14 @@ To validate a model with a date, time or datetime attribute you just use the
 validation method
 
   class Person < ActiveRecord::Base
-    validates_date :date_of_birth, :on_or_before => lambda { Date.current }
+    validates_date :date_of_birth, on_or_before: lambda { Date.current }
     # or
-    validates :date_of_birth, :timeliness => {:on_or_before => lambda { Date.current }, :type => :date}
+    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 }
+  @person.validates_date :date_of_birth, on_or_before: lambda { Date.current }
 
 
 The list of validation methods available are as follows:
@@ -139,8 +137,8 @@ like so
 
   ValidatesTimeliness.setup do |config|
 
-    # Extend ORM/ODMs for full support (:active_record, :mongoid).
+    # Extend ORM/ODMs for full support (:active_record).
-    config.extend_orms = [ :mongoid ]
+    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 
+Note: There is no :between_message option. The between error message should be defined using the :on_or_after and :on_or_before
-:on_or_before and :on_or_after messages.
+(: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.
 
@@ -208,14 +206,14 @@ plugin allows you to use shorthand symbols for often used relative times or date
 
 Just provide the symbol as the option value like so:
 
-  validates_date :birth_date, :on_or_before => :today
+  validates_date :birth_date, on_or_before: :today
 
 The :today symbol is evaluated as <tt>lambda { Date.today }</tt>. The :now and :today
 symbols are pre-configured. Configure your own like so:
 
   # in the setup block
   config.restriction_shorthand_symbols.update(
-    :yesterday => lambda { 1.day.ago }
+    yesterday: lambda { 1.day.ago }
   )
 
 
@@ -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

Rakefile

@@ -1,9 +1,11 @@
 require 'bundler'
+require 'bundler/setup'
+
+require 'appraisal'
+
 Bundler::GemHelper.install_tasks
 
-Bundler.setup
+require 'rdoc/task'
-
-require 'rake/rdoctask'
 require 'rspec/core/rake_task'
 
 desc "Run specs"

autotest/discover.rb

@@ -1 +0,0 @@
-Autotest.add_discovery { "rspec2" }

gemfiles/rails_5_0.gemfile

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

gemfiles/rails_5_1.gemfile

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

gemfiles/rails_5_2.gemfile

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

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'

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).
+  # Extend ORM/ODMs for full support (:active_record included).
-  # config.extend_orms = [ :active_record ]
+  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.

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).
+  # Extend ORM/ODMs for full support (:active_record).
-  mattr_accessor :extend_orms
+  self.extend_orms = []
-  @@extend_orms = []
 
   # Ignore errors when restriction options are evaluated
-  mattr_accessor :ignore_restriction_errors
+  self.ignore_restriction_errors = false
-  @@ignore_restriction_errors = false
 
   # Shorthand time and date symbols for restrictions
-  mattr_accessor :restriction_shorthand_symbols
+  self.restriction_shorthand_symbols = {
-  @@restriction_shorthand_symbols = {
+    now:   proc { Time.current },
-    :now   => lambda { Time.current },
+    today: proc { Date.current }
-    :today => lambda { Date.current }
   }
 
   # Use the plugin date/time parser which is stricter and extensible
-  mattr_accessor :use_plugin_parser
+  self.use_plugin_parser = false
-  @@use_plugin_parser = false
 
   # Default timezone
   self.default_timezone = :utc
@@ -51,18 +49,20 @@ 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'
+require 'validates_timeliness/converter'
 require 'validates_timeliness/validator'
 require 'validates_timeliness/helper_methods'
 require 'validates_timeliness/attribute_methods'

lib/validates_timeliness/attribute_methods.rb

@@ -6,87 +6,44 @@ module ValidatesTimeliness
       class_attribute :timeliness_validated_attributes
       self.timeliness_validated_attributes = []
     end
-
-    module ClassMethods
-
-      public
-      # Override in ORM shim
-      def timeliness_attribute_timezone_aware?(attr_name)
-        false
-      end
-
-      # Override in ORM shim
-      def timeliness_attribute_type(attr_name)
-        :datetime
-      end
-
-      def 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|
-          define_attribute_timeliness_methods(attr_name, before_type_cast)
-        end
-      end
-
-      def define_attribute_timeliness_methods(attr_name, before_type_cast=false)
-        define_timeliness_write_method(attr_name)
-        define_timeliness_before_type_cast_method(attr_name) if before_type_cast
-      end
-
-      def define_timeliness_write_method(attr_name)
-        method_body, line = <<-EOV, __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)
-          end
-        EOV
-        generated_timeliness_methods.module_eval(method_body, __FILE__, line)
-      end
-
-      def define_timeliness_before_type_cast_method(attr_name)
-        method_body, line = <<-EOV, __LINE__ + 1
-          def #{attr_name}_before_type_cast
-            _timeliness_raw_value_for('#{attr_name}') || @attributes['#{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
-      end
-    end
-
-    def _timeliness_raw_value_for(attr_name)
-      @timeliness_cache && @timeliness_cache[attr_name]
-    end
-
-    def _clear_timeliness_cache
-      @timeliness_cache = {}
-    end
   end
 end
+
+ActiveModel::Type::Date.prepend Module.new {
+  def cast_value(value)
+    return super unless ValidatesTimeliness.use_plugin_parser
+
+    if value.is_a?(::String)
+      return if value.empty?
+      value = Timeliness::Parser.parse(value, :date)
+      value.to_date if value
+    elsif value.respond_to?(:to_date)
+      value.to_date
+    else
+      value
+    end
+  end
+}
+
+ActiveModel::Type::Time.prepend Module.new {
+  def user_input_in_time_zone(value)
+    return super unless ValidatesTimeliness.use_plugin_parser
+
+    if value.is_a?(String)
+      dummy_time_value = value.sub(/\A(\d\d\d\d-\d\d-\d\d |)/, Date.current.to_s + ' ')
+      Timeliness::Parser.parse(dummy_time_value, :datetime, zone: :current)
+    else
+      value.in_time_zone
+    end
+  end
+}
+
+ActiveModel::Type::DateTime.prepend Module.new {
+  def user_input_in_time_zone(value)
+    if value.is_a?(String) && ValidatesTimeliness.use_plugin_parser
+      Timeliness::Parser.parse(value, :datetime, zone: :current)
+    else
+      value.in_time_zone
+    end
+  end
+}

lib/validates_timeliness/converter.rb

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

lib/validates_timeliness/extensions.rb

@@ -1,14 +1,13 @@
 module ValidatesTimeliness
   module Extensions
-    autoload :DateTimeSelect,        'validates_timeliness/extensions/date_time_select'
+    autoload :TimelinessDateTimeSelect, 'validates_timeliness/extensions/date_time_select'
-    autoload :MultiparameterHandler, 'validates_timeliness/extensions/multiparameter_handler'
   end
 
   def self.enable_date_time_select_extension!
-    ::ActionView::Helpers::InstanceTag.send(:include, ValidatesTimeliness::Extensions::DateTimeSelect)
+    ::ActionView::Helpers::Tags::DateSelect.send(:prepend, ValidatesTimeliness::Extensions::TimelinessDateTimeSelect)
   end
 
   def self.enable_multiparameter_extension!
-    ::ActiveRecord::Base.send(:include, ValidatesTimeliness::Extensions::MultiparameterHandler)
+    require 'validates_timeliness/extensions/multiparameter_handler'
   end
 end

lib/validates_timeliness/extensions/date_time_select.rb

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

lib/validates_timeliness/extensions/multiparameter_handler.rb

@@ -1,80 +1,55 @@
 module ValidatesTimeliness
   module Extensions
-    module MultiparameterHandler
+    class AcceptsMultiparameterTime < Module
-      extend ActiveSupport::Concern
 
-      # Stricter handling of date and time values from multiparameter 
+      def initialize(defaults: {})
-      # assignment from the date/time select view helpers
 
-      included do
+        define_method(:cast) do |value|
-        alias_method_chain :instantiate_time_object, :timeliness
+          if value.is_a?(Hash)
-        alias_method :execute_callstack_for_multiparameter_attributes, :execute_callstack_for_multiparameter_attributes_with_timeliness
+            value_from_multiparameter_assignment(value)
-        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)
+            super(value)
           end
         end
-      end
 
-      def execute_callstack_for_multiparameter_attributes_with_timeliness(callstack)
+        define_method(:assert_valid_value) do |value|
-        errors = []
+          if value.is_a?(Hash)
-        callstack.each do |name, values_with_empty_parameters|
+            value_from_multiparameter_assignment(value)
-          begin
+          else
-            send(name + "=", read_value_from_parameter(name, values_with_empty_parameters))
+            super(value)
-          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"
+        define_method(:value_from_multiparameter_assignment) do |values_hash|
+          defaults.each do |k, v|
+            values_hash[k] ||= v
+          end
+          return unless values_hash.values_at(1,2,3).all?{ |v| v.present? } &&
+                          Date.valid_civil?(*values_hash.values_at(1,2,3))
+
+          values = values_hash.sort.map(&:last)
+          ::Time.send(default_timezone, *values)
         end
+        private :value_from_multiparameter_assignment
+
       end
 
     end
   end
 end
+
+ActiveModel::Type::Date.class_eval do
+  include ValidatesTimeliness::Extensions::AcceptsMultiparameterTime.new
+end
+
+ActiveModel::Type::Time.class_eval do
+  include ValidatesTimeliness::Extensions::AcceptsMultiparameterTime.new(
+    defaults: { 1 => 1970, 2 => 1, 3 => 1, 4 => 0, 5 => 0 }
+  )
+end
+
+ActiveModel::Type::DateTime.class_eval do
+  include ValidatesTimeliness::Extensions::AcceptsMultiparameterTime.new(
+    defaults: { 4 => 0, 5 => 0 }
+  )
+end

lib/validates_timeliness/helper_methods.rb

@@ -14,12 +14,13 @@ module ActiveModel
         timeliness_validation_for attr_names, :datetime
       end
 
-      def timeliness_validation_for(attr_names, type)
+      def validates_timeliness_of(*attr_names)
-        options = _merge_attributes(attr_names).merge(:type => type)
+        timeliness_validation_for attr_names
-        if respond_to?(:timeliness_validated_attributes)
+      end
-          self.timeliness_validated_attributes ||= []
+
-          self.timeliness_validated_attributes += (attr_names - self.timeliness_validated_attributes)
+      def timeliness_validation_for(attr_names, type=nil)
-        end
+        options = _merge_attributes(attr_names)
+        options.update(:type => type) if type
         validates_with TimelinessValidator, options
       end
     end

lib/validates_timeliness/orm/active_model.rb

@@ -0,0 +1,71 @@
+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
+
+        def define_timeliness_methods(before_type_cast=false)
+          return if timeliness_validated_attributes.blank?
+          timeliness_validated_attributes.each do |attr_name|
+            define_attribute_timeliness_methods(attr_name, before_type_cast)
+          end
+        end
+
+        def generated_timeliness_methods
+          @generated_timeliness_methods ||= Module.new { |m|
+            extend Mutex_m
+          }.tap { |mod| include mod }
+        end
+
+        def undefine_timeliness_attribute_methods
+          generated_timeliness_methods.module_eval do
+            instance_methods.each { |m| undef_method(m) }
+          end
+        end
+
+        def define_attribute_timeliness_methods(attr_name, before_type_cast=false)
+          define_timeliness_write_method(attr_name)
+          define_timeliness_before_type_cast_method(attr_name) if before_type_cast
+        end
+
+        def define_timeliness_write_method(attr_name)
+          generated_timeliness_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            def #{attr_name}=(value)
+              @timeliness_cache ||= {}
+              @timeliness_cache['#{attr_name}'] = value
+
+              @attributes['#{attr_name}'] = super
+            end
+          STR
+        end
+
+        def define_timeliness_before_type_cast_method(attr_name)
+          generated_timeliness_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            def #{attr_name}_before_type_cast
+              read_timeliness_attribute_before_type_cast('#{attr_name}')
+            end
+          STR
+        end
+      end
+
+      def read_timeliness_attribute_before_type_cast(attr_name)
+        @timeliness_cache && @timeliness_cache[attr_name] || @attributes[attr_name]
+      end
+
+      def _clear_timeliness_cache
+        @timeliness_cache = {}
+      end
+
+    end
+  end
+end

lib/validates_timeliness/orm/active_record.rb

@@ -3,82 +3,15 @@ module ValidatesTimeliness
     module ActiveRecord
       extend ActiveSupport::Concern
 
-      def self.use_plugin_cache?
+      def read_timeliness_attribute_before_type_cast(attr_name)
-        ::ActiveRecord::VERSION::STRING < '3.1.0'
+        read_attribute_before_type_cast(attr_name)
-      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])
-        end
-
-        def timeliness_attribute_type(attr_name)
-          columns_hash[attr_name.to_s].type
-        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
-            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
-        end
-      end
-
-      module Reload
-        def reload(*args)
-          _clear_timeliness_cache
-          super
-        end
       end
 
     end
   end
 end
 
-class ActiveRecord::Base
+ActiveSupport.on_load(:active_record) do
   include ValidatesTimeliness::AttributeMethods
   include ValidatesTimeliness::ORM::ActiveRecord
 end

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

lib/validates_timeliness/railtie.rb

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

lib/validates_timeliness/validator.rb

@@ -1,10 +1,9 @@
+require 'active_model'
 require 'active_model/validator'
 
 module ValidatesTimeliness
   class Validator < ActiveModel::EachValidator
-    include Conversion
+    attr_reader :type, :attributes, :converter
-
-    attr_reader :type
 
     RESTRICTIONS = {
       :is_at        => :==,
@@ -22,26 +21,46 @@ 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
 
     def validate_each(record, attr_name, value)
       raw_value = attribute_raw_value(record, attr_name) || value
       return if (@allow_nil && raw_value.nil?) || (@allow_blank && raw_value.blank?)
 
-      @timezone_aware = timezone_aware?(record, attr_name)
+      @converter = initialize_converter(record, attr_name)
-      value = parse(raw_value) if value.is_a?(String) || options[:format]
+
-      value = type_cast_value(value, @type)
+      value = @converter.parse(raw_value) if value.is_a?(String) || options[:format]
+      value = @converter.type_cast_value(value)
 
       add_error(record, attr_name, :"invalid_#{@type}") and return if value.blank?
 
@@ -51,7 +70,7 @@ module ValidatesTimeliness
     def validate_restrictions(record, attr_name, value)
       @restrictions_to_check.each do |restriction|
         begin
-          restriction_value = type_cast_value(evaluate_option_value(options[restriction], record), @type)
+          restriction_value = @converter.type_cast_value(@converter.evaluate(options[restriction], record))
           unless value.send(RESTRICTIONS[restriction], restriction_value)
             add_error(record, attr_name, restriction, restriction_value) and break
           end
@@ -66,7 +85,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,13 +95,22 @@ module ValidatesTimeliness
     end
 
     def attribute_raw_value(record, attr_name)
-      record.respond_to?(:_timeliness_raw_value_for) &&
+      record.respond_to?(:read_timeliness_attribute_before_type_cast) &&
-        record._timeliness_raw_value_for(attr_name.to_s)
+        record.read_timeliness_attribute_before_type_cast(attr_name.to_s)
     end
 
-    def timezone_aware?(record, attr_name)
+    def time_zone_aware?(record, attr_name)
-      record.class.respond_to?(:timeliness_attribute_timezone_aware?) &&
+      record.class.respond_to?(:skip_time_zone_conversion_for_attributes) &&
-        record.class.timeliness_attribute_timezone_aware?(attr_name)
+        !record.class.skip_time_zone_conversion_for_attributes.include?(attr_name.to_sym)
+    end
+
+    def initialize_converter(record, attr_name)
+      ValidatesTimeliness::Converter.new(
+        type: @type,
+        time_zone_aware: time_zone_aware?(record, attr_name),
+        format: options[:format],
+        ignore_usec: options[:ignore_usec]
+      )
     end
 
   end

lib/validates_timeliness/version.rb

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

spec/spec_helper.rb

@@ -1,17 +1,21 @@
 require 'rspec'
 
+require 'byebug'
 require 'active_model'
 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 'rails/railtie'
 
 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 +28,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,8 +57,10 @@ 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::Base.time_zone_aware_types = [:datetime, :time]
 ActiveRecord::Migration.verbose = false
 ActiveRecord::Schema.define(:version => 1) do
   create_table :employees, :force => true do |t|
@@ -73,8 +75,8 @@ end
 class Employee < ActiveRecord::Base
   attr_accessor :redefined_birth_date_called
   validates_date :birth_date, :allow_nil => true
-  validates_date :birth_time, :allow_nil => true
+  validates_time :birth_time, :allow_nil => true
-  validates_date :birth_datetime, :allow_nil => true
+  validates_datetime :birth_datetime, :allow_nil => true
 
   def birth_date=(value)
     self.redefined_birth_date_called = true
@@ -84,7 +86,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 +94,7 @@ RSpec.configure do |c|
     reset_validation_setup_for(PersonWithShim)
   end
 
-  RSpec.configure do |c|
+  c.filter_run_excluding :active_record => lambda {|version|
-    c.filter_run_excluding :active_record => lambda {|version|
+    !(::ActiveRecord::VERSION::STRING.to_s =~ /^#{version.to_s}/)
-      !(::ActiveRecord::VERSION::STRING.to_s =~ /^#{version.to_s}/)
+  }
-    }
-  end
-  
 end

spec/support/model_helpers.rb

@@ -3,22 +3,21 @@ 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
+      expect(record).to be_invalid
-      record.errors[attr_name].size.should >= 1
+      expect(record.errors[attr_name].size).to be >= 1
-      record.errors[attr_name].first.should == error if error
+      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
 
   def with_each_person_value(attr_name, values)
     record = Person.new
-    values = [values] unless values.is_a?(Array)
+    Array.wrap(values).each do |value|
-    values.each do |value|
       record.send("#{attr_name}=", value)
       yield record, value
     end

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

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
@@ -26,7 +25,9 @@ module TestModel
 
     def type_cast(attr_name, value)
       return value unless value.is_a?(String)
-      value.send("to_#{model_attributes[attr_name.to_sym]}") rescue nil
+      type_name = model_attributes[attr_name.to_sym]
+      type = ActiveModel::Type.lookup(type_name)
+      type.cast(value)
     end
   end
 
@@ -49,7 +50,7 @@ module TestModel
   end
 
   def method_missing(method_id, *args, &block)
-    if match_attribute_method?(method_id.to_s)
+    if !matched_attribute_method(method_id.to_s).nil?
       self.class.define_attribute_methods self.class.model_attributes.keys
       send(method_id, *args, &block)
     else

spec/validates_timeliness/attribute_methods_spec.rb

@@ -1,8 +1,6 @@
-require 'spec_helper'
+RSpec.describe ValidatesTimeliness::AttributeMethods do
-
+  it 'should define read_timeliness_attribute_before_type_cast instance method' do
-describe ValidatesTimeliness::AttributeMethods do
+    expect(PersonWithShim.new).to respond_to(:read_timeliness_attribute_before_type_cast)
-  it 'should define _timeliness_raw_value_for instance method' do
-    PersonWithShim.new.should respond_to(:_timeliness_raw_value_for)
   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,28 +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
-      # Force method definitions
-      PersonWithShim.validates_date :birth_date
-      r = PersonWithShim.new
-      r.birth_date = Time.now
-
-      write_method = RUBY_VERSION < '1.9' ? 'birth_date=' : :birth_date=
-
-      PersonWithShim.send(:generated_timeliness_methods).instance_methods.should include(write_method)
-
-      PersonWithShim.undefine_attribute_methods 
-
-      PersonWithShim.send(:generated_timeliness_methods).instance_methods.should_not include(write_method)
     end
 
     context "with plugin parser" do
@@ -70,7 +53,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 +63,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

spec/validates_timeliness/converter_spec.rb

@@ -1,182 +1,197 @@
-require 'spec_helper'
+RSpec.describe ValidatesTimeliness::Converter do
-
+  subject(:converter) { described_class.new(type: type, time_zone_aware: time_zone_aware, ignore_usec: ignore_usec) }
-describe ValidatesTimeliness::Conversion do
-  include ValidatesTimeliness::Conversion
 
   let(:options) { Hash.new }
+  let(:type) { :date }
+  let(:time_zone_aware) { false }
+  let(:ignore_usec) { false }
 
   before do
     Timecop.freeze(Time.mktime(2010, 1, 1, 0, 0, 0))
   end
 
+  delegate :type_cast_value, :evaluate, :parse, :dummy_time, to: :converter
+
   describe "#type_cast_value" do
     describe "for date type" do
+      let(:type) { :date }
+
       it "should return same value for date value" do
-        type_cast_value(Date.new(2010, 1, 1), :date).should == Date.new(2010, 1, 1)
+        expect(type_cast_value(Date.new(2010, 1, 1))).to eq(Date.new(2010, 1, 1))
       end
 
       it "should return date part of time value" do
-        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))).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))).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)).to eq(nil)
       end
     end
 
     describe "for time type" do
+      let(:type) { :time }
+
       it "should return same value for time value matching dummy date part" do
-        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))).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))).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))).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))).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)).to eq(nil)
       end
     end
 
     describe "for datetime type" do
+      let(:type) { :datetime }
+      let(:time_zone_aware) { true }
+
       it "should return Date as Time value" do
-        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))).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))).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))).to eq(Time.utc(2010, 1, 1, 12, 34, 56))
       end
 
       it "should return same Time in correct zone if timezone aware" do
-        @timezone_aware = true
         value = Time.utc(2010, 1, 1, 12, 34, 56)
-        result = type_cast_value(value, :datetime)
+        result = type_cast_value(value)
-        result.should == Time.zone.local(2010, 1, 1, 23, 34, 56)
+        expect(result).to eq(Time.zone.local(2010, 1, 1, 23, 34, 56))
-        result.zone.should == 'EST'
+        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)).to eq(nil)
       end
     end
 
     describe "ignore_usec option" do
-      let(:options) { {:ignore_usec => true} }
+      let(:type) { :datetime }
+      let(:ignore_usec) { true }
 
       it "should ignore usec on time values when evaluated" do
         value = Time.utc(2010, 1, 1, 12, 34, 56, 10000)
-        type_cast_value(value, :datetime).should == Time.utc(2010, 1, 1, 12, 34, 56)
+        expect(type_cast_value(value)).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
+      context do
-        @timezone_aware = true
+        let(:time_zone_aware) { true }
-        value = Time.utc(2010, 1, 1, 12, 34, 56, 10000)
+
-        result = type_cast_value(value, :datetime)
+        it "should ignore usec and return time in correct zone if timezone aware" do
-        result.should == Time.zone.local(2010, 1, 1, 23, 34, 56)
+          value = Time.utc(2010, 1, 1, 12, 34, 56, 10000)
-        result.zone.should == 'EST'
+          result = type_cast_value(value)
+          expect(result).to eq(Time.zone.local(2010, 1, 1, 23, 34, 56))
+          expect(result.zone).to eq('AEDT')
+        end
       end
     end
   end
 
   describe "#dummy_time" do
     it 'should return Time with dummy date values but same time components' do
-      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
+      expect(dummy_time(Time.utc(2000, 1, 1, 12, 34, 56))).to eq(Time.zone.local(2000, 1, 1, 23, 34, 56))
-      dummy_time(Time.utc(2000, 1, 1, 12, 34, 56)).should == 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
   end
 
-  describe "#evaluate_option_value" do
+  describe "#evaluate" do
     let(:person) { Person.new }
 
     it 'should return Date object as is' do
       value = Date.new(2010,1,1)
-      evaluate_option_value(value, person).should == value
+      expect(evaluate(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(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(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(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(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
+      person.birth_datetime = value
-      evaluate_option_value(:birth_time, person).should == value
+      expect(evaluate(:birth_datetime, person)).to eq(value)
     end
 
     it 'should return Time value is default zone from string time value' do
       value = '2010-01-01 12:00:00'
-      evaluate_option_value(value, person).should == Time.utc(2010,1,1,12,0,0)
+      expect(evaluate(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
+    context do
-      @timezone_aware = true
+      let(:converter) { described_class.new(type: :date, time_zone_aware: true) }
-      value = '2010-01-01 12:00:00'
+
-      evaluate_option_value(value, person).should == Time.zone.local(2010,1,1,12,0,0)
+      it 'should return Time value is current zone from string time value if timezone aware' do
+        value = '2010-01-01 12:00:00'
+        expect(evaluate(value, person)).to eq(Time.zone.local(2010,1,1,12,0,0))
+      end
     end
 
     it 'should return Time value in default zone from proc which returns string time' do
-      value = '2010-01-01 12:00:00'
+      value = '2010-11-12 13:00:00'
-      evaluate_option_value(lambda { value }, person).should == Time.utc(2010,1,1,12,0,0)
+      expect(evaluate(lambda { value }, person)).to eq(Time.utc(2010,11,12,13,0,0))
     end
 
     it 'should return Time value for attribute method symbol which returns string time value' do
-      value = '2010-01-01 12:00:00'
+      value = '13:00:00'
       person.birth_time = value
-      evaluate_option_value(:birth_time, person).should == Time.utc(2010,1,1,12,0,0)
+      expect(evaluate(:birth_time, person)).to eq(Time.utc(2000,1,1,13,0,0))
     end
 
     context "restriction shorthand" do
@@ -185,17 +200,17 @@ describe ValidatesTimeliness::Conversion do
       end
 
       it 'should evaluate :now as current time' do
-        evaluate_option_value(:now, person).should == Time.now
+        expect(evaluate(: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(: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)
+        allow(person).to receive(:now).and_return(time)
-        evaluate_option_value(:now, person).should == time
+        expect(evaluate(:now, person)).to eq(time)
       end
     end
   end
@@ -205,7 +220,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
@@ -214,21 +229,19 @@ describe ValidatesTimeliness::Conversion do
       with_config(:use_plugin_parser, false)
 
       it 'should use Time.zone.parse attribute is timezone aware' do
-        @timezone_aware = true
+        expect(Timeliness::Parser).to_not receive(:parse)
-        Time.zone.should_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

spec/validates_timeliness/extensions/date_time_select_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
+RSpec.describe 'ValidatesTimeliness::Extensions::DateTimeSelect' do
-
-describe ValidatesTimeliness::Extensions::DateTimeSelect do
   include ActionView::Helpers::DateHelper
   attr_reader :person, :params
 
@@ -22,8 +20,8 @@ describe ValidatesTimeliness::Extensions::DateTimeSelect do
         "birth_datetime(6i)" => '14',
       }
       person.birth_datetime = nil
-      @output = datetime_select(:person, :birth_datetime, :include_blank => true, :include_seconds => true)
+      @output = datetime_select(:person, :birth_datetime, include_blank: true, include_seconds: true)
-      should_have_datetime_selected(:birth_datetime, :year => 2009, :month => 'February', :day => 29, :hour => 12, :min => 13, :sec => 14)
+      should_have_datetime_selected(:birth_datetime, year: 2009, month: 'February', day: 29, hour: 12, min: 13, sec: 14)
     end
 
     it "should override object values and use params if present" do
@@ -36,26 +34,26 @@ describe ValidatesTimeliness::Extensions::DateTimeSelect do
         "birth_datetime(6i)" => '14',
       }
       person.birth_datetime = "2010-01-01 15:16:17"
-      @output = datetime_select(:person, :birth_datetime, :include_blank => true, :include_seconds => true)
+      @output = datetime_select(:person, :birth_datetime, include_blank: true, include_seconds: true)
-      should_have_datetime_selected(:birth_datetime, :year => 2009, :month => 'February', :day => 29, :hour => 12, :min => 13, :sec => 14)
+      should_have_datetime_selected(:birth_datetime, year: 2009, month: 'February', day: 29, hour: 12, min: 13, sec: 14)
     end
 
     it "should use attribute values from object if no params" do
       person.birth_datetime = "2009-01-02 12:13:14"
-      @output = datetime_select(:person, :birth_datetime, :include_blank => true, :include_seconds => true)
+      @output = datetime_select(:person, :birth_datetime, include_blank: true, include_seconds: true)
-      should_have_datetime_selected(:birth_datetime, :year => 2009, :month => 'January', :day => 2, :hour => 12, :min => 13, :sec => 14)
+      should_have_datetime_selected(:birth_datetime, year: 2009, month: 'January', day: 2, hour: 12, min: 13, sec: 14)
     end
 
     it "should use attribute values if params does not contain attribute params" do
       person.birth_datetime = "2009-01-02 12:13:14"
       @params["person"] = { }
-      @output = datetime_select(:person, :birth_datetime, :include_blank => true, :include_seconds => true)
+      @output = datetime_select(:person, :birth_datetime, include_blank: true, include_seconds: true)
-      should_have_datetime_selected(:birth_datetime, :year => 2009, :month => 'January', :day => 2, :hour => 12, :min => 13, :sec => 14)
+      should_have_datetime_selected(:birth_datetime, year: 2009, month: 'January', day: 2, hour: 12, min: 13, sec: 14)
     end
 
     it "should not select values when attribute value is nil and has no param values" do
       person.birth_datetime = nil
-      @output = datetime_select(:person, :birth_datetime, :include_blank => true, :include_seconds => true)
+      @output = datetime_select(:person, :birth_datetime, include_blank: true, include_seconds: true)
       should_not_have_datetime_selected(:birth_datetime, :year, :month, :day, :hour, :min, :sec)
     end
   end
@@ -68,8 +66,8 @@ describe ValidatesTimeliness::Extensions::DateTimeSelect do
         "birth_date(3i)" => '29',
       }
       person.birth_date = nil
-      @output = date_select(:person, :birth_date, :include_blank => true)
+      @output = date_select(:person, :birth_date, include_blank: true)
-      should_have_datetime_selected(:birth_date, :year => 2009, :month => 'February', :day => 29)
+      should_have_datetime_selected(:birth_date, year: 2009, month: 'February', day: 29)
     end
 
     it "should override object values and use params if present" do
@@ -79,26 +77,26 @@ describe ValidatesTimeliness::Extensions::DateTimeSelect do
         "birth_date(3i)" => '29',
       }
       person.birth_date = "2009-03-01"
-      @output = date_select(:person, :birth_date, :include_blank => true)
+      @output = date_select(:person, :birth_date, include_blank: true)
-      should_have_datetime_selected(:birth_date, :year => 2009, :month => 'February', :day => 29)
+      should_have_datetime_selected(:birth_date, year: 2009, month: 'February', day: 29)
     end
 
     it "should select attribute values from object if no params" do
       person.birth_date = "2009-01-02"
-      @output = date_select(:person, :birth_date, :include_blank => true)
+      @output = date_select(:person, :birth_date, include_blank: true)
-      should_have_datetime_selected(:birth_date, :year => 2009, :month => 'January', :day => 2)
+      should_have_datetime_selected(:birth_date, year: 2009, month: 'January', day: 2)
     end
 
     it "should select attribute values if params does not contain attribute params" do
       person.birth_date = "2009-01-02"
       @params["person"] = { }
-      @output = date_select(:person, :birth_date, :include_blank => true)
+      @output = date_select(:person, :birth_date, include_blank: true)
-      should_have_datetime_selected(:birth_date, :year => 2009, :month => 'January', :day => 2)
+      should_have_datetime_selected(:birth_date, year: 2009, month: 'January', day: 2)
     end
 
     it "should not select values when attribute value is nil and has no param values" do
       person.birth_date = nil
-      @output = date_select(:person, :birth_date, :include_blank => true)
+      @output = date_select(:person, :birth_date, include_blank: true)
       should_not_have_datetime_selected(:birth_time, :year, :month, :day)
     end
 
@@ -108,10 +106,10 @@ describe ValidatesTimeliness::Extensions::DateTimeSelect do
         "birth_date(2i)" => '2',
       }
 
-      @output = date_select(:person, :birth_date, :include_blank => true, :discard_day => true)
+      @output = date_select(:person, :birth_date, include_blank: true, discard_day: true)
-      should_have_datetime_selected(:birth_date, :year => 2009, :month => 'February')
+      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
 
@@ -130,34 +128,35 @@ describe ValidatesTimeliness::Extensions::DateTimeSelect do
         "birth_time(6i)" => '14',
       }
       person.birth_time = nil
-      @output = time_select(:person, :birth_time, :include_blank => true, :include_seconds => true)
+      @output = time_select(:person, :birth_time, include_blank: true, include_seconds: true)
-      should_have_datetime_selected(:birth_time, :hour => 12, :min => 13, :sec => 14)
+      should_have_datetime_selected(:birth_time, hour: 12, min: 13, sec: 14)
     end
 
     it "should select attribute values from object if no params" do
       person.birth_time = "2000-01-01 12:13:14"
-      @output = time_select(:person, :birth_time, :include_blank => true, :include_seconds => true)
+      @output = time_select(:person, :birth_time, include_blank: true, include_seconds: true)
-      should_have_datetime_selected(:birth_time, :hour => 12, :min => 13, :sec => 14)
+      should_have_datetime_selected(:birth_time, hour: 12, min: 13, sec: 14)
     end
 
     it "should not select values when attribute value is nil and has no param values" do
       person.birth_time = nil
-      @output = time_select(:person, :birth_time, :include_blank => true, :include_seconds => true)
+      @output = time_select(:person, :birth_time, include_blank: true, include_seconds: true)
       should_not_have_datetime_selected(:birth_time, :hour, :min, :sec)
     end
   end
 
   def should_have_datetime_selected(field, datetime_hash)
     datetime_hash.each do |key, value|
-      index = {:year => 1, :month => 2, :day => 3, :hour => 4, :min => 5, :sec => 6}[key]
+      index = {year: 1, month: 2, day: 3, hour: 4, min: 5, sec: 6}[key]
-      @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]
+      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

spec/validates_timeliness/extensions/multiparameter_handler_spec.rb

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

spec/validates_timeliness/helper_methods_spec.rb

@@ -1,30 +1,28 @@
-require 'spec_helper'
+RSpec.describe ValidatesTimeliness, 'HelperMethods' do
-
+  let(:record) { Person.new }
-describe ValidatesTimeliness, 'HelperMethods' do
+  
   it 'should define class validation methods' do
-    Person.should respond_to(:validates_date)
+    expect(Person).to respond_to(:validates_date)
-    Person.should respond_to(:validates_time)
+    expect(Person).to respond_to(:validates_time)
-    Person.should respond_to(:validates_datetime)
+    expect(Person).to respond_to(:validates_datetime)
   end
 
   it 'should define instance validation methods' do
-    Person.new.should respond_to(:validates_date)
+    expect(record).to respond_to(:validates_date)
-    Person.new.should respond_to(:validates_time)
+    expect(record).to respond_to(:validates_time)
-    Person.new.should respond_to(:validates_datetime)
+    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
+    record.valid?
-    r.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
+    record.validates_date :birth_date
-    r.validates_date :birth_date
 
-    r.errors[:birth_date].should_not be_empty
+    expect(record.errors[:birth_date]).not_to be_empty
   end
 end

spec/validates_timeliness/orm/active_record_spec.rb

@@ -1,172 +1,190 @@
-require 'spec_helper'
+RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
-
-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)
+      expect(ActiveRecord::Base).to respond_to(:validates_date)
-      ActiveRecord::Base.should respond_to(:validates_time)
+      expect(ActiveRecord::Base).to respond_to(:validates_time)
-      ActiveRecord::Base.should respond_to(:validates_datetime)
+      expect(ActiveRecord::Base).to respond_to(:validates_datetime)
     end
 
     it 'should defines for the instance' do
-      Employee.new.should respond_to(:validates_date)
+      expect(record).to respond_to(:validates_date)
-      Employee.new.should respond_to(:validates_time)
+      expect(record).to respond_to(:validates_time)
-      Employee.new.should respond_to(:validates_datetime)
+      expect(record).to respond_to(:validates_datetime)
     end
 
     it "should validate a valid value string" do
-      r = Employee.new
+      record.birth_date = '2012-01-01'
-      r.birth_date = '2012-01-01'
 
-      r.valid?
+      record.valid?
-      r.errors[:birth_date].should be_empty
+      expect(record.errors[:birth_date]).to be_empty
     end
 
     it "should validate a invalid value string" do
-      r = Employee.new
+      record.birth_date = 'not a date'
-      r.birth_date = 'not a date'
 
-      r.valid?
+      record.valid?
-      r.errors[:birth_date].should_not be_empty
+      expect(record.birth_date_before_type_cast).to eq 'not a date'
+      expect(record.errors[:birth_date]).not_to be_empty
     end
 
     it "should validate a nil value" do
-      r = Employee.new
+      record.birth_date = nil
-      r.birth_date = nil
 
-      r.valid?
+      record.valid?
-      r.errors[:birth_date].should be_empty
+      expect(record.errors[:birth_date]).to be_empty
     end
   end
 
-  it 'should determine type for attribute' do
+  context 'attribute timezone awareness' do
-    Employee.timeliness_attribute_type(:birth_date).should == :date
+    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
+    }
   end
   
   context "attribute write method" do
     class EmployeeWithCache < ActiveRecord::Base
-      set_table_name 'employees'
+      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
 
-    context 'value cache' do
-      context 'for datetime column' do
-        it 'should store raw value' do
-          r = EmployeeWithCache.new
-          r.birth_datetime = date_string = '2010-01-01'
-          r._timeliness_raw_value_for('birth_datetime').should == date_string
-        end
-      end
-
-      context 'for date column' do
-        it 'should store raw value' do
-          r = EmployeeWithCache.new
-          r.birth_date = date_string = '2010-01-01'
-          r._timeliness_raw_value_for('birth_date').should == date_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'
+        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
+      before do
-        Timeliness::Parser.should_receive(:parse)
+        allow(Timeliness::Parser).to receive(:parse).and_call_original
-        r = EmployeeWithParser.new
-        r.birth_date = '2010-01-01'
-      end
-
-      it 'should parse a invalid string value as nil' do
-        Timeliness::Parser.should_receive(:parse)
-        r = EmployeeWithParser.new
-        r.birth_date = 'not a date'
       end
 
       context "for a date column" do
-        it 'should store a date value after parsing string' do
+        it 'should parse a string value' do
-          r = EmployeeWithParser.new
+          record.birth_date = '2010-01-01'
-          r.birth_date = '2010-01-01'
+          expect(record.birth_date).to eq(Date.new(2010, 1, 1))
 
-          r.birth_date.should be_kind_of(Date)
+          expect(Timeliness::Parser).to have_received(:parse)
-          r.birth_date.should == Date.new(2010, 1, 1)
+        end
+
+        it 'should parse a invalid string value as nil' do
+          record.birth_date = 'not valid'
+          expect(record.birth_date).to be_nil
+
+          expect(Timeliness::Parser).to have_received(:parse)
+        end
+
+        it 'should store a Date value after parsing string' do
+          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 time column" do
+        around do |example|
+          time_zone_aware_types = ActiveRecord::Base.time_zone_aware_types.dup
+          example.call
+          ActiveRecord::Base.time_zone_aware_types = time_zone_aware_types
+        end
+
+        context 'timezone aware' do
+          with_config(:default_timezone, 'Australia/Melbourne')
+
+          before do
+            unless ActiveRecord::Base.time_zone_aware_types.include?(:time)
+              ActiveRecord::Base.time_zone_aware_types.push(:time)
+            end
+          end
+
+          it 'should parse a string value' do
+            record.birth_time = '12:30'
+
+            expect(record.birth_time).to eq('12:30'.in_time_zone)
+            expect(Timeliness::Parser).to have_received(:parse)
+          end
+
+          it 'should parse a invalid string value as nil' do
+            record.birth_time = 'not valid'
+
+            expect(record.birth_time).to be_nil
+            expect(Timeliness::Parser).to have_received(:parse)
+          end
+
+          it 'should store a Time value after parsing string' do
+            record.birth_time = '12:30'
+
+            expect(record.birth_time).to eq('12:30'.in_time_zone)
+            expect(record.birth_time.utc_offset).to eq '12:30'.in_time_zone.utc_offset
+          end
+        end
+
+        skip 'not timezone aware' do
+          before do
+            ActiveRecord::Base.time_zone_aware_types.delete(:time)
+          end
+
+          it 'should parse a string value' do
+            record.birth_time = '12:30'
+
+            expect(record.birth_time).to eq(Time.utc(2000,1,1,12,30))
+            expect(Timeliness::Parser).to have_received(:parse)
+          end
+
+          it 'should parse a invalid string value as nil' do
+            record.birth_time = 'not valid'
+
+            expect(record.birth_time).to be_nil
+            expect(Timeliness::Parser).to have_received(:parse)
+          end
+
+          it 'should store a Time value in utc' do
+            record.birth_time = '12:30'
+
+            expect(record.birth_time.utc_offset).to eq Time.now.utc.utc_offset
+          end
         end
       end
 
       context "for a datetime column" do
         with_config(:default_timezone, 'Australia/Melbourne')
 
-        it 'should parse string into Time value' do
+        it 'should parse a string value into Time value' do
-          r = EmployeeWithParser.new
+          record.birth_datetime = '2010-01-01 12:00'
-          r.birth_datetime = '2010-01-01 12:00'
 
-          r.birth_datetime.should be_kind_of(Time)
+          expect(record.birth_datetime).to eq Time.zone.local(2010,1,1,12,00)
+          expect(Timeliness::Parser).to have_received(:parse)
+        end
+
+        it 'should parse a invalid string value as nil' do
+          record.birth_datetime = 'not valid'
+
+          expect(record.birth_datetime).to be_nil
+          expect(Timeliness::Parser).to have_received(:parse)
         end
 
         it 'should parse string as current timezone' do
-          r = EmployeeWithParser.new
+          record.birth_datetime = '2010-06-01 12:00'
-          r.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 "reload" do
-    it 'should clear cache value' do
-      r = Employee.create!
-      r.birth_date = '2010-01-01'
-      
-      r.reload
-
-      r._timeliness_raw_value_for('birth_date').should be_nil
-    end
-  end
-
-  context "before_type_cast method" do
-    it 'should be defined on class if ORM supports it' do
-      Employee.new.should 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'
-
-      r.birth_datetime_before_type_cast.should == 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/)
-    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'
-
-        r.birth_datetime_before_type_cast.should == date_string
-      end
-    end
-
-  end
-
-  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
-    end
-  end
 end

spec/validates_timeliness/orm/mongoid_spec.rb

@@ -1,137 +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
-
-    it "should validate a valid value string" do
-      r = Article.new
-      r.publish_date = '2012-01-01'
-
-      r.valid?
-      r.errors[:publish_date].should be_empty
-    end
-
-    it "should validate a invalid value string" do
-      r = Article.new
-      r.publish_date = 'not a date'
-
-      r.valid?
-      r.errors[:publish_date].should_not be_empty
-    end
-
-    it "should validate a nil value" do
-      r = Article.new
-      r.publish_date = nil
-
-      r.valid?
-      r.errors[:publish_date].should be_empty
-    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

spec/validates_timeliness/railtie_spec.rb

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

spec/validates_timeliness/validator/after_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
+RSpec.describe ValidatesTimeliness::Validator, ":after option" do
-
-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
 

spec/validates_timeliness/validator/before_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
+RSpec.describe ValidatesTimeliness::Validator, ":before option" do
-
-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
 

spec/validates_timeliness/validator/is_at_spec.rb

@@ -1,8 +1,6 @@
-require 'spec_helper'
+RSpec.describe ValidatesTimeliness::Validator, ":is_at option" do
-
-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
 

spec/validates_timeliness/validator/on_or_after_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
+RSpec.describe ValidatesTimeliness::Validator, ":on_or_after option" do
-
-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
 

spec/validates_timeliness/validator/on_or_before_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
+RSpec.describe ValidatesTimeliness::Validator, ":on_or_before option" do
-
-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
 

spec/validates_timeliness/validator_spec.rb

@@ -1,23 +1,27 @@
-require 'spec_helper'
+RSpec.describe ValidatesTimeliness::Validator do
-
-describe ValidatesTimeliness::Validator do
-  NIL = [nil]
-
   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)
+    allow(record).to receive(:birth_date).and_return(nil)
-    record.stub!(:_timeliness_raw_value_for).and_return("Not a date")
+    allow(record).to receive(:read_timeliness_attribute_before_type_cast).and_return("Not a date")
-    record.should_not be_valid
+    expect(record).not_to be_valid
-    record.errors[:birth_date].first.should == 'is not a valid date'
+    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
+        expect(Person.validators.first.options[:on_or_after]).to eq(on_or_after)
-        Person.validators.first.options[:on_or_before].should == on_or_before
+        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
+        expect(Person.validators.first.options[:on_or_after]).to eq(on_or_after)
-        Person.validators.first.options[:on_or_before].should == on_or_before
+        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')

spec/validates_timeliness_spec.rb

@@ -1,41 +1,39 @@
-require 'spec_helper'
+RSpec.describe ValidatesTimeliness do
-
-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) 
+      expect(Timeliness).to receive(:dummy_date_for_time_type) 
-      Timeliness.should_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

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.6"])
+  s.add_runtime_dependency(%q<timeliness>, [">= 0.3.10", "< 1"])
 end