Railsで保守性の高いコードを書くには?実務で差がつくベストプラクティス設計手法5選

Railsで保守性の高いコードを書くための実務で差がつく設計手法5選を解説するアイキャッチ画像 バックエンド

Railsは「設定より規約」という設計思想のもと、少ない記述で多くの機能を実現できる優れたフレームワークです。
しかし、その柔軟さゆえに、開発チームの規模が大きくなるほどコードの保守性が課題になりやすいのも事実です。
特に実務では、動くコードを書くことよりも、半年後・一年後も安全に変更できるコードを書くことが求められます。

では、保守性の高いRailsコードとは具体的にどのようなものでしょうか。
ここで重要なのは、単に「短いコード」や「DRYなコード」を目指すことではありません。
変更の影響範囲を局所化し、意図が明確で、テストが容易であることが本質です。
本記事では、コンピューターサイエンスの観点から見ても妥当性が高く、実務で差がつきやすい設計手法を5つ厳選して紹介します。

  • Fat Modelを避け、責務を適切に分離する
  • Service ObjectやForm Objectを目的別に使い分ける
  • Query Objectで複雑な検索条件をカプセル化する
  • Policy Objectで認可ロジックを一箇所に集約する
  • プレゼンターやDecoratorでビューのロジックを整理する

これらはどれも、Rails Wayを否定するものではありません。
むしろ、Railsの規約を活かしながら、アプリケーション固有の複雑さを適切に隔離するための実践的なアプローチです。
たとえば、コントローラに業務ロジックを書きがちな処理も、Service Objectに切り出せばテストが書きやすくなります。

# 悪い例: コントローラにロジックが集中
def create
  @user = User.new(user_params)
  if @user.save
    Mailer.welcome(@user).deliver_later
    redirect_to @user
  else
    render :new
  end
end

上記のようなコードは一見問題ありませんが、登録後の処理が増えるたびにコントローラが肥大化します。
そこで、次のように責務を分離します。

# 良い例: Service Objectに切り出す
class UserRegistration
  def initialize(params)
    @params = params
  end

  def call
    user = User.new(@params)
    return user unless user.save
    Mailer.welcome(user).deliver_later
    user
  end
end

このように、変更理由が異なるコードを同じ場所に置かないことが、保守性の第一歩です。
次のセクションでは、各手法の具体的な適用条件と注意点を、コード例を交えながら詳しく解説します。
読者の皆さんが、自身のプロジェクトに合った設計判断を下せるようになることを目的としています。

Railsの保守性が問われる理由と設計原則の基礎

Railsアプリケーションの保守性が重要となる背景と設計原則の基礎を解説するイメージ

Railsは「設定より規約(Convention over Configuration)」という設計哲学を採用しており、開発者は本質的な業務ロジックに集中できるようになっています。
しかし、この恩恵を享受するほど、アプリケーションが成長するにつれて保守性という別の課題が顔を出します。
ここでは、なぜRailsのコードが肥大化しやすいのか、そして保守性の高いコードとは何かを論理的に整理していきます。

なぜRailsのコードは肥大化しやすいのか

Railsのコードが肥大化しやすい理由は、フレームワークの親切さそのものにあります。
ジェネレータが生成するコントローラ、モデル、ビューという構造は学習コストを下げる一方で、開発者に「どこに何を書くか」という判断を暗黙のうちに委ねます。
結果として、業務ロジックがコントローラやモデルに流れ込み、Fat ControllerやFat Modelと呼ばれる状態に陥りやすくなります。

特にActive Recordは強力なORMであり、バリデーション、関連、コールバック、スコープなど多様な機能を一つのクラスに集約できます。
この便利さは、単一責任の原則(SRP)と衝突しやすいのです。
たとえば、ユーザー登録という一つの機能を考えても、バリデーション、永続化、メール送信、外部API連携といった複数の責務が自然とモデルに集中していきます。

  • 規約が「書く場所」を明確にしないため、開発者ごとに判断がばらつく
  • ジェネレータが生成する構造が、機能追加のたびに肥大化を加速させる
  • Active Recordの多機能さが、単一責任の原則との衝突を生む
  • テストが書きにくいコードは、変更のたびに心理的なコストを増大させる

また、Railsは動的型付け言語であるRubyを採用しているため、コンパイル時の静的チェックが存在しません。
変更の影響範囲をコンパイラが教えてくれない以上、設計段階で責務を明確に分離しておくことが、保守性を担保する唯一の防衛線となります。

保守性の高いコードを定義する3つの指標

