@k2works/claude-code-booster 6.1.0 → 6.3.0

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

@@ -1,119 +0,0 @@
----
-type: Article
-title: "第 9 章: SOLID 原則とモジュール設計"
-description: "前章ではデザインパターンを適用して設計を改善しました。"
-tags: [article, getting-start-tdd, rust]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 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

@@ -1,103 +0,0 @@
----
-type: Article
-title: "第 10 章: 高階関数と関数合成"
-description: "Rust は関数型プログラミングの機能を豊富にサポートしています。"
-tags: [article, getting-start-tdd, rust]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 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

@@ -1,114 +0,0 @@
----
-type: Article
-title: "第 11 章: 不変データとパイプライン処理"
-description: "前章ではクロージャとイテレータを使った高階関数を学びました。"
-tags: [article, getting-start-tdd, rust]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 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

@@ -1,121 +0,0 @@
----
-type: Article
-title: "第 12 章: エラーハンドリングと型安全性"
-description: "前章ではイテレータチェーンによるパイプライン処理を学びました。"
-tags: [article, getting-start-tdd, rust]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 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

@@ -1,83 +0,0 @@
-# テスト駆動開発から始める 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

@@ -1,120 +0,0 @@
----
-type: Article
-title: "第 1 章: TODO リストと最初のテスト"
-description: "この章では、TDD の基本サイクルである Red-Green-Refactor を FizzBuzz 問題で体験します。"
-tags: [article, getting-start-tdd, scala]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 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 件の結果を返す