zesdex/src/tool/fs/helpers.rs

use std::path::Path;
use serde_json::Value;
use anyhow::{Result, anyhow};

pub fn arg_str(args: &Value, name: &str) -> Result<String> {
    args.get(name)
        .and_then(|v| v.as_str())
        .map(|s| s.to_string())
        .ok_or_else(|| anyhow!("missing required argument: {}", name))
}

pub fn not_found_help(ctx: &super::super::ToolCtx, path: &Path, rel: &str) -> String {
    let canon = path.canonicalize().unwrap_or_else(|_| path.to_path_buf());
    let in_ws = ctx.workspaces.iter().any(|w| {
        let wc = w.canonicalize().unwrap_or_else(|_| w.to_path_buf());
        canon.starts_with(&wc)
    });
    if !in_ws {
        format!(
            "path '{}' is outside all workspace roots. Workspace roots: {}",
            rel,
            ctx.workspaces.iter().map(|w| w.display().to_string()).collect::<Vec<_>>().join(", ")
        )
    } else {
        format!("path '{}' does not exist (resolved to {})", rel, canon.display())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    #[test]
    fn test_arg_str_found() {
        let args = json!({"key": "value"});
        assert_eq!(arg_str(&args, "key").unwrap(), "value");
    }

    #[test]
    fn test_arg_str_missing() {
        let args = json!({"other": "value"});
        assert!(arg_str(&args, "key").is_err());
    }

    #[test]
    fn test_arg_str_empty_string() {
        let args = json!({"key": ""});
        assert_eq!(arg_str(&args, "key").unwrap(), "");
    }

    #[test]
    fn test_arg_str_wrong_type() {
        let args = json!({"key": 42});
        assert!(arg_str(&args, "key").is_err());
    }

    #[test]
    fn test_arg_str_null() {
        let args = json!({"key": null});
        assert!(arg_str(&args, "key").is_err());
    }
}