では、保守性の高いコードとは具体的にどのような状態を指すのでしょうか。
ここでは、コンピューターサイエンスの観点から、次の3つの指標で定義します。

指標 内容 実務での意味
変更影響の局所化 一つの変更が一箇所で完結する デグレを防ぎ、レビュー範囲を限定できる
意図の明確さ コードを読めば何をするか即座に理解できる 属人化を防ぎ、オンボーディングを短縮できる
テスト容易性 依存を差し替えて単体で検証できる リファクタリングの安全性を高める

これら3つの指標は互いに独立しているようで、実際には強く連関しています。
変更影響が局所化されていればテストは書きやすくなり、テストが書きやすければ意図が明確であることが多いのです。
逆に、テストが書きにくいコードは設計が悪いサインであると捉えてよいでしょう。

保守性を高める第一歩は、コードを書く前に「この処理の変更理由は何か」を問うことです。
変更理由が異なるコードを同じ場所に置かないという原則を徹底するだけで、Fat ModelやFat Controllerの多くは自然と解消されます。
次のセクションでは、具体的な設計手法としてService ObjectやQuery Objectなどを取り上げ、各手法の適用条件と注意点を詳しく見ていきます。

Fat ModelとFat Controllerを避ける責務分離の設計手法

Fat ModelとFat Controllerを回避し責務を分離するRails設計手法のイメージ

Railsアプリケーションの保守性を損なう最大の要因は、特定のクラスに責務が集中するFat ModelやFat Controllerと呼ばれる状態です。
これらは開発初期には問題なく動作しますが、機能追加のたびに変更の影響範囲が広がり、テストが壊れやすくなり、結果として開発速度が急激に低下します。
ここでは、責務分離の具体的な設計手法として、Active RecordのリスクとConcernによる共通処理の切り出しを論理的に整理します。

Active Recordに業務ロジックを書きすぎるリスク

Active RecordはRailsの中核をなすORMであり、データベースのテーブルとクラスを対応させ、バリデーション、関連、コールバック、スコープといった豊富な機能を提供します。
しかし、これらの機能を一つのモデルに詰め込むと、モデルは永続化の責務と業務ロジックの責務を同時に負うことになります。
これは単一責任の原則に明確に反します。

具体的にどのようなリスクがあるでしょうか。
第一に、テストの実行コストが増大します。
業務ロジックを検証するためにデータベース接続が必須となり、単体テストが遅くなります。
第二に、コールバックの連鎖が予測困難な副作用を生みます。
保存時に発火するコールバックが複数あると、どの順序で何が実行されるかを追うのが難しくなります。
第三に、変更の影響範囲が読めなくなります。
あるメソッドを修正したとき、それがどの機能に影響するかを静的に判断できません。

  • 永続化と業務ロジックが混在し、単一責任の原則に反する
  • データベース依存により単体テストが遅く、書きにくくなる
  • コールバックの連鎖が予測困難な副作用を生む
  • 変更の影響範囲が静的に判断できず、デグレの温床になる

では、どのように判断すればよいでしょうか。
目安として、そのメソッドが「データベースの状態を直接扱うか」を問うてみてください。
状態を直接扱わないのであれば、それはモデルの責務ではなく、別のオブジェクトに切り出す候補です。
たとえば、外部API連携、メール送信、複数モデルにまたがる業務処理は、モデルから追い出すべき典型例です。

Concernとモジュールで共通処理を安全に切り出す方法

複数のモデルで同じ処理を共有したい場合、RailsではConcernという仕組みが用意されています。
ConcernはActiveSupport::Concernを拡張したモジュールであり、includedブロックやclass_methodsブロックを通じて、クラスメソッドとインスタンスメソッドを整理して取り込めます。
しかし、Concernは使い方を誤ると、かえって依存関係を複雑にする諸刃の剣でもあります。

まず、Concernを適用すべきでないケースを明確にしましょう。
それは「たまたま同じコードがある」という理由だけで共通化する場合です。
共通化の判断基準は、コードの見た目ではなく、変更理由が同じかどうかです。
変更理由が異なるコードを一つのConcernにまとめると、片方の変更がもう片方に影響を与える結合が生まれます。

安全にConcernを活用するための原則は次のとおりです。

原則 内容 判断のポイント
変更理由の一致 同じ理由で変更されるものだけをまとめる 仕様変更時に両者が同時に変わるか
命名の具体性 役割が一目で分かる名前を付ける SearchableやTaggableなど
依存の明示 前提となるカラムや関連を明記する includedブロックで検証する
過剰な抽象化の回避 二重抽象化を避ける 一箇所でしか使わないなら不要

