validates_timeliness 3.0.15 → 6.0.0

data/lib/validates_timeliness/extensions/date_time_select.rb

@@ -1,60 +1,49 @@
 module ValidatesTimeliness
   module Extensions
-    module DateTimeSelect
-      extend ActiveSupport::Concern
-
+    module TimelinessDateTimeSelect
       # 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.
+      attr_accessor :object_name, :method_name, :template_object, :options, :html_options
 
-      included do
-        alias_method_chain :datetime_selector, :timeliness
-        alias_method_chain :value, :timeliness
-      end
+      POSITION = {
+        :year => 1, :month => 2, :day => 3, :hour => 4, :min => 5, :sec => 6
+      }.freeze
 
-      class TimelinessDateTime
+      class DateTimeValue
         attr_accessor :year, :month, :day, :hour, :min, :sec
 
-        def initialize(year, month, day, hour, min, sec)
+        def initialize(year:, month:, day: nil, hour: nil, min: nil, sec: nil)
           @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)
+          self.class.new(
+            year:  options.fetch(:year, year),
+            month: options.fetch(:month, month),
+            day:   options.fetch(:day, day),
+            hour:  options.fetch(:hour, hour),
+            min:   options.fetch(:min) { options[:hour] ? 0 : min },
+            sec:   options.fetch(: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]
+      # Splat args to support Rails 5.0 which expects object, and 5.2 which doesn't
+      def value(*object)
+        return super unless @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?
+        return super 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
+        values = {}
+        pairs.each_pair do |key, value|
+          position = key[/\((\d+)\w+\)/, 1]
+          values[POSITION.key(position.to_i)] = value.to_i
         end
 
-        TimelinessDateTime.new(*values)
+        DateTimeValue.new(**values)
       end
     end
   end

data/lib/validates_timeliness/extensions/multiparameter_handler.rb

@@ -1,80 +1,55 @@
 module ValidatesTimeliness
   module Extensions
-    module MultiparameterHandler
-      extend ActiveSupport::Concern
+    class AcceptsMultiparameterTime < Module
 
-      # Stricter handling of date and time values from multiparameter 
-      # assignment from the date/time select view helpers
+      def initialize(defaults: {})
 
-      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)
+        define_method(:cast) do |value|
+          if value.is_a?(Hash)
+            value_from_multiparameter_assignment(value)
+          else
+            super(value)
+          end
         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)
+        define_method(:assert_valid_value) do |value|
+          if value.is_a?(Hash)
+            value_from_multiparameter_assignment(value)
           else
-            klass.new(*values)
+            super(value)
           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)
+        define_method(:value_from_multiparameter_assignment) do |values_hash|
+          defaults.each do |k, v|
+            values_hash[k] ||= v
           end
+          return unless values_hash.values_at(1,2,3).all?{ |v| v.present? } &&
+                          Date.valid_civil?(*values_hash.values_at(1,2,3))
+
+          values = values_hash.sort.map(&:last)
+          ::Time.send(default_timezone, *values)
         end
-        unless errors.empty?
-          raise ActiveRecord::MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes"
-        end
+        private :value_from_multiparameter_assignment
+
       end
 
     end
   end
 end
+
+ActiveModel::Type::Date.class_eval do
+  include ValidatesTimeliness::Extensions::AcceptsMultiparameterTime.new
+end
+
+ActiveModel::Type::Time.class_eval do
+  include ValidatesTimeliness::Extensions::AcceptsMultiparameterTime.new(
+    defaults: { 1 => 1970, 2 => 1, 3 => 1, 4 => 0, 5 => 0 }
+  )
+end
+
+ActiveModel::Type::DateTime.class_eval do
+  include ValidatesTimeliness::Extensions::AcceptsMultiparameterTime.new(
+    defaults: { 4 => 0, 5 => 0 }
+  )
+end

data/lib/validates_timeliness/extensions.rb

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

data/lib/validates_timeliness/helper_methods.rb

@@ -14,8 +14,14 @@ module ActiveModel
         timeliness_validation_for attr_names, :datetime
       end
 
-      def timeliness_validation_for(attr_names, type)
-        validates_with TimelinessValidator, _merge_attributes(attr_names).merge(:type => type)
+      def validates_timeliness_of(*attr_names)
+        timeliness_validation_for attr_names
+      end
+
+      def timeliness_validation_for(attr_names, type=nil)
+        options = _merge_attributes(attr_names)
+        options.update(:type => type) if type
+        validates_with TimelinessValidator, options
       end
     end
 

data/lib/validates_timeliness/orm/active_model.rb

