szilm-validates_timeliness 2.3.1

data/lib/validates_timeliness/locale/en.yml

@@ -0,0 +1,18 @@
+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"
+        is_at: "must be at {{restriction}}"
+        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}}"
+  validates_timeliness:
+    error_value_formats:
+      date: '%Y-%m-%d'
+      time: '%H:%M:%S'
+      datetime: '%Y-%m-%d %H:%M:%S'

data/lib/validates_timeliness/matcher.rb

@@ -0,0 +1 @@
+require 'validates_timeliness/spec/rails/matchers/validate_timeliness'

data/lib/validates_timeliness/parser.rb

@@ -0,0 +1,44 @@
+module ValidatesTimeliness
+  module Parser
+
+    class << self
+
+      def parse(raw_value, type, options={})
+        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, options.reverse_merge(:strict => true))
+        return nil if time_array.nil?
+        
+        if type == :date
+          Date.new(*time_array[0..2]) rescue nil
+        else
+          make_time(time_array[0..7])
+        end
+      end
+
+      def make_time(time_array)
+        # Enforce date part validity which Time class does not
+        return nil unless Date.valid_civil?(*time_array[0..2])
+
+        if Time.respond_to?(:zone) && ValidatesTimeliness.use_time_zones
+          Time.zone.local(*time_array)
+        else
+          # Older AR way of handling times with datetime fallback
+          begin
+            time_zone = ValidatesTimeliness.default_timezone
+            Time.send(time_zone, *time_array)
+          rescue ArgumentError, TypeError
+            zone_offset = time_zone == :local ? DateTime.local_offset : 0
+            time_array.pop # remove microseconds
+            DateTime.civil(*(time_array << zone_offset))
+          end
+        end
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,162 @@
+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 = {
+          :is_at        => { :method => :+, :modify_on => :invalid },
+          :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(:is_at)        if valid && @options[:is_at]
+          valid = test_option(:before)       if valid && @options[:before]
+          valid = test_option(:after)        if valid && @options[:after]
+          valid = test_option(:on_or_before) if valid && @options[:on_or_before]
+          valid = test_option(:on_or_after)  if valid && @options[:on_or_after]
+          valid = test_between               if valid && @options[:between]
+
+          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.class.send(:evaluate_option_value, value, @type, @record)
+          @validator.class.send(:type_cast_value, value, @type)
+        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(message)
+          restriction = @validator.class.send(:evaluate_option_value, @validator.configuration[message], @type, @record)
+
+          if restriction
+            restriction = @validator.class.send(:type_cast_value, restriction, @type)
+            interpolate = @validator.send(:interpolation_values, message, restriction)
+          end
+
+          if defined?(I18n)
+            interpolate ||= {}
+            options = interpolate.merge(:default => @validator.send(:custom_error_messages)[message])
+            if defined?(ActiveRecord::Error)
+              ActiveRecord::Error.new(@record, @expected, message, options).message
+            else
+              @record.errors.generate_message(@expected, message, options)
+            end
+          else
+            interpolate ||= nil
+            @validator.error_messages[message] % interpolate
+          end
+        end
+
+        def format_value(value)
+          return value if value.is_a?(String)
+          value.strftime(@validator.class.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,46 @@
+module ValidatesTimeliness
+  module ValidationMethods
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      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.symbolize_keys)
+        
+        # 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, value)
+        end
+      end
+
+    end
+
+  end
+end
+
+ActiveRecord::Base.send(:include, ValidatesTimeliness::ValidationMethods)

data/lib/validates_timeliness/validator.rb

@@ -0,0 +1,230 @@
+#TODO remove deprecated option :equal_to
+module ValidatesTimeliness
+
+  class Validator
+    cattr_accessor :error_value_formats
+    cattr_accessor :ignore_restriction_errors
+    self.ignore_restriction_errors = false
+
+    RESTRICTION_METHODS = {
+      :is_at        => :==,
+      :equal_to     => :==,
+      :before       => :<,
+      :after        => :>,
+      :on_or_before => :<=,
+      :on_or_after  => :>=,
+      :between      => lambda {|v, r| (r.first..r.last).include?(v) }
+    }
+
+    VALID_OPTION_KEYS = [
+      :on, :if, :unless, :allow_nil, :empty, :allow_blank,
+      :with_time, :with_date, :ignore_usec, :format,
+      :invalid_time_message, :invalid_date_message, :invalid_datetime_message
+    ] + RESTRICTION_METHODS.keys.map {|option| [option, "#{option}_message".to_sym] }.flatten
+
+    DEFAULT_OPTIONS = { :on => :save, :type => :datetime, :allow_nil => false, :allow_blank => false, :ignore_usec => false }
+
+    attr_reader :configuration, :type
+
+    def initialize(configuration)
+      @configuration = DEFAULT_OPTIONS.merge(configuration)
+      @type = @configuration.delete(:type)
+      validate_options(@configuration)
+    end
+
+    def call(record, attr_name, value)
+      raw_value = raw_value(record, attr_name) || value
+
+      if value.is_a?(String) || configuration[:format]
+        value = ValidatesTimeliness::Parser.parse(raw_value, type, :strict => false, :format => configuration[:format])
+      end
+
+      return if (raw_value.nil? && configuration[:allow_nil]) || (raw_value.blank? && configuration[:allow_blank])
+
+      return add_error(record, attr_name, :blank) if raw_value.blank?
+      return add_error(record, attr_name, "invalid_#{type}".to_sym) if value.nil?
+
+      validate_restrictions(record, attr_name, value)
+    end
+
+    def error_messages
+      @error_messages ||= ::ActiveRecord::Errors.default_error_messages.merge(custom_error_messages)
+    end
+
+   private
+
+    def raw_value(record, attr_name)
+      record.send("#{attr_name}_before_type_cast") rescue nil
+    end
+
+    def validate_restrictions(record, attr_name, value)
+      if configuration[:with_time] || configuration[:with_date]
+        value = combine_date_and_time(value, record)
+      end
+
+      value = self.class.type_cast_value(value, implied_type, configuration[:ignore_usec])
+
+      return if value.nil?
+
+      RESTRICTION_METHODS.each do |option, method|
+        next unless restriction = configuration[option]
+        begin
+          restriction = self.class.evaluate_option_value(restriction, implied_type, record)
+          next if restriction.nil?
+          restriction = self.class.type_cast_value(restriction, implied_type, configuration[:ignore_usec])
+
+          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_format_for(type)
+      restriction = [restriction] unless restriction.is_a?(Array)
+
+      if defined?(I18n)
+        interpolations = {}
+        keys = restriction.size == 1 ? [:restriction] : [:earliest, :latest]
+        keys.each_with_index {|key, i| interpolations[key] = 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)
+        custom = custom_error_messages[message]
+        record.errors.add(attr_name, message, { :default => custom }.merge(interpolate || {}))
+      else
+        message = error_messages[message] if message.is_a?(Symbol)
+        record.errors.add(attr_name, message % interpolate)
+      end
+    end
+
+    def custom_error_messages
+      @custom_error_messages ||= configuration.inject({}) {|msgs, (k, v)|
+        if md = /(.*)_message$/.match(k.to_s)
+          msgs[md[1].to_sym] = v
+        end
+        msgs
+      }
+    end
+
+    def combine_date_and_time(value, record)
+      if type == :date
+        date = value
+        time = configuration[:with_time]
+      else
+        date = configuration[:with_date]
+        time = value
+      end
+      date, time = self.class.evaluate_option_value(date, :date, record), self.class.evaluate_option_value(time, :time, record)
+      return if date.nil? || time.nil?
+      ValidatesTimeliness::Parser.make_time([date.year, date.month, date.day, time.hour, time.min, time.sec, time.usec])
+    end
+
+    def validate_options(options)
+      if options.key?(:equal_to)
+        ::ActiveSupport::Deprecation.warn("ValidatesTimeliness :equal_to option is deprecated due to clash with a default Rails option. Use :is_at instead. You will need to fix any I18n error message references to this option date/time attributes now.")
+        options[:is_at] = options.delete(:equal_to)
+        options[:is_at_message] = options.delete(:equal_to_message)
+      end
+
+      invalid_for_type = ([:time, :date, :datetime] - [type]).map {|k| "invalid_#{k}_message".to_sym }
+      invalid_for_type << :with_date unless type == :time
+      invalid_for_type << :with_time unless type == :date
+      options.assert_valid_keys(VALID_OPTION_KEYS - invalid_for_type)
+    end
+
+    def implied_type
+      @implied_type ||= configuration[:with_date] || configuration[:with_time] ? :datetime : type
+    end
+
+    # class methods
+    class << self
+
+      def error_value_format_for(type)
+        if defined?(I18n)
+          # work around for syntax check in vendored I18n for Rails <= 2.3.3
+          I18n.t('validates_timeliness.error_value_formats')[type] || error_value_formats[type]
+        else
+          error_value_formats[type]
+        end
+      end
+
+      def evaluate_option_value(value, type, record)
+        case value
+        when Time, Date
+          value
+        when Symbol
+          evaluate_option_value(record.send(value), type, record)
+        when Proc
+          result = value.arity > 0 ? value.call(record) : value.call
+          evaluate_option_value(result, type, record)
+        when Array
+          value.map {|r| evaluate_option_value(r, type, record) }.sort
+        when Range
+          evaluate_option_value([value.first, value.last], type, record)
+        else
+          ValidatesTimeliness::Parser.parse(value, type, :strict => false)
+        end
+      end
+
+      def type_cast_value(value, type, ignore_usec=false)
+        if value.is_a?(Array)
+          value.map {|v| type_cast_value(v, type, ignore_usec) }
+        else
+          value = case type
+          when :time
+            dummy_time(value)
+          when :date
+            value.to_date
+          when :datetime
+            if value.is_a?(Time) || value.is_a?(DateTime)
+              value.to_time
+            else
+              value.to_time(ValidatesTimeliness.default_timezone)
+            end
+          else
+            nil
+          end
+          if ignore_usec && value.is_a?(Time)
+            ValidatesTimeliness::Parser.make_time(Array(value).reverse[4..9])
+          else
+            value
+          end
+        end
+      end
+
+      def dummy_time(value)
+        if value.is_a?(Time) || value.is_a?(DateTime)
+          time = [value.hour, value.min, value.sec]
+        else
+          time = [0,0,0]
+        end
+        dummy_date = ValidatesTimeliness::Formats.dummy_date_for_time_type
+        ValidatesTimeliness::Parser.make_time(dummy_date + time)
+      end
+
+    end
+
+  end
+end