1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

class PhoneNumber
  attr_reader :value
  delegate :hash, to: :value

  def initialize(value)
    raise "Phone number is invalid" unless value.match?(/|A0\d{9,10}|z/)
    @value = value.frozen? ? value : value.dup.freeze
  end

  def ==(other)
    # PhoneNumberインスタンスが渡されることを想定
    self.class == other.class && value == other.value
  end
  alias eql? ==

  def mobile?
    value.match?(/\A0[7-9]0\d{8}\z/)
  end
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class User < ApplicationRecord
  def phone_number
    @phone_number ||= PhoneNumber.new(self[:phone_number])
  end

  def phone_number=(new_phone_number)
    self[:phone_number] = new_phone_number.value
    @phone_number = new_phone_number
  end
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

irb(main):006:0> user = User.last
   (0.1ms)  SELECT sqlite_version(*)
  User Load (0.2ms)  SELECT "users".* FROM "users" ORDER BY "users"."id" DESC LIMIT ?  [["LIMIT", 1]]
=> #<User id: 4, name: "aaa", created_at: "2020-09-15 09:26:10", updated_at: "2020-09-15 09:26:10", phone_number: "000-1111-1111">
irb(main):007:0> user.phone_number
=> #<PhoneNumber:0x00007fde1491d238 @value="000-1111-1111">
irb(main):008:0> user[:phone_number]
=> "000-1111-1111"
irb(main):009:0> user.phone_number = PhoneNumber.new('000-0000-0000')
=> #<PhoneNumber:0x00007fde14044fa8 @value="000-0000-0000">
irb(main):010:0> user.name
=> "aaa"
irb(main):011:0> user[:name]
=> "aaa"

1
2
3

class User < ApplicationRecord
  compose_of :phone_number, mapping: %w[phone_number value]
end

1
2
3
4
5

composed_of :ip_address,
            class_name: "IPAddr",
            mapping: %w[ip to_i],
            constructor: Proc.new { |ip| IPAddr.new(ip, Socket::AF_INET) },
            converter: Proc.new { |ip| ip.is_a?(Integer) ? IPAddr.new(ip, Socket::AF_INET) : IPAddr.new(ip.to_s) }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

class TransferMoneyBetweenBankAccountService
  private_class_method :new

  def call(**kwargs)
    new.call(**kwargs)
  end

  def call(from:, to:, money:)
    from.transaction do
      from.withdraw(money)
      to.deposit(money)
    end
  end
end

  # private
  # 必要に応じて切り出したロジックをprivateに置く

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class BankAccount < ApplicationRecord
  composed_of :balance, class_name: "Money", mapping: [%w[balance amount], %w[currency currency]]

  def deposit(money)
    with_lock { update!(balance: balance + money) }
  end

  def withdraw
    with_lock do
      raise "Withdrawal amount must not be greater than balance" if money > balance
    end
  end
end