Class Index [+]

Quicksearch

ActiveModel::Validations::ClassMethods

Public Instance Methods

attribute_method?(attribute) click to toggle source

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
inherited(base) click to toggle source

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
validate(*args, &block) click to toggle source

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

Or 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
     # File lib/active_model/validations.rb, line 121
121:       def validate(*args, &block)
122:         options = args.extract_options!
123:         if options.key?(:on)
124:           options = options.dup
125:           options[:if] = Array.wrap(options[:if])
126:           options[:if] << "validation_context == :#{options[:on]}"
127:         end
128:         args << options
129:         set_callback(:validate, *args, &block)
130:       end
validates(*attributes) click to toggle source

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[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[attribute] << "must start with 'the'" unless value =~ /\Athe/i
      end
    end

    validates :name, :title => true
  end

The validators hash can also handle regular expressions, ranges and arrays:

  validates :email, :format => /@/
  validates :gender, :inclusion => %w(male female)
  validates :password, :length => 6..20

Finally, the options :if, :unless, :on, :allow_blank and :allow_nil can be given to one specific validator:

  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 73
73:       def validates(*attributes)
74:         defaults = attributes.extract_options!
75:         validations = defaults.slice!(:if, :unless, :on, :allow_blank, :allow_nil)
76: 
77:         raise ArgumentError, "You need to supply at least one attribute" if attributes.empty?
78:         raise ArgumentError, "Attribute names must be symbols" if attributes.any?{ |attribute| !attribute.is_a?(Symbol) }
79:         raise ArgumentError, "You need to supply at least one validation" if validations.empty?
80: 
81:         defaults.merge!(:attributes => attributes)
82: 
83:         validations.each do |key, options|
84:           begin
85:             validator = const_get("#{key.to_s.camelize}Validator")
86:           rescue NameError
87:             raise ArgumentError, "Unknown validator: '#{key}'"
88:           end
89: 
90:           validates_with(validator, defaults.merge(_parse_validates_options(options)))
91:         end
92:       end
validates_each(*attr_names, &block) click to toggle source

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 when this validation is active (default is :save, other options :create, :update).

  • :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
validates_with(*args, &block) click to toggle source

Passes the record off to the class or classes specified and allows them to add errors based on more complex conditions.

  class Person
    include ActiveModel::Validations
    validates_with MyValidator
  end

  class MyValidator < ActiveModel::Validator
    def validate(record)
      if some_complex_logic
        record.errors[:base] << "This record is invalid"
      end
    end

    private
      def some_complex_logic
        # ...
      end
  end

You may also pass it multiple classes, like so:

  class Person
    include ActiveModel::Validations
    validates_with MyValidator, MyOtherValidator, :on => :create
  end

Configuration options:

  • on - Specifies when this validation is active (:create or :update

  • 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.

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 67
67:       def validates_with(*args, &block)
68:         options = args.extract_options!
69:         args.each do |klass|
70:           validator = klass.new(options, &block)
71:           validator.setup(self) if validator.respond_to?(:setup)
72: 
73:           if validator.respond_to?(:attributes) && !validator.attributes.empty?
74:             validator.attributes.each do |attribute|
75:               _validators[attribute.to_sym] << validator
76:             end
77:           else
78:             _validators[nil] << validator
79:           end
80: 
81:           validate(validator, options)
82:         end
83:       end
validators() click to toggle source

List all validators that are being used to validate the model using validates_with method.

     # File lib/active_model/validations.rb, line 146
146:       def validators
147:         _validators.values.flatten.uniq
148:       end
validators_on(attribute) click to toggle source

List all validators that being used to validate a specific attribute.

     # File lib/active_model/validations.rb, line 151
151:       def validators_on(attribute)
152:         _validators[attribute.to_sym]
153:       end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.