Ruby on Rails
Validations ActiveRecord

Valider la numéricité d'un attribut

Cette validation limite l'insertion de valeurs numériques uniquement.

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

Outre :only_integer , cet assistant accepte également les options suivantes pour ajouter des contraintes aux valeurs acceptables:

• :greater_than - Spécifie que la valeur doit être supérieure à la valeur fournie. Le message d'erreur par défaut pour cette option est "doit être supérieur à% {count}".
• :greater_than_or_equal_to - Spécifie que la valeur doit être supérieure ou égale à la valeur fournie. Le message d'erreur par défaut pour cette option est "doit être supérieur ou égal à% {count}".
• :equal_to - Spécifie que la valeur doit être égale à la valeur fournie. Le message d'erreur par défaut pour cette option est "doit être égal à% {count}".
• :less_than - Spécifie que la valeur doit être inférieure à la valeur fournie. Le message d'erreur par défaut pour cette option est "doit être inférieur à% {count}".
• :less_than_or_equal_to - Spécifie que la valeur doit être inférieure ou égale à la valeur fournie. Le message d'erreur par défaut pour cette option est "doit être inférieur ou égal à% {count}".
• :other_than - Spécifie que la valeur doit être différente de la valeur fournie. Le message d'erreur par défaut pour cette option est "doit être différent de% {count}".
• :odd - Spécifie que la valeur doit être un nombre impair si elle est définie sur true. Le message d'erreur par défaut pour cette option est "doit être impair".
• :even - Spécifie que la valeur doit être un nombre pair si elle est définie sur true. Le message d'erreur par défaut pour cette option est "doit être pair".

Par défaut, la numéricité n'autorise aucune valeur nulle. Vous pouvez utiliser l'option allow_nil: true pour l'autoriser.

Valider l'unicité d'un attribut

Cet assistant vérifie que la valeur de l'attribut est unique juste avant que l'objet soit enregistré.

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

Il existe une option :scope que vous pouvez utiliser pour spécifier un ou plusieurs attributs utilisés pour limiter la vérification de l'unicité:

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

Il existe également une option :case_sensitive que vous pouvez utiliser pour définir si la contrainte d'unicité doit être sensible à la casse ou non. Cette option est définie par défaut sur true .

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

Valider la présence d'un attribut

Cet assistant vérifie que les attributs spécifiés ne sont pas vides.

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

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

Vous pouvez utiliser l'assistant d' absence pour valider l' absence des attributs spécifiés. Il utilise le present? méthode pour vérifier les valeurs nulles ou vides.

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

Remarque: Si l'attribut est boolean , vous ne pouvez pas utiliser la validation de présence habituelle (l'attribut ne serait pas valide pour une valeur false ). Vous pouvez le faire en utilisant une validation d'inclusion:

validates :attribute, inclusion: [true, false]

Saut des validations

Utilisez les méthodes suivantes si vous souhaitez ignorer les validations. Ces méthodes enregistreront l'objet dans la base de données même s'il n'est pas valide.

• décrémenter!
• decrement_counter
• incrément!
• increment_counter
• basculer!
• toucher
• Tout mettre à jour
• update_attribute
• update_column
• update_columns
• update_counters

Vous pouvez également ignorer la validation lors de l'enregistrement en transmettant validate comme argument pour save

User.save(validate: false)

Valider la longueur d'un attribut

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

Les options possibles de contrainte de longueur sont les suivantes:

• :minimum - L'attribut ne peut pas avoir moins que la longueur spécifiée.
• :maximum - L'attribut ne peut pas avoir plus que la longueur spécifiée.
• :in (or :within ) - La longueur de l'attribut doit être incluse dans un intervalle donné. La valeur de cette option doit être une plage.
• :is - La longueur de l'attribut doit être égale à la valeur donnée.

Validation groupée

Parfois, il est utile d'avoir plusieurs validations utilisant une seule condition. Cela peut être facilement réalisé en utilisant 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

Toutes les validations à l'intérieur du bloc with_options auront automatiquement passé la condition si:: is_admin?

Validations personnalisées

Vous pouvez ajouter vos propres validations en ajoutant de nouvelles classes héritant d' ActiveModel::Validator ou d' ActiveModel::EachValidator . Les deux méthodes sont similaires mais fonctionnent différemment:

ActiveModel::Validator et validates_with

Implémentez la méthode validate qui prend un enregistrement en argument et effectue la validation sur celui-ci. Ensuite, utilisez validates_with avec la classe sur le modèle.

# 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 et validate

Si vous préférez utiliser votre nouveau validateur en utilisant la méthode validate commune sur un seul paramètre, créez une classe héritant d' ActiveModel::EachValidator et implémentez la méthode validate_each qui prend trois arguments: record , attribute et 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

Plus d'informations sur les guides Rails .

Valide le format d'un attribut

Validez que la valeur d'un attribut correspond à une expression régulière utilisant le format et l'option with .

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

Vous pouvez également définir une constante et définir sa valeur sur une expression régulière et la transmettre à l'option with: :. Cela pourrait être plus pratique pour les expressions régulières très complexes

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

Le message d'erreur par défaut is invalid . Cela peut être changé avec l'option :message .

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

L'inverse répond également, et vous pouvez spécifier qu'une valeur ne doit pas correspondre à une expression régulière avec l'option without:

Valide l'inclusion d'un attribut

Vous pouvez vérifier si une valeur est incluse dans un tableau en utilisant l' inclusion: helper. L'option :in et son alias :within indiquent l'ensemble des valeurs acceptables.

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

Pour vérifier si une valeur n'est pas incluse dans un tableau, utilisez l' exclusion: helper

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

Validation conditionnelle

Parfois, vous devrez peut-être valider un enregistrement uniquement sous certaines conditions.

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

  def admin?
    conditional here that returns boolean value
  end
end

Si vous êtes conditionnel, vous pouvez utiliser un Proc:

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

Pour conditionnel négatif, vous pouvez utiliser à unless :

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

Vous pouvez également passer une chaîne, qui sera exécutée via instance_eval :

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

Confirmation de l'attribut

Vous devez l'utiliser lorsque vous avez deux champs de texte qui doivent recevoir exactement le même contenu. Par exemple, vous souhaiterez peut-être confirmer une adresse e-mail ou un mot de passe. Cette validation crée un attribut virtuel dont le nom est le nom du champ à confirmer avec _confirmation ajouté.

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

Remarque Cette vérification est effectuée uniquement si email_confirmation n'est pas nul.

Pour demander une confirmation, veillez à ajouter un contrôle de présence pour l'attribut de confirmation.

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

La source

Utiliser: en option

L'option :on vous permet de spécifier quand la validation doit avoir lieu. Le comportement par défaut de tous les assistants de validation intégrés doit être exécuté lors de l'enregistrement (à la fois lorsque vous créez un nouvel enregistrement et lorsque vous le mettez à jour).

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