npm - @k2works/claude-code-booster - Versions diffs - 6.2.0 → 6.3.1 - Mend

@k2works/claude-code-booster 6.2.0 → 6.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (618) hide show

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

@@ -1,407 +0,0 @@
----
-type: Article
-title: "第 12 章: エラーハンドリングと型安全性"
-description: "前章までに高階関数、不変データ、パイプライン処理を学びました。"
-tags: [article, getting-start-tdd, ruby]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-# 第 12 章: エラーハンドリングと型安全性
-## 12.1 はじめに
-前章までに高階関数、不変データ、パイプライン処理を学びました。最終章では、Ruby 3.x の **パターンマッチング** を使った型安全なコード、**安全なファクトリメソッド**、そして **フィボナッチ数** を題材にした **ベンチマーク** を実装します。
-## 12.2 パターンマッチング（Ruby 3.x）
-### case/in 構文
-Ruby 3.0 以降、`case/in` でパターンマッチングが使えます。従来の `case/when` が値の一致を見るのに対し、`case/in` は構造の一致を見ます。
-```ruby
-# 従来の case/when（値の一致）
-case value
-when 1 then 'one'
-when 2 then 'two'
-end
-# Ruby 3.x の case/in（構造の一致）
-case [1, 2, 3]
-in [Integer => a, Integer => b, Integer => c]
-  puts "#{a}, #{b}, #{c}"  # => "1, 2, 3"
-end
-```
-### deconstruct_keys によるオブジェクトのパターンマッチング
-`deconstruct_keys` を実装すると、自作クラスでもパターンマッチングが使えます。
-```ruby
-class FizzBuzzValue
-  def deconstruct_keys(_keys)
-    { value: @value, number: @number }
-  end
-end
-```
-```ruby
-# 使用例
-value = FizzBuzzValue.new('FizzBuzz', 15)
-case value
-in { value: 'FizzBuzz', number: Integer => n }
-  puts "FizzBuzz at #{n}"  # => "FizzBuzz at 15"
-in { value: 'Fizz', number: Integer => n }
-  puts "Fizz at #{n}"
-in { value: 'Buzz', number: Integer => n }
-  puts "Buzz at #{n}"
-else
-  puts "Number"
-end
-```
-### テスト
-```ruby
-class FizzBuzzValueTest < Minitest::Test
-  def test_パターンマッチングで値を取り出せる
-    value = FizzBuzzValue.new('Fizz', 3)
-    case value
-    in { value: 'Fizz', number: 3 }
-      matched = true
-    else
-      matched = false
-    end
-    assert matched
-  end
-end
-```
-## 12.3 型安全なファクトリ
-### 問題: マジックナンバー
-現在のファクトリメソッドは数値定数でタイプを指定しています。
-```ruby
-# マジックナンバーが散在する可能性
-type = FizzBuzzType.create(1)  # 1 が何を意味するか不明確
-```
-### 解決: FizzBuzzTypeName
-名前付き定数でタイプを指定できるようにします。
-```ruby
-module FizzBuzzTypeName
-  STANDARD = FizzBuzzType::TYPE_01
-  NUMBER_ONLY = FizzBuzzType::TYPE_02
-  FIZZ_BUZZ_ONLY = FizzBuzzType::TYPE_03
-end
-```
-```ruby
-# 名前で指定（意図が明確）
-type = FizzBuzzType.create(FizzBuzzTypeName::STANDARD)
-```
-### try_create: 安全なファクトリ
-未定義のタイプに対して例外ではなく `nil` を返すメソッドを追加します。
-```ruby
-class FizzBuzzType
-  def self.try_create(type)
-    create(type)
-  rescue RuntimeError
-    nil
-  end
-end
-```
-### テスト
-```ruby
-class FizzBuzzTypeTest < Minitest::Test
-  def test_FizzBuzzTypeNameで型安全に生成できる
-    type = FizzBuzzType.create(FizzBuzzTypeName::STANDARD)
-    assert_instance_of FizzBuzzType01, type
-  end
-  def test_try_createで有効なタイプはインスタンスを返す
-    type = FizzBuzzType.try_create(FizzBuzzType::TYPE_01)
-    assert_instance_of FizzBuzzType01, type
-  end
-  def test_try_createで不明なタイプはnilを返す
-    type = FizzBuzzType.try_create(999)
-    assert_nil type
-  end
-end
-```
-## 12.4 検索メソッド
-FizzBuzzList に検索メソッドを追加しました。
-```ruby
-class FizzBuzzList
-  def find_value(&)
-    @value.find(&)
-  end
-  def any_match?(&)
-    @value.any?(&)
-  end
-  def all_match?(&)
-    @value.all?(&)
-  end
-end
-```
-### テスト
-```ruby
-class FizzBuzzListTest < Minitest::Test
-  def test_find_valueで条件に合う最初の要素を返す
-    type = FizzBuzzType.create(FizzBuzzType::TYPE_01)
-    command = FizzBuzzListCommand.new(type, 15)
-    list = command.execute
-    result = list.find_value { |v| v.value == 'Buzz' }
-    assert_equal 'Buzz', result.value
-    assert_equal 5, result.number
-  end
-  def test_any_matchで条件に合う要素が存在するか
-    type = FizzBuzzType.create(FizzBuzzType::TYPE_01)
-    command = FizzBuzzListCommand.new(type, 15)
-    list = command.execute
-    assert list.any_match? { |v| v.value == 'FizzBuzz' }
-    refute list.any_match? { |v| v.value == 'Unknown' }
-  end
-  def test_all_matchで全要素が条件を満たすか
-    type = FizzBuzzType.create(FizzBuzzType::TYPE_02)
-    command = FizzBuzzListCommand.new(type, 15)
-    list = command.execute
-    assert list.all_match? { |v| v.number.positive? }
-    refute list.all_match? { |v| v.value == 'Fizz' }
-  end
-end
-```
-## 12.5 フィボナッチ数とベンチマーク
-### フィボナッチ数の TDD
-フィボナッチ数を 3 つのアルゴリズムで実装し、パフォーマンスを比較します。
-#### Fibonacci::Command（Strategy パターン）
-```ruby
-module Fibonacci
-  class Command
-    def initialize(algorithm)
-      @algorithm = algorithm
-    end
-    def exec(number)
-      @algorithm.exec(number)
-    end
-  end
-end
-```
-#### 再帰（メモ化あり）
-```ruby
-module Fibonacci
-  class Recursive
-    def exec(number, memo = {})
-      return 0 if number.zero?
-      return 1 if number == 1
-      memo[number] ||= exec(number - 1, memo) + exec(number - 2, memo)
-    end
-  end
-end
-```
-#### ループ
-```ruby
-module Fibonacci
-  class Loop
-    def exec(number)
-      a = 0
-      b = 1
-      c = 0
-      (0...number).each do |_i|
-        a = b
-        b = c
-        c = a + b
-      end
-      c
-    end
-  end
-end
-```
-#### 一般項（数学公式）
-```ruby
-module Fibonacci
-  class GeneralTerm
-    def exec(number)
-      a = ((1 + Math.sqrt(5)) / 2)**number
-      b = ((1 - Math.sqrt(5)) / 2)**number
-      ((a - b) / Math.sqrt(5)).round
-    end
-  end
-end
-```
-### テスト
-```ruby
-class FibonacciTest < Minitest::Test
-  def setup
-    @recursive = Fibonacci::Command.new(Fibonacci::Recursive.new)
-    @loop = Fibonacci::Command.new(Fibonacci::Loop.new)
-    @general_term = Fibonacci::Command.new(Fibonacci::GeneralTerm.new)
-  end
-  def test_fibonacci_基本ケース
-    cases = [[0, 0], [1, 1], [2, 1], [3, 2], [4, 3], [5, 5]]
-    cases.each do |input, expected|
-      assert_equal expected, @recursive.exec(input)
-      assert_equal expected, @loop.exec(input)
-      assert_equal expected, @general_term.exec(input)
-    end
-  end
-  def test_fibonacci_再帰_大きな数
-    assert_equal 102_334_155, @recursive.exec(40)
-  end
-  def test_fibonacci_ループ_大きな数
-    assert_equal 102_334_155, @loop.exec(40)
-  end
-  def test_fibonacci_一般項_大きな数
-    assert_equal 102_334_155, @general_term.exec(40)
-  end
-end
-```
-### ベンチマーク
-`Minitest::Benchmark` で各アルゴリズムのパフォーマンスを測定します。
-```ruby
-class FibonacciBenchmark < Minitest::Benchmark
-  def setup
-    @recursive = Fibonacci::Command.new(Fibonacci::Recursive.new)
-    @loop = Fibonacci::Command.new(Fibonacci::Loop.new)
-    @general_term = Fibonacci::Command.new(Fibonacci::GeneralTerm.new)
-  end
-  def bench_recursive
-    assert_performance_constant do |_n|
-      1000.times { |i| @recursive.exec(i) }
-    end
-  end
-  def bench_loop
-    assert_performance_constant do |_n|
-      1000.times { |i| @loop.exec(i) }
-    end
-  end
-  def bench_general_term
-    assert_performance_constant do |_n|
-      1000.times { |i| @general_term.exec(i) }
-    end
-  end
-end
-```
-### ベンチマーク結果
-```bash
-$ bundle exec rake benchmark
-bench_general_term	 0.001057
-bench_loop	 0.162474
-bench_recursive	 0.449281
-```
-一般項が最速で、再帰の約 400 倍高速です。
-| アルゴリズム | 計算量 | 特徴 |
-|------------|--------|------|
-| 再帰（メモ化） | O(n) | 理解しやすいが、メモ化が必要 |
-| ループ | O(n) | メモリ効率が良い |
-| 一般項 | O(1) | 数学公式で最速、大きな数では誤差の可能性 |
-## 12.6 ディレクトリ構成
-### Fibonacci モジュール
-```
-lib/
-├── fizz_buzz/        (既存)
-└── fibonacci/
-    ├── fibonacci.rb  (バレルファイル)
-    ├── command.rb    (Strategy パターン)
-    ├── recursive.rb  (再帰アルゴリズム)
-    ├── loop.rb       (ループアルゴリズム)
-    └── general_term.rb (一般項アルゴリズム)
-test/
-├── fizz_buzz/        (既存 + FP メソッドのテスト追加)
-└── fibonacci/
-    ├── fibonacci_test.rb       (ユニットテスト)
-    └── fibonacci_benchmark.rb  (ベンチマーク)
-```
-### テスト実行結果
-```bash
-$ bundle exec rake test
-39 tests, 72 assertions, 0 failures, 0 errors, 0 skips
-Coverage report generated for Unit Tests.
-Line Coverage: 95.95% (142 / 148)
-Branch Coverage: 100.0% (20 / 20)
-```
-## 12.7 各言語のエラーハンドリング比較
-| 概念 | Ruby | Java | TypeScript | Python |
-|------|------|------|-----------|--------|
-| パターンマッチング | `case/in` + `deconstruct_keys` | `switch` (JDK 21+) | Type Guards | `match/case` (3.10+) |
-| 安全なファクトリ | `try_create` → `nil` | `Optional` | `T \| undefined` | `None` |
-| null 安全 | `nil` + `&.`（safe navigation） | `Optional` | Union Types | `Optional` typing |
-| 列挙型 | Symbol / Module 定数 | `enum` | `enum` | `Enum` |
-| ベンチマーク | `Minitest::Benchmark` | JMH | カスタム | `timeit` |
-## 12.8 第 4 部のまとめ
-第 4 部（章 10〜12）を通じて、OOP の FizzBuzz に関数型プログラミングの要素を追加しました。
-| 章 | テーマ | 適用した技術 |
-|---|--------|-------------|
-| 10 | 高階関数と関数合成 | ブロック/Proc/Lambda、カリー化、`>>` 合成 |
-| 11 | 不変データとパイプライン | `freeze`、`then` パイプライン、`tally`、Lazy |
-| 12 | エラーハンドリングと型安全性 | パターンマッチング、`try_create`、ベンチマーク |
-### 全 12 章の学習体系
-| 部 | テーマ | 章 |
-|---|--------|---|
-| 第 1 部 | TDD の基本サイクル | 章 1〜3: TODO リスト、仮実装と三角測量、明白な実装 |
-| 第 2 部 | 開発環境と自動化 | 章 4〜6: バージョン管理、パッケージ管理、タスクランナー |
-| 第 3 部 | オブジェクト指向設計 | 章 7〜9: ポリモーフィズム、デザインパターン、SOLID |
-| 第 4 部 | 関数型プログラミング | 章 10〜12: 高階関数、パイプライン、型安全性 + ベンチマーク |
-Ruby の特徴であるブロック・Proc・Lambda、Enumerable Mix-in、パターンマッチング、そしてベンチマークにより、OOP と FP のハイブリッドなプログラミングスタイルを実現しました。

