ricecoder_hooks/config/

reloader.rs

//! Configuration reloading for hooks
//!
//! Provides functionality to detect configuration changes and reload hooks
//! without restarting the application. Preserves hook state (enabled/disabled)
//! during reload.

use crate::error::{HooksError, Result};
use crate::types::Hook;
use std::collections::HashMap;
use std::fs;
use std::path::{Path, PathBuf};
use std::time::SystemTime;

/// Configuration reloader for detecting and applying configuration changes
///
/// Monitors configuration files for changes and reloads hooks when changes
/// are detected. Preserves hook state (enabled/disabled) during reload.
pub struct ConfigReloader {
    /// Last known modification time of project config
    project_config_mtime: Option<SystemTime>,

    /// Last known modification time of user config
    user_config_mtime: Option<SystemTime>,

    /// Current hook state (enabled/disabled)
    hook_state: HashMap<String, bool>,
}

impl ConfigReloader {
    /// Create a new configuration reloader
    pub fn new() -> Self {
        Self {
            project_config_mtime: None,
            user_config_mtime: None,
            hook_state: HashMap::new(),
        }
    }

    /// Check if configuration has changed
    ///
    /// Returns true if any configuration file has been modified since the last check.
    pub fn has_changed(&mut self) -> Result<bool> {
        let project_path = PathBuf::from(".ricecoder/hooks.yaml");
        let project_mtime = Self::get_file_mtime(&project_path)?;

        let user_path = Self::get_user_config_path()?;
        let user_mtime = Self::get_file_mtime(&user_path)?;

        let changed =
            project_mtime != self.project_config_mtime || user_mtime != self.user_config_mtime;

        if changed {
            self.project_config_mtime = project_mtime;
            self.user_config_mtime = user_mtime;
        }

        Ok(changed)
    }

    /// Save hook state before reload
    ///
    /// Saves the enabled/disabled state of all hooks so it can be restored
    /// after reloading configuration.
    pub fn save_hook_state(&mut self, hooks: &HashMap<String, Hook>) {
        self.hook_state.clear();
        for (id, hook) in hooks {
            self.hook_state.insert(id.clone(), hook.enabled);
        }
    }

    /// Restore hook state after reload
    ///
    /// Restores the enabled/disabled state of hooks after reloading configuration.
    /// Hooks that were disabled before reload remain disabled, and hooks that were
    /// enabled remain enabled.
    pub fn restore_hook_state(&self, hooks: &mut HashMap<String, Hook>) {
        for (id, hook) in hooks.iter_mut() {
            if let Some(&enabled) = self.hook_state.get(id) {
                hook.enabled = enabled;
            }
        }
    }

    /// Get the modification time of a file
    ///
    /// Returns None if the file doesn't exist.
    fn get_file_mtime(path: &Path) -> Result<Option<SystemTime>> {
        if !path.exists() {
            return Ok(None);
        }

        let metadata = fs::metadata(path)
            .map_err(|e| HooksError::StorageError(format!("Failed to get file metadata: {}", e)))?;

        let mtime = metadata.modified().map_err(|e| {
            HooksError::StorageError(format!("Failed to get modification time: {}", e))
        })?;

        Ok(Some(mtime))
    }

    /// Get the user configuration path
    fn get_user_config_path() -> Result<PathBuf> {
        use ricecoder_storage::PathResolver;

        let global_path = PathResolver::resolve_global_path()
            .map_err(|e| HooksError::StorageError(e.to_string()))?;
        Ok(global_path.join("hooks.yaml"))
    }
}

impl Default for ConfigReloader {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::io::Write;
    use std::thread;
    use std::time::Duration;
    use tempfile::NamedTempFile;

    #[test]
    fn test_new_reloader() {
        let reloader = ConfigReloader::new();
        assert!(reloader.project_config_mtime.is_none());
        assert!(reloader.user_config_mtime.is_none());
        assert_eq!(reloader.hook_state.len(), 0);
    }

    #[test]
    fn test_save_and_restore_hook_state() {
        let mut reloader = ConfigReloader::new();

        // Create test hooks
        let mut hooks = HashMap::new();
        hooks.insert(
            "hook1".to_string(),
            Hook {
                id: "hook1".to_string(),
                name: "Hook 1".to_string(),
                description: None,
                event: "event1".to_string(),
                action: crate::types::Action::Command(crate::types::CommandAction {
                    command: "cmd".to_string(),
                    args: vec![],
                    timeout_ms: None,
                    capture_output: false,
                }),
                enabled: true,
                tags: vec![],
                metadata: serde_json::json!({}),
                condition: None,
            },
        );

        hooks.insert(
            "hook2".to_string(),
            Hook {
                id: "hook2".to_string(),
                name: "Hook 2".to_string(),
                description: None,
                event: "event2".to_string(),
                action: crate::types::Action::Command(crate::types::CommandAction {
                    command: "cmd".to_string(),
                    args: vec![],
                    timeout_ms: None,
                    capture_output: false,
                }),
                enabled: false,
                tags: vec![],
                metadata: serde_json::json!({}),
                condition: None,
            },
        );

        // Save state
        reloader.save_hook_state(&hooks);
        assert_eq!(reloader.hook_state.len(), 2);
        assert_eq!(reloader.hook_state.get("hook1"), Some(&true));
        assert_eq!(reloader.hook_state.get("hook2"), Some(&false));

        // Modify hooks
        hooks.get_mut("hook1").unwrap().enabled = false;
        hooks.get_mut("hook2").unwrap().enabled = true;

        // Restore state
        reloader.restore_hook_state(&mut hooks);
        assert!(hooks.get("hook1").unwrap().enabled);
        assert!(!hooks.get("hook2").unwrap().enabled);
    }

    #[test]
    fn test_get_file_mtime_nonexistent() {
        let path = PathBuf::from("/nonexistent/path/file.yaml");
        let mtime = ConfigReloader::get_file_mtime(&path).expect("Should not error");
        assert!(mtime.is_none());
    }

    #[test]
    fn test_get_file_mtime_existing() {
        let temp_file = NamedTempFile::new().expect("Should create temp file");
        let path = temp_file.path();

        let mtime = ConfigReloader::get_file_mtime(path).expect("Should get mtime");
        assert!(mtime.is_some());
    }

    #[test]
    fn test_has_changed_no_files() {
        let mut reloader = ConfigReloader::new();
        let changed = reloader.has_changed().expect("Should check for changes");
        // Should return false since no files exist
        assert!(!changed);
    }

    #[test]
    fn test_has_changed_detects_modification() {
        let mut reloader = ConfigReloader::new();

        // Create a temporary file
        let mut temp_file = NamedTempFile::new().expect("Should create temp file");
        let path = temp_file.path().to_path_buf();

        // Write initial content
        temp_file.write_all(b"initial").expect("Should write");
        temp_file.flush().expect("Should flush");

        // First check should detect the file
        let _changed1 = reloader.has_changed().expect("Should check");

        // Wait a bit to ensure time difference
        thread::sleep(Duration::from_millis(100));

        // Modify the file
        temp_file.write_all(b" modified").expect("Should write");
        temp_file.flush().expect("Should flush");

        // Second check should detect the modification
        let _changed2 = reloader.has_changed().expect("Should check");

        // Clean up
        drop(temp_file);
        drop(path);

        // Note: This test may be flaky on some systems due to filesystem timestamp resolution
        // In practice, the reloader would be used with actual config files
    }
}