@k2works/claude-code-booster 2.7.1 → 3.1.0

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

@@ -0,0 +1,327 @@
+# 第 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 手続き的なアプローチ
+
+最初に思いつくのは、`switch` 文でタイプを分岐する手続き的なアプローチです。
+
+```typescript
+// 手続き的な実装（アンチパターン）
+class FizzBuzz {
+  generate(number: number, type: number): string {
+    switch (type) {
+      case 1:
+        if (number % 15 === 0) return "FizzBuzz";
+        if (number % 3 === 0) return "Fizz";
+        if (number % 5 === 0) return "Buzz";
+        return number.toString();
+      case 2:
+        return number.toString();
+      case 3:
+        if (number % 15 === 0) return "FizzBuzz";
+        return number.toString();
+      default:
+        throw new Error(`未定義のタイプ: ${type}`);
+    }
+  }
+}
+```
+
+この実装には問題があります:
+
+- **単一責任原則の違反**: 1 つのメソッドに複数のアルゴリズムが詰め込まれている
+- **開放閉鎖原則の違反**: 新しいタイプを追加するたびに既存のコードを修正する必要がある
+- **テストの困難さ**: タイプごとの独立したテストがしにくい
+
+## 7.4 カプセル化
+
+TypeScript では `private readonly` を使ってフィールドをカプセル化します。
+
+```typescript
+export class FizzBuzz {
+  private readonly _type: FizzBuzzType;
+
+  constructor(type?: FizzBuzzType) {
+    this._type = type ?? new FizzBuzzType01();
+  }
+
+  get type(): FizzBuzzType {
+    return this._type;
+  }
+
+  generate(number: number): string {
+    return this._type.generate(number);
+  }
+}
+```
+
+### TypeScript のカプセル化メカニズム
+
+| 機能 | TypeScript | Java | Python |
+|------|-----------|------|--------|
+| アクセス修飾子 | `private`, `protected`, `public` | `private`, `protected`, `public` | `_` 命名規約 |
+| 不変フィールド | `readonly` | `final` | `@property`（setter なし） |
+| getter | `get prop()` | `getProp()` | `@property` |
+
+- `private readonly _type`: 外部からアクセス不可、再代入不可
+- `get type()`: 読み取り専用アクセサ
+- コンストラクタでのみ初期化可能
+
+## 7.5 ポリモーフィズム
+
+### 抽象クラスの定義
+
+TypeScript の `abstract class` を使って、タイプの共通インターフェースを定義します。
+
+```typescript
+export abstract class FizzBuzzType {
+  static readonly TYPE_01 = 1;
+  static readonly TYPE_02 = 2;
+  static readonly TYPE_03 = 3;
+
+  abstract generate(number: number): string;
+
+  static create(type: number): FizzBuzzType {
+    switch (type) {
+      case FizzBuzzType.TYPE_01:
+        return new FizzBuzzType01();
+      case FizzBuzzType.TYPE_02:
+        return new FizzBuzzType02();
+      case FizzBuzzType.TYPE_03:
+        return new FizzBuzzType03();
+      default:
+        throw new Error(`未定義のタイプ: ${type}`);
+    }
+  }
+}
+```
+
+### 具体クラスの実装
+
+```typescript
+export class FizzBuzzType01 extends FizzBuzzType {
+  generate(number: number): string {
+    if (number % 15 === 0) return "FizzBuzz";
+    if (number % 3 === 0) return "Fizz";
+    if (number % 5 === 0) return "Buzz";
+    return number.toString();
+  }
+}
+
+export class FizzBuzzType02 extends FizzBuzzType {
+  generate(number: number): string {
+    return number.toString();
+  }
+}
+
+export class FizzBuzzType03 extends FizzBuzzType {
+  generate(number: number): string {
+    if (number % 15 === 0) return "FizzBuzz";
+    return number.toString();
+  }
+}
+```
+
+### Strategy パターン
+
+この設計は **Strategy パターン** です。`FizzBuzz` クラスが Context、`FizzBuzzType` が Strategy に相当します。
+
+```
+FizzBuzz (Context)
+  └── FizzBuzzType (Strategy - abstract)
+        ├── FizzBuzzType01 (通常の FizzBuzz)
+        ├── FizzBuzzType02 (数値のみ)
+        └── FizzBuzzType03 (FizzBuzz のみ)
+```
+
+**利点**:
+
+- タイプの追加は新しいクラスを作るだけ（開放閉鎖原則）
+- 各タイプを独立してテストできる
+- 実行時にアルゴリズムを切り替え可能
+
+### FizzBuzz クラスの委譲
+
+```typescript
+export class FizzBuzz {
+  private readonly _type: FizzBuzzType;
+
+  constructor(type?: FizzBuzzType) {
+    this._type = type ?? new FizzBuzzType01();
+  }
+
+  get type(): FizzBuzzType {
+    return this._type;
+  }
+
+  generate(number: number): string {
+    return this._type.generate(number);
+  }
+
+  generateList(count: number): string[] {
+    return Array.from({ length: count }, (_, index) =>
+      this._type.generate(index + 1),
+    );
+  }
+
+  printFizzBuzz(count: number): void {
+    this.generateList(count).forEach((value) => {
+      console.log(value);
+    });
+  }
+}
+```
+
+## 7.6 テストの更新
+
+テストをタイプ別の `describe` ブロックに整理します。
+
+```typescript
+import { beforeEach, describe, expect, test } from "vitest";
+import {
+  FizzBuzz,
+  FizzBuzzType,
+  FizzBuzzType01,
+  FizzBuzzType02,
+  FizzBuzzType03,
+} from "../src/fizzbuzz";
+
+describe("FizzBuzz", () => {
+  describe("タイプ1の場合", () => {
+    let fizzbuzz: FizzBuzz;
+
+    beforeEach(() => {
+      fizzbuzz = new FizzBuzz(FizzBuzzType.create(FizzBuzzType.TYPE_01));
+    });
+
+    test("1を渡したら文字列1を返す", () => {
+      expect(fizzbuzz.generate(1)).toBe("1");
+    });
+
+    test("3を渡したらFizzを返す", () => {
+      expect(fizzbuzz.generate(3)).toBe("Fizz");
+    });
+
+    test("5を渡したらBuzzを返す", () => {
+      expect(fizzbuzz.generate(5)).toBe("Buzz");
+    });
+
+    test("15を渡したらFizzBuzzを返す", () => {
+      expect(fizzbuzz.generate(15)).toBe("FizzBuzz");
+    });
+  });
+
+  describe("タイプ2の場合", () => {
+    let fizzbuzz: FizzBuzz;
+
+    beforeEach(() => {
+      fizzbuzz = new FizzBuzz(FizzBuzzType.create(FizzBuzzType.TYPE_02));
+    });
+
+    test("3を渡したら文字列3を返す", () => {
+      expect(fizzbuzz.generate(3)).toBe("3");
+    });
+
+    test("15を渡したら文字列15を返す", () => {
+      expect(fizzbuzz.generate(15)).toBe("15");
+    });
+  });
+
+  describe("タイプ3の場合", () => {
+    let fizzbuzz: FizzBuzz;
+
+    beforeEach(() => {
+      fizzbuzz = new FizzBuzz(FizzBuzzType.create(FizzBuzzType.TYPE_03));
+    });
+
+    test("3を渡したら文字列3を返す", () => {
+      expect(fizzbuzz.generate(3)).toBe("3");
+    });
+
+    test("15を渡したらFizzBuzzを返す", () => {
+      expect(fizzbuzz.generate(15)).toBe("FizzBuzz");
+    });
+  });
+
+  describe("ファクトリメソッド", () => {
+    test("TYPE_01 を指定すると FizzBuzzType01 が返る", () => {
+      const type = FizzBuzzType.create(FizzBuzzType.TYPE_01);
+      expect(type).toBeInstanceOf(FizzBuzzType01);
+    });
+
+    test("未定義のタイプを指定するとエラーが発生する", () => {
+      expect(() => FizzBuzzType.create(99)).toThrow("未定義のタイプ: 99");
+    });
+  });
+
+  describe("デフォルトコンストラクタ", () => {
+    test("引数なしで生成するとタイプ1として動作する", () => {
+      const fizzbuzz = new FizzBuzz();
+      expect(fizzbuzz.generate(3)).toBe("Fizz");
+      expect(fizzbuzz.generate(15)).toBe("FizzBuzz");
+    });
+  });
+});
+```
+
+### テスト実行結果
+
+```
+ ✓ test/fizzbuzz.test.ts (19 tests) 18ms
+   ✓ FizzBuzz > タイプ1の場合 > 1を渡したら文字列1を返す
+   ✓ FizzBuzz > タイプ1の場合 > 3を渡したらFizzを返す
+   ✓ FizzBuzz > タイプ1の場合 > 5を渡したらBuzzを返す
+   ✓ FizzBuzz > タイプ1の場合 > 15を渡したらFizzBuzzを返す
+   ✓ FizzBuzz > タイプ2の場合 > 3を渡したら文字列3を返す
+   ✓ FizzBuzz > タイプ2の場合 > 15を渡したら文字列15を返す
+   ✓ FizzBuzz > タイプ3の場合 > 3を渡したら文字列3を返す
+   ✓ FizzBuzz > タイプ3の場合 > 15を渡したらFizzBuzzを返す
+   ✓ FizzBuzz > ファクトリメソッド > 未定義のタイプを指定するとエラー
+
+ Test Files  1 passed (1)
+      Tests  19 passed (19)
+```
+
+## 7.7 各言語の OOP 比較
+
+| 概念 | TypeScript | Java | Python |
+|------|-----------|------|--------|
+| 抽象クラス | `abstract class` | `abstract class` | `abc.ABC` + `@abstractmethod` |
+| 抽象メソッド | `abstract method()` | `abstract method()` | `@abstractmethod` |
+| 継承 | `extends` | `extends` | `class Sub(Base)` |
+| アクセス修飾子 | `private`, `protected`, `public` | `private`, `protected`, `public` | `_` 命名規約 |
+| 不変フィールド | `readonly` | `final` | `@property`（setter なし） |
+| インスタンス判定 | `instanceof` | `instanceof` | `isinstance()` |
+
+## 7.8 まとめ
+
+この章で学んだこと:
+
+1. **カプセル化**: `private readonly` でフィールドを保護し、getter で安全にアクセス
+2. **ポリモーフィズム**: `abstract class` と `extends` による型階層で条件分岐を排除
+3. **Strategy パターン**: 実行時にアルゴリズムを切り替える設計パターン
+4. **ファクトリメソッド**: `FizzBuzzType.create()` による生成の集約
+
+次の章では、値オブジェクト、ファーストクラスコレクション、コマンドパターンなど、さらに多くのデザインパターンを適用していきます。

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

