validates_timeliness 3.0.0.beta.3 → 3.0.0.beta.4

data/README.rdoc

@@ -5,23 +5,23 @@
 
 == Description
 
-Validate dates, times and datetimes for Rails 3.x and ActiveModel.
+Complete validation of dates, times and datetimes for Rails 3.x and ActiveModel.
 
 If you a looking for the old version for Rails 2.x go here[http://github.com/adzap/validates_timeliness/tree/v2.3].
 
 
 == Features
 
-* Adds ActiveModel validation for dates, times and datetimes
+* Adds validation for dates, times and datetimes to ActiveModel
 
-* Should work with any ORM using ActiveModel
+* Adds extensions to fix Rails date/time select issues
+
+* Includes extensible date/time parser
 
 * Supports timezone handling
 
 * Supports I18n for the error messages
 
-* Adds before_type_cast method on validated attributes, if ORM supports it.
-
 
 == Installation
 
@@ -41,24 +41,29 @@ Then run
   
   $ rails generate validates_timeliness:install
 
-This creates configuration initializer and locale files. In the initializer, you there are a number of config options to customize the plugin.
+This creates configuration initializer and locale files. In the initializer, you there are a number of config
+options to customize the plugin.
 
-  ValidatesTimeliness.setup do |config|
 
-    # Add plugin to supported ORMs (only :active_record for now)
-    # config.extend_orms = [ :active_record ]
+== Examples
 
-  end
+  validates_datetime :occurred_at
+
+  validates_date :date_of_birth :before => lambda { 18.years.ago },
+                                :before_message => "must be at least 18 years old"
 
-By default the plugin extends ActiveRecord if present. Currently ActiveRecord is the only ORM included for extension. If you wish to extend
-another ORM then look at the {wiki page}[http://github.com/adzap/validates_timeliness/wiki/ORM-Support] for more information.
+  validates_datetime :finish_time, :after => :start_time # Method symbol
 
-To extend other ORMs is pretty straight forward. It's matter of hooking into a couple of methods, being the attribute method generation and 
-timezone handling of validated attributes. However, the plugin must support the ActiveModel validations system. If you extend an ORM 
-successfully, please send me a pull request to add the shim to the plugin or let me know where to find it.
+  validates_date :booked_at, :on => :create, :on_or_after => :today # See Restriction Shorthand.
+  validates_time :booked_at, :between => ['9.00am', '5:00pm']
 
+  validates_time :breakfast_time, :on_or_after => '6:00am',
+                                  :on_or_after_message => 'must be after opening time',
+                                  :before => :lunchtime,
+                                  :before_message => 'must be before lunch time'
 
-== Usage:
+
+== Usage
 
 To validate a model with a date, time or datetime attribute you just use the
 validation method
@@ -90,13 +95,13 @@ Temporal options (or restrictions):
   :after        - Attribute must be after this value to be valid
   :on_or_after  - Attribute must be equal to or after this value to be valid
   :between      - Attribute must be between the values to be valid. Range or Array of 2 values. 
-                  Uses :on_or_after and :on_of_before for error messages on lower and upper bounds respectively.
 
 Regular validation options:
   :allow_nil    - Allow a nil value to be valid
   :allow_blank  - Allows a nil or empty string value to be valid
   :if           - Execute validation when :if evaluates true
   :unless       - Execute validation when :unless evaluates false
+  :on           - Specify validation context e.g :save, :create or :update. Default is :save.
 
 Special options:
   :ignore_usec  - Ignores microsecond value on datetime restrictions
@@ -116,6 +121,29 @@ values are compared as dates.
 
 == Configuration
 
+=== ORM/ODM Support
+
+The plugin adds date/time validation to ActiveModel for any ORM/ODM that supports the ActiveModel validations component.
+However, there is an issue with most ORM/ODMs which does not allow 100% date/time validation by default. Specifically, when you
+assign an invalid date/time value to an attribute, most ORM/ODMs will only store a nil value for the attribute. This causes an
+issue for date/time validation, since we need to know that a value was assigned but was invalid. To fix this, we need to cache
+the original invalid value to know that the attribute is not just nil.
+
+Each ORM/ODM requires a specific shim to fix it. The plugin includes a shim for ActiveRecord and Mongoid. You can activate them
+like so
+
+  ValidatesTimeliness.setup do |config|
+
+    # Extend ORM/ODMs for full support (:active_record, :mongoid).
+    config.extend_orms = [ :mongoid ]
+
+  end
+
+By default the plugin extends ActiveRecord if loaded. If you wish to extend another ORM then look at the {wiki page}[http://github.com/adzap/validates_timeliness/wiki/ORM-Support] for more information.
+
+It is not required that you use a shim, but you will not catch errors when the attribute value is invalid and evaluated to nil.
+
+
 === Error Messages
 
 Using the I18n system to define new defaults:
@@ -164,7 +192,7 @@ By default the parser is switched off. To switch it on:
 See the wiki[http://github.com/adzap/validates_timeliness/wiki/Plugin-Parser] for all the details about the parser.
 
 
-=== Restriction Option Shorthand
+=== Restriction Shorthand
 
 It is common to restrict an attribute to being on or before the current time or current day. 
 To specify this you need to use a lambda as an option value e.g. <tt>lambda { Time.now }</tt>.

data/lib/generators/validates_timeliness/templates/validates_timeliness.rb

@@ -1,5 +1,5 @@
 ValidatesTimeliness.setup do |config|
-  # Add plugin to supported ORMs (only :active_record for now)
+  # Extend ORM/ODMs for full support (:active_record, :mongoid).
   # config.extend_orms = [ :active_record ]
   #
   # User the plugin date/time parser which is stricter and extendable
@@ -22,4 +22,16 @@ ValidatesTimeliness.setup do |config|
   #   :now   => lambda { Time.now },
   #   :today => lambda { Date.today }
   # )
+  #
+  # Add one or more formats making them valid. e.g. add_formats(:date, 'd(st|rd|th) of mmm, yyyy')
+  # config.parser.add_formats()
+  #
+  # Remove one or more formats making them invalid. e.g. remove_formats(:date, 'dd/mm/yyy')
+  # config.parser.remove_formats()
+  #
+  # Change the amiguous year threshold when parsing a 2 digit year
+  # config.parser.ambiguous_year_threshold =  30
+  #
+  # Treat ambiguous dates, such as 01/02/1950, as a Non-US date.
+  # config.parser.remove_us_formats
 end

data/lib/validates_timeliness/attribute_methods.rb

@@ -2,23 +2,42 @@ module ValidatesTimeliness
   module AttributeMethods
     extend ActiveSupport::Concern
 
+    included do
+      class_inheritable_accessor :timeliness_validated_attributes
+      self.timeliness_validated_attributes = []
+    end
+
     module ClassMethods
 
+      public
+      # Override in ORM shim
+      def timeliness_attribute_timezone_aware?(attr_name)
+        false
+      end
+
+      # Override in ORM shim
+      def timeliness_attribute_type(attr_name)
+        :datetime
+      end
+
+      protected
+
       def define_timeliness_methods(before_type_cast=false)
         return if timeliness_validated_attributes.blank?
-        timeliness_validated_attributes.each do |attr_name, type|
-          define_timeliness_write_method(attr_name, type, timeliness_attribute_timezone_aware?(attr_name))
+        timeliness_validated_attributes.each do |attr_name|
+          define_timeliness_write_method(attr_name)
           define_timeliness_before_type_cast_method(attr_name) if before_type_cast
         end
       end
 
-      protected
+      def define_timeliness_write_method(attr_name)
+        type = timeliness_attribute_type(attr_name)
+        timezone_aware = timeliness_attribute_timezone_aware?(attr_name)
 
-      def define_timeliness_write_method(attr_name, type, timezone_aware)
         method_body, line = <<-EOV, __LINE__ + 1
           def #{attr_name}=(value)
-            @attributes_cache ||= {}
-            @attributes_cache["_#{attr_name}_before_type_cast"] = value
+            @timeliness_cache ||= {}
+            @timeliness_cache["#{attr_name}"] = value
             #{ "value = ValidatesTimeliness::Parser.parse(value, :#{type}, :timezone_aware => #{timezone_aware}) if value.is_a?(String)" if ValidatesTimeliness.use_plugin_parser }
             super
           end
@@ -34,21 +53,16 @@ module ValidatesTimeliness
         EOV
         class_eval(method_body, __FILE__, line)
       end
-
-      public
-
-      def timeliness_attribute_timezone_aware?(attr_name)
-        false
-      end
-
     end
 
     module InstanceMethods
-
       def _timeliness_raw_value_for(attr_name)
-        @attributes_cache && @attributes_cache["_#{attr_name}_before_type_cast"]
+        @timeliness_cache && @timeliness_cache[attr_name.to_s]
       end
 
+      def _clear_timeliness_cache
+        @timeliness_cache = {}
+      end
     end
 
   end

data/lib/validates_timeliness/extensions/date_time_select.rb

@@ -3,10 +3,10 @@ module ValidatesTimeliness
     module DateTimeSelect
       extend ActiveSupport::Concern
 
-      # Intercepts the date and time select helpers to reuse the values from the
+      # Intercepts the date and time select helpers to reuse the values from
       # the params rather than the parsed value. This allows invalid date/time
       # values to be redisplayed instead of blanks to aid correction by the user.
-      # Its a minor usability improvement which is rarely an issue for the user.
+      # It's a minor usability improvement which is rarely an issue for the user.
 
       included do
         alias_method_chain :datetime_selector, :timeliness

data/lib/validates_timeliness/helper_methods.rb

@@ -1,15 +1,7 @@
-module ValidatesTimeliness
-  module HelperMethods
-    extend ActiveSupport::Concern
+module ActiveModel
+  module Validations
 
-    included do
-      include ValidationMethods
-      extend ValidationMethods
-      class_inheritable_hash :timeliness_validated_attributes
-      self.timeliness_validated_attributes = {}
-    end
-
-    module ValidationMethods
+    module HelperMethods
       def validates_date(*attr_names)
         timeliness_validation_for attr_names, :date
       end
@@ -23,17 +15,14 @@ module ValidatesTimeliness
       end
 
       def timeliness_validation_for(attr_names, type)
-        options = _merge_attributes(attr_names)
-        options[:type] = type
-        attributes = attr_names.inject({}) {|validated, attr_name|
-          attr_name = attr_name.to_s
-          validated[attr_name] = type
-          validated
-        }
-        self.timeliness_validated_attributes = attributes
-        validates_with Validator, options
+        options = _merge_attributes(attr_names).merge(:type => type)
+        if respond_to?(:timeliness_validated_attributes)
+          self.timeliness_validated_attributes ||= []
+          self.timeliness_validated_attributes += (attr_names - self.timeliness_validated_attributes)
+        end
+        validates_with ValidatesTimeliness::Validator, options
       end
-
     end
+
   end
 end

data/lib/validates_timeliness/orm/active_record.rb

@@ -1,14 +1,37 @@
-class ActiveRecord::Base
-  include ValidatesTimeliness::HelperMethods
-  include ValidatesTimeliness::AttributeMethods
+module ValidatesTimeliness
+  module ORM
+    module ActiveRecord
+      extend ActiveSupport::Concern
 
-  def self.define_attribute_methods
-    super
-    # Define write method and before_type_cast method
-    define_timeliness_methods(true)
-  end
+      module ClassMethods
+        def define_attribute_methods
+          super
+          # Define write method and before_type_cast method
+          define_timeliness_methods(true)
+        end
+
+        def timeliness_attribute_timezone_aware?(attr_name)
+          attr_name = attr_name.to_s
+          create_time_zone_conversion_attribute?(attr_name, columns_hash[attr_name])
+        end
+
+        def timeliness_attribute_type(attr_name)
+          columns_hash[attr_name.to_s].type
+        end
+      end
 
-  def self.timeliness_attribute_timezone_aware?(attr_name)
-    create_time_zone_conversion_attribute?(attr_name, columns_hash[attr_name])
+      module InstanceMethods
+        def reload(*args)
+          _clear_timeliness_cache
+          super
+        end
+      end
+
+    end
   end
 end
+
+class ActiveRecord::Base
+  include ValidatesTimeliness::AttributeMethods
+  include ValidatesTimeliness::ORM::ActiveRecord
+end

data/lib/validates_timeliness/orm/mongoid.rb

@@ -7,29 +7,58 @@ module ValidatesTimeliness
       # field value in Mongoid. Parser will return nil rather than error.
 
       module ClassMethods 
+        # 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, type, false) }
+          attr_names.each { |attr_name| define_timeliness_write_method(attr_name) }
         end
 
-        def define_timeliness_write_method(attr_name, type, timezone_aware)
+        def define_timeliness_write_method(attr_name)
+          type = timeliness_attribute_type(attr_name)
           method_body, line = <<-EOV, __LINE__ + 1
             def #{attr_name}=(value)
-              @attributes_cache ||= {}
-              @attributes_cache["_#{attr_name}_before_type_cast"] = value
+              @timeliness_cache ||= {}
+              @timeliness_cache["#{attr_name}"] = value
               #{ "value = ValidatesTimeliness::Parser.parse(value, :#{type}) if value.is_a?(String)" if ValidatesTimeliness.use_plugin_parser }
               write_attribute(:#{attr_name}, value)
             end
           EOV
           class_eval(method_body, __FILE__, line)
         end
+
+        def timeliness_attribute_type(attr_name)
+          {
+            Date => :date,
+            Time => :datetime,
+            DateTime => :datetime
+          }[fields[attr_name.to_s].type] || :datetime
+        end
       end
+
     end
   end
 end
  
 module Mongoid::Document
-  include ValidatesTimeliness::HelperMethods
-  include ValidatesTimeliness::AttributeMethods
-  include ValidatesTimeliness::ORM::Mongoid
+  # Due to how Mongoid misuses ActiveSupport::Concern,
+  # the only way to override a core component method is 
+  # using an append_features hook.
+  #
+  module TimelinessConcern
+    def append_features(base)
+      super
+      base.send :include, ValidatesTimeliness::AttributeMethods
+      base.send :include, ValidatesTimeliness::ORM::Mongoid
+    end
+  end
+  extend TimelinessConcern
+
+  def reload_with_timeliness
+    _clear_timeliness_cache
+    reload_without_timeliness
+  end
+  alias_method_chain :reload, :timeliness
 end

data/lib/validates_timeliness/parser.rb

@@ -23,14 +23,6 @@ module ValidatesTimeliness
     cattr_accessor :ambiguous_year_threshold
     self.ambiguous_year_threshold = 30
 
-    # Set the dummy date part for a time type value. Should be an array of 3 values
-    # being year, month and day in that order.
-    #
-    # Default: [ 2000, 1, 1 ] same as ActiveRecord
-    #
-    cattr_accessor :dummy_date_for_time_type
-    self.dummy_date_for_time_type = [ 2000, 1, 1 ]
-
     # Format tokens:
     #       y = year
     #       m = month

data/lib/validates_timeliness/validator.rb

@@ -14,6 +14,12 @@ module ValidatesTimeliness
       :on_or_after  => :>=,
     }.freeze
 
+    DEFAULT_ERROR_VALUE_FORMATS = {
+      :date => '%Y-%m-%d',
+      :time => '%H:%M:%S',
+      :datetime => '%Y-%m-%d %H:%M:%S'
+    }.freeze
+
     def self.kind
       :timeliness
     end
@@ -31,10 +37,10 @@ module ValidatesTimeliness
     end
 
     def validate_each(record, attr_name, value)
-      raw_value = record._timeliness_raw_value_for(attr_name) || value
+      raw_value = attribute_raw_value(record, attr_name) || value
       return if (@allow_nil && raw_value.nil?) || (@allow_blank && raw_value.blank?)
 
-      @timezone_aware = record.class.timeliness_attribute_timezone_aware?(attr_name)
+      @timezone_aware = timezone_aware?(record, attr_name)
       value = parse(raw_value) if value.is_a?(String) || options[:format]
       value = type_cast_value(value, @type)
 
@@ -56,10 +62,21 @@ module ValidatesTimeliness
     end
 
     def format_error_value(value)
-      format = I18n.t(@type, :scope => 'validates_timeliness.error_value_formats')
+      format = I18n.t(@type, :default => DEFAULT_ERROR_VALUE_FORMATS[@type], :scope => 'validates_timeliness.error_value_formats')
       value.strftime(format)
     end
 
+    def attribute_raw_value(record, attr_name)
+      if record.respond_to?(:_timeliness_raw_value_for)
+        record._timeliness_raw_value_for(attr_name)
+      end
+    end
+
+    def timezone_aware?(record, attr_name)
+      record.class.respond_to?(:timeliness_attribute_timezone_aware?) &&
+        record.class.timeliness_attribute_timezone_aware?(attr_name)
+    end
+
   end
 end
 

data/lib/validates_timeliness/version.rb

@@ -1,3 +1,3 @@
 module ValidatesTimeliness
-  VERSION = '3.0.0.beta.3'
+  VERSION = '3.0.0.beta.4'
 end

data/lib/validates_timeliness.rb

@@ -12,7 +12,7 @@ module ValidatesTimeliness
   autoload :Parser,  'validates_timeliness/parser'
   autoload :VERSION, 'validates_timeliness/version'
 
-  # Add plugin to supported ORMs (only :active_record for now)
+  # Extend ORM/ODMs for full support (:active_record, :mongoid).
   mattr_accessor :extend_orms
   @@extend_orms = [ defined?(ActiveRecord) && :active_record ].compact
 
@@ -39,6 +39,10 @@ module ValidatesTimeliness
     :today => lambda { Date.today }
   }
 
+  def self.parser
+    Parser
+  end
+
   # Setup method for plugin configuration
   def self.setup
     yield self

data/spec/spec_helper.rb

@@ -24,15 +24,11 @@ LOCALE_PATH = File.expand_path(File.dirname(__FILE__) + '/../lib/generators/vali
 I18n.load_path.unshift(LOCALE_PATH)
 
 # Extend TestModel as you would another ORM/ODM module
-module TestModel
-  include ValidatesTimeliness::HelperMethods
+module TestModelShim
+  extend ActiveSupport::Concern
   include ValidatesTimeliness::AttributeMethods
 
-  def self.included(base)
-    base.extend HookMethods
-  end
-
-  module HookMethods
+  module ClassMethods
     # Hook method for attribute method generation
     def define_attribute_methods(attr_names)
       super
@@ -48,11 +44,17 @@ end
 
 class Person
   include TestModel
-  self.model_attributes = :birth_date, :birth_time, :birth_datetime
+  attribute :birth_date, :date
+  attribute :birth_time, :time
+  attribute :birth_datetime, :datetime
   validates_date :birth_date
   validates_time :birth_time
   validates_datetime :birth_datetime
-  define_attribute_methods model_attributes
+  define_attribute_methods model_attributes.keys
+end
+
+class PersonWithShim < Person
+  include TestModelShim
 end
 
 ActiveRecord::Base.time_zone_aware_attributes = true
@@ -62,8 +64,8 @@ ActiveRecord::Schema.define(:version => 1) do
   create_table :employees, :force => true do |t|
     t.string   :first_name
     t.string   :last_name
-    t.datetime :birth_date
-    t.datetime :birth_time
+    t.date     :birth_date
+    t.time     :birth_time
     t.datetime :birth_datetime
   end
 end
@@ -80,10 +82,10 @@ Rspec.configure do |c|
   c.include(RspecTagMatchers)
   c.before do
     Person.reset_callbacks(:validate)
-    Person.timeliness_validated_attributes = {}
+    PersonWithShim.timeliness_validated_attributes = []
     Person._validators.clear
     Employee.reset_callbacks(:validate)
-    Employee.timeliness_validated_attributes = {}
+    Employee.timeliness_validated_attributes = []
     Employee._validators.clear
   end
 end

data/spec/test_model.rb

@@ -1,41 +1,32 @@
 module TestModel
-  extend  ActiveSupport::Concern
+  extend ActiveSupport::Concern
+  extend ActiveModel::Translation
+  include ActiveModel::Validations
+  include ActiveModel::AttributeMethods
 
   included do
-    extend  ActiveModel::Translation
-    include ActiveModel::Validations
-    include ActiveModel::AttributeMethods
-    include DynamicMethods
-
     attribute_method_suffix ""
     attribute_method_suffix "="
     cattr_accessor :model_attributes
   end
 
   module ClassMethods
+    def attribute(name, type)
+      self.model_attributes ||= {}
+      self.model_attributes[name] = type
+    end
+
     def define_method_attribute=(attr_name)
-      generated_attribute_methods.module_eval("def #{attr_name}=(new_value); @attributes['#{attr_name}']=self.class.type_cast(new_value); end", __FILE__, __LINE__)
+      generated_attribute_methods.module_eval("def #{attr_name}=(new_value); @attributes['#{attr_name}']=self.class.type_cast('#{attr_name}', new_value); end", __FILE__, __LINE__)
     end
 
     def define_method_attribute(attr_name)
       generated_attribute_methods.module_eval("def #{attr_name}; @attributes['#{attr_name}']; end", __FILE__, __LINE__)
     end
 
-    def type_cast(value)
+    def type_cast(attr_name, value)
       return value unless value.is_a?(String)
-      value.to_time rescue nil
-    end
-  end
-
-  module DynamicMethods
-    def method_missing(method_id, *args, &block)
-      if !self.class.attribute_methods_generated?
-        self.class.define_attribute_methods self.class.model_attributes.map(&:to_s)
-        method_name = method_id.to_s
-        send(method_id, *args, &block)
-      else
-        super
-      end
+      value.send("to_#{model_attributes[attr_name.to_sym]}") rescue nil
     end
   end
 
@@ -57,5 +48,15 @@ module TestModel
     end
   end
 
+  def method_missing(method_id, *args, &block)
+    if !self.class.attribute_methods_generated?
+      self.class.define_attribute_methods self.class.model_attributes.keys.map(&:to_s)
+      method_name = method_id.to_s
+      send(method_id, *args, &block)
+    else
+      super
+    end
+  end
+
 end
 

data/spec/validates_timeliness/attribute_methods_spec.rb

@@ -2,13 +2,27 @@ require 'spec_helper'
 
 describe ValidatesTimeliness::AttributeMethods do
   it 'should define _timeliness_raw_value_for instance method' do
-    Person.instance_methods.should include('_timeliness_raw_value_for')
+    PersonWithShim.instance_methods.should include('_timeliness_raw_value_for')
+  end
+
+  describe ".timeliness_validated_attributes" do
+    it 'should return attributes validated with plugin validator' do
+      PersonWithShim.timeliness_validated_attributes = []
+      PersonWithShim.validates_date :birth_date
+      PersonWithShim.validates_time :birth_time
+      PersonWithShim.validates_datetime :birth_datetime
+
+      PersonWithShim.timeliness_validated_attributes.should == [ :birth_date, :birth_time, :birth_datetime ]
+    end
   end
   
   context "attribute write method" do
     class PersonWithCache
       include TestModel
-      self.model_attributes = :birth_date, :birth_time, :birth_datetime
+      include TestModelShim
+      attribute :birth_date, :date
+      attribute :birth_time, :time
+      attribute :birth_datetime, :datetime
       validates_date :birth_date
       validates_time :birth_time
       validates_datetime :birth_datetime
@@ -23,7 +37,10 @@ describe ValidatesTimeliness::AttributeMethods do
     context "with plugin parser" do
       class PersonWithParser
         include TestModel
-        self.model_attributes = :birth_date, :birth_time, :birth_datetime
+        include TestModelShim
+        attribute :birth_date, :date
+        attribute :birth_time, :time
+        attribute :birth_datetime, :datetime
         validates_date :birth_date
         validates_time :birth_time
         validates_datetime :birth_datetime
@@ -53,7 +70,7 @@ describe ValidatesTimeliness::AttributeMethods do
 
   context "before_type_cast method" do
     it 'should not be defined if ORM does not support it' do
-      Person.instance_methods(false).should_not include("birth_datetime_before_type_cast")
+      PersonWithShim.instance_methods(false).should_not include("birth_datetime_before_type_cast")
     end
   end
 end

data/spec/validates_timeliness/helper_methods_spec.rb

@@ -1,16 +1,16 @@
 require 'spec_helper'
 
-describe ValidatesTimeliness::HelperMethods do
-  it 'should define class validation methods on extended classes' do
-    ActiveRecord::Base.should respond_to(:validates_date)
-    ActiveRecord::Base.should respond_to(:validates_time)
-    ActiveRecord::Base.should respond_to(:validates_datetime)
+describe ValidatesTimeliness, 'HelperMethods' do
+  it 'should define class validation methods' do
+    Person.should respond_to(:validates_date)
+    Person.should respond_to(:validates_time)
+    Person.should respond_to(:validates_datetime)
   end
 
-  it 'should define instance validation methods on extended classes' do
-    ActiveRecord::Base.instance_methods.should include('validates_date')
-    ActiveRecord::Base.instance_methods.should include('validates_time')
-    ActiveRecord::Base.instance_methods.should include('validates_datetime')
+  it 'should define instance validation methods' do
+    Person.instance_methods.should include('validates_date')
+    Person.instance_methods.should include('validates_time')
+    Person.instance_methods.should include('validates_datetime')
   end
 
   it 'should validate instance when validation method called' do
@@ -18,19 +18,4 @@ describe ValidatesTimeliness::HelperMethods do
     r.validates_date :birth_date
     r.errors[:birth_date].should_not be_empty
   end
-
-  describe ".timeliness_validated_attributes" do
-    it 'should return attributes validated with plugin validator' do
-      Person.timeliness_validated_attributes = {}
-      Person.validates_date :birth_date
-      Person.validates_time :birth_time
-      Person.validates_datetime :birth_datetime
-
-      Person.timeliness_validated_attributes.should == {
-        "birth_date" => :date,
-        "birth_time" => :time,
-        "birth_datetime" => :datetime
-      }
-    end
-  end
 end

data/spec/validates_timeliness/orm/active_record_spec.rb

@@ -1,8 +1,23 @@
 require 'spec_helper'
 
 describe ValidatesTimeliness, 'ActiveRecord' do
-  it 'should define _timeliness_raw_value_for instance method' do
-    Employee.instance_methods.should include('_timeliness_raw_value_for')
+
+  context "validation methods" do
+    it 'should be defined for the class' do
+      ActiveRecord::Base.should respond_to(:validates_date)
+      ActiveRecord::Base.should respond_to(:validates_time)
+      ActiveRecord::Base.should respond_to(:validates_datetime)
+    end
+
+    it 'should defines for the instance' do
+      ActiveRecord::Base.instance_methods.should include('validates_date')
+      ActiveRecord::Base.instance_methods.should include('validates_time')
+      ActiveRecord::Base.instance_methods.should include('validates_datetime')
+    end
+  end
+
+  it 'should determine type for attribute' do
+    Employee.timeliness_attribute_type(:birth_date).should == :date
   end
   
   context "attribute write method" do
@@ -36,16 +51,26 @@ describe ValidatesTimeliness, 'ActiveRecord' do
 
       it 'should parse string as current timezone' do
         r = EmployeeWithParser.new
-        r.birth_datetime = '2010-01-01 12:00'
-        r.birth_datetime.zone == Time.zone.name
+        r.birth_datetime = '2010-06-01 12:00'
+        r.birth_datetime.utc_offset.should == 10.hours
       end
 
       after :all do
+        Time.zone = 'Australia/Melbourne'
         ValidatesTimeliness.use_plugin_parser = false
       end
     end
   end
 
+  context "cached value" do
+    it 'should be cleared on reload' do
+      r = Employee.create!
+      r.birth_date = '2010-01-01'
+      r.reload
+      r._timeliness_raw_value_for(:birth_date).should be_nil
+    end
+  end
+
   context "before_type_cast method" do
     it 'should be defined on class if ORM supports it' do
       Employee.instance_methods(false).should include("birth_datetime_before_type_cast")

data/spec/validates_timeliness/orm/mongoid_spec.rb

@@ -10,22 +10,36 @@ Mongoid.configure do |config|
   config.persist_in_safe_mode = false
 end
 
+class Article
+  ::ValidatesTimeliness.use_plugin_parser = true
+  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
+  ::ValidatesTimeliness.use_plugin_parser = false
+end
+
 describe ValidatesTimeliness, 'Mongoid' do
 
-  class Article
-    ::ValidatesTimeliness.use_plugin_parser = true
-    include Mongoid::Document
-    field :publish_date, :type => Date
-    field :publish_time, :type => Time
-    field :publish_datetime, :type => DateTime
-    validates_date :publish_date
-    validates_time :publish_time
-    validates_datetime :publish_datetime
-    ::ValidatesTimeliness.use_plugin_parser = false
+  context "validation methods" do
+    it 'should be defined on the class' do
+      Article.should respond_to(:validates_date)
+      Article.should respond_to(:validates_time)
+      Article.should respond_to(:validates_datetime)
+    end
+
+    it 'should be defined on the instance' do
+      Article.instance_methods.should include('validates_date')
+      Article.instance_methods.should include('validates_time')
+      Article.instance_methods.should include('validates_datetime')
+    end
   end
 
-  it 'should define _timeliness_raw_value_for instance method' do
-    Article.instance_methods.should include('_timeliness_raw_value_for')
+  it 'should determine type for attribute' do
+    Article.timeliness_attribute_type(:publish_date).should == :date
   end
   
   context "attribute write method" do
@@ -58,6 +72,15 @@ describe ValidatesTimeliness, 'Mongoid' do
     end
   end
 
+  context "cached value" do
+    it 'should be cleared on reload' do
+      r = Article.create!
+      r.publish_date = '2010-01-01'
+      r.reload
+      r._timeliness_raw_value_for(:publish_date).should be_nil
+    end
+  end
+
   context "before_type_cast method" do
     it 'should not be defined if ORM does not support it' do
       Article.instance_methods(false).should_not include("birth_datetime_before_type_cast")

data/spec/validates_timeliness/parser_spec.rb

@@ -177,22 +177,6 @@ describe ValidatesTimeliness::Parser do
         ValidatesTimeliness::Parser.ambiguous_year_threshold = default
       end
     end
-
-    context "with custom dummy date values" do
-      before(:all) do
-        @old_dummy_date = ValidatesTimeliness.dummy_date_for_time_type
-        ValidatesTimeliness.dummy_date_for_time_type = [2009,1,1]
-      end
-
-      it "should return time array with custom dummy date" do
-        time_array = formats._parse('12:13:14', :time, :strict => true)
-        time_array.should == [2009,1,1,12,13,14,0]
-      end
-
-      after(:all) do
-        ValidatesTimeliness.dummy_date_for_time_type = @old_dummy_date
-      end
-    end
   end
 
   describe "parse" do

data/spec/validates_timeliness/validator_spec.rb

@@ -101,7 +101,10 @@ describe ValidatesTimeliness::Validator do
   describe ":format option" do
     class PersonWithFormatOption
       include TestModel
-      self.model_attributes = :birth_date, :birth_time, :birth_datetime
+      include TestModelShim
+      attribute :birth_date, :date
+      attribute :birth_time, :time
+      attribute :birth_datetime, :datetime
       validates_date :birth_date, :format => 'dd-mm-yyyy'
     end
 
@@ -169,6 +172,21 @@ describe ValidatesTimeliness::Validator do
         validator.format_error_value(Time.mktime(2010,1,1,12,34,56)).should == '2010-01-01 12:34:56'
       end
     end
+
+    describe "with missing translation" do
+      before :all do
+        I18n.locale = :es
+      end
+
+      it 'should use the default format for the type' do
+        validator = ValidatesTimeliness::Validator.new(:attributes => [:birth_date], :type => :date)
+        validator.format_error_value(Date.new(2010,1,1)).should == '2010-01-01'
+      end
+
+      after :all do
+        I18n.locale = :en
+      end
+    end
   end
 
   context "custom error message" do

data/validates_timeliness.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{validates_timeliness}
-  s.version = "3.0.0.beta.3"
+  s.version = "3.0.0.beta.4"
 
   s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["Adam Meehan"]
-  s.date = %q{2010-09-22}
+  s.date = %q{2010-09-29}
   s.description = %q{Date and time validation plugin for Rails which allows custom formats}
   s.email = %q{adam.meehan@gmail.com}
   s.extra_rdoc_files = ["README.rdoc", "LICENSE", "CHANGELOG"]

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: validates_timeliness
 version: !ruby/object:Gem::Version 
-  hash: 62196421
+  hash: 62196427
   prerelease: true
   segments: 
   - 3
   - 0
   - 0
   - beta
-  - 3
-  version: 3.0.0.beta.3
+  - 4
+  version: 3.0.0.beta.4
 platform: ruby
 authors: 
 - Adam Meehan
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-22 00:00:00 +10:00
+date: 2010-09-29 00:00:00 +10:00
 default_executable: 
 dependencies: []