@k2works/claude-code-booster 2.7.1 → 3.1.0

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

@@ -0,0 +1,110 @@
+# 第 9 章: SOLID 原則とモジュール設計
+
+## 9.1 はじめに
+
+前章ではデザインパターンを適用して設計を改善しました。この章では **SOLID 原則** の観点から設計を評価し、**モジュール分割** によってコードの責務を明確にします。
+
+## 9.2 SOLID 原則の適用
+
+### 単一責任の原則（SRP）
+
+| モジュール | 責務 |
+|-----------|------|
+| `domain::types` | FizzBuzz タイプの定義と生成ルール |
+| `domain::model` | 値オブジェクトとコレクション |
+| `application` | コマンドの実行と結果の出力 |
+
+### 開放閉鎖の原則（OCP）
+
+`FizzBuzzType` トレイトを実装する新しい構造体を追加するだけで、既存のコードを変更せずに新しいタイプを追加できます。
+
+### リスコフの置換の原則（LSP）
+
+`FizzBuzzType` トレイトを実装するすべての構造体は、`Box<dyn FizzBuzzType>` として交換可能です。
+
+### インターフェース分離の原則（ISP）
+
+`FizzBuzzType` トレイトは `generate` メソッドのみを定義しており、不必要なメソッドを強制しません。
+
+### 依存性逆転の原則（DIP）
+
+`FizzBuzzCommand` は具体的な `FizzBuzzType01` ではなく `Box<dyn FizzBuzzType>` に依存しています。
+
+## 9.3 モジュール分割
+
+### ディレクトリ構成
+
+```
+src/
+├── lib.rs                    (ライブラリルート)
+├── main.rs                   (エントリポイント)
+├── fizz_buzz.rs              (公開 API + ファクトリ)
+├── domain/
+│   ├── mod.rs
+│   ├── model/
+│   │   ├── mod.rs
+│   │   ├── fizz_buzz_value.rs
+│   │   └── fizz_buzz_list.rs
+│   └── types/
+│       ├── mod.rs
+│       ├── fizz_buzz_type.rs
+│       ├── fizz_buzz_type01.rs
+│       ├── fizz_buzz_type02.rs
+│       └── fizz_buzz_type03.rs
+└── application/
+    ├── mod.rs
+    ├── fizz_buzz_command.rs
+    ├── fizz_buzz_value_command.rs
+    └── fizz_buzz_list_command.rs
+```
+
+### Rust のモジュールシステム
+
+Rust の `mod` キーワードはモジュールを定義し、`pub` で公開/非公開を制御します。
+
+```rust
+// src/lib.rs
+pub mod domain;
+pub mod application;
+pub mod fizz_buzz;
+```
+
+```rust
+// src/domain/mod.rs
+pub mod model;
+pub mod types;
+```
+
+Go のパッケージシステム（大文字/小文字による公開制御）に対して、Rust では `pub` キーワードで明示的にアイテムを公開します。Java の `public`/`private` に近い感覚です。
+
+## 9.4 依存関係
+
+```
+application → domain::types
+application → domain::model
+domain::model ← domain::types
+```
+
+- `application` は `domain` に依存
+- `domain::types` は `domain::model` に依存（`FizzBuzzValue` を生成）
+- 逆方向の依存は存在しない（単方向依存）
+
+## 9.5 まとめ
+
+この章では以下を実現しました。
+
+| 原則 | 適用内容 |
+|------|---------|
+| SRP | types / model / application の責務分離 |
+| OCP | trait による拡張ポイント |
+| LSP | Box<dyn FizzBuzzType> による交換可能性 |
+| ISP | 最小限のトレイト定義 |
+| DIP | トレイトオブジェクトによる依存の抽象化 |
+
+| モジュール | 責務 | 含まれる型 |
+|-----------|------|-----------|
+| `domain::types` | FizzBuzz 生成ルール | FizzBuzzType, Type01-03 |
+| `domain::model` | 値オブジェクト | FizzBuzzValue, FizzBuzzList |
+| `application` | コマンド実行 | FizzBuzzCommand, ValueCommand, ListCommand |
+
+第 3 部を通じて、Rust のトレイト、構造体、モジュールシステムを使ったオブジェクト指向的な設計を学びました。次の第 4 部では、Rust の関数型プログラミング機能（クロージャ、イテレータ、Result/Option）を活用します。

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

