@k2works/claude-code-booster 3.0.0 → 3.1.0

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

@@ -0,0 +1,188 @@
+# 第 10 章: 高階関数と関数合成
+
+## 10.1 はじめに
+
+第 3 部では、手続き型の FizzBuzz をオブジェクト指向設計に変換しました。この第 4 部では、Java の **関数型プログラミング** 機能を活用して、さらにコードを発展させます。
+
+Java 8 以降で導入された主要な関数型機能:
+
+| 機能 | 説明 |
+|------|------|
+| Lambda 式 | 匿名関数を簡潔に記述 |
+| メソッド参照 | 既存メソッドを関数として渡す |
+| `Function` インターフェース | 関数を値として扱う |
+| Stream API | コレクションの宣言的処理 |
+
+## 10.2 Lambda 式とメソッド参照
+
+### Lambda 式
+
+Lambda 式を使うと、関数を値として変数に代入したり、引数として渡したりできます。
+
+```java
+// 従来の匿名クラス
+Comparator<FizzBuzzValue> comparator = new Comparator<FizzBuzzValue>() {
+    @Override
+    public int compare(FizzBuzzValue a, FizzBuzzValue b) {
+        return Integer.compare(a.getNumber(), b.getNumber());
+    }
+};
+
+// Lambda 式
+Comparator<FizzBuzzValue> comparator =
+    (a, b) -> Integer.compare(a.getNumber(), b.getNumber());
+```
+
+### メソッド参照
+
+メソッド参照は Lambda 式をさらに簡潔に書く記法です。
+
+```java
+// Lambda 式
+values.stream().map(v -> v.getValue());
+
+// メソッド参照
+values.stream().map(FizzBuzzValue::getValue);
+```
+
+| 種類 | 構文 | 例 |
+|------|------|-----|
+| 静的メソッド | `クラス::メソッド` | `Integer::parseInt` |
+| インスタンスメソッド | `オブジェクト::メソッド` | `type::generate` |
+| 任意オブジェクトのメソッド | `クラス::メソッド` | `FizzBuzzValue::getValue` |
+| コンストラクタ | `クラス::new` | `ArrayList::new` |
+
+## 10.3 Function インターフェース
+
+`java.util.function` パッケージには、関数を型として表現するインターフェースが用意されています。
+
+| インターフェース | シグネチャ | 用途 |
+|----------------|-----------|------|
+| `Function<T, R>` | `R apply(T t)` | 変換 |
+| `Predicate<T>` | `boolean test(T t)` | 条件判定 |
+| `Consumer<T>` | `void accept(T t)` | 副作用のある操作 |
+| `Supplier<T>` | `T get()` | 値の生成 |
+| `UnaryOperator<T>` | `T apply(T t)` | 同じ型への変換 |
+
+### FizzBuzz での活用
+
+`FizzBuzzType` の `generate` メソッドは `int → FizzBuzzValue` の関数です。これを `IntFunction` として表現できます。
+
+```java
+import java.util.function.IntFunction;
+
+// FizzBuzzType.generate は IntFunction<FizzBuzzValue> と同じシグネチャ
+IntFunction<FizzBuzzValue> generator = type::generate;
+FizzBuzzValue result = generator.apply(15);
+```
+
+## 10.4 Stream API の基本
+
+### for ループから Stream へ
+
+`FizzBuzzListCommand` の `executeList` メソッドを Stream API でリファクタリングします。
+
+```java
+// Before: for ループ
+public FizzBuzzList executeList(int count) {
+    List<FizzBuzzValue> values = new ArrayList<>();
+    for (int i = 1; i <= count; i++) {
+        values.add(type.generate(i));
+    }
+    return new FizzBuzzList(values);
+}
+
+// After: Stream API
+public FizzBuzzList executeList(int count) {
+    List<FizzBuzzValue> values = IntStream.rangeClosed(1, count)
+        .mapToObj(type::generate)
+        .collect(Collectors.toList());
+    return new FizzBuzzList(values);
+}
+```
+
+### Stream の 3 ステップ
+
+1. **生成**: `IntStream.rangeClosed(1, count)` — 1 から count までの数列
+2. **中間操作**: `.mapToObj(type::generate)` — 各数値を FizzBuzzValue に変換
+3. **終端操作**: `.collect(Collectors.toList())` — リストに集約
+
+## 10.5 関数合成
+
+### compose と andThen
+
+`Function` インターフェースは関数を合成するメソッドを持っています。
+
+```java
+Function<Integer, FizzBuzzValue> generate = type::generate;
+Function<FizzBuzzValue, String> getValue = FizzBuzzValue::getValue;
+
+// andThen: generate した後に getValue を実行
+Function<Integer, String> generateAndGetValue =
+    generate.andThen(getValue);
+
+String result = generateAndGetValue.apply(15); // "FizzBuzz"
+```
+
+### Predicate の合成
+
+```java
+Predicate<FizzBuzzValue> isFizz =
+    v -> v.getValue().equals("Fizz");
+Predicate<FizzBuzzValue> isBuzz =
+    v -> v.getValue().equals("Buzz");
+
+// or: Fizz または Buzz
+Predicate<FizzBuzzValue> isFizzOrBuzz = isFizz.or(isBuzz);
+
+// and + negate: Fizz でも Buzz でもない
+Predicate<FizzBuzzValue> isNumber =
+    isFizz.negate().and(isBuzz.negate());
+```
+
+## 10.6 Stream API を使ったフィルタリング
+
+Stream API と Predicate を組み合わせて、FizzBuzzList にフィルタリング機能を追加します。
+
+```java
+// FizzBuzzList にメソッドを追加
+public FizzBuzzList filter(Predicate<FizzBuzzValue> predicate) {
+    List<FizzBuzzValue> filtered = values.stream()
+        .filter(predicate)
+        .collect(Collectors.toList());
+    return new FizzBuzzList(filtered);
+}
+```
+
+使用例:
+
+```java
+FizzBuzzList list = listCommand.executeList(100);
+
+// Fizz だけを抽出
+FizzBuzzList fizzOnly = list.filter(
+    v -> v.getValue().equals("Fizz")
+);
+
+// 数値だけを抽出（Fizz でも Buzz でも FizzBuzz でもない）
+FizzBuzzList numbersOnly = list.filter(
+    v -> !v.getValue().equals("Fizz")
+        && !v.getValue().equals("Buzz")
+        && !v.getValue().equals("FizzBuzz")
+);
+```
+
+## 10.7 まとめ
+
+この章では Java の関数型プログラミングの基礎を学びました。
+
+| 概念 | 適用 |
+|------|------|
+| Lambda 式 | 匿名関数の簡潔な記述 |
+| メソッド参照 | `type::generate`、`FizzBuzzValue::getValue` |
+| Function インターフェース | 関数を値として扱う |
+| Stream API | for ループの宣言的な置き換え |
+| 関数合成 | `andThen`、`compose` による関数の連結 |
+| Predicate 合成 | `and`、`or`、`negate` による条件の組み合わせ |
+
+次の第 11 章では、Stream API をさらに活用してパイプライン処理を構築し、不変データの操作パターンを深掘りします。

