Mongoid 3.0 appraisal and failing specs

.gitignore

@@ -3,4 +3,3 @@ pkg/
 .rvmrc
 Gemfile.lock
 gemfiles/*.lock
-.byebug_history

.rspec

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

.travis.yml

@@ -1,24 +0,0 @@
-language: ruby
-before_install:
-  - gem uninstall -v '>= 2' -i $(rvm gemdir)@global -ax bundler || true
-  - gem install bundler -v '< 2'
-before_script:
-  - bundle install
-cache: bundler
-bundler_args: --verbose
-
-matrix:
-  include:
-    - rvm: "2.4.6"
-      gemfile: gemfiles/rails_4_2.gemfile
-    - rvm: "2.5.5"
-      gemfile: gemfiles/rails_4_2.gemfile
-
-script: 'bundle exec rspec'
-
-notifications:
-  email:
-    recipients:
-      - adam.meehan@gmail.com
-    on_failure: change
-    on_success: never

Appraisals

@@ -1,11 +1,31 @@
-appraise "rails_4_0" do
-  gem "rails", "~> 4.0.13"
+appraise "rails_3_0" do
+  gem "rails", "~> 3.0.0"
 end
 
-appraise "rails_4_1" do
-  gem "rails", "~> 4.1.14"
+appraise "rails_3_1" do
+  gem "rails", "~> 3.1.0"
 end
 
-appraise "rails_4_2" do
-  gem "rails", "~> 4.2.11"
+appraise "rails_3_2" do
+  gem "rails", "~> 3.2.0"
+end
+
+appraise "mongoid_2_1" do
+  gem "mongoid", "~> 2.1.0"
+end
+
+appraise "mongoid_2_2" do
+  gem "mongoid", "~> 2.2.0"
+end
+
+appraise "mongoid_2_3" do
+  gem "mongoid", "~> 2.3.0"
+end
+
+appraise "mongoid_2_4" do
+  gem "mongoid", "~> 2.4.0"
+end
+
+appraise "mongoid_3_0" do
+  gem "mongoid", "~> 3.0.0"
 end

CHANGELOG.rdoc

@@ -1,34 +1,3 @@
-= 4.1.1 [2019-08-06]
-* Add initializer to ensure Timeliness default ambigiuous date handling config
-  in Timeliness v0.4.1+ is set correctly when using `use_us_formats` or
-  `use_euro_formats` switcher to set default.
-* Removed build support for Ruby 2.3 and Rails 4.0 and 4.1 to EOL official
-  support for those.
-
-= 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.
 

Gemfile

@@ -1,13 +1,24 @@
-source 'https://rubygems.org'
+source 'http://rubygems.org'
 
 gemspec
 
-gem 'rake'
-gem 'rails', '~> 4.2.11.1'
-gem 'rspec'
-gem 'rspec-rails', '~> 3.7'
+gem 'rails', '~> 3.2.6'
+gem 'rspec', '~> 2.8'
+gem 'rspec-rails', '~> 2.8'
 gem 'timecop'
-gem 'byebug'
+gem 'rspec_tag_matchers'
+gem 'ruby-debug', :platforms => [:ruby_18, :jruby]
+gem 'debugger', :platforms => [:ruby_19]
 gem 'appraisal'
-gem 'sqlite3', '~> 1.3.13'
-gem 'nokogiri', '~> 1.8'
+gem 'sqlite3'
+
+group :mongoid do
+  gem 'mongoid', '~> 3.0.0'
+  gem 'mongo'
+  gem 'bson_ext'
+  gem 'system_timer', :platforms => [:ruby_18]
+end
+
+group :active_record do
+  gem 'sqlite3-ruby', :require => 'sqlite3'
+end

README.rdoc

@@ -5,10 +5,9 @@
 
 == Description
 
-Complete validation of dates, times and datetimes for Rails 4.2.x and ActiveModel. Rails 4.0.x and 4.1.x may
-still work but official support has ended.
+Complete validation of dates, times and datetimes for Rails 3.x and ActiveModel.
 
-If you a looking for the old version for Rails 3.x go here[http://github.com/adzap/validates_timeliness/tree/v3.x].
+If you a looking for the old version for Rails 2.x go here[http://github.com/adzap/validates_timeliness/tree/v2.3].
 
 
 == Features
@@ -23,7 +22,7 @@ If you a looking for the old version for Rails 3.x go here[http://github.com/adz
 
 * 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 I18n for the error messages
 
 * Supports all the Rubies (that any sane person would be using in production).
 
@@ -31,7 +30,7 @@ If you a looking for the old version for Rails 3.x go here[http://github.com/adz
 == Installation
 
   # in Gemfile
-  gem 'validates_timeliness', '~> 4.1'
+  gem 'validates_timeliness', '~> 3.0'
 
   # Run bundler
   $ bundle install
@@ -40,7 +39,7 @@ Then run
   
   $ rails generate validates_timeliness:install
 
-This creates configuration initializer and locale files. In the initializer, there are a number of config
+This creates configuration initializer and locale files. In the initializer, you 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.
@@ -56,10 +55,7 @@ NOTE: You may wish to enable the plugin parser and the extensions to start. Plea
   validates_datetime :finish_time, :after => :start_time # Method symbol
 
   validates_date :booked_at, :on => :create, :on_or_after => :today # See Restriction Shorthand.
-
-  validates_time :booked_at, :between => ['9:00am', '5:00pm'] # On or after 9:00AM and on or before 5:00PM
-  validates_time :booked_at, :between => '9:00am'..'5:00pm' # The same as previous example
-  validates_time :booked_at, :between => '9:00am'...'5:00pm' # On or after 9:00AM and strictly before 5:00PM
+  validates_time :booked_at, :between => ['9.00am', '5:00pm']
 
   validates_time :breakfast_time, :on_or_after => '6:00am',
                                   :on_or_after_message => 'must be after opening time',
@@ -138,8 +134,8 @@ like so
 
   ValidatesTimeliness.setup do |config|
 
-    # Extend ORM/ODMs for full support (:active_record).
-    config.extend_orms = [ :active_record ]
+    # Extend ORM/ODMs for full support (:active_record, :mongoid).
+    config.extend_orms = [ :mongoid ]
 
   end
 
@@ -177,8 +173,8 @@ You can also use validation options for custom error messages. The following opt
     :after_message
     :on_or_after_message
 
-Note: There is no :between_message option. The between error message should be defined using the :on_or_after and :on_or_before
-(:before in case when :between argument is a Range with excluded high value, see Examples) messages.
+Note: There is no :between_message option. The between error message should be defined using the 
+:on_or_before and :on_or_after messages.
 
 It is highly recommended you use the I18n system for error messages.
 

autotest/discover.rb

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

gemfiles/mongoid_2_1.gemfile

@@ -0,0 +1,16 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", "~> 3.2.6"
+gem "rspec", "~> 2.8"
+gem "rspec-rails", "~> 2.8"
+gem "timecop"
+gem "rspec_tag_matchers"
+gem "ruby-debug", :platforms=>[:ruby_18, :jruby]
+gem "debugger", :platforms=>[:ruby_19]
+gem "appraisal"
+gem "sqlite3"
+gem "mongoid", "~> 2.1.0"
+
+gemspec :path=>"../"

gemfiles/mongoid_2_2.gemfile

@@ -0,0 +1,16 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", "~> 3.2.6"
+gem "rspec", "~> 2.8"
+gem "rspec-rails", "~> 2.8"
+gem "timecop"
+gem "rspec_tag_matchers"
+gem "ruby-debug", :platforms=>[:ruby_18, :jruby]
+gem "debugger", :platforms=>[:ruby_19]
+gem "appraisal"
+gem "sqlite3"
+gem "mongoid", "~> 2.2.0"
+
+gemspec :path=>"../"

gemfiles/mongoid_2_3.gemfile

@@ -0,0 +1,16 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", "~> 3.2.6"
+gem "rspec", "~> 2.8"
+gem "rspec-rails", "~> 2.8"
+gem "timecop"
+gem "rspec_tag_matchers"
+gem "ruby-debug", :platforms=>[:ruby_18, :jruby]
+gem "debugger", :platforms=>[:ruby_19]
+gem "appraisal"
+gem "sqlite3"
+gem "mongoid", "~> 2.3.0"
+
+gemspec :path=>"../"

gemfiles/mongoid_2_4.gemfile

@@ -0,0 +1,16 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", "~> 3.2.6"
+gem "rspec", "~> 2.8"
+gem "rspec-rails", "~> 2.8"
+gem "timecop"
+gem "rspec_tag_matchers"
+gem "ruby-debug", :platforms=>[:ruby_18, :jruby]
+gem "debugger", :platforms=>[:ruby_19]
+gem "appraisal"
+gem "sqlite3"
+gem "mongoid", "~> 2.4.0"
+
+gemspec :path=>"../"

gemfiles/mongoid_3_0.gemfile

@@ -0,0 +1,16 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", "~> 3.2.6"
+gem "rspec", "~> 2.8"
+gem "rspec-rails", "~> 2.8"
+gem "timecop"
+gem "rspec_tag_matchers"
+gem "ruby-debug", :platforms=>[:ruby_18, :jruby]
+gem "debugger", :platforms=>[:ruby_19]
+gem "appraisal"
+gem "sqlite3"
+gem "mongoid", "~> 3.0.0"
+
+gemspec :path=>"../"

gemfiles/mongoid_3_1.gemfile

@@ -0,0 +1,16 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", "~> 3.2.6"
+gem "rspec", "~> 2.8"
+gem "rspec-rails", "~> 2.8"
+gem "timecop"
+gem "rspec_tag_matchers"
+gem "ruby-debug", :platforms=>[:ruby_18, :jruby]
+gem "debugger", :platforms=>[:ruby_19]
+gem "appraisal"
+gem "sqlite3"
+gem "mongoid", "~> 3.1.0"
+
+gemspec :path=>"../"

gemfiles/rails_3_0.gemfile

@@ -0,0 +1,15 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rspec", "~> 2.8"
+gem "rspec-rails", "~> 2.8"
+gem "timecop"
+gem "rspec_tag_matchers"
+gem "ruby-debug", :platforms=>[:ruby_18, :jruby]
+gem "debugger", :platforms=>[:ruby_19]
+gem "appraisal"
+gem "sqlite3"
+gem "rails", "~> 3.0.0"
+
+gemspec :path=>"../"

gemfiles/rails_3_1.gemfile

@@ -0,0 +1,15 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rspec", "~> 2.8"
+gem "rspec-rails", "~> 2.8"
+gem "timecop"
+gem "rspec_tag_matchers"
+gem "ruby-debug", :platforms=>[:ruby_18, :jruby]
+gem "debugger", :platforms=>[:ruby_19]
+gem "appraisal"
+gem "sqlite3"
+gem "rails", "~> 3.1.0"
+
+gemspec :path=>"../"

gemfiles/rails_3_2.gemfile

@@ -0,0 +1,15 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rspec", "~> 2.8"
+gem "rspec-rails", "~> 2.8"
+gem "timecop"
+gem "rspec_tag_matchers"
+gem "ruby-debug", :platforms=>[:ruby_18, :jruby]
+gem "debugger", :platforms=>[:ruby_19]
+gem "appraisal"
+gem "sqlite3"
+gem "rails", "~> 3.2.0"
+
+gemspec :path=>"../"

gemfiles/rails_4_2.gemfile

@@ -1,14 +0,0 @@
-# This file was generated by Appraisal
-
-source "https://rubygems.org"
-
-gem "rails", "~> 4.2.8"
-gem "rspec", "~> 3.6.0"
-gem "rspec-rails", "~> 3.6.0"
-gem "timecop"
-gem "byebug"
-gem "appraisal"
-gem "sqlite3", "~> 1.3.0"
-gem "nokogiri", "1.6.7"
-
-gemspec path: "../"

lib/generators/validates_timeliness/templates/validates_timeliness.rb

@@ -1,6 +1,6 @@
 ValidatesTimeliness.setup do |config|
-  # Extend ORM/ODMs for full support (:active_record included).
-  config.extend_orms = [ :active_record ]
+  # Extend ORM/ODMs for full support (:active_record, :mongoid).
+  # 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 ambiguous year threshold when parsing a 2 digit year
+  # Change the amiguous 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

@@ -28,7 +28,7 @@ module ValidatesTimeliness
     attr_accessor :extend_orms, :ignore_restriction_errors, :restriction_shorthand_symbols, :use_plugin_parser
   end
 
-  # Extend ORM/ODMs for full support (:active_record).
+  # Extend ORM/ODMs for full support (:active_record, :mongoid).
   self.extend_orms = []
 
   # Ignore errors when restriction options are evaluated

lib/validates_timeliness/attribute_methods.rb

@@ -20,6 +20,13 @@ module ValidatesTimeliness
         :datetime
       end
 
+      def undefine_attribute_methods
+        super
+        undefine_timeliness_attribute_methods
+      end
+
+      protected
+
       def define_timeliness_methods(before_type_cast=false)
         return if timeliness_validated_attributes.blank?
         timeliness_validated_attributes.each do |attr_name|
@@ -27,58 +34,55 @@ module ValidatesTimeliness
         end
       end
 
-      def generated_timeliness_methods
-        @generated_timeliness_methods ||= Module.new { |m| 
-          extend Mutex_m
-        }.tap { |mod| include mod }
-      end
-
-      def undefine_timeliness_attribute_methods
-        generated_timeliness_methods.module_eval do
-          instance_methods.each { |m| undef_method(m) } 
-        end
-      end
-
-      protected
-
       def define_attribute_timeliness_methods(attr_name, before_type_cast=false)
         define_timeliness_write_method(attr_name)
         define_timeliness_before_type_cast_method(attr_name) if before_type_cast
       end
 
       def define_timeliness_write_method(attr_name)
-        generated_timeliness_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+        method_body, line = <<-EOV, __LINE__ + 1
           def #{attr_name}=(value)
-            write_timeliness_attribute('#{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
-        STR
+        EOV
+        generated_timeliness_methods.module_eval(method_body, __FILE__, line)
       end
 
       def define_timeliness_before_type_cast_method(attr_name)
-        generated_timeliness_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+        method_body, line = <<-EOV, __LINE__ + 1
           def #{attr_name}_before_type_cast
-            read_timeliness_attribute_before_type_cast('#{attr_name}')
+            _timeliness_raw_value_for('#{attr_name}') || @attributes['#{attr_name}']
           end
-        STR
+        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 write_timeliness_attribute(attr_name, value)
-      @timeliness_cache ||= {}
-      @timeliness_cache[attr_name] = value
-
-      if ValidatesTimeliness.use_plugin_parser
-        type = self.class.timeliness_attribute_type(attr_name)
-        timezone = :current if self.class.timeliness_attribute_timezone_aware?(attr_name)
-        value = Timeliness::Parser.parse(value, type, :zone => timezone)
-        value = value.to_date if value && type == :date
-      end
-
-      @attributes[attr_name] = value
-    end
-
-    def read_timeliness_attribute_before_type_cast(attr_name)
-      @timeliness_cache && @timeliness_cache[attr_name] || @attributes[attr_name]
+    def _timeliness_raw_value_for(attr_name)
+      @timeliness_cache && @timeliness_cache[attr_name]
     end
 
     def _clear_timeliness_cache

lib/validates_timeliness/conversion.rb

@@ -12,8 +12,6 @@ module ValidatesTimeliness
         value.to_date
       when :datetime
         value.is_a?(Time) ? value : value.to_time
-      else
-        value
       end
       if options[:ignore_usec] && value.is_a?(Time)
         Timeliness::Parser.make_time(Array(value).reverse[4..9], (:current if @timezone_aware))

lib/validates_timeliness/extensions.rb

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

lib/validates_timeliness/extensions/date_time_select.rb

@@ -9,6 +9,7 @@ module ValidatesTimeliness
       # It's a minor usability improvement which is rarely an issue for the user.
 
       included do
+        alias_method_chain :datetime_selector, :timeliness
         alias_method_chain :value, :timeliness
       end
 
@@ -32,8 +33,15 @@ module ValidatesTimeliness
         end
       end
 
+      def datetime_selector_with_timeliness(*args)
+        @timeliness_date_or_time_tag = true
+        datetime_selector_without_timeliness(*args)
+      end
+
       def value_with_timeliness(object)
-        return value_without_timeliness(object) unless @template_object.params[@object_name]
+        unless @timeliness_date_or_time_tag && @template_object.params[@object_name]
+          return value_without_timeliness(object)
+        end
 
         @template_object.params[@object_name]
 
@@ -48,7 +56,6 @@ module ValidatesTimeliness
 
         TimelinessDateTime.new(*values)
       end
-
     end
   end
 end

lib/validates_timeliness/extensions/multiparameter_handler.rb

@@ -1,74 +1,80 @@
-ActiveRecord::AttributeAssignment::MultiparameterAttribute.class_eval do
-  private
+module ValidatesTimeliness
+  module Extensions
+    module MultiparameterHandler
+      extend ActiveSupport::Concern
 
-  # Yield if date values are valid
-  def validate_multiparameter_date_values(set_values)
-    if set_values[0..2].all?{ |v| v.present? } && Date.valid_civil?(*set_values[0..2])
-      yield
-    else
-      invalid_multiparameter_date_or_time_as_string(set_values)
-    end
-  end
+      # Stricter handling of date and time values from multiparameter 
+      # assignment from the date/time select view helpers
 
-  def invalid_multiparameter_date_or_time_as_string(values)
-    value =  [values[0], *values[1..2].map {|s| s.to_s.rjust(2,"0")} ].join("-")
-    value += ' ' + values[3..5].map {|s| s.to_s.rjust(2, "0") }.join(":") unless values[3..5].empty?
-    value
-  end
-
-  def instantiate_time_object(set_values)
-    raise if set_values.any?(&:nil?)
-
-    validate_multiparameter_date_values(set_values) {
-      set_values = set_values.map {|v| v.is_a?(String) ? v.strip : v }
-
-      if object.class.send(:create_time_zone_conversion_attribute?, name, cast_type_or_column)
-        Time.zone.local(*set_values)
-      else
-        Time.send(object.class.default_timezone, *set_values)
+      included do
+        alias_method_chain :instantiate_time_object, :timeliness
+        alias_method :execute_callstack_for_multiparameter_attributes, :execute_callstack_for_multiparameter_attributes_with_timeliness
+        alias_method :read_value_from_parameter, :read_value_from_parameter_with_timeliness
       end
-    }
-  rescue
-    invalid_multiparameter_date_or_time_as_string(set_values)
-  end
 
-  def read_time
-    # If column is a :time (and not :date or :timestamp) there is no need to validate if
-    # there are year/month/day fields
-    if cast_type_or_column.type == :time
-      # if the column is a time set the values to their defaults as January 1, 1970, but only if they're nil
-      { 1 => 1970, 2 => 1, 3 => 1 }.each do |key,value|
-        values[key] ||= value
+      private
+
+      def invalid_multiparameter_date_or_time_as_string(values)
+        value =  [values[0], *values[1..2].map {|s| s.to_s.rjust(2,"0")} ].join("-")
+        value += ' ' + values[3..5].map {|s| s.to_s.rjust(2, "0") }.join(":") unless values[3..5].empty?
+        value
       end
+
+      def instantiate_time_object_with_timeliness(name, values)
+        validate_multiparameter_date_values(values) {
+          instantiate_time_object_without_timeliness(name, values)
+        }
+      end
+
+      def instantiate_date_object(name, values)
+        validate_multiparameter_date_values(values) {
+          Date.new(*values)
+        }
+      end
+
+      # Yield if date values are valid
+      def validate_multiparameter_date_values(values)
+        if values[0..2].all?{ |v| v.present? } && Date.valid_civil?(*values[0..2])
+          yield
+        else
+          invalid_multiparameter_date_or_time_as_string(values)
+        end
+      end
+
+      def read_value_from_parameter_with_timeliness(name, values_from_param)
+        klass = (self.class.reflect_on_aggregation(name.to_sym) || column_for_attribute(name)).klass
+        values = values_from_param.is_a?(Hash) ? values_from_param.to_a.sort_by(&:first).map(&:last) : values_from_param
+
+        if values.empty? || values.all?{ |v| v.nil? }
+          nil
+        elsif klass == Time
+          instantiate_time_object(name, values)
+        elsif klass == Date
+          instantiate_date_object(name, values)
+        else
+          if respond_to?(:read_other_parameter_value)
+            read_date_parameter_value(name, values_from_param)
+          else
+            klass.new(*values)
+          end
+        end
+      end
+
+      def execute_callstack_for_multiparameter_attributes_with_timeliness(callstack)
+        errors = []
+        callstack.each do |name, values_with_empty_parameters|
+          begin
+            send(name + "=", read_value_from_parameter(name, values_with_empty_parameters))
+          rescue => ex
+            values = values_with_empty_parameters.is_a?(Hash) ? values_with_empty_parameters.values : values_with_empty_parameters 
+            errors << ActiveRecord::AttributeAssignmentError.new("error on assignment #{values.inspect} to #{name}", ex, name)
+          end
+        end
+        unless errors.empty?
+          raise ActiveRecord::MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes"
+        end
+      end
+
     end
-
-    max_position = extract_max_param(6)
-    set_values   = values.values_at(*(1..max_position))
-
-    instantiate_time_object(set_values)
   end
-
-  def read_date
-    set_values = values.values_at(1,2,3).map {|v| v.is_a?(String) ? v.strip : v }
-    
-    if set_values.any? { |v| v.is_a?(String) }
-      Timeliness.parse(set_values.join('-'), :date).try(:to_date) or raise TypeError
-    else
-      Date.new(*set_values)
-    end
-  rescue TypeError, ArgumentError, NoMethodError => ex # if Date.new raises an exception on an invalid date
-    # Date.new with nil values throws NoMethodError
-    raise ex if ex.is_a?(NoMethodError) && ex.message !~ /undefined method `div' for/
-    invalid_multiparameter_date_or_time_as_string(set_values)
-  end
-
-  # Cast type is v4.2 and column before
-  def cast_type_or_column
-    @cast_type || @column
-  end
-
-  def timezone_conversion_attribute?
-    object.class.send(:create_time_zone_conversion_attribute?, name, column)
-  end
-
 end

lib/validates_timeliness/helper_methods.rb

@@ -14,14 +14,8 @@ module ActiveModel
         timeliness_validation_for attr_names, :datetime
       end
 
-      def validates_timeliness_of(*attr_names)
-        timeliness_validation_for attr_names
-      end
-
-      def timeliness_validation_for(attr_names, type=nil)
-        options = _merge_attributes(attr_names)
-        options.update(:type => type) if type
-        validates_with TimelinessValidator, options
+      def timeliness_validation_for(attr_names, type)
+        validates_with TimelinessValidator, _merge_attributes(attr_names).merge(:type => type)
       end
     end
 

lib/validates_timeliness/orm/active_model.rb

@@ -1,20 +0,0 @@
-module ValidatesTimeliness
-  module ORM
-    module ActiveModel
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-        public
-
-        def define_attribute_methods(*attr_names)
-          super.tap { define_timeliness_methods}
-        end
-
-        def undefine_attribute_methods
-          super.tap { undefine_timeliness_attribute_methods }
-        end
-      end
-      
-    end
-  end
-end

lib/validates_timeliness/orm/active_record.rb

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

lib/validates_timeliness/orm/mongoid.rb

@@ -0,0 +1,63 @@
+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 => :time,
+            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

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

lib/validates_timeliness/validator.rb

@@ -1,11 +1,10 @@
-require 'active_model'
 require 'active_model/validator'
 
 module ValidatesTimeliness
   class Validator < ActiveModel::EachValidator
     include Conversion
 
-    attr_reader :type, :attributes
+    attr_reader :type
 
     RESTRICTIONS = {
       :is_at        => :==,
@@ -33,33 +32,20 @@ module ValidatesTimeliness
 
       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] = range.first
-        if range.is_a?(Range) && range.exclude_end?
-          options[:before] = range.last
-        else
-          options[:on_or_before] = range.last
-        end
+        options[:on_or_after], options[:on_or_before] = range.first, range.last
       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)
+    def setup(model)
       if model.respond_to?(:timeliness_validated_attributes)
         model.timeliness_validated_attributes ||= []
-        model.timeliness_validated_attributes |= attributes
+        model.timeliness_validated_attributes |= @attributes
       end
     end
 
-    # Rails 4.0 compatibility for old #setup method with class as arg
-    if Gem::Version.new(ActiveModel::VERSION::STRING) <= Gem::Version.new('4.1')
-      alias_method(:setup, :setup_timeliness_validated_attributes) 
-    end
-
     def validate_each(record, attr_name, value)
       raw_value = attribute_raw_value(record, attr_name) || value
       return if (@allow_nil && raw_value.nil?) || (@allow_blank && raw_value.blank?)
@@ -91,7 +77,7 @@ module ValidatesTimeliness
 
     def add_error(record, attr_name, message, value=nil)
       value = format_error_value(value) if value
-      message_options = { :message => options.fetch(:"#{message}_message", options[:message]), :restriction => value }
+      message_options = { :message => options[:"#{message}_message"], :restriction => value }
       record.errors.add(attr_name, message, message_options)
     end
 
@@ -101,8 +87,8 @@ module ValidatesTimeliness
     end
 
     def attribute_raw_value(record, attr_name)
-      record.respond_to?(:read_timeliness_attribute_before_type_cast) &&
-        record.read_timeliness_attribute_before_type_cast(attr_name.to_s)
+      record.respond_to?(:_timeliness_raw_value_for) &&
+        record._timeliness_raw_value_for(attr_name.to_s)
     end
 
     def timezone_aware?(record, attr_name)

lib/validates_timeliness/version.rb

@@ -1,3 +1,3 @@
 module ValidatesTimeliness
-  VERSION = '4.1.1'
+  VERSION = '3.0.14'
 end

spec/spec_helper.rb

@@ -5,16 +5,13 @@ 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 ]
@@ -27,15 +24,19 @@ 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
@@ -56,7 +57,6 @@ class PersonWithShim < Person
   include TestModelShim
 end
 
-ActiveRecord::Base.default_timezone = :utc
 ActiveRecord::Base.time_zone_aware_attributes = true
 ActiveRecord::Base.establish_connection({:adapter => 'sqlite3', :database => ':memory:'})
 ActiveRecord::Migration.verbose = false
@@ -73,8 +73,8 @@ end
 class Employee < ActiveRecord::Base
   attr_accessor :redefined_birth_date_called
   validates_date :birth_date, :allow_nil => true
-  validates_time :birth_time, :allow_nil => true
-  validates_datetime :birth_datetime, :allow_nil => true
+  validates_date :birth_time, :allow_nil => true
+  validates_date :birth_datetime, :allow_nil => true
 
   def birth_date=(value)
     self.redefined_birth_date_called = true
@@ -84,7 +84,7 @@ end
 
 RSpec.configure do |c|
   c.mock_with :rspec
-  c.include(TagMatcher)
+  c.include(RspecTagMatchers)
   c.include(ModelHelpers)
   c.include(ConfigHelper)
   c.before do

spec/support/model_helpers.rb

@@ -3,15 +3,15 @@ module ModelHelpers
   # Some test helpers from Rails source 
   def invalid!(attr_name, values, error = nil)
     with_each_person_value(attr_name, values) do |record, value|
-      expect(record).to be_invalid
-      expect(record.errors[attr_name].size).to be >= 1
-      expect(record.errors[attr_name].first).to eq(error) if error
+      record.should be_invalid
+      record.errors[attr_name].size.should >= 1
+      record.errors[attr_name].first.should == error if error
     end
   end
 
   def valid!(attr_name, values)
     with_each_person_value(attr_name, values) do |record, value|
-      expect(record).to be_valid
+      record.should be_valid
     end
   end
 

spec/support/mongoid.yml

@@ -0,0 +1,6 @@
+test:
+  sessions:
+    default:
+      database: mongoid
+      hosts:
+        - localhost:27017

spec/support/tag_matcher.rb

@@ -1,35 +0,0 @@
-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,6 +5,7 @@ module TestModel
   include ActiveModel::AttributeMethods
 
   included do
+    attribute_method_suffix ""
     attribute_method_suffix "="
     cattr_accessor :model_attributes
   end

spec/validates_timeliness/attribute_methods_spec.rb

@@ -1,6 +1,8 @@
-RSpec.describe ValidatesTimeliness::AttributeMethods do
-  it 'should define read_timeliness_attribute_before_type_cast instance method' do
-    expect(PersonWithShim.new).to respond_to(:read_timeliness_attribute_before_type_cast)
+require 'spec_helper'
+
+describe ValidatesTimeliness::AttributeMethods do
+  it 'should define _timeliness_raw_value_for instance method' do
+    PersonWithShim.new.should respond_to(:_timeliness_raw_value_for)
   end
 
   describe ".timeliness_validated_attributes" do
@@ -10,7 +12,7 @@ RSpec.describe ValidatesTimeliness::AttributeMethods do
       PersonWithShim.validates_time :birth_time
       PersonWithShim.validates_datetime :birth_datetime
 
-      expect(PersonWithShim.timeliness_validated_attributes).to eq([ :birth_date, :birth_time, :birth_datetime ])
+      PersonWithShim.timeliness_validated_attributes.should == [ :birth_date, :birth_time, :birth_datetime ]
     end
   end
   
@@ -29,13 +31,13 @@ RSpec.describe ValidatesTimeliness::AttributeMethods do
     it 'should cache attribute raw value' do
       r = PersonWithCache.new
       r.birth_datetime = date_string = '2010-01-01'
-      expect(r.read_timeliness_attribute_before_type_cast('birth_datetime')).to eq(date_string)
+      r._timeliness_raw_value_for('birth_datetime').should == date_string
     end
 
     it 'should not overwrite user defined methods' do
       e = Employee.new
       e.birth_date = '2010-01-01'
-      expect(e.redefined_birth_date_called).to be_truthy
+      e.redefined_birth_date_called.should be_true
     end
 
     it 'should be undefined if model class has dynamic attribute methods reset' do
@@ -44,13 +46,13 @@ RSpec.describe ValidatesTimeliness::AttributeMethods do
       r = PersonWithShim.new
       r.birth_date = Time.now
 
-      write_method = :birth_date=
+      write_method = RUBY_VERSION < '1.9' ? 'birth_date=' : :birth_date=
 
-      expect(PersonWithShim.send(:generated_timeliness_methods).instance_methods).to include(write_method)
+      PersonWithShim.send(:generated_timeliness_methods).instance_methods.should include(write_method)
 
       PersonWithShim.undefine_attribute_methods 
 
-      expect(PersonWithShim.send(:generated_timeliness_methods).instance_methods).not_to include(write_method)
+      PersonWithShim.send(:generated_timeliness_methods).instance_methods.should_not include(write_method)
     end
 
     context "with plugin parser" do
@@ -68,7 +70,7 @@ RSpec.describe ValidatesTimeliness::AttributeMethods do
       end
 
       it 'should parse a string value' do
-        expect(Timeliness::Parser).to receive(:parse)
+        Timeliness::Parser.should_receive(:parse)
         r = PersonWithParser.new
         r.birth_date = '2010-01-01'
       end
@@ -78,7 +80,7 @@ RSpec.describe ValidatesTimeliness::AttributeMethods do
 
   context "before_type_cast method" do
     it 'should not be defined if ORM does not support it' do
-      expect(PersonWithShim.new).not_to respond_to(:birth_datetime_before_type_cast)
+      PersonWithShim.new.should_not respond_to(:birth_datetime_before_type_cast)
     end
   end
 end

spec/validates_timeliness/conversion_spec.rb

@@ -1,4 +1,6 @@
-RSpec.describe ValidatesTimeliness::Conversion do
+require 'spec_helper'
+
+describe ValidatesTimeliness::Conversion do
   include ValidatesTimeliness::Conversion
 
   let(:options) { Hash.new }
@@ -10,68 +12,68 @@ RSpec.describe ValidatesTimeliness::Conversion do
   describe "#type_cast_value" do
     describe "for date type" do
       it "should return same value for date value" do
-        expect(type_cast_value(Date.new(2010, 1, 1), :date)).to eq(Date.new(2010, 1, 1))
+        type_cast_value(Date.new(2010, 1, 1), :date).should == Date.new(2010, 1, 1)
       end
 
       it "should return date part of time value" do
-        expect(type_cast_value(Time.mktime(2010, 1, 1, 0, 0, 0), :date)).to eq(Date.new(2010, 1, 1))
+        type_cast_value(Time.mktime(2010, 1, 1, 0, 0, 0), :date).should == Date.new(2010, 1, 1)
       end
 
       it "should return date part of datetime value" do
-        expect(type_cast_value(DateTime.new(2010, 1, 1, 0, 0, 0), :date)).to eq(Date.new(2010, 1, 1))
+        type_cast_value(DateTime.new(2010, 1, 1, 0, 0, 0), :date).should == Date.new(2010, 1, 1)
       end
 
       it 'should return nil for invalid value types' do
-        expect(type_cast_value(12, :date)).to eq(nil)
+        type_cast_value(12, :date).should == nil
       end
     end
 
     describe "for time type" do
       it "should return same value for time value matching dummy date part" do
-        expect(type_cast_value(Time.utc(2000, 1, 1, 0, 0, 0), :time)).to eq(Time.utc(2000, 1, 1, 0, 0, 0))
+        type_cast_value(Time.utc(2000, 1, 1, 0, 0, 0), :time).should == Time.utc(2000, 1, 1, 0, 0, 0)
       end
 
       it "should return dummy time value with same time part for time value with different date" do
-        expect(type_cast_value(Time.utc(2010, 1, 1, 0, 0, 0), :time)).to eq(Time.utc(2000, 1, 1, 0, 0, 0))
+        type_cast_value(Time.utc(2010, 1, 1, 0, 0, 0), :time).should == Time.utc(2000, 1, 1, 0, 0, 0)
       end
 
       it "should return dummy time only for date value" do
-        expect(type_cast_value(Date.new(2010, 1, 1), :time)).to eq(Time.utc(2000, 1, 1, 0, 0, 0))
+        type_cast_value(Date.new(2010, 1, 1), :time).should == Time.utc(2000, 1, 1, 0, 0, 0)
       end
 
       it "should return dummy date with time part for datetime value" do
-        expect(type_cast_value(DateTime.civil_from_format(:utc, 2010, 1, 1, 12, 34, 56), :time)).to eq(Time.utc(2000, 1, 1, 12, 34, 56))
+        type_cast_value(DateTime.civil_from_format(:utc, 2010, 1, 1, 12, 34, 56), :time).should == Time.utc(2000, 1, 1, 12, 34, 56)
       end
 
       it 'should return nil for invalid value types' do
-        expect(type_cast_value(12, :time)).to eq(nil)
+        type_cast_value(12, :time).should == nil
       end
     end
 
     describe "for datetime type" do
       it "should return Date as Time value" do
-        expect(type_cast_value(Date.new(2010, 1, 1), :datetime)).to eq(Time.local(2010, 1, 1, 0, 0, 0))
+        type_cast_value(Date.new(2010, 1, 1), :datetime).should == Time.local_time(2010, 1, 1, 0, 0, 0)
       end
 
       it "should return same Time value" do
         value = Time.utc(2010, 1, 1, 12, 34, 56)
-        expect(type_cast_value(Time.utc(2010, 1, 1, 12, 34, 56), :datetime)).to eq(value)
+        type_cast_value(Time.utc(2010, 1, 1, 12, 34, 56), :datetime).should == value
       end
 
       it "should return as Time with same component values" do
-        expect(type_cast_value(DateTime.civil_from_format(:utc, 2010, 1, 1, 12, 34, 56), :datetime)).to eq(Time.utc(2010, 1, 1, 12, 34, 56))
+        type_cast_value(DateTime.civil_from_format(:utc, 2010, 1, 1, 12, 34, 56), :datetime).should == 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)
-        expect(result).to eq(Time.zone.local(2010, 1, 1, 23, 34, 56))
-        expect(result.zone).to eq('AEDT')
+        result.should == Time.zone.local(2010, 1, 1, 23, 34, 56)
+        result.zone.should == 'EST'
       end
 
       it 'should return nil for invalid value types' do
-        expect(type_cast_value(12, :datetime)).to eq(nil)
+        type_cast_value(12, :datetime).should == nil
       end
     end
 
@@ -80,41 +82,41 @@ RSpec.describe ValidatesTimeliness::Conversion do
 
       it "should ignore usec on time values when evaluated" do
         value = Time.utc(2010, 1, 1, 12, 34, 56, 10000)
-        expect(type_cast_value(value, :datetime)).to eq(Time.utc(2010, 1, 1, 12, 34, 56))
+        type_cast_value(value, :datetime).should == Time.utc(2010, 1, 1, 12, 34, 56)
       end
 
       it "should ignore usec and return time in correct zone if timezone aware" do
         @timezone_aware = true
         value = Time.utc(2010, 1, 1, 12, 34, 56, 10000)
         result = type_cast_value(value, :datetime)
-        expect(result).to eq(Time.zone.local(2010, 1, 1, 23, 34, 56))
-        expect(result.zone).to eq('AEDT')
+        result.should == Time.zone.local(2010, 1, 1, 23, 34, 56)
+        result.zone.should == 'EST'
       end
     end
   end
 
   describe "#dummy_time" do
     it 'should return Time with dummy date values but same time components' do
-      expect(dummy_time(Time.utc(2010, 11, 22, 12, 34, 56))).to eq(Time.utc(2000, 1, 1, 12, 34, 56))
+      dummy_time(Time.utc(2010, 11, 22, 12, 34, 56)).should == Time.utc(2000, 1, 1, 12, 34, 56)
     end
 
     it 'should return same value for Time which already has dummy date values' do
-      expect(dummy_time(Time.utc(2000, 1, 1, 12, 34, 56))).to eq(Time.utc(2000, 1, 1, 12, 34, 56))
+      dummy_time(Time.utc(2000, 1, 1, 12, 34, 56)).should == 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
-      expect(dummy_time(Date.new(2010, 11, 22))).to eq(Time.utc(2000, 1, 1, 0, 0, 0))
+      dummy_time(Date.new(2010, 11, 22)).should == 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
-          expect(dummy_time(Time.utc(1999, 11, 22, 12, 34, 56))).to eq(Time.utc(2010, 1, 1, 12, 34, 56))
+          dummy_time(Time.utc(1999, 11, 22, 12, 34, 56)).should == Time.utc(2010, 1, 1, 12, 34, 56)
         end
       end
     end
@@ -125,56 +127,56 @@ RSpec.describe ValidatesTimeliness::Conversion do
 
     it 'should return Date object as is' do
       value = Date.new(2010,1,1)
-      expect(evaluate_option_value(value, person)).to eq(value)
+      evaluate_option_value(value, person).should == value
     end
 
     it 'should return Time object as is' do
       value = Time.mktime(2010,1,1)
-      expect(evaluate_option_value(value, person)).to eq(value)
+      evaluate_option_value(value, person).should == value
     end
 
     it 'should return DateTime object as is' do
       value = DateTime.new(2010,1,1,0,0,0)
-      expect(evaluate_option_value(value, person)).to eq(value)
+      evaluate_option_value(value, person).should == value
     end
 
     it 'should return Time value returned from proc with 0 arity' do
       value = Time.mktime(2010,1,1)
-      expect(evaluate_option_value(lambda { value }, person)).to eq(value)
+      evaluate_option_value(lambda { value }, person).should == value
     end
 
     it 'should return Time value returned by record attribute call in proc arity of 1' do
       value = Time.mktime(2010,1,1)
       person.birth_time = value
-      expect(evaluate_option_value(lambda {|r| r.birth_time }, person)).to eq(value)
+      evaluate_option_value(lambda {|r| r.birth_time }, person).should == value
     end
 
     it 'should return Time value for attribute method symbol which returns Time' do
       value = Time.mktime(2010,1,1)
       person.birth_time = value
-      expect(evaluate_option_value(:birth_time, person)).to eq(value)
+      evaluate_option_value(:birth_time, person).should == value
     end
 
     it 'should return Time value is default zone from string time value' do
       value = '2010-01-01 12:00:00'
-      expect(evaluate_option_value(value, person)).to eq(Time.utc(2010,1,1,12,0,0))
+      evaluate_option_value(value, person).should == Time.utc(2010,1,1,12,0,0)
     end
 
     it 'should return Time value is current zone from string time value if timezone aware' do
       @timezone_aware = true
       value = '2010-01-01 12:00:00'
-      expect(evaluate_option_value(value, person)).to eq(Time.zone.local(2010,1,1,12,0,0))
+      evaluate_option_value(value, person).should == Time.zone.local(2010,1,1,12,0,0)
     end
 
     it 'should return Time value in default zone from proc which returns string time' do
       value = '2010-01-01 12:00:00'
-      expect(evaluate_option_value(lambda { value }, person)).to eq(Time.utc(2010,1,1,12,0,0))
+      evaluate_option_value(lambda { value }, person).should == Time.utc(2010,1,1,12,0,0)
     end
 
     it 'should return Time value for attribute method symbol which returns string time value' do
       value = '2010-01-01 12:00:00'
       person.birth_time = value
-      expect(evaluate_option_value(:birth_time, person)).to eq(Time.local(2010,1,1,12,0,0))
+      evaluate_option_value(:birth_time, person).should == Time.utc(2010,1,1,12,0,0)
     end
 
     context "restriction shorthand" do
@@ -183,17 +185,17 @@ RSpec.describe ValidatesTimeliness::Conversion do
       end
 
       it 'should evaluate :now as current time' do
-        expect(evaluate_option_value(:now, person)).to eq(Time.now)
+        evaluate_option_value(:now, person).should == Time.now
       end
 
       it 'should evaluate :today as current time' do
-        expect(evaluate_option_value(:today, person)).to eq(Date.today)
+        evaluate_option_value(:today, person).should == Date.today
       end
 
       it 'should not use shorthand if symbol if is record method' do
         time = 1.day.from_now
-        allow(person).to receive(:now).and_return(time)
-        expect(evaluate_option_value(:now, person)).to eq(time)
+        person.stub!(:now).and_return(time)
+        evaluate_option_value(:now, person).should == time
       end
     end
   end
@@ -203,7 +205,7 @@ RSpec.describe ValidatesTimeliness::Conversion do
       with_config(:use_plugin_parser, true)
 
       it 'should use timeliness' do
-        expect(Timeliness::Parser).to receive(:parse)
+        Timeliness::Parser.should_receive(:parse)
         parse('2000-01-01')
       end
     end
@@ -213,20 +215,20 @@ RSpec.describe ValidatesTimeliness::Conversion do
 
       it 'should use Time.zone.parse attribute is timezone aware' do
         @timezone_aware = true
-        expect(Time.zone).to 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'
-        expect(value).to receive(:to_time)
+        value.should_receive(:to_time)
         parse(value)
       end
     end
 
     it 'should return nil if value is nil' do
-      expect(parse(nil)).to be_nil
+      parse(nil).should be_nil
     end
   end
 end

spec/validates_timeliness/extensions/date_time_select_spec.rb

@@ -1,4 +1,6 @@
-RSpec.describe 'ValidatesTimeliness::Extensions::DateTimeSelect' do
+require 'spec_helper'
+
+describe ValidatesTimeliness::Extensions::DateTimeSelect do
   include ActionView::Helpers::DateHelper
   attr_reader :person, :params
 
@@ -109,7 +111,7 @@ RSpec.describe 'ValidatesTimeliness::Extensions::DateTimeSelect' do
       @output = date_select(:person, :birth_date, :include_blank => true, :discard_day => true)
       should_have_datetime_selected(:birth_date, :year => 2009, :month => 'February')
       should_not_have_datetime_selected(:birth_time, :day)
-      expect(@output).to have_tag("input[id=person_birth_date_3i][type=hidden][value='1']")
+      @output.should have_tag("input[id=person_birth_date_3i][type=hidden][value='1']")
     end
   end
 
@@ -148,15 +150,14 @@ RSpec.describe 'ValidatesTimeliness::Extensions::DateTimeSelect' do
   def should_have_datetime_selected(field, datetime_hash)
     datetime_hash.each do |key, value|
       index = {:year => 1, :month => 2, :day => 3, :hour => 4, :min => 5, :sec => 6}[key]
-      expect(@output).to have_tag("select[id=person_#{field}_#{index}i] option[selected=selected]", value.to_s)
+      @output.should 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]
-      expect(@output).not_to have_tag("select[id=person_#{attribute}_#{index}i] option[selected=selected]")
+      @output.should_not have_tag("select[id=person_#{attribute}_#{index}i] option[selected=selected]")
     end
   end
-  
 end

spec/validates_timeliness/extensions/multiparameter_handler_spec.rb

@@ -1,36 +1,38 @@
-RSpec.describe 'ValidatesTimeliness::Extensions::MultiparameterHandler' do
+require 'spec_helper'
+
+describe ValidatesTimeliness::Extensions::MultiparameterHandler do
 
   context "time column" do
     it 'should assign a string value for invalid date portion' do
       employee = record_with_multiparameter_attribute(:birth_datetime, [2000, 2, 31, 12, 0, 0])
-      expect(employee.birth_datetime_before_type_cast).to eq '2000-02-31 12:00:00'
+      employee.birth_datetime_before_type_cast.should eq '2000-02-31 12:00:00'
     end
      
     it 'should assign a Time value for valid datetimes' do
       employee = record_with_multiparameter_attribute(:birth_datetime, [2000, 2, 28, 12, 0, 0])
-      expect(employee.birth_datetime_before_type_cast).to eq Time.zone.local(2000, 2, 28, 12, 0, 0)
+      employee.birth_datetime_before_type_cast.should eq Time.local(2000, 2, 28, 12, 0, 0)
     end
 
     it 'should assign a string value for incomplete time' do
       employee = record_with_multiparameter_attribute(:birth_datetime, [2000, nil, nil])
-      expect(employee.birth_datetime_before_type_cast).to eq '2000-00-00'
+      employee.birth_datetime_before_type_cast.should eq '2000-00-00'
     end
   end
 
   context "date column" do
     it 'should assign a string value for invalid date' do
       employee = record_with_multiparameter_attribute(:birth_date, [2000, 2, 31])
-      expect(employee.birth_date_before_type_cast).to eq '2000-02-31'
+      employee.birth_date_before_type_cast.should eq '2000-02-31'
     end
 
     it 'should assign a Date value for valid date' do
       employee = record_with_multiparameter_attribute(:birth_date, [2000, 2, 28])
-      expect(employee.birth_date_before_type_cast).to eq Date.new(2000, 2, 28)
+      employee.birth_date_before_type_cast.should eq Date.new(2000, 2, 28)
     end
 
     it 'should assign a string value for incomplete date' do
       employee = record_with_multiparameter_attribute(:birth_date, [2000, nil, nil])
-      expect(employee.birth_date_before_type_cast).to eq '2000-00-00'
+      employee.birth_date_before_type_cast.should eq '2000-00-00'
     end
   end
 
@@ -39,5 +41,4 @@ RSpec.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,28 +1,30 @@
-RSpec.describe ValidatesTimeliness, 'HelperMethods' do
+require 'spec_helper'
+
+describe ValidatesTimeliness, 'HelperMethods' do
   let(:record) { Person.new }
   
   it 'should define class validation methods' do
-    expect(Person).to respond_to(:validates_date)
-    expect(Person).to respond_to(:validates_time)
-    expect(Person).to respond_to(:validates_datetime)
+    Person.should respond_to(:validates_date)
+    Person.should respond_to(:validates_time)
+    Person.should respond_to(:validates_datetime)
   end
 
   it 'should define instance validation methods' do
-    expect(record).to respond_to(:validates_date)
-    expect(record).to respond_to(:validates_time)
-    expect(record).to respond_to(:validates_datetime)
+    record.should respond_to(:validates_date)
+    record.should respond_to(:validates_time)
+    record.should respond_to(:validates_datetime)
   end
 
   it 'should validate instance using class validation defined' do
     Person.validates_date :birth_date
     record.valid?
 
-    expect(record.errors[:birth_date]).not_to be_empty
+    record.errors[:birth_date].should_not be_empty
   end
 
   it 'should validate instance using instance valiation method' do
     record.validates_date :birth_date
 
-    expect(record.errors[:birth_date]).not_to be_empty
+    record.errors[:birth_date].should_not be_empty
   end
 end

spec/validates_timeliness/orm/active_record_spec.rb

@@ -1,44 +1,46 @@
-RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
+require 'spec_helper'
+
+describe ValidatesTimeliness, 'ActiveRecord' do
 
   context "validation methods" do
     let(:record) { Employee.new }
 
     it 'should be defined for the class' do
-      expect(ActiveRecord::Base).to respond_to(:validates_date)
-      expect(ActiveRecord::Base).to respond_to(:validates_time)
-      expect(ActiveRecord::Base).to respond_to(:validates_datetime)
+      ActiveRecord::Base.should respond_to(:validates_date)
+      ActiveRecord::Base.should respond_to(:validates_time)
+      ActiveRecord::Base.should respond_to(:validates_datetime)
     end
 
     it 'should defines for the instance' do
-      expect(record).to respond_to(:validates_date)
-      expect(record).to respond_to(:validates_time)
-      expect(record).to respond_to(:validates_datetime)
+      record.should respond_to(:validates_date)
+      record.should respond_to(:validates_time)
+      record.should respond_to(:validates_datetime)
     end
 
     it "should validate a valid value string" do
       record.birth_date = '2012-01-01'
 
       record.valid?
-      expect(record.errors[:birth_date]).to be_empty
+      record.errors[:birth_date].should be_empty
     end
 
     it "should validate a invalid value string" do
       record.birth_date = 'not a date'
 
       record.valid?
-      expect(record.errors[:birth_date]).not_to be_empty
+      record.errors[:birth_date].should_not be_empty
     end
 
     it "should validate a nil value" do
       record.birth_date = nil
 
       record.valid?
-      expect(record.errors[:birth_date]).to be_empty
+      record.errors[:birth_date].should be_empty
     end
   end
 
   it 'should determine type for attribute' do
-    expect(Employee.timeliness_attribute_type(:birth_date)).to eq :date
+    Employee.timeliness_attribute_type(:birth_date).should eq :date
   end
 
   context 'attribute timezone awareness' do
@@ -56,17 +58,17 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
 
     context 'for column attribute' do
       it 'should be detected from column type' do
-        expect(klass.timeliness_attribute_timezone_aware?(:birth_date)).to be_falsey
-        expect(klass.timeliness_attribute_timezone_aware?(:birth_time)).to be_falsey
-        expect(klass.timeliness_attribute_timezone_aware?(:birth_datetime)).to be_truthy
+        klass.timeliness_attribute_timezone_aware?(:birth_date).should be_false
+        klass.timeliness_attribute_timezone_aware?(:birth_time).should be_false
+        klass.timeliness_attribute_timezone_aware?(:birth_datetime).should be_true
       end
     end
 
     context 'for non-column attribute' do
       it 'should be detected from the validation type' do
-        expect(klass.timeliness_attribute_timezone_aware?(:some_date)).to be_falsey
-        expect(klass.timeliness_attribute_timezone_aware?(:some_time)).to be_falsey
-        expect(klass.timeliness_attribute_timezone_aware?(:some_datetime)).to be_truthy
+        klass.timeliness_attribute_timezone_aware?(:some_date).should be_false
+        klass.timeliness_attribute_timezone_aware?(:some_time).should be_false
+        klass.timeliness_attribute_timezone_aware?(:some_datetime).should be_true
       end
     end
   end
@@ -86,7 +88,7 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
         it 'should store raw value' do
           record.birth_datetime = datetime_string = '2010-01-01 12:30'
 
-          expect(record.read_timeliness_attribute_before_type_cast('birth_datetime')).to eq datetime_string
+          record._timeliness_raw_value_for('birth_datetime').should eq datetime_string
         end
       end
 
@@ -94,7 +96,7 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
         it 'should store raw value' do
           record.birth_date = date_string = '2010-01-01'
 
-          expect(record.read_timeliness_attribute_before_type_cast('birth_date')).to eq date_string
+          record._timeliness_raw_value_for('birth_date').should eq date_string
         end
       end
 
@@ -102,7 +104,7 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
         it 'should store raw value' do
           record.birth_time = time_string = '12:12'
 
-          expect(record.read_timeliness_attribute_before_type_cast('birth_time')).to eq time_string
+          record._timeliness_raw_value_for('birth_time').should eq time_string
         end
       end
     end
@@ -120,13 +122,13 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
 
       context "for a date column" do
         it 'should parse a string value' do
-          expect(Timeliness::Parser).to receive(:parse)
+          Timeliness::Parser.should_receive(:parse)
 
           record.birth_date = '2010-01-01'
         end
 
         it 'should parse a invalid string value as nil' do
-          expect(Timeliness::Parser).to receive(:parse)
+          Timeliness::Parser.should_receive(:parse)
 
           record.birth_date = 'not valid'
         end
@@ -134,20 +136,20 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
         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)
+          record.birth_date.should be_kind_of(Date)
+          record.birth_date.should eq Date.new(2010, 1, 1)
         end
       end
 
       context "for a time column" do
         it 'should parse a string value' do
-          expect(Timeliness::Parser).to receive(:parse)
+          Timeliness::Parser.should_receive(:parse)
 
           record.birth_time = '12:30'
         end
 
         it 'should parse a invalid string value as nil' do
-          expect(Timeliness::Parser).to receive(:parse)
+          Timeliness::Parser.should_receive(:parse)
 
           record.birth_time = 'not valid'
         end
@@ -155,8 +157,8 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
         it 'should store a Time value after parsing string' do
           record.birth_time = '12:30'
 
-          expect(record.birth_time).to be_kind_of(Time)
-          expect(record.birth_time).to eq Time.utc(2000, 1, 1, 12, 30)
+          record.birth_time.should be_kind_of(Time)
+          record.birth_time.should eq Time.utc(2000, 1, 1, 12, 30)
         end
       end
 
@@ -164,13 +166,13 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
         with_config(:default_timezone, 'Australia/Melbourne')
 
         it 'should parse a string value' do
-          expect(Timeliness::Parser).to receive(:parse)
+          Timeliness::Parser.should_receive(:parse)
 
           record.birth_datetime = '2010-01-01 12:00'
         end
 
         it 'should parse a invalid string value as nil' do
-          expect(Timeliness::Parser).to receive(:parse)
+          Timeliness::Parser.should_receive(:parse)
 
           record.birth_datetime = 'not valid'
         end
@@ -178,13 +180,13 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
         it 'should parse string into Time value' do
           record.birth_datetime = '2010-01-01 12:00'
 
-          expect(record.birth_datetime).to be_kind_of(Time)
+          record.birth_datetime.should be_kind_of(Time)
         end
 
         it 'should parse string as current timezone' do
           record.birth_datetime = '2010-06-01 12:00'
 
-          expect(record.birth_datetime.utc_offset).to eq Time.zone.utc_offset
+          record.birth_datetime.utc_offset.should eq Time.zone.utc_offset
         end
       end
     end
@@ -197,7 +199,7 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
       
       record.reload
 
-      expect(record.read_timeliness_attribute_before_type_cast('birth_date')).to be_nil
+      record._timeliness_raw_value_for('birth_date').should be_nil
     end
   end
 
@@ -205,13 +207,13 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
     let(:record) { Employee.new }
 
     it 'should be defined on class if ORM supports it' do
-      expect(record).to respond_to(:birth_datetime_before_type_cast)
+      record.should respond_to(:birth_datetime_before_type_cast)
     end
 
     it 'should return original value' do
       record.birth_datetime = date_string = '2010-01-01'
 
-      expect(record.birth_datetime_before_type_cast).to eq date_string
+      record.birth_datetime_before_type_cast.should eq date_string
     end
 
     it 'should return attribute if no attribute assignment has been made' do
@@ -219,7 +221,7 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
       Employee.create(:birth_datetime => datetime)
 
       record = Employee.last
-      expect(record.birth_datetime_before_type_cast).to match(/#{datetime.utc.to_s[0...-4]}/)
+      record.birth_datetime_before_type_cast.should match(/2010-01-01 00:00:00/)
     end
 
     context "with plugin parser" do
@@ -228,7 +230,7 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
       it 'should return original value' do
         record.birth_datetime = date_string = '2010-01-31'
 
-        expect(record.birth_datetime_before_type_cast).to eq date_string
+        record.birth_datetime_before_type_cast.should eq date_string
       end
     end
 
@@ -236,19 +238,7 @@ RSpec.describe ValidatesTimeliness, 'ActiveRecord' do
 
   context "define_attribute_methods" do
     it "returns a falsy value if the attribute methods have already been generated" do
-      expect(Employee.define_attribute_methods).to be_falsey
-    end
-  end
-
-  context "undefine_attribute_methods" do
-    it "returns remove attribute methods that have already been generated" do
-      Employee.define_attribute_methods
-
-      expect(Employee.instance_methods).to include(:birth_datetime)
-
-      Employee.undefine_attribute_methods
-
-      expect(Employee.instance_methods).to_not include(:birth_datetime)
+      Employee.define_attribute_methods.should be_false
     end
   end
 end

spec/validates_timeliness/orm/mongoid_spec.rb

@@ -0,0 +1,233 @@
+require 'spec_helper'
+
+# Try loading mongoid and connecting. Otherwise, abort and skip spec.
+begin
+
+require 'mongoid'
+require 'mongoid/version'
+require 'validates_timeliness/orm/mongoid'
+
+if Mongoid::VERSION >= '3.0'
+  Mongoid.load!("spec/support/mongoid.yml", :test)
+else
+  require 'mongo'
+  Mongoid.configure do |config|
+    name = "validates_timeliness_test"
+    host = "localhost"
+    config.master = Mongo::Connection.new.db(name)
+    config.persist_in_safe_mode = false
+  end
+end
+
+describe ValidatesTimeliness, 'Mongoid' do
+
+  class Article
+    include Mongoid::Document
+    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
+  end
+
+  context "validation methods" do
+    let(:record) { Article.new }
+
+    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
+      record.should respond_to(:validates_date)
+      record.should respond_to(:validates_time)
+      record.should respond_to(:validates_datetime)
+    end
+
+    it "should validate a valid value string" do
+      record.publish_date = '2012-01-01'
+
+      record.valid?
+      record.errors[:publish_date].should be_empty
+    end
+
+    it "should validate an invalid time value string" do
+      begin
+        record.publish_time = 'not valid'
+      rescue
+      end
+
+      record.valid?
+      record.errors[:publish_time].should_not be_empty
+    end
+
+    it "should validate an invalid date value string" do
+      begin
+        record.publish_date = 'not valid'
+      rescue
+      end
+
+      record.valid?
+      record.errors[:publish_date].should_not be_empty
+    end
+
+    it "should validate an invalid datetime value string" do
+      begin
+        record.publish_datetime = 'not valid'
+      rescue
+      end
+
+      record.valid?
+      record.errors[:publish_datetime].should_not be_empty
+    end
+
+    it "should accept a nil time value" do
+      record.publish_date = nil
+
+      record.valid?
+      record.errors[:publish_time].should be_empty
+    end
+
+    it "should accept a nil date value" do
+      record.publish_date = nil
+
+      record.valid?
+      record.errors[:publish_date].should be_empty
+    end
+
+    it "should accept a nil datetime value" do
+      record.publish_datetime = nil
+
+      record.valid?
+      record.errors[:publish_datetime].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
+    let(:record) { Article.new }
+
+    it 'should cache attribute raw value' do
+      record.publish_datetime = date_string = '2010-01-01'
+
+      record._timeliness_raw_value_for('publish_datetime').should == date_string
+    end
+
+    context "with plugin parser" do
+      let(:record) { ArticleWithParser.new }
+
+      class ArticleWithParser
+        include Mongoid::Document
+        field :publish_date, :type => Date
+        field :publish_time, :type => Time
+        field :publish_datetime, :type => DateTime
+
+        ValidatesTimeliness.use_plugin_parser = true
+        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 "for a date column" do
+        it 'should parse a string value' do
+          Timeliness::Parser.should_receive(:parse)
+
+          record.publish_date = '2010-01-01'
+        end
+
+        it 'should parse a invalid string value as nil' do
+          Timeliness::Parser.should_receive(:parse)
+
+          record.publish_date = 'not valid'
+
+          record.publish_date.should be_nil
+        end
+
+        it 'should store a Date value after parsing string' do
+          record.publish_date = '2010-01-01'
+
+          record.publish_date.should be_kind_of(Date)
+          record.publish_date.should eq Date.new(2010, 1, 1)
+        end
+      end
+
+      context "for a time column" do
+        it 'should parse a string value' do
+          Timeliness::Parser.should_receive(:parse)
+
+          record.publish_time = '12:30'
+        end
+
+        it 'should parse a invalid string value as nil' do
+          Timeliness::Parser.should_receive(:parse)
+
+          record.publish_time = 'not valid'
+        end
+
+        it 'should store a Time value after parsing string' do
+          record.publish_time = '12:30'
+
+          record.publish_time.should be_kind_of(Time)
+          record.publish_time.should eq Time.utc(2000, 1, 1, 12, 30)
+        end
+      end
+
+      context "for a datetime column" do
+        with_config(:default_timezone, 'Australia/Melbourne')
+
+        it 'should parse a string value' do
+          Timeliness::Parser.should_receive(:parse)
+
+          record.publish_datetime = '2010-01-01 12:00'
+        end
+
+        it 'should parse a invalid string value as nil' do
+          Timeliness::Parser.should_receive(:parse)
+
+          record.publish_datetime = 'not valid'
+
+          record.publish_datetime.should be_nil
+        end
+
+        it 'should parse string into DateTime value' do
+          record.publish_datetime = '2010-01-01 12:00'
+
+          record.publish_datetime.should be_kind_of(DateTime)
+        end
+
+        pending 'should parse string as current timezone' do
+          record.publish_datetime = '2010-06-01 12:00'
+
+          record.publish_datetime.utc_offset.should eq Time.zone.utc_offset
+        end
+      end
+    end
+  end
+
+  context "cached value" do
+    it 'should be cleared on reload' do
+      record = Article.create!
+      record.publish_date = '2010-01-01'
+      record.reload
+      record._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

@@ -1,22 +0,0 @@
-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,4 +1,6 @@
-RSpec.describe ValidatesTimeliness::Validator, ":after option" do
+require 'spec_helper'
+
+describe ValidatesTimeliness::Validator, ":after option" do
   describe "for date type" do
     before do
       Person.validates_date :birth_date, :after => Date.new(2010, 1, 1)
@@ -23,15 +25,15 @@ RSpec.describe ValidatesTimeliness::Validator, ":after option" do
     end
 
     it "should not be valid for same time as restriction" do
-      invalid!(:birth_time, Time.local(2000, 1, 1, 12, 0, 0), 'must be after 12:00:00')
+      invalid!(:birth_time, Time.local_time(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(2000, 1, 1, 11, 59, 59), 'must be after 12:00:00')
+      invalid!(:birth_time, Time.local_time(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(2000, 1, 1, 12, 00, 01))
+      valid!(:birth_time, Time.local_time(2000, 1, 1, 12, 00, 01))
     end
   end
 

spec/validates_timeliness/validator/before_spec.rb

@@ -1,4 +1,6 @@
-RSpec.describe ValidatesTimeliness::Validator, ":before option" do
+require 'spec_helper'
+
+describe ValidatesTimeliness::Validator, ":before option" do
   describe "for date type" do
     before do
       Person.validates_date :birth_date, :before => Date.new(2010, 1, 1)
@@ -23,15 +25,15 @@ RSpec.describe ValidatesTimeliness::Validator, ":before option" do
     end
 
     it "should not be valid for time after restriction" do
-      invalid!(:birth_time, Time.local(2000, 1, 1, 12, 00, 01), 'must be before 12:00:00')
+      invalid!(:birth_time, Time.local_time(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(2000, 1, 1, 12, 0, 0), 'must be before 12:00:00')
+      invalid!(:birth_time, Time.local_time(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(2000, 1, 1, 11, 59, 59))
+      valid!(:birth_time, Time.local_time(2000, 1, 1, 11, 59, 59))
     end
   end
 

spec/validates_timeliness/validator/is_at_spec.rb

@@ -1,6 +1,8 @@
-RSpec.describe ValidatesTimeliness::Validator, ":is_at option" do
+require 'spec_helper'
+
+describe ValidatesTimeliness::Validator, ":is_at option" do
   before do
-    Timecop.freeze(Time.local(2010, 1, 1, 0, 0, 0))
+    Timecop.freeze(Time.local_time(2010, 1, 1, 0, 0, 0))
   end
 
   describe "for date type" do
@@ -27,15 +29,15 @@ RSpec.describe ValidatesTimeliness::Validator, ":is_at option" do
     end
 
     it "should not be valid for time before restriction" do
-      invalid!(:birth_time, Time.local(2000, 1, 1, 11, 59, 59), 'must be at 12:00:00')
+      invalid!(:birth_time, Time.local_time(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(2000, 1, 1, 12, 00, 01), 'must be at 12:00:00')
+      invalid!(:birth_time, Time.local_time(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(2000, 1, 1, 12, 0, 0))
+      valid!(:birth_time, Time.local_time(2000, 1, 1, 12, 0, 0))
     end
   end
 

spec/validates_timeliness/validator/on_or_after_spec.rb

@@ -1,4 +1,6 @@
-RSpec.describe ValidatesTimeliness::Validator, ":on_or_after option" do
+require 'spec_helper'
+
+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)
@@ -23,15 +25,15 @@ RSpec.describe ValidatesTimeliness::Validator, ":on_or_after option" do
     end
 
     it "should not be valid for time before restriction" do
-      invalid!(:birth_time, Time.local(2000, 1, 1, 11, 59, 59), 'must be on or after 12:00:00')
+      invalid!(:birth_time, Time.local_time(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(2000, 1, 1, 12, 00, 01))
+      valid!(:birth_time, Time.local_time(2000, 1, 1, 12, 00, 01))
     end
 
     it "should be valid for same time as restriction" do
-      valid!(:birth_time, Time.local(2000, 1, 1, 12, 0, 0))
+      valid!(:birth_time, Time.local_time(2000, 1, 1, 12, 0, 0))
     end
   end
 

spec/validates_timeliness/validator/on_or_before_spec.rb

@@ -1,4 +1,6 @@
-RSpec.describe ValidatesTimeliness::Validator, ":on_or_before option" do
+require 'spec_helper'
+
+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)
@@ -23,15 +25,15 @@ RSpec.describe ValidatesTimeliness::Validator, ":on_or_before option" do
     end
 
     it "should not be valid for time after restriction" do
-      invalid!(:birth_time, Time.local(2000, 1, 1, 12, 00, 01), 'must be on or before 12:00:00')
+      invalid!(:birth_time, Time.local_time(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(2000, 1, 1, 11, 59, 59))
+      valid!(:birth_time, Time.local_time(2000, 1, 1, 11, 59, 59))
     end
 
     it "should be valid for same time as restriction" do
-      valid!(:birth_time, Time.local(2000, 1, 1, 12, 0, 0))
+      valid!(:birth_time, Time.local_time(2000, 1, 1, 12, 0, 0))
     end
   end
 

spec/validates_timeliness/validator_spec.rb

@@ -1,27 +1,29 @@
-RSpec.describe ValidatesTimeliness::Validator do
+require 'spec_helper'
+
+describe ValidatesTimeliness::Validator do
   before do
-    Timecop.freeze(Time.local(2010, 1, 1, 0, 0, 0))
+    Timecop.freeze(Time.local_time(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}
-      expect(Person.validators.select { |v| v.is_a?(ActiveModel::Validations::TimelinessValidator) }.size).to eq(1)
+      Person.validators.should have(1).kind_of(ActiveModel::Validations::TimelinessValidator)
       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)}
-      expect(Person.validators.first.type).to eq(:datetime)
+      Person.validators.first.type.should == :datetime
     end
 
     it 'should add attribute to timeliness attributes set' do
-      expect(PersonWithShim.timeliness_validated_attributes).not_to include(:birth_time)
+      PersonWithShim.timeliness_validated_attributes.should_not include(:birth_time)
 
       PersonWithShim.validates :birth_time, :timeliness => {:is_at => "12:30"}
 
-      expect(PersonWithShim.timeliness_validated_attributes).to include(:birth_time)
+      PersonWithShim.timeliness_validated_attributes.should include(:birth_time)
     end
   end
 
@@ -33,10 +35,10 @@ RSpec.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
-    allow(record).to receive(:birth_date).and_return(nil)
-    allow(record).to receive(:read_timeliness_attribute_before_type_cast).and_return("Not a date")
-    expect(record).not_to be_valid
-    expect(record.errors[:birth_date].first).to eq('is not a valid date')
+    record.stub!(:birth_date).and_return(nil)
+    record.stub!(:_timeliness_raw_value_for).and_return("Not a date")
+    record.should_not be_valid
+    record.errors[:birth_date].first.should == 'is not a valid date'
   end
 
   describe ":allow_nil option" do
@@ -58,7 +60,7 @@ RSpec.describe ValidatesTimeliness::Validator do
         p = PersonWithShim.new
         p.birth_date = 'bogus'
 
-        expect(p).not_to be_valid
+        p.should_not be_valid
       end
     end
   end
@@ -82,32 +84,18 @@ RSpec.describe ValidatesTimeliness::Validator do
         p = PersonWithShim.new
         p.birth_date = 'bogus'
 
-        expect(p).not_to be_valid
+        p.should_not 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]
-        expect(Person.validators.first.options[:on_or_after]).to eq(on_or_after)
-        expect(Person.validators.first.options[:on_or_before]).to eq(on_or_before)
+        Person.validators.first.options[:on_or_after].should == on_or_after
+        Person.validators.first.options[:on_or_before].should == 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)
@@ -119,27 +107,14 @@ RSpec.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
-        expect(Person.validators.first.options[:on_or_after]).to eq(on_or_after)
-        expect(Person.validators.first.options[:on_or_before]).to eq(on_or_before)
+        Person.validators.first.options[:on_or_after].should == on_or_after
+        Person.validators.first.options[:on_or_before].should == 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
@@ -171,13 +146,13 @@ RSpec.describe ValidatesTimeliness::Validator do
     it "should be valid when value matches format" do
       person.birth_date = '11-12-1913'
       person.valid?
-      expect(person.errors[:birth_date]).to be_empty
+      person.errors[:birth_date].should be_empty
     end
 
     it "should not be valid when value does not match format" do
       person.birth_date = '1913-12-11'
       person.valid?
-      expect(person.errors[:birth_date]).to include('is not a valid date')
+      person.errors[:birth_date].should include('is not a valid date')
     end
   end
 
@@ -191,21 +166,21 @@ RSpec.describe ValidatesTimeliness::Validator do
     it "should be added when ignore_restriction_errors is false" do
       with_config(:ignore_restriction_errors, false) do
         person.valid?
-        expect(person.errors[:birth_date].first).to match("Error occurred validating birth_date")
+        person.errors[:birth_date].first.should 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?
-        expect(person.errors[:birth_date]).to be_empty
+        person.errors[:birth_date].should be_empty
       end
     end
 
     it 'should exit on first error' do
       with_config(:ignore_restriction_errors, false) do
         person.valid?
-        expect(person.errors[:birth_date].size).to eq(1)
+        person.errors[:birth_date].should have(1).items
       end
     end
   end
@@ -214,17 +189,17 @@ RSpec.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)
-        expect(validator.format_error_value(Date.new(2010,1,1))).to eq('2010-01-01')
+        validator.format_error_value(Date.new(2010,1,1)).should == '2010-01-01'
       end
 
       it 'should format time error value as hh:nn:ss' do
         validator = ValidatesTimeliness::Validator.new(:attributes => [:birth_time], :type => :time)
-        expect(validator.format_error_value(Time.mktime(2010,1,1,12,34,56))).to eq('12:34:56')
+        validator.format_error_value(Time.mktime(2010,1,1,12,34,56)).should == '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)
-        expect(validator.format_error_value(Time.mktime(2010,1,1,12,34,56))).to eq('2010-01-01 12:34:56')
+        validator.format_error_value(Time.mktime(2010,1,1,12,34,56)).should == '2010-01-01 12:34:56'
       end
     end
 
@@ -235,7 +210,7 @@ RSpec.describe ValidatesTimeliness::Validator do
 
       it 'should use the default format for the type' do
         validator = ValidatesTimeliness::Validator.new(:attributes => [:birth_date], :type => :date)
-        expect(validator.format_error_value(Date.new(2010,1,1))).to eq('2010-01-01')
+        validator.format_error_value(Date.new(2010,1,1)).should == '2010-01-01'
       end
 
       after :all do
@@ -249,7 +224,7 @@ RSpec.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,39 +1,41 @@
-RSpec.describe ValidatesTimeliness do
+require 'spec_helper'
+
+describe ValidatesTimeliness do
 
   it 'should alias use_euro_formats to remove_us_formats on Timeliness gem' do
-    expect(Timeliness).to respond_to(:remove_us_formats) 
+    Timeliness.should respond_to(:remove_us_formats) 
   end
 
   it 'should alias to date_for_time_type to dummy_date_for_time_type on Timeliness gem' do
-    expect(Timeliness).to respond_to(:dummy_date_for_time_type) 
+    Timeliness.should respond_to(:dummy_date_for_time_type) 
   end
 
   describe "config" do
     it 'should delegate default_timezone to Timeliness gem' do
-      expect(Timeliness).to receive(:default_timezone=)
+      Timeliness.should_receive(:default_timezone=)
       ValidatesTimeliness.default_timezone = :utc
     end
 
     it 'should delegate dummy_date_for_time_type to Timeliness gem' do
-      expect(Timeliness).to receive(:dummy_date_for_time_type) 
-      expect(Timeliness).to receive(:dummy_date_for_time_type=) 
+      Timeliness.should_receive(:dummy_date_for_time_type) 
+      Timeliness.should_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
-        expect(Timeliness).to receive(:add_formats)
+        Timeliness.should_receive(:add_formats)
         ValidatesTimeliness.parser.add_formats
       end
 
       it 'should delegate remove_formats to Timeliness gem' do
-        expect(Timeliness).to receive(:remove_formats)
+        Timeliness.should_receive(:remove_formats)
         ValidatesTimeliness.parser.remove_formats
       end
 
       it 'should delegate remove_us_formats to Timeliness gem' do
-        expect(Timeliness).to receive(:remove_us_formats)
+        Timeliness.should_receive(:remove_us_formats)
         ValidatesTimeliness.parser.remove_us_formats
       end
     end

validates_timeliness.gemspec

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