@@ -0,0 +1,71 @@
+module ValidatesTimeliness
+  module ORM
+    module ActiveModel
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        public
+
+        def define_attribute_methods(*attr_names)
+          super.tap { define_timeliness_methods }
+        end
+
+        def undefine_attribute_methods
+          super.tap { undefine_timeliness_attribute_methods }
+        end
+
+        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 generated_timeliness_methods
+          @generated_timeliness_methods ||= Module.new { |m|
+            extend Mutex_m
+          }.tap { |mod| include mod }
+        end
+
+        def undefine_timeliness_attribute_methods
+          generated_timeliness_methods.module_eval do
+            instance_methods.each { |m| undef_method(m) }
+          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)
+          generated_timeliness_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            def #{attr_name}=(value)
+              @timeliness_cache ||= {}
+              @timeliness_cache['#{attr_name}'] = value
+
+              @attributes['#{attr_name}'] = super
+            end
+          STR
+        end
+
+        def define_timeliness_before_type_cast_method(attr_name)
+          generated_timeliness_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            def #{attr_name}_before_type_cast
+              read_timeliness_attribute_before_type_cast('#{attr_name}')
+            end
+          STR
+        end
+      end
+
+      def read_timeliness_attribute_before_type_cast(attr_name)
+        @timeliness_cache && @timeliness_cache[attr_name] || @attributes[attr_name]
+      end
+
+      def _clear_timeliness_cache
+        @timeliness_cache = {}
+      end
+
+    end
+  end
+end

data/lib/validates_timeliness/orm/active_record.rb

@@ -3,51 +3,15 @@ module ValidatesTimeliness
     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
+      def read_timeliness_attribute_before_type_cast(attr_name)
+        read_attribute_before_type_cast(attr_name)
       end
 
     end
   end
 end
 
-class ActiveRecord::Base
+ActiveSupport.on_load(:active_record) do
   include ValidatesTimeliness::AttributeMethods
   include ValidatesTimeliness::ORM::ActiveRecord
 end

data/lib/validates_timeliness/railtie.rb

@@ -11,5 +11,13 @@ module ValidatesTimeliness
     initializer "validates_timeliness.initialize_restriction_errors" do
       ValidatesTimeliness.ignore_restriction_errors = !Rails.env.test?
     end
+
+    initializer "validates_timeliness.initialize_timeliness_ambiguous_date_format", :after => :load_config_initializers do
+      if Timeliness.respond_to?(:ambiguous_date_format) # i.e. v0.4+
+        # Set default for each new thread if you have changed the default using
+        # the format switching methods.
+        Timeliness.configuration.ambiguous_date_format = Timeliness::Definitions.current_date_format
+      end
+    end
   end
 end

data/lib/validates_timeliness/validator.rb

@@ -3,9 +3,7 @@ require 'active_model/validator'
 
 module ValidatesTimeliness
   class Validator < ActiveModel::EachValidator
-    include Conversion
-
-    attr_reader :type
+    attr_reader :type, :attributes, :converter
 
     RESTRICTIONS = {
       :is_at        => :==,
@@ -42,13 +40,16 @@ module ValidatesTimeliness
       end
 
       @restrictions_to_check = RESTRICTIONS.keys & options.keys
+
       super
+
+      setup_timeliness_validated_attributes(options[:class]) if options[:class]
     end
 
-    def setup(model)
+    def setup_timeliness_validated_attributes(model)
       if model.respond_to?(:timeliness_validated_attributes)
         model.timeliness_validated_attributes ||= []
-        model.timeliness_validated_attributes |= @attributes
+        model.timeliness_validated_attributes |= attributes
       end
     end
 
@@ -56,9 +57,10 @@ module ValidatesTimeliness
       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)
+      @converter = initialize_converter(record, attr_name)
+
+      value = @converter.parse(raw_value) if value.is_a?(String) || options[:format]
+      value = @converter.type_cast_value(value)
 
       add_error(record, attr_name, :"invalid_#{@type}") and return if value.blank?
 
@@ -68,7 +70,7 @@ module ValidatesTimeliness
     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)
+          restriction_value = @converter.type_cast_value(@converter.evaluate(options[restriction], record))
           unless value.send(RESTRICTIONS[restriction], restriction_value)
             add_error(record, attr_name, restriction, restriction_value) and break
           end
@@ -83,23 +85,32 @@ module ValidatesTimeliness
 
     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)
