@k2works/claude-code-booster 3.0.0 → 3.1.0

package/lib/assets/docs/article/getting-start-tdd/fsharp/chapter05.md

@@ -0,0 +1,267 @@
+# 第 5 章: パッケージ管理と静的解析
+
+## 5.1 はじめに
+
+前章では Conventional Commits によるコミットメッセージの規約を学びました。この章では、**パッケージ管理** と **静的コード解析** を導入し、コードの品質を自動でチェックできるようにします。
+
+## 5.2 NuGet によるパッケージ管理
+
+### NuGet とは
+
+> NuGet は .NET のパッケージマネージャです。パッケージの追加、削除、更新、依存関係の解決を自動で行います。
+
+Java の Gradle、Node の npm、Python の uv、Ruby の Bundler、Rust の Cargo に相当するのが NuGet です。
+
+### .fsproj ファイルの構成
+
+F# プロジェクトの設定は `.fsproj` ファイルで管理されます。本プロジェクトのライブラリプロジェクトは以下の構成です。
+
+```xml
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="Library.fs" />
+  </ItemGroup>
+</Project>
+```
+
+テストプロジェクトの設定は以下の通りです。
+
+```xml
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <IsPackable>false</IsPackable>
+    <GenerateProgramFile>false</GenerateProgramFile>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="Tests.fs" />
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="xunit" Version="2.5.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
+    <PackageReference Include="coverlet.collector" Version="6.0.0" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\FizzBuzzFSharp\FizzBuzzFSharp.fsproj" />
+  </ItemGroup>
+</Project>
+```
+
+F# プロジェクトの重要な特徴として、`<Compile Include>` の **順序が意味を持つ** 点があります。F# コンパイラはファイルを上から下へ順に処理するため、依存先のファイルを先に記述する必要があります。
+
+### 主要なコマンド
+
+| コマンド | 説明 |
+|---------|------|
+| `dotnet new` | 新しいプロジェクトを作成 |
+| `dotnet build` | プロジェクトをビルド |
+| `dotnet test` | テストを実行 |
+| `dotnet run` | アプリケーションを実行 |
+| `dotnet add package <name>` | パッケージを追加 |
+| `dotnet restore` | 依存パッケージを復元 |
+
+### NuGet の特徴
+
+- **`obj/project.assets.json` による再現性** — 依存パッケージのバージョンを固定し、環境間の差異を排除
+- **Central Package Management** — `Directory.Packages.props` で複数プロジェクトのパッケージバージョンを統一管理
+- **`bin/` と `obj/` ディレクトリ** — Rust の `target/`、Node の `node_modules/` に相当（`.gitignore` に追加）
+
+## 5.3 Fantomas によるコードフォーマット
+
+### Fantomas とは
+
+> Fantomas は F# の公式コードフォーマッターです。コードスタイルを統一し、チーム内のスタイル議論を排除します。
+
+Rust の rustfmt、Go の gofmt、Python の Ruff format、TypeScript の Prettier に相当します。
+
+### インストールと実行
+
+```bash
+# グローバルツールとしてインストール
+$ dotnet tool install -g fantomas
+
+# フォーマットチェック（CI 向け）
+$ fantomas --check src/ tests/
+
+# 自動フォーマット
+$ fantomas src/ tests/
+```
+
+### コードスタイル例
+
+Fantomas はデフォルトで F# のスタイルガイドに従ったフォーマットを適用します。
+
+```fsharp
+// Before（手動フォーマット）
+let generate(number:int):string=match(number%3,number%5)with|(0,0)->"FizzBuzz"|(0,_)->"Fizz"|(_,0)->"Buzz"|_->string number
+
+// After（Fantomas 適用後）
+let generate (number: int) : string =
+    match (number % 3, number % 5) with
+    | (0, 0) -> "FizzBuzz"
+    | (0, _) -> "Fizz"
+    | (_, 0) -> "Buzz"
+    | _ -> string number
+```
+
+## 5.4 FSharpLint によるコード複雑度チェック
+
+### 循環的複雑度（Cyclomatic Complexity）
+
+FSharpLint には **FL0071**（CyclomaticComplexity）ルールが内蔵されており、関数の循環的複雑度を計測できます。
+
+> 循環的複雑度とは、コードの線形独立なパスの数を数値化した指標です。条件分岐（`if`/`elif`/`else`）、`match` 式のケース、`for`/`while` ループ、条件内のブール演算子によってインクリメントされます。
+
+| 複雑度の範囲 | 意味 |
+|-------------|------|
+| 1〜7 | 低複雑度: 管理しやすく、問題なし |
+| 8〜15 | 中程度の複雑度: リファクタリングを検討 |
+| 16〜25 | 高複雑度: リファクタリングが強く推奨される |
+| 26 以上 | 非常に高い複雑度: 関数を分割する必要がある |
+
+### FSharpLint の導入
+
+dotnet tool としてインストールします。
+
+```bash
+# ローカルツールとしてインストール
+$ dotnet new tool-manifest  # 初回のみ
+$ dotnet tool install dotnet-fsharplint
+```
+
+### fsharplint.json による閾値設定
+
+プロジェクトルートに `fsharplint.json` を作成し、閾値を設定します。
+
+```json
+{
+    "cyclomaticComplexity": {
+        "enabled": true,
+        "config": {
+            "maxComplexity": 7
+        }
+    }
+}
+```
+
+他言語の複雑度チェック（C# の SonarAnalyzer `S3776`、Rust の Clippy `cognitive-complexity-threshold = 7`、PHP の PHPMD `reportLevel: 7`、Python の Ruff `max-complexity = 7`）と同じ基準値 **7** を設定します。
+
+### 実行してみる
+
+```bash
+# 複雑度チェック
+$ dotnet dotnet-fsharplint lint --lint-config fsharplint.json FizzBuzzFSharp/Library.fs
+========== Linting FizzBuzzFSharp/Library.fs ==========
+========== Finished: 0 warnings ==========
+========== Summary: 0 warnings ==========
+```
+
+現在の FizzBuzz 実装では、各関数が短く単純なため、閾値 7 を超える関数はありません。
+
+### 複雑度違反の例
+
+閾値を超えるとこのように検出されます。
+
+```
+The cyclomatic complexity of this section is 8, which exceeds the maximum
+suggested complexity of 7.
+Error on line 4 starting at column 8
+    let complexFunction x =
+        ^
+See https://fsprojects.github.io/FSharpLint/how-tos/rules/FL0071.html
+```
+
+### F# で複雑度を低く保つコツ
+
+F# の `match` 式は判別共用体のケースごとに複雑度がカウントされます。ヘルパー関数に分割することで複雑度を低く保てます。
+
+```fsharp
+// ヘルパー関数で複雑度を分散
+let private isFizz number = number % 3 = 0
+let private isBuzz number = number % 5 = 0
+let private isFizzBuzz number = isFizz number && isBuzz number
+```
+
+### Cake への追加
+
+`build.cake` に FSharpLint タスクを追加します。
+
+```csharp
+Task("FSharpLint")
+    .Does(() =>
+{
+    var exitCode = StartProcess("dotnet", new ProcessSettings
+    {
+        Arguments = "dotnet-fsharplint lint --lint-config fsharplint.json FizzBuzzFSharp/Library.fs"
+    });
+    if (exitCode != 0)
+    {
+        throw new Exception("FSharpLint チェックに失敗しました。F# コードの複雑度を下げてください。");
+    }
+    Information("FSharpLint チェック: OK（全関数が閾値以下）");
+});
+
+Task("Check")
+    .IsDependentOn("Test")
+    .IsDependentOn("Complexity")
+    .IsDependentOn("FSharpLint");
+```
+
+`dotnet dotnet-cake --target=FSharpLint` で F# の複雑度チェックを単独実行、`dotnet dotnet-cake --target=Check` で C#/F# 両方の全品質チェックをまとめて実行できます。
+
+### 他言語との比較
+
+| 言語 | 複雑度チェックツール | 設定 |
+|------|---------------------|------|
+| F# | FSharpLint（FL0071） | `fsharplint.json: maxComplexity: 7` |
+| C# | SonarAnalyzer（S3776） | `.editorconfig: dotnet_diagnostic.S3776.severity = warning` |
+| Rust | Clippy（cognitive_complexity） | `clippy.toml: cognitive-complexity-threshold = 7` |
+| PHP | PHPMD | `reportLevel: 7` |
+| Java | PMD | `CyclomaticComplexity` |
+| Python | Ruff（McCabe） | `max-complexity = 7` |
+| TypeScript | ESLint | `complexity: ["error", { max: 7 }]` |
+| Ruby | RuboCop | `Metrics/CyclomaticComplexity` |
+| Go | golangci-lint（gocognit） | `.golangci.yml: gocognit.min-complexity: 7` |
+
+## 5.5 コードカバレッジ
+
+### coverlet によるカバレッジ計測
+
+coverlet は .NET のクロスプラットフォームカバレッジツールです。
+
+```bash
+# カバレッジ付きでテスト実行
+$ dotnet test --collect:"XPlat Code Coverage"
+```
+
+テスト結果は `TestResults/` ディレクトリに Cobertura XML 形式で出力されます。
+
+## 5.6 他言語との比較
+
+| ツール | 役割 | 他言語の対応ツール |
+|--------|------|-------------------|
+| NuGet | パッケージ管理 | npm, Bundler, Cargo, Go Modules |
+| Fantomas | コードフォーマット | Prettier, rustfmt, gofmt, Ruff |
+| FSharpLint（FL0071） | コード複雑度チェック | Clippy cognitive_complexity, SonarAnalyzer S3776, PHPMD |
+| coverlet | カバレッジ計測 | c8, tarpaulin, go test -cover |
+
+## 5.7 まとめ
+
+この章では以下を導入しました。
+
+| ツール | 役割 |
+|--------|------|
+| NuGet | パッケージ管理と依存関係の解決 |
+| .fsproj | F# プロジェクトの設定とファイル順序管理 |
+| Fantomas | F# コードの自動フォーマット |
+| FSharpLint | 循環的複雑度チェック（閾値 7） |
+| coverlet | テストカバレッジの計測 |
+
+次章では、これらのツールを **タスクランナー**（Cake）でまとめて実行できるようにし、**CI/CD** パイプラインを構築します。

