@k2works/claude-code-booster 2.7.1 → 3.1.0

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

@@ -0,0 +1,208 @@
+# 第 7 章: カプセル化とポリモーフィズム
+
+## 7.1 はじめに
+
+第 1〜2 部で FizzBuzz の基本実装と開発環境を整えました。第 3 部では、手続き的なコードをオブジェクト指向設計にリファクタリングしていきます。この章では、FizzBuzz に **追加仕様** を導入し、**カプセル化** と **ポリモーフィズム** を適用します。
+
+## 7.2 追加仕様
+
+FizzBuzz プログラムに以下の 3 つのタイプを追加します。
+
+| タイプ | 動作 |
+|--------|------|
+| タイプ 1 | 通常の FizzBuzz（3 の倍数→Fizz、5 の倍数→Buzz、両方→FizzBuzz） |
+| タイプ 2 | 数をそのまま文字列で返す |
+| タイプ 3 | 3 と 5 の倍数のときだけ FizzBuzz、それ以外は数を返す |
+
+**TODO リスト**:
+
+- [ ] タイプ 1: 通常の FizzBuzz
+- [ ] タイプ 2: 数をそのまま返す
+- [ ] タイプ 3: FizzBuzz のみ
+- [ ] それ以外のタイプは例外を送出する
+
+## 7.3 手続き的アプローチ
+
+まず、テストから書きます。タイプをコンストラクタで受け取る設計にします。
+
+```python
+class TestFizzBuzz:
+    class TestType1:
+        def setup_method(self):
+            self.fizzbuzz = FizzBuzz(1)
+
+        def test_3と5の倍数の場合FizzBuzzを返す(self):
+            assert self.fizzbuzz.generate(15) == "FizzBuzz"
+
+        def test_3の倍数の場合Fizzを返す(self):
+            assert self.fizzbuzz.generate(3) == "Fizz"
+
+        def test_5の倍数の場合Buzzを返す(self):
+            assert self.fizzbuzz.generate(5) == "Buzz"
+
+        def test_その他の場合数を文字列で返す(self):
+            assert self.fizzbuzz.generate(1) == "1"
+
+    class TestType2:
+        def setup_method(self):
+            self.fizzbuzz = FizzBuzz(2)
+
+        def test_数をそのまま文字列で返す(self):
+            assert self.fizzbuzz.generate(3) == "3"
+
+    class TestType3:
+        def setup_method(self):
+            self.fizzbuzz = FizzBuzz(3)
+
+        def test_3と5の倍数の場合FizzBuzzを返す(self):
+            assert self.fizzbuzz.generate(15) == "FizzBuzz"
+
+        def test_その他の場合数を文字列で返す(self):
+            assert self.fizzbuzz.generate(3) == "3"
+```
+
+手続き的な実装は `if/elif` の連鎖になります。
+
+```python
+class FizzBuzz:
+    def __init__(self, type_: int) -> None:
+        self._type = type_
+
+    def generate(self, number: int) -> str:
+        if self._type == 1:
+            if number % 15 == 0:
+                return "FizzBuzz"
+            if number % 3 == 0:
+                return "Fizz"
+            if number % 5 == 0:
+                return "Buzz"
+            return str(number)
+        elif self._type == 2:
+            return str(number)
+        elif self._type == 3:
+            if number % 15 == 0:
+                return "FizzBuzz"
+            return str(number)
+        else:
+            raise ValueError("未定義のタイプです")
+```
+
+このコードには問題があります。タイプが増えるたびに `if/elif` が肥大化し、変更の影響範囲が広がります。
+
+## 7.4 カプセル化
+
+### @property によるフィールドアクセス制御
+
+Python では `@property` デコレータを使ってフィールドのアクセスを制御します。setter を定義しないことで **読み取り専用** にできます。
+
+```python
+class FizzBuzz:
+    def __init__(self, type_: int) -> None:
+        self._type = type_
+
+    @property
+    def type(self) -> int:
+        return self._type
+```
+
+Java の `private final` + getter に相当します。外部から `fizzbuzz.type` で読み取れますが、`fizzbuzz.type = 2` のような代入はエラーになります。
+
+## 7.5 ポリモーフィズム
+
+### 抽象基底クラスの導入
+
+`if/elif` の連鎖をポリモーフィズムで置き換えます。Python では `abc.ABC` と `@abstractmethod` を使います。
+
+```python
+from abc import ABC, abstractmethod
+
+class FizzBuzzType(ABC):
+    @abstractmethod
+    def generate(self, number: int) -> str:
+        pass
+
+    def _is_fizz(self, number: int) -> bool:
+        return number % 3 == 0
+
+    def _is_buzz(self, number: int) -> bool:
+        return number % 5 == 0
+
+    def _is_fizz_buzz(self, number: int) -> bool:
+        return number % 15 == 0
+```
+
+### 具象クラスの作成
+
+```python
+class FizzBuzzType01(FizzBuzzType):
+    def generate(self, number: int) -> str:
+        if self._is_fizz_buzz(number):
+            return "FizzBuzz"
+        if self._is_fizz(number):
+            return "Fizz"
+        if self._is_buzz(number):
+            return "Buzz"
+        return str(number)
+
+class FizzBuzzType02(FizzBuzzType):
+    def generate(self, number: int) -> str:
+        return str(number)
+
+class FizzBuzzType03(FizzBuzzType):
+    def generate(self, number: int) -> str:
+        if self._is_fizz_buzz(number):
+            return "FizzBuzz"
+        return str(number)
+```
+
+### ファクトリメソッド
+
+タイプの生成を一箇所にまとめます。
+
+```python
+class FizzBuzzType(ABC):
+    @staticmethod
+    def create(type_: int) -> "FizzBuzzType":
+        if type_ == 1:
+            return FizzBuzzType01()
+        elif type_ == 2:
+            return FizzBuzzType02()
+        elif type_ == 3:
+            return FizzBuzzType03()
+        else:
+            raise ValueError("未定義のタイプです")
+```
+
+## 7.6 テストの更新
+
+リファクタリング後のテストは、ファクトリメソッド経由でタイプを生成します。
+
+```python
+class TestFizzBuzzType:
+    class TestType01:
+        def setup_method(self):
+            self.type = FizzBuzzType.create(1)
+
+        def test_FizzBuzzを返す(self):
+            assert self.type.generate(15) == "FizzBuzz"
+
+        def test_Fizzを返す(self):
+            assert self.type.generate(3) == "Fizz"
+
+        def test_Buzzを返す(self):
+            assert self.type.generate(5) == "Buzz"
+
+        def test_数を文字列で返す(self):
+            assert self.type.generate(1) == "1"
+```
+
+## 7.7 まとめ
+
+| 概念 | Java | Python |
+|------|------|--------|
+| フィールド隠蔽 | `private final` | `_` 接頭辞 + `@property` |
+| 抽象クラス | `abstract class` | `abc.ABC` + `@abstractmethod` |
+| ファクトリメソッド | `static` メソッド | `@staticmethod` |
+| 条件分岐の排除 | ポリモーフィズム | ポリモーフィズム |
+
+次の章では、Value Object や Command パターンなどのデザインパターンを適用します。

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

