ae-validates_timeliness 4.0.0

data/init.rb

@@ -0,0 +1 @@
+require 'validates_timeliness'

data/lib/ae-validates_timeliness.rb

@@ -0,0 +1 @@
+require "validates_timeliness"

data/lib/ae-validates_timeliness/version.rb

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

data/lib/generators/validates_timeliness/install_generator.rb

@@ -0,0 +1,16 @@
+module ValidatesTimeliness
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      desc "Copy ValidatesTimeliness default files"
+      source_root File.expand_path('../templates', __FILE__)
+
+      def copy_initializers
+        copy_file 'validates_timeliness.rb', 'config/initializers/validates_timeliness.rb'
+      end
+
+      def copy_locale_file
+        copy_file 'en.yml', 'config/locales/validates_timeliness.en.yml'
+      end
+    end
+  end
+end

data/lib/generators/validates_timeliness/templates/en.yml

@@ -0,0 +1,16 @@
+en:
+  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}"
+  validates_timeliness:
+    error_value_formats:
+      date: '%Y-%m-%d'
+      time: '%H:%M:%S'
+      datetime: '%Y-%m-%d %H:%M:%S'

data/lib/generators/validates_timeliness/templates/validates_timeliness.rb

@@ -0,0 +1,40 @@
+ValidatesTimeliness.setup do |config|
+  # Extend ORM/ODMs for full support (:active_record, :mongoid).
+  # config.extend_orms = [ :active_record ]
+  #
+  # Default timezone
+  # config.default_timezone = :utc
+  #
+  # Set the dummy date part for a time type values.
+  # config.dummy_date_for_time_type = [ 2000, 1, 1 ]
+  #
+  # Ignore errors when restriction options are evaluated
+  # config.ignore_restriction_errors = false
+  #
+  # Re-display invalid values in date/time selects
+  # config.enable_date_time_select_extension!
+  #
+  # Handle multiparameter date/time values strictly
+  # config.enable_multiparameter_extension!
+  #
+  # Shorthand date and time symbols for restrictions
+  # config.restriction_shorthand_symbols.update(
+  #   :now   => lambda { Time.current },
+  #   :today => lambda { Date.current }
+  # )
+  #
+  # Use the plugin date/time parser which is stricter and extendable
+  # config.use_plugin_parser = false
+  #
+  # Add one or more formats making them valid. e.g. add_formats(:date, 'd(st|rd|th) of mmm, yyyy')
+  # config.parser.add_formats()
+  #
+  # Remove one or more formats making them invalid. e.g. remove_formats(:date, 'dd/mm/yyy')
+  # config.parser.remove_formats()
+  #
+  # Change the amiguous year threshold when parsing a 2 digit year
+  # config.parser.ambiguous_year_threshold =  30
+  #
+  # Treat ambiguous dates, such as 01/02/1950, as a Non-US date.
+  # config.parser.remove_us_formats
+end

data/lib/validates_timeliness.rb

@@ -0,0 +1,70 @@
+require 'date'
+require 'active_support/concern'
+require 'active_support/core_ext/module'
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/string/conversions'
+require 'active_support/core_ext/date/acts_like'
+require 'active_support/core_ext/date/conversions'
+require 'active_support/core_ext/time/acts_like'
+require 'active_support/core_ext/time/conversions'
+require 'active_support/core_ext/date_time/acts_like'
+require 'active_support/core_ext/date_time/conversions'
+require 'timeliness'
+
+Timeliness.module_eval do
+  class << self
+    alias :dummy_date_for_time_type :date_for_time_type
+    alias :dummy_date_for_time_type= :date_for_time_type=
+    alias :remove_us_formats :use_euro_formats
+  end
+end
+
+module ValidatesTimeliness
+  autoload :VERSION, 'validates_timeliness/version'
+
+  class << self
+    delegate :default_timezone, :default_timezone=, :dummy_date_for_time_type, :dummy_date_for_time_type=, :to => Timeliness
+
+    attr_accessor :extend_orms, :ignore_restriction_errors, :restriction_shorthand_symbols, :use_plugin_parser
+  end
+
+  # Extend ORM/ODMs for full support (:active_record, :mongoid).
+  self.extend_orms = []
+
+  # Ignore errors when restriction options are evaluated
+  self.ignore_restriction_errors = false
+
+  # Shorthand time and date symbols for restrictions
+  self.restriction_shorthand_symbols = {
+    :now   => lambda { Time.current },
+    :today => lambda { Date.current }
+  }
+
+  # Use the plugin date/time parser which is stricter and extensible
+  self.use_plugin_parser = false
+
+  # Default timezone
+  self.default_timezone = :utc
+
+  # Set the dummy date part for a time type values.
+  self.dummy_date_for_time_type = [ 2000, 1, 1 ]
+
+  # Setup method for plugin configuration
+  def self.setup
+    yield self
+    load_orms
+  end
+
+  def self.load_orms
+    extend_orms.each {|orm| require "validates_timeliness/orm/#{orm}" }
+  end
+
+  def self.parser; Timeliness end
+end
+
+require 'validates_timeliness/conversion'
+require 'validates_timeliness/validator'
+require 'validates_timeliness/helper_methods'
+require 'validates_timeliness/attribute_methods'
+require 'validates_timeliness/extensions'
+require 'validates_timeliness/railtie' if defined?(Rails)

data/lib/validates_timeliness/attribute_methods.rb

