mcp_sync/

utils.rs

//! # mcp-sync utilities
//!
//! Common helper functions for file operations, JSON/TOML manipulation,
//! and path resolution.

use anyhow::{anyhow, Context, Result};
use serde_json::Value as JsonValue;
use std::{
    fs,
    path::{Path, PathBuf},
};
use time::OffsetDateTime;

/// Returns the user's home directory.
pub fn home() -> Result<PathBuf> {
    dirs::home_dir().ok_or_else(|| anyhow!("no home directory found"))
}

/// Finds the git repository root by traversing up from `start`.
/// Returns `start` if no `.git` directory is found.
pub fn find_git_root(start: &Path) -> PathBuf {
    let mut cur = start.to_path_buf();
    loop {
        if cur.join(".git").exists() {
            return cur;
        }
        if !cur.pop() {
            return start.to_path_buf();
        }
    }
}

/// Generates a timestamp string in `YYYYMMDD-HHMMSS` format.
pub fn now_stamp() -> String {
    let dt = OffsetDateTime::now_local().unwrap_or_else(|_| OffsetDateTime::now_utc());
    dt.format(&time::format_description::parse("[year][month][day]-[hour][minute][second]").unwrap())
        .unwrap()
}

/// Creates a backup copy of a file with a timestamped extension.
///
/// # Arguments
/// * `path` - The file to back up
///
/// # Returns
/// `Ok(())` if the backup was created or the file doesn't exist.
pub fn backup(path: &Path) -> Result<()> {
    if !path.exists() {
        return Ok(());
    }
    let ext = path.extension().and_then(|s| s.to_str()).unwrap_or("");
    let bak = path.with_extension(format!("{}.bak.{}", ext, now_stamp()));
    fs::copy(path, &bak).with_context(|| format!("backup {:?} -> {:?}", path, bak))?;
    Ok(())
}

/// Ensures that the parent directory of `path` exists.
pub fn ensure_parent(path: &Path) -> Result<()> {
    if let Some(p) = path.parent() {
        fs::create_dir_all(p).with_context(|| format!("create dirs {:?}", p))?;
    }
    Ok(())
}

/// Prints a message to stderr if `verbose` is true.
#[inline]
pub fn log_verbose(verbose: bool, msg: impl AsRef<str>) {
    if verbose {
        eprintln!("{}", msg.as_ref());
    }
}

// ─────────────────────────── JSON Helpers ───────────────────────────

/// Reads a JSON file, returning an empty object if the file doesn't exist.
pub fn read_json_file(path: &Path) -> Result<JsonValue> {
    if !path.exists() {
        return Ok(JsonValue::Object(serde_json::Map::new()));
    }
    let s = fs::read_to_string(path).with_context(|| format!("read {:?}", path))?;
    let v: JsonValue = serde_json::from_str(&s).with_context(|| format!("parse JSON {:?}", path))?;
    Ok(v)
}

/// Writes a JSON value to a file with pretty-printing.
/// Creates a backup before writing.
pub fn write_json_file(path: &Path, v: &JsonValue, dry_run: bool) -> Result<()> {
    let s = serde_json::to_string_pretty(v).context("stringify JSON")? + "\n";
    if dry_run {
        return Ok(());
    }
    ensure_parent(path)?;
    backup(path)?;
    fs::write(path, s).with_context(|| format!("write {:?}", path))?;
    Ok(())
}

/// Returns a mutable reference to the JSON object, or an error if not an object.
pub fn json_obj_mut(v: &mut JsonValue) -> Result<&mut serde_json::Map<String, JsonValue>> {
    v.as_object_mut()
        .ok_or_else(|| anyhow!("expected JSON object"))
}

