Class: ActiveModel::Validator

### Home Classes Methods

### In Files

- lib/active_model/validator.rb

### Parent

Object

### Methods

- ::kind
- ::new
- #kind
- #validate

### Class/Module Index

Quicksearch

- ActiveModel
- ActiveModel::AttributeMethods
- ActiveModel::AttributeMethods::ClassMethods
- ActiveModel::AttributeMethods::ClassMethods::AttributeMethodMatcher
- ActiveModel::BlockValidator
- ActiveModel::Callbacks
- ActiveModel::Conversion
- ActiveModel::Dirty
- ActiveModel::EachValidator
- ActiveModel::Errors
- ActiveModel::Lint
- ActiveModel::Lint::Tests
- ActiveModel::MassAssignmentSecurity
- ActiveModel::MassAssignmentSecurity::BlackList
- ActiveModel::MassAssignmentSecurity::ClassMethods
- ActiveModel::MassAssignmentSecurity::Error
- ActiveModel::MassAssignmentSecurity::LoggerSanitizer
- ActiveModel::MassAssignmentSecurity::PermissionSet
- ActiveModel::MassAssignmentSecurity::Sanitizer
- ActiveModel::MassAssignmentSecurity::StrictSanitizer
- ActiveModel::MassAssignmentSecurity::WhiteList
- ActiveModel::MissingAttributeError
- ActiveModel::Name
- ActiveModel::Naming
- ActiveModel::Observer
- ActiveModel::ObserverArray
- ActiveModel::Observing
- ActiveModel::Observing::ClassMethods
- ActiveModel::SecurePassword
- ActiveModel::SecurePassword::ClassMethods
- ActiveModel::SecurePassword::InstanceMethodsOnActivation
- ActiveModel::Serialization
- ActiveModel::Serializers
- ActiveModel::Serializers::JSON
- ActiveModel::Serializers::Xml
- ActiveModel::StrictValidationFailed
- ActiveModel::Translation
- ActiveModel::Validations
- ActiveModel::Validations::AcceptanceValidator
- ActiveModel::Validations::Callbacks
- ActiveModel::Validations::Callbacks::ClassMethods
- ActiveModel::Validations::ClassMethods
- ActiveModel::Validations::ConfirmationValidator
- ActiveModel::Validations::ExclusionValidator
- ActiveModel::Validations::FormatValidator
- ActiveModel::Validations::HelperMethods
- ActiveModel::Validations::InclusionValidator
- ActiveModel::Validations::LengthValidator
- ActiveModel::Validations::NumericalityValidator
- ActiveModel::Validations::PresenceValidator
- ActiveModel::Validations::WithValidator
- ActiveModel::Validator

No matching classes.

# 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.add :base, "This is some custom error message"
        record.errors.add :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(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.add attribute, 'must be Mr. Mrs. or Dr.' unless value.in?(['Mr.', 'Mrs.', 'Dr.'])
      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
    end

Validator may also define a `setup` instance method which will get called with the class that using that validator as its 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 107
    def self.kind
      @kind ||= name.split('::').last.underscore.sub(/_validator$/, '').to_sym unless anonymous?
    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 112
    def initialize(options)
      @options = options.freeze
    end

### Public Instance Methods

kind() click to toggle source

Return the kind for this validator.

    # File lib/active_model/validator.rb, line 117
    def kind
      self.class.kind
    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 123
    def validate(record)
      raise NotImplementedError, "Subclasses must implement a validate(record) method."
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.