Active Record验证

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

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

class Person < ApplicationRecord
end

irb> p = Person.new(name: "John Doe")
=> #<Person id: nil, name: "John Doe", created_at: nil, updated_at: nil>

irb> p.new_record?
=> true

irb> p.save
=> true

irb> p.new_record?
=> false

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

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

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

irb> p = Person.new
=> #<Person id: nil, name: nil>
irb> p.errors.size
=> 0

irb> p.valid?
=> false
irb> p.errors.objects.first.full_message
=> "Name can’t be blank"

irb> p = Person.create
=> #<Person id: nil, name: nil>
irb> p.errors.objects.first.full_message
=> "Name can’t be blank"

irb> p.save
=> false

irb> p.save!
ActiveRecord::RecordInvalid: Validation failed: Name can’t be blank

irb> Person.create!
ActiveRecord::RecordInvalid: Validation failed: Name can’t be blank

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

irb> Person.new.errors[:name].any?
=> false
irb> Person.create.errors[:name].any?
=> true

class Person < ApplicationRecord
  validates :terms_of_service, acceptance: true
end

class Person < ApplicationRecord
  validates :terms_of_service, acceptance: { message: '必须遵守' }
end

class Person < ApplicationRecord
  validates :terms_of_service, acceptance: { accept: '是' }
  validates :eula, acceptance: { accept: ['TRUE', '已接受'] }
end

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

<%= text_field :person, :email %>
<%= text_field :person, :email_confirmation %>

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

class Person < ApplicationRecord
  validates :email, confirmation: { case_sensitive: false }
end

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

class Promotion < ApplicationRecord
  validates :end_date, comparison: { greater_than: :start_date }
end

class Product < ApplicationRecord
  validates :legacy_code, format: { with: /\A[a-zA-Z]+\z/,
    message: "只允许字母" }
end

class Coffee < ApplicationRecord
  validates :size, inclusion: { in: %w(small medium large),
    message: "%{value} 不是一个有效的尺寸" }
end

class Account < ApplicationRecord
  validates :subdomain, exclusion: { in: %w(www us ca jp),
    message: "%{value} 是保留的。" }
end

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

class Person < ApplicationRecord
  validates :bio, length: { maximum: 1000,
    too_long: "%{count} 个字符是允许的最大长度" }
end

/\A[+-]?\d+\z/

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

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

class Supplier < ApplicationRecord
  has_one :account
  validates :account, presence: true
end

class Order < ApplicationRecord
  has_many :line_items, inverse_of: :order
end

# 值必须是true或false
validates :boolean_field_name, inclusion: [true, false]
# 值不能为nil，即true或false
validates :boolean_field_name, exclusion: [nil]

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

class LineItem < ApplicationRecord
  belongs_to :order
  validates :order, absence: true
end

class Order < ApplicationRecord
  has_many :line_items, inverse_of: :order
end

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

class Holiday < ApplicationRecord
  validates :name, uniqueness: { scope: :year,
    message: "每年只能发生一次" }
end

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

class Library < ApplicationRecord
  has_many :books
  validates_associated :books
end

class Person < ApplicationRecord
  validates_each :name, :surname do |record, attr, value|
    record.errors.add(attr, '必须以大写字母开头') if /\A[[:lower:]]/.match?(value)
  end
end

class GoodnessValidator < ActiveModel::Validator
  def validate(record)
    if record.first_name == "Evil"
      record.errors.add :base, "这个人是邪恶的"
    end
  end
end

class Person < ApplicationRecord
  validates_with GoodnessValidator
end

def validate(record)
  if record.some_field != "acceptable"
    record.errors.add :some_field, "此字段不可接受"
  end
end

class Person < ApplicationRecord
  validates_with MyValidator, MyOtherValidator, on: :create
end

class GoodnessValidator < ActiveModel::Validator
  def validate(record)
    if options[:fields].any? { |field| record.send(field) == "Evil" }
      record.errors.add :base, "这个人是邪恶的"
    end
  end
end

class Person < ApplicationRecord
  validates_with GoodnessValidator, fields: [:first_name, :last_name]
end

class Person < ApplicationRecord
  validate do |person|
    GoodnessValidator.new(person).validate
  end
end

class GoodnessValidator
  def initialize(person)
    @person = person
  end

  def validate
    if some_complex_condition_involving_ivars_and_private_methods?
      @person.errors.add :base, "这个人是邪恶的"
    end
  end

  # ...
end

