Ruby on Rails
Validación de ActiveRecord

Validando la numericalidad de un atributo.

Esta validación restringe la inserción de solo valores numéricos.

class Player < ApplicationRecord
  validates :points, numericality: true
  validates :games_played, numericality: { only_integer: true }
end

Además :only_integer , este asistente también acepta las siguientes opciones para agregar restricciones a los valores aceptables:

• :greater_than : especifica que el valor debe ser mayor que el valor proporcionado. El mensaje de error predeterminado para esta opción es "debe ser mayor que% {count}".
• :greater_than_or_equal_to : especifica que el valor debe ser mayor o igual al valor suministrado. El mensaje de error predeterminado para esta opción es "debe ser mayor o igual a% {count}".
• :equal_to : especifica que el valor debe ser igual al valor suministrado. El mensaje de error predeterminado para esta opción es "debe ser igual a% {count}".
• :less_than : especifica que el valor debe ser menor que el valor proporcionado. El mensaje de error predeterminado para esta opción es "debe ser menor que% {count}".
• :less_than_or_equal_to : especifica que el valor debe ser menor o igual al valor proporcionado. El mensaje de error predeterminado para esta opción es "debe ser menor o igual a% {count}".
• :other_than : especifica que el valor debe ser distinto del valor suministrado. El mensaje de error predeterminado para esta opción es "debe ser distinto de% {count}".
• :odd : especifica que el valor debe ser un número impar si se establece en true. El mensaje de error predeterminado para esta opción es "debe ser impar".
• :even : especifica que el valor debe ser un número par si se establece en true. El mensaje de error predeterminado para esta opción es "debe ser par".

Por defecto, la numericalidad no permite valores nulos. Puede usar la opción allow_nil: true para permitirlo.

Validar la singularidad de un atributo.

Este ayudante valida que el valor del atributo sea único justo antes de que se guarde el objeto.

class Account < ApplicationRecord
  validates :email, uniqueness: true
end

Hay una opción de :scope que puede usar para especificar uno o más atributos que se usan para limitar la verificación de unicidad:

class Holiday < ApplicationRecord
  validates :name, uniqueness: { scope: :year,
    message: "should happen once per year" }
end

También hay una opción :case_sensitive que puede usar para definir si la restricción de unicidad será sensible a mayúsculas o no. Esta opción por defecto es true .

class Person < ApplicationRecord
  validates :name, uniqueness: { case_sensitive: false }
end

Validar la presencia de un atributo.

Este ayudante valida que los atributos especificados no estén vacíos.

class Person < ApplicationRecord
  validates :name, presence: true
end

Person.create(name: "John").valid? # => true
Person.create(name: nil).valid? # => false

Puede usar el asistente de absence para validar que los atributos especificados están ausentes. ¿Utiliza el present? Método para verificar valores nulos o vacíos.

class Person < ApplicationRecord
  validates :name, :login, :email, absence: true
end

Nota: En caso de que el atributo sea boolean , no puede hacer uso de la validación de presencia habitual (el atributo no sería válido para un valor false ). Puede hacer esto utilizando una validación de inclusión:

validates :attribute, inclusion: [true, false]

Saltando validaciones

Utilice los siguientes métodos si desea omitir las validaciones. Estos métodos guardarán el objeto en la base de datos incluso si no es válido.

• ¡decremento!
• decrement_counter
• ¡incremento!
• increment_counter
• ¡palanca!
• toque
• actualizar todo
• atributo_actualizacion
• update_column
• update_columns
• actualizar_contadores

También puede omitir la validación mientras se guarda al pasar validate como un argumento para save

User.save(validate: false)

Validación de la longitud de un atributo.

class Person < ApplicationRecord
  validates :name, length: { minimum: 2 }
  validates :bio, length: { maximum: 500 }
  validates :password, length: { in: 6..20 }
  validates :registration_number, length: { is: 6 }
end

Las posibles opciones de restricción de longitud son:

• :minimum : el atributo no puede tener menos de la longitud especificada.
• :maximum : el atributo no puede tener más de la longitud especificada.
• :in (o :within ): la longitud del atributo debe incluirse en un intervalo determinado. El valor para esta opción debe ser un rango.
• :is - La longitud del atributo debe ser igual al valor dado.

Validación de agrupación

A veces es útil tener varias validaciones para usar una condición. Se puede lograr fácilmente usando with_options.

class User < ApplicationRecord
  with_options if: :is_admin? do |admin|
    admin.validates :password, length: { minimum: 10 }
    admin.validates :email, presence: true
  end
end

Todas las validaciones dentro del bloque with_options pasarán automáticamente la condición si:: is_admin?