+      message_options = { message: options.fetch(:"#{message}_message", options[: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')
+      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)
+      record.respond_to?(:read_timeliness_attribute_before_type_cast) &&
+        record.read_timeliness_attribute_before_type_cast(attr_name.to_s)
+    end
+
+    def time_zone_aware?(record, attr_name)
+      record.class.respond_to?(:skip_time_zone_conversion_for_attributes) &&
+        !record.class.skip_time_zone_conversion_for_attributes.include?(attr_name.to_sym)
     end
 
-    def timezone_aware?(record, attr_name)
-      record.class.respond_to?(:timeliness_attribute_timezone_aware?) &&
-        record.class.timeliness_attribute_timezone_aware?(attr_name)
+    def initialize_converter(record, attr_name)
+      ValidatesTimeliness::Converter.new(
+        type: @type,
+        time_zone_aware: time_zone_aware?(record, attr_name),
+        format: options[:format],
+        ignore_usec: options[:ignore_usec]
+      )
     end
 
   end

data/lib/validates_timeliness/version.rb

@@ -1,3 +1,3 @@
 module ValidatesTimeliness
-  VERSION = '3.0.15'
+  VERSION = '6.0.0'
 end

data/lib/validates_timeliness.rb

@@ -28,7 +28,7 @@ module ValidatesTimeliness
     attr_accessor :extend_orms, :ignore_restriction_errors, :restriction_shorthand_symbols, :use_plugin_parser
   end
 
-  # Extend ORM/ODMs for full support (:active_record, :mongoid).
+  # Extend ORM/ODMs for full support (:active_record).
   self.extend_orms = []
 
   # Ignore errors when restriction options are evaluated
@@ -36,8 +36,8 @@ module ValidatesTimeliness
 
   # Shorthand time and date symbols for restrictions
   self.restriction_shorthand_symbols = {
-    :now   => lambda { Time.current },
-    :today => lambda { Date.current }
+    now:   proc { Time.current },
+    today: proc { Date.current }
   }
 
   # Use the plugin date/time parser which is stricter and extensible
@@ -62,7 +62,7 @@ module ValidatesTimeliness
   def self.parser; Timeliness end
 end
 
-require 'validates_timeliness/conversion'
+require 'validates_timeliness/converter'
 require 'validates_timeliness/validator'
 require 'validates_timeliness/helper_methods'
 require 'validates_timeliness/attribute_methods'

data/spec/spec_helper.rb

@@ -1,17 +1,21 @@
 require 'rspec'
 
+require 'byebug'
 require 'active_model'
 require 'active_model/validations'
 require 'active_record'
 require 'action_view'
-require 'timecop'
-require 'rspec_tag_matchers'
+require 'active_support/testing/time_helpers'
 
 require 'validates_timeliness'
+require 'validates_timeliness/orm/active_model'
+
+require 'rails/railtie'
 
 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 ]
@@ -24,19 +28,15 @@ 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)
+I18n.available_locales = ['en', 'es']
 
 # Extend TestModel as you would another ORM/ODM module
 module TestModelShim
   extend ActiveSupport::Concern
   include ValidatesTimeliness::AttributeMethods
+  include ValidatesTimeliness::ORM::ActiveModel
 
   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
@@ -60,6 +60,7 @@ end
 ActiveRecord::Base.default_timezone = :utc
 ActiveRecord::Base.time_zone_aware_attributes = true
 ActiveRecord::Base.establish_connection({:adapter => 'sqlite3', :database => ':memory:'})
+ActiveRecord::Base.time_zone_aware_types = [:datetime, :time]
 ActiveRecord::Migration.verbose = false
 ActiveRecord::Schema.define(:version => 1) do
   create_table :employees, :force => true do |t|
@@ -74,8 +75,8 @@ 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
+  validates_time :birth_time, :allow_nil => true
+  validates_datetime :birth_datetime, :allow_nil => true
 
   def birth_date=(value)
     self.redefined_birth_date_called = true
@@ -85,9 +86,10 @@ end
 
 RSpec.configure do |c|
   c.mock_with :rspec
-  c.include(RspecTagMatchers)
+  c.include(TagMatcher)
   c.include(ModelHelpers)
   c.include(ConfigHelper)
+  c.include(ActiveSupport::Testing::TimeHelpers)
   c.before do
     reset_validation_setup_for(Person)
     reset_validation_setup_for(PersonWithShim)

data/spec/support/model_helpers.rb

@@ -3,22 +3,21 @@ 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
+      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|
-      record.should be_valid
+      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|
+    Array.wrap(values).each do |value|
       record.send("#{attr_name}=", value)
       yield record, value
     end

data/spec/support/tag_matcher.rb

@@ -0,0 +1,35 @@
+require 'nokogiri'
+
+module TagMatcher
+  extend RSpec::Matchers::DSL
+
+  matcher :have_tag do |selector|
+    match do |subject|
+      matches = doc(subject).search(selector)
+
+      if @inner_text
+        matches = matches.select { |element| element.inner_text == @inner_text }
+      end
+
+      matches.any?
+    end
+
+    chain :with_inner_text do |inner_text|
+      @inner_text = inner_text
+    end
+
+    private
+
+    def body(subject)
+      if subject.respond_to?(:body)
+        subject.body
+      else
+        subject.to_s
+      end
+    end
+
+    def doc(subject)
+      @doc ||= Nokogiri::HTML(body(subject))
+    end
+  end
+end