validates_timeliness 2.3.2 → 3.0.0.beta

data/lib/validates_timeliness/validator.rb

@@ -1,230 +1,67 @@
-#TODO remove deprecated option :equal_to
+require 'active_model/validator'
+
 module ValidatesTimeliness
+  class Validator < ActiveModel::EachValidator
+    include Conversion
 
-  class Validator
-    cattr_accessor :error_value_formats
-    cattr_accessor :ignore_restriction_errors
-    self.ignore_restriction_errors = false
+    attr_reader :type
 
-    RESTRICTION_METHODS = {
+    RESTRICTIONS = {
       :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
+    }.freeze
 
-    def initialize(configuration)
-      @configuration = DEFAULT_OPTIONS.merge(configuration)
-      @type = @configuration.delete(:type)
-      validate_options(@configuration)
+    def self.kind
+      :timeliness
     end
 
-    def call(record, attr_name, value)
-      raw_value = raw_value(record, attr_name) || value
+    def initialize(options)
+      @type = options.delete(:type) || :datetime
+      @allow_nil, @allow_blank = options.delete(:allow_nil), options.delete(:allow_blank)
+      @restrictions_to_check = RESTRICTIONS.keys & options.keys
 
-      if value.is_a?(String) || configuration[:format]
-        value = ValidatesTimeliness::Parser.parse(raw_value, type, :strict => false, :format => configuration[:format])
+      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], options[:on_or_before] = range.first, range.last
       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)
+      super
     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
+    def validate_each(record, attr_name, value)
+      raw_value = record._timeliness_raw_value_for(attr_name) || value
+      return if (@allow_nil && raw_value.nil?) || (@allow_blank && raw_value.blank?)
 
-      value = self.class.type_cast_value(value, implied_type, configuration[:ignore_usec])
+      @timezone_aware = record.class.timeliness_attribute_timezone_aware?(attr_name)
+      value = parse(value) if value.is_a?(String)
+      value = type_cast_value(value, @type)
 
-      return if value.nil?
+      return record.errors.add(attr_name, :"invalid_#{@type}") if value.blank?
 
-      RESTRICTION_METHODS.each do |option, method|
-        next unless restriction = configuration[option]
+      @restrictions_to_check.each do |restriction|
         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])
+          restriction_value = type_cast_value(evaluate_option_value(options[restriction], record), @type)
 
-          unless evaluate_restriction(restriction, value, method)
-            add_error(record, attr_name, option, interpolation_values(option, restriction))
+          unless value.send(RESTRICTIONS[restriction], restriction_value)
+            return record.errors.add(attr_name, restriction, :message => options[:"#{restriction}_message"], :restriction => format_error_value(restriction_value))
           end
-        rescue
-          unless self.class.ignore_restriction_errors
-            add_error(record, attr_name, "restriction '#{option}' value was invalid")
+        rescue => e
+          unless ValidatesTimeliness.ignore_restriction_errors
+            record.errors[attr_name] = "Error occurred validating #{attr_name} for #{restriction.inspect} restriction:\n#{e.message}" 
           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
-
+    def format_error_value(value)
+      format = I18n.t(@type, :scope => 'validates_timeliness.error_value_formats')
+      value.strftime(format)
     end
 
   end
 end
+
+# Compatibility with ActiveModel validates method which matches option keys to their validator class
+TimelinessValidator = ValidatesTimeliness::Validator

data/lib/validates_timeliness/version.rb

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

data/spec/model_helpers.rb

@@ -0,0 +1,27 @@
+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|
+      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|
+      record.should be_valid
+    end
+  end
+
+  def with_each_person_value(attr_name, values)
+    record = Person.new
+    values = [values] unless values.is_a?(Array)
+    values.each do |value|
+      record.send("#{attr_name}=", value)
+      yield record, value
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -1,58 +1,89 @@
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-$:.unshift(File.dirname(__FILE__))
-$:.unshift(File.dirname(__FILE__) + '/resources')
+require 'rspec'
+require 'rspec/autorun'
 
-RAILS_ENV = ENV['RAILS_ENV'] = 'test'
-
-require 'rubygems'
-require 'spec/autorun'
+require 'active_model'
+require 'active_model/validations'
+require 'active_record'
+require 'action_view'
+require 'timecop'
+require 'rspec_tag_matchers'
+require 'model_helpers'
 
