validates_timeliness 1.0.0

data/lib/validates_timeliness/locale/en.yml

@@ -0,0 +1,11 @@
+en:
+  activerecord:
+    errors:
+      messages:
+        invalid_date: "is not a valid date"
+        invalid_time: "is not a valid time"
+        invalid_datetime: "is not a valid datetime"
+        before: "must be before {{restriction}}"
+        on_or_before: "must be on or before {{restriction}}"
+        after: "must be after {{restriction}}"
+        on_or_after: "must be on or after {{restriction}}"

data/lib/validates_timeliness/spec/rails/matchers/validate_timeliness.rb

@@ -0,0 +1,121 @@
+module Spec
+  module Rails
+    module Matchers
+      class ValidateTimeliness
+        cattr_accessor :test_values
+   
+        @@test_values = {
+          :date     => {:pass => '2000-01-01', :fail => '2000-01-32'},
+          :time     => {:pass => '12:00',      :fail => '25:00'},
+          :datetime => {:pass => '2000-01-01 00:00:00', :fail => '2000-01-32 00:00:00'}
+        }
+
+        def initialize(attribute, options)
+          @expected, @options = attribute, options
+          @validator = ValidatesTimeliness::Validator.new(options)
+          compile_error_messages
+        end
+        
+        def compile_error_messages
+          messages = validator.send(:error_messages)
+          @messages = messages.inject({}) {|h, (k, v)| h[k] = v.gsub(/ (\%s|\{\{\w*\}\})/, ''); h }
+        end
+
+        def matches?(record)
+          @record = record
+          type = options[:type]
+          
+          invalid_value = @@test_values[type][:fail]
+          valid_value   = parse_and_cast(@@test_values[type][:pass])
+          valid = error_matching(invalid_value, /#{messages["invalid_#{type}".to_sym]}/) &&
+              no_error_matching(valid_value, /#{messages["invalid_#{type}".to_sym]}/)
+
+          valid = test_option(:before, :-) if options[:before] && valid
+          valid = test_option(:after, :+) if options[:after] && valid
+          
+          valid = test_option(:on_or_before, :+, :modify_on => :invalid) if options[:on_or_before] && valid
+          valid = test_option(:on_or_after, :-, :modify_on => :invalid) if options[:on_or_after] && valid
+
+          return valid
+        end
+      
+        def failure_message
+          "expected model to validate #{options[:type]} attribute #{expected.inspect} with #{last_failure}"
+        end
+        
+        def negative_failure_message
+          "expected not to validate #{options[:type]} attribute #{expected.inspect}"
+        end
+        
+        def description
+          "have validated #{options[:type]} attribute #{expected.inspect}"
+        end
+        
+       private
+        attr_reader :actual, :expected, :record, :options, :messages, :last_failure, :validator
+        
+        def test_option(option, modifier, settings={})
+          settings.reverse_merge!(:modify_on => :valid)
+          boundary = parse_and_cast(options[option])
+          
+          valid_value, invalid_value = if settings[:modify_on] == :valid
+            [ boundary.send(modifier, 1), boundary ]
+          else
+            [ boundary, boundary.send(modifier, 1) ]
+          end
+          
+          message = messages[option]
+          error_matching(invalid_value, /#{message}/) && 
+            no_error_matching(valid_value, /#{message}/)
+        end
+       
+        def parse_and_cast(value)
+          value = validator.send(:restriction_value, value, record)
+          validator.send(:type_cast_value, value)
+        end
+
+        def error_matching(value, match)
+          record.send("#{expected}=", value)
+          record.valid?
+          errors = record.errors.on(expected)
+          pass = [ errors ].flatten.any? {|error| match === error }
+          @last_failure = "error matching #{match.inspect} when value is #{format_value(value)}" unless pass
+          pass
+        end
+        
+        def no_error_matching(value, match)
+          pass = !error_matching(value, match)
+          @last_failure = "no error matching #{match.inspect} when value is #{format_value(value)}" unless pass
+          pass
+        end
+        
+        def format_value(value)
+          return value if value.is_a?(String)
+          value.strftime(ValidatesTimeliness::Validator.error_value_formats[options[:type]])
+        end
+      end
+
+      def validate_date(attribute, options={})
+        options[:type] = :date
+        validate_timeliness_of(attribute, options)
+      end
+
+      def validate_time(attribute, options={})
+        options[:type] = :time
+        validate_timeliness_of(attribute, options)
+      end
+
+      def validate_datetime(attribute, options={})
+        options[:type] = :datetime
+        validate_timeliness_of(attribute, options)
+      end
+
+      private
+
+      def validate_timeliness_of(attribute, options={})
+        ValidateTimeliness.new(attribute, options)
+      end
+
+    end
+  end
+end

data/lib/validates_timeliness/validation_methods.rb

@@ -0,0 +1,82 @@
+module ValidatesTimeliness
+  module ValidationMethods
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def parse_date_time(raw_value, type, strict=true)
+        return nil if raw_value.blank?
+        return raw_value if raw_value.acts_like?(:time) || raw_value.is_a?(Date)
+        
+        time_array = ValidatesTimeliness::Formats.parse(raw_value, type, strict)
+        raise if time_array.nil?
+        
+        # Rails dummy time date part is defined as 2000-01-01
+        time_array[0..2] = 2000, 1, 1 if type == :time
+  
+        # Date.new enforces days per month, unlike Time
+        date = Date.new(*time_array[0..2]) unless type == :time
+        
+        return date if type == :date
+        
+        # Create time object which checks time part, and return time object
+        make_time(time_array)
+      rescue
+        nil
+      end
+
+      def validates_time(*attr_names)
+        configuration = attr_names.extract_options!
+        configuration[:type] = :time
+        validates_timeliness_of(attr_names, configuration)
+      end
+      
+      def validates_date(*attr_names)
+        configuration = attr_names.extract_options!
+        configuration[:type] = :date
+        validates_timeliness_of(attr_names, configuration)
+      end
+      
+      def validates_datetime(*attr_names)
+        configuration = attr_names.extract_options!
+        configuration[:type] = :datetime
+        validates_timeliness_of(attr_names, configuration)
+      end
+
+      private
+
+      def validates_timeliness_of(attr_names, configuration)
+        validator = ValidatesTimeliness::Validator.new(configuration)
+        
+        # bypass handling of allow_nil and allow_blank to validate raw value
+        configuration.delete(:allow_nil)
+        configuration.delete(:allow_blank)
+        validates_each(attr_names, configuration) do |record, attr_name, value|
+          validator.call(record, attr_name)
+        end
+      end
+
+      # Time.zone. Rails 2.0 should be default_timezone.
+      def make_time(time_array)
+        if Time.respond_to?(:zone) && time_zone_aware_attributes
+          Time.zone.local(*time_array)
+        else
+          begin
+            Time.send(::ActiveRecord::Base.default_timezone, *time_array)
+          rescue ArgumentError, TypeError
+            zone_offset = ::ActiveRecord::Base.default_timezone == :local ? DateTime.local_offset : 0
+            time_array.pop # remove microseconds
+            DateTime.civil(*(time_array << zone_offset))
+          end
+        end
+      end
+
+    end
+
+  end
+end
+
+ActiveRecord::Base.send(:include, ValidatesTimeliness::ValidationMethods)

data/lib/validates_timeliness/validator.rb

@@ -0,0 +1,120 @@
+module ValidatesTimeliness
+
+  class Validator
+    cattr_accessor :ignore_restriction_errors
+    cattr_accessor :error_value_formats
+
+    self.ignore_restriction_errors = false
+    self.error_value_formats = {
+      :time     => '%H:%M:%S',
+      :date     => '%Y-%m-%d',
+      :datetime => '%Y-%m-%d %H:%M:%S'
+    }
+
+    attr_reader :configuration, :type
+
+    def initialize(configuration)
+      defaults = { :on => :save, :type => :datetime, :allow_nil => false, :allow_blank => false }
+      @configuration = defaults.merge(configuration)
+      @type = @configuration.delete(:type)
+    end
+      
+    def call(record, attr_name)
+      value     = record.send(attr_name)
+      value     = record.class.parse_date_time(value, type, false) if value.is_a?(String)
+      raw_value = raw_value(record, attr_name)
+
+      return if (raw_value.nil? && configuration[:allow_nil]) || (raw_value.blank? && configuration[:allow_blank])
+
+      add_error(record, attr_name, :blank) and return if raw_value.blank?
+       
+      add_error(record, attr_name, "invalid_#{type}".to_sym) and return unless value
+
+      validate_restrictions(record, attr_name, value)
+    end
+    
+   private
+
+    def raw_value(record, attr_name)
+      record.send("#{attr_name}_before_type_cast")
+    end
+   
+    def validate_restrictions(record, attr_name, value)
+      restriction_methods = {:before => '<', :after => '>', :on_or_before => '<=', :on_or_after => '>='}
+      
+      display = self.class.error_value_formats[type]
+      
+      value = type_cast_value(value)
+      
+      restriction_methods.each do |option, method|
+        next unless restriction = configuration[option]
+        begin
+          compare = restriction_value(restriction, record)
+          next if compare.nil?
+          compare = type_cast_value(compare)
+
+          unless value.send(method, compare)
+            add_error(record, attr_name, option, :restriction => compare.strftime(display))
+          end
+        rescue
+          unless self.class.ignore_restriction_errors
+            add_error(record, attr_name, "restriction '#{option}' value was invalid")
+          end
+        end
+      end
+    end
+    
+    def add_error(record, attr_name, message, interpolate={})
+      if Rails::VERSION::STRING < '2.2'
+        message = error_messages[message] if message.is_a?(Symbol)
+        message = message % interpolate.values unless interpolate.empty?
+        record.errors.add(attr_name, message)
+      else
+        # use i18n support in AR for message or use custom message passed to validation method
+        custom = custom_error_messages[message]
+        record.errors.add(attr_name, custom || message, interpolate)
+      end
+    end
+
+    def error_messages
+      return @error_messages if defined?(@error_messages)
+      @error_messages = ValidatesTimeliness.default_error_messages.merge(custom_error_messages)
+    end
+    
+    def custom_error_messages
+      return @custom_error_messages if defined?(@custom_error_messages)
+      @custom_error_messages = configuration.inject({}) {|h, (k, v)| h[$1.to_sym] = v if k.to_s =~ /(.*)_message$/;h }
+    end
+    
+    def restriction_value(restriction, record)
+      case restriction
+        when Time, Date, DateTime
+          restriction
+        when Symbol
+          restriction_value(record.send(restriction), record)
+        when Proc
+          restriction_value(restriction.call(record), record)
+        else
+         record.class.parse_date_time(restriction, type, false)
+      end
+    end
+    
+    def type_cast_value(value)
+      case type
+        when :time
+          value.to_dummy_time
+        when :date
+          value.to_date
+        when :datetime
+          if value.is_a?(DateTime) || value.is_a?(Time)
+            value.to_time
+          else
+            value.to_time(ValidatesTimelines.default_timezone)
+          end
+        else
+          nil
+      end
+    end
+
+  end
+end

data/spec/action_view/instance_tag_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ValidatesTimeliness::ActionView::InstanceTag, :type => :helper do
+  
+  before do
+    @person = Person.new
+  end
+  
+  it "should display invalid datetime as datetime_select values" do
+    @person.birth_date_and_time = "2008-02-30 12:00:22"
+    output = datetime_select(:person, :birth_date_and_time, :include_blank => true, :include_seconds => true)
+   
+    output.should have_tag('select[id=person_birth_date_and_time_1i]') do
+      with_tag('option[selected=selected]', '2008')
+    end
+    output.should have_tag('select[id=person_birth_date_and_time_2i]') do
+      with_tag('option[selected=selected]', 'February')
+    end
+    output.should have_tag('select[id=person_birth_date_and_time_3i]') do
+      with_tag('option[selected=selected]', '30')
+    end
+    output.should have_tag('select[id=person_birth_date_and_time_4i]') do
+      with_tag('option[selected=selected]', '12')
+    end
+    output.should have_tag('select[id=person_birth_date_and_time_5i]') do
+      with_tag('option[selected=selected]', '00')
+    end
+    output.should have_tag('select[id=person_birth_date_and_time_6i]') do
+      with_tag('option[selected=selected]', '22')
+    end
+  end
+  
+  it "should display datetime_select when datetime value is nil" do
+    @person.birth_date_and_time = nil
+    output = datetime_select(:person, :birth_date_and_time, :include_blank => true, :include_seconds => true)
+    output.should have_tag('select', 6)
+  end
+end

data/spec/active_record/attribute_methods_spec.rb

@@ -0,0 +1,204 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ValidatesTimeliness::ActiveRecord::AttributeMethods do
+  include ValidatesTimeliness::ActiveRecord::AttributeMethods
+  include ValidatesTimeliness::ValidationMethods
+  
+  before do
+    @person = Person.new
+  end
+
+  it "should call write_date_time_attribute when date attribute assigned value" do
+    @person.should_receive(:write_date_time_attribute)
+    @person.birth_date = "2000-01-01"
+  end
+
+  it "should call write_date_time_attribute when time attribute assigned value" do
+    @person.should_receive(:write_date_time_attribute)
+    @person.birth_time = "12:00"
+  end
+
+  it "should call write_date_time_attribute when datetime attribute assigned value" do
+    @person.should_receive(:write_date_time_attribute)
+    @person.birth_date_and_time = "2000-01-01 12:00"
+  end
+
+  it "should call parser on write for datetime attribute" do
+    @person.class.should_receive(:parse_date_time).once
+    @person.birth_date_and_time = "2000-01-01 02:03:04"
+  end
+
+  it "should call parser on write for date attribute" do
+    @person.class.should_receive(:parse_date_time).once
+    @person.birth_date = "2000-01-01"
+  end
+
+  it "should call parser on write for time attribute" do
+    @person.class.should_receive(:parse_date_time).once
+    @person.birth_time = "12:00"
+  end
+
+  it "should return raw string value for attribute_before_type_cast when written as string" do
+    time_string = "2000-01-01 02:03:04"
+    @person.birth_date_and_time = time_string
+    @person.birth_date_and_time_before_type_cast.should == time_string
+  end
+  
+  it "should return Time object for attribute_before_type_cast when written as Time" do
+    @person.birth_date_and_time = Time.mktime(2000, 1, 1, 2, 3, 4)
+    @person.birth_date_and_time_before_type_cast.should be_kind_of(Time)
+  end
+
+  it "should return Time object for datetime attribute read method when assigned Time object" do
+    @person.birth_date_and_time = Time.now
+    @person.birth_date_and_time.should be_kind_of(Time)
+  end
+
+  it "should return Time object for datetime attribute read method when assigned string" do
+    @person.birth_date_and_time = "2000-01-01 02:03:04"
+    @person.birth_date_and_time.should be_kind_of(Time)
+  end    
+ 
+  it "should return Date object for date attribute read method when assigned Date object" do
+    @person.birth_date = Date.today
+    @person.birth_date.should be_kind_of(Date)
+  end  
+ 
+  it "should return Date object for date attribute read method when assigned string" do
+    @person.birth_date = '2000-01-01'
+    @person.birth_date.should be_kind_of(Date)
+  end 
+ 
+  it "should return nil when time is invalid" do
+    @person.birth_date_and_time = "2000-01-32 02:03:04"
+    @person.birth_date_and_time.should be_nil
+  end
+
+  it "should not save invalid date value to database" do        
+    time_string = "2000-01-32 02:03:04"
+    @person = Person.new
+    @person.birth_date_and_time = time_string
+    @person.save
+    @person.reload
+    @person.birth_date_and_time_before_type_cast.should be_nil
+  end
+  
+  unless RAILS_VER < '2.1'
+    it "should return stored time string as Time with correct timezone" do
+      Time.zone = 'Melbourne'
+      time_string = "2000-06-01 02:03:04"
+      @person.birth_date_and_time = time_string
+      @person.birth_date_and_time.strftime('%Y-%m-%d %H:%M:%S %Z %z').should == time_string + ' EST +1000'
+    end
+
+    it "should return time object from database in correct timezone" do        
+      Time.zone = 'Melbourne'
+      time_string = "2000-06-01 09:00:00"
+      @person = Person.new
+      @person.birth_date_and_time = time_string
+      @person.save
+      @person.reload
+      @person.birth_date_and_time.strftime('%Y-%m-%d %H:%M:%S %Z %z').should == time_string + ' EST +1000'
+    end
+    
+    describe "dirty attributes" do
+    
+      it "should return true for attribute changed? when value updated" do
+        time_string = "2000-01-01 02:03:04"
+        @person.birth_date_and_time = time_string
+        @person.birth_date_and_time_changed?.should be_true
+      end
+    
+      it "should show changes when time attribute changed from nil to Time object" do
+        time_string = "2000-01-01 02:03:04"
+        @person.birth_date_and_time = time_string
+        time = @person.birth_date_and_time
+        @person.changes.should == {"birth_date_and_time" => [nil, time]}
+      end
+      
+      it "should show changes when time attribute changed from Time object to nil" do
+        time_string = "2020-01-01 02:03:04"
+        @person.birth_date_and_time = time_string
+        @person.save false
+        @person.reload
+        time = @person.birth_date_and_time
+        @person.birth_date_and_time = nil
+        @person.changes.should == {"birth_date_and_time" => [time, nil]}
+      end
+      
+      it "should show no changes when assigned same value as Time object" do
+        time_string = "2020-01-01 02:03:04"
+        @person.birth_date_and_time = time_string
+        @person.save false
+        @person.reload
+        time = @person.birth_date_and_time
+        @person.birth_date_and_time = time
+        @person.changes.should == {}
+      end
+      
+      it "should show no changes when assigned same value as time string" do
+        time_string = "2020-01-01 02:03:04"
+        @person.birth_date_and_time = time_string
+        @person.save false
+        @person.reload
+        @person.birth_date_and_time = time_string
+        @person.changes.should == {}
+      end
+      
+    end
+  else
+    
+    it "should return time object from database in default timezone" do        
+      ActiveRecord::Base.default_timezone = :utc
+      time_string = "2000-01-01 09:00:00"
+      @person = Person.new
+      @person.birth_date_and_time = time_string
+      @person.save
+      @person.reload
+      @person.birth_date_and_time.strftime('%Y-%m-%d %H:%M:%S %Z').should == time_string + ' GMT'
+    end
+      
+  end
+  
+  it "should return same time object on repeat reads on existing object" do
+    Time.zone = 'Melbourne' unless RAILS_VER < '2.1'
+    time_string = "2000-01-01 09:00:00"
+    @person = Person.new
+    @person.birth_date_and_time = time_string
+    @person.save!
+    @person.reload
+    time = @person.birth_date_and_time
+    @person.birth_date_and_time.should == time
+  end
+  
+  it "should return same date object on repeat reads on existing object" do
+    date_string = Date.today
+    @person = Person.new
+    @person.birth_date = date_string
+    @person.save!
+    @person.reload
+    date = @person.birth_date
+    @person.birth_date.should == date
+  end
+  
+  it "should return correct date value after new value assigned" do
+    today = Date.today
+    tomorrow = Date.today + 1.day    
+    @person = Person.new
+    @person.birth_date = today
+    @person.birth_date.should == today
+    @person.birth_date = tomorrow
+    @person.birth_date.should == tomorrow
+  end
+ 
+  it "should update date attribute on existing object" do
+    today = Date.today
+    tomorrow = Date.today + 1.day
+    @person = Person.create(:birth_date => today)
+    @person.birth_date = tomorrow
+    @person.save!
+    @person.reload
+    @person.birth_date.should == tomorrow
+  end
+ 
+end