@k2works/claude-code-booster 3.0.0 → 3.1.0

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

@@ -0,0 +1,392 @@
+# 第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

@@ -0,0 +1,300 @@
+# 第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`
+
+## 次章予告
+
+次章では、**給与計算システム**を通じて、より複雑なビジネスロジックの実装を学びます。