jc-validates_timeliness 3.1.0

data/lib/validates_timeliness/extensions.rb

@@ -0,0 +1,14 @@
+module ValidatesTimeliness
+  module Extensions
+    autoload :DateTimeSelect,        'validates_timeliness/extensions/date_time_select'
+    autoload :MultiparameterHandler, 'validates_timeliness/extensions/multiparameter_handler'
+  end
+
+  def self.enable_date_time_select_extension!
+    ::ActionView::Helpers::InstanceTag.send(:include, ValidatesTimeliness::Extensions::DateTimeSelect)
+  end
+
+  def self.enable_multiparameter_extension!
+    ::ActiveRecord::Base.send(:include, ValidatesTimeliness::Extensions::MultiparameterHandler)
+  end
+end

data/lib/validates_timeliness/extensions/date_time_select.rb

@@ -0,0 +1,61 @@
+module ValidatesTimeliness
+  module Extensions
+    module DateTimeSelect
+      extend ActiveSupport::Concern
+
+      # 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.
+      # It's a minor usability improvement which is rarely an issue for the user.
+
+      included do
+        alias_method_chain :datetime_selector, :timeliness
+        alias_method_chain :value, :timeliness
+      end
+
+      class TimelinessDateTime
+        attr_accessor :year, :month, :day, :hour, :min, :sec
+
+        def initialize(year, month, day, hour, min, sec)
+          @year, @month, @day, @hour, @min, @sec = year, month, day, hour, min, sec
+        end
+
+        # adapted from activesupport/lib/active_support/core_ext/date_time/calculations.rb, line 36 (3.0.7)
+        def change(options)
+          TimelinessDateTime.new(
+            options[:year]  || year,
+            options[:month] || month,
+            options[:day]   || day,
+            options[:hour]  || hour,
+            options[:min]   || (options[:hour] ? 0 : min),
+            options[:sec]   || ((options[:hour] || options[:min]) ? 0 : sec)
+          )
+        end
+      end
+
+      def datetime_selector_with_timeliness(*args)
+        @timeliness_date_or_time_tag = true
+        datetime_selector_without_timeliness(*args)
+      end
+
+      def value_with_timeliness(object)
+        unless @timeliness_date_or_time_tag && @template_object.params[@object_name]
+          return value_without_timeliness(object)
+        end
+
+        @template_object.params[@object_name]
+
+        pairs = @template_object.params[@object_name].select {|k,v| k =~ /^#{@method_name}\(/ }
+        return value_without_timeliness(object) if pairs.empty?
+
+        values = [nil] * 6
+        pairs.map do |(param, value)|
+          position = param.scan(/\((\d+)\w+\)/).first.first
+          values[position.to_i-1] = value.to_i
+        end
+
+        TimelinessDateTime.new(*values)
+      end
+    end
+  end
+end

data/lib/validates_timeliness/extensions/multiparameter_handler.rb

@@ -0,0 +1,80 @@
+module ValidatesTimeliness
+  module Extensions
+    module MultiparameterHandler
+      extend ActiveSupport::Concern
+
+      # Stricter handling of date and time values from multiparameter 
+      # assignment from the date/time select view helpers
+
+      included do
+        alias_method_chain :instantiate_time_object, :timeliness
+        alias_method :execute_callstack_for_multiparameter_attributes, :execute_callstack_for_multiparameter_attributes_with_timeliness
+        alias_method :read_value_from_parameter, :read_value_from_parameter_with_timeliness
+      end
+
+      private
+
+      def invalid_multiparameter_date_or_time_as_string(values)
+        value =  [values[0], *values[1..2].map {|s| s.to_s.rjust(2,"0")} ].join("-")
+        value += ' ' + values[3..5].map {|s| s.to_s.rjust(2, "0") }.join(":") unless values[3..5].empty?
+        value
+      end
+
+      def instantiate_time_object_with_timeliness(name, values)
+        validate_multiparameter_date_values(values) {
+          instantiate_time_object_without_timeliness(name, values)
+        }
+      end
+
+      def instantiate_date_object(name, values)
+        validate_multiparameter_date_values(values) {
+          Date.new(*values)
+        }
+      end
+
+      # Yield if date values are valid
+      def validate_multiparameter_date_values(values)
+        if values[0..2].all?{ |v| v.present? } && Date.valid_civil?(*values[0..2])
+          yield
+        else
+          invalid_multiparameter_date_or_time_as_string(values)
+        end
+      end
+
+      def read_value_from_parameter_with_timeliness(name, values_from_param)
+        klass = (self.class.reflect_on_aggregation(name.to_sym) || column_for_attribute(name)).klass
+        values = values_from_param.is_a?(Hash) ? values_from_param.to_a.sort_by(&:first).map(&:last) : values_from_param
+
+        if values.empty? || values.all?{ |v| v.nil? }
+          nil
+        elsif klass == Time
+          instantiate_time_object(name, values)
+        elsif klass == Date
+          instantiate_date_object(name, values)
+        else
+          if respond_to?(:read_other_parameter_value)
+            read_date_parameter_value(name, values_from_param)
+          else
+            klass.new(*values)
+          end
+        end
+      end
+
+      def execute_callstack_for_multiparameter_attributes_with_timeliness(callstack)
+        errors = []
+        callstack.each do |name, values_with_empty_parameters|
+          begin
+            send(name + "=", read_value_from_parameter(name, values_with_empty_parameters))
+          rescue => ex
+            values = values_with_empty_parameters.is_a?(Hash) ? values_with_empty_parameters.values : values_with_empty_parameters 
+            errors << ActiveRecord::AttributeAssignmentError.new("error on assignment #{values.inspect} to #{name}", ex, name)
+          end
+        end
+        unless errors.empty?
+          raise ActiveRecord::MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes"
+        end
+      end
+
+    end
+  end
+end

data/lib/validates_timeliness/helper_methods.rb

@@ -0,0 +1,23 @@
+module ActiveModel
+  module Validations
+
+    module HelperMethods
+      def validates_date(*attr_names)
+        timeliness_validation_for attr_names, :date
+      end
+
+      def validates_time(*attr_names)
+        timeliness_validation_for attr_names, :time
+      end
+
+      def validates_datetime(*attr_names)
+        timeliness_validation_for attr_names, :datetime
+      end
+
+      def timeliness_validation_for(attr_names, type)
+        validates_with TimelinessValidator, _merge_attributes(attr_names).merge(:type => type)
+      end
+    end
+
+  end
+end

data/lib/validates_timeliness/orm/active_record.rb

@@ -0,0 +1,53 @@
+module ValidatesTimeliness
+  module ORM
+    module ActiveRecord
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        public
+
+        def timeliness_attribute_timezone_aware?(attr_name)
+          create_time_zone_conversion_attribute?(attr_name, timeliness_column_for_attribute(attr_name))
+        end
+
+        def timeliness_attribute_type(attr_name)
+          timeliness_column_for_attribute(attr_name).type
+        end
+
+        def timeliness_column_for_attribute(attr_name)
+          columns_hash.fetch(attr_name.to_s) do |attr_name|
+            validation_type = _validators[attr_name.to_sym].find {|v| v.kind == :timeliness }.type
+            ::ActiveRecord::ConnectionAdapters::Column.new(attr_name, nil, validation_type.to_s)
+          end
+        end
+
+        def define_attribute_methods
+          super.tap do |attribute_methods_generated|
+            define_timeliness_methods true
+          end
+        end
+
+        protected
+
+        def timeliness_type_cast_code(attr_name, var_name)
+          type = timeliness_attribute_type(attr_name)
+
+          method_body = super
+          method_body << "\n#{var_name} = #{var_name}.to_date if #{var_name}" if type == :date
+          method_body
+        end
+      end
+
+      def reload(*args)
+        _clear_timeliness_cache
+        super
+      end
+
+    end
+  end
+end
+
+class ActiveRecord::Base
+  include ValidatesTimeliness::AttributeMethods
+  include ValidatesTimeliness::ORM::ActiveRecord
+end

data/lib/validates_timeliness/orm/mongoid.rb

@@ -0,0 +1,63 @@
+module ValidatesTimeliness
+  module ORM
+    module Mongoid
+      extend ActiveSupport::Concern
+      # You need define the fields before you define the validations.
+      # It is best to use the plugin parser to avoid errors on a bad
+      # field value in Mongoid. Parser will return nil rather than error.
+
+      module ClassMethods 
+        public
+
+        # 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) }
+        end
+
+        def timeliness_attribute_type(attr_name)
+          {
+            Date => :date,
+            Time => :time,
+            DateTime => :datetime
+          }[fields[attr_name.to_s].type] || :datetime
+        end
+
+        protected
+
+        def timeliness_type_cast_code(attr_name, var_name)
+          type = timeliness_attribute_type(attr_name)
+
+          "#{var_name} = Timeliness::Parser.parse(value, :#{type})"
+        end
+
+      end
+
+      module Reload
+        def reload(*args)
+          _clear_timeliness_cache
+          super
+        end
+      end
+    end
+  end
+end
+ 
+module Mongoid::Document
+  include ValidatesTimeliness::AttributeMethods
+  include ValidatesTimeliness::ORM::Mongoid
+
+  # Pre-2.3 reload
+  if (instance_methods & ['reload', :reload]).present?
+    def reload_with_timeliness
+      _clear_timeliness_cache
+      reload_without_timeliness
+    end
+    alias_method_chain :reload, :timeliness
+  else
+    include ValidatesTimeliness::ORM::Mongoid::Reload
+  end
+end

data/lib/validates_timeliness/railtie.rb

@@ -0,0 +1,15 @@
+module ValidatesTimeliness
+  class Railtie < Rails::Railtie
+    initializer "validates_timeliness.initialize_active_record", :after => 'active_record.initialize_timezone' do
+      ActiveSupport.on_load(:active_record) do
+        ValidatesTimeliness.default_timezone = ActiveRecord::Base.default_timezone
+        ValidatesTimeliness.extend_orms << :active_record
+        ValidatesTimeliness.load_orms
+      end
+    end
+
+    initializer "validates_timeliness.initialize_restriction_errors" do
+      ValidatesTimeliness.ignore_restriction_errors = !Rails.env.test?
+    end
+  end
+end

data/lib/validates_timeliness/validator.rb

@@ -0,0 +1,117 @@
+require 'active_model'
+require 'active_model/validator'
+
+module ValidatesTimeliness
+  class Validator < ActiveModel::EachValidator
+    include Conversion
+
+    attr_reader :type
+
+    RESTRICTIONS = {
+      :is_at        => :==,
+      :before       => :<,
+      :after        => :>,
+      :on_or_before => :<=,
+      :on_or_after  => :>=,
+    }.freeze
+
+    DEFAULT_ERROR_VALUE_FORMATS = {
+      :date => '%Y-%m-%d',
+      :time => '%H:%M:%S',
+      :datetime => '%Y-%m-%d %H:%M:%S'
+    }.freeze
+
+    RESTRICTION_ERROR_MESSAGE = "Error occurred validating %s for %s restriction:\n%s"
+
+    # Prior to version 4.1, Rails will call `#setup`, if defined. This method is deprecated in Rails 4.1 and removed
+    # altogether in 4.2.
+    SETUP_DEPRECATED = ActiveModel.respond_to?(:version) && ActiveModel.version >= Gem::Version.new('4.1')
+
+    def self.kind
+      :timeliness
+    end
+
+    def initialize(options)
+      @type = options.delete(:type) || :datetime
+      @allow_nil, @allow_blank = options.delete(:allow_nil), options.delete(:allow_blank)
+
+      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] = range.first
+        if range.is_a?(Range) && range.exclude_end?
+          options[:before] = range.last
+        else
+          options[:on_or_before] = range.last
+        end
+      end
+
+      @restrictions_to_check = RESTRICTIONS.keys & options.keys
+      super
+      setup_timeliness_validated_attributes(options[:class]) if options[:class]
+    end
+
+    def setup_timeliness_validated_attributes(model)
+      if model.respond_to?(:timeliness_validated_attributes)
+        model.timeliness_validated_attributes ||= []
+        model.timeliness_validated_attributes |= @attributes
+      end
+    end
+
+    # Provide backwards compatibility for Rails < 4.1, which expects `#setup` to be defined.
+    alias_method :setup, :setup_timeliness_validated_attributes unless SETUP_DEPRECATED
+
+    def validate_each(record, 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 = timezone_aware?(record, attr_name)
+      value = parse(raw_value) if value.is_a?(String) || options[:format]
+      value = type_cast_value(value, @type)
+
+      add_error(record, attr_name, :"invalid_#{@type}") and return if value.blank?
+
+      validate_restrictions(record, attr_name, value)
+    end
+
+    def validate_restrictions(record, attr_name, value)
+      @restrictions_to_check.each do |restriction|
+        begin
+          restriction_value = type_cast_value(evaluate_option_value(options[restriction], record), @type)
+          unless value.send(RESTRICTIONS[restriction], restriction_value)
+            add_error(record, attr_name, restriction, restriction_value) and break
+          end
+        rescue => e
+          unless ValidatesTimeliness.ignore_restriction_errors
+            message = RESTRICTION_ERROR_MESSAGE % [ attr_name, restriction.inspect, e.message ]
+            add_error(record, attr_name, message) and break
+          end
+        end
+      end
+    end
+
+    def add_error(record, attr_name, message, value=nil)
+      value = format_error_value(value) if value
+      message_options = { :message => options[:"#{message}_message"], :restriction => value }
+      record.errors.add(attr_name, message, message_options)
+    end
+
+    def format_error_value(value)
+      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)
+      record.respond_to?(:_timeliness_raw_value_for) &&
+        record._timeliness_raw_value_for(attr_name.to_s)
+    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
+
+# Compatibility with ActiveModel validates method which matches option keys to their validator class
+ActiveModel::Validations::TimelinessValidator = ValidatesTimeliness::Validator