/// Gets or creates a nested object at `key`.
pub fn json_get_obj_mut<'a>(
    root: &'a mut JsonValue,
    key: &str,
) -> Result<&'a mut serde_json::Map<String, JsonValue>> {
    let obj = json_obj_mut(root)?;
    if !obj.contains_key(key) {
        obj.insert(key.to_string(), JsonValue::Object(serde_json::Map::new()));
    }
    obj.get_mut(key)
        .and_then(|v| v.as_object_mut())
        .ok_or_else(|| anyhow!("expected object at key {}", key))
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs;
    use tempfile::TempDir;

    // ─────────────────────────── find_git_root tests ───────────────────────────

    #[test]
    fn test_find_git_root_with_git_dir() {
        let temp = TempDir::new().unwrap();
        let git_dir = temp.path().join(".git");
        fs::create_dir(&git_dir).unwrap();
        
        let result = find_git_root(temp.path());
        assert_eq!(result, temp.path());
    }

    #[test]
    fn test_find_git_root_in_subdirectory() {
        let temp = TempDir::new().unwrap();
        let git_dir = temp.path().join(".git");
        fs::create_dir(&git_dir).unwrap();
        
        let subdir = temp.path().join("src").join("deep");
        fs::create_dir_all(&subdir).unwrap();
        
        let result = find_git_root(&subdir);
        assert_eq!(result, temp.path());
    }

    #[test]
    fn test_find_git_root_no_git_returns_start() {
        let temp = TempDir::new().unwrap();
        let subdir = temp.path().join("some").join("path");
        fs::create_dir_all(&subdir).unwrap();
        
        let result = find_git_root(&subdir);
        assert_eq!(result, subdir);
    }

    // ─────────────────────────── now_stamp tests ───────────────────────────

    #[test]
    fn test_now_stamp_format() {
        let stamp = now_stamp();
        // Format: YYYYMMDD-HHMMSS (15 characters)
        assert_eq!(stamp.len(), 15);
        assert!(stamp.contains('-'));
        
        // Should be numeric except for the dash
        let parts: Vec<&str> = stamp.split('-').collect();
        assert_eq!(parts.len(), 2);
        assert!(parts[0].chars().all(|c| c.is_ascii_digit()));
        assert!(parts[1].chars().all(|c| c.is_ascii_digit()));
    }

    // ─────────────────────────── ensure_parent tests ───────────────────────────

    #[test]
    fn test_ensure_parent_creates_directory() {
        let temp = TempDir::new().unwrap();
        let file_path = temp.path().join("deep").join("nested").join("file.json");
        
        ensure_parent(&file_path).unwrap();
        
        assert!(file_path.parent().unwrap().exists());
    }

    #[test]
    fn test_ensure_parent_existing_directory() {
        let temp = TempDir::new().unwrap();
        let file_path = temp.path().join("file.json");
        
        // Should not fail for existing parent
        ensure_parent(&file_path).unwrap();
    }

    // ─────────────────────────── backup tests ───────────────────────────

    #[test]
    fn test_backup_nonexistent_file_ok() {
        let temp = TempDir::new().unwrap();
        let file_path = temp.path().join("nonexistent.json");
        
        // Should succeed for nonexistent files
        backup(&file_path).unwrap();
    }

    #[test]
    fn test_backup_creates_backup_file() {
        let temp = TempDir::new().unwrap();
        let file_path = temp.path().join("config.json");
        fs::write(&file_path, r#"{"test": true}"#).unwrap();
        
        backup(&file_path).unwrap();
        
        // Check that a backup file was created
        let entries: Vec<_> = fs::read_dir(temp.path()).unwrap().collect();
        assert_eq!(entries.len(), 2); // Original + backup
        
        // Verify backup contains same content
        let backup_file = entries.iter()
            .map(|e| e.as_ref().unwrap().path())
            .find(|p| p.to_string_lossy().contains(".bak."))
            .unwrap();
        let backup_content = fs::read_to_string(&backup_file).unwrap();
        assert_eq!(backup_content, r#"{"test": true}"#);
    }

    // ─────────────────────────── JSON helpers tests ───────────────────────────

    #[test]
    fn test_read_json_file_nonexistent_returns_empty_object() {
        let temp = TempDir::new().unwrap();
        let file_path = temp.path().join("nonexistent.json");
        
        let result = read_json_file(&file_path).unwrap();
        
        assert!(result.is_object());
        assert!(result.as_object().unwrap().is_empty());
    }

    #[test]
    fn test_read_json_file_valid_json() {
        let temp = TempDir::new().unwrap();
        let file_path = temp.path().join("config.json");
        fs::write(&file_path, r#"{"name": "test", "value": 42}"#).unwrap();
        
        let result = read_json_file(&file_path).unwrap();
        
        assert_eq!(result["name"], "test");
        assert_eq!(result["value"], 42);
    }

    #[test]
    fn test_read_json_file_invalid_json_error() {
        let temp = TempDir::new().unwrap();
        let file_path = temp.path().join("invalid.json");
        fs::write(&file_path, "not valid json {").unwrap();
        
        let result = read_json_file(&file_path);
        
        assert!(result.is_err());
    }

    #[test]
    fn test_write_json_file_creates_file() {
        let temp = TempDir::new().unwrap();
        let file_path = temp.path().join("output.json");
        let value = serde_json::json!({"key": "value"});
        
        write_json_file(&file_path, &value, false).unwrap();
        
        assert!(file_path.exists());
        let content = fs::read_to_string(&file_path).unwrap();
        assert!(content.contains(r#""key": "value""#));
    }

    #[test]
    fn test_write_json_file_dry_run_no_write() {
        let temp = TempDir::new().unwrap();
        let file_path = temp.path().join("output.json");
        let value = serde_json::json!({"key": "value"});
        
        write_json_file(&file_path, &value, true).unwrap();
        
        assert!(!file_path.exists());
    }

    #[test]
    fn test_write_json_file_creates_parent_dirs() {
        let temp = TempDir::new().unwrap();
        let file_path = temp.path().join("deep").join("nested").join("output.json");
        let value = serde_json::json!({});
        
        write_json_file(&file_path, &value, false).unwrap();
        
        assert!(file_path.exists());
    }

    #[test]
    fn test_json_obj_mut_on_object() {
        let mut value = serde_json::json!({"key": "value"});
        
        let obj = json_obj_mut(&mut value).unwrap();
        obj.insert("new_key".to_string(), JsonValue::String("new_value".to_string()));
        
        assert_eq!(value["new_key"], "new_value");
    }

    #[test]
    fn test_json_obj_mut_on_non_object_error() {
        let mut value = serde_json::json!("string");
        
        let result = json_obj_mut(&mut value);
        
        assert!(result.is_err());
    }

    #[test]
    fn test_json_get_obj_mut_existing_key() {
        let mut value = serde_json::json!({"servers": {"test": {}}});
        
        let servers = json_get_obj_mut(&mut value, "servers").unwrap();
        
        assert!(servers.contains_key("test"));
    }

    #[test]
    fn test_json_get_obj_mut_creates_key() {
        let mut value = serde_json::json!({});
        
        let servers = json_get_obj_mut(&mut value, "servers").unwrap();
        servers.insert("test".to_string(), serde_json::json!({}));
        
        assert!(value["servers"]["test"].is_object());
    }

    #[test]
    fn test_json_get_obj_mut_nested_key_not_object_error() {
        let mut value = serde_json::json!({"servers": "not an object"});
        
        let result = json_get_obj_mut(&mut value, "servers");
        
        assert!(result.is_err());
    }

    // ─────────────────────────── log_verbose tests ───────────────────────────

    #[test]
    fn test_log_verbose_false_no_panic() {
        // Should not panic
        log_verbose(false, "test message");
    }

    #[test]
    fn test_log_verbose_true_no_panic() {
        // Should not panic (output goes to stderr)
        log_verbose(true, "test message");
    }

    // ─────────────────────────── home tests ───────────────────────────

    #[test]
    fn test_home_returns_path() {
        let result = home();
        // On most systems, this should succeed
        assert!(result.is_ok());
        assert!(result.unwrap().is_absolute());
    }
}