class Coffee < ApplicationRecord
  validates :size, inclusion: { in: %w(small medium large),
    message: "%{value} 不是有效的尺寸" }, allow_nil: true
end

irb> Coffee.create(size: nil).valid?
=> true
irb> Coffee.create(size: "mega").valid?
=> false

class Topic < ApplicationRecord
  validates :title, length: { is: 5 }, allow_blank: true
end

irb> Topic.create(title: "").valid?
=> true
irb> Topic.create(title: nil).valid?
=> true

class Person < ApplicationRecord
  # 固定的消息
  validates :name, presence: { message: "必须提供" }

  # 包含动态属性值的消息。%{value}将被替换为属性的实际值。%{attribute}和%{model}也可用。
  validates :age, numericality: { message: "%{value}似乎不正确" }
end

class Person < ApplicationRecord
  validates :username,
    uniqueness: {
      # object = 正在验证的person对象
      # data = { model: "Person", attribute: "Username", value: <username> }
      message: ->(object, data) do
        "嘿#{object.name}，#{data[:value]}已经被使用了。"
      end
    }
end

class Person < ApplicationRecord
  # 可以使用重复的值更新电子邮件
  validates :email, uniqueness: true, on: :create

  # 可以使用非数字年龄创建记录
  validates :age, numericality: true, on: :update

  # 默认（在创建和更新时验证）
  validates :name, presence: true
end

class Person < ApplicationRecord
  validates :email, uniqueness: true, on: :account_setup
  validates :age, numericality: true, on: :account_setup
end

irb> person = Person.new(age: 'thirty-three')
irb> person.valid?
=> true
irb> person.valid?(:account_setup)
=> false
irb> person.errors.messages
=> {:email=>["已经被使用"], :age=>["不是一个数字"]}

class Book
  include ActiveModel::Validations

  validates :title, presence: true, on: [:update, :ensure_title]
end

irb> book = Book.new(title: nil)
irb> book.valid?
=> true
irb> book.valid?(:ensure_title)
=> false
irb> book.errors.messages
=> {:title=>["不能为空"]}

class Person < ApplicationRecord
  validates :email, uniqueness: true, on: :account_setup
  validates :age, numericality: true, on: :account_setup
  validates :name, presence: true
end

irb> person = Person.new
irb> person.valid?(:account_setup)
=> false
irb> person.errors.messages
=> {:email=>["已经被使用"], :age=>["不是一个数字"], :name=>["不能为空"]}

class Person < ApplicationRecord
  validates :name, presence: { strict: true }
end

irb> Person.new.valid?
ActiveModel::StrictValidationFailed: 名称不能为空

class Person < ApplicationRecord
  validates :token, presence: true, uniqueness: true, strict: TokenGenerationException
end

irb> Person.new.valid?
TokenGenerationException: 令牌不能为空

class Order < ApplicationRecord
  validates :card_number, presence: true, if: :paid_with_card?

  def paid_with_card?
    payment_type == "card"
  end
end

class Account < ApplicationRecord
  validates :password, confirmation: true,
    unless: Proc.new { |a| a.password.blank? }
end

validates :password, confirmation: true, unless: -> { password.blank? }

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

class Computer < ApplicationRecord
  validates :mouse, presence: true,
                    if: [Proc.new { |c| c.market.retail? }, :desktop?],
                    unless: Proc.new { |c| c.trackpad.present? }
end

class MyValidator < ActiveModel::Validator
  def validate(record)
    unless record.name.start_with? 'X'
      record.errors.add :name, "请提供以 X 开头的名称！"
    end
  end
end

class Person < ApplicationRecord
  validates_with MyValidator
end

class EmailValidator < ActiveModel::EachValidator
  def validate_each(record, attribute, value)
    unless URI::MailTo::EMAIL_REGEXP.match?(value)
      record.errors.add attribute, (options[:message] || "不是有效的电子邮件")
    end
  end
end

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

class Invoice < ApplicationRecord
  validate :expiration_date_cannot_be_in_the_past,
    :discount_cannot_be_greater_than_total_value

  def expiration_date_cannot_be_in_the_past
    if expiration_date.present? && expiration_date < Date.today
      errors.add(:expiration_date, "不能是过去的日期")
    end
  end

  def discount_cannot_be_greater_than_total_value
    if discount > total_value
      errors.add(:discount, "不能大于总价值")
    end
  end
end

class Invoice < ApplicationRecord
  validate :active_customer, on: :create

  def active_customer
    errors.add(:customer_id, "不是活动的") unless customer.active?
  end
