@k2works/claude-code-booster 6.1.0 → 6.3.0

package/lib/assets/docs/article/functional-desgin-ppp/rust/14-abstract-server-pattern.md

@@ -1,401 +0,0 @@
----
-type: Article
-title: "第14章: Abstract Server パターン"
-description: "Abstract Server パターンは、サーバー（サービス提供者）のインターフェースを抽象化し、クライアントを具体的な実装から分離するパターンです。"
-tags: [article, functional-desgin-ppp, rust]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第14章: Abstract Server パターン
-
-## はじめに
-
-Abstract Server パターンは、サーバー（サービス提供者）のインターフェースを抽象化し、クライアントを具体的な実装から分離するパターンです。依存性注入（DI）と組み合わせて使用されることが多く、テスト容易性とモジュール性を向上させます。
-
-本章では、ストレージサービス、通知サービス、認証サービスなど、様々な例を通じて Abstract Server パターンの Rust での実装を学びます。
-
-## 1. パターンの構造
-
-```plantuml
-@startuml
-title Abstract Server パターン構造（Rust）
-
-interface "Storage trait" as Storage {
-  +read(key): Option<String>
-  +write(key, value): Result
-  +delete(key): Result
-}
-
-class "Client" as Client {
-  +storage: Box<dyn Storage>
-}
-
-class "FileStorage" as FileStorage
-class "MemoryStorage" as MemoryStorage
-class "S3Storage" as S3Storage
-
-Storage <|.. FileStorage
-Storage <|.. MemoryStorage
-Storage <|.. S3Storage
-Client o-- Storage
-@enduml
-```
-
-## 2. ストレージサービス
-
-### トレイト定義
-
-```rust
-/// ストレージトレイト
-pub trait Storage {
-    fn read(&self, key: &str) -> Option<String>;
-    fn write(&mut self, key: &str, value: &str) -> Result<(), String>;
-    fn delete(&mut self, key: &str) -> Result<(), String>;
-    fn exists(&self, key: &str) -> bool;
-    fn list_keys(&self) -> Vec<String>;
-}
-```
-
-### インメモリ実装
-
-```rust
-/// インメモリストレージ
-pub struct MemoryStorage {
-    data: HashMap<String, String>,
-}
-
-impl MemoryStorage {
-    pub fn new() -> MemoryStorage {
-        MemoryStorage {
-            data: HashMap::new(),
-        }
-    }
-}
-
-impl Storage for MemoryStorage {
-    fn read(&self, key: &str) -> Option<String> {
-        self.data.get(key).cloned()
-    }
-
-    fn write(&mut self, key: &str, value: &str) -> Result<(), String> {
-        self.data.insert(key.to_string(), value.to_string());
-        Ok(())
-    }
-
-    fn delete(&mut self, key: &str) -> Result<(), String> {
-        self.data.remove(key);
-        Ok(())
-    }
-
-    fn exists(&self, key: &str) -> bool {
-        self.data.contains_key(key)
-    }
-
-    fn list_keys(&self) -> Vec<String> {
-        self.data.keys().cloned().collect()
-    }
-}
-```
-
-### ファイルストレージ実装
-
-```rust
-/// ファイルストレージ
-pub struct FileStorage {
-    base_path: PathBuf,
-}
-
-impl FileStorage {
-    pub fn new(base_path: &str) -> FileStorage {
-        FileStorage {
-            base_path: PathBuf::from(base_path),
-        }
-    }
-
-    fn file_path(&self, key: &str) -> PathBuf {
-        self.base_path.join(key)
-    }
-}
-
-impl Storage for FileStorage {
-    fn read(&self, key: &str) -> Option<String> {
-        std::fs::read_to_string(self.file_path(key)).ok()
-    }
-
-    fn write(&mut self, key: &str, value: &str) -> Result<(), String> {
-        std::fs::write(self.file_path(key), value)
-            .map_err(|e| e.to_string())
-    }
-
-    fn delete(&mut self, key: &str) -> Result<(), String> {
-        std::fs::remove_file(self.file_path(key))
-            .map_err(|e| e.to_string())
-    }
-
-    fn exists(&self, key: &str) -> bool {
-        self.file_path(key).exists()
-    }
-
-    fn list_keys(&self) -> Vec<String> {
-        std::fs::read_dir(&self.base_path)
-            .map(|entries| {
-                entries
-                    .filter_map(|e| e.ok())
-                    .filter_map(|e| e.file_name().into_string().ok())
-                    .collect()
-            })
-            .unwrap_or_default()
-    }
-}
-```
-
-## 3. 通知サービス
-
-```rust
-/// 通知トレイト
-pub trait NotificationService {
-    fn send(&self, recipient: &str, message: &str) -> Result<(), String>;
-    fn send_bulk(&self, recipients: &[&str], message: &str) -> Vec<Result<(), String>>;
-}
-
-/// メール通知
-pub struct EmailNotification {
-    smtp_server: String,
-}
-
-impl NotificationService for EmailNotification {
-    fn send(&self, recipient: &str, message: &str) -> Result<(), String> {
-        // 実際にはSMTPサーバーに接続
-        println!("Sending email to {} via {}: {}", recipient, self.smtp_server, message);
-        Ok(())
-    }
-
-    fn send_bulk(&self, recipients: &[&str], message: &str) -> Vec<Result<(), String>> {
-        recipients.iter().map(|r| self.send(r, message)).collect()
-    }
-}
-
-/// SMS 通知
-pub struct SmsNotification {
-    api_key: String,
-}
-
-impl NotificationService for SmsNotification {
-    fn send(&self, recipient: &str, message: &str) -> Result<(), String> {
-        println!("Sending SMS to {}: {}", recipient, message);
-        Ok(())
-    }
-
-    fn send_bulk(&self, recipients: &[&str], message: &str) -> Vec<Result<(), String>> {
-        recipients.iter().map(|r| self.send(r, message)).collect()
-    }
-}
-
-/// モック通知（テスト用）
-pub struct MockNotification {
-    pub sent: RefCell<Vec<(String, String)>>,
-}
-
-impl NotificationService for MockNotification {
-    fn send(&self, recipient: &str, message: &str) -> Result<(), String> {
-        self.sent.borrow_mut().push((recipient.to_string(), message.to_string()));
-        Ok(())
-    }
-
-    fn send_bulk(&self, recipients: &[&str], message: &str) -> Vec<Result<(), String>> {
-        recipients.iter().map(|r| self.send(r, message)).collect()
-    }
-}
-```
-
-## 4. 認証サービス
-
-```rust
-/// ユーザー情報
-#[derive(Debug, Clone)]
-pub struct User {
-    pub id: String,
-    pub username: String,
-    pub email: String,
-}
-
-/// 認証結果
-pub enum AuthResult {
-    Success(User),
-    InvalidCredentials,
-    AccountLocked,
-    Error(String),
-}
-
-/// 認証トレイト
-pub trait AuthService {
-    fn authenticate(&self, username: &str, password: &str) -> AuthResult;
-    fn validate_token(&self, token: &str) -> Option<User>;
-    fn logout(&mut self, token: &str) -> Result<(), String>;
-}
-
-/// 基本認証
-pub struct BasicAuthService {
-    users: HashMap<String, (String, User)>,  // username -> (password_hash, user)
-    sessions: HashMap<String, User>,          // token -> user
-}
-
-impl AuthService for BasicAuthService {
-    fn authenticate(&self, username: &str, password: &str) -> AuthResult {
-        match self.users.get(username) {
-            Some((stored_hash, user)) if self.verify_password(password, stored_hash) => {
-                AuthResult::Success(user.clone())
-            }
-            Some(_) => AuthResult::InvalidCredentials,
-            None => AuthResult::InvalidCredentials,
-        }
-    }
-
-    fn validate_token(&self, token: &str) -> Option<User> {
-        self.sessions.get(token).cloned()
-    }
-
-    fn logout(&mut self, token: &str) -> Result<(), String> {
-        self.sessions.remove(token);
-        Ok(())
-    }
-}
-```
-
-## 5. 依存性注入
-
-```rust
-/// アプリケーションサービス
-pub struct Application {
-    storage: Box<dyn Storage>,
-    notifications: Box<dyn NotificationService>,
-    auth: Box<dyn AuthService>,
-}
-
-impl Application {
-    pub fn new(
-        storage: Box<dyn Storage>,
-        notifications: Box<dyn NotificationService>,
-        auth: Box<dyn AuthService>,
-    ) -> Application {
-        Application {
-            storage,
-            notifications,
-            auth,
-        }
-    }
-
-    pub fn save_and_notify(&mut self, key: &str, value: &str, recipient: &str) -> Result<(), String> {
-        self.storage.write(key, value)?;
-        self.notifications.send(recipient, &format!("Data saved: {}", key))
-    }
-}
-
-// 本番環境
-let app = Application::new(
-    Box::new(FileStorage::new("/data")),
-    Box::new(EmailNotification { smtp_server: "smtp.example.com".to_string() }),
-    Box::new(BasicAuthService::new()),
-);
-
-// テスト環境
-let test_app = Application::new(
-    Box::new(MemoryStorage::new()),
-    Box::new(MockNotification { sent: RefCell::new(Vec::new()) }),
-    Box::new(MockAuthService::new()),
-);
-```
-
-## 6. サービスレジストリ
-
-```rust
-/// サービスレジストリ
-pub struct ServiceRegistry {
-    storage: Option<Box<dyn Storage>>,
-    notifications: Option<Box<dyn NotificationService>>,
-    auth: Option<Box<dyn AuthService>>,
-}
-
-impl ServiceRegistry {
-    pub fn new() -> ServiceRegistry {
-        ServiceRegistry {
-            storage: None,
-            notifications: None,
-            auth: None,
-        }
-    }
-
-    pub fn with_storage(mut self, storage: Box<dyn Storage>) -> Self {
-        self.storage = Some(storage);
-        self
-    }
-
-    pub fn with_notifications(mut self, notifications: Box<dyn NotificationService>) -> Self {
-        self.notifications = Some(notifications);
-        self
-    }
-
-    pub fn with_auth(mut self, auth: Box<dyn AuthService>) -> Self {
-        self.auth = Some(auth);
-        self
-    }
-
-    pub fn build(self) -> Result<Application, String> {
-        Ok(Application::new(
-            self.storage.ok_or("Storage not configured")?,
-            self.notifications.ok_or("Notifications not configured")?,
-            self.auth.ok_or("Auth not configured")?,
-        ))
-    }
-}
-```
-
-## 7. パターンの利点
-
-1. **テスト容易性**: モック実装で単体テスト可能
-2. **柔軟性**: 実装を切り替え可能
-3. **分離**: クライアントと実装の疎結合
-4. **拡張性**: 新しい実装を追加しやすい
-
-## Rust での特徴
-
-### トレイトオブジェクトと所有権
-
-```rust
-// Box<dyn Trait> で動的ディスパッチ
-pub struct Application {
-    storage: Box<dyn Storage>,
-}
-```
-
-### 内部可変性
-
-```rust
-// RefCell で内部状態を変更
-pub struct MockNotification {
-    pub sent: RefCell<Vec<(String, String)>>,
-}
-```
-
-## まとめ
-
-本章では、Abstract Server パターンについて学びました：
-
-1. **ストレージサービス**: ファイル、メモリ、クラウドストレージ
-2. **通知サービス**: メール、SMS、モック
-3. **認証サービス**: 基本認証、OAuth、モック
-4. **依存性注入**: サービスの組み立て
-5. **サービスレジストリ**: ビルダーパターンとの組み合わせ
-
-Rust のトレイトシステムを活用することで、テスト可能で保守性の高いアーキテクチャを実現できます。
-
-## 参考コード
-
-本章のコード例は以下のファイルで確認できます：
-
-- ソースコード: `apps/rust/part5/src/chapter14.rs`
-
-## 次章予告
-
-次章では、**ゴシップ好きなバスの運転手**問題を通じて、これまで学んだパターンを実践的に適用します。

