adzap-validates_timeliness 1.1.1

data/lib/validates_timeliness/locale/en.yml

@@ -0,0 +1,12 @@
+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}}"
+        between: "must be between {{earliest}} and {{latest}}"

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

@@ -0,0 +1,157 @@
+module Spec
+  module Rails
+    module Matchers
+      class ValidateTimeliness
+   
+        VALIDITY_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'}
+        }
+
+        OPTION_TEST_SETTINGS = {
+          :before       => { :method => :-, :modify_on => :valid },
+          :after        => { :method => :+, :modify_on => :valid },
+          :on_or_before => { :method => :+, :modify_on => :invalid },
+          :on_or_after  => { :method => :-, :modify_on => :invalid }
+        }
+
+        def initialize(attribute, options)
+          @expected, @options = attribute, options
+          @validator = ValidatesTimeliness::Validator.new(options)
+        end
+
+        def matches?(record)
+          @record = record
+          @type = @options[:type]
+          
+          valid = test_validity
+
+          valid = test_option(:before) if @options[:before] && valid
+          valid = test_option(:after) if @options[:after] && valid
+          
+          valid = test_option(:on_or_before) if @options[:on_or_before] && valid
+          valid = test_option(:on_or_after) if @options[:on_or_after] && valid
+
+          valid = test_between if @options[:between] && valid
+
+          return valid
+        end
+      
+        def failure_message
+          "expected model to validate #{@type} attribute #{@expected.inspect} with #{@last_failure}"
+        end
+        
+        def negative_failure_message
+          "expected not to validate #{@type} attribute #{@expected.inspect}"
+        end
+        
+        def description
+          "have validated #{@type} attribute #{@expected.inspect}"
+        end
+        
+       private
+       
+        def test_validity
+          invalid_value = VALIDITY_TEST_VALUES[@type][:fail]
+          valid_value   = parse_and_cast(VALIDITY_TEST_VALUES[@type][:pass])
+          error_matching(invalid_value, "invalid_#{@type}".to_sym) &&
+            no_error_matching(valid_value, "invalid_#{@type}".to_sym)
+        end
+
+        def test_option(option)
+          settings = OPTION_TEST_SETTINGS[option]
+          boundary = parse_and_cast(@options[option])
+          
+          method = settings[:method]
+
+          valid_value, invalid_value = if settings[:modify_on] == :valid
+            [ boundary.send(method, 1), boundary ]
+          else
+            [ boundary, boundary.send(method, 1) ]
+          end
+          
+          error_matching(invalid_value, option) && 
+            no_error_matching(valid_value, option)
+        end
+
+        def test_before
+          before = parse_and_cast(@options[:before])
+
+          error_matching(before - 1, :before) && 
+            no_error_matching(before, :before)
+        end
+
+        def test_between
+          between = parse_and_cast(@options[:between]) 
+          
+          error_matching(between.first - 1, :between) && 
+            error_matching(between.last + 1, :between) && 
+            no_error_matching(between.first, :between) &&
+            no_error_matching(between.last, :between)
+        end
+       
+        def parse_and_cast(value)
+          value = @validator.send(:restriction_value, value, @record)
+          @validator.send(:type_cast_value, value)
+        end
+
+        def error_matching(value, option)
+          match = error_message_for(option)
+          @record.send("#{@expected}=", value)
+          @record.valid?
+          errors = @record.errors.on(@expected)
+          pass = [ errors ].flatten.any? {|error| /#{match}/ === error }
+          @last_failure = "error matching '#{match}' when value is #{format_value(value)}" unless pass
+          pass
+        end
+        
+        def no_error_matching(value, option)
+          pass = !error_matching(value, option)
+          unless pass
+            error = error_message_for(option)
+            @last_failure = "no error matching '#{error}' when value is #{format_value(value)}"
+          end
+          pass
+        end
+
+        def error_message_for(option)
+          msg = @validator.send(:error_messages)[option]
+          restriction = @validator.send(:restriction_value, @validator.configuration[option], @record)
+
+          if restriction 
+            restriction = [restriction] unless restriction.is_a?(Array)
+            restriction.map! {|r| @validator.send(:type_cast_value, r) }
+            interpolate = @validator.send(:interpolation_values, option, restriction )
+            if defined?(I18n)
+              msg = @record.errors.generate_message(@expected, option, interpolate)
+            else
+              msg = msg % interpolate
+            end
+          end 
+          msg
+        end
+        
+        def format_value(value)
+          return value if value.is_a?(String)
+          value.strftime(ValidatesTimeliness::Validator.error_value_formats[@type])
+        end
+      end
+
+      def validate_date(attribute, options={})
+        options[:type] = :date
+        ValidateTimeliness.new(attribute, options)
+      end
+
+      def validate_time(attribute, options={})
+        options[:type] = :time
+        ValidateTimeliness.new(attribute, options)
+      end
+
+      def validate_datetime(attribute, options={})
+        options[:type] = :datetime
+        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,163 @@
+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'
+    }
+
+    RESTRICTION_METHODS = {
+      :before       => :<, 
+      :after        => :>, 
+      :on_or_before => :<=,
+      :on_or_after  => :>=,
+      :between      => lambda {|v, r| (r.first..r.last).include?(v) } 
+    }
+
+    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)
+      value = type_cast_value(value)
+      
+      RESTRICTION_METHODS.each do |option, method|
+        next unless restriction = configuration[option]
+        begin
+          restriction = restriction_value(restriction, record)
+          next if restriction.nil?
+          restriction = type_cast_value(restriction)
+
+          unless evaluate_restriction(restriction, value, method)
+            add_error(record, attr_name, option, interpolation_values(option, restriction))
+          end
+        rescue
+          unless self.class.ignore_restriction_errors
+            add_error(record, attr_name, "restriction '#{option}' value was invalid")
+          end
+        end
+      end
+    end
+
+    def interpolation_values(option, restriction)
+      format = self.class.error_value_formats[type]
+      restriction = [restriction] unless restriction.is_a?(Array)
+
+      if defined?(I18n)
+        message = custom_error_messages[option] || I18n.translate('activerecord.errors.messages')[option]
+        subs = message.scan(/\{\{([^\}]*)\}\}/)
+        interpolations = {}
+        subs.each_with_index {|s, i| interpolations[s[0].to_sym] = restriction[i].strftime(format) }
+        interpolations
+      else
+        restriction.map {|r| r.strftime(format) }
+      end
+    end
+
+    def evaluate_restriction(restriction, value, comparator)
+      return true if restriction.nil?
+
+      case comparator
+        when Symbol
+          value.send(comparator, restriction)
+        when Proc
+          comparator.call(value, restriction)
+      end
+    end
+    
+    def add_error(record, attr_name, message, interpolate=nil)
+      if defined?(I18n)
+        # 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 || {})
+      else
+        message = error_messages[message] if message.is_a?(Symbol)
+        message = message % interpolate
+        record.errors.add(attr_name, message)
+      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({}) {|msgs, (k, v)|
+        if md = /(.*)_message$/.match(k.to_s) 
+          msgs[md[0].to_sym] = v 
+        end
+        msgs
+      }
+    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)
+        when Array
+          restriction.map {|r| restriction_value(r, record) }.sort
+        when Range
+          restriction_value([restriction.first, restriction.last], record)
+        else
+         record.class.parse_date_time(restriction, type, false)
+      end
+    end
+    
+    def type_cast_value(value)
+      if value.is_a?(Array)
+        value.map {|v| type_cast_value(v) }
+      else 
+        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(ValidatesTimeliness.default_timezone)
+          end
+        else
+          nil
+        end
+      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