具体的な実装例を見てみましょう。
たとえば、複数のモデルで論理削除を実装する場合、次のようにConcernを定義します。

module Discardable
  extend ActiveSupport::Concern

  included do
    scope :active, -> { where(discarded_at: nil) }
  end

  def discard
    update(discarded_at: Time.current)
  end
end

このように、includedブロックでスコープを定義し、インスタンスメソッドで操作を提供することで、各モデルはinclude Discardableと書くだけで論理削除の機能を得られます。
重要なのは、このConcernが「論理削除」という単一の変更理由に基づいており、命名も具体的である点です。

一方、コントローラの共通処理をConcernに切り出す場合も同様の原則が適用されます。
ただし、コントローラのConcernは認証やエラーハンドリングなど横断的関心事に限定し、業務ロジックはService Objectなど別の層に委ねるのが定石です。
責務分離とは、単にコードを別ファイルに移すことではなく、変更理由の異なるものを異なる場所に配置する営みであると理解してください。

Service ObjectとForm Objectを使い分ける実践パターン

Service ObjectとForm Objectの役割の違いと使い分けを示すイメージ

責務分離の代表的な手法として、Service ObjectとForm Objectが挙げられます。
どちらもモデルやコントローラから業務ロジックを追い出す目的で使われますが、その役割は明確に異なります。
この違いを理解せずに場当たり的に導入すると、かえってコードの見通しが悪化します。
ここでは、両者の適用条件とアンチパターンを論理的に整理します。

Service Objectが適する処理とアンチパターン

Service Objectは、複数のモデルや外部システムにまたがる業務処理を一つの単位としてカプセル化するオブジェクトです。
英語圏ではOperationやInteractorと呼ばれることもあります。
適する処理の典型は、単一のモデルでは完結しない副作用を伴う操作です。

  • 複数モデルにまたがる登録や更新の調整
  • 外部APIや決済サービスとの連携
  • メール送信やバッチ処理の起動
  • トランザクション境界を明示したい処理

逆に、Service Objectが適さない処理もあります。
単一モデルのCRUD操作、単純なバリデーション、ビューの表示ロジックなどは、Service Objectに切り出しても抽象度が上がるだけで得るものがありません。
次のようなコードは、過剰な抽象化の典型例です。

class UserUpdater
  def initialize(user, params)
    @user = user
    @params = params
  end

  def call
    @user.update(@params)
  end
end

この例では、@user.update(@params)という一行の処理をわざわざクラスに包んでいます。
変更理由が増えていない以上、これは単なる間接層であり、保守性を下げます。
Service Objectを導入する判断基準は、単一のモデルでは表現できない業務上の一貫性があるかです。

また、Service Objectのアンチパターンとして、責務の詰め込みすぎが挙げられます。
一つのServiceが登録、更新、削除、通知をすべて担うと、結局はFat Modelの再現になります。
一つのServiceは一つの業務トランザクションに対応させ、命名もUserRegistrationやOrderCancellationのように動詞を含む具体的なものにするのが原則です。

戻り値の設計も重要です。
真偽値だけを返すと、呼び出し側でエラー理由を扱えません。
成功時と失敗時を明示する結果オブジェクトを返すか、例外を送出するかを一貫させましょう。
次のように、結果を構造化して返す設計が実務では扱いやすくなります。

class UserRegistration
  Result = Struct.new(:success?, :user, :errors, keyword_init: true)

  def call
    user = User.new(@params)
    return Result.new(success?: false, errors: user.errors) unless user.save
    Mailer.welcome(user).deliver_later
    Result.new(success?: true, user: user)
  end
end

この設計により、呼び出し側は成功と失敗を型のように扱え、テストも容易になります。

Form Objectでバリデーションと永続化を分離する

Form Objectは、画面から送信された複数のモデルにまたがる入力を一つのフォームとして扱い、バリデーションと永続化を分離するオブジェクトです。
特に、一つのフォームが複数のモデルを更新する場合や、データベースのカラムに対応しない入力項目がある場合に有効です。

たとえば、ユーザー登録時にユーザー情報とプロフィール情報を同時に受け取るケースを考えます。
Active Recordのaccepts_nested_attributes_forを使う方法もありますが、バリデーションの責務がモデルに漏れ出し、フォーム固有の制約を表現しにくくなります。
Form Objectを使えば、フォームの入力仕様を一箇所に閉じ込められます。

