# module ActiveModel::Validations

## Active Model Validations¶ ↑

Provides a full validation framework to your objects.

A minimal implementation could be:

    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

Which provides you with the full standard validation stack that you know from Active Record:

    person = Person.new
    person.valid?                   # => true
    person.invalid?                 # => false

    person.first_name = 'zoolander'
    person.valid?                   # => false
    person.invalid?                 # => true
    person.errors.messages          # => {first_name:["starts with z."]}

Note that `ActiveModel::Validations` automatically adds an `errors` method to your instances initialized with a new `ActiveModel::Errors` object, so there is no need for you to do this manually.

### Public Instance Methods

errors() click to toggle source

Returns the `Errors` object that holds all information about attribute error messages.

    class Person
      include ActiveModel::Validations

      attr_accessor :name
      validates_presence_of :name
    end

    person = Person.new
    person.valid? # => false
    person.errors # => #<ActiveModel::Errors:0x007fe603816640 @messages={name:["can't be blank"]}>

    # File lib/active_model/validations.rb, line 299
    def errors
      @errors ||= Errors.new(self)
    end

invalid?(context = nil) click to toggle source

Performs the opposite of `valid?`. Returns `true` if errors were added, `false` otherwise.

    class Person
      include ActiveModel::Validations

      attr_accessor :name
      validates_presence_of :name
    end

    person = Person.new
    person.name = ''
    person.invalid? # => true
    person.name = 'david'
    person.invalid? # => false

Context can optionally be supplied to define which callbacks to test against (the context is defined on the validations using `:on`).

    class Person
      include ActiveModel::Validations

      attr_accessor :name
      validates_presence_of :name, on: :new
    end

    person = Person.new
    person.invalid?       # => false
    person.invalid?(:new) # => true

    # File lib/active_model/validations.rb, line 371
    def invalid?(context = nil)
      !valid?(context)
    end

valid?(context = nil) click to toggle source

Runs all the specified validations and returns `true` if no errors were added otherwise `false`.

    class Person
      include ActiveModel::Validations

      attr_accessor :name
      validates_presence_of :name
    end

    person = Person.new
    person.name = ''
    person.valid? # => false
    person.name = 'david'
    person.valid? # => true

Context can optionally be supplied to define which callbacks to test against (the context is defined on the validations using `:on`).

    class Person
      include ActiveModel::Validations

      attr_accessor :name
      validates_presence_of :name, on: :new
    end

    person = Person.new
    person.valid?       # => true
    person.valid?(:new) # => false

    # File lib/active_model/validations.rb, line 332
    def valid?(context = nil)
      current_context, self.validation_context = validation_context, context
      errors.clear
      run_validations!
    ensure
      self.validation_context = current_context
    end

Also aliased as: validate
validate(context = nil)
Alias for: valid?
validate!(context = nil) click to toggle source

Runs all the validations within the specified context. Returns `true` if no errors are found, raises `ValidationError` otherwise.

Validations with no `:on` option will run no matter the context. Validations with some `:on` option will only run in the specified context.

    # File lib/active_model/validations.rb, line 380
    def validate!(context = nil)
      valid?(context) || raise_validation_error
    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

      validate :instance_validations

      def instance_validations
        validates_with MyValidator
      end
    end

Please consult the class method documentation for more information on creating your own validator.

You may also pass it multiple classes, like so:

    class Person
      include ActiveModel::Validations

      validate :instance_validations, on: :create

      def instance_validations
        validates_with MyValidator, MyOtherValidator
      end
    end

Standard configuration options (`:on`, `:if` and `:unless`), which are available on the class version of `validates_with`, should instead be placed on the `validates` method as these are applied and tested in the callback.

If you pass any additional configuration options, they will be passed to the class and available as `options`, please refer to the class version of this method for more information.

    # File lib/active_model/validations/with.rb, line 135
    def validates_with(*args, &block)
      options = args.extract_options!
      options[:class] = self.class

      args.each do |klass|
        validator = klass.new(options, &block)
        validator.validate(self)
      end
    end

### Private Instance Methods

raise_validation_error() click to toggle source

    # File lib/active_model/validations.rb, line 409
    def raise_validation_error # :doc:
      raise(ValidationError.new(self))
    end

run_validations!() click to toggle source

    # File lib/active_model/validations.rb, line 404
    def run_validations!
      _run_validate_callbacks
      errors.empty?
    end