@k2works/claude-code-booster 6.1.0 → 6.3.0

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

@@ -1,217 +0,0 @@
----
-type: Article
-title: "第 7 章: カプセル化とポリモーフィズム"
-description: "第 1〜2 部で FizzBuzz の基本実装と開発環境を整えました。"
-tags: [article, getting-start-tdd, python]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 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

@@ -1,181 +0,0 @@
----
-type: Article
-title: "第 8 章: デザインパターンの適用"
-description: "前章では、カプセル化とポリモーフィズムで if/elif の連鎖を排除しました。"
-tags: [article, getting-start-tdd, python]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 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

@@ -1,139 +0,0 @@
----
-type: Article
-title: "第 9 章: SOLID 原則とモジュール設計"
-description: "前章までに、FizzBuzz をオブジェクト指向設計で洗練させてきました。"
-tags: [article, getting-start-tdd, python]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 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

@@ -1,131 +0,0 @@
----
-type: Article
-title: "第 10 章: 高階関数と関数合成"
-description: "第 3 部でオブジェクト指向設計を完成させました。"
-tags: [article, getting-start-tdd, python]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 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)` |
-
-次の章では、不変データとパイプライン処理を適用します。