@@ -0,0 +1,172 @@
+# 第 8 章: デザインパターンの適用
+
+## 8.1 はじめに
+
+前章では、カプセル化とポリモーフィズムで `if/elif` の連鎖を排除しました。この章では、さらに **デザインパターン** を適用して設計を洗練させます。
+
+適用するパターン:
+
+1. **Value Object** — 値をオブジェクトとして表現
+2. **First-Class Collection** — コレクションをドメインオブジェクト化
+3. **Command パターン** — 操作をオブジェクト化
+4. **Null Object パターン** — 例外の代わりにデフォルト動作を提供
+
+## 8.2 Value Object（値オブジェクト）
+
+FizzBuzz の結果を「数」と「変換後の文字列」のペアとして保持する値オブジェクトを作成します。
+
+```python
+class FizzBuzzValue:
+    def __init__(self, number: int, value: str) -> None:
+        self._number = number
+        self._value = value
+
+    @property
+    def number(self) -> int:
+        return self._number
+
+    @property
+    def value(self) -> str:
+        return self._value
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, FizzBuzzValue):
+            return NotImplemented
+        return self._number == other._number and self._value == other._value
+
+    def __hash__(self) -> int:
+        return hash((self._number, self._value))
+
+    def __repr__(self) -> str:
+        return f"{self._number}:{self._value}"
+```
+
+### テスト
+
+```python
+class TestFizzBuzzValue:
+    def test_値を保持する(self):
+        value = FizzBuzzValue(1, "1")
+        assert value.number == 1
+        assert value.value == "1"
+
+    def test_同じ値は等しい(self):
+        assert FizzBuzzValue(1, "1") == FizzBuzzValue(1, "1")
+
+    def test_文字列表現(self):
+        assert repr(FizzBuzzValue(3, "Fizz")) == "3:Fizz"
+```
+
+### FizzBuzzType の更新
+
+`generate` の戻り値を `str` から `FizzBuzzValue` に変更します。
+
+```python
+class FizzBuzzType01(FizzBuzzType):
+    def generate(self, number: int) -> FizzBuzzValue:
+        if self._is_fizz_buzz(number):
+            return FizzBuzzValue(number, "FizzBuzz")
+        if self._is_fizz(number):
+            return FizzBuzzValue(number, "Fizz")
+        if self._is_buzz(number):
+            return FizzBuzzValue(number, "Buzz")
+        return FizzBuzzValue(number, str(number))
+```
+
+## 8.3 First-Class Collection
+
+FizzBuzz の結果リストを専用クラスで包みます。
+
+```python
+class FizzBuzzList:
+    def __init__(self, values: list[FizzBuzzValue] | None = None) -> None:
+        self._values: list[FizzBuzzValue] = list(values) if values else []
+
+    def add(self, value: FizzBuzzValue) -> None:
+        self._values.append(value)
+
+    def get(self, index: int) -> FizzBuzzValue:
+        return self._values[index]
+
+    def size(self) -> int:
+        return len(self._values)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, FizzBuzzList):
+            return NotImplemented
+        return self._values == other._values
+
+    def __hash__(self) -> int:
+        return hash(tuple(self._values))
+
+    def __repr__(self) -> str:
+        return "[" + ", ".join(repr(v) for v in self._values) + "]"
+```
+
+## 8.4 Command パターン
+
+操作をオブジェクトとしてカプセル化します。
+
+```python
+from abc import ABC, abstractmethod
+
+class FizzBuzzCommand(ABC):
+    @abstractmethod
+    def execute(self) -> FizzBuzzValue | FizzBuzzList:
+        pass
+
+class FizzBuzzValueCommand(FizzBuzzCommand):
+    def __init__(self, type_: FizzBuzzType, number: int) -> None:
+        self._type = type_
+        self._number = number
+
+    def execute(self) -> FizzBuzzValue:
+        return self._type.generate(self._number)
+
+class FizzBuzzListCommand(FizzBuzzCommand):
+    MAX_NUMBER: int = 100
+
+    def __init__(self, type_: FizzBuzzType) -> None:
+        self._type = type_
+
+    def execute(self) -> FizzBuzzList:
+        result = FizzBuzzList()
+        for i in range(1, self.MAX_NUMBER + 1):
+            result.add(self._type.generate(i))
+        return result
+```
+
+## 8.5 Null Object パターン
+
+未定義のタイプに対して例外ではなくデフォルト動作を返します。
+
+```python
+class FizzBuzzTypeNotDefined(FizzBuzzType):
+    def generate(self, number: int) -> FizzBuzzValue:
+        return FizzBuzzValue(number, "")
+```
+
+ファクトリメソッドを更新します。
+
+```python
+@staticmethod
+def create(type_: int) -> "FizzBuzzType":
+    types = {
+        1: FizzBuzzType01,
+        2: FizzBuzzType02,
+        3: FizzBuzzType03,
+    }
+    return types.get(type_, FizzBuzzTypeNotDefined)()
+```
+
+## 8.6 まとめ
+
+| パターン | クラス | 効果 |
+|----------|--------|------|
+| Value Object | `FizzBuzzValue` | 値の意味を明示し、等価性を保証 |
+| First-Class Collection | `FizzBuzzList` | コレクション操作を一元化 |
+| Command | `FizzBuzzValueCommand` / `FizzBuzzListCommand` | 操作と実行を分離 |
+| Null Object | `FizzBuzzTypeNotDefined` | 例外の代わりにデフォルト動作 |
+| Factory Method | `FizzBuzzType.create()` | 生成ロジックの一元化 |
+
+次の章では、SOLID 原則を確認しながらモジュール設計を行います。

