Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

199 lines (168 sloc) 7.256 kb
module Formtastic
module Inputs
module Base
module Validations
class IndeterminableMinimumAttributeError < ArgumentError
def message
[
"A minimum value can not be determined when the validation uses :greater_than on a :decimal or :float column type.",
"Please alter the validation to use :greater_than_or_equal_to, or provide a value for this attribute explicitly with the :min option on input()."
].join("\n")
end
end
class IndeterminableMaximumAttributeError < ArgumentError
def message
[
"A maximum value can not be determined when the validation uses :less_than on a :decimal or :float column type.",
"Please alter the validation to use :less_than_or_equal_to, or provide a value for this attribute explicitly with the :max option on input()."
].join("\n")
end
end
def validations
@validations ||= if object && object.class.respond_to?(:validators_on)
object.class.ancestors.
select { |ancestor| ancestor.respond_to?(:validators_on) }.
inject([]) { |validators, ancestor| validators + ancestor.validators_on(attributized_method_name) }.
select { |validator| validator_relevant?(validator) }
else
nil
end
end
def validator_relevant?(validator)
return true unless validator.options.key?(:if) || validator.options.key?(:unless)
conditional = validator.options.key?(:if) ? validator.options[:if] : validator.options[:unless]
result = if conditional.respond_to?(:call)
conditional.call(object)
elsif conditional.is_a?(::Symbol) && object.respond_to?(conditional)
object.send(conditional)
else
conditional
end
result = validator.options.key?(:unless) ? !result : !!result
not_required_through_negated_validation! if !result && [:presence, :inclusion, :length].include?(validator.kind)
result
end
def validation_limit
validation = validations? && validations.find do |validation|
validation.kind == :length
end
if validation
validation.options[:maximum] || (validation.options[:within].present? ? validation.options[:within].max : nil)
else
nil
end
end
# Prefer :greater_than_or_equal_to over :greater_than, for no particular reason.
def validation_min
validation = validations? && validations.find do |validation|
validation.kind == :numericality
end
if validation
# We can't determine an appropriate value for :greater_than with a float/decimal column
raise IndeterminableMinimumAttributeError if validation.options[:greater_than] && column? && [:float, :decimal].include?(column.type)
if validation.options[:greater_than_or_equal_to]
return (validation.options[:greater_than_or_equal_to].call(object)) if validation.options[:greater_than_or_equal_to].kind_of?(Proc)
return (validation.options[:greater_than_or_equal_to])
end
if validation.options[:greater_than]
return (validation.options[:greater_than].call(object) + 1) if validation.options[:greater_than].kind_of?(Proc)
return (validation.options[:greater_than] + 1)
end
end
end
# Prefer :less_than_or_equal_to over :less_than, for no particular reason.
def validation_max
validation = validations? && validations.find do |validation|
validation.kind == :numericality
end
if validation
# We can't determine an appropriate value for :greater_than with a float/decimal column
raise IndeterminableMaximumAttributeError if validation.options[:less_than] && column? && [:float, :decimal].include?(column.type)
if validation.options[:less_than_or_equal_to]
return (validation.options[:less_than_or_equal_to].call(object)) if validation.options[:less_than_or_equal_to].kind_of?(Proc)
return (validation.options[:less_than_or_equal_to])
end
if validation.options[:less_than]
return ((validation.options[:less_than].call(object)) - 1) if validation.options[:less_than].kind_of?(Proc)
return (validation.options[:less_than] - 1)
end
end
end
def validation_step
validation = validations? && validations.find do |validation|
validation.kind == :numericality
end
if validation
validation.options[:step] || (1 if validation_integer_only?)
else
nil
end
end
def validation_integer_only?
validation = validations? && validations.find do |validation|
validation.kind == :numericality
end
if validation
validation.options[:only_integer]
else
false
end
end
def validations?
validations != nil
end
def required?
return false if options[:required] == false
return true if options[:required] == true
return false if not_required_through_negated_validation?
if validations?
validations.select { |validator|
if validator.options.key?(:on)
return false if (validator.options[:on] != :save) && ((object.new_record? && validator.options[:on] != :create) || (!object.new_record? && validator.options[:on] != :update))
end
case validator.kind
when :presence
true
when :inclusion
validator.options[:allow_blank] != true
when :length
validator.options[:allow_blank] != true &&
validator.options[:minimum].to_i > 0 ||
validator.options[:within].try(:first).to_i > 0
else
false
end
}.any?
else
return responds_to_global_required? && !!builder.all_fields_required_by_default
end
end
def required_attribute?
required? && builder.use_required_attribute
end
def not_required_through_negated_validation?
@not_required_through_negated_validation
end
def not_required_through_negated_validation!
@not_required_through_negated_validation = true
end
def responds_to_global_required?
true
end
def optional?
!required?
end
def autofocus?
opt_autofocus = options[:input_html] && options[:input_html][:autofocus]
!!opt_autofocus
end
def column_limit
column.limit if column? && column.respond_to?(:limit)
end
def limit
validation_limit || column_limit
end
end
end
end
end
Jump to Line
Something went wrong with that request. Please try again.