@@ -0,0 +1,94 @@
+# 第 10 章: 高階関数と関数合成
+
+## 10.1 はじめに
+
+Rust は関数型プログラミングの機能を豊富にサポートしています。この章では **クロージャ** と **イテレータ** を中心に、高階関数と関数合成の考え方を学びます。
+
+## 10.2 クロージャ
+
+Rust のクロージャは環境をキャプチャする無名関数です。`Fn`、`FnMut`、`FnOnce` の 3 つのトレイトに分類されます。
+
+```rust
+// クロージャの基本
+let add = |a: i32, b: i32| a + b;
+assert_eq!(5, add(2, 3));
+
+// 環境のキャプチャ
+let factor = 3;
+let is_multiple = |n: i32| n % factor == 0;
+assert!(is_multiple(9));
+```
+
+PHP のアロー関数 `fn($x) => $x * 2` や Go のクロージャに相当しますが、Rust のクロージャは所有権の観点から 3 種類に分類される点が独特です。
+
+## 10.3 イテレータと高階関数
+
+### map — 要素の変換
+
+```rust
+let values: Vec<String> = list.value().iter()
+    .map(|v| v.value().to_string())
+    .collect();
+```
+
+### filter — 要素の選別
+
+```rust
+let fizz_values: Vec<&FizzBuzzValue> = list.value().iter()
+    .filter(|v| v.value() == "Fizz")
+    .collect();
+```
+
+### find — 最初の一致要素
+
+```rust
+let first_buzz = list.value().iter()
+    .find(|v| v.value() == "Buzz");
+```
+
+### any / all — 条件判定
+
+```rust
+let has_fizzbuzz = list.value().iter()
+    .any(|v| v.value() == "FizzBuzz");
+
+let all_non_empty = list.value().iter()
+    .all(|v| !v.value().is_empty());
+```
+
+## 10.4 FizzBuzzList への関数型メソッド追加
+
+```rust
+impl FizzBuzzList {
+    pub fn filter_by_value(&self, target: &str) -> Vec<&FizzBuzzValue> {
+        self.list.iter().filter(|v| v.value() == target).collect()
+    }
+
+    pub fn map_values(&self) -> Vec<String> {
+        self.list.iter().map(|v| v.value().to_string()).collect()
+    }
+
+    pub fn find_first(&self, target: &str) -> Option<&FizzBuzzValue> {
+        self.list.iter().find(|v| v.value() == target)
+    }
+
+    pub fn any_match(&self, target: &str) -> bool {
+        self.list.iter().any(|v| v.value() == target)
+    }
+
+    pub fn all_match(&self, predicate: impl Fn(&FizzBuzzValue) -> bool) -> bool {
+        self.list.iter().all(|v| predicate(v))
+    }
+}
+```
+
+## 10.5 まとめ
+
+| 概念 | Rust | PHP | Go |
+|------|------|-----|-----|
+| クロージャ | `\|x\| x * 2` | `fn($x) => $x * 2` | `func(x int) int { return x * 2 }` |
+| map | `.iter().map(f).collect()` | `array_map(f, $arr)` | `for` + `append` |
+| filter | `.iter().filter(f).collect()` | `array_filter($arr, f)` | `for` + `if` + `append` |
+| find | `.iter().find(f)` → `Option` | — | `for` + `if` + `return` |
+
+次章では、イテレータチェーンによるパイプライン処理と不変データの考え方を学びます。

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