package/lib/assets/docs/article/getting-start-tdd/python/09-solid-principles-and-module-design.md

@@ -0,0 +1,130 @@
+# 第 9 章: SOLID 原則とモジュール設計
+
+## 9.1 はじめに
+
+前章までに、FizzBuzz をオブジェクト指向設計で洗練させてきました。この章では、**SOLID 原則** の観点で設計を検証し、**モジュール分割** を行ってパッケージ構造を整理します。
+
+## 9.2 SOLID 原則の確認
+
+### 単一責任の原則（SRP）
+
+| クラス | 責務 | 変更理由 |
+|--------|------|---------|
+| `FizzBuzzType01/02/03` | タイプ別の変換ルール | ルール変更時 |
+| `FizzBuzzValue` | 値の保持と等価性 | 値表現の変更時 |
+| `FizzBuzzList` | コレクション操作 | コレクション仕様変更時 |
+| `FizzBuzzValueCommand` | 単一値の実行 | 実行方法の変更時 |
+| `FizzBuzzListCommand` | リスト生成の実行 | 実行方法の変更時 |
+
+各クラスが 1 つの責務のみを持っていることが確認できます。
+
+### 開放閉鎖の原則（OCP）
+
+新しいタイプ（たとえばタイプ 4）を追加する場合:
+
+1. `FizzBuzzType04` クラスを新規作成
+2. `FizzBuzzType.create()` に 1 行追加
+
+既存のクラスを修正する必要はありません。
+
+### 依存性逆転の原則（DIP）
+
+```
+FizzBuzzValueCommand → FizzBuzzType (抽象) ← FizzBuzzType01/02/03
+FizzBuzzListCommand  → FizzBuzzType (抽象) ← FizzBuzzType01/02/03
+```
+
+上位モジュール（Command）は抽象（FizzBuzzType）に依存し、具象クラスには直接依存しません。
+
+## 9.3 パッケージ設計
+
+責務に基づいてモジュールを分割します。
+
+### ディレクトリ構成
+
+```
+apps/python/
+├── lib/
+│   ├── __init__.py
+│   ├── domain/
+│   │   ├── __init__.py
+│   │   ├── model/
+│   │   │   ├── __init__.py
+│   │   │   ├── fizz_buzz_value.py
+│   │   │   └── fizz_buzz_list.py
+│   │   └── type/
+│   │       ├── __init__.py
+│   │       ├── fizz_buzz_type.py
+│   │       ├── fizz_buzz_type_01.py
+│   │       ├── fizz_buzz_type_02.py
+│   │       ├── fizz_buzz_type_03.py
+│   │       └── fizz_buzz_type_not_defined.py
+│   └── application/
+│       ├── __init__.py
+│       ├── fizz_buzz_command.py
+│       ├── fizz_buzz_value_command.py
+│       └── fizz_buzz_list_command.py
+├── test/
+│   ├── __init__.py
+│   ├── domain/
+│   │   ├── __init__.py
+│   │   ├── model/
+│   │   │   ├── __init__.py
+│   │   │   ├── test_fizz_buzz_value.py
+│   │   │   └── test_fizz_buzz_list.py
+│   │   └── type/
+│   │       ├── __init__.py
+│   │       └── test_fizz_buzz_type.py
+│   └── application/
+│       ├── __init__.py
+│       └── test_fizz_buzz_command.py
+└── main.py
+```
+
+### パッケージ依存関係
+
+```
+application → domain.type → domain.model
+```
+
+- `domain` は `application` に依存しない（単方向依存）
+- ビジネスロジック（domain）がアプリケーション層から独立
+
+## 9.4 エントリポイントの更新
+
+```python
+# main.py
+from lib.application.fizz_buzz_list_command import FizzBuzzListCommand
+from lib.domain.type.fizz_buzz_type import FizzBuzzType
+
+if __name__ == "__main__":
+    type_ = FizzBuzzType.create(1)
+    command = FizzBuzzListCommand(type_)
+    result = command.execute()
+    for i in range(result.size()):
+        print(result.get(i))
+```
+
+## 9.5 まとめ
+
+### 第 3 部の振り返り
+
+| 章 | テーマ | 適用した技法 |
+|----|--------|------------|
+| 7 | カプセル化とポリモーフィズム | `@property`、`abc.ABC`、`@abstractmethod`、Factory Method |
+| 8 | デザインパターン | Value Object、First-Class Collection、Command、Null Object |
+| 9 | SOLID 原則とモジュール設計 | SRP、OCP、DIP、パッケージ分割 |
+
+### リファクタリングの進化
+
+```
+第 1 部: 手続き的な FizzBuzz（1 クラス）
+    ↓
+第 3 部 章 7: ポリモーフィズム（FizzBuzzType 階層）
+    ↓
+第 3 部 章 8: デザインパターン（Value Object、Command）
+    ↓
+第 3 部 章 9: モジュール設計（domain/application 分離）
+```
+
+次の第 4 部では、関数型プログラミング（高階関数、デコレータ、ジェネレータ）を FizzBuzz に適用します。