-vendored_rails = File.dirname(__FILE__) + '/../../../../vendor/rails'
+require 'validates_timeliness'
+require 'test_model'
 
-if vendored = File.exists?(vendored_rails)
-  Dir.glob(vendored_rails + "/**/lib").each { |dir| $:.unshift dir }
-else
-  begin
-   require 'ginger'
-  rescue LoadError
-  end
-  if ENV['VERSION']
-    gem 'rails', ENV['VERSION']
-  else
-    gem 'rails'
-  end
+ValidatesTimeliness.setup do |c|
+  c.extend_orms = [ :active_record ]
+  c.enable_date_time_select_extension!
+  c.enable_multiparameter_extension!
+  c.default_timezone = :utc
 end
 
-RAILS_ROOT = File.dirname(__FILE__)
+Time.zone = 'Australia/Melbourne'
 
-require 'rails/version'
-require 'active_record'
-require 'active_record/version'
-require 'action_controller'
-require 'action_view'
-require 'action_mailer'
+LOCALE_PATH = File.expand_path(File.dirname(__FILE__) + '/../lib/generators/validates_timeliness/templates/en.yml')
+I18n.load_path.unshift(LOCALE_PATH)
 
-require 'spec/rails'
-require 'time_travel/time_travel'
+# Extend TestModel as you would another ORM/ODM module
+module TestModel
+  include ValidatesTimeliness::HelperMethods
+  include ValidatesTimeliness::AttributeMethods
 
-ActiveRecord::Base.default_timezone = :utc
-RAILS_VER = Rails::VERSION::STRING
-puts "Using #{vendored ? 'vendored' : 'gem'} Rails version #{RAILS_VER} (ActiveRecord version #{ActiveRecord::VERSION::STRING})"
+  def self.included(base)
+    base.extend HookMethods
+  end
 
-if RAILS_VER >= '2.1'
-  Time.zone_default = ActiveSupport::TimeZone['UTC']
-  ActiveRecord::Base.time_zone_aware_attributes = true
-end
+  module HookMethods
+    # Hook method for attribute method generation
+    def define_attribute_methods(attr_names)
+      super
+      define_timeliness_methods
+    end
 
-require 'validates_timeliness'
-require 'validates_timeliness/matcher'
+    # Hook into native time zone handling check, if any
+    def timeliness_attribute_timezone_aware?(attr_name)
+      false
+    end
+  end
+end
 
-ValidatesTimeliness.enable_datetime_select_extension!
+class Person
+  include TestModel
+  self.model_attributes = :birth_date, :birth_time, :birth_datetime
+  validates_date :birth_date
+  validates_time :birth_time
+  validates_datetime :birth_datetime
+  define_attribute_methods model_attributes
+end
 
-ActiveRecord::Migration.verbose = false
 ActiveRecord::Base.establish_connection({:adapter => 'sqlite3', :database => ':memory:'})
+ActiveRecord::Migration.verbose = false
+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.datetime :birth_datetime
+  end
+end
 
-require 'sqlite_patch' if RAILS_VER < '2.1'
+class Employee < ActiveRecord::Base
+  validates_date :birth_date
+  validates_time :birth_time
+  validates_datetime :birth_datetime
+  define_attribute_methods
+end
 
-require 'schema'
-require 'person'
+Rspec.configure do |c|
+  c.mock_with :rspec
+  c.include(RspecTagMatchers)
+  c.before do
+    Person.reset_callbacks(:validate)
+    Person.timeliness_validated_attributes = {}
+    Person._validators.clear
+    Employee.reset_callbacks(:validate)
+    Employee.timeliness_validated_attributes = {}
+    Employee._validators.clear
+  end
+end

data/spec/test_model.rb

@@ -0,0 +1,56 @@
+module TestModel
+  extend  ActiveSupport::Concern
+
+  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 define_method_attribute=(attr_name)
+      generated_attribute_methods.module_eval("def #{attr_name}=(new_value); @attributes['#{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
+  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
+    end
+  end
+
+  def initialize(attributes = nil)
+    @attributes = self.class.model_attributes.inject({}) do |hash, column|
+      hash[column.to_s] = nil
+      hash
+    end
+    self.attributes = attributes unless attributes.nil?
+  end
+
+  def attributes
+    @attributes.keys
+  end
+
+  def attributes=(new_attributes={})
+    new_attributes.each do |key, value|
+      send "#{key}=", value
+    end
+  end
+
+end
+