sp-validates_timeliness 3.1.2

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.2'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,109 @@
+require 'rspec'
+require 'rspec/collection_matchers'
+
+# Coveralls
+require "coveralls"
+
+Coveralls.wear! do
+  add_filter 'spec'
+end
+
+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
+
+I18n.enforce_available_locales = false
+
+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

data/spec/support/config_helper.rb

@@ -0,0 +1,36 @@
+module ConfigHelper
+  extend ActiveSupport::Concern
+
+  # Justin French tip
+  def with_config(preference_name, temporary_value)
+    old_value = ValidatesTimeliness.send(preference_name)
+    ValidatesTimeliness.send(:"#{preference_name}=", temporary_value)
+    yield
+  ensure
+    ValidatesTimeliness.send(:"#{preference_name}=", old_value)
+  end
+
+  def reset_validation_setup_for(model_class)
+    model_class.reset_callbacks(:validate)
+    model_class._validators.clear
+    model_class.timeliness_validated_attributes = [] if model_class.respond_to?(:timeliness_validated_attributes)
+    model_class.undefine_attribute_methods
+    # This is a hack to avoid a disabled super method error message after an undef
+    model_class.instance_variable_set(:@generated_attribute_methods, nil)
+    model_class.instance_variable_set(:@generated_timeliness_methods, nil)
+  end
+
+  module ClassMethods
+    def with_config(preference_name, temporary_value)
+      original_config_value = ValidatesTimeliness.send(preference_name)
+
+      before(:all) do
+        ValidatesTimeliness.send(:"#{preference_name}=", temporary_value)
+      end
+
+      after(:all) do
+        ValidatesTimeliness.send(:"#{preference_name}=", original_config_value)
+      end
+    end
+  end
+end

data/spec/support/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|
+      expect(record).to be_invalid
+      expect(record.errors[attr_name].size).to be >= 1
+      expect(record.errors[attr_name].first).to eq(error) if error
+    end
+  end
+
+  def valid!(attr_name, values)
+    with_each_person_value(attr_name, values) do |record, value|
+      expect(record).to 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