Ruby on Rails
Validazioni ActiveRecord

Convalida della numericità di un attributo

Questa convalida limita l'inserimento di soli valori numerici.

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

Inoltre :only_integer , questo helper accetta anche le seguenti opzioni per aggiungere vincoli a valori accettabili:

• :greater_than - Specifica che il valore deve essere maggiore del valore fornito. Il messaggio di errore predefinito per questa opzione è "deve essere maggiore di% {count}".
• :greater_than_or_equal_to - Specifica che il valore deve essere maggiore o uguale al valore fornito. Il messaggio di errore predefinito per questa opzione è "deve essere maggiore o uguale a% {count}".
• :equal_to - Specifica che il valore deve essere uguale al valore fornito. Il messaggio di errore predefinito per questa opzione è "deve essere uguale a% {count}".
• :less_than - Specifica che il valore deve essere inferiore al valore fornito. Il messaggio di errore predefinito per questa opzione è "deve essere inferiore a% {count}".
• :less_than_or_equal_to - Specifica che il valore deve essere minore o uguale al valore fornito. Il messaggio di errore predefinito per questa opzione è "deve essere minore o uguale a% {count}".
• :other_than - Specifica che il valore deve essere diverso dal valore fornito. Il messaggio di errore predefinito per questa opzione è "deve essere diverso da% {count}".
• :odd - Specifica che il valore deve essere un numero dispari se impostato su true. Il messaggio di errore predefinito per questa opzione è "deve essere dispari".
• :even - Specifica che il valore deve essere un numero pari se impostato su true. Il messaggio di errore predefinito per questa opzione è "deve essere pari".

Per impostazione predefinita, la numericità non consente valori nulli. Puoi usare allow_nil: true per permetterlo.

Convalida l'unicità di un attributo

Questo helper convalida che il valore dell'attributo è univoco proprio prima che l'oggetto venga salvato.

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

Esiste un'opzione :scope che è possibile utilizzare per specificare uno o più attributi utilizzati per limitare il controllo di unicità:

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

Esiste anche un'opzione :case_sensitive che è possibile utilizzare per definire se il vincolo di univocità sarà sensibile al maiuscolo o minuscolo. Questa opzione è impostata su true .

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

Convalida presenza di un attributo

Questo helper convalida che gli attributi specificati non sono vuoti.

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

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

È possibile utilizzare l'helper absence per convalidare che gli attributi specificati sono assenti. Usa il present? metodo per verificare valori nulli o vuoti.

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

Nota: se l'attributo è di tipo boolean , non è possibile utilizzare la normale convalida di presenza (l'attributo non sarebbe valido per un valore false ). È possibile ottenere questo risultato utilizzando una convalida di inclusione:

validates :attribute, inclusion: [true, false]

Saltare le convalide

Usa i seguenti metodi se vuoi saltare le convalide. Questi metodi salveranno l'oggetto nel database anche se non è valido.

• decrementare!
• decrement_counter
• incremento!
• increment_counter
• alternare!
• toccare
• aggiorna tutto
• update_attribute
• update_column
• update_columns
• update_counters

È inoltre possibile saltare la convalida durante il salvataggio passando validate come argomento per save

User.save(validate: false)

Convalida della lunghezza di un attributo

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

Le possibili opzioni di limitazione della lunghezza sono:

• :minimum - L'attributo non può avere meno della lunghezza specificata.
• :maximum - L'attributo non può avere più della lunghezza specificata.
• :in (o :within ) - La lunghezza dell'attributo deve essere inclusa in un dato intervallo. Il valore per questa opzione deve essere un intervallo.
• :is - La lunghezza dell'attributo deve essere uguale al valore specificato.

Convalida del raggruppamento

A volte è utile avere più convalida per utilizzare una condizione. Può essere facilmente raggiunto 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

Tutte le convalide all'interno del blocco with_options avranno automaticamente superato la condizione se:: is_admin?

Convalide personalizzate

È possibile aggiungere le proprie convalide aggiungendo nuove classi ereditate da ActiveModel::Validator o da ActiveModel::EachValidator . Entrambi i metodi sono simili ma funzionano in modi leggermente diversi:

ActiveModel::Validator e validates_with

Implementa il metodo di validate che prende un record come argomento ed esegue la convalida su di esso. Quindi utilizzare validates_with con la classe sul modello.

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

Se si preferisce utilizzare il nuovo validatore utilizzando il metodo di validate comune su un singolo parametro, creare una classe che eredita da ActiveModel::EachValidator e implementare il metodo validate_each che accetta tre argomenti: record , attribute e 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

Maggiori informazioni sulle guide di Rails .

Convalida il formato di un attributo

Convalida che il valore di un attributo corrisponde a un'espressione regolare utilizzando il format e l'opzione with .

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

Puoi anche definire una costante e impostarne il valore su un'espressione regolare e passarla all'opzione with: . Questo potrebbe essere più conveniente per espressioni regolari davvero complesse

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

Il messaggio di errore predefinito is invalid . Questo può essere modificato con l'opzione :message .

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

Anche il contrario risponde e puoi specificare che un valore non deve corrispondere a un'espressione regolare con l'opzione without:

Convalida l'inclusione di un attributo

Puoi verificare se un valore è incluso in un array usando l' inclusion: helper. L'opzione :in e il suo alias,: :within mostra l'insieme di valori accettabili.

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

Per verificare se un valore non è incluso in una matrice, utilizzare l' exclusion: helper

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

Convalida condizionale

A volte potrebbe essere necessario convalidare la registrazione solo in determinate condizioni.

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

  def admin?
    conditional here that returns boolean value
  end
end

Se il tuo condizionale è veramente piccolo, puoi usare un Proc:

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

Per condizionale negativo è possibile utilizzare a unless :

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

Puoi anche passare una stringa, che verrà eseguita tramite instance_eval :

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

Conferma dell'attributo

Dovresti usare questo quando hai due campi di testo che dovrebbero ricevere esattamente lo stesso contenuto. Ad esempio, potresti voler confermare un indirizzo email o una password. Questa convalida crea un attributo virtuale il cui nome è il nome del campo che deve essere confermato con _confirmation aggiunto.

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

Nota Questo controllo viene eseguito solo se email_confirmation non è nullo.

Per richiedere la conferma, assicurati di aggiungere un controllo di presenza per l'attributo di conferma.

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

fonte

Utilizzo: su opzione

L'opzione :on consente di specificare quando deve avvenire la convalida. Il comportamento predefinito per tutti gli helper di convalida incorporati deve essere eseguito su save (sia quando si crea un nuovo record sia quando lo si aggiorna).

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