package/lib/assets/docs/article/getting-start-tdd/python/10-higher-order-functions-and-composition.md

@@ -0,0 +1,122 @@
+# 第 10 章: 高階関数と関数合成
+
+## 10.1 はじめに
+
+第 3 部でオブジェクト指向設計を完成させました。第 4 部では、Python の **関数型プログラミング** 機能を FizzBuzz に適用します。この章では、**高階関数** と **関数合成** を導入し、命令的なコードを宣言的に書き換えます。
+
+## 10.2 ラムダ式
+
+Python では `lambda` キーワードで無名関数を定義できます。
+
+```python
+# 通常の関数定義
+def double(x: int) -> int:
+    return x * 2
+
+# ラムダ式
+double = lambda x: x * 2
+```
+
+## 10.3 組み込み高階関数
+
+Python には `map()`、`filter()`、`sorted()` などの高階関数が組み込まれています。
+
+```python
+numbers = [1, 2, 3, 4, 5]
+
+# map: 各要素を変換
+doubled = list(map(lambda x: x * 2, numbers))
+
+# filter: 条件に合う要素を抽出
+evens = list(filter(lambda x: x % 2 == 0, numbers))
+
+# sorted: カスタムキーでソート
+sorted(numbers, key=lambda x: -x)
+```
+
+## 10.4 リスト内包表記
+
+Python では、`map()` + `filter()` の代わりに **リスト内包表記** がよく使われます。
+
+```python
+# map + filter 相当
+result = [x * 2 for x in numbers if x % 2 == 0]
+```
+
+## 10.5 FizzBuzzListCommand のリファクタリング
+
+従来のループを関数型スタイルに書き換えます。
+
+### Before（命令的）
+
+```python
+def execute(self) -> FizzBuzzList:
+    result = FizzBuzzList()
+    for i in range(1, self.MAX_NUMBER + 1):
+        result.add(self._type.generate(i))
+    return result
+```
+
+### After（関数型）
+
+```python
+def execute(self) -> FizzBuzzList:
+    values = [self._type.generate(i) for i in range(1, self.MAX_NUMBER + 1)]
+    return FizzBuzzList(values)
+```
+
+## 10.6 FizzBuzzList にフィルタリングを追加
+
+特定の条件に合う値だけを抽出するメソッドを追加します。
+
+```python
+from collections.abc import Callable
+
+class FizzBuzzList:
+    def filter(self, predicate: Callable[[FizzBuzzValue], bool]) -> "FizzBuzzList":
+        return FizzBuzzList([v for v in self._values if predicate(v)])
+```
+
+### テスト
+
+```python
+def test_Fizzだけをフィルタリングする(self) -> None:
+    type_ = FizzBuzzType.create(1)
+    command = FizzBuzzListCommand(type_)
+    result = command.execute()
+    fizzes = result.filter(lambda v: v.value == "Fizz")
+    assert fizzes.size() > 0
+    assert all(fizzes.get(i).value == "Fizz" for i in range(fizzes.size()))
+```
+
+## 10.7 関数合成
+
+`functools` モジュールを使って関数を合成します。
+
+```python
+from functools import reduce
+
+def compose(*funcs):
+    """右から左に関数を合成する。"""
+    return reduce(lambda f, g: lambda x: f(g(x)), funcs)
+```
+
+### FizzBuzzList での文字列変換
+
+```python
+class FizzBuzzList:
+    def to_formatted_string(self, separator: str = "\n") -> str:
+        return separator.join(repr(v) for v in self._values)
+```
+
+## 10.8 まとめ
+
+| 概念 | Java | Python |
+|------|------|--------|
+| ラムダ式 | `(x) -> x * 2` | `lambda x: x * 2` |
+| map | `stream.map()` | `map()` / リスト内包表記 |
+| filter | `stream.filter()` | `filter()` / リスト内包表記 |
+| reduce | `stream.reduce()` | `functools.reduce()` |
+| 関数合成 | `f.andThen(g)` | `compose(f, g)` |
+
+次の章では、不変データとパイプライン処理を適用します。