@@ -0,0 +1,105 @@
+# 第 11 章: 不変データとパイプライン処理
+
+## 11.1 はじめに
+
+前章ではクロージャとイテレータを使った高階関数を学びました。この章では **イテレータチェーン** によるパイプライン処理と **不変データ** の考え方を深めます。
+
+## 11.2 Rust の不変性
+
+Rust では変数はデフォルトで不変（immutable）です。
+
+```rust
+let x = 5;       // 不変（デフォルト）
+let mut y = 10;  // 可変（明示的）
+```
+
+`FizzBuzzValue` は `#[derive(Clone)]` で値のコピーが可能ですが、フィールドは非公開なため外部から変更できません。これにより不変性が自然に保証されます。
+
+## 11.3 イテレータチェーン（パイプライン）
+
+Rust のイテレータは **遅延評価** され、チェーンで連結できます。
+
+```rust
+// パイプライン: filter → map → collect
+let fizz_numbers: Vec<i32> = list.value().iter()
+    .filter(|v| v.value() == "Fizz")
+    .map(|v| v.number())
+    .collect();
+```
+
+### fold（集約）
+
+```rust
+// 全 FizzBuzz 値を改行区切りで連結
+let joined = list.value().iter()
+    .map(|v| v.value().to_string())
+    .fold(String::new(), |acc, v| {
+        if acc.is_empty() { v } else { format!("{}\n{}", acc, v) }
+    });
+```
+
+### take（先頭 N 件）
+
+```rust
+let first_five: Vec<String> = list.value().iter()
+    .take(5)
+    .map(|v| v.value().to_string())
+    .collect();
+```
+
+### group_by 相当の処理
+
+Rust の標準ライブラリには `group_by` がないため、`HashMap` を使って実装します。
+
+```rust
+use std::collections::HashMap;
+
+pub fn group_by_value(&self) -> HashMap<String, Vec<&FizzBuzzValue>> {
+    let mut groups: HashMap<String, Vec<&FizzBuzzValue>> = HashMap::new();
+    for v in &self.list {
+        groups.entry(v.value().to_string()).or_default().push(v);
+    }
+    groups
+}
+
+pub fn count_by_value(&self) -> HashMap<String, usize> {
+    self.group_by_value().into_iter()
+        .map(|(k, v)| (k, v.len()))
+        .collect()
+}
+```
+
+## 11.4 FizzBuzzList のパイプライン操作
+
+```rust
+impl FizzBuzzList {
+    pub fn take(&self, n: usize) -> Vec<&FizzBuzzValue> {
+        self.list.iter().take(n).collect()
+    }
+
+    pub fn join(&self, separator: &str) -> String {
+        self.list.iter()
+            .map(|v| v.value().to_string())
+            .collect::<Vec<_>>()
+            .join(separator)
+    }
+
+    pub fn reduce<F>(&self, f: F) -> String
+    where
+        F: Fn(String, &FizzBuzzValue) -> String,
+    {
+        self.list.iter().fold(String::new(), |acc, v| f(acc, v))
+    }
+}
+```
+
+## 11.5 まとめ
+
+| 概念 | Rust | PHP | Go |
+|------|------|-----|-----|
+| 不変デフォルト | `let x = 5` | — | — |
+| パイプライン | `.iter().filter().map().collect()` | `array_filter` → `array_map` | `for` ループのチェーン |
+| fold | `.fold(init, f)` | `array_reduce($arr, f, init)` | `for` + 累積変数 |
+| 遅延評価 | イテレータは遅延 | — | — |
+
+次章では、Result/Option 型を使ったエラーハンドリングと型安全性を学びます。

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

@@ -0,0 +1,112 @@
+# 第 12 章: エラーハンドリングと型安全性
+
+## 12.1 はじめに
+
+前章ではイテレータチェーンによるパイプライン処理を学びました。この最終章では、Rust の **Result / Option 型** を使ったエラーハンドリングと **enum** による型安全性を学びます。
+
+## 12.2 Result 型によるエラーハンドリング
+
+Rust には例外（Exception）がありません。代わりに `Result<T, E>` 型を使います。
+
+```rust
+pub fn create(type_number: i32) -> Result<Box<dyn FizzBuzzType>, String> {
+    match type_number {
+        1 => Ok(Box::new(FizzBuzzType01)),
+        2 => Ok(Box::new(FizzBuzzType02)),
+        3 => Ok(Box::new(FizzBuzzType03)),
+        _ => Err(format!("タイプ{}は見つかりません", type_number)),
+    }
+}
+```
+
+### ? 演算子によるエラー伝播
+
+```rust
+pub fn new(type_number: i32, number: i32) -> Result<Self, String> {
+    let fizz_buzz_type = create(type_number)?;  // エラーなら早期リターン
+    Ok(Self { fizz_buzz_type, number })
+}
+```
+
+`?` 演算子は Go の `if err != nil { return err }` パターンを簡潔に表現するものです。
+
+## 12.3 Option 型
+
+値が存在しない可能性を表現する型です。Rust には `null` がありません。
+
+```rust
+pub fn find_first(&self, target: &str) -> Option<&FizzBuzzValue> {
+    self.list.iter().find(|v| v.value() == target)
+}
+
+// 使用例
+match list.find_first("Buzz") {
+    Some(value) => println!("Found: {}", value),
+    None => println!("Not found"),
+}
+```
+
+## 12.4 enum による型安全な定数
+
+### FizzBuzzTypeName enum
+
+```rust
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum FizzBuzzTypeName {
+    Standard = 1,
+    NumberOnly = 2,
+    FizzBuzzOnly = 3,
+}
+
+impl FizzBuzzTypeName {
+    pub fn from_number(n: i32) -> Result<Self, String> {
+        match n {
+            1 => Ok(Self::Standard),
+            2 => Ok(Self::NumberOnly),
+            3 => Ok(Self::FizzBuzzOnly),
+            _ => Err(format!("タイプ{}は見つかりません", n)),
+        }
+    }
+
+    pub fn create_type(&self) -> Box<dyn FizzBuzzType> {
+        match self {
+            Self::Standard => Box::new(FizzBuzzType01),
+            Self::NumberOnly => Box::new(FizzBuzzType02),
+            Self::FizzBuzzOnly => Box::new(FizzBuzzType03),
+        }
+    }
+
+    pub fn label(&self) -> &str {
+        match self {
+            Self::Standard => "通常",
+            Self::NumberOnly => "数値のみ",
+            Self::FizzBuzzOnly => "FizzBuzzのみ",
+        }
+    }
+}
+```
+
+Rust の `enum` は PHP の `enum`（8.1+）や Java の `enum` よりも強力で、パターンマッチングの網羅性チェックをコンパイラが行います。
+
+## 12.5 他言語との比較
+
+| 概念 | Rust | PHP | Go | Java |
+|------|------|-----|-----|------|
+| エラーハンドリング | `Result<T, E>` | `try-catch` | `error` 戻り値 | `try-catch` |
+| null 安全 | `Option<T>` | nullable types | ゼロ値 | `Optional<T>` |
+| 列挙型 | `enum`（代数的データ型） | `enum`（PHP 8.1+） | `const` + `iota` | `enum` |
+| エラー伝播 | `?` 演算子 | `throw` | `if err != nil` | `throws` |
+| パターンマッチ | `match`（網羅性チェック） | `match`（PHP 8.0+） | `switch` | `switch` |
+
+## 12.6 まとめ
+
+この章では以下を学びました。
+
+| 概念 | Rust の実現方法 |
+|------|---------------|
+| エラーハンドリング | `Result<T, E>` + `?` 演算子 |
+| null 安全 | `Option<T>` + パターンマッチ |
+| 列挙型 | `enum` + メソッド実装 |
+| 型安全なファクトリ | `enum` → `Box<dyn Trait>` 変換 |
+
+全 12 章を通じて、Rust の TDD 基本サイクル、開発環境の自動化、オブジェクト指向的な設計、関数型プログラミングの活用を一通り学びました。Rust の所有権システム、トレイト、enum、Result/Option は、安全で堅牢なソフトウェアを構築するための強力な基盤です。

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

@@ -0,0 +1,83 @@
+# テスト駆動開発から始める Rust 入門
+
+## 概要
+
+FizzBuzz 問題を題材に、テスト駆動開発（TDD）の基本サイクルから、開発環境の整備、オブジェクト指向設計、関数型プログラミングの活用まで、Rust の特徴を活かしながら段階的に学びます。
+
+## 対象読者
+
+- Rust の基本文法を理解しているプログラミング学習者
+- TDD を体験してみたい開発者
+- 所有権システムやトレイトベースの設計に興味がある方
+
+## 前提条件
+
+- Rust 1.70 以降がインストールされていること
+- Clippy、rustfmt が利用可能であること（Nix 環境推奨: `nix develop .#rust`）
+
+## Rust の特徴
+
+| 特徴 | 説明 |
+|------|------|
+| 所有権と借用 | メモリ安全性をコンパイル時に保証、GC 不要 |
+| 静的型付け + 型推論 | 強力な型システムと `let` による型推論 |
+| トレイト | インターフェースの明示的実装、ポリモーフィズムの基盤 |
+| enum + パターンマッチ | 代数的データ型と網羅的なパターンマッチング |
+| Result / Option | null や例外に頼らない安全なエラーハンドリング |
+| ゼロコスト抽象化 | 高レベルな抽象化がランタイムコストを伴わない |
+
+## 開発ツール
+
+| ツール | 用途 |
+|--------|------|
+| [cargo test](https://doc.rust-lang.org/cargo/commands/cargo-test.html) | 標準テストランナー |
+| [Cargo](https://doc.rust-lang.org/cargo/) | パッケージ管理・ビルドシステム |
+| [Clippy](https://github.com/rust-lang/rust-clippy) | Linter（コード品質チェック） |
+| [rustfmt](https://github.com/rust-lang/rustfmt) | 標準フォーマッター |
+| [just](https://github.com/casey/just) | タスクランナー |
+
+## 目次
+
+### 第 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/rust/` に実装されています。
+
+```bash
+# 開発環境に入る
+nix develop .#rust
+
+# テスト実行
+cd apps/rust
+cargo test
+```
+
+## 参考文献
+
+- Kent Beck 著『テスト駆動開発』
+- Martin Fowler 著『リファクタリング: 既存のコードを安全に改善する』
+- Robert C. Martin 著『Clean Code: アジャイルソフトウェア達人の技』
+- Steve Klabnik, Carol Nichols 著『The Rust Programming Language』

package/lib/assets/docs/article/getting-start-tdd/scala/01-todo-list-and-first-test.md

@@ -0,0 +1,111 @@
+# 第 1 章: TODO リストと最初のテスト
+
+## 1.1 はじめに
+
+この章では、TDD の基本サイクルである Red-Green-Refactor を FizzBuzz 問題で体験します。
+
+- Red: まず失敗するテストを書きます。
+- Green: テストを通す最小限の実装を書きます。
+- Refactor: テストを壊さずに実装を整理します。
+
+題材の FizzBuzz 仕様は次の通りです。
+
+- 3 の倍数は `Fizz` を返します。
+- 5 の倍数は `Buzz` を返します。
+- 15 の倍数は `FizzBuzz` を返します。
+- それ以外は数値を文字列で返します。
+
+## 1.2 仕様の確認
+
+最初に仕様をテスト可能な単位で整理します。
+
+- 入力は `Int` 型です。
+- 出力は `String` 型です。
+- 1 は `"1"` を返します。
+- 3 は `"Fizz"` を返します。
+- 5 は `"Buzz"` を返します。
+- 15 は `"FizzBuzz"` を返します。
+
+この段階では、まだ実装方法を決めません。仕様だけを明確にします。
+
+## 1.3 TODO リストの作成
+
+仕様を小さく分解して TODO リストにします。
+
+- [ ] `FizzBuzz.generate(1)` が `"1"` を返す
+- [ ] `FizzBuzz.generate(2)` が `"2"` を返す
+- [ ] `FizzBuzz.generate(3)` が `"Fizz"` を返す
+- [ ] `FizzBuzz.generate(5)` が `"Buzz"` を返す
+- [ ] `FizzBuzz.generate(15)` が `"FizzBuzz"` を返す
+- [ ] `FizzBuzz.generateList(100)` が 100 件の結果を返す
+
+最初のタスクは、もっとも単純で失敗時の原因が明確なものを選びます。
+このため、最初は `1` のケースから始めます。
+
+## 1.4 テストファースト
+
+### プロジェクトのセットアップ
+
+Scala の sbt プロジェクトは、主に次の構成で進めます。
+
+- `build.sbt`: プロジェクト名、Scala バージョン、依存関係
+- `project/`: sbt 設定
+- `src/main/scala/`: 本番コード
+- `src/test/scala/`: テストコード
+
+`ScalaTest` を利用するため、`build.sbt` に test scope の依存関係を追加します。
+
+```scala
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.19" % Test
+```
+
+### 最初のテストを書く
+
+最初の失敗するテストを `FizzBuzzSpec.scala` に書きます。
+
+```scala
+package fizzbuzz
+
+import org.scalatest.funsuite.AnyFunSuite
+
+class FizzBuzzSpec extends AnyFunSuite:
+  test("1 を渡すと文字列 1 を返す") {
+    assert(FizzBuzz.generate(1) === "1")
+  }
+```
+
+### テストを実行して失敗を確認（Red）
+
+`sbt test` を実行すると、最初は `FizzBuzz` が未定義でコンパイルエラーになります。
+これは Red の成功です。失敗するテストから開発を開始できています。
+
+## 1.5 仮実装
+
+次に最小限の実装を追加して Green を目指します。
+
+```scala
+package fizzbuzz
+
+object FizzBuzz:
+  def generate(number: Int): String = "1"
+```
+
+この時点では `1` を固定で返す仮実装で十分です。
+再度 `sbt test` を実行し、最初のテストが通ることを確認します。
+
+## 1.6 まとめ
+
+この章では、TDD の最初の 1 サイクルを実行しました。
+
+- Red: 最初のテストを追加
+- Green: 最小実装でテストを通過
+- Refactor: 今回は対象なし（次章で一般化）
+
+TODO リストも更新して進捗を明確にします。
+
+- [x] `FizzBuzz.generate(1)` が `"1"` を返す
+- [ ] `FizzBuzz.generate(2)` が `"2"` を返す
+- [ ] `FizzBuzz.generate(3)` が `"Fizz"` を返す
+- [ ] `FizzBuzz.generate(5)` が `"Buzz"` を返す
+- [ ] `FizzBuzz.generate(15)` が `"FizzBuzz"` を返す
+- [ ] `FizzBuzz.generateList(100)` が 100 件の結果を返す