package/lib/assets/docs/article/getting-start-tdd/ruby/index.md DELETED Viewed

@@ -1,83 +0,0 @@
-# テスト駆動開発から始める Ruby 入門
-## 概要
-FizzBuzz 問題を題材に、テスト駆動開発（TDD）の基本サイクルから、開発環境の整備、オブジェクト指向設計、関数型プログラミングの活用まで、Ruby の特徴を活かしながら段階的に学びます。
-## 対象読者
-- Ruby の基本文法を理解しているプログラミング学習者
-- TDD を体験してみたい開発者
-- オブジェクト指向設計や関数型プログラミングに興味がある方
-## 前提条件
-- Ruby 3.3 以降がインストールされていること
-- Bundler が利用可能であること（Nix 環境推奨: `nix develop .#ruby`）
-## Ruby の特徴
-| 特徴 | 説明 |
-|------|------|
-| 動的型付け | 変数に型宣言が不要、柔軟なプログラミングが可能 |
-| オブジェクト指向 | すべてがオブジェクト、ダックタイピングによるポリモーフィズム |
-| ブロック・Proc・Lambda | 高階関数をサポートする強力なクロージャ機構 |
-| Enumerable | コレクション操作のための豊富なメソッド群 |
-| オープンクラス | 既存クラスの拡張が可能 |
-| パターンマッチング | Ruby 3.0 以降の構造的パターンマッチ |
-## 開発ツール
-| ツール | 用途 |
-|--------|------|
-| [Minitest](https://github.com/minitest/minitest) | テスティングフレームワーク |
-| [Bundler](https://bundler.io/) | パッケージ管理 |
-| [RuboCop](https://rubocop.org/) | リンター・フォーマッター |
-| [SimpleCov](https://github.com/simplecov-ruby/simplecov) | カバレッジ計測 |
-| [Rake](https://ruby.github.io/rake/) | タスクランナー |
-## 目次
-### 第 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/ruby/` に実装されています。
-```bash
-# 開発環境に入る
-nix develop .#ruby
-# テスト実行
-cd apps/ruby
-bundle exec rake test
-```
-## 参考文献
-- Kent Beck 著『テスト駆動開発』
-- Martin Fowler 著『リファクタリング: 既存のコードを安全に改善する』
-- Robert C. Martin 著『Clean Code: アジャイルソフトウェア達人の技』
-- David Thomas, Andrew Hunt 著『プログラミング Ruby 改訂版』

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

@@ -1,220 +0,0 @@
----
-type: Article
-title: "第 1 章: TODO リストと最初のテスト"
-description: "プログラムを作成するにあたって、まず何をすればよいでしょうか？私たちは、仕様を確認して TODO リスト を作るところから始めます。"
-tags: [article, getting-start-tdd, rust]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-# 第 1 章: TODO リストと最初のテスト
-## 1.1 はじめに
-プログラムを作成するにあたって、まず何をすればよいでしょうか？私たちは、仕様を確認して **TODO リスト** を作るところから始めます。
-> TODO リスト
->
-> 何をテストすべきだろうか——着手する前に、必要になりそうなテストをリストに書き出しておこう。
->
-> — テスト駆動開発
-## 1.2 仕様の確認
-今回取り組む FizzBuzz 問題の仕様は以下の通りです。
-```
-1 から 100 までの数をプリントするプログラムを書け。
-ただし 3 の倍数のときは数の代わりに「Fizz」と、5 の倍数のときは「Buzz」とプリントし、
-3 と 5 両方の倍数の場合には「FizzBuzz」とプリントすること。
-```
-この仕様をそのままプログラムに落とし込むには少しサイズが大きいですね。最初の作業は仕様を **TODO リスト** に分解する作業から着手しましょう。
-## 1.3 TODO リストの作成
-仕様を分解して TODO リストを作成します。
-**TODO リスト**:
-- [ ] 数を文字列にして返す
-  - [ ] 1 を渡したら文字列 "1" を返す
-- [ ] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [ ] 5 の倍数のときは「Buzz」と返す
-- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-まず「1 を渡したら文字列 "1" を返す」という、最も小さなタスクから取り掛かります。
-## 1.4 テスティングフレームワークの導入
-### テストファースト
-最初にプログラムする対象を決めたので、早速プロダクトコードを実装……ではなく **テストファースト** で作業を進めましょう。
-> テストファースト
->
-> いつテストを書くべきだろうか——それはテスト対象のコードを書く前だ。
->
-> — テスト駆動開発
-今回 Rust のテスティングフレームワークには **標準搭載のテストフレームワーク** を利用します。Rust のテストは Cargo と統合されており、`cargo test` コマンドで簡単に実行できます。
-### 開発環境のセットアップ
-Cargo でプロジェクトを初期化し、テスト環境をセットアップします。
-```bash
-# Nix 環境に入る
-$ nix develop .#rust
-# プロジェクトの初期化
-$ cd apps
-$ cargo new rust --name fizzbuzz
-$ cd rust
-```
-Rust のテストは `#[cfg(test)]` アトリビュートで囲んだモジュール内に書きます。テスト関数は `#[test]` アトリビュートを付けます。
-### 環境確認テスト
-環境が正しく設定されていることを確認するため、学習用テストを書きます。
-```rust
-// src/lib.rs
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn test_learning_to_string_整数を文字列へ変換できる() {
-        assert_eq!("42", 42.to_string());
-    }
-}
-```
-テストを実行します。
-```bash
-$ cargo test
-running 1 test
-test tests::test_learning_to_string_整数を文字列へ変換できる ... ok
-test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
-```
-テストが通りました。Rust の標準テストフレームワークが正常に動作することが確認できました。`assert_eq!` マクロは Go の `if got != want` パターンや Java の `assertEquals` に相当する、Rust のアサーション手段です。
-## 1.5 仮実装
-テスト環境の準備ができたので、TODO リストの最初の作業に取り掛かりましょう。
-**TODO リスト**:
-- [ ] 数を文字列にして返す
-  - **1 を渡したら文字列 "1" を返す**
-- [ ] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [ ] 5 の倍数のときは「Buzz」と返す
-- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-まずはアサーションを最初に書きましょう。
-> アサートファースト
->
-> いつアサーションを書くべきだろうか——最初に書こう。
->
-> — テスト駆動開発
-### Red: 最初のテスト
-FizzBuzz のテストを書きます。
-```rust
-// src/lib.rs
-pub fn generate(number: i32) -> String {
-    todo!()
-}
-#[cfg(test)]
-mod tests {
-    use super::*;
-    #[test]
-    fn test_1を渡したら文字列1を返す() {
-        assert_eq!("1", generate(1));
-    }
-}
-```
-テストを実行します。
-```bash
-$ cargo test
-running 1 test
-test tests::test_1を渡したら文字列1を返す ... FAILED
-thread 'tests::test_1を渡したら文字列1を返す' panicked at 'not yet implemented'
-```
-`not yet implemented`——まだ実装されていません。`todo!()` マクロは「ここはまだ未実装」であることを明示し、実行時にパニックを起こします。
-### Green: 仮実装
-テストを通すために **仮実装** から始めます。
-> 仮実装を経て本実装へ
->
-> 失敗するテストを書いてから、最初に行う実装はどのようなものだろうか——ベタ書きの値を返そう。
->
-> — テスト駆動開発
-`generate` 関数を定義して、文字列リテラルを返します。
-```rust
-pub fn generate(number: i32) -> String {
-    "1".to_string()
-}
-```
-テストを実行します。
-```bash
-$ cargo test
-running 1 test
-test tests::test_1を渡したら文字列1を返す ... ok
-test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
-```
-テストが通りました。Rust では `"1"` は `&str`（文字列スライス）であり、`"1".to_string()` で `String`（所有権を持つ文字列）に変換します。Go の `return "1"` がそのまま `string` を返せるのとは異なり、Rust では `&str` と `String` の区別が重要です。
-**TODO リスト**:
-- [ ] 数を文字列にして返す
-  - [x] 1 を渡したら文字列 "1" を返す
-- [ ] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [ ] 5 の倍数のときは「Buzz」と返す
-- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-ここまでの作業をバージョン管理システムにコミットしておきましょう。
-```bash
-$ git add .
-$ git commit -m 'test: 数を文字列にして返す'
-```
-## 1.6 まとめ
-この章では以下のことを学びました。
-- **TODO リスト** で仕様をプログラミング対象に分解する方法
-- **テストファースト** で最初にテストを書く考え方
-- Rust の標準テストフレームワーク（`#[test]`、`assert_eq!`）のセットアップ
-- **仮実装** でベタ書きの値を返してテストを通す手法
-- **アサートファースト** でテストの終わりから書き始めるアプローチ
-- Rust の `&str` と `String` の違い
-次章では、2 つ目のテストケースを追加して **三角測量** を行い、プログラムを一般化していきます。