Active Model 기초

class EmailContact
  include ActiveModel::API

  attr_accessor :name, :email, :message
  validates :name, :email, :message, presence: true # name, email, message가 존재하는지 검증합니다

  def deliver
    if valid?
      # 이메일 전송
    end
  end
end

irb> email_contact = EmailContact.new(name: "David", email: "david@example.com", message: "Hello World")

irb> email_contact.name # 속성 할당
=> "David"

irb> email_contact.to_model == email_contact # 변환
=> true

irb> email_contact.model_name.name # 이름 지정
=> "EmailContact"

irb> EmailContact.human_attribute_name("name") # locale이 설정된 경우 번역
=> "Name"

irb> email_contact.valid? # 유효성 검사
=> true

irb> empty_contact = EmailContact.new
irb> empty_contact.valid?
=> false

<%= form_with model: EmailContact.new do |form| %>
  <%= form.text_field :name %>
<% end %>

<form action="/email_contacts" method="post">
  <input type="text" name="email_contact[name]" id="email_contact_name">  
</form>

<%= render @email_contact %>

class Person
  include ActiveModel::Model

  attr_accessor :name, :age
end

irb> person = Person.new(name: 'bob', age: '18')
irb> person.name # => "bob"
irb> person.age  # => "18"

class Person
  include ActiveModel::Attributes

  attribute :name, :string
  attribute :date_of_birth, :date
  attribute :active, :boolean, default: true
end

irb> person = Person.new

irb> person.name = "Jane"
irb> person.name
=> "Jane"

# 문자열을 attribute에 설정된 date로 형변환
irb> person.date_of_birth = "2020-01-01"
irb> person.date_of_birth
=> Wed, 01 Jan 2020
irb> person.date_of_birth.class
=> Date

# attribute에 설정된 기본값 사용
irb> person.active
=> true

# 정수를 attribute에 설정된 boolean으로 형변환
irb> person.active = 0
irb> person.active
=> false

irb> Person.attribute_names
=> ["name", "date_of_birth", "active"] # model의 속성명들을 반환합니다

irb> person.attributes
=> {"name" => "Jane", "date_of_birth" => 수, 01 1월 2020, "active" => false}

class Person
  include ActiveModel::AttributeAssignment

  attr_accessor :name, :date_of_birth, :active
end

irb> person = Person.new

# 여러 속성을 한번에 설정
irb> person.assign_attributes(name: "John", date_of_birth: "1998-01-01", active: false)

irb> person.name
=> "John"
irb> person.date_of_birth
=> Thu, 01 Jan 1998
irb> person.active
=> false

irb> person = Person.new

# strong parameters 체크를 사용해서 요청의 params와 유사한 속성 해시를 생성
irb> params = ActionController::Parameters.new(name: "John")
=> #<ActionController::Parameters {"name" => "John"} permitted: false>

irb> person.assign_attributes(params)
=> # ActiveModel::ForbiddenAttributesError 발생
irb> person.name
=> nil

# 할당을 허용할 속성들을 permit
irb> permitted_params = params.permit(:name)
=> #<ActionController::Parameters {"name" => "John"} permitted: true>

irb> person.assign_attributes(permitted_params)
irb> person.name
=> "John"

irb> person = Person.new

irb> person.attributes = { name: "John", date_of_birth: "1998-01-01", active: false }

irb> person.name
=> "John" 
irb> person.date_of_birth
=> "1998-01-01"

class Person
  include ActiveModel::AttributeMethods

  # reset_와 _to_default! 접두사/접미사 메서드 정의
  attribute_method_affix prefix: "reset_", suffix: "_to_default!"
  # first_, last_ 접두사 메서드 정의
  attribute_method_prefix "first_", "last_"
  # _short? 접미사 메서드 정의 
  attribute_method_suffix "_short?"

  # name 속성에 대한 메서드 정의
  define_attribute_methods "name"

  attr_accessor :name

  private
    # 'first_name' 속성 메서드 호출 
    def first_attribute(attribute)
      public_send(attribute).split.first
    end

    # 'last_name' 속성 메서드 호출
    def last_attribute(attribute)
      public_send(attribute).split.last
    end

    # 'name_short?' 속성 메서드 호출
    def attribute_short?(attribute)
      public_send(attribute).length < 5
    end

    # 'reset_name_to_default!' 속성 메서드 호출
    def reset_attribute_to_default!(attribute)
      public_send("#{attribute}=", "Default Name")
    end