end

class Person < ApplicationRecord
  validates :name, presence: true, on: :create
  validates :email, format: URI::MailTo::EMAIL_REGEXP
  validates_with MyOtherValidator, strict: true
end

irb> Person.validators
#=> [#<ActiveRecord::Validations::PresenceValidator:0x10b2f2158
      @attributes=[:name], @options={:on=>:create}>,
     #<MyOtherValidatorValidator:0x10b2f17d0
      @attributes=[:name], @options={:strict=>true}>,
     #<ActiveModel::Validations::FormatValidator:0x10b2f0f10
      @attributes=[:email],
      @options={:with=>URI::MailTo::EMAIL_REGEXP}>]
     #<MyOtherValidator:0x10b2f0948 @options={:strict=>true}>]

irb> Person.validators_on(:name)
#=> [#<ActiveModel::Validations::PresenceValidator:0x10b2f2158
      @attributes=[:name], @options={on: :create}>]

class Person < ApplicationRecord
  validates :name, presence: true, length: { minimum: 3 }
end

irb> person = Person.new
irb> person.valid?
=> false
irb> person.errors.full_messages
=> ["Name不能为空", "Name太短（最少为3个字符）"]

irb> person = Person.new(name: "John Doe")
irb> person.valid?
=> true
irb> person.errors.full_messages
=> []

irb> person = Person.new
irb> person.valid?
=> false
irb> person.errors.first.details
=> {:error=>:too_short, :count=>3}

class Person < ApplicationRecord
  validates :name, presence: true, length: { minimum: 3 }
end

irb> person = Person.new(name: "John Doe")
irb> person.valid?
=> true
irb> person.errors[:name]
=> []

irb> person = Person.new(name: "JD")
irb> person.valid?
=> false
irb> person.errors[:name]
=> ["太短（最少为3个字符）"]

irb> person = Person.new
irb> person.valid?
=> false
irb> person.errors[:name]
=> ["不能为空", "太短（最少为3个字符）"]

class Person < ApplicationRecord
  validates :name, presence: true, length: { minimum: 3 }
end

irb> person = Person.new
irb> person.valid?
=> false

irb> person.errors.where(:name)
=> [ ... ] # :name属性的所有错误

irb> person.errors.where(:name, :too_short)
=> [ ... ] # :name属性的:too_short错误

irb> person = Person.new
irb> person.valid?
=> false

irb> person.errors.where(:name, :too_short, minimum: 3)
=> [ ... ] # 所有名称错误都太短，最小为2

irb> error = person.errors.where(:name).last

irb> error.attribute
=> :name
irb> error.type
=> :too_short
irb> error.options[:count]
=> 3

irb> error.message
=> "太短（最少为3个字符）"
irb> error.full_message
=> "Name太短（最少为3个字符）"

class Person < ApplicationRecord
  validate do |person|
    errors.add :name, :too_plain, message: "不够酷"
  end
end

irb> person = Person.create
irb> person.errors.where(:name).first.type
=> :too_plain
irb> person.errors.where(:name).first.full_message
=> "名字不够酷"

class Person < ApplicationRecord
  validate do |person|
    errors.add :base, :invalid, message: "这个人无效，因为..."
  end
end

irb> person = Person.create
irb> person.errors.where(:base).first.full_message
=> "这个人无效，因为..."

class Person < ApplicationRecord
  validates :name, presence: true, length: { minimum: 3 }
end

irb> person = Person.new
irb> person.valid?
=> false
irb> person.errors.size
=> 2

irb> person = Person.new(name: "Andrea", email: "[email protected]")
irb> person.valid?
=> true
irb> person.errors.size
=> 0

class Person < ApplicationRecord
  validates :name, presence: true, length: { minimum: 3 }
end

irb> person = Person.new
irb> person.valid?
=> false
irb> person.errors.empty?
=> false

irb> person.errors.clear
irb> person.errors.empty?
=> true

irb> person.save
=> false

irb> person.errors.empty?
=> false

<% if @article.errors.any? %>
  <div id="error_explanation">
    <h2><%= pluralize(@article.errors.count, "error") %> 阻止保存此文章：</h2>

    <ul>
      <% @article.errors.each do |error| %>
        <li><%= error.full_message %></li>
      <% end %>
    </ul>
  </div>
<% end %>

<div class="field_with_errors">
  <input id="article_title" name="article[title]" size="30" type="text" value="">
</div>

.field_with_errors {
  padding: 2px;
  background-color: red;
  display: table;
}