観点 Active Record直接 Form Object
複数モデルの入力 ネスト属性で複雑化 一箇所で調整可能
カラム外の項目 仮想属性が散らばる フォームに集約できる
バリデーション モデルに責務が漏れる フォーム固有の制約を表現できる
テスト 永続化が前提となる 単体で検証しやすい

Form Objectの実装では、ActiveModel::ModelとActiveModel::Attributesをincludeし、persisted?やsaveといったActive Recordに似たインターフェースを提供します。
これにより、コントローラ側はモデルを扱うのと同じ感覚でフォームを扱えます。
次の例を見てください。

class UserRegistrationForm
  include ActiveModel::Model
  include ActiveModel::Attributes

  attribute :name, :string
  attribute :email, :string
  attribute :profile_bio, :string

  validates :name, :email, presence: true
  validates :email, format: { with: URI::MailTo::EMAIL_REGEXP }

  def save
    return false if invalid?
    ActiveRecord::Base.transaction do
      user = User.create!(name: name, email: email)
      user.create_profile!(bio: profile_bio)
    end
    true
  end
end

この設計の利点は、フォームの入力仕様とモデルの永続化仕様が分離されている点です。
フォームのバリデーションルールを変更しても、モデルには影響しません。
また、saveメソッドの中でトランザクションを明示しているため、複数モデルの整合性も保証されます。

Service ObjectとForm Objectの使い分けをまとめると、Form Objectは入力の検証と変換に責務を限定し、Service Objectは業務トランザクションの調整に責務を限定します。
両者を混同すると、Form Objectに業務ロジックが流れ込み、再び肥大化の道を辿ります。
境界を意識した設計が、長期的な保守性を支えるのです。

Query Objectで複雑な検索条件をカプセル化する設計

Query Objectで複雑な検索条件をカプセル化するRails設計のイメージ

Railsアプリケーションが成長すると、検索条件は必然的に複雑化します。
キーワード検索、複数の絞り込み、並び替え、ページネーション、権限に応じた可視範囲の制御など、条件が増えるほどモデルやコントローラに検索ロジックが散在します。
これを解決するのがQuery Objectです。
ここでは、Active Recordの標準機能であるスコープとクラスメソッドの限界を確認し、Query Objectを導入すべき判断基準を論理的に整理します。

スコープとクラスメソッドの限界

Active Recordのスコープは、頻繁に使う検索条件を名前付きで定義できる便利な機能です。
しかし、スコープはあくまでモデルクラスの文脈で評価されるため、条件が複雑になると次のような問題が生じます。

  • 条件分岐がスコープ内に増え、メソッドチェーンの順序に依存する
  • 複数のスコープを組み合わせた結果、どのSQLが発行されるか把握しにくくなる
  • 引数の数が増え、呼び出し側の可読性が低下する
  • モデルが検索の関心事で肥大化し、単一責任の原則に反する

たとえば、次のようなスコープを考えてみましょう。

class Article < ApplicationRecord
  scope :search, ->(keyword, category_id, published_only) {
    where("title LIKE ?", "%#{keyword}%")
      .then { |q| category_id.present? ? q.where(category_id: category_id) : q }
      .then { |q| published_only ? q.where(published: true) : q }
  }
end

このスコープは動作しますが、引数の意味が呼び出し側から読み取りにくく、条件が増えるたびにthenの連鎖が長くなります。
また、検索条件の組み合わせに関する仕様がモデルに閉じ込められ、テストもしにくくなります。
クラスメソッドでも同様の問題が発生します。
クラスメソッドはスコープよりも柔軟ですが、その分だけ責務が曖昧になりやすいのです。

Query Objectを導入すべき判断基準

Query Objectは、検索条件の組み立てを専用のクラスにカプセル化する設計手法です。
モデルはデータの永続化に専念し、検索の関心事はQuery Objectが担います。
導入すべきかどうかは、次の基準で判断できます。

判断基準 導入が有効なケース 導入が不要なケース
条件の数 3つ以上の絞り込みを組み合わせる 単一のカラムで絞り込むだけ
条件の分岐 権限や状態により可視範囲が変わる 常に同じ条件で検索する
再利用性 複数の画面やAPIで同じ検索を使う 一箇所でしか使わない
テストの必要性 条件の組み合わせを網羅的に検証したい 単純なスコープで十分

これらの基準に複数当てはまる場合、Query Objectの導入は保守性を大きく向上させます。
逆に、単純な検索を無理にQuery Object化すると、間接層が増えるだけで可読性を損ないます。