package/lib/assets/docs/article/getting-start-tdd/java/11-immutable-data-and-pipeline.md

@@ -0,0 +1,167 @@
+# 第 11 章: 不変データとパイプライン処理
+
+## 11.1 はじめに
+
+前章では Lambda 式、メソッド参照、Stream API の基本を学びました。この章では **不変データ** の設計パターンを深掘りし、**パイプライン処理** でデータを宣言的に変換する手法を学びます。
+
+## 11.2 不変データの原則
+
+### なぜ不変性が重要か
+
+> 変更可能なデータはしばしば予期せぬ結果や、厄介なバグを引き起こします。そのため、関数型プログラミングは、データは不変であるべきで、更新時は常に元データ構造のコピーを返すようにし、元データには手を触れないという思想に基づいています。
+>
+> — Martin Fowler「リファクタリング（第 2 版）」
+
+### FizzBuzz における不変設計の確認
+
+第 8 章で作成した `FizzBuzzValue` と `FizzBuzzList` は既に不変設計です。
+
+| クラス | 不変性の実装 |
+|--------|------------|
+| `FizzBuzzValue` | `final` フィールド、setter なし |
+| `FizzBuzzList` | 防御的コピー、`add()` が新しいインスタンスを返す |
+
+```java
+// FizzBuzzList.add() は元のリストを変更しない
+FizzBuzzList original = listCommand.executeList(10);
+FizzBuzzList extended = original.add(newValues);
+
+// original は変更されていない
+assert original.size() == 10;
+```
+
+## 11.3 Stream パイプラインの構築
+
+### パイプラインとは
+
+Stream API のパイプラインは、データに対する一連の変換を宣言的に記述する仕組みです。
+
+```
+データソース → 中間操作 → 中間操作 → ... → 終端操作
+```
+
+### FizzBuzzList にパイプライン操作を追加
+
+```java
+// map: 各要素を変換
+public <R> List<R> map(Function<FizzBuzzValue, R> mapper) {
+    return values.stream()
+        .map(mapper)
+        .collect(Collectors.toList());
+}
+
+// toStringValues: 値の文字列リストを取得
+public List<String> toStringValues() {
+    return values.stream()
+        .map(FizzBuzzValue::getValue)
+        .collect(Collectors.toList());
+}
+```
+
+### Collectors の活用
+
+```java
+// グルーピング: 値の種類ごとに分類
+public Map<String, List<FizzBuzzValue>> groupByValue() {
+    return values.stream()
+        .collect(Collectors.groupingBy(FizzBuzzValue::getValue));
+}
+
+// カウント: 値の種類ごとの出現回数
+public Map<String, Long> countByValue() {
+    return values.stream()
+        .collect(Collectors.groupingBy(
+            FizzBuzzValue::getValue,
+            Collectors.counting()
+        ));
+}
+
+// 結合: カンマ区切りの文字列に変換
+public String joining(String delimiter) {
+    return values.stream()
+        .map(FizzBuzzValue::getValue)
+        .collect(Collectors.joining(delimiter));
+}
+```
+
+## 11.4 IntStream によるリスト生成
+
+### executeList のリファクタリング
+
+`FizzBuzzListCommand.executeList` を `IntStream` でリファクタリングします。
+
+```java
+// Before: for ループ
+public FizzBuzzList executeList(int count) {
+    List<FizzBuzzValue> values = new ArrayList<>();
+    for (int i = 1; i <= count; i++) {
+        values.add(type.generate(i));
+    }
+    return new FizzBuzzList(values);
+}
+
+// After: IntStream パイプライン
+public FizzBuzzList executeList(int count) {
+    List<FizzBuzzValue> values = IntStream.rangeClosed(1, count)
+        .mapToObj(type::generate)
+        .collect(Collectors.toList());
+    return new FizzBuzzList(values);
+}
+```
+
+### Stream 操作の組み合わせ
+
+```java
+// 1〜100 の FizzBuzz で "Fizz" の出現回数を数える
+long fizzCount = IntStream.rangeClosed(1, 100)
+    .mapToObj(type::generate)
+    .map(FizzBuzzValue::getValue)
+    .filter("Fizz"::equals)
+    .count();
+```
+
+## 11.5 reduce による集約
+
+### 基本的な reduce
+
+```java
+// 数値の合計を計算（FizzBuzz の数値のみ）
+int sum = IntStream.rangeClosed(1, 100)
+    .mapToObj(type::generate)
+    .filter(v -> v.getValue().matches("\\d+"))
+    .mapToInt(FizzBuzzValue::getNumber)
+    .sum();
+```
+
+### FizzBuzzList での reduce 活用
+
+```java
+// FizzBuzzList に統計情報を追加
+public FizzBuzzListStats getStats() {
+    long fizzCount = values.stream()
+        .filter(v -> "Fizz".equals(v.getValue())).count();
+    long buzzCount = values.stream()
+        .filter(v -> "Buzz".equals(v.getValue())).count();
+    long fizzBuzzCount = values.stream()
+        .filter(v -> "FizzBuzz".equals(v.getValue())).count();
+    long numberCount = values.stream()
+        .filter(v -> v.getValue().matches("\\d+")).count();
+
+    return new FizzBuzzListStats(
+        fizzCount, buzzCount, fizzBuzzCount, numberCount);
+}
+```
+
+## 11.6 まとめ
+
+この章では不変データとパイプライン処理を学びました。
+
+| 概念 | 適用 |
+|------|------|
+| 不変データ | `FizzBuzzValue`、`FizzBuzzList` の不変設計を確認 |
+| パイプライン | Stream の中間操作・終端操作の連鎖 |
+| IntStream | `rangeClosed` による数列生成 |
+| Collectors | `groupingBy`、`counting`、`joining` による集約 |
+| reduce / sum | 統計情報の算出 |
+
+次の第 12 章では、`Optional` によるエラーハンドリングと型安全性を学びます。

