@k2works/claude-code-booster 3.0.0 → 3.1.0

package/lib/assets/docs/article/getting-start-tdd/ruby/07-encapsulation-and-polymorphism.md

@@ -0,0 +1,279 @@
+# 第 7 章: カプセル化とポリモーフィズム
+
+## 7.1 はじめに
+
+第 1 部では FizzBuzz を TDD で実装し、第 2 部では開発環境を整備しました。第 3 部では **オブジェクト指向設計** に踏み込み、手続き的なコードをより柔軟で拡張しやすい構造にリファクタリングしていきます。
+
+この章では、**追加仕様** を題材にして **カプセル化** と **ポリモーフィズム** を学びます。
+
+## 7.2 追加仕様
+
+FizzBuzz に 3 つの **タイプ** を導入します。
+
+| タイプ | 仕様 |
+|--------|------|
+| タイプ 1（通常） | 3 の倍数→Fizz、5 の倍数→Buzz、15 の倍数→FizzBuzz、それ以外→数値 |
+| タイプ 2（数値のみ） | すべて数値文字列を返す（Fizz/Buzz 変換なし） |
+| タイプ 3（FizzBuzz のみ） | 15 の倍数→FizzBuzz、それ以外→数値 |
+
+**TODO リスト**:
+
+- [ ] タイプ 1: 通常の FizzBuzz（既存の動作）
+- [ ] タイプ 2: 数値のみ返す
+- [ ] タイプ 3: FizzBuzz のみ返す
+- [ ] 未定義のタイプはエラー
+
+## 7.3 手続き的なアプローチ
+
+最初に思いつくのは、`case` 文でタイプを分岐する手続き的なアプローチです。
+
+```ruby
+# 手続き的な実装（アンチパターン）
+class FizzBuzz
+  def self.generate(number, type = 1)
+    case type
+    when 1
+      return 'FizzBuzz' if (number % 15).zero?
+      return 'Fizz' if (number % 3).zero?
+      return 'Buzz' if (number % 5).zero?
+      number.to_s
+    when 2
+      number.to_s
+    when 3
+      return 'FizzBuzz' if (number % 15).zero?
+      number.to_s
+    else
+      raise "未定義のタイプ: #{type}"
+    end
+  end
+end
+```
+
+この実装には問題があります:
+
+- **単一責任原則の違反**: 1 つのメソッドに複数のアルゴリズムが詰め込まれている
+- **開放閉鎖原則の違反**: 新しいタイプを追加するたびに既存のコードを修正する必要がある
+- **テストの困難さ**: タイプごとの独立したテストがしにくい
+
+## 7.4 カプセル化
+
+Ruby では `attr_reader` を使ってフィールドを読み取り専用で公開し、カプセル化を実現します。
+
+```ruby
+class FizzBuzz
+  attr_reader :type
+
+  def initialize(type = nil)
+    @type = type || FizzBuzzType01.new
+  end
+
+  def generate(number)
+    @type.generate(number)
+  end
+end
+```
+
+### Ruby のカプセル化メカニズム
+
+| 機能 | Ruby | Java | TypeScript |
+|------|------|------|-----------|
+| アクセス修飾子 | `private`, `protected`, `public` | `private`, `protected`, `public` | `private`, `protected`, `public` |
+| 不変フィールド | `freeze` | `final` | `readonly` |
+| getter | `attr_reader` | `getProp()` | `get prop()` |
+| setter | `attr_writer` / `attr_accessor` | `setProp()` | `set prop()` |
+
+- `attr_reader :type`: 読み取り専用アクセサ（getter のみ生成）
+- コンストラクタ（`initialize`）でのみ `@type` を設定
+- 外部からの直接変更を防止
+
+## 7.5 ポリモーフィズム
+
+### 基底クラスの定義
+
+Ruby ではダックタイピングが基本ですが、明示的な型階層を使って共通インターフェースを定義できます。
+
+```ruby
+# frozen_string_literal: true
+
+class FizzBuzzType
+  TYPE_01 = 1
+  TYPE_02 = 2
+  TYPE_03 = 3
+
+  def self.create(type)
+    case type
+    when TYPE_01 then FizzBuzzType01.new
+    when TYPE_02 then FizzBuzzType02.new
+    when TYPE_03 then FizzBuzzType03.new
+    else raise "未定義のタイプ: #{type}"
+    end
+  end
+
+  def fizz?(number)
+    (number % 3).zero?
+  end
+
+  def buzz?(number)
+    (number % 5).zero?
+  end
+
+  def generate(_number)
+    raise NotImplementedError
+  end
+end
+```
+
+### 具体クラスの実装
+
+```ruby
+# frozen_string_literal: true
+
+class FizzBuzzType01 < FizzBuzzType
+  def generate(number)
+    return FizzBuzzValue.new('FizzBuzz', number) if fizz?(number) && buzz?(number)
+    return FizzBuzzValue.new('Fizz', number) if fizz?(number)
+    return FizzBuzzValue.new('Buzz', number) if buzz?(number)
+
+    FizzBuzzValue.new(number.to_s, number)
+  end
+end
+
+class FizzBuzzType02 < FizzBuzzType
+  def generate(number)
+    FizzBuzzValue.new(number.to_s, number)
+  end
+end
+
+class FizzBuzzType03 < FizzBuzzType
+  def generate(number)
+    return FizzBuzzValue.new('FizzBuzz', number) if fizz?(number) && buzz?(number)
+
+    FizzBuzzValue.new(number.to_s, number)
+  end
+end
+```
+
+### Strategy パターン
+
+この設計は **Strategy パターン** です。`FizzBuzz` クラスが Context、`FizzBuzzType` が Strategy に相当します。
+
+```
+FizzBuzz (Context)
+  └── FizzBuzzType (Strategy - 基底クラス)
+        ├── FizzBuzzType01 (通常の FizzBuzz)
+        ├── FizzBuzzType02 (数値のみ)
+        └── FizzBuzzType03 (FizzBuzz のみ)
+```
+
+**利点**:
+
+- タイプの追加は新しいクラスを作るだけ（開放閉鎖原則）
+- 各タイプを独立してテストできる
+- 実行時にアルゴリズムを切り替え可能
+
+## 7.6 テストの更新
+
+テストをタイプ別の `describe` ブロックに整理します。
+
+```ruby
+# frozen_string_literal: true
+
+require_relative '../../../test_helper'
+require_relative '../../../../lib/fizz_buzz/fizz_buzz'
+
+class FizzBuzzTypeTest < Minitest::Test
+  describe 'タイプ1の場合' do
+    def setup
+      @type = FizzBuzzType.create(FizzBuzzType::TYPE_01)
+    end
+
+    def test_1を渡したら文字列1を返す
+      assert_equal '1', @type.generate(1).to_s
+    end
+
+    def test_3を渡したらFizzを返す
+      assert_equal 'Fizz', @type.generate(3).to_s
+    end
+
+    def test_5を渡したらBuzzを返す
+      assert_equal 'Buzz', @type.generate(5).to_s
+    end
+
+    def test_15を渡したらFizzBuzzを返す
+      assert_equal 'FizzBuzz', @type.generate(15).to_s
+    end
+  end
+
+  describe 'タイプ2の場合' do
+    def setup
+      @type = FizzBuzzType.create(FizzBuzzType::TYPE_02)
+    end
+
+    def test_3を渡したら文字列3を返す
+      assert_equal '3', @type.generate(3).to_s
+    end
+
+    def test_15を渡したら文字列15を返す
+      assert_equal '15', @type.generate(15).to_s
+    end
+  end
+
+  describe 'タイプ3の場合' do
+    def setup
+      @type = FizzBuzzType.create(FizzBuzzType::TYPE_03)
+    end
+
+    def test_3を渡したら文字列3を返す
+      assert_equal '3', @type.generate(3).to_s
+    end
+
+    def test_15を渡したらFizzBuzzを返す
+      assert_equal 'FizzBuzz', @type.generate(15).to_s
+    end
+  end
+
+  describe 'ファクトリメソッド' do
+    def test_TYPE_01を指定するとFizzBuzzType01が返る
+      type = FizzBuzzType.create(FizzBuzzType::TYPE_01)
+      assert_instance_of FizzBuzzType01, type
+    end
+
+    def test_未定義のタイプを指定するとエラーが発生する
+      assert_raises RuntimeError do
+        FizzBuzzType.create(99)
+      end
+    end
+  end
+end
+```
+
+### テスト実行結果
+
+```bash
+$ bundle exec rake test
+Started with run options --seed 1052
+
+22 tests, 27 assertions, 0 failures, 0 errors, 0 skips
+```
+
+## 7.7 各言語の OOP 比較
+
+| 概念 | Ruby | Java | TypeScript | Python |
+|------|------|------|-----------|--------|
+| 抽象クラス | 規約（`raise NotImplementedError`） | `abstract class` | `abstract class` | `abc.ABC` + `@abstractmethod` |
+| 継承 | `class Sub < Base` | `extends` | `extends` | `class Sub(Base)` |
+| アクセス修飾子 | `private`, `protected`, `public` | `private`, `protected`, `public` | `private`, `protected`, `public` | `_` 命名規約 |
+| 不変フィールド | `freeze` | `final` | `readonly` | `@property`（setter なし） |
+| インスタンス判定 | `is_a?` / `instance_of?` | `instanceof` | `instanceof` | `isinstance()` |
+| ダックタイピング | ネイティブ対応 | なし（interface） | 構造的部分型 | ネイティブ対応 |
+
+## 7.8 まとめ
+
+この章で学んだこと:
+
+1. **カプセル化**: `attr_reader` でフィールドを読み取り専用にし、オブジェクトの内部状態を保護
+2. **ポリモーフィズム**: 基底クラスとサブクラスによる型階層で条件分岐を排除
+3. **Strategy パターン**: 実行時にアルゴリズムを切り替える設計パターン
+4. **ファクトリメソッド**: `FizzBuzzType.create()` による生成の集約
+
+次の章では、値オブジェクト、ファーストクラスコレクション、コマンドパターンなど、さらに多くのデザインパターンを適用していきます。