Query Objectの実装では、ActiveModelやRelationをラップし、callメソッドで結果を返す設計が一般的です。
次の例を見てください。

class ArticleSearchQuery
  def initialize(relation: Article.all, params: {})
    @relation = relation
    @params = params
  end

  def call
    @relation
      .then { |q| filter_by_keyword(q) }
      .then { |q| filter_by_category(q) }
      .then { |q| filter_by_published(q) }
      .order(created_at: :desc)
  end

  private

  def filter_by_keyword(q)
    return q if @params[:keyword].blank?
    q.where("title LIKE ?", "%#{@params[:keyword]}%")
  end

  def filter_by_category(q)
    return q if @params[:category_id].blank?
    q.where(category_id: @params[:category_id])
  end

  def filter_by_published(q)
    return q unless @params[:published_only]
    q.where(published: true)
  end
end

この設計の利点は、各フィルタが独立したメソッドとして分離されているため、条件の追加や変更が局所化される点です。
また、relationを注入可能にしているため、テストではArticle.allではなく任意のリレーションを渡して検証できます。
呼び出し側はArticleSearchQuery.new(params: params).callと書くだけで、検索条件の詳細を知る必要がありません。

さらに、Query Objectはページネーションや並び替えのロジックを内包できるため、コントローラから検索の関心事を完全に排除できます。
コントローラはリクエストの受け取りとレスポンスの整形に専念し、検索の仕様はQuery Objectに集約されるのです。
この分離により、検索仕様の変更が一箇所で完結し、変更影響の局所化という保守性の指標を満たします。

Policy Objectで認可ロジックを一箇所に集約する

Policy Objectで認可ロジックを一箇所に集約するRails設計のイメージ

認可とは「誰が何をしてよいか」を判定する処理であり、認証とは明確に区別されます。
認証がユーザーの同一性を確認するのに対し、認可はそのユーザーが特定の操作を許可されているかを判断します。
Railsアプリケーションでは、この認可ロジックがコントローラやモデルに散在しがちです。
本セクションでは、散在する認可の問題点を整理し、Policy Objectによる集約の実例を示します。

コントローラやモデルに散らばる認可の問題点

認可ロジックが散在すると、どのような問題が生じるでしょうか。
典型的なのは、コントローラの各アクションに条件分岐が書かれるケースです。
たとえば、記事の編集権限を判定するコードがedit、update、destroyの各アクションに重複して書かれているとします。
この状態では、権限ルールの変更が複数箇所に波及し、変更影響の局所化という保守性の指標を満たしません。

  • 同じ権限判定が複数アクションに重複し、修正漏れの温床になる
  • 権限ルールが仕様として文書化されず、コードを読まないと分からない
  • ビューでの表示制御とコントローラでの制御が別々に実装され、不整合が生じる
  • テストがリクエストスペックに偏り、権限ルール単体の検証が困難になる

また、認可ロジックをモデルに置く場合も問題があります。
モデルは永続化と業務ロジックを担うため、認可の関心事まで抱えると単一責任の原則に反します。
さらに、認可は「現在のユーザー」という文脈に依存するため、モデル単体では扱いにくいのです。
認可は本質的にリクエストの文脈に依存する横断的関心事であり、専用のオブジェクトに分離するのが論理的に妥当です。

Punditを活用した認可設計の実例

RailsでPolicy Objectを実装する際、Punditは事実上の標準ライブラリです。
Punditは各モデルに対応するPolicyクラスを生成し、index?、show?、create?、update?、destroy?といった述語メソッドで認可を表現します。
コントローラではauthorizeメソッドを呼び出すだけで、認可ロジックをPolicyに委譲できます。

まず、Punditの基本的な使い方を見てみましょう。
コントローラにPundit::Authorizationをincludeし、各アクションでauthorizeを呼び出します。

class ArticlesController < ApplicationController
  include Pundit::Authorization

  def update
    @article = Article.find(params[:id])
    authorize @article
    if @article.update(article_params)
      redirect_to @article
    else
      render :edit
    end
  end
end

次に、Policyクラスを定義します。
ApplicationPolicyを基底クラスとして、共通の初期化とデフォルトの拒否を実装します。

class ArticlePolicy < ApplicationPolicy
  def update?
    user.admin? || record.author == user
  end

  def destroy?
    user.admin? || record.author == user
  end

  class Scope < ApplicationPolicy::Scope
    def resolve
      return scope.all if user.admin?
      scope.where(author: user)
    end
  end
end

