validates_uniqueness_of(フィールド名..)

validates_uniqueness_of :user_name, scope: :account_id

validates_associated(バリデーション対象..)

class Book < ActiveRecord::Base
  has_many :pages
  belongs_to :library
  validates_associated :pages, :library
end

validates(種類, オプション引数)

# 失敗したら例外発生
validates!(種類, オプション引数)

validates :form, acceptance: true

validates :form, acceptance: false

validates :email, confirmation: true

validates :email, confirmation: false

validates :subdomain, exclusion: {in: %w(www us ca jp)}

validates :legacy_code, format: {with: /\A[a-zA-Z]+\z/}

validates :size, inclusion: {in: %w(small medium large)}

validates :name, length: {minimum: 2}

validates :points, numericality: true

validates :name, :login, :email, presence: true

validates :name, :login, :email, absence: true

validates :email, uniqueness: true

validates_presence_of(バリデーション対象..)

validates_presence_of :first_name

validate(バリデーションメソッド名.., ブロック引数)

# 失敗したら例外発生
validate!(バリデーションメソッド名.., ブロック引数)

validate :must_be_friends

validate do |comment|
  comment.must_be_friends
end

validates_absence_of(フィールド名..)

class Person < ActiveRecord::Base
  validates_acceptance_of :terms_of_service
  validates_acceptance_of :eula, message: 'must be abided'
end

validates_acceptance_of(フィールド名..)

class Person < ActiveRecord::Base
  validates_acceptance_of :terms_of_service
  validates_acceptance_of :eula, message: 'must be abided'
end

validates_confirmation_of(フィールド名..)

  validates_confirmation_of :user_name, :password

validates_exclusion_of(フィールド名..)

class Person < ActiveRecord::Base
  validates_exclusion_of :username, in: %w( admin superuser ), message: "You don't belong here"
  validates_exclusion_of :age, in: 30..60, message: 'This site is only for under 30 and over 60'
  validates_exclusion_of :format, in: %w( mov avi ), message: "extension %{value} is not allowed"
  validates_exclusion_of :password, in: ->(person) { [person.username, person.first_name] },
                         message: 'should not be the same as your username or first name'
  validates_exclusion_of :karma, in: :reserved_karmas
end

validates_format_of(フィールド名..)

validates_format_of :email, with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/, on: :create

validates_inclusion_of(フィールド名..)

class Person < ActiveRecord::Base
  validates_inclusion_of :gender, in: %w( m f )
  validates_inclusion_of :age, in: 0..99
  validates_inclusion_of :format, in: %w( jpg gif png ), message: "extension %{value} is not included in the list"
  validates_inclusion_of :states, in: ->(person) { STATES[person.country] }
  validates_inclusion_of :karma, in: :available_karmas
end

validates_length_of(フィールド名..)

class Person < ActiveRecord::Base
  validates_length_of :first_name, maximum: 30
  validates_length_of :last_name, maximum: 30, message: "less than 30 if you don't mind"
  validates_length_of :fax, in: 7..32, allow_nil: true
  validates_length_of :phone, in: 7..32, allow_blank: true
  validates_length_of :user_name, within: 6..20, too_long: 'pick a shorter name', too_short: 'pick a longer name'
  validates_length_of :zip_code, minimum: 5, too_short: 'please enter at least 5 characters'
  validates_length_of :smurf_leader, is: 4, message: "papa is spelled with 4 characters... don't play me."
  validates_length_of :essay, minimum: 100, too_short: 'Your essay must be at least 100 words.'
end

validates_numericality_of(フィールド名..)

validates_numericality_of :value, on: :create

validates_comparison_of(属性名..)

class Person < ActiveRecord::Base
  validates_comparison_of :value, greater_than: 'the sum of its parts'
end

validates_with(引数.., ブロック引数)

validates_with MyValidator

validates_each(キー名.., ブロック引数)

validates_each :first_name, :last_name, allow_blank: true do |record, attr, value|
  record.errors.add attr, 'starts with z.' if value.to_s[0] == ?z
end

validates!(属性..)

class Person
  include ActiveModel::Validations

  attr_accessor :name
  validates! :name, presence: true
end

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

validators()

class Person
  include ActiveModel::Validations

  validates_with MyValidator
  validates_with OtherValidator, on: :create
  validates_with StrictValidator, strict: true
end

Person.validators
#=> [
#      <MyValidator:0x007fbff403e808 @options={}>,
#      <OtherValidator:0x007fbff403d930 @options={on: :create}>,
#      <StrictValidator:0x007fbff3204a30 @options={strict:true}>
#    ]

validators_on(属性..)

class Person
  include ActiveModel::Validations

  attr_accessor :name , :age

  validates_presence_of :name
  validates_inclusion_of :age, in: 0..99
end

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

モデル.errors()

person = Person.new
person.valid? #=> false
person.errors #=> #<ActiveModel::Errors:0x007fe603816640 @messages={name:["can't be blank"]}>

モデル.valid?(コンテキスト=nil)

person = Person.new
person.name = ''
person.valid? #=> false
person.name = 'david'
person.valid? #=> true

person = Person.new
person.valid?       #=> true
person.valid?(:new) #=> false

モデル.invalid?(コンテキスト=nil)

person = Person.new
person.name = ''
person.invalid? #=> true
person.name = 'david'
person.invalid? #=> false

person = Person.new
person.invalid?       #=> false
person.invalid?(:new) #=> true