end

irb> person = Person.new
irb> person.name = "Jane Doe"

irb> person.first_name
=> "Jane"
irb> person.last_name
=> "Doe"

irb> person.name_short? 
=> false

irb> person.reset_name_to_default!
=> "Default Name"

class Person
  include ActiveModel::AttributeMethods

  attribute_method_suffix "_short?"
  define_attribute_methods :name

  attr_accessor :name

  alias_attribute :full_name, :name

  private
    # attribute의 길이가 5보다 작은지 확인하는 메서드
    def attribute_short?(attribute)
      public_send(attribute).length < 5
    end 
end

irb> person = Person.new
irb> person.name = "Joe Doe"
irb> person.name
=> "Joe Doe"

# `full_name`은 `name`의 alias이며, 같은 값을 반환합니다
irb> person.full_name  
=> "Joe Doe"
irb> person.name_short?
=> false

# `full_name_short?`는 `name_short?`의 alias이며, 같은 값을 반환합니다
irb> person.full_name_short?
=> false

class Person
  extend ActiveModel::Callbacks

  define_model_callbacks :update

  before_update :reset_me
  after_update :finalize_me
  around_update :log_me

  # `define_model_callbacks` 메서드는 주어진 이벤트에 대한 콜백을 실행하는 `run_callbacks`를 포함합니다
  def update
    run_callbacks(:update) do
      puts "update 메서드가 호출됨"
    end
  end

  private
    # 객체에서 update가 호출되면 `before_update` 콜백에 의해 이 메서드가 호출됩니다
    def reset_me
      puts "reset_me 메서드: update 메서드 이전에 호출됨"
    end

    # 객체에서 update가 호출되면 `after_update` 콜백에 의해 이 메서드가 호출됩니다
    def finalize_me
      puts "finalize_me 메서드: update 메서드 이후에 호출됨"
    end

    # 객체에서 update가 호출되면 `around_update` 콜백에 의해 이 메서드가 호출됩니다
    def log_me
      puts "log_me 메서드: update 메서드 주변에서 호출됨"
      yield
      puts "log_me 메서드: 블록이 성공적으로 호출됨"
    end
end

irb> person = Person.new
irb> person.update
reset_me method: update method 이전에 호출됨 
log_me method: update method 주변에서 호출됨
update method 호출됨
log_me method: block이 성공적으로 호출됨
finalize_me method: update method 이후에 호출됨
=> nil

define_model_callbacks :create, only: :after   # create에 대해 after callback만 정의
define_model_callbacks :update, only: :before  # update에 대해 before callback만 정의
define_model_callbacks :destroy, only: :around # destroy에 대해 around callback만 정의

class Person
  extend ActiveModel::Callbacks

  define_model_callbacks :create
  before_create PersonCallbacks
end

class PersonCallbacks
  def self.before_create(obj)
    # `obj`는 callback이 호출되는 Person 인스턴스입니다
  end
end

class Person
  extend ActiveModel::Callbacks

  define_model_callbacks :update

  before_update :reset_me
  after_update :finalize_me  
  around_update :log_me

  def update
    run_callbacks(:update) do
      puts "update 메서드가 호출됨"
    end
  end

  private
    def reset_me
      puts "reset_me 메서드: update 메서드 이전에 호출됨"
      throw :abort
      puts "reset_me 메서드: abort 이후의 코드"
    end

    def finalize_me
      puts "finalize_me 메서드: update 메서드 이후에 호출됨"
    end

    def log_me
      puts "log_me 메서드: update 메서드 주변에서 호출됨" 
      yield
      puts "log_me 메서드: 블록이 성공적으로 호출됨"
    end