この設計の利点は、認可ルールがArticlePolicyという一箇所に集約される点です。
update?とdestroy?が同じ条件を共有しているため、ルール変更時はこのファイルだけを修正すればよくなります。
また、Scopeクラスを定義することで、一覧表示における可視範囲の制御も同じPolicyに集約できます。

Punditを活用する際の注意点を整理します。

観点 推奨される設計 避けるべき設計
メソッド名 アクションに対応した述語メソッド 独自の曖昧な命名
条件の共通化 privateメソッドで抽出 各メソッドに重複記述
例外処理 コントローラで一括rescue 各アクションで個別対応
ビュー連携 policyヘルパーで判定 コントローラの変数を直接参照

ビューでの表示制御もPolicyに統一できます。
policy(@article).update?と書けば、コントローラと同じ判定をビューで再利用できます。
これにより、ビューとコントローラの認可判定が乖離するリスクを排除できるのです。

まとめると、Policy Objectは認可という横断的関心事を一箇所に集約し、変更影響の局所化と意図の明確さを同時に実現します。
認可ルールは仕様そのものであり、コード上で明示的に表現されるべきです。
Punditのような実績あるライブラリを活用し、認可の責務をPolicyに閉じ込めることが、保守性の高いRailsアプリケーションへの近道となります。

PresenterとDecoratorでビューのロジックを整理する

PresenterとDecoratorでビューのロジックを整理するRails設計のイメージ

ビューはアプリケーションの中でも特にロジックが混入しやすい層です。
条件分岐による表示の切り替え、日付や通貨のフォーマット、複数モデルを組み合わせた表示など、気づけばERBテンプレートが複雑な条件式で埋め尽くされているという経験はないでしょうか。
ここでは、ビューのロジックを整理する手法として、Helperの限界を確認し、PresenterとDecoratorの使い分けを論理的に整理します。

Helperにロジックを書きすぎないための指針

RailsのHelperは、ビューで使う補助メソッドを定義する仕組みです。
しかし、Helperはグローバルな名前空間に定義されるため、次のような問題を抱えやすいという本質的な制約があります。

  • すべてのビューから参照できるため、依存関係が不透明になる
  • メソッド名が衝突しやすく、命名に悩む
  • 状態を持てないため、複雑な表示ロジックの表現に限界がある
  • テストがビューの文脈に依存し、単体で検証しにくい

Helperに向く処理は、文字列の整形やHTMLタグの生成など、状態に依存しない純粋な関数です。
逆に、モデルの状態に応じて複数の要素を組み合わせて表示する処理は、Helperに書くと肥大化します。
判断基準はシンプルです。
引数のみに依存する純粋な処理はHelper、オブジェクトの状態に依存する表示はPresenterかDecoratorに委ねます。

たとえば、ユーザーの氏名を「姓 名」の順で表示する処理はHelperに適します。
一方、ユーザーの権限、プロフィールの有無、最終ログイン日時に応じて表示内容を変える処理は、Helperに書くと条件分岐が増え、テストも困難になります。

DraperとView Objectの使い分け

ビューのロジックを整理する代表的な手法に、DraperによるDecoratorと、独自のPresenterまたはView Objectがあります。
両者は似ていますが、責務と適用場面が異なります。

Draperは、モデルをラップしてビュー向けのメソッドを追加するDecoratorを提供します。
decorateヘルパーを通じてモデルを装飾し、元のモデルのインターフェースを保ちながら表示用のメソッドを追加できます。
一方、View Objectは特定の画面やコンポーネントに必要なデータを集約するオブジェクトであり、複数のモデルや集計値をまとめて扱うのに適します。

観点 Draper View Object
対象 単一モデルの装飾 画面やコンポーネント単位
複数モデルの扱い 苦手 得意
モデルのインターフェース 保持する 保持しない
適用場面 一覧や詳細の表示整形 ダッシュボードや複合ビュー

Draperの具体的な使い方を見てみましょう。
ApplicationDecoratorを基底クラスとし、モデル固有の表示メソッドを定義します。

class UserDecorator < Draper::Decorator
  delegate_all

  def display_name
    "#{last_name} #{first_name}"
  end

  def status_label
    return h.tag.span("退会済み", class: "label-gray") if discarded?
    h.tag.span("有効", class: "label-green")
  end
end

このDecoratorは、Userモデルをラップしつつ、display_nameやstatus_labelといった表示専用のメソッドを提供します。
ビューでは@user.decorate.display_nameと書くだけで、条件分岐をテンプレートから排除できます。
delegate_allにより、元のモデルのメソッドも透過的に呼び出せるため、既存のコードへの影響も最小限です。

