Parent

Class Index [+]

Quicksearch

ActiveModel::Validator

Active Model Validator

A simple base class that can be used along with ActiveModel::Validations::ClassMethods.validates_with

  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

Any class that inherits from ActiveModel::Validator must implement a method called validate which accepts a record.

  class Person
    include ActiveModel::Validations
    validates_with MyValidator
  end

  class MyValidator < ActiveModel::Validator
    def validate(record)
      record # => The person instance being validated
      options # => Any non-standard options passed to validates_with
    end
  end

To cause a validation error, you must add to the record’s errors directly from within the validators message

  class MyValidator < ActiveModel::Validator
    def validate(record)
      record.errors[:base] << "This is some custom error message"
      record.errors[:first_name] << "This is some complex validation"
      # etc...
    end
  end

To add behavior to the initialize method, use the following signature:

  class MyValidator < ActiveModel::Validator
    def initialize(record, options)
      super
      @my_custom_field = options[:field_name] || :first_name
    end
  end

The easiest way to add custom validators for validating individual attributes is with the convenient ActiveModel::EachValidator for example:

  class TitleValidator < ActiveModel::EachValidator
    def validate_each(record, attribute, value)
      record.errors[attribute] << 'must be Mr. Mrs. or Dr.' unless ['Mr.', 'Mrs.', 'Dr.'].include?(value)
    end
  end

This can now be used in combination with the validates method (see ActiveModel::Validations::ClassMethods.validates for more on this)

  class Person
    include ActiveModel::Validations
    attr_accessor :title

    validates :title, :presence => true, :title => true
  end

Validator may also define a setup instance method which will get called with the class that using that validator as it’s argument. This can be useful when there are prerequisites such as an attr_accessor being present for example:

  class MyValidator < ActiveModel::Validator
    def setup(klass)
      klass.send :attr_accessor, :custom_attribute
    end
  end

This setup method is only called when used with validation macros or the class level validates_with method.

Attributes

options[R]

Public Class Methods

kind() click to toggle source

Returns the kind of the validator.

Examples

  PresenceValidator.kind   # => :presence
  UniquenessValidator.kind # => :uniqueness
     # File lib/active_model/validator.rb, line 108
108:     def self.kind
109:       @kind ||= name.split('::').last.underscore.sub(/_validator$/, '').to_sym unless anonymous?
110:     end
new(options) click to toggle source

Accepts options that will be made available through the options reader.

     # File lib/active_model/validator.rb, line 113
113:     def initialize(options)
114:       @options = options.freeze
115:     end

Public Instance Methods

kind() click to toggle source

Return the kind for this validator.

     # File lib/active_model/validator.rb, line 118
118:     def kind
119:       self.class.kind
120:     end
validate(record) click to toggle source

Override this method in subclasses with validation logic, adding errors to the records errors array where necessary.

     # File lib/active_model/validator.rb, line 124
124:     def validate(record)
125:       raise NotImplementedError
126:     end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.