package/lib/assets/docs/article/functional-desgin-ppp/rust/15-gossiping-bus-drivers.md

@@ -1,309 +0,0 @@
----
-type: Article
-title: "第15章: ゴシップ好きなバスの運転手"
-description: "本章では、「ゴシップ好きなバスの運転手」問題を通じて、これまで学んだ関数型デザインパターンを実践的に適用します。"
-tags: [article, functional-desgin-ppp, rust]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第15章: ゴシップ好きなバスの運転手
-
-## はじめに
-
-本章では、「ゴシップ好きなバスの運転手」問題を通じて、これまで学んだ関数型デザインパターンを実践的に適用します。この問題は、複数のバス運転手がルートを走りながら情報を交換し、全員が全ての噂を知るまでに何日かかるかを計算するものです。
-
-## 1. 問題の概要
-
-- 複数のバス運転手がいる
-- 各運転手は固定のルートを毎日走る
-- 運転手は同じ停留所に停まると、お互いの噂を交換する
-- 全員が全ての噂を知るまでに何日かかるか？
-
-## 2. データ構造
-
-```rust
-/// 停留所
-pub type Stop = usize;
-
-/// ルート（停留所の循環リスト）
-#[derive(Debug, Clone)]
-pub struct Route {
-    stops: Vec<Stop>,
-    current_index: usize,
-}
-
-impl Route {
-    pub fn new(stops: Vec<Stop>) -> Route {
-        Route {
-            stops,
-            current_index: 0,
-        }
-    }
-
-    pub fn current_stop(&self) -> Stop {
-        self.stops[self.current_index]
-    }
-
-    pub fn advance(&self) -> Route {
-        Route {
-            stops: self.stops.clone(),
-            current_index: (self.current_index + 1) % self.stops.len(),
-        }
-    }
-}
-
-/// 運転手
-#[derive(Debug, Clone)]
-pub struct Driver {
-    pub id: usize,
-    pub route: Route,
-    pub gossips: HashSet<usize>,  // 知っている噂のID
-}
-
-impl Driver {
-    pub fn new(id: usize, route: Route) -> Driver {
-        let mut gossips = HashSet::new();
-        gossips.insert(id);  // 最初は自分の噂だけ知っている
-        Driver { id, route, gossips }
-    }
-
-    pub fn current_stop(&self) -> Stop {
-        self.route.current_stop()
-    }
-
-    pub fn advance(&self) -> Driver {
-        Driver {
-            id: self.id,
-            route: self.route.advance(),
-            gossips: self.gossips.clone(),
-        }
-    }
-
-    pub fn share_gossips(&self, other_gossips: &HashSet<usize>) -> Driver {
-        Driver {
-            id: self.id,
-            route: self.route.clone(),
-            gossips: self.gossips.union(other_gossips).cloned().collect(),
-        }
-    }
-
-    pub fn knows_all(&self, total_drivers: usize) -> bool {
-        self.gossips.len() == total_drivers
-    }
-}
-```
-
-## 3. シミュレーション
-
-```rust
-/// シミュレーション状態
-#[derive(Debug, Clone)]
-pub struct Simulation {
-    pub drivers: Vec<Driver>,
-    pub day: usize,
-    pub stop: usize,  // 1日あたりの停留所数
-}
-
-impl Simulation {
-    pub fn new(routes: Vec<Vec<Stop>>) -> Simulation {
-        let drivers = routes
-            .into_iter()
-            .enumerate()
-            .map(|(id, stops)| Driver::new(id, Route::new(stops)))
-            .collect();
-
-        Simulation {
-            drivers,
-            day: 1,
-            stop: 0,
-        }
-    }
-
-    /// 同じ停留所にいる運転手間で噂を交換
-    fn exchange_gossips(&self) -> Vec<Driver> {
-        let mut drivers_by_stop: HashMap<Stop, Vec<usize>> = HashMap::new();
-
-        // 停留所ごとに運転手をグループ化
-        for (i, driver) in self.drivers.iter().enumerate() {
-            drivers_by_stop
-                .entry(driver.current_stop())
-                .or_default()
-                .push(i);
-        }
-
-        // 同じ停留所の運転手間で噂を交換
-        let mut new_drivers = self.drivers.clone();
-        for driver_indices in drivers_by_stop.values() {
-            if driver_indices.len() > 1 {
-                // 全ての噂を収集
-                let combined_gossips: HashSet<usize> = driver_indices
-                    .iter()
-                    .flat_map(|&i| self.drivers[i].gossips.iter().cloned())
-                    .collect();
-
-                // 各運転手に噂を共有
-                for &i in driver_indices {
-                    new_drivers[i] = new_drivers[i].share_gossips(&combined_gossips);
-                }
-            }
-        }
-
-        new_drivers
-    }
-
-    /// 1停留所進める
-    pub fn step(&self) -> Simulation {
-        let drivers_after_exchange = self.exchange_gossips();
-        let drivers_advanced: Vec<Driver> = drivers_after_exchange
-            .into_iter()
-            .map(|d| d.advance())
-            .collect();
-
-        let new_stop = self.stop + 1;
-        let (day, stop) = if new_stop >= 480 {  // 8時間 = 480分（1分1停留所）
-            (self.day + 1, 0)
-        } else {
-            (self.day, new_stop)
-        };
-
-        Simulation {
-            drivers: drivers_advanced,
-            day,
-            stop,
-        }
-    }
-
-    /// 全員が全ての噂を知っているか
-    pub fn all_know_everything(&self) -> bool {
-        let total = self.drivers.len();
-        self.drivers.iter().all(|d| d.knows_all(total))
-    }
-}
-
-/// シミュレーションを実行
-pub fn run_simulation(routes: Vec<Vec<Stop>>, max_days: usize) -> Option<usize> {
-    let stops_per_day = 480;
-    let max_stops = max_days * stops_per_day;
-    let mut sim = Simulation::new(routes);
-
-    for _ in 0..max_stops {
-        if sim.all_know_everything() {
-            return Some(sim.day);
-        }
-        sim = sim.step();
-    }
-
-    None  // max_days 以内に完了しない
-}
-```
-
-## 4. DSL によるルート定義
-
-```rust
-/// ルートビルダー
-pub struct RouteBuilder {
-    routes: Vec<Vec<Stop>>,
-}
-
-impl RouteBuilder {
-    pub fn new() -> RouteBuilder {
-        RouteBuilder { routes: Vec::new() }
-    }
-
-    pub fn driver(mut self, stops: Vec<Stop>) -> RouteBuilder {
-        self.routes.push(stops);
-        self
-    }
-
-    pub fn build(self) -> Vec<Vec<Stop>> {
-        self.routes
-    }
-}
-
-/// DSL マクロ
-macro_rules! routes {
-    ($($stops:expr),* $(,)?) => {
-        RouteBuilder::new()
-            $(.driver($stops))*
-            .build()
-    };
-}
-
-// 使用例
-let routes = routes![
-    vec![1, 2, 3],
-    vec![2, 3, 4],
-    vec![3, 4, 5],
-];
-```
-
-## 5. テスト例
-
-```rust
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_simple_exchange() {
-        // 2人の運転手が同じ停留所を共有
-        let routes = vec![
-            vec![1, 2, 3],
-            vec![2, 3, 4],
-        ];
-        let result = run_simulation(routes, 10);
-        assert!(result.is_some());
-    }
-
-    #[test]
-    fn test_no_common_stop() {
-        // 共通の停留所がない
-        let routes = vec![
-            vec![1, 2, 3],
-            vec![4, 5, 6],
-        ];
-        let result = run_simulation(routes, 10);
-        assert!(result.is_none());
-    }
-
-    #[test]
-    fn test_three_drivers() {
-        let routes = vec![
-            vec![3, 1, 2, 3],
-            vec![3, 2, 3, 1],
-            vec![4, 2, 3, 4, 5],
-        ];
-        let result = run_simulation(routes, 10);
-        assert_eq!(result, Some(2));
-    }
-}
-```
-
-## 6. パターンの適用
-
-この問題では以下のパターンが適用されています：
-
-1. **不変データ構造**: Driver, Route, Simulation は全て不変
-2. **関数合成**: step() を繰り返し適用
-3. **DSL**: routes! マクロによる宣言的な定義
-4. **イテレータ**: 効率的なデータ処理
-
-## まとめ
-
-本章では、「ゴシップ好きなバスの運転手」問題を通じて：
-
-1. 不変データ構造による状態管理
-2. 純粋関数による状態遷移
-3. DSL による宣言的な問題定義
-4. イテレータを使った効率的な処理
-
-を学びました。関数型のアプローチにより、テストしやすく、理解しやすいコードが実現できます。
-
-## 参考コード
-
-- ソースコード: `apps/rust/part6/src/chapter15.rs`
-
-## 次章予告
-
-次章では、**給与計算システム**を通じて、より複雑なビジネスロジックの実装を学びます。