@@ -0,0 +1,322 @@
+# 第 8 章: デザインパターンの適用
+
+## 8.1 はじめに
+
+前章ではカプセル化とポリモーフィズムを使って、手続き的な条件分岐をクラス階層に置き換えました。この章では、さらに多くの **デザインパターン** を適用して、コードの表現力と安全性を向上させます。
+
+## 8.2 値オブジェクト（Value Object）
+
+### 問題: プリミティブ型の使用
+
+現在 `generate()` は `string` を返しています。しかし、FizzBuzz の結果には「変換前の数値」と「変換後の文字列」の 2 つの情報が含まれます。プリミティブ型では、このドメイン知識が表現できません。
+
+### 解決: FizzBuzzValue クラス
+
+```typescript
+export class FizzBuzzValue {
+  private readonly _value: string;
+  private readonly _number: number;
+
+  constructor(value: string, number: number) {
+    this._value = value;
+    this._number = number;
+  }
+
+  get value(): string {
+    return this._value;
+  }
+
+  get number(): number {
+    return this._number;
+  }
+
+  equals(other: FizzBuzzValue): boolean {
+    if (!(other instanceof FizzBuzzValue)) {
+      return false;
+    }
+    return this._value === other._value && this._number === other._number;
+  }
+
+  toString(): string {
+    return this._value;
+  }
+}
+```
+
+### 値オブジェクトの特徴
+
+| 特徴 | 実現方法 |
+|------|---------|
+| **不変性** | `private readonly` フィールド |
+| **等価性** | `equals()` メソッドで値による比較 |
+| **自己記述性** | `toString()` で文字列表現 |
+| **副作用なし** | setter を持たない |
+
+### テスト
+
+```typescript
+describe("FizzBuzzValue", () => {
+  test("値と数値を保持する", () => {
+    const value = new FizzBuzzValue("Fizz", 3);
+    expect(value.value).toBe("Fizz");
+    expect(value.number).toBe(3);
+  });
+
+  test("toString は値を返す", () => {
+    const value = new FizzBuzzValue("Buzz", 5);
+    expect(value.toString()).toBe("Buzz");
+  });
+
+  test("同じ値と数値の場合 equals は true", () => {
+    const v1 = new FizzBuzzValue("Fizz", 3);
+    const v2 = new FizzBuzzValue("Fizz", 3);
+    expect(v1.equals(v2)).toBe(true);
+  });
+
+  test("異なる値の場合 equals は false", () => {
+    const v1 = new FizzBuzzValue("Fizz", 3);
+    const v2 = new FizzBuzzValue("Buzz", 5);
+    expect(v1.equals(v2)).toBe(false);
+  });
+});
+```
+
+### FizzBuzzType の更新
+
+generate メソッドの戻り値を `string` から `FizzBuzzValue` に変更します。
+
+```typescript
+export class FizzBuzzType01 extends FizzBuzzType {
+  generate(number: number): FizzBuzzValue {
+    if (number % 15 === 0) return new FizzBuzzValue("FizzBuzz", number);
+    if (number % 3 === 0) return new FizzBuzzValue("Fizz", number);
+    if (number % 5 === 0) return new FizzBuzzValue("Buzz", number);
+    return new FizzBuzzValue(number.toString(), number);
+  }
+}
+```
+
+## 8.3 ファーストクラスコレクション（First-Class Collection）
+
+### 問題: 生の配列の使用
+
+`generateList()` が `string[]` を返すと、コレクションに対する操作が外部に散らばります。
+
+### 解決: FizzBuzzList クラス
+
+```typescript
+import { FizzBuzzValue } from "./fizz-buzz-value";
+
+export class FizzBuzzList {
+  private readonly _list: readonly FizzBuzzValue[];
+
+  constructor(list: FizzBuzzValue[] = []) {
+    this._list = Object.freeze([...list]);
+  }
+
+  add(value: FizzBuzzValue): FizzBuzzList {
+    return new FizzBuzzList([...this._list, value]);
+  }
+
+  get value(): readonly FizzBuzzValue[] {
+    return this._list;
+  }
+
+  get size(): number {
+    return this._list.length;
+  }
+
+  toStringArray(): string[] {
+    return this._list.map((v) => v.toString());
+  }
+
+  *[Symbol.iterator](): Iterator<FizzBuzzValue> {
+    for (const value of this._list) {
+      yield value;
+    }
+  }
+}
+```
+
+### ファーストクラスコレクションの特徴
+
+| 特徴 | 実現方法 |
+|------|---------|
+| **不変性** | `Object.freeze()` で凍結、`add()` は新インスタンスを返す |
+| **カプセル化** | コレクション操作をクラス内に集約 |
+| **イテレータ** | `Symbol.iterator` で `for...of` 対応 |
+| **型安全** | `FizzBuzzValue` のみ格納可能 |
+
+### テスト
+
+```typescript
+describe("FizzBuzzList", () => {
+  test("空リストを生成できる", () => {
+    const list = new FizzBuzzList();
+    expect(list.size).toBe(0);
+  });
+
+  test("add で新しいリストを返す（不変）", () => {
+    const list = new FizzBuzzList();
+    const newList = list.add(new FizzBuzzValue("1", 1));
+    expect(list.size).toBe(0);
+    expect(newList.size).toBe(1);
+  });
+
+  test("toStringArray で文字列配列を返す", () => {
+    let list = new FizzBuzzList();
+    list = list.add(new FizzBuzzValue("1", 1));
+    list = list.add(new FizzBuzzValue("2", 2));
+    list = list.add(new FizzBuzzValue("Fizz", 3));
+    expect(list.toStringArray()).toEqual(["1", "2", "Fizz"]);
+  });
+
+  test("イテレータで反復できる", () => {
+    let list = new FizzBuzzList();
+    list = list.add(new FizzBuzzValue("Fizz", 3));
+    list = list.add(new FizzBuzzValue("Buzz", 5));
+
+    const values: string[] = [];
+    for (const v of list) {
+      values.push(v.toString());
+    }
+    expect(values).toEqual(["Fizz", "Buzz"]);
+  });
+});
+```
+
+## 8.4 コマンドパターン（Command Pattern）
+
+### 問題: 操作の直接実行
+
+`FizzBuzz` クラスが「値の生成」と「リストの生成」という複数の操作を直接持っていました。
+
+### 解決: FizzBuzzCommand
+
+操作をオブジェクトとして表現します。
+
+```typescript
+export interface FizzBuzzCommand {
+  execute(): FizzBuzzValue | FizzBuzzList;
+}
+```
+
+### FizzBuzzValueCommand
+
+```typescript
+export class FizzBuzzValueCommand implements FizzBuzzCommand {
+  private readonly _type: FizzBuzzType;
+  private readonly _number: number;
+
+  constructor(type: FizzBuzzType, number: number) {
+    this._type = type;
+    this._number = number;
+  }
+
+  execute(): FizzBuzzValue {
+    return this._type.generate(this._number);
+  }
+}
+```
+
+### FizzBuzzListCommand
+
+```typescript
+export class FizzBuzzListCommand implements FizzBuzzCommand {
+  private readonly _type: FizzBuzzType;
+  private readonly _count: number;
+
+  constructor(type: FizzBuzzType, count: number) {
+    this._type = type;
+    this._count = count;
+  }
+
+  execute(): FizzBuzzList {
+    let list = new FizzBuzzList();
+    for (let i = 1; i <= this._count; i++) {
+      list = list.add(this._type.generate(i));
+    }
+    return list;
+  }
+}
+```
+
+### テスト
+
+```typescript
+describe("FizzBuzzCommand", () => {
+  test("FizzBuzzValueCommand は単一の値を生成する", () => {
+    const type = FizzBuzzType.create(FizzBuzzType.TYPE_01);
+    const command = new FizzBuzzValueCommand(type, 3);
+    const result = command.execute();
+    expect(result.toString()).toBe("Fizz");
+  });
+
+  test("FizzBuzzListCommand はリストを生成する", () => {
+    const type = FizzBuzzType.create(FizzBuzzType.TYPE_01);
+    const command = new FizzBuzzListCommand(type, 100);
+    const result = command.execute();
+    const arr = result.toStringArray();
+
+    expect(result.size).toBe(100);
+    expect(arr[2]).toBe("Fizz");
+    expect(arr[4]).toBe("Buzz");
+    expect(arr[14]).toBe("FizzBuzz");
+  });
+});
+```
+
+### コマンドパターンの利点
+
+- **操作の具象化**: 「何をするか」をオブジェクトで表現
+- **パラメータの保持**: 実行に必要な情報をコマンド内に保持
+- **実行の分離**: 操作の「定義」と「実行」を分離
+- **拡張性**: 新しい操作は新しいコマンドクラスを追加するだけ
+
+## 8.5 リファクタリング後のクラス構造
+
+### 適用したデザインパターン一覧
+
+| パターン | クラス | 役割 |
+|---------|--------|------|
+| **Value Object** | `FizzBuzzValue` | 不変の値を表現 |
+| **First-Class Collection** | `FizzBuzzList` | コレクション操作のカプセル化 |
+| **Strategy** | `FizzBuzzType` + サブクラス | アルゴリズムの交換 |
+| **Factory Method** | `FizzBuzzType.create()` | インスタンス生成の集約 |
+| **Command** | `FizzBuzzCommand` + 実装クラス | 操作のオブジェクト化 |
+
+### テスト実行結果
+
+```
+ ✓ test/fizzbuzz.test.ts (27 tests) 21ms
+   ✓ FizzBuzz > タイプ1の場合 (6 tests)
+   ✓ FizzBuzz > タイプ2の場合 (3 tests)
+   ✓ FizzBuzz > タイプ3の場合 (3 tests)
+   ✓ FizzBuzz > ファクトリメソッド (4 tests)
+   ✓ FizzBuzz > FizzBuzzValue (4 tests)
+   ✓ FizzBuzz > FizzBuzzList (4 tests)
+   ✓ FizzBuzz > FizzBuzzCommand (3 tests)
+
+ Test Files  1 passed (1)
+      Tests  27 passed (27)
+```
+
+## 8.6 各言語のデザインパターン比較
+
+| パターン | TypeScript | Java | Python |
+|---------|-----------|------|--------|
+| Value Object | `readonly` + `equals()` | `final` + `equals()` / `hashCode()` | `__eq__()` / `__hash__()` |
+| Collection | `Object.freeze()` + `Symbol.iterator` | `Collections.unmodifiableList()` | `tuple` / `frozenset` |
+| Interface | `interface` | `interface` | `Protocol` / `ABC` |
+| Command | `implements FizzBuzzCommand` | `implements FizzBuzzCommand` | ABC + `@abstractmethod` |
+
+## 8.7 まとめ
+
+この章で学んだこと:
+
+1. **値オブジェクト**: プリミティブ型をドメイン固有のオブジェクトで置き換え、型安全性と表現力を向上
+2. **ファーストクラスコレクション**: 配列操作をカプセル化し、不変性を保証
+3. **コマンドパターン**: 操作をオブジェクトとして表現し、実行の柔軟性を確保
+4. **ファクトリメソッド**: インスタンス生成ロジックを集約
+
+次の章では、SOLID 原則の観点からコードを検証し、モジュール構造に再編成します。