一方、View Objectは次のように、画面に必要なデータを一箇所に集約します。

class DashboardView
  def initialize(user)
    @user = user
  end

  def recent_articles
    @user.articles.order(created_at: :desc).limit(5)
  end

  def unread_count
    @user.notifications.unread.count
  end

  def greeting
    hour = Time.current.hour
    hour < 12 ? "おはようございます" : "こんにちは"
  end
end

このView Objectは、ダッシュボード画面に必要な複数のデータを一つのオブジェクトにまとめています。
コントローラは@dashboard = DashboardView.new(current_user)とするだけで、ビューは@dashboard.recent_articlesのように参照できます。
複数のモデルにまたがる集計や条件分岐が、Selv Object内に閉じ込められるのです。

使い分けの原則をまとめます。
単一モデルの表示整形であればDraper、複数モデルや集計を伴う画面全体の表示であればView Objectを選びます。
どちらの場合も、ビューからロジックを追い出し、表示の仕様を一箇所に集約するという目的は共通しています。
ビューは本来、データをどう見せるかに専念すべきであり、その前提を支えるのがPresenterとDecoratorなのです。

テスト容易性を高めるRSpecと設計の相互関係

RSpecによるテスト容易性とRails設計の相互関係を解説するイメージ

テスト容易性は、保守性の高いコードを定義する3つの指標の一つです。
しかし、テストは設計の結果ではなく、設計そのものと相互に影響し合う関係にあります。
テストが書きにくいと感じたとき、それは設計上の問題を早期に検出するシグナルです。
本セクションでは、テスト容易性と設計の関係を整理し、依存性注入とモックを活用した責務検証の実践を解説します。

テストが書きにくいコードは設計が悪いサイン

テストを書こうとして困難を感じる場面は、大きく次の3つに分類できます。

  • セットアップが複雑で、多数の関連レコードを事前に作成する必要がある
  • 一つのメソッドを検証するために、外部APIやメール送信などの副作用を制御しなければならない
  • プライベートメソッドや内部状態に依存し、公開インターフェースだけでは検証できない

これらの困難は、いずれも責務の集中や依存の硬直化という設計上の問題に起因します。
たとえば、モデルのコールバックでメール送信が実行される設計では、テストのたびにメール送信をスタブする必要があります。
これは、永続化と通知という変更理由の異なる責務が一箇所に混在している証拠です。

テスト容易性を高める第一歩は、テストの書きにくさを設計のシグナルとして受け止めることです。
テストが書きにくいからテストを書かないのではなく、テストが書きにくいから設計を見直すという順序で考える必要があります。
テストは設計を映す鏡であり、鏡に映る姿を改善することが保守性の向上につながります。

依存性注入とモックで責務を検証する

依存性注入(Dependency Injection)は、オブジェクトが自ら依存を生成するのではなく、外部から受け取る設計手法です。
これにより、テスト時には本物の依存を偽物に差し替えられます。
Railsではコンストラクタ引数を通じた注入が最も基本的な形です。

次の例を見てください。
通知処理を担うService Objectが、メール送信の依存を外部から受け取る設計になっています。

class OrderNotifier
  def initialize(order, mailer: OrderMailer)
    @order = order
    @mailer = mailer
  end

  def call
    @mailer.confirmation(@order).deliver_later
  end
end

この設計では、テスト時にmailerにダブルを注入できます。
RSpecではinstance_doubleを使い、実際のインターフェースに準拠したモックを作成するのが定石です。

RSpec.describe OrderNotifier do
  let(:order) { build(:order) }
  let(:mailer) { instance_double(OrderMailer) }
  let(:mail_double) { instance_double(ActionMailer::MessageDelivery) }

  it "確認メールを非同期で送信する" do
    allow(mailer).to receive(:confirmation).with(order).and_return(mail_double)
    expect(mail_double).to receive(:deliver_later)

    OrderNotifier.new(order, mailer: mailer).call
  end
end

このテストは、データベースに接続することなく、OrderNotifierの責務である「確認メールを非同期で送信する」ことだけを検証しています。
instance_doubleを使うことで、存在しないメソッドをモックしてしまうリスクを防げます。
これは、モックと実際のインターフェースの乖離を防ぐ重要な指針です。

依存性注入とモックを適切に組み合わせるための原則を整理します。