package/lib/assets/docs/article/getting-start-tdd/ruby/08-design-patterns.md

@@ -0,0 +1,329 @@
+# 第 8 章: デザインパターンの適用
+
+## 8.1 はじめに
+
+前章ではカプセル化とポリモーフィズムを使って、手続き的な条件分岐をクラス階層に置き換えました。この章では、さらに多くの **デザインパターン** を適用して、コードの表現力と安全性を向上させます。
+
+## 8.2 値オブジェクト（Value Object）
+
+### 問題: プリミティブ型の使用
+
+現在 `generate()` は `String` を返しています。しかし、FizzBuzz の結果には「変換前の数値」と「変換後の文字列」の 2 つの情報が含まれます。プリミティブ型では、このドメイン知識が表現できません。
+
+### 解決: FizzBuzzValue クラス
+
+```ruby
+# frozen_string_literal: true
+
+class FizzBuzzValue
+  attr_reader :value, :number
+
+  def initialize(value, number)
+    raise ArgumentError, '値は正の値のみ許可します' if number.negative?
+
+    @value = value
+    @number = number
+  end
+
+  def ==(other)
+    other.is_a?(FizzBuzzValue) && value == other.value && number == other.number
+  end
+
+  def eql?(other)
+    self == other
+  end
+
+  def hash
+    [value, number].hash
+  end
+
+  def to_s
+    value
+  end
+end
+```
+
+### 値オブジェクトの特徴
+
+| 特徴 | 実現方法 |
+|------|---------|
+| **不変性** | `attr_reader` のみ（setter なし） |
+| **等価性** | `==` メソッドで値による比較 |
+| **自己記述性** | `to_s` で文字列表現 |
+| **副作用なし** | setter を持たない |
+| **ハッシュキー対応** | `eql?` と `hash` を実装 |
+
+### テスト
+
+```ruby
+class FizzBuzzValueTest < Minitest::Test
+  def test_値と数値を保持する
+    value = FizzBuzzValue.new('Fizz', 3)
+    assert_equal 'Fizz', value.value
+    assert_equal 3, value.number
+  end
+
+  def test_toStringは値を返す
+    value = FizzBuzzValue.new('Buzz', 5)
+    assert_equal 'Buzz', value.to_s
+  end
+
+  def test_同じ値と数値の場合equalはtrue
+    v1 = FizzBuzzValue.new('Fizz', 3)
+    v2 = FizzBuzzValue.new('Fizz', 3)
+    assert_equal v1, v2
+  end
+
+  def test_異なる値の場合equalはfalse
+    v1 = FizzBuzzValue.new('Fizz', 3)
+    v2 = FizzBuzzValue.new('Buzz', 5)
+    refute_equal v1, v2
+  end
+
+  def test_負の値はエラー
+    assert_raises ArgumentError do
+      FizzBuzzValue.new('Fizz', -1)
+    end
+  end
+end
+```
+
+### FizzBuzzType の更新
+
+`generate` メソッドの戻り値を `String` から `FizzBuzzValue` に変更します。
+
+```ruby
+class FizzBuzzType01 < FizzBuzzType
+  def generate(number)
+    return FizzBuzzValue.new('FizzBuzz', number) if fizz?(number) && buzz?(number)
+    return FizzBuzzValue.new('Fizz', number) if fizz?(number)
+    return FizzBuzzValue.new('Buzz', number) if buzz?(number)
+
+    FizzBuzzValue.new(number.to_s, number)
+  end
+end
+```
+
+## 8.3 ファーストクラスコレクション（First-Class Collection）
+
+### 問題: 生の配列の使用
+
+`generate_list()` が `Array` を返すと、コレクションに対する操作が外部に散らばります。
+
+### 解決: FizzBuzzList クラス
+
+```ruby
+# frozen_string_literal: true
+
+class FizzBuzzList
+  MAX_COUNT = 100
+
+  include Enumerable
+
+  attr_reader :value
+
+  def initialize(list = [])
+    raise "上限は#{MAX_COUNT}件までです" if list.count > MAX_COUNT
+
+    @value = list.dup.freeze
+  end
+
+  def add(other_list)
+    FizzBuzzList.new(@value + other_list)
+  end
+
+  def size
+    @value.size
+  end
+
+  def to_string_array
+    @value.map(&:to_s)
+  end
+
+  def each(&)
+    @value.each(&)
+  end
+end
+```
+
+### ファーストクラスコレクションの特徴
+
+| 特徴 | 実現方法 |
+|------|---------|
+| **不変性** | `dup.freeze` で凍結、`add` は新インスタンスを返す |
+| **カプセル化** | コレクション操作をクラス内に集約 |
+| **イテレータ** | `Enumerable` の Mix-in で `each`, `map` 等を提供 |
+| **上限管理** | `MAX_COUNT` で件数を制限 |
+
+### テスト
+
+```ruby
+class FizzBuzzListTest < Minitest::Test
+  def test_空リストを生成できる
+    list = FizzBuzzList.new
+    assert_equal 0, list.size
+  end
+
+  def test_addで新しいリストを返す
+    list = FizzBuzzList.new
+    values = [FizzBuzzValue.new('1', 1)]
+    new_list = list.add(values)
+    assert_equal 0, list.size
+    assert_equal 1, new_list.size
+  end
+
+  def test_to_string_arrayで文字列配列を返す
+    values = [
+      FizzBuzzValue.new('1', 1),
+      FizzBuzzValue.new('2', 2),
+      FizzBuzzValue.new('Fizz', 3)
+    ]
+    list = FizzBuzzList.new(values)
+    assert_equal %w[1 2 Fizz], list.to_string_array
+  end
+
+  def test_上限を超えるとエラー
+    values = (1..101).map { |n| FizzBuzzValue.new(n.to_s, n) }
+    assert_raises RuntimeError do
+      FizzBuzzList.new(values)
+    end
+  end
+end
+```
+
+## 8.4 コマンドパターン（Command Pattern）
+
+### 問題: 操作の直接実行
+
+`FizzBuzz` クラスが「値の生成」と「リストの生成」という複数の操作を直接持っていました。
+
+### 解決: FizzBuzzCommand
+
+操作をオブジェクトとして表現します。Ruby ではモジュールをインターフェースとして使います。
+
+```ruby
+# frozen_string_literal: true
+
+module FizzBuzzCommand
+  def execute
+    raise NotImplementedError
+  end
+end
+```
+
+### FizzBuzzValueCommand
+
+```ruby
+# frozen_string_literal: true
+
+class FizzBuzzValueCommand
+  include FizzBuzzCommand
+
+  def initialize(type, number)
+    @type = type
+    @number = number
+  end
+
+  def execute
+    @type.generate(@number)
+  end
+end
+```
+
+### FizzBuzzListCommand
+
+```ruby
+# frozen_string_literal: true
+
+class FizzBuzzListCommand
+  include FizzBuzzCommand
+
+  def initialize(type, count = 100)
+    @type = type
+    @count = count
+  end
+
+  def execute
+    list = (1..@count).map { |number| @type.generate(number) }
+    FizzBuzzList.new(list)
+  end
+end
+```
+
+### テスト
+
+```ruby
+class FizzBuzzCommandTest < Minitest::Test
+  def test_FizzBuzzValueCommandは単一の値を生成する
+    type = FizzBuzzType.create(FizzBuzzType::TYPE_01)
+    command = FizzBuzzValueCommand.new(type, 3)
+    result = command.execute
+    assert_equal 'Fizz', result.to_s
+  end
+
+  def test_FizzBuzzListCommandはリストを生成する
+    type = FizzBuzzType.create(FizzBuzzType::TYPE_01)
+    command = FizzBuzzListCommand.new(type, 100)
+    result = command.execute
+    arr = result.to_string_array
+
+    assert_equal 100, result.size
+    assert_equal 'Fizz', arr[2]
+    assert_equal 'Buzz', arr[4]
+    assert_equal 'FizzBuzz', arr[14]
+  end
+
+  def test_デフォルトで100件のリストを生成する
+    type = FizzBuzzType.create(FizzBuzzType::TYPE_01)
+    command = FizzBuzzListCommand.new(type)
+    result = command.execute
+    assert_equal 100, result.size
+  end
+end
+```
+
+### コマンドパターンの利点
+
+- **操作の具象化**: 「何をするか」をオブジェクトで表現
+- **パラメータの保持**: 実行に必要な情報をコマンド内に保持
+- **実行の分離**: 操作の「定義」と「実行」を分離
+- **拡張性**: 新しい操作は新しいコマンドクラスを追加するだけ
+
+## 8.5 リファクタリング後のクラス構造
+
+### 適用したデザインパターン一覧
+
+| パターン | クラス | 役割 |
+|---------|--------|------|
+| **Value Object** | `FizzBuzzValue` | 不変の値を表現 |
+| **First-Class Collection** | `FizzBuzzList` | コレクション操作のカプセル化 |
+| **Strategy** | `FizzBuzzType` + サブクラス | アルゴリズムの交換 |
+| **Factory Method** | `FizzBuzzType.create()` | インスタンス生成の集約 |
+| **Command** | `FizzBuzzCommand` + 実装クラス | 操作のオブジェクト化 |
+
+### テスト実行結果
+
+```bash
+$ bundle exec rake test
+22 tests, 27 assertions, 0 failures, 0 errors, 0 skips
+```
+
+## 8.6 各言語のデザインパターン比較
+
+| パターン | Ruby | Java | TypeScript | Python |
+|---------|------|------|-----------|--------|
+| Value Object | `attr_reader` + `==` | `final` + `equals()` / `hashCode()` | `readonly` + `equals()` | `__eq__()` / `__hash__()` |
+| Collection | `Enumerable` + `freeze` | `Collections.unmodifiableList()` | `Object.freeze()` + `Symbol.iterator` | `tuple` / `frozenset` |
+| Interface | `module`（Mix-in） | `interface` | `interface` | `Protocol` / `ABC` |
+| Command | `include FizzBuzzCommand` | `implements FizzBuzzCommand` | `implements FizzBuzzCommand` | ABC + `@abstractmethod` |
+
+## 8.7 まとめ
+
+この章で学んだこと:
+
+1. **値オブジェクト**: プリミティブ型をドメイン固有のオブジェクトで置き換え、型安全性と表現力を向上
+2. **ファーストクラスコレクション**: 配列操作をカプセル化し、`Enumerable` Mix-in で Ruby らしいイテレーションを実現
+3. **コマンドパターン**: 操作をオブジェクトとして表現し、実行の柔軟性を確保
+4. **ファクトリメソッド**: インスタンス生成ロジックを集約
+
+次の章では、SOLID 原則の観点からコードを検証し、モジュール構造に再編成します。