Validaciones personalizadas

Puede agregar sus propias validaciones agregando nuevas clases heredadas de ActiveModel::Validator o de ActiveModel::EachValidator . Ambos métodos son similares pero funcionan de formas ligeramente diferentes:

ActiveModel::Validator and validates_with

Implementar el método de validate que toma un registro como argumento y realiza la validación en él. Luego use validates_with con la clase en el modelo.

# app/validators/starts_with_a_validator.rb
class StartsWithAValidator < ActiveModel::Validator
  def validate(record)
    unless record.name.starts_with? 'A'
      record.errors[:name] << 'Need a name starting with A please!'
    end
  end
end
 
class Person < ApplicationRecord
  validates_with StartsWithAValidator
end

ActiveModel::EachValidator y validate

Si prefiere usar su nuevo validador usando el método de validate común en un solo parámetro, cree una clase ActiveModel::EachValidator de ActiveModel::EachValidator e implemente el método validate_each que toma tres argumentos: record , attribute y value :

class EmailValidator < ActiveModel::EachValidator
  def validate_each(record, attribute, value)
    unless value =~ /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i
      record.errors[attribute] << (options[:message] || 'is not an email')
    end
  end
end
 
class Person < ApplicationRecord
  validates :email, presence: true, email: true
end

Más información sobre las guías de rieles .

Valida el formato de un atributo.

Valide que el valor de un atributo coincida con una expresión regular usando el format y la opción with .

class User < ApplicationRecord
  validates :name, format: { with: /\A\w{6,10}\z/ }
end

También puede definir una constante y establecer su valor en una expresión regular y pasarla a la opción with: Esto podría ser más conveniente para expresiones regulares realmente complejas

PHONE_REGEX = /\A\(\d{3}\)\d{3}-\d{4}\z/
validates :phone, format: { with: PHONE_REGEX }

El mensaje de error predeterminado is invalid . Esto se puede cambiar con la opción :message .

validates :bio, format: { with: /\A\D+\z/, message: "Numbers are not allowed" }

El reverso también responde, y puede especificar que un valor no debe coincidir con una expresión regular con la opción without:

Valida la inclusión de un atributo.

Puede verificar si un valor está incluido en una matriz usando la inclusion: helper. La opción :in y su alias,: :within muestran el conjunto de valores aceptables.

class Country < ApplicationRecord
  validates :continent, inclusion: { in: %w(Africa Antartica Asia Australia
                                            Europe North America South America) }
end

Para verificar si un valor no está incluido en una matriz, use la exclusion: helper

class User < ApplicationRecord
  validates :name, exclusion: { in: %w(admin administrator owner) }
end

Validación condicional

A veces es posible que necesite validar el registro solo bajo ciertas condiciones.

class User < ApplicationRecord
  validates :name, presence: true, if: :admin? 

  def admin?
    conditional here that returns boolean value
  end
end

Si tu condicional es realmente pequeño, puedes usar un Proc:

class User < ApplicationRecord
  validates :first_name, presence: true, if: Proc.new { |user| user.last_name.blank? }
end

Para condicional negativo puede usar a unless :

class User < ApplicationRecord
  validates :first_name, presence: true, unless: Proc.new { |user| user.last_name.present? }
end

También puede pasar una cadena, que se ejecutará a través de instance_eval :

class User < ApplicationRecord
  validates :first_name, presence: true, if: 'last_name.blank?'
end

Confirmación de atributo

Debe usar esto cuando tenga dos campos de texto que deberían recibir exactamente el mismo contenido. Por ejemplo, es posible que desee confirmar una dirección de correo electrónico o una contraseña. Esta validación crea un atributo virtual cuyo nombre es el nombre del campo que debe confirmarse con _confirmation anexada.

class Person < ApplicationRecord
  validates :email, confirmation: true
end

Nota Esta comprobación se realiza solo si email_confirmation no es nulo.

Para requerir confirmación, asegúrese de agregar una verificación de presencia para el atributo de confirmación.

class Person < ApplicationRecord
  validates :email,      confirmation: true
  validates :email_confirmation, presence: true
end

Fuente

Usando: en la opción

La opción :on permite especificar cuándo debe ocurrir la validación. El comportamiento predeterminado para todos los ayudantes de validación incorporados se debe ejecutar en guardar (tanto cuando está creando un nuevo registro como cuando lo está actualizando).

class Person < ApplicationRecord
  # it will be possible to update email with a duplicated value
  validates :email, uniqueness: true, on: :create
 
  # it will be possible to create the record with a non-numerical age
  validates :age, numericality: true, on: :update
 
  # the default (validates on both create and update)
  validates :name, presence: true
end