ae-validates_timeliness 4.0.0

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,94 @@
+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)
+          if ::ActiveRecord.version < ::Gem::Version.new('4.2')
+            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
+          else
+            columns_hash.fetch(attr_name.to_s) do |attr_name|
+              validation_type = _validators[attr_name.to_sym].find {|v| v.kind == :timeliness }.type
+              connection = ::ActiveRecord::Base.connection
+              connection.new_column(attr_name, nil, connection.lookup_cast_type(validation_type.to_s), validation_type.to_s)
+            end
+          end
+        end
+
+        def define_attribute_methods
+          super.tap do |attribute_methods_generated|
+            define_timeliness_methods(true) if attribute_methods_generated
+          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
+    
+    module ActiveRecordLessThan42
+      module ClassMethods
+        def allocate
+          define_attribute_methods
+          super
+        end
+      end
+      
+      private
+      
+      def init_internals
+        self.class.define_attribute_methods
+        super
+      end
+    end
+    
+  end
+end
+
+class ActiveRecord::Base
+  include ValidatesTimeliness::AttributeMethods
+  include ValidatesTimeliness::ORM::ActiveRecord
+  
+  if ActiveRecord.version < Gem::Version.new('4.2')
+    # Rails 4.0 / 4.1 are lazy and wait until method_missing / respond_to? is called before 
+    # calling define_attribute_methods. This is now quite complex and no longer works with 
+    # validates timeliness when the first attribute access for a AR model is to a 
+    # validates_timeliness attribute. 
+    #
+    # In Rails 4.2, this has changes to be less lazy and probably more robust. These patches 
+    # match Rails 4.2.
+    
+    prepend ValidatesTimeliness::ORM::ActiveRecordLessThan42
+  
+    class << self
+      prepend ValidatesTimeliness::ORM::ActiveRecordLessThan42::ClassMethods
+    end
+  end
+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

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: ae-validates_timeliness
+version: !ruby/object:Gem::Version
+  version: 4.0.0
+platform: ruby
+authors:
+- Paul Kmiec
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: timeliness
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.7
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-collection_matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Adds validation methods to ActiveModel for validating dates and times.
+  Works with multiple ORMS.
+email: paul.kmiec@appfolio.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Appraisals
+- CHANGELOG.rdoc
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- ae-validates_timeliness.gemspec
+- autotest/discover.rb
+- gemfiles/rails_4_0.gemfile
+- gemfiles/rails_4_0.gemfile.lock
+- gemfiles/rails_4_1.gemfile
+- gemfiles/rails_4_1.gemfile.lock
+- gemfiles/rails_4_2.gemfile
+- gemfiles/rails_4_2.gemfile.lock
+- init.rb
+- lib/ae-validates_timeliness.rb
+- lib/ae-validates_timeliness/version.rb
+- lib/generators/validates_timeliness/install_generator.rb
+- lib/generators/validates_timeliness/templates/en.yml
+- lib/generators/validates_timeliness/templates/validates_timeliness.rb
+- lib/validates_timeliness.rb
+- lib/validates_timeliness/attribute_methods.rb
+- lib/validates_timeliness/conversion.rb
+- lib/validates_timeliness/extensions.rb
+- lib/validates_timeliness/extensions/date_time_select.rb
+- lib/validates_timeliness/extensions/multiparameter_handler.rb
+- lib/validates_timeliness/helper_methods.rb
+- lib/validates_timeliness/orm/active_record.rb
+- lib/validates_timeliness/orm/mongoid.rb
+- lib/validates_timeliness/railtie.rb
+- lib/validates_timeliness/validator.rb
+homepage: http://github.com/appfolio/validates_timeliness
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.7
+signing_key: 
+specification_version: 4
+summary: Date and time validation plugin for Rails which allows custom formats
+test_files: []