data/lib/validates_timeliness/version.rb

@@ -0,0 +1,3 @@
+module ValidatesTimeliness
+  VERSION = '3.1.0'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,100 @@
+require 'rspec'
+require 'rspec/collection_matchers'
+
+require 'active_model'
+require 'active_model/validations'
+require 'active_record'
+require 'action_view'
+require 'timecop'
+
+require 'validates_timeliness'
+
+require 'support/test_model'
+require 'support/model_helpers'
+require 'support/config_helper'
+require 'support/tag_matcher'
+
+ValidatesTimeliness.setup do |c|
+  c.extend_orms = [ :active_record ]
+  c.enable_date_time_select_extension!
+  c.enable_multiparameter_extension!
+  c.default_timezone = :utc
+end
+
+Time.zone = 'Australia/Melbourne'
+
+LOCALE_PATH = File.expand_path(File.dirname(__FILE__) + '/../lib/generators/validates_timeliness/templates/en.yml')
+I18n.load_path.unshift(LOCALE_PATH)
+
+# Extend TestModel as you would another ORM/ODM module
+module TestModelShim
+  extend ActiveSupport::Concern
+  include ValidatesTimeliness::AttributeMethods
+
+  module ClassMethods
+    # Hook method for attribute method generation
+    def define_attribute_methods(attr_names)
+      super
+      define_timeliness_methods
+    end
+
+    # Hook into native time zone handling check, if any
+    def timeliness_attribute_timezone_aware?(attr_name)
+      false
+    end
+  end
+end
+
+class Person
+  include TestModel
+  attribute :birth_date, :date
+  attribute :birth_time, :time
+  attribute :birth_datetime, :datetime
+
+  define_attribute_methods model_attributes.keys
+end
+
+class PersonWithShim < Person
+  include TestModelShim
+end
+
+ActiveRecord::Base.default_timezone = :utc
+ActiveRecord::Base.time_zone_aware_attributes = true
+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.date     :birth_date
+    t.time     :birth_time
+    t.datetime :birth_datetime
+  end
+end
+
+class Employee < ActiveRecord::Base
+  attr_accessor :redefined_birth_date_called
+  validates_date :birth_date, :allow_nil => true
+  validates_date :birth_time, :allow_nil => true
+  validates_date :birth_datetime, :allow_nil => true
+
+  def birth_date=(value)
+    self.redefined_birth_date_called = true
+    super
+  end
+end
+
+RSpec.configure do |c|
+  c.mock_with :rspec
+  c.include(ModelHelpers)
+  c.include(ConfigHelper)
+  c.include(TagMatcher)
+  c.before do
+    reset_validation_setup_for(Person)
+    reset_validation_setup_for(PersonWithShim)
+  end
+
+  c.filter_run_excluding :active_record => lambda {|version|
+    !(::ActiveRecord::VERSION::STRING.to_s =~ /^#{version.to_s}/)
+  }
+end