プロローグ — 読めないコードとの戦い

git checkout legacy/order-processing
git log --oneline -5
# a3f8b21 fix: quick fix for payment bug
# 7c2d104 update order stuff
# 3e9f001 changes
# 9ba2c88 fix
# 4d1f220 initial commit

# app/models/order.rb (抜粋)
# Before: 実際にあったコード（悪い例）
def p(o, u, c)
  x = Order.find(o)
  if x.st == 1
    if u.pr == true
      x.tt = x.tt * 0.8
    end
    if c != nil
      cp = Coupon.find_by(cd: c)
      if cp && cp.ex > Time.now && cp.u == false
        x.tt = x.tt - cp.am
        cp.u = true
        cp.save
      end
    end
    x.st = 2
    x.save
    UserMailer.om(u.em, x.id).deliver_later
    return true
  else
    return false
  end
end

# 2時間かけて作成した「解読表」
# o  → order_id     （Orderのid）
# u  → user         （Userオブジェクト）
# c  → coupon_code  （クーポンコード文字列）
# x  → order        （Orderオブジェクト）
# st → status       （注文ステータス 1=pending, 2=completed）
# tt → total        （合計金額）
# pr → premium?     （プレミアム会員か）
# cp → coupon       （Couponオブジェクト）
# cd → code         （クーポンコード文字列）
# ex → expired_at   （有効期限）
# am → amount       （割引額）
# u  → used?        （使用済みか）  ← uがまた別の意味で使われている！

# 段階的な劣化の例
# バージョン1（最初はきれいだった）
def process_order(order, user)
  order.update!(status: :completed)
  OrderMailer.confirmation(user, order).deliver_later
end
 
# バージョン2（緊急修正で条件が増えた）
def process_order(order, user)
  order.update!(status: :completed)
  OrderMailer.confirmation(user, order).deliver_later unless order.test_order?
  InventoryService.decrease(order) if order.physical_items?  # 追加
end
 
# バージョン5（1年後、誰も全体を把握していない）
def process_order(order, user, skip_mail: false, force: false)
  return false if order.locked? && !force
  order.update!(status: :completed)
  unless skip_mail || order.test_order? || user.email_unsubscribed?
    OrderMailer.confirmation(user, order).deliver_later
  end
  InventoryService.decrease(order) if order.physical_items? && !order.preorder?
  CrmService.sync(user) if user.crm_enabled? && !Rails.env.test?
  Analytics.track('order.completed', order_id: order.id, user_id: user.id)
  true
end

# 「次の行を予測できる」コードとはこういうこと
 
# Before: 次に何が来るか予測できない
def p(o, u, c)
  x = Order.find(o)
  if x.st == 1
    if u.pr == true
      x.tt = x.tt * 0.8  # ← 0.8が何なのか予測できない
    end
    # ...
 
# After: 次の行を読む前から意図が伝わる
def process_order(order_id, user, coupon_code)
  order = Order.find(order_id)
  return false unless order.pending?  # ← pending?でなければ何もしない、とわかる
 
  apply_premium_discount(order, user)  # ← 次の処理が予測できる
  apply_coupon(order, coupon_code)     # ← そしてクーポン適用
  complete_order(order, user)          # ← 最後に注文完了
  true
end

# After: 3Rを適用したコード
class Order < ApplicationRecord
  PREMIUM_DISCOUNT_RATE = 0.20  # 定数で意図を明示
 
  scope :pending, -> { where(status: 'pending') }
 
  def pending?
    status == 'pending'
  end
 
  def apply_premium_discount_for(user)
    return unless user.premium?
    self.total = (total * (1 - PREMIUM_DISCOUNT_RATE)).round(2)
  end
end
 
class Coupon < ApplicationRecord
  def redeemable?
    !used? && expired_at > Time.current
  end
 
  def apply_to(order)
    return false unless redeemable?
    order.total -= discount_amount
    mark_as_used!
    true
  end
 
  def mark_as_used!
    update!(used: true)
  end
end
 
# 注文処理メソッド（意図が伝わる）
def process_order(order_id, user, coupon_code: nil)
  order = Order.find(order_id)
  return false unless order.pending?
 
  order.apply_premium_discount_for(user)
  apply_coupon_if_present(order, coupon_code)
  complete_order(order, user)
  true
end
 
private
 
def apply_coupon_if_present(order, coupon_code)
  return unless coupon_code.present?
 
  coupon = Coupon.find_by(code: coupon_code)
  return unless coupon&.redeemable?
 
  coupon.apply_to(order)
end
 
def complete_order(order, user)
  order.update!(status: :completed)
  OrderMailer.confirmation(user.email, order.id).deliver_later
end

# これから学ぶこと
module ThreeRs
  # R1: Readability — 読んで理解できるコードを書く
  #   - 意図が伝わる命名
  #   - 単一責任のメソッド
  #   - Railsの規約を活かす
 
  # R2: Reusability — 同じロジックを安全に使い回す
  #   - DRY原則（Don't Repeat Yourself）
  #   - Service Object
  #   - モジュール・Gem化
 
  # R3: Refactorability — 変更が怖くないコードにする
  #   - SOLID原則
  #   - テスト駆動
  #   - 依存性の注入
end

# レガシーコードのサイン（赤信号）
 
# 1. 意味不明な変数名
x = Order.find(o)           # 赤: x, o
order = Order.find(order_id) # 緑: order, order_id
 
# 2. 否定の否定
if !user.not_premium?  # 赤: 二重否定で頭が痛い
if user.premium?       # 緑: ストレートに読める
 
# 3. マジックナンバー
order.total * 0.8     # 赤: 0.8が何かわからない
order.total * (1 - PREMIUM_DISCOUNT_RATE)  # 緑: 意図が明確
 
# 4. 1メソッドに複数の「and」
def create_and_notify_and_log_order   # 赤: andが複数
def create_order                       # 緑: 1つのことだけ
 
# 5. コメントで補うコード
# ユーザーがプレミアムなら割引
if u.pr == true        # 赤: コメントが必要なほど不明瞭
if user.premium?       # 緑: コメント不要で意図が伝わる

# 技術的負債の返済: 計画的に取り組む
# Martin Fowler の「技術的負債の四象限」
 
# 無謀 & 意図的（最悪）
# 「時間がないからテストは書かない」
# → 後で絶対問題になるとわかっているのに選ぶ判断
 
# 慎重 & 意図的（戦略的）
# 「締め切りのために今は動くものを出す。来週リファクタリングする」
# → 意識的な判断。来週本当にリファクタリングすれば問題ない
 
# 無謀 & 非意図的（気づいていない）
# 「レイヤーって何？」
# → 知識不足で負債を作っている。学習で解決
 
# 慎重 & 非意図的（避けられない）
# 「今になってわかった、このアーキテクチャでは対応できない」
# → 事前に知る方法がなかった。受け入れて対処する
 
module TechnicalDebt
  # 返済の優先順位
  # 1. 変更頻度が高い × 複雑度が高い → 最優先
  # 2. バグの温床になっている → 高優先
  # 3. 読むたびに時間を取られる → 中優先
  # 4. 完璧じゃないが機能している → 低優先（触れない）
end