package/lib/assets/docs/article/getting-start-tdd/java/12-error-handling-and-type-safety.md

@@ -0,0 +1,205 @@
+# 第 12 章: エラーハンドリングと型安全性
+
+## 12.1 はじめに
+
+前章までで Stream API とパイプライン処理を学びました。この章では、`Optional` を使った **null 安全** なコードの書き方と、**型安全** なファクトリパターンを学びます。
+
+## 12.2 Optional による null 安全
+
+### null の問題
+
+`null` は「値がない」ことを表現しますが、NullPointerException の原因になります。
+
+```java
+// 危険: null チェック忘れ
+FizzBuzzValue value = map.get(key); // null の可能性
+String result = value.getValue();    // NullPointerException!
+```
+
+### Optional の基本
+
+`Optional` は「値があるかもしれないし、ないかもしれない」を型で表現します。
+
+```java
+// Optional の生成
+Optional<FizzBuzzValue> present = Optional.of(value);      // 値あり
+Optional<FizzBuzzValue> empty = Optional.empty();           // 値なし
+Optional<FizzBuzzValue> nullable = Optional.ofNullable(v);  // null 許容
+```
+
+### Optional の操作
+
+```java
+Optional<FizzBuzzValue> opt = Optional.of(type.generate(15));
+
+// map: 値を変換
+Optional<String> result = opt.map(FizzBuzzValue::getValue);
+
+// filter: 条件に合わなければ empty
+Optional<FizzBuzzValue> fizz = opt
+    .filter(v -> "Fizz".equals(v.getValue()));
+
+// orElse: 値がなければデフォルト値
+String value = opt.map(FizzBuzzValue::getValue)
+    .orElse("unknown");
+
+// orElseThrow: 値がなければ例外
+String value = opt.map(FizzBuzzValue::getValue)
+    .orElseThrow(() ->
+        new IllegalStateException("値が存在しません"));
+```
+
+## 12.3 FizzBuzzType ファクトリの改善
+
+### 現在の実装: 例外スロー
+
+```java
+public static FizzBuzzType create(int type) {
+    switch (type) {
+        case 1: return new FizzBuzzType01();
+        case 2: return new FizzBuzzType02();
+        case 3: return new FizzBuzzType03();
+        default:
+            throw new IllegalArgumentException(
+                "該当するタイプは存在しません");
+    }
+}
+```
+
+### Optional を使った安全なファクトリ
+
+```java
+public static Optional<FizzBuzzType> createOptional(int type) {
+    switch (type) {
+        case 1: return Optional.of(new FizzBuzzType01());
+        case 2: return Optional.of(new FizzBuzzType02());
+        case 3: return Optional.of(new FizzBuzzType03());
+        default: return Optional.empty();
+    }
+}
+```
+
+使用例:
+
+```java
+// パターン 1: デフォルト値を指定
+FizzBuzzType type = FizzBuzzType.createOptional(4)
+    .orElse(FizzBuzzType.create(1));
+
+// パターン 2: Optional のまま操作
+FizzBuzzType.createOptional(1)
+    .map(t -> t.generate(15))
+    .map(FizzBuzzValue::getValue)
+    .ifPresent(System.out::println);
+```
+
+## 12.4 FizzBuzzList の検索機能
+
+### find: 最初の一致を Optional で返す
+
+```java
+// FizzBuzzList にメソッドを追加
+public Optional<FizzBuzzValue> findFirst(
+        Predicate<FizzBuzzValue> predicate) {
+    return values.stream()
+        .filter(predicate)
+        .findFirst();
+}
+```
+
+使用例:
+
+```java
+FizzBuzzList list = listCommand.executeList(100);
+
+// 最初の FizzBuzz を検索
+Optional<FizzBuzzValue> firstFizzBuzz = list.findFirst(
+    v -> "FizzBuzz".equals(v.getValue())
+);
+
+// 値があれば表示、なければ "none"
+String result = firstFizzBuzz
+    .map(FizzBuzzValue::toString)
+    .orElse("none");
+```
+
+## 12.5 型安全な列挙型ファクトリ
+
+### enum を使った型安全なタイプ指定
+
+```java
+public enum FizzBuzzTypeName {
+    STANDARD(1),
+    NUMBER_ONLY(2),
+    FIZZBUZZ_ONLY(3);
+
+    private final int code;
+
+    FizzBuzzTypeName(int code) {
+        this.code = code;
+    }
+
+    public int getCode() {
+        return code;
+    }
+}
+```
+
+ファクトリメソッドを enum で受け取るバージョン:
+
+```java
+public static FizzBuzzType create(FizzBuzzTypeName name) {
+    return create(name.getCode());
+}
+```
+
+使用例:
+
+```java
+// Before: マジックナンバー
+FizzBuzzType type = FizzBuzzType.create(1);
+
+// After: 型安全な列挙型
+FizzBuzzType type = FizzBuzzType.create(FizzBuzzTypeName.STANDARD);
+```
+
+## 12.6 全体の振り返り
+
+### 第 4 部で学んだこと
+
+| 章 | テーマ | 学んだこと |
+|----|--------|-----------|
+| 10 | 高階関数と関数合成 | Lambda 式、メソッド参照、Function、Stream 基本 |
+| 11 | 不変データとパイプライン処理 | 不変設計、IntStream、Collectors、パイプライン |
+| 12 | エラーハンドリングと型安全性 | Optional、型安全なファクトリ、enum |
+
+### 全 12 章の総括
+
+```
+第 1 部（章 1-3）: TDD の基本サイクル
+  → Red-Green-Refactor、テストファースト
+
+第 2 部（章 4-6）: 開発環境と自動化
+  → Git、静的解析、CI/CD
+
+第 3 部（章 7-9）: オブジェクト指向設計
+  → ポリモーフィズム、デザインパターン、SOLID
+
+第 4 部（章 10-12）: 関数型プログラミング
+  → Lambda、Stream、Optional
+```
+
+TDD の規律を守りながら、手続き型 → OOP → FP と段階的にコードを改善しました。これは「動作するきれいなコード」を目指す TDD の本質です。
+
+## 12.7 まとめ
+
+| 概念 | 適用 |
+|------|------|
+| Optional | null 安全な値の表現と操作 |
+| Optional ファクトリ | `createOptional` で例外を回避 |
+| findFirst | Stream + Optional による安全な検索 |
+| enum ファクトリ | マジックナンバーの排除と型安全性 |
+
+> **よいソフトウェアとは、変更を楽に安全にできて役に立つソフトウェアである。**
+>
+> TDD の規律と、オブジェクト指向・関数型の設計技法を組み合わせることで、この目標に近づくことができます。

