Ruby on Rails
Walidacje ActiveRecord

Sprawdzanie poprawności liczbowej atrybutu

Ta walidacja ogranicza wstawianie tylko wartości liczbowych.

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

Poza tym :only_integer ten pomocnik akceptuje również następujące opcje, aby dodać ograniczenia do akceptowalnych wartości:

• :greater_than - określa, że wartość musi być większa niż podana wartość. Domyślny komunikat o błędzie dla tej opcji to „musi być większy niż% {count}”.
• :greater_than_or_equal_to - Określa, że wartość musi być większa lub równa :greater_than_or_equal_to wartości. Domyślny komunikat o błędzie dla tej opcji to „musi być większy lub równy% {count}”.
• :equal_to - określa, że wartość musi być równa :equal_to wartości. Domyślny komunikat o błędzie dla tej opcji to „musi być równy% {count}”.
• :less_than - określa, że wartość musi być mniejsza niż podana wartość. Domyślny komunikat błędu dla tej opcji to „musi być mniejszy niż% {count}”.
• :less_than_or_equal_to - Określa, że wartość musi być mniejsza lub równa :less_than_or_equal_to wartości. Domyślny komunikat błędu dla tej opcji to „musi być mniejszy lub równy% {count}”.
• :other_than - określa, że wartość musi być inna niż wartość podana. Domyślny komunikat błędu dla tej opcji to „musi być inny niż% {count}”.
• :odd - określa, że wartość musi być liczbą nieparzystą, jeśli jest ustawiona na true. Domyślny komunikat błędu dla tej opcji to „musi być nieparzysty”.
• :even - określa, że wartość musi być liczbą parzystą, jeśli jest ustawiona na true. Domyślny komunikat błędu dla tej opcji to „musi być parzysty”.

Domyślnie numeryczność nie dopuszcza wartości zerowych. Możesz użyć opcji allow_nil: true, aby na to zezwolić.

Sprawdź unikalność atrybutu

Ten pomocnik sprawdza, czy wartość atrybutu jest unikalna tuż przed zapisaniem obiektu.

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

Istnieje opcja :scope , której można użyć do określenia jednego lub więcej atrybutów, które są używane do ograniczenia kontroli unikatowości:

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

Istnieje również opcja :case_sensitive rozróżnianie wielkości liter, której można użyć do zdefiniowania, czy ograniczenie niepowtarzalności rozróżnia wielkość liter, czy nie. Domyślnie ta opcja ma wartość true .

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

Sprawdzanie obecności atrybutu

Ten pomocnik sprawdza, czy określone atrybuty nie są puste.

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

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

Za pomocą pomocnika absence można sprawdzić, czy określone atrybuty są nieobecne. Wykorzystuje present? metoda sprawdzania wartości zerowej lub pustej.

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

Uwaga: W przypadku, gdy atrybut ma wartość boolean , nie można użyć zwykłej weryfikacji obecności (atrybut nie byłby prawidłowy dla wartości false ). Możesz to zrobić za pomocą sprawdzania poprawności włączenia:

validates :attribute, inclusion: [true, false]

Pomijanie sprawdzeń poprawności

Jeśli chcesz pominąć sprawdzanie poprawności, użyj następujących metod. Te metody zapiszą obiekt w bazie danych, nawet jeśli jest on nieprawidłowy.

• ubytek!
• licznik_dekrementacji
• przyrost!
• increment_counter
• przełącznik!
• dotknąć
• update_all
• update_attribute
• aktualizacja_kolumna
• aktualizacja_kolumn
• update_counters

Możesz także pominąć sprawdzanie poprawności podczas zapisywania, przekazując validate jako argument do save

User.save(validate: false)

Sprawdzanie poprawności długości atrybutu

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

Możliwe opcje ograniczenia długości to:

• :minimum - atrybut nie może mieć mniejszej niż określona długość.
• :maximum - atrybut nie może mieć więcej niż określoną długość.
• :in (lub :within ) - długość atrybutu musi być uwzględniona w danym przedziale. Wartość tej opcji musi być zakresem.
• :is - Długość atrybutu musi być równa podanej wartości.

Sprawdzanie poprawności grupowania

Czasami przydaje się wielokrotne sprawdzanie poprawności przy użyciu jednego warunku. Można to łatwo osiągnąć za pomocą opcji 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

Wszystkie walidacje w bloku with_options automatycznie przejdą warunek, jeśli:: is_admin?

Weryfikacje niestandardowe

Możesz dodać własne walidacje, dodając nowe klasy dziedziczące z ActiveModel::Validator lub z ActiveModel::EachValidator . Obie metody są podobne, ale działają w nieco inny sposób:

ActiveModel::Validator i validates_with

Zaimplementuj metodę validate , która pobiera rekord jako argument i wykonuje na nim weryfikację. Następnie użyj validates_with z klasą w modelu.

# 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 i ActiveModel::EachValidator validate

Jeśli wolisz używać nowego validate za pomocą wspólnej metody validate na pojedynczym parametrze, utwórz klasę dziedziczącą z ActiveModel::EachValidator i zaimplementuj metodę validate_each , która przyjmuje trzy argumenty: record , attribute i 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

Więcej informacji na temat przewodników po szynach .

Sprawdza format atrybutu

Sprawdź, czy wartość atrybutu jest zgodna z wyrażeniem regularnym, używając format i opcji with .

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

Możesz także zdefiniować stałą i ustawić jej wartość na wyrażenie regularne i przekazać ją do opcji with: :. Może to być wygodniejsze w przypadku naprawdę złożonych wyrażeń regularnych

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

Domyślny komunikat o błędzie is invalid . Można to zmienić za pomocą opcji :message .

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

Odwrotna odpowiedź również, i można określić, że wartość nie powinna pasować do wyrażenia regularnego z opcją „ without:

Sprawdza poprawność włączenia atrybutu

Możesz sprawdzić, czy wartość jest zawarta w tablicy, korzystając z parametru inclusion: helper. Opcja :in opcji i jej alias :within wyświetla zbiór dopuszczalnych wartości.

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

Aby sprawdzić, czy wartość nie jest zawarta w tablicy, użyj exclusion: pomocnik

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

Walidacja warunkowa

Czasami może być konieczne sprawdzenie poprawności zapisu tylko pod pewnymi warunkami.

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

  def admin?
    conditional here that returns boolean value
  end
end

Jeśli warunek jest naprawdę mały, możesz użyć Proc:

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

W przypadku warunku ujemnego można użyć, unless :

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

Możesz także przekazać ciąg znaków, który zostanie wykonany za pomocą instance_eval :

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

Potwierdzenie atrybutu

Powinieneś tego użyć, gdy masz dwa pola tekstowe, które powinny otrzymać dokładnie taką samą treść. Na przykład możesz chcieć potwierdzić adres e-mail lub hasło. Ta walidacja tworzy wirtualny atrybut, którego nazwa to nazwa pola, które musi zostać potwierdzone przez _confirmation .

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

Uwaga Ta kontrola jest przeprowadzana tylko wtedy, gdy email_confirmation nie jest zerowe.

Aby wymagać potwierdzenia, należy dodać sprawdzanie obecności dla atrybutu potwierdzenia.

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

Źródło

Korzystanie: z opcji

Opcja :on pozwala określić, kiedy ma nastąpić walidacja. Domyślnym zachowaniem wszystkich wbudowanych pomocników sprawdzania poprawności jest uruchamianie podczas zapisywania (zarówno podczas tworzenia nowego rekordu, jak i podczas jego aktualizacji).

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