end

irb> person = Person.new

irb> person.update
reset_me 메서드: update 메서드 호출 전에 실행됨
=> false

class Person
  include ActiveModel::Conversion
  attr_accessor :id

  def initialize(id)
    @id = id
  end

  # persisted? 메서드는 object가 데이터베이스에 존재하는지를 나타냅니다
  def persisted?
    id.present? 
  end
end

irb> person = Person.new(1)
irb> person.to_model == person
=> true

class Person
  def to_model
    # 당신의 object를 Active Model 호환 메소드로 감싸는 proxy object입니다.
    PersonModel.new(self)
  end
end

irb> person.to_key
=> [1]

irb> person.to_param
=> "1"

irb> person.to_partial_path
=> "people/person"

class Person
  include ActiveModel::Dirty

  attr_reader :first_name, :last_name 
  define_attribute_methods :first_name, :last_name

  def initialize
    @first_name = nil
    @last_name = nil
  end

  def first_name=(value)
    first_name_will_change! unless value == @first_name
    @first_name = value
  end

  def last_name=(value)
    last_name_will_change! unless value == @last_name
    @last_name = value
  end

  def save
    # 데이터 유지 - dirty 데이터를 지우고 `changes`를 `previous_changes`로 이동합니다.
    changes_applied
  end

  def reload!
    # 모든 dirty 데이터를 지웁니다: 현재 변경사항과 이전 변경사항.
    clear_changes_information
  end

  def rollback!
    # 제공된 속성들의 모든 이전 데이터를 복원합니다.
    restore_attributes
  end
end

person = Person.new
person.changed? # => false

person.name = 'Bob'
person.changed? # => true
person.changed  # => ["name"]
person.changed_attributes # => {"name" => nil}

person.name = 'Bill'
person.changed? # => true
person.changed  # => ["name"]
person.changed_attributes # => {"name" => nil}

person.name = 'Bob'
person.changed? # => true
person.changed  # => ["name"]
person.changed_attributes # => {"name" => nil}

irb> person = Person.new

# 새로 인스턴스화된 `Person` 객체는 변경되지 않은 상태입니다:
irb> person.changed?
=> false

irb> person.first_name = "Jane Doe"
irb> person.first_name
=> "Jane Doe"

irb> person.changed?
=> true

irb> person.changed
=> ["first_name"] # first_name이 변경되었음을 나타냄

irb> person.changed_attributes
=> {"first_name" => nil}

irb> person.changes
=> {"first_name" => [nil, "Jane Doe"]} 
# 값이 [이전 값, 새로운 값] 형태로 표시됨

irb> person.previous_changes
=> {}

irb> person.save
irb> person.previous_changes
=> {"first_name" => [nil, "Jane Doe"]} # 이전 변경사항 [변경 전 값, 변경 후 값]

irb> person = Person.new

irb> person.changed? 
=> false

irb> person.first_name = "John Doe"
irb> person.first_name
=> "John Doe"

irb> person.first_name_changed?
=> true

irb> person.first_name_was
=> nil

irb> person.first_name_change
=> [변경 전 값은 nil, "John Doe"로 변경됨]
irb> person.last_name_change
=> nil

irb> person.first_name_previously_changed? # first_name이 이전에 변경되었는지 확인
=> false
irb> person.save
irb> person.first_name_previously_changed? # 저장 후 first_name이 이전에 변경되었는지 확인
=> true

irb> person.first_name_previous_change
=> [nil, "John Doe"]
# 이전 변경 내용인 [변경 전 값, 변경 후 값]을 반환합니다

class Person
  extend ActiveModel::Naming
end

irb> Person.model_name.name
=> "Person"

irb> Person.model_name.singular # Person model의 단수형 이름을 반환
=> "person"

irb> Person.model_name.plural # model의 복수형 이름을 가져옴
=> "people"

irb> Person.model_name.element
=> "person"

irb> Person.model_name.human
=> "Person"