package/lib/assets/docs/article/getting-start-tdd/java/index.md

@@ -0,0 +1,61 @@
+# テスト駆動開発から始める Java 入門
+
+## 概要
+
+FizzBuzz 問題を題材に、テスト駆動開発（TDD）の基本サイクルから、開発環境の整備、オブジェクト指向設計、関数型プログラミングの活用まで、Java の特徴を活かしながら段階的に学びます。
+
+## 対象読者
+
+- Java の基本文法を理解しているプログラミング学習者
+- TDD を体験してみたい開発者
+- オブジェクト指向設計や関数型プログラミングに興味がある方
+
+## 前提条件
+
+- JDK 11 以降がインストールされていること
+- Gradle が利用可能であること（Nix 環境推奨: `nix develop .#java`）
+
+## 目次
+
+### 第 1 部: TDD の基本サイクル
+
+1. [第 1 章: TODO リストと最初のテスト](01-todo-list-and-first-test.md)
+2. [第 2 章: 仮実装と三角測量](02-fake-it-and-triangulation.md)
+3. [第 3 章: 明白な実装とリファクタリング](03-obvious-implementation-and-refactoring.md)
+
+### 第 2 部: 開発環境と自動化
+
+4. [第 4 章: バージョン管理と Conventional Commits](04-version-control-and-conventional-commits.md)
+5. [第 5 章: パッケージ管理と静的解析](05-package-management-and-static-analysis.md)
+6. [第 6 章: タスクランナーと CI/CD](06-task-runner-and-ci-cd.md)
+
+### 第 3 部: オブジェクト指向設計
+
+7. [第 7 章: カプセル化とポリモーフィズム](07-encapsulation-and-polymorphism.md)
+8. [第 8 章: デザインパターンの適用](08-design-patterns.md)
+9. [第 9 章: SOLID 原則とモジュール設計](09-solid-principles-and-module-design.md)
+
+### 第 4 部: 関数型プログラミングへの展開
+
+10. [第 10 章: 高階関数と関数合成](10-higher-order-functions-and-composition.md)
+11. [第 11 章: 不変データとパイプライン処理](11-immutable-data-and-pipeline.md)
+12. [第 12 章: エラーハンドリングと型安全性](12-error-handling-and-type-safety.md)
+
+## 実装コード
+
+本記事のすべてのコード例は `apps/java/` に実装されています。
+
+```bash
+# 開発環境に入る
+nix develop .#java
+
+# テスト実行
+cd apps/java
+./gradlew test
+```
+
+## 参考文献
+
+- Kent Beck 著『テスト駆動開発』
+- Martin Fowler 著『リファクタリング: 既存のコードを安全に改善する』
+- Robert C. Martin 著『Clean Code: アジャイルソフトウェア達人の技』