Rubyアプリケーションにおけるモジュール性の再考
Rethinking Modularity in Ruby Applications (noteflakes.com)
要約
この記事では、Rubyアプリケーションにおけるモジュール性の概念を再考し、従来のRailsのオートローディングアプローチと、筆者が開発中の新しいWebフレームワークSyntropyが採用する明示的な依存関係アプローチを比較しています。Syntropyはファイルベースのルーティングと明示的なインポート/エクスポートメカニズムを通じて、グローバルな状態への副作用がない、自己完結型のモジュール化を可能にし、テストと理解の容易さを向上させると主張しています。これにより、複雑なアプリケーションの構造理解とメンテナンスが簡素化されると述べています。
全文翻訳
Rubyアプリケーションにおけるモジュール性の再考
2026年6月18日
先日、私が開発中の新しいRuby WebフレームワークであるSyntropy(このサイトでも使用されています)について書きました。Syntropyのデザインは、ファイルベースルーティングという考え方に基づいています。これは、アプリケーションを構成するルートハンドラ(つまりコントローラー)のソースファイルが、アプリケーションのURL名前空間に従って整理・命名されることを意味します。また、Syntropyが異なるソースファイル(モジュールと呼ばれる)をどのようにロードするかについても触れましたが、今回はこの点についてもう少し詳しく説明したいと思います。
Ruby on Railsにおけるコード組織化
Railsの開発者であれば、Railsのアプローチが、Zeitwerk gemによって実行される、アプリケーションを構成する様々なソースファイルの自動ロードに基づいていることをご存知でしょう。このアプローチは、ディレクトリ構造をアプリケーションの名前空間(クラスやモジュール)の表現として使用して、依存関係のロードを自動化します。
Railsのアプローチでは、アプリケーションのすべてのクラスとモジュールはグローバルであり、アプリケーションのディレクトリ構造に従ってネストされます。定数が参照されると自動的にロードされるため、依存関係を明示的にrequireする必要はありません。これは、アプリケーションの異なる部分間の依存関係が暗黙的であることを意味します。
このアプローチは、コードを特定の命名規則とファイル配置に従うクラスに整理している限り、非常にうまく機能します。大きな利点は、アプリケーション内の異なるソースファイルを明示的にrequireする必要がないことです。代わりに、実行中のコードによって定数が参照されると、それらは自動的にロードされます。Zeitwerkは、開発モードでの変更されたファイルの自動リロードもサポートしています。
Railsのアプローチの重要な欠点の一つは、1つのファイルに1つのクラスという考え方に縛られることです。そしてもちろん、異なるクラスの名前はソースファイルの場所と一致する必要があります。これは、ソースファイルを別のディレクトリに移動した場合、その新しい場所に一致するようにクラスの名前も変更する必要があることを意味します。
さらに欠点として、すべてがグローバルであるため、本来触れるべきではないクラスに誤って触れたり参照したりするリスクがあり、依存関係が暗黙的であるため、これらの「誤った参照」は見過ごされ、予期しない(つまり未定義の)動作を引き起こす可能性があります。例えば、シングルトンオブジェクト(Webアプリケーションでは非常に便利なシングルトンオブジェクト)はグローバルとして定義されているため、コードがそのグローバルオブジェクトに誤ってアクセスしたり、その状態を変更したりする可能性があります。
私の経験では、アプリケーションがある程度の複雑さに達し、ソースコードが多数のファイルに分割されると、ソースコードの異なる部分間の依存関係を明示的に表現することが、コードの構造とアプリケーションの各部分の関係を理解する上で非常に役立つことがわかりました。
また、クラスやモジュールだけでなく、proc/lambda(つまりクロージャ)やその他のシングルトンオブジェクトの観点からもインターフェースを表現できることに感謝するようになりました。多くの場合、データベース接続プール、バックグラウンドジョブストア、メーラーオブジェクト、あるいは設定ハッシュのような「グローバル」サービスや状態オブジェクトにアクセスする必要があります。これらを明示的な参照でアクセスできるということは、これらのオブジェクトがグローバル定数として利用可能であることに依存する必要がないということです。これにより、依存性注入の実装が容易になり、テストも大幅に簡素化されます。
Syntropyにおけるコード組織化
Syntropyは、アプリケーションのディレクトリ構造がURL名前空間を反映するという考えに基づいています。例えば、シンプルなブログアプリケーションのディレクトリ構造は以下のようになります。
files URLs
===== ====
+ app/
+ _lib/
+ storage.rb
+ _layout/
+ default.rb
+ index.rb /
+ about.rb /about
+ posts/
+ [id]/
+ index.rb /posts/[id]
+ edit.rb /posts/[id]/edit
+ index.rb /posts
+ new.rb /posts/new
上記の例には、コントローラーコード(URLにマッピングされる)と、通常_libや_layoutのようなディレクトリに配置される内部依存関係(アンダースコアで始まるディレクトリまたはファイル名は内部的なものと見なされ、Syntropyルーターによって公開されません)の両方が含まれています。
これらの異なるソースファイルは、アプリケーションによってどのようにロードされるのでしょうか?コントローラーの場合、サーバーがソースファイルの場所と一致するURLのリクエストを受信すると、自動的にロードされます。例えば、GET /postsリクエストはapp/posts/index.rbにルーティングされます。
Syntropyの第二の原則は、すべての依存関係が明示的であるということです。アプリケーション内の任意の依存関係をロードするには、importを呼び出します。例えば、投稿インデックスコントローラーは以下のようになります。
# app/posts/index.rb
@storage = import '/_lib/storage'
@layout = import '/_layout/default'
@template = @layout.apply { |posts:, **|
posts.each { |post|
article { a post.title, href: post.url }
p post.body
}
}
export ->(req) {
posts = @storage.get_all_posts
req.respond_html(@template.render(posts:))
}
上記の例では、モデルインターフェースとして機能する@storageオブジェクトと、Papercraftレイアウトテンプレートとして機能する@layoutオブジェクトという2つの依存関係をインポートしています。次に、投稿のリストをレンダリングするテンプレートを作成し、最後に、HTTPリクエストを受け取り、@storageから投稿のリストを取得し、@templateをレンダリングしてHTMLレスポンスを返すコントローラーラムダをエクスポートします。
モジュールから任意のオブジェクトをエクスポートでき、それがその値として機能するため、レイアウトモジュールを次のように表現できます。
# app/_layout/default.rb
export template {
html {
head { ... }
body {
render_children
}
}
}
このモジュールでは、レイアウトテンプレート(Papercraftテンプレート)がモジュールの実際のインターフェースであり、インポートするたびにエクスポートされたのと同じオブジェクトを取得できます。ストレージモジュールは以下のようになります。
# app/_lib/storage.rb
export self
def get_posts
...
end
...
ストレージモジュールの場合は、モジュール自体をシングルトンとしてエクスポートするため、そのメソッドを呼び出すことができます。
storage = import '/_lib/storage'
storage.get_posts
このようにコードをロードすることには、いくつかの重要な利点があります。
- モジュールコードのロードはグローバル状態に副作用を及ぼしません。すべての定数とインスタンス変数はモジュールのコンテキストに完全にローカルであり、グローバルコンテキストに漏れません。
- モジュールのインターフェースはクラスだけでなく任意のオブジェクトにできるため、シングルトンを使いやすくなります。
- 依存関係が明示的であるため、コードの各部分がどのように連携し、どこにあるかを理解しやすくなります。
- 各モジュールは完全に自己完結しており、グローバル名前空間に「漏れ」ないため、分離してテストするのがはるかに簡単です。
- コードリロードの実装もはるかに容易になります。すべての依存関係は実行時にわかっているため、
importの呼び出しを追跡でき、モジュールの基盤となるファイルが変更された場合は、古いモジュールを破棄し、新しいコードをロードしてから、そのすべての逆依存関係を再帰的にロードするだけで済みます。
モジュールへの状態の注入
各モジュールは個別の匿名コンテキストでevalされるため、ロード時にモジュールに状態を簡単に注入することもできます。これは、環境ハッシュ(アプリケーションの設定を含む)や、モジュールが使用する可能性のあるその他のアプリケーションの懸念事項(アプリケーションオブジェクト自体、基盤となるUringMachineインスタンス、またはその他のグローバルサービスなど)を注入する場合に特に役立ちます。これもまた、これらのモジュールの単体テストのタスクを簡素化します。これは、モジュールで利用可能なインスタンス変数を設定することによって行われます。Syntropyモジュールがアプリケーションの設定にアクセスする方法を次に示します。
# app/_lib/mailer.rb
require 'my_mailer'
export MyMailer.new(@env[:config][:smtp_server])
ここでは、@envにアクセスしています。これは、ロード時にモジュールに注入されます。そしてもちろん、テスト目的でカスタム@envオブジェクトを簡単に注入することもできます。
Syntropyでのモジュールロードの仕組み
Syntropyを紹介する前の記事で、Syntropyがモジュールをロードする基本的な仕組みについて説明しました。Syntropyがこれをどのように実現するかを詳しく見てみましょう。Syntropyのモジュールローダーコード全体は完全に自己完結しており、Syntropyの他の部分に依存していません。ロードされるモジュールに渡されるいくつかの依存関係が提供されるだけで済みます。
# 大幅に簡略化されたバージョン:
class ModuleLoader
def initialize(env)
@env = env
@app_root = env[:app_root]
@modules = {} # ref を module entry にマップ
end
def load(ref)
ref = "/#{ref}" if ref !~ /^\//
if !(entry = @modules[ref])
entry = load_module(ref)
@modules[ref] = entry
end
entry[:export_value]
end
private
def load_module(ref)
fn = File.expand_path(File.join(@app_root, "#{ref}.rb"))
code = read_file(fn)
env = @env.merge(module_loader: self, ref: clean_ref(ref))
mod = ModuleContext.new(env, code, fn)
{
fn: fn,
module: mod,
export_value: mod.__export_value__,
}
end
end
モジュールローダーは、アプリケーションの環境(設定を含む)を表すenvオブジェクトで初期化されます。#loadメソッドはモジュールのソースコードを読み込み、次にモジュールのソースコードが実行されるコンテキストとなるModuleContextオブジェクトをインスタンス化します。
# 大幅に簡略化されたバージョン:
class ModuleContext
def initialize(env, code, fn)
@env = env
@module_loader = env[:module_loader]
@ref = env[:ref]
instance_eval(code, fn)
end
private
def export(v)
@__export_value__ = v
end
def import(ref)
@module_loader.load(ref)
end
end
モジュールロードのメカニズム全体は、これらの数行で表されます。モジュールコンテキストインスタンスを作成し、#instance_evalを使用してソースコードを評価し、import/exportメソッドはプライベートメソッドとして定義され、異なるモジュール間の明示的な依存関係と、任意のオブジェクトをモジュールインターフェースとして使用することを可能にします。
テスト状況での使用方法を次に示します。
class FooTest < Minitest::Test
def setup
@module_loader = ModuleLoader.new(
# 注入された環境ハッシュ
{
app_root: File.join(__dir__, 'fixtures')
foo: 'foo'
}
)
end
def test_foo_module
foo = @module_loader.load('foo')
refute_nil foo
# fooモジュールが#envメソッドを持っていると仮定する:
assert_equal 'foo', foo.env[:foo]
end
end
上記のコードからわかるように、グローバル状態がないという事実は、テストの記述をはるかに容易にします。私たちのテストは(少なくともグローバル名前空間を変更するという点では)副作用がなく、ロードされたモジュールに渡される環境に任意の値を注入できます。また、ModuleLoaderおよびModuleContextクラスのインターフェースは非常に最小限であるため、それらを拡張またはより複雑な動作に合成したり、単に標準の動作をオーバーライドしたりすることが容易です。
OOPの牢獄からの脱却
Rubyについて私が愛していることの一つは、それが非常に柔軟で、異なるコーディングスタイルや異なるテクニックを受け入れやすいことです。Rubyコードを書く一般的なアプローチは、多かれ少なかれ厳格なOOP原則(カプセル化、継承、クラスに整理されたコード、そして単一のグローバルトポロジーに整理されたクラス)に従うことに基づいています。
しかし、Rubyコードを書く他の方法もあります。そして多くの場合、機能をクロージャ(つまりProc)として表現することは、通常のよりもはるかに強力で、表現力豊かで、簡潔です。これは、Webフレームワーク上でアプリケーションを構築する場合に特に当てはまります。フレームワークは、アプリケーションのコントローラーに特定の形状を期待しますが、コントローラーをクラスとして表現する代わりに、procとして表現できます。
# Railsの方法:
class PostsController < ApplicationController
def index = ...
end
end
# Syntropyの方法
export ->(req) { ... }
ここには重要な違いがあります。それらのいくつかは上記で議論されました。そして、ボイラープレートの問題は実際には最も興味のないものです。Railsコントローラーはグローバルに名前が付けられていますが、Syntropyコントローラーは匿名です。Railsでは、各リクエストに対してコントローラーのインスタンスが割り当てられ、そのエントリポイントメソッドが呼び出されます。Syntropyでは、コントローラー自体が各リクエストで呼び出されるエントリポイントであり(リクエストを引数として)、コントローラーが呼び出されるときにオブジェクトの割り当ては発生しません。
また、コントローラーがprocであるという事実は、コードを好きなように整理する自由と、さまざまなテクニックを使用してカスタムコントローラーを動的に生成するほぼ魔法のような能力の両方をもたらします。最後に、クロージャ(つまりproc)をモジュール性の単位として使用することは、クリーンなインターフェースを作成することを奨励します。特定の機能のサーフェスエリアが単一のメソッドインターフェース(つまり#call)に縮小されると、アプリケーションの構築方法について異なる考え方を始めるようになります。
Syntropyリポジトリのブログ例のコントローラーを見てみましょう。これは、ブログ投稿の表示、追加、編集、削除を可能にする基本的なサイトです。
# app/posts/index.rb
@posts = import '_lib/posts'
@layout = import '_layout/default'
@template = @layout.apply {
...
}
export dispatch_by_http_method
def get(req)
posts = @posts.get_all
req.respond_html(@template.render(posts:, flash: req.flash))
end
def post(req)
data = req.get_form_data
title = req.validate(data['title'], String, /.+/)
body = req.validate(data['body'], String, /.+/)
id = @posts.create(title, body)
req.flash[:notice] = 'Post was successfully created.'
req.redirect("posts/#{id}")
end
依存関係をインポートし、インスタンス変数に割り当てることから始めます。@postsはモデル、@layoutはレイアウトとして使用されるPapercraftテンプレート、そして@templateは投稿リストを表示するHTMLを生成します。次に、dispatch_by_http_methodという式をエクスポートします。これは実際にはメソッド呼び出しであり、その実装は次のとおりです。
def dispatch_by_http_method
->(req) {
sym = req.method.to_sym
raise Syntropy::Error.method_not_allowed unless self.respond_to?(sym)
send(sym, req)
}
end
ここで、procをクロージャとして使用する力の片鱗を味わうことができます。HTTPメソッドに基づいてリクエストをディスパッチする方法を知っているクロージャを生成します。これはモジュールコンテキスト(つまりself)に自動的にバインドされ、わずか数行のコードで非常に一般的な動作を表現できます。リクエストはリクエストのHTTPメソッドに対応するメソッドにディスパッチされ、メソッドが実装されていない場合は、クライアントにMETHOD NOT ALLOWEDステータスコードが返されます。
したがって、コントローラーのエントリポイントを生成するためにdispatch_by_http_methodを呼び出した後、受け入れたいHTTPメソッド、つまりGETとPOSTのハンドラを実装するだけです。
export dispatch_by_http_method
def get(req)
...
end
def post(req)
...
end
実際、同じテクニックを使用してRailsスタイルのコントローラーを実装することもできます(Railsコントローラーはデフォルトで複数の異なるURLを処理するため、ワイルドカードルートが必要になります)。
# app/posts+.rb
export dispatch_action
def index(req) = ...
def show(req) = ...
def new(req) = ...
# etc...
さて、上記のコードを見てください。有名なRails関係者の言葉を借りれば、「私がやっていないことを見てください!」クラスを定義していませんし、何も名前空間化していませんし、グローバル定数を定義していません。このコードへの唯一の参照は、アプリケーションのディレクトリ構造内のその場所であり、dispatch_by_actionディレクティブは、コードをラップするクロージャと、リクエストを正しいメソッドにディスパッチするためのちょっとしたロジックを動的に作成します。
したがって、コントローラーロジックをメソッドを使用して整理し続けていますが、グルーコードはproc/クロージャを使用して実装されています。すべてのRubyコードがこのようであるべきだと言っているのではありません。もちろん、古典的なOOPアプローチが有益な状況はたくさんあります。これは、明確に定義されたAPIと型情報が必要なRuby gemの場合に特に当てはまります。しかし、フレームワーク上で動作するアプリケーションでは、アプリケーションコードがフレームワークによって駆動されるため、アプリケーションのエントリポイントをクロージャとしてコーディングすることは、ボイラープレートの削減、依存関係の明確化、より動的な動作、そして表現力の向上といった複数の利点をもたらします。
Rubyコードの記述において、より関数的なスタイルでまだ多くの発見があると思います。過去数年間、私はまさにその探求をしてきました。より関数的なアプローチをRubyにもたらすことです。私の仕事の一部は、HTMLテンプレートに機能的なアプローチをもたらすPapercraftの開発につながりました。Syntropyは現在、Webコントローラーに機能的なアプローチをもたらしています。そして、モデルについても同様のことが可能であると私は考えており、将来の記事で議論したいと思っています。