原則 内容 効果
依存は引数で受け取る 内部で生成しない テスト時に差し替え可能
インターフェースに準拠 instance_doubleを使用 乖離による偽陽性を防止
責務を一つに絞る 検証対象を限定する テストの意図が明確になる
副作用を注入する メール、API、時刻を注入 予測可能なテストを実現

特に時刻の扱いは見落とされがちです。
Time.currentを直接呼び出すコードは、テストの実行タイミングによって結果が変わります。
Time.currentを注入可能にするか、travel_toヘルパーで時刻を固定するのが望ましい設計です。

まとめると、テスト容易性は設計の質を測る有効な指標です。
テストが書きにくいと感じたら、責務の集中や依存の硬直化を疑い、依存性注入とモックによって責務を分離します。
テストと設計は相互に改善し合う関係にあり、この循環を意識することが、保守性の高いRailsアプリケーションを育てる鍵となるのです。

実務で差がつくRails設計手法5選のまとめ

Railsで保守性の高いコードを書くための実務設計手法5選を総括するイメージ

ここまで、Railsで保守性の高いコードを書くための設計手法を5つ取り上げてきました。
個々の手法は独立しているように見えますが、その根底には共通する設計原則があります。
それは変更理由が異なるものを異なる場所に配置するという単一責任の原則です。
本セクションでは、5つの手法を振り返り、実務で使いこなすための判断軸と導入の順序を整理します。

まず、取り上げた5つの手法を一覧で確認しましょう。

手法 主な責務 導入の効果
Service Object 業務トランザクションの調整 複数モデルにまたがる処理の局所化
Form Object 入力の検証と変換 フォーム固有の仕様の集約
Query Object 検索条件の組み立て 複雑な検索仕様のカプセル化
Policy Object 認可の判定 横断的関心事の一箇所への集約
Presenter / Decorator 表示用の整形 ビューからロジックを排除

これらに共通するのは、モデルやコントローラから特定の関心事を追い出し、専用のオブジェクトに閉じ込めるという発想です。
Railsの規約に従いつつも、アプリケーション固有の複雑さはフレームワークの枠外に適切に隔離する。
この姿勢が、長期的な保守性を支えます。

では、実務ではどの手法から導入すべきでしょうか。
闇雲にすべてを適用すると、間接層が増えてかえって可読性を損ないます。
導入の判断基準は、その箇所の変更がどれだけ頻繁に起きるか、そして変更の影響範囲がどれだけ広がるかです。
変更頻度が高く影響範囲が広い箇所から着手するのが合理的です。

一般的な導入順序としては、まずQuery ObjectとPolicy Objectが挙げられます。
この2つは条件分岐が集中しやすく、かつ仕様変更が起きやすい領域だからです。
次にService Objectを導入し、複数モデルにまたがる業務処理を整理します。
Form ObjectとPresenterは、フォームやビューの複雑さが顕在化した段階で導入すれば十分です。

  • 変更頻度が高く影響範囲が広い箇所から着手する
  • 一度にすべてを導入せず、段階的に適用する
  • 間接層が増えることのコストを常に意識する
  • 各オブジェクトの責務を一つに限定する

見落とされがちなのは、これらの手法が銀の弾丸ではないという点です。
単純なCRUD操作にService Objectを導入しても、抽象度が上がるだけで得るものはありません。
重要なのは、目の前のコードが抱える問題を正確に診断し、その問題に適した手法を選ぶことです。
設計手法は目的ではなく手段であるという原点を忘れないでください。

また、これらの手法を導入する際には、チーム内での合意形成が欠かせません。
個人が独断で導入しても、他のメンバーがその意図を理解できなければ、かえって混乱を招きます。
命名規則や配置ディレクトリを統一し、コードレビューで責務の境界を確認する文化を育てることが、設計手法を定着させる前提となります。

テスト容易性の観点も忘れてはなりません。
本記事で紹介した手法は、いずれもテストを書きやすくする効果を持っています。
逆に言えば、テストが書きにくいと感じたときは、これらの手法のいずれかが適用されていないサインです。
テストの書きにくさを設計改善のトリガーとして活用してください。

保守性の高いコードとは、半年後の自分や同僚が安全に変更できるコードです。
そのためには、コードを書く時点で将来の変更を予測し、変更の影響を局所化しておく必要があります。
今回紹介した5つの手法は、そのための実践的な道具立てです。
すべてを一度に導入する必要はありません。
まずは一つの手法を選び、小さな範囲で適用してみてください。
その効果を実感できたとき、設計手法は知識から実践の技術へと変わるはずです。

コメント

タイトルとURLをコピーしました