@@ -0,0 +1,97 @@
+module ValidatesTimeliness
+  module AttributeMethods
+    extend ActiveSupport::Concern
+
+    included do
+      class << self
+        attr_accessor :timeliness_validated_attributes
+      end
+      self.timeliness_validated_attributes = []
+    end
+
+    module ClassMethods
+
+      public
+      # Override in ORM shim
+      def timeliness_attribute_timezone_aware?(attr_name)
+        false
+      end
+
+      # Override in ORM shim
+      def timeliness_attribute_type(attr_name)
+        :datetime
+      end
+
+      def undefine_attribute_methods
+        super
+        undefine_timeliness_attribute_methods
+      end
+
+      protected
+
+      def define_timeliness_methods(before_type_cast=false)
+        return if timeliness_validated_attributes.blank?
+        timeliness_validated_attributes.each do |attr_name|
+          define_attribute_timeliness_methods(attr_name, before_type_cast)
+        end
+      end
+
+      def define_attribute_timeliness_methods(attr_name, before_type_cast=false)
+        define_timeliness_write_method(attr_name)
+        define_timeliness_before_type_cast_method(attr_name) if before_type_cast
+      end
+
+      def define_timeliness_write_method(attr_name)
+        method_body, line = <<-EOV, __LINE__ + 1
+          def #{attr_name}=(value)
+            original_value = value
+            @timeliness_cache ||= {}
+            @timeliness_cache["#{attr_name}"] = original_value
+            #{ "if value.is_a?(String)\n#{timeliness_type_cast_code(attr_name, 'value')}\nend" if ValidatesTimeliness.use_plugin_parser }
+
+            super(value)
+          end
+        EOV
+        generated_timeliness_methods.module_eval(method_body, __FILE__, line)
+      end
+
+      def define_timeliness_before_type_cast_method(attr_name)
+        method_body, line = <<-EOV, __LINE__ + 1
+          def #{attr_name}_before_type_cast
+            _timeliness_raw_value_for('#{attr_name}') || begin
+              a = @attributes['#{attr_name}']
+              a.respond_to?(:value_before_type_cast) ? a.value_before_type_cast : a
+            end
+          end
+        EOV
+        generated_timeliness_methods.module_eval(method_body, __FILE__, line)
+      end
+
+      def timeliness_type_cast_code(attr_name, var_name)
+        type = timeliness_attribute_type(attr_name)
+        timezone_aware = timeliness_attribute_timezone_aware?(attr_name)
+        timezone = :current if timezone_aware
+
+        "#{var_name} = Timeliness::Parser.parse(#{var_name}, :#{type}, :zone => #{timezone.inspect})"
+      end
+
+      def generated_timeliness_methods
+        @generated_timeliness_methods ||= Module.new.tap { |m| include(m) }
+      end
+
+      def undefine_timeliness_attribute_methods
+        generated_timeliness_methods.module_eval do
+          instance_methods.each { |m| undef_method(m) }
+        end
+      end
+    end
+
+    def _timeliness_raw_value_for(attr_name)
+      @timeliness_cache && @timeliness_cache[attr_name]
+    end
+
+    def _clear_timeliness_cache
+      @timeliness_cache = {}
+    end
+  end
+end

data/lib/validates_timeliness/conversion.rb

@@ -0,0 +1,70 @@
+module ValidatesTimeliness
+  module Conversion
+
+    def type_cast_value(value, type)
+      return nil if value.nil? || !value.respond_to?(:to_time)
+
+      value = value.in_time_zone if value.acts_like?(:time) && @timezone_aware
+      value = case type
+      when :time
+        dummy_time(value)
+      when :date
+        value.to_date
+      when :datetime
+        value.is_a?(Time) ? value : value.to_time
+      end
+      if options[:ignore_usec] && value.is_a?(Time)
+        Timeliness::Parser.make_time(Array(value).reverse[4..9], (:current if @timezone_aware))
+      else
+        value
+      end
+    end
+
+    def dummy_time(value)
+      time = if value.acts_like?(:time)
+        value = value.in_time_zone if @timezone_aware
+        [value.hour, value.min, value.sec]
+      else
+        [0,0,0]
+      end
+      values = ValidatesTimeliness.dummy_date_for_time_type + time
+      Timeliness::Parser.make_time(values, (:current if @timezone_aware))
+    end
+
+    def evaluate_option_value(value, record)
+      case value
+      when Time, Date
+        value
+      when String
+        parse(value)
+      when Symbol
+        if !record.respond_to?(value) && restriction_shorthand?(value)
+          ValidatesTimeliness.restriction_shorthand_symbols[value].call
+        else
+          evaluate_option_value(record.send(value), record)
+        end
+      when Proc
+        result = value.arity > 0 ? value.call(record) : value.call
+        evaluate_option_value(result, record)
+      else
+        value
+      end
+    end
+
+    def restriction_shorthand?(symbol)
+      ValidatesTimeliness.restriction_shorthand_symbols.keys.include?(symbol)
+    end
+
+    def parse(value)
+      return nil if value.nil?
+      if ValidatesTimeliness.use_plugin_parser
+        Timeliness::Parser.parse(value, @type, :zone => (:current if @timezone_aware), :format => options[:format], :strict => false)
+      else
+        @timezone_aware ? Time.zone.parse(value, Time.zone.now) : value.to_time(ValidatesTimeliness.default_timezone)
+      end
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+  end
+end

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