claude-mpm 4.21.3__py3-none-any.whl → 5.1.9__py3-none-any.whl

claude_mpm/skills/bundled/rust/desktop-applications/references/architecture-patterns.md

@@ -1,901 +0,0 @@
-# Architecture Patterns
-
-Desktop-specific architectural patterns for building maintainable, scalable Rust applications with clear separation of concerns.
-
-## Core Architectural Patterns
-
-### MVC (Model-View-Controller)
-
-Traditional pattern adapted for desktop applications.
-
-```rust
-// Model - Application state and business logic
-mod model {
-    use serde::{Deserialize, Serialize};
-
-    #[derive(Clone, Debug, Serialize, Deserialize)]
-    pub struct User {
-        pub id: u64,
-        pub name: String,
-        pub email: String,
-    }
-
-    #[derive(Clone, Debug)]
-    pub struct UserModel {
-        users: Vec<User>,
-    }
-
-    impl UserModel {
-        pub fn new() -> Self {
-            Self { users: Vec::new() }
-        }
-
-        pub fn add_user(&mut self, user: User) {
-            self.users.push(user);
-        }
-
-        pub fn remove_user(&mut self, id: u64) {
-            self.users.retain(|u| u.id != id);
-        }
-
-        pub fn get_users(&self) -> &[User] {
-            &self.users
-        }
-
-        pub fn find_user(&self, id: u64) -> Option<&User> {
-            self.users.iter().find(|u| u.id == id)
-        }
-    }
-}
-
-// Controller - Handles user input and updates model
-mod controller {
-    use super::model::{User, UserModel};
-
-    pub struct UserController {
-        model: UserModel,
-    }
-
-    impl UserController {
-        pub fn new(model: UserModel) -> Self {
-            Self { model }
-        }
-
-        pub fn create_user(&mut self, name: String, email: String) -> Result<(), String> {
-            // Validation
-            if name.is_empty() {
-                return Err("Name cannot be empty".to_string());
-            }
-
-            let id = self.model.get_users().len() as u64 + 1;
-            let user = User { id, name, email };
-
-            self.model.add_user(user);
-            Ok(())
-        }
-
-        pub fn delete_user(&mut self, id: u64) -> Result<(), String> {
-            if self.model.find_user(id).is_none() {
-                return Err("User not found".to_string());
-            }
-
-            self.model.remove_user(id);
-            Ok(())
-        }
-
-        pub fn get_model(&self) -> &UserModel {
-            &self.model
-        }
-    }
-}
-
-// View - UI rendering (Tauri example)
-#[tauri::command]
-fn get_users(controller: tauri::State<UserController>) -> Vec<User> {
-    controller.get_model().get_users().to_vec()
-}
-
-#[tauri::command]
-fn create_user(
-    controller: tauri::State<UserController>,
-    name: String,
-    email: String,
-) -> Result<(), String> {
-    controller.inner().lock().unwrap().create_user(name, email)
-}
-```
-
-### MVVM (Model-View-ViewModel)
-
-Better for reactive UIs with two-way data binding.
-
-```rust
-use std::sync::{Arc, Mutex};
-use tokio::sync::broadcast;
-
-// Model - Business data
-#[derive(Clone, Debug)]
-pub struct TodoItem {
-    pub id: u64,
-    pub title: String,
-    pub completed: bool,
-}
-
-pub struct TodoModel {
-    items: Vec<TodoItem>,
-    next_id: u64,
-}
-
-impl TodoModel {
-    pub fn new() -> Self {
-        Self {
-            items: Vec::new(),
-            next_id: 1,
-        }
-    }
-
-    pub fn add_item(&mut self, title: String) -> TodoItem {
-        let item = TodoItem {
-            id: self.next_id,
-            title,
-            completed: false,
-        };
-        self.next_id += 1;
-        self.items.push(item.clone());
-        item
-    }
-
-    pub fn toggle_item(&mut self, id: u64) -> Option<bool> {
-        self.items
-            .iter_mut()
-            .find(|item| item.id == id)
-            .map(|item| {
-                item.completed = !item.completed;
-                item.completed
-            })
-    }
-
-    pub fn get_items(&self) -> &[TodoItem] {
-        &self.items
-    }
-}
-
-// ViewModel - Presentation logic and state
-pub struct TodoViewModel {
-    model: Arc<Mutex<TodoModel>>,
-    change_notifier: broadcast::Sender<ViewModelEvent>,
-}
-
-#[derive(Clone, Debug)]
-pub enum ViewModelEvent {
-    ItemAdded(TodoItem),
-    ItemToggled(u64, bool),
-    ItemsChanged,
-}
-
-impl TodoViewModel {
-    pub fn new() -> Self {
-        let (tx, _rx) = broadcast::channel(100);
-        Self {
-            model: Arc::new(Mutex::new(TodoModel::new())),
-            change_notifier: tx,
-        }
-    }
-
-    pub fn add_todo(&self, title: String) -> Result<(), String> {
-        if title.trim().is_empty() {
-            return Err("Title cannot be empty".to_string());
-        }
-
-        let mut model = self.model.lock().unwrap();
-        let item = model.add_item(title);
-        drop(model);
-
-        let _ = self.change_notifier.send(ViewModelEvent::ItemAdded(item));
-        Ok(())
-    }
-
-    pub fn toggle_todo(&self, id: u64) -> Result<(), String> {
-        let mut model = self.model.lock().unwrap();
-        let completed = model
-            .toggle_item(id)
-            .ok_or("Item not found".to_string())?;
-        drop(model);
-
-        let _ = self
-            .change_notifier
-            .send(ViewModelEvent::ItemToggled(id, completed));
-        Ok(())
-    }
-
-    pub fn get_todos(&self) -> Vec<TodoItem> {
-        self.model.lock().unwrap().get_items().to_vec()
-    }
-
-    pub fn subscribe(&self) -> broadcast::Receiver<ViewModelEvent> {
-        self.change_notifier.subscribe()
-    }
-}
-
-// View - Tauri commands
-#[tauri::command]
-async fn add_todo(viewmodel: tauri::State<'_, TodoViewModel>, title: String) -> Result<(), String> {
-    viewmodel.add_todo(title)
-}
-
-#[tauri::command]
-async fn toggle_todo(viewmodel: tauri::State<'_, TodoViewModel>, id: u64) -> Result<(), String> {
-    viewmodel.toggle_todo(id)
-}
-
-#[tauri::command]
-async fn get_todos(viewmodel: tauri::State<'_, TodoViewModel>) -> Vec<TodoItem> {
-    viewmodel.get_todos()
-}
-
-// Setup with change notifications
-fn main() {
-    let viewmodel = TodoViewModel::new();
-    let mut rx = viewmodel.subscribe();
-
-    // Background task to push updates to frontend
-    tokio::spawn(async move {
-        while let Ok(event) = rx.recv().await {
-            // Emit event to frontend
-            println!("ViewModel changed: {:?}", event);
-        }
-    });
-
-    tauri::Builder::default()
-        .manage(viewmodel)
-        .invoke_handler(tauri::generate_handler![add_todo, toggle_todo, get_todos])
-        .run(tauri::generate_context!())
-        .expect("error while running tauri application");
-}
-```
-
-### Command Pattern
-
-Encapsulate actions as objects for undo/redo functionality.
-
-```rust
-use std::fmt;
-
-// Command trait
-pub trait Command: fmt::Debug {
-    fn execute(&mut self, app: &mut Application) -> Result<(), String>;
-    fn undo(&mut self, app: &mut Application) -> Result<(), String>;
-    fn description(&self) -> String;
-}
-
-// Application state
-pub struct Application {
-    pub text: String,
-    pub cursor: usize,
-}
-
-// Concrete commands
-#[derive(Debug)]
-pub struct InsertTextCommand {
-    text: String,
-    position: usize,
-}
-
-impl Command for InsertTextCommand {
-    fn execute(&mut self, app: &mut Application) -> Result<(), String> {
-        app.text.insert_str(self.position, &self.text);
-        app.cursor = self.position + self.text.len();
-        Ok(())
-    }
-
-    fn undo(&mut self, app: &mut Application) -> Result<(), String> {
-        let start = self.position;
-        let end = self.position + self.text.len();
-        app.text.drain(start..end);
-        app.cursor = self.position;
-        Ok(())
-    }
-
-    fn description(&self) -> String {
-        format!("Insert '{}'", self.text)
-    }
-}
-
-#[derive(Debug)]
-pub struct DeleteTextCommand {
-    deleted_text: String,
-    position: usize,
-    length: usize,
-}
-
-impl Command for DeleteTextCommand {
-    fn execute(&mut self, app: &mut Application) -> Result<(), String> {
-        let start = self.position;
-        let end = self.position + self.length;
-        self.deleted_text = app.text.drain(start..end).collect();
-        app.cursor = self.position;
-        Ok(())
-    }
-
-    fn undo(&mut self, app: &mut Application) -> Result<(), String> {
-        app.text.insert_str(self.position, &self.deleted_text);
-        app.cursor = self.position + self.deleted_text.len();
-        Ok(())
-    }
-
-    fn description(&self) -> String {
-        format!("Delete {} characters", self.length)
-    }
-}
-
-// Command manager with undo/redo
-pub struct CommandManager {
-    history: Vec<Box<dyn Command>>,
-    current: usize,
-}
-
-impl CommandManager {
-    pub fn new() -> Self {
-        Self {
-            history: Vec::new(),
-            current: 0,
-        }
-    }
-
-    pub fn execute(&mut self, mut command: Box<dyn Command>, app: &mut Application) -> Result<(), String> {
-        command.execute(app)?;
-
-        // Clear redo history
-        self.history.truncate(self.current);
-        self.history.push(command);
-        self.current += 1;
-
-        Ok(())
-    }
-
-    pub fn undo(&mut self, app: &mut Application) -> Result<(), String> {
-        if self.current == 0 {
-            return Err("Nothing to undo".to_string());
-        }
-
-        self.current -= 1;
-        self.history[self.current].undo(app)?;
-        Ok(())
-    }
-
-    pub fn redo(&mut self, app: &mut Application) -> Result<(), String> {
-        if self.current >= self.history.len() {
-            return Err("Nothing to redo".to_string());
-        }
-
-        self.history[self.current].execute(app)?;
-        self.current += 1;
-        Ok(())
-    }
-
-    pub fn can_undo(&self) -> bool {
-        self.current > 0
-    }
-
-    pub fn can_redo(&self) -> bool {
-        self.current < self.history.len()
-    }
-
-    pub fn get_history(&self) -> Vec<String> {
-        self.history
-            .iter()
-            .take(self.current)
-            .map(|cmd| cmd.description())
-            .collect()
-    }
-}
-
-// Tauri integration
-use std::sync::Mutex;
-
-struct AppState {
-    app: Mutex<Application>,
-    commands: Mutex<CommandManager>,
-}
-
-#[tauri::command]
-fn insert_text(state: tauri::State<AppState>, text: String, position: usize) -> Result<(), String> {
-    let mut app = state.app.lock().unwrap();
-    let mut commands = state.commands.lock().unwrap();
-
-    let command = Box::new(InsertTextCommand { text, position });
-    commands.execute(command, &mut app)
-}
-
-#[tauri::command]
-fn undo(state: tauri::State<AppState>) -> Result<(), String> {
-    let mut app = state.app.lock().unwrap();
-    let mut commands = state.commands.lock().unwrap();
-    commands.undo(&mut app)
-}
-
-#[tauri::command]
-fn redo(state: tauri::State<AppState>) -> Result<(), String> {
-    let mut app = state.app.lock().unwrap();
-    let mut commands = state.commands.lock().unwrap();
-    commands.redo(&mut app)
-}
-```
-
-## Event-Driven Architecture
-
-### Event Bus Pattern
-
-```rust
-use std::collections::HashMap;
-use std::sync::{Arc, Mutex};
-use tokio::sync::mpsc;
-
-// Event types
-#[derive(Clone, Debug)]
-pub enum AppEvent {
-    UserLoggedIn { user_id: u64, username: String },
-    FileOpened { path: String },
-    DataChanged { entity: String, id: u64 },
-    ErrorOccurred { message: String },
-}
-
-// Event handler trait
-pub trait EventHandler: Send + Sync {
-    fn handle(&self, event: &AppEvent);
-}
-
-// Event bus
-pub struct EventBus {
-    handlers: Arc<Mutex<HashMap<String, Vec<Arc<dyn EventHandler>>>>>,
-    sender: mpsc::UnboundedSender<AppEvent>,
-}
-
-impl EventBus {
-    pub fn new() -> Self {
-        let handlers = Arc::new(Mutex::new(HashMap::new()));
-        let handlers_clone = handlers.clone();
-
-        let (sender, mut receiver) = mpsc::unbounded_channel();
-
-        // Background task to dispatch events
-        tokio::spawn(async move {
-            while let Some(event) = receiver.recv().await {
-                let event_type = format!("{:?}", event).split('{').next().unwrap().trim().to_string();
-                let handlers = handlers_clone.lock().unwrap();
-
-                if let Some(handlers_list) = handlers.get(&event_type) {
-                    for handler in handlers_list {
-                        handler.handle(&event);
-                    }
-                }
-            }
-        });
-
-        Self { handlers, sender }
-    }
-
-    pub fn subscribe(&self, event_type: &str, handler: Arc<dyn EventHandler>) {
-        let mut handlers = self.handlers.lock().unwrap();
-        handlers
-            .entry(event_type.to_string())
-            .or_insert_with(Vec::new)
-            .push(handler);
-    }
-
-    pub fn publish(&self, event: AppEvent) {
-        let _ = self.sender.send(event);
-    }
-}
-
-// Example handlers
-struct LoggingHandler;
-
-impl EventHandler for LoggingHandler {
-    fn handle(&self, event: &AppEvent) {
-        println!("[LOG] Event: {:?}", event);
-    }
-}
-
-struct AnalyticsHandler;
-
-impl EventHandler for AnalyticsHandler {
-    fn handle(&self, event: &AppEvent) {
-        // Send to analytics service
-        println!("[ANALYTICS] Tracking: {:?}", event);
-    }
-}
-
-// Usage
-fn setup_event_bus() -> EventBus {
-    let event_bus = EventBus::new();
-
-    event_bus.subscribe("UserLoggedIn", Arc::new(LoggingHandler));
-    event_bus.subscribe("UserLoggedIn", Arc::new(AnalyticsHandler));
-
-    event_bus
-}
-
-#[tauri::command]
-fn login_user(
-    event_bus: tauri::State<EventBus>,
-    user_id: u64,
-    username: String,
-) -> Result<(), String> {
-    // Perform login logic...
-
-    event_bus.publish(AppEvent::UserLoggedIn { user_id, username });
-
-    Ok(())
-}
-```
-
-## Plugin System
-
-### Dynamic Plugin Architecture
-
-```rust
-use std::collections::HashMap;
-use std::sync::Arc;
-
-// Plugin trait
-pub trait Plugin: Send + Sync {
-    fn name(&self) -> &str;
-    fn version(&self) -> &str;
-    fn initialize(&mut self, context: &PluginContext) -> Result<(), String>;
-    fn shutdown(&mut self) -> Result<(), String>;
-    fn execute(&self, command: &str, args: Vec<String>) -> Result<String, String>;
-}
-
-// Plugin context (shared resources)
-pub struct PluginContext {
-    pub app_name: String,
-    pub config_dir: String,
-}
-
-// Plugin manager
-pub struct PluginManager {
-    plugins: HashMap<String, Box<dyn Plugin>>,
-    context: Arc<PluginContext>,
-}
-
-impl PluginManager {
-    pub fn new(context: PluginContext) -> Self {
-        Self {
-            plugins: HashMap::new(),
-            context: Arc::new(context),
-        }
-    }
-
-    pub fn register(&mut self, mut plugin: Box<dyn Plugin>) -> Result<(), String> {
-        let name = plugin.name().to_string();
-
-        plugin.initialize(&self.context)?;
-        self.plugins.insert(name.clone(), plugin);
-
-        println!("Plugin registered: {}", name);
-        Ok(())
-    }
-
-    pub fn execute(
-        &self,
-        plugin_name: &str,
-        command: &str,
-        args: Vec<String>,
-    ) -> Result<String, String> {
-        self.plugins
-            .get(plugin_name)
-            .ok_or_else(|| format!("Plugin '{}' not found", plugin_name))?
-            .execute(command, args)
-    }
-
-    pub fn list_plugins(&self) -> Vec<(String, String)> {
-        self.plugins
-            .values()
-            .map(|p| (p.name().to_string(), p.version().to_string()))
-            .collect()
-    }
-
-    pub fn shutdown_all(&mut self) -> Result<(), String> {
-        for (name, plugin) in self.plugins.iter_mut() {
-            plugin.shutdown().map_err(|e| {
-                format!("Failed to shutdown plugin '{}': {}", name, e)
-            })?;
-        }
-        Ok(())
-    }
-}
-
-// Example plugin
-struct MarkdownPlugin {
-    enabled: bool,
-}
-
-impl Plugin for MarkdownPlugin {
-    fn name(&self) -> &str {
-        "markdown"
-    }
-
-    fn version(&self) -> &str {
-        "1.0.0"
-    }
-
-    fn initialize(&mut self, _context: &PluginContext) -> Result<(), String> {
-        self.enabled = true;
-        println!("Markdown plugin initialized");
-        Ok(())
-    }
-
-    fn shutdown(&mut self) -> Result<(), String> {
-        self.enabled = false;
-        println!("Markdown plugin shutdown");
-        Ok(())
-    }
-
-    fn execute(&self, command: &str, args: Vec<String>) -> Result<String, String> {
-        if !self.enabled {
-            return Err("Plugin not enabled".to_string());
-        }
-
-        match command {
-            "render" => {
-                if args.is_empty() {
-                    return Err("No markdown text provided".to_string());
-                }
-                // Simplified markdown rendering
-                Ok(format!("<html>{}</html>", args[0]))
-            }
-            _ => Err(format!("Unknown command: {}", command)),
-        }
-    }
-}
-
-// Tauri integration
-#[tauri::command]
-fn execute_plugin(
-    manager: tauri::State<PluginManager>,
-    plugin: String,
-    command: String,
-    args: Vec<String>,
-) -> Result<String, String> {
-    manager.execute(&plugin, &command, args)
-}
-
-#[tauri::command]
-fn list_plugins(manager: tauri::State<PluginManager>) -> Vec<(String, String)> {
-    manager.list_plugins()
-}
-```
-
-## Resource Management
-
-### Resource Pool Pattern
-
-```rust
-use std::sync::{Arc, Mutex};
-use std::collections::VecDeque;
-
-pub struct ResourcePool<T> {
-    resources: Arc<Mutex<VecDeque<T>>>,
-    factory: Arc<dyn Fn() -> T + Send + Sync>,
-    max_size: usize,
-}
-
-impl<T: Send + 'static> ResourcePool<T> {
-    pub fn new<F>(factory: F, max_size: usize) -> Self
-    where
-        F: Fn() -> T + Send + Sync + 'static,
-    {
-        Self {
-            resources: Arc::new(Mutex::new(VecDeque::new())),
-            factory: Arc::new(factory),
-            max_size,
-        }
-    }
-
-    pub fn acquire(&self) -> PooledResource<T> {
-        let resource = {
-            let mut pool = self.resources.lock().unwrap();
-            pool.pop_front().unwrap_or_else(|| (self.factory)())
-        };
-
-        PooledResource {
-            resource: Some(resource),
-            pool: self.resources.clone(),
-            max_size: self.max_size,
-        }
-    }
-
-    pub fn size(&self) -> usize {
-        self.resources.lock().unwrap().len()
-    }
-}
-
-pub struct PooledResource<T> {
-    resource: Option<T>,
-    pool: Arc<Mutex<VecDeque<T>>>,
-    max_size: usize,
-}
-
-impl<T> PooledResource<T> {
-    pub fn get(&self) -> &T {
-        self.resource.as_ref().unwrap()
-    }
-
-    pub fn get_mut(&mut self) -> &mut T {
-        self.resource.as_mut().unwrap()
-    }
-}
-
-impl<T> Drop for PooledResource<T> {
-    fn drop(&mut self) {
-        if let Some(resource) = self.resource.take() {
-            let mut pool = self.pool.lock().unwrap();
-            if pool.len() < self.max_size {
-                pool.push_back(resource);
-            }
-        }
-    }
-}
-
-// Example: Database connection pool
-use sqlx::{SqlitePool, SqliteConnection};
-
-pub struct DatabasePool {
-    pool: ResourcePool<SqliteConnection>,
-}
-
-impl DatabasePool {
-    pub async fn new(database_url: &str, max_size: usize) -> Self {
-        let url = database_url.to_string();
-        Self {
-            pool: ResourcePool::new(
-                move || {
-                    // This would need to be async in real implementation
-                    unimplemented!("Use sqlx::SqlitePool instead")
-                },
-                max_size,
-            ),
-        }
-    }
-}
-```
-
-## Error Handling Strategies
-
-### Application-Level Error Types
-
-```rust
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum AppError {
-    #[error("Database error: {0}")]
-    Database(#[from] sqlx::Error),
-
-    #[error("IO error: {0}")]
-    Io(#[from] std::io::Error),
-
-    #[error("Serialization error: {0}")]
-    Serialization(#[from] serde_json::Error),
-
-    #[error("Not found: {0}")]
-    NotFound(String),
-
-    #[error("Validation error: {0}")]
-    Validation(String),
-
-    #[error("Permission denied: {0}")]
-    PermissionDenied(String),
-
-    #[error("Internal error: {0}")]
-    Internal(String),
-}
-
-// Convert to Tauri-compatible error
-impl From<AppError> for String {
-    fn from(error: AppError) -> Self {
-        error.to_string()
-    }
-}
-
-// Result type alias
-pub type AppResult<T> = Result<T, AppError>;
-
-// Usage in commands
-#[tauri::command]
-async fn save_data(data: String) -> Result<(), String> {
-    perform_save(&data)
-        .await
-        .map_err(|e: AppError| e.to_string())
-}
-
-async fn perform_save(data: &str) -> AppResult<()> {
-    // Validation
-    if data.is_empty() {
-        return Err(AppError::Validation("Data cannot be empty".to_string()));
-    }
-
-    // IO operation
-    std::fs::write("data.txt", data)?;
-
-    Ok(())
-}
-```
-
-### Error Recovery Pattern
-
-```rust
-use std::time::Duration;
-use tokio::time::sleep;
-
-pub struct RetryPolicy {
-    max_attempts: u32,
-    delay: Duration,
-    exponential_backoff: bool,
-}
-
-impl RetryPolicy {
-    pub fn new(max_attempts: u32, delay: Duration) -> Self {
-        Self {
-            max_attempts,
-            delay,
-            exponential_backoff: false,
-        }
-    }
-
-    pub fn with_exponential_backoff(mut self) -> Self {
-        self.exponential_backoff = true;
-        self
-    }
-
-    pub async fn execute<F, T, E>(&self, mut operation: F) -> Result<T, E>
-    where
-        F: FnMut() -> Result<T, E>,
-        E: std::fmt::Display,
-    {
-        let mut attempt = 0;
-        let mut delay = self.delay;
-
-        loop {
-            attempt += 1;
-
-            match operation() {
-                Ok(result) => return Ok(result),
-                Err(error) => {
-                    if attempt >= self.max_attempts {
-                        println!("Operation failed after {} attempts", attempt);
-                        return Err(error);
-                    }
-
-                    println!(
-                        "Attempt {} failed: {}. Retrying in {:?}...",
-                        attempt, error, delay
-                    );
-
-                    sleep(delay).await;
-
-                    if self.exponential_backoff {
-                        delay *= 2;
-                    }
-                }
-            }
-        }
-    }
-}
-
-// Usage
-async fn fetch_with_retry(url: &str) -> Result<String, String> {
-    let policy = RetryPolicy::new(3, Duration::from_secs(1))
-        .with_exponential_backoff();
-
-    policy
-        .execute(|| {
-            // Attempt operation
-            Ok("data".to_string())
-        })
-        .await
-}
-```
-
-These patterns provide a solid foundation for building maintainable desktop applications. Choose and combine based on application complexity and requirements.