render plain: params[:article].inspect

# 使用 ActiveRecord::Base.table_name= 方法可以指定要使用的表名：
class Product < ApplicationRecord
  self.table_name = "my_products"
end

# 如果这么做，还要调用 set_fixture_class 方法，手动指定固件（my_products.yml）的类名：
class ProductTest < ActiveSupport::TestCase
  set_fixture_class my_products: Product
  fixtures :my_products
  ...
end

# 还可以使用 ActiveRecord::Base.primary_key= 方法指定表的主键：
class Product < ApplicationRecord
  self.primary_key = "product_id"
end

class ChangeProductsPrice < ActiveRecord::Migration[5.0]
  def change
    reversible do |dir|
      change_table :products do |t|
        dir.up   { t.change :price, :string }
        dir.down { t.change :price, :integer }
      end
    end
  end
end

validates :terms_of_service, acceptance: { accept: 'yes' }
validates :eula, acceptance: { accept: ['TRUE', 'accepted'] }

has_many :books
validates_associated :books # 不要在关联的两端都使用 validates_associated，这样会变成无限循环。

validates :email, confirmation: true
# 只有 email_confirmation 的值不是 nil 时才会检查。所以要为确认属性加上存在性验证
# 还可以使用 :case_sensitive 选项指定确认时是否区分大小写。这个选项的默认值是 true
validates :email_confirmation, presence: true

validates :subdomain, exclusion: { in: %w(www us ca jp) }
validates :legacy_code, format: { with: /\A[a-zA-Z]+\z/, message: "only allows letters" }
validates :registration_number, length: { minimum: 2, maximum: 500, in: 6..20, is: 6 }
validates :games_played, numericality: { only_integer: true } # numericality 默认不接受 nil 值
validates :name, :login, :email, absence: true

class LineItem < ApplicationRecord
  belongs_to :order
  validates :order, presence: true # 如果要确保关联对象存在，需要测试关联的对象本身是否存在，而不是用来映射关联的外键
end

class Order < ApplicationRecord
  has_many :line_items, inverse_of: :order # 为了能验证关联的对象是否存在，要在关联中指定 :inverse_of 选项
end

class LineItem < ApplicationRecord
  belongs_to :order
  validates :order, absence: true # 要测试关联的对象本身是否为空，而不是用来映射关联的外键
end

class Order < ApplicationRecord
  has_many :line_items, inverse_of: :order # 为了能验证关联的对象是否为空，要在关联中指定 :inverse_of 选项。
end

validates :boolean_field_name, inclusion: { in: [true, false] }
validates :boolean_field_name, exclusion: { in: [nil] }

class GoodnessValidator < ActiveModel::Validator
  def validate(record)
    if options[:fields].any?{|field| record.send(field) == "Evil" }
      record.errors[:base] << "This person is evil"
    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[:base] << "This person is evil"
    end
  end
  # ...
end

class Person < ApplicationRecord
  validates_each :name, :surname do |record, attr, value|
    record.errors.add(attr, 'must start with upper case') if value =~ /\A[[:lower:]]/
  end
end

class Person < ApplicationRecord
  # 直接写消息
  validates :name, presence: { message: "must be given please" }

  # 带有动态属性值的消息。%{value} 会被替换成属性的值
  # 此外还可以使用 %{attribute} 和 %{model}
  validates :age, numericality: { message: "%{value} seems wrong" }

  # Proc
  validates :username,
    uniqueness: {
      # object = 要验证的 person 对象
      # data = { model: "Person", attribute: "Username", value: <username> }
      message: ->(object, data) do
        "Hey #{object.name}!, #{data[:value]} is taken already! Try again #{Time.zone.tomorrow}"
      end
    }
end

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

person = Person.new
person.valid?(:account_setup) # 会执行上述两个验证，但不保存记录。
person.save(context: :account_setup) # 在保存之前在 account_setup 上下文中验证 person。显式触发时，可以只使用某个上下文验证，也可以不使用某个上下文验证。

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

Person.new.valid?  # => ActiveModel::StrictValidationFailed: Name can't be blank

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

Person.new.valid?  # => TokenGenerationException: Token can't be blank

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

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

class MyValidator < ActiveModel::Validator
  def validate(record)
    unless record.name.starts_with? 'X'
      record.errors[:name] << 'Need a name starting with X please!'
    end
  end
end

class Person
  include ActiveModel::Validations
  validates_with MyValidator
end

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

class Person < ApplicationRecord
  def a_method_used_for_validation_purposes
    errors.add(:name, "cannot contain the characters !@#%*()_-+=")
  end

  def a_method_used_for_validation_purposes
    errors.add(:name, :invalid_characters, not_allowed: "!@#%*()_-+=")
  end
end

person.valid?
person.errors.messages #=> {:name=>["can't be blank", "is too short (minimum is 3 characters)"]}
person.errors[:name] #=> ["is too short (minimum is 3 characters)"]
person.errors.full_messages #=> ["Name cannot contain the characters !@#%*()_-+="]
person.errors.details[:name] #=> [{error: :invalid_characters}]