irb> Person.model_name.collection
=> "people"

irb> Person.model_name.param_key 
=> "person"

irb> Person.model_name.i18n_key
=> :person
# person Symbol을 리턴합니다

irb> Person.model_name.route_key
=> "people" # 라우트에서 사용되는 복수형 모델 이름

irb> Person.model_name.singular_route_key
=> "person"

irb> Person.model_name.uncountable?
=> false

module Person
  class Profile
    include ActiveModel::Model

    # model_name은 기본적으로 module namespace를 class 이름의 일부로 포함시킵니다.
    # 이 예제에서 namespace를 제거하고 model name을 "Profile"로만 설정하려면
    # ActiveModel::Name.new의 두 번째 인자로 nil을 전달하면 됩니다.
    def self.model_name
      ActiveModel::Name.new(self, nil, "Profile")
    end
  end
end

Rails.application.routes.draw do
  resources :profiles 
end

irb> name = ActiveModel::Name.new(Person::Profile, nil, "Profile")
=> #<ActiveModel::Name:0x000000014c5dbae0

irb> name.singular
=> "profile" # 단수형
irb> name.singular_route_key
=> "profile" # 라우팅에서 사용되는 단수형 키
irb> name.route_key 
=> "profiles" # 라우팅에서 사용되는 복수형 키

gem "bcrypt"

class Person
  include ActiveModel::SecurePassword

  has_secure_password
  has_secure_password :recovery_password, validations: false

  attr_accessor :password_digest, :recovery_password_digest
end

irb> person = Person.new

# 패스워드가 비어있을 때
irb> person.valid?
=> false

# 확인용 패스워드가 패스워드와 일치하지 않을 때
irb> person.password = "aditya"
irb> person.password_confirmation = "nomatch"
irb> person.valid?
=> false

# 패스워드 길이가 72자를 초과할 때
irb> person.password = person.password_confirmation = "a" * 100
irb> person.valid?
=> false

# password_confirmation 없이 패스워드만 입력되었을 때
irb> person.password = "aditya"
irb> person.valid?
=> true

# 모든 유효성 검사를 통과했을 때
irb> person.password = person.password_confirmation = "aditya"
irb> person.valid?
=> true

irb> person.recovery_password = "42password"

# `authenticate`는 `authenticate_password`의 별칭입니다
irb> person.authenticate("aditya")
=> #<Person> # == person
irb> person.authenticate("notright")
=> false
irb> person.authenticate_password("aditya")
=> #<Person> # == person
irb> person.authenticate_password("notright")
=> false

irb> person.authenticate_recovery_password("aditya")
=> false
irb> person.authenticate_recovery_password("42password")
=> #<Person> # == person
irb> person.authenticate_recovery_password("notright")
=> false

irb> person.password_digest
=> "$2a$04$gF8RfZdoXHvyTjHhiU4ZsO.kQqV9oonYZu31PRE4hLQn3xM2qkpIy"
irb> person.recovery_password_digest
=> "$2a$04$iOfhwahFymCs5weB3BNH/uXkTG65HR.qpW.bNhEjFP3ftli3o5DQC"

class Person
  include ActiveModel::Serialization

  attr_accessor :name, :age

  def attributes
    # serialization될 attributes 선언
    { "name" => nil, "age" => nil }
  end

  def capitalized_name
    # 선언된 메서드는 나중에 serialized hash에 포함될 수 있음
    name&.capitalize
  end
end

irb> person = Person.new

irb> person.serializable_hash
=> {"name" => nil, "age" => nil}

# 이름과 나이 속성을 설정하고 객체를 직렬화
irb> person.name = "bob"  
irb> person.age = 22
irb> person.serializable_hash
=> {"name" => "bob", "age" => 22}

# methods 옵션을 사용해 capitalized_name 메서드를 포함
irb>  person.serializable_hash(methods: :capitalized_name)  
=> {"name" => "bob", "age" => 22, "capitalized_name" => "Bob"}

# only 메서드를 사용해 name 속성만 포함
irb> person.serializable_hash(only: :name)
=> {"name" => "bob"}

# except 메서드를 사용해 name 속성을 제외
irb> person.serializable_hash(except: :name)
=> {"age" => 22}

  class Person
    include ActiveModel::Serialization
    attr_accessor :name, :notes # has_many :notes를 모방

    def attributes
      { "name" => nil }
    end
  end

  class Note
    include ActiveModel::Serialization
    attr_accessor :title, :text

    def attributes
      { "title" => nil, "text" => nil }
    end
  end

irb> note = Note.new
irb> note.title = "Weekend Plans"
irb> note.text = "Some text here"

irb> person = Person.new
irb> person.name = "Napoleon"
irb> person.notes = [note]

irb> person.serializable_hash
=> {"name" => "Napoleon"}

irb> person.serializable_hash(include: { notes: { only: "title" }})
=> {"name" => "Napoleon", "notes" => [{"title" => "Weekend Plans"}]}

class Person
  include ActiveModel::Serializers::JSON

  attr_accessor :name

  def attributes
    { "name" => nil }
  end
end

irb> person = Person.new

# 모델을 문자열 키를 가진 해시로 표현
irb> person.as_json
=> {"name" => nil}

# 모델을 JSON 문자열로 표현 
irb> person.to_json
=> "{\"name\":null}"

irb> person.name = "Bob"
irb> person.as_json
=> {"name" => "Bob"}

irb> person.to_json
=> "{\"name\":\"Bob\"}"

class Person
  include ActiveModel::Serializers::JSON

  attr_accessor :name

  def attributes=(hash)
    hash.each do |key, value|
      public_send("#{key}=", value)
    end
  end

  def attributes 
    { "name" => nil }
  end
end

irb> json = { name: "Bob" }.to_json
=> "{\"name\":\"Bob\"}"

irb> person = Person.new

irb> person.from_json(json)
=> #<Person:0x00000100c773f0 @name="Bob">

irb> person.name
=> "Bob"

class Person
  extend ActiveModel::Translation
end

# config/locales/app.pt-BR.yml
pt-BR:
  activemodel:
    attributes:
      person:
        name: "이름"

irb> Person.human_attribute_name("name")
=> "Name"

irb> I18n.locale = :"pt-BR"
=> :"pt-BR" 
irb> Person.human_attribute_name("name")  
=> "이름"

class Person
  include ActiveModel::Validations

  attr_accessor :name, :email, :token

  # name 속성이 비어있지 않은지 검증합니다
  validates :name, presence: true
  # email 속성이 올바른 이메일 형식인지 검증합니다  
  validates :email, format: { with: URI::MailTo::EMAIL_REGEXP }
  # token 속성이 비어있지 않은지 엄격하게 검증합니다
  validates! :token, presence: true
end

irb> person = Person.new
irb> person.token = "2b1f325"
irb> person.valid?
=> false

irb> person.name = "Jane Doe"
irb> person.email = "me" 
irb> person.valid?
=> false

irb> person.email = "jane.doe@gmail.com"
irb> person.valid?
=> true

# `token`은 validate!를 사용하며 설정되지 않았을 때 예외를 발생시킵니다.
irb> person.token = nil
irb> person.valid?
=> "Token can't be blank (ActiveModel::StrictValidationFailed)"

irb> person = Person.new

irb> person.email = "me" 
irb> person.valid?
=> # Token이 비어있을 수 없다는 오류 발생 (ActiveModel::StrictValidationFailed)

irb> person.errors.to_hash
=> {:name => ["비어있을 수 없습니다"], :email => ["유효하지 않습니다"]}

irb> person.errors.full_messages
=> ["Name은 비어있을 수 없습니다", "Email이 유효하지 않습니다"]

$ bin/rails test

실행 옵션: --seed 14596

# 실행 중:

......

0.024899초 만에 완료, 240.9735회/초 실행, 1204.8677회/초 검증.

6회 실행, 30회 검증, 0회 실패, 0회 에러, 0회 건너뜀