package/lib/assets/docs/article/getting-start-tdd/fsharp/chapter06.md

@@ -0,0 +1,190 @@
+# 第 6 章: タスクランナーと CI/CD
+
+## 6.1 はじめに
+
+前章では NuGet によるパッケージ管理と Fantomas によるコードフォーマットを導入しました。テストの実行、静的解析、フォーマットチェックと、様々なコマンドを使えるようになりましたが、毎回それぞれのコマンドを覚えて実行するのは面倒です。
+
+この章では **タスクランナー** を使ってこれらのタスクをまとめて実行できるようにし、さらに **CI/CD** パイプラインを構築します。
+
+## 6.2 Cake によるタスク管理
+
+### Cake とは
+
+> Cake（C# Make）は C# で記述できるクロスプラットフォームのビルド自動化ツールです。タスクの定義、依存関係の管理、実行をスクリプトで記述します。
+
+Ruby の Rake、Java の Gradle、Node の npm scripts、Rust の Makefile に相当します。F# プロジェクトでは Cake が広く使われています。
+
+### Cake ビルドスクリプトの定義
+
+```csharp
+// build.cake
+var target = Argument("target", "Default");
+var configuration = Argument("configuration", "Release");
+
+Task("Clean")
+    .Does(() =>
+{
+    CleanDirectory("./src/bin");
+    CleanDirectory("./src/obj");
+    CleanDirectory("./tests/bin");
+    CleanDirectory("./tests/obj");
+});
+
+Task("Build")
+    .IsDependentOn("Clean")
+    .Does(() =>
+{
+    DotNetBuild("./FizzBuzzFSharp.sln", new DotNetBuildSettings
+    {
+        Configuration = configuration
+    });
+});
+
+Task("Format")
+    .Does(() =>
+{
+    StartProcess("dotnet", "fantomas ./src --recurse");
+    StartProcess("dotnet", "fantomas ./tests --recurse");
+});
+
+Task("Test")
+    .IsDependentOn("Build")
+    .Does(() =>
+{
+    DotNetTest("./tests/FizzBuzzFSharpTest.fsproj", new DotNetTestSettings
+    {
+        Configuration = configuration,
+        NoBuild = true
+    });
+});
+
+Task("All")
+    .IsDependentOn("Clean")
+    .IsDependentOn("Format")
+    .IsDependentOn("Build")
+    .IsDependentOn("Test");
+
+Task("Default")
+    .IsDependentOn("All");
+
+RunTarget(target);
+```
+
+### 主要なタスク
+
+| タスク | コマンド | 説明 |
+|--------|---------|------|
+| `dotnet cake` | 全タスク実行 | Clean → Format → Build → Test |
+| `dotnet cake --target=Test` | テスト実行 | Build → Test |
+| `dotnet cake --target=Format` | フォーマット | Fantomas 実行 |
+| `dotnet cake --target=Clean` | クリーン | ビルド成果物の削除 |
+
+### 実行例
+
+```bash
+# 全チェック実行
+$ dotnet cake
+========================================
+Clean
+========================================
+Build
+========================================
+Format
+========================================
+Test
+  合計: 7、成功: 7、失敗: 0、スキップ: 0
+========================================
+Task Duration
+--------------------------------------------------
+Clean    00:00:00.1234567
+Build    00:00:02.3456789
+Format   00:00:01.2345678
+Test     00:00:03.4567890
+--------------------------------------------------
+Total:   00:00:07.1604924
+```
+
+## 6.3 GitHub Actions による CI/CD
+
+### CI/CD とは
+
+> CI/CD（Continuous Integration / Continuous Delivery）は、コードの変更を自動的にビルド、テスト、デプロイするプラクティスです。
+
+### ワークフローの定義
+
+`.github/workflows/fsharp-ci.yml` にワークフローを定義します。
+
+```yaml
+name: F# CI
+
+on:
+  push:
+    branches: [main, develop]
+    paths:
+      - "apps/dotnet/FizzBuzzFSharp/**"
+      - "apps/dotnet/FizzBuzzFSharpTest/**"
+      - ".github/workflows/fsharp-ci.yml"
+  pull_request:
+    branches: [main]
+    paths:
+      - "apps/dotnet/FizzBuzzFSharp/**"
+      - "apps/dotnet/FizzBuzzFSharpTest/**"
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@v4
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: 8.0.x
+
+      - name: Restore dependencies
+        run: dotnet restore
+        working-directory: apps/dotnet
+
+      - name: Build
+        run: dotnet build --no-restore
+        working-directory: apps/dotnet
+
+      - name: Run tests
+        run: dotnet test --no-build
+        working-directory: apps/dotnet
+```
+
+### CI パイプラインの流れ
+
+```
+Push / PR → Restore → Build → Test → 結果通知
+```
+
+## 6.4 他言語との比較
+
+| 言語 | タスクランナー | CI ツール | テスト | フォーマット |
+|------|-------------|----------|--------|------------|
+| F# | Cake | GitHub Actions | xUnit | Fantomas |
+| Rust | Makefile | GitHub Actions | cargo test | rustfmt |
+| Go | Makefile | GitHub Actions | go test | gofmt |
+| Java | Gradle | GitHub Actions | JUnit | Checkstyle |
+| Python | tox | GitHub Actions | pytest | Ruff |
+| Node | npm scripts | GitHub Actions | Vitest | Prettier |
+
+## 6.5 まとめ
+
+この章では以下を実現しました。
+
+| 項目 | 内容 |
+|------|------|
+| Cake | Clean / Format / Build / Test タスクを定義 |
+| `dotnet cake` | フォーマット → ビルド → テストを一括実行 |
+| GitHub Actions | push / PR 時に自動で CI を実行 |
+| .NET SDK 統合 | CI でも同じ dotnet コマンドを使用し環境を統一 |
+
+第 2 部を通じて、ソフトウェア開発の三種の神器（バージョン管理、テスティング、自動化）を F# の開発環境に整備しました。次の第 3 部では、F# の関数型アプローチによる設計（レコード型、判別共用体、モジュール分割）に進みます。

package/lib/assets/docs/article/getting-start-tdd/fsharp/chapter07.md

@@ -0,0 +1,161 @@
+# 第 7 章: レコード型とモジュールによるカプセル化
+
+## 7.1 はじめに
+
+第 1 部では手続き型の FizzBuzz プログラムを TDD で構築しました。この章からは **F# の関数型アプローチ** による設計を導入していきます。まず **レコード型** と **モジュール** によるカプセル化を実現します。
+
+## 7.2 手続き型コードの課題
+
+第 1 部で作成した `generate` 関数は手続き型プログラミングの典型例です。
+
+```fsharp
+let generate (number: int) : string =
+    match (number % 3, number % 5) with
+    | (0, 0) -> "FizzBuzz"
+    | (0, _) -> "Fizz"
+    | (_, 0) -> "Buzz"
+    | _ -> string number
+```
+
+この設計の課題は、数値と変換結果の関係がプリミティブ型（`int` と `string`）で表現されており、ドメインの意味が失われていることです。
+
+## 7.3 レコード型による値オブジェクト
+
+### FizzBuzzValue レコード型
+
+数値と FizzBuzz の結果をまとめたレコード型を作成します。
+
+```fsharp
+type FizzBuzzValue =
+    { Number: int
+      Value: string }
+
+    override this.ToString() = sprintf "%d:%s" this.Number this.Value
+```
+
+### テストを書く
+
+```fsharp
+[<Fact>]
+let ``値を保持する`` () =
+    let value = createValue 1 "1"
+    Assert.Equal(1, value.Number)
+    Assert.Equal("1", value.Value)
+
+[<Fact>]
+let ``同じ値のレコードは等しい`` () =
+    let value1 = createValue 1 "1"
+    let value2 = createValue 1 "1"
+    Assert.Equal(value1, value2)
+
+[<Fact>]
+let ``ToStringはNumber_Colon_Value形式`` () =
+    let value = createValue 3 "Fizz"
+    Assert.Equal("3:Fizz", value.ToString())
+```
+
+### createValue 関数の実装
+
+```fsharp
+let createValue number value = { Number = number; Value = value }
+```
+
+```bash
+$ dotnet test
+  合計: 10、成功: 10、失敗: 0、スキップ: 0
+```
+
+F# のレコード型は **構造的等価性** を持ちます。つまり、フィールドの値が同じであれば 2 つのレコードは等しいと判定されます。Rust では `#[derive(PartialEq)]` が必要ですが、F# のレコード型ではデフォルトで構造的等価性が提供されます。
+
+### レコード型の特徴
+
+| 特徴 | F# レコード型 | Rust struct | Java class |
+|------|-------------|-------------|------------|
+| 不変性 | デフォルト不変 | デフォルト不変 | 明示的に `final` |
+| 等価性 | 構造的（自動） | `#[derive(PartialEq)]` | `equals()` 手動実装 |
+| コピー | `{ record with Field = newValue }` | `.clone()` | コンストラクタで新規作成 |
+| パターンマッチ | 対応 | 対応 | Java 21+ で対応 |
+
+## 7.4 モジュールによるアクセス制御
+
+### Domain モジュールの作成
+
+F# では `module` でコードをグルーピングし、`private` でアクセスを制御します。
+
+```fsharp
+namespace FizzBuzzFSharp
+
+module Domain =
+
+    type FizzBuzzValue =
+        { Number: int
+          Value: string }
+
+        override this.ToString() = sprintf "%d:%s" this.Number this.Value
+
+    let createValue number value = { Number = number; Value = value }
+
+    let private isFizz number = number % 3 = 0
+    let private isBuzz number = number % 5 = 0
+    let private isFizzBuzz number = isFizz number && isBuzz number
+```
+
+`private` キーワードで修飾された関数はモジュール外からアクセスできません。Rust の `pub`/非公開 や Java の `private` に相当します。
+
+### generate 関数の更新
+
+`generate` 関数を Domain モジュール内に移動し、`FizzBuzzValue` を返すように変更します。
+
+```fsharp
+let generate (number: int) : FizzBuzzValue =
+    if isFizzBuzz number then createValue number "FizzBuzz"
+    elif isFizz number then createValue number "Fizz"
+    elif isBuzz number then createValue number "Buzz"
+    else createValue number (string number)
+```
+
+### テストの更新
+
+```fsharp
+[<Fact>]
+let ``Standard_数を文字列にして返す`` () =
+    let result = Domain.generate 1
+    Assert.Equal("1", result.Value)
+
+[<Fact>]
+let ``Standard_三の倍数のときはFizzを返す`` () =
+    let result = Domain.generate 3
+    Assert.Equal("Fizz", result.Value)
+```
+
+## 7.5 F# のモジュールシステム
+
+F# のモジュールシステムは `namespace` と `module` の 2 つの構造で構成されます。
+
+```fsharp
+namespace FizzBuzzFSharp    // 名前空間
+
+module Domain =              // モジュール（値と関数を含む）
+    let createValue ...      // 公開関数
+    let private isFizz ...   // 非公開関数
+```
+
+| 構造 | 用途 | Rust の対応 |
+|------|------|-----------|
+| `namespace` | 型のグルーピング | `mod`（ファイルレベル） |
+| `module` | 関数と値のグルーピング | `mod`（内部モジュール） |
+| `private` | アクセス制限 | デフォルト非公開 |
+| `internal` | アセンブリ内公開 | `pub(crate)` |
+
+## 7.6 まとめ
+
+この章では以下を学びました。
+
+| 概念 | F# の実現方法 | 他言語の対応 |
+|------|---------------|-------------|
+| 値オブジェクト | レコード型 | Rust: struct + derive, Java: record |
+| 構造的等価性 | レコード型のデフォルト | Rust: PartialEq, Java: equals |
+| カプセル化 | module + private | Rust: mod + pub, Java: class + private |
+| ファクトリ関数 | let createValue | Rust: fn new(), Java: static factory |
+
+次章では、**判別共用体** と **パターンマッチ** を導入して、FizzBuzz のタイプを型安全に表現します。