Check if method is an attribute method or not.
# File lib/active_model/validations.rb, line 156 156: def attribute_method?(attribute) 157: method_defined?(attribute) 158: end
Copy validators on inheritance.
# File lib/active_model/validations.rb, line 161 161: def inherited(base) 162: dup = _validators.dup 163: base._validators = dup.each { |k, v| dup[k] = v.dup } 164: super 165: end
Adds a validation method or block to the class. This is useful when overriding the validate instance method becomes too unwieldy and you’re looking for more descriptive declaration of your validations.
This can be done with a symbol pointing to a method:
class Comment include ActiveModel::Validations validate :must_be_friends def must_be_friends errors.add(:base, "Must be friends to leave a comment") unless commenter.friend_of?(commentee) end end
With a block which is passed with the current record to be validated:
class Comment include ActiveModel::Validations validate do |comment| comment.must_be_friends end def must_be_friends errors.add(:base, "Must be friends to leave a comment") unless commenter.friend_of?(commentee) end end
Or with a block where self points to the current record to be validated:
class Comment include ActiveModel::Validations validate do errors.add(:base, "Must be friends to leave a comment") unless commenter.friend_of?(commentee) end end
# File lib/active_model/validations.rb, line 131 131: def validate(*args, &block) 132: options = args.extract_options! 133: if options.key?(:on) 134: options = options.dup 135: options[:if] = Array.wrap(options[:if]) 136: options[:if].unshift("validation_context == :#{options[:on]}") 137: end 138: args << options 139: set_callback(:validate, *args, &block) 140: end
This method is a shortcut to all default validators and any custom validator classes ending in ‘Validator’. Note that Rails default validators can be overridden inside specific classes by creating custom validator classes in their place such as PresenceValidator.
Examples of using the default rails validators:
validates :terms, :acceptance => true validates :password, :confirmation => true validates :username, :exclusion => { :in => %w(admin superuser) } validates :email, :format => { :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i, :on => :create } validates :age, :inclusion => { :in => 0..9 } validates :first_name, :length => { :maximum => 30 } validates :age, :numericality => true validates :username, :presence => true validates :username, :uniqueness => true
The power of the validates method comes when using custom validators and default validators in one call for a given attribute e.g.
class EmailValidator < ActiveModel::EachValidator def validate_each(record, attribute, value) record.errors.add attribute, (options[:message] || "is not an email") unless value =~ /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i end end class Person include ActiveModel::Validations attr_accessor :name, :email validates :name, :presence => true, :uniqueness => true, :length => { :maximum => 100 } validates :email, :presence => true, :email => true end
Validator classes may also exist within the class being validated allowing custom modules of validators to be included as needed e.g.
class Film include ActiveModel::Validations class TitleValidator < ActiveModel::EachValidator def validate_each(record, attribute, value) record.errors.add attribute, "must start with 'the'" unless value =~ /\Athe/i end end validates :name, :title => true end
Additionally validator classes may be in another namespace and still used within any class.
validates :name, :'film/title' => true
The validators hash can also handle regular expressions, ranges, arrays and strings in shortcut form, e.g.
validates :email, :format => /@/ validates :gender, :inclusion => %w(male female) validates :password, :length => 6..20
When using shortcut form, ranges and arrays are passed to your validator’s initializer as +options[:in]+ while other types including regular expressions and strings are passed as +options[:with]+
Finally, the options :if, :unless, :on, :allow_blank, :allow_nil and :strict can be given to one specific validator, as a hash:
validates :password, :presence => { :if => :password_required? }, :confirmation => true
Or to all at the same time:
validates :password, :presence => true, :confirmation => true, :if => :password_required?
# File lib/active_model/validations/validates.rb, line 81 81: def validates(*attributes) 82: defaults = attributes.extract_options! 83: validations = defaults.slice!(*_validates_default_keys) 84: 85: raise ArgumentError, "You need to supply at least one attribute" if attributes.empty? 86: raise ArgumentError, "You need to supply at least one validation" if validations.empty? 87: 88: defaults.merge!(:attributes => attributes) 89: 90: validations.each do |key, options| 91: key = "#{key.to_s.camelize}Validator" 92: 93: begin 94: validator = key.include?('::') ? key.constantize : const_get(key) 95: rescue NameError 96: raise ArgumentError, "Unknown validator: '#{key}'" 97: end 98: 99: validates_with(validator, defaults.merge(_parse_validates_options(options))) 100: end 101: end
This method is used to define validation that cannot be corrected by end user and is considered exceptional. So each validator defined with bang or :strict option set to true will always raise ActiveModel::StrictValidationFailed instead of adding error when validation fails. See validates for more information about validation itself.
# File lib/active_model/validations/validates.rb, line 109 109: def validates!(*attributes) 110: options = attributes.extract_options! 111: options[:strict] = true 112: validates(*(attributes << options)) 113: end
Validates each attribute against a block.
class Person include ActiveModel::Validations attr_accessor :first_name, :last_name validates_each :first_name, :last_name do |record, attr, value| record.errors.add attr, 'starts with z.' if value.to_s[0] == ?z end end
Options:
:on - Specifies the context where this validation is active (e.g. :on => :create or :on => :custom_validation_context)
:allow_nil - Skip validation if attribute is nil.
:allow_blank - Skip validation if attribute is blank.
:if - Specifies a method, proc or string to call to determine if the validation should occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }). The method, proc or string should return or evaluate to a true or false value.
:unless - Specifies a method, proc or string to call to determine if the validation should not occur (e.g. :unless => :skip_validation, or :unless => Proc.new { |user| user.signup_step <= 2 }). The method, proc or string should return or evaluate to a true or false value.
# File lib/active_model/validations.rb, line 86 86: def validates_each(*attr_names, &block) 87: options = attr_names.extract_options!.symbolize_keys 88: validates_with BlockValidator, options.merge(:attributes => attr_names.flatten), &block 89: end
If you pass any additional configuration options, they will be passed to the class and available as options:
class Person include ActiveModel::Validations validates_with MyValidator, :my_custom_key => "my custom value" end class MyValidator < ActiveModel::Validator def validate(record) options[:my_custom_key] # => "my custom value" end end
# File lib/active_model/validations/with.rb, line 79 79: def validates_with(*args, &block) 80: options = args.extract_options! 81: args.each do |klass| 82: validator = klass.new(options, &block) 83: validator.setup(self) if validator.respond_to?(:setup) 84: 85: if validator.respond_to?(:attributes) && !validator.attributes.empty? 86: validator.attributes.each do |attribute| 87: _validators[attribute.to_sym] << validator 88: end 89: else 90: _validators[nil] << validator 91: end 92: 93: validate(validator, options) 94: end 95: end
List all validators that are being used to validate the model using validates_with method.
# File lib/active_model/validations.rb, line 144 144: def validators 145: _validators.values.flatten.uniq 146: end
List all validators that being used to validate a specific attribute.
# File lib/active_model/validations.rb, line 149 149: def validators_on(*attributes) 150: attributes.map do |attribute| 151: _validators[attribute.to_sym] 152: end.flatten 153: end
When creating custom validators, it might be useful to be able to specify additional default keys. This can be done by overwriting this method.
# File lib/active_model/validations/validates.rb, line 119 119: def _validates_default_keys 120: [:if, :unless, :on, :allow_blank, :allow_nil , :strict] 121: end
Disabled; run with --debug to generate this.
Generated with the Darkfish Rdoc Generator 1.1.6.