cargo_nvim/

cargo_commands.rs

// src/cargo_commands.rs
use crate::lua_exports::set_input_sender;
use mlua::prelude::*;
use std::process::Stdio;
use std::sync::Arc;
use std::time::Duration;
use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
use tokio::process::Command as TokioCommand;
use tokio::runtime::Runtime;
use tokio::sync::mpsc;

/// Structure for handling Cargo commands
/// Contains a runtime for async operations
#[derive(Clone)]
pub struct CargoCommands {
    runtime: Arc<Runtime>,
}

impl CargoCommands {
    /// Create a new CargoCommands instance
    pub fn new() -> LuaResult<Self> {
        Ok(Self {
            runtime: Arc::new(
                tokio::runtime::Builder::new_current_thread()
                    .enable_all()
                    .build()
                    .map_err(|e| LuaError::RuntimeError(e.to_string()))?,
            ),
        })
    }

    /// Executes a future on the runtime
    pub fn execute<F, T>(&self, future: F) -> T
    where
        F: std::future::Future<Output = T>,
    {
        self.runtime.block_on(future)
    }

    /// Execute a Cargo command with the given arguments
    #[cfg(not(test))]
    #[allow(dead_code)]
    async fn execute_cargo_command(
        &self,
        command: &str,
        args: &[&str],
    ) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_internal(command, args, None)
            .await
    }

    /// Execute a Cargo command with the given arguments (public for testing)
    #[cfg(test)]
    pub async fn execute_cargo_command(
        &self,
        command: &str,
        args: &[&str],
    ) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_internal(command, args, None)
            .await
    }

    /// Execute a Cargo command with timeout and interactive mode support
    async fn execute_cargo_command_internal(
        &self,
        command: &str,
        args: &[&str],
        timeout_duration: Option<Duration>,
    ) -> LuaResult<(String, bool)> {
        let mut cmd = TokioCommand::new("cargo");
        cmd.arg(command)
            .args(args)
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::piped());

        // Always set a timeout (with default values)
        let command_timeout = timeout_duration.unwrap_or_else(|| {
            match command {
                "run" => Duration::from_secs(300),   // 5 minutes
                "test" => Duration::from_secs(300),  // 5 minutes
                "bench" => Duration::from_secs(600), // 10 minutes
                _ => Duration::from_secs(120),       // 2 minutes
            }
        });

        let mut child = cmd.spawn().map_err(|e| {
            LuaError::RuntimeError(format!("Failed to execute cargo {}: {}", command, e))
        })?;

        let stdout = child.stdout.take().unwrap();
        let stderr = child.stderr.take().unwrap();
        let stdin = child.stdin.take().unwrap();

        // Create buffered streams
        let mut stdout_reader = BufReader::new(stdout).lines();
        let mut stderr_reader = BufReader::new(stderr).lines();

        // Interactive mode detection flag
        let mut is_interactive = false;

        // Assume interactive mode based on command name
        if command == "run" {
            // Treat run command as interactive by default
            is_interactive = true;
        }

        // Output buffer
        let output = String::new();

        // Channel for standard input
        let (tx, mut rx) = mpsc::channel::<String>(32);
        set_input_sender(tx.clone());

        // Task to handle standard input
        let stdin_handle = tokio::spawn(async move {
            let mut stdin = stdin;
            while let Some(input) = rx.recv().await {
                match stdin.write_all(input.as_bytes()).await {
                    Ok(_) => {
                        if let Err(e) = stdin.flush().await {
                            eprintln!("Failed to flush stdin: {}", e);
                            break;
                        }
                    }
                    Err(e) => {
                        eprintln!("Failed to write to stdin: {}", e);
                        break;
                    }
                }
            }
        });

        // Asynchronous IO processing and timeout control
        let output_handle = tokio::spawn(async move {
            let mut combined_output = String::new();
            let start_time = std::time::Instant::now();

            // Output reading loop
            loop {
                let timeout_remaining = command_timeout
                    .checked_sub(start_time.elapsed())
                    .unwrap_or_else(|| Duration::from_secs(1));

                // Monitor both stdout and stderr simultaneously
                tokio::select! {
                    // Reading standard output
                    stdout_result = stdout_reader.next_line() => {
                        match stdout_result {
                            Ok(Some(line)) => {
                                // Detect interactive mode based on specific patterns
                                if !is_interactive && (
                                    line.contains("? [Y/n]") ||
                                    line.contains("Enter password:") ||
                                    line.contains("> ") ||
                                    line.contains("[1/3]") ||
                                    line.ends_with("? ") ||
                                    line.trim().is_empty() // Empty line may indicate interactive mode
                                ) {
                                    is_interactive = true;
                                }

                                combined_output.push_str(&line);
                                combined_output.push('\n');
                            },
                            Ok(None) => break, // EOF
                            Err(_) => break,
                        }
                    },

                    // Reading standard error
                    stderr_result = stderr_reader.next_line() => {
                        match stderr_result {
                            Ok(Some(line)) => {
                                combined_output.push_str(&line);
                                combined_output.push('\n');
                            },
                            Ok(None) => {}, // Stdout might still have data
                            Err(_) => {},
                        }
                    },

                    // Timeout processing (only for non-interactive mode)
                    _ = tokio::time::sleep(timeout_remaining), if !is_interactive => {
                        return (combined_output, is_interactive, true); // Timeout
                    }
                }

                // Check timeout (even for interactive mode)
                if start_time.elapsed() >= command_timeout {
                    return (combined_output, is_interactive, true);
                }

                // For interactive mode, use an extended timeout (3x normal timeout)
                // but still terminate after excessive inactivity
                if is_interactive
                    && start_time.elapsed() >= Duration::from_secs(command_timeout.as_secs() * 3)
                {
                    return (combined_output, is_interactive, true);
                }
            }

            (combined_output, is_interactive, false)
        });

        // Wait for process completion
        let process_status = tokio::select! {
            status = child.wait() => {
                match status {
                    Ok(s) => (s.success(), false), // (succeeded, timed out)
                    Err(_) => (false, false),
                }
            },
            _ = tokio::time::sleep(command_timeout) => {
                // Timeout occurred
                child.kill().await.ok(); // Force terminate the process
                (false, true)
            }
        };

        // Get results from output processing task
        let output_result = match tokio::time::timeout(Duration::from_secs(5), output_handle).await
        {
            Ok(Ok((out, interactive, _))) => (out, interactive),
            _ => (output, is_interactive),
        };

        // Resource cleanup
        stdin_handle.abort();
        drop(tx);
        // rx is already moved into the stdin_handle task
        // and will be dropped when the task is aborted

        // Process the results
        let (process_success, process_timeout) = process_status;
        let (final_output, is_interactive_mode) = output_result;

        // Check if process timed out
        if process_timeout && !is_interactive_mode {
            return Err(LuaError::RuntimeError(format!(
                "cargo {} timed out after {} seconds",
                command,
                command_timeout.as_secs()
            )));
        }

        // Check if process failed
        if !process_success && !is_interactive_mode {
            return Err(LuaError::RuntimeError(format!(
                "cargo {} failed: {}",
                command, final_output
            )));
        }

        Ok((final_output, is_interactive_mode))
    }

    /// Check the project for errors
    pub async fn cargo_check(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        let result = self
            .execute_cargo_command_internal("check", args, None)
            .await;

        // If the command executed successfully but the output is empty, provide a default message
        match result {
            Ok((output, interactive)) if output.trim().is_empty() => Ok((
                "Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.00s".to_string(),
                interactive,
            )),
            other => other,
        }
    }

    /// Execute a Cargo command with automatic interactive mode detection
    async fn execute_cargo_command_smart(
        &self,
        command: &str,
        args: &[&str],
    ) -> LuaResult<(String, bool)> {
        // 特定のコマンドは常にインタラクティブモードとして扱う
        let result = self
            .execute_cargo_command_internal(command, args, None)
            .await?;

        // run コマンドは常にインタラクティブモードとして扱う
        if command == "run" {
            return Ok((result.0, true));
        }

        Ok(result)
    }

    /// Run benchmarks
    pub async fn cargo_bench(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_smart("bench", args).await
    }

    /// Build the project
    pub async fn cargo_build(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_smart("build", args).await
    }

    /// Run the project
    pub async fn cargo_run(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        // Designed to support interactive programs
        let result = self
            .execute_cargo_command_internal("run", args, None)
            .await?;

        // Check if proconio is likely being used by examining Cargo.toml
        // This is important for competitive programming scenarios where proconio::input! is common
        let has_proconio = std::fs::read_to_string("Cargo.toml")
            .map(|content| content.contains("proconio"))
            .unwrap_or(false);

        // If proconio is used, force interactive mode
        if has_proconio {
            return Ok((result.0, true));
        }

        Ok(result)
    }

    /// Run the tests
    pub async fn cargo_test(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_smart("test", args).await
    }

    /// Clean the target directory
    pub async fn cargo_clean(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_internal("clean", args, None)
            .await
    }

    /// Generate documentation
    pub async fn cargo_doc(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_internal("doc", args, None).await
    }

    /// Create a new package
    pub async fn cargo_new(&self, name: &str, args: &[&str]) -> LuaResult<(String, bool)> {
        let mut full_args = vec![name];
        full_args.extend_from_slice(args);
        self.execute_cargo_command_internal("new", &full_args, None)
            .await
    }

    /// Update dependencies
    pub async fn cargo_update(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_internal("update", args, None)
            .await
    }

    // Additional Cargo Commands

    /// Initialize a new package in an existing directory
    pub async fn cargo_init(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_internal("init", args, None)
            .await
    }

    /// Add dependencies to a manifest file
    pub async fn cargo_add(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_internal("add", args, None).await
    }

    /// Remove dependencies from a manifest file
    pub async fn cargo_remove(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_internal("remove", args, None)
            .await
    }

    /// Format Rust code
    pub async fn cargo_fmt(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_internal("fmt", args, None).await
    }

    /// Run the Clippy linter
    pub async fn cargo_clippy(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_internal("clippy", args, None)
            .await
    }

    /// Automatically fix lint warnings
    pub async fn cargo_fix(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_internal("fix", args, None).await
    }

    /// Package and upload crate to registry
    pub async fn cargo_publish(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_internal("publish", args, None)
            .await
    }

    /// Install a Rust binary
    pub async fn cargo_install(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_internal("install", args, None)
            .await
    }

    /// Uninstall a Rust binary
    pub async fn cargo_uninstall(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_internal("uninstall", args, None)
            .await
    }

    /// Search packages in registry
    pub async fn cargo_search(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_internal("search", args, None)
            .await
    }

    /// Display dependency tree
    pub async fn cargo_tree(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_internal("tree", args, None)
            .await
    }

    /// Vendor all dependencies locally
    pub async fn cargo_vendor(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_internal("vendor", args, None)
            .await
    }

    /// Audit dependencies for security vulnerabilities
    pub async fn cargo_audit(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_internal("audit", args, None)
            .await
    }

    /// Show outdated dependencies
    pub async fn cargo_outdated(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_internal("outdated", args, None)
            .await
    }

    /// Get Cargo help
    pub async fn cargo_help(&self, args: &[&str]) -> LuaResult<(String, bool)> {
        self.execute_cargo_command_internal("help", args, None)
            .await
    }

    /// Run cargo-autodd command
    pub async fn cargo_autodd(&self, _args: &[&str]) -> LuaResult<(String, bool)> {
        // テスト環境では常にエラーを返す
        #[cfg(test)]
        return Err(LuaError::RuntimeError(
            "cargo-autodd is not installed. Please install it with 'cargo install cargo-autodd'"
                .to_string(),
        ));

        // 実環境ではインストール確認を行う
        #[cfg(not(test))]
        {
            // Check if cargo-autodd is installed
            let check_output = std::process::Command::new("cargo")
                .arg("--list")
                .output()
                .map_err(|e| {
                    LuaError::RuntimeError(format!("Failed to check cargo commands: {}", e))
                })?;

            let output_str = String::from_utf8_lossy(&check_output.stdout);
            if !output_str.contains("autodd") {
                return Err(LuaError::RuntimeError(
                    "cargo-autodd is not installed. Please install it with 'cargo install cargo-autodd'"
                        .to_string(),
                ));
            }

            self.execute_cargo_command_internal("autodd", _args, None)
                .await
        }
    }
}

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

    fn setup_test_commands() -> CargoCommands {
        CargoCommands::new().unwrap()
    }

    #[test]
    fn test_cargo_command_execution() {
        let rt = tokio::runtime::Runtime::new().unwrap();
        let cargo_commands = setup_test_commands();
        let result = rt.block_on(async { cargo_commands.cargo_help(&[]).await });
        assert!(result.is_ok());
    }

    #[test]
    fn test_invalid_command() {
        let rt = tokio::runtime::Runtime::new().unwrap();
        let cargo_commands = setup_test_commands();
        let result =
            rt.block_on(async { cargo_commands.execute_cargo_command("invalid", &[]).await });
        assert!(result.is_err());
    }

    #[test]
    fn test_execute_method() {
        let cargo_commands = setup_test_commands();
        let result =
            cargo_commands.execute(async { Ok::<_, LuaError>(("test".to_string(), false)) });
        assert!(result.is_ok());
        assert_eq!(result.unwrap().0, "test");
    }

    #[test]
    fn test_cargo_autodd() {
        let rt = tokio::runtime::Runtime::new().unwrap();
        let cargo_commands = setup_test_commands();
        let result = rt.block_on(async { cargo_commands.cargo_autodd(&[]).await });
        assert!(result.is_err());
        let err_msg = result.unwrap_err().to_string().to_lowercase();

        // More flexible error message checking
        assert!(
            err_msg.contains("failed to check cargo commands")
                || err_msg.contains("cargo-autodd is not installed")
                || err_msg.contains("no valid version found")
                || err_msg.contains("cargo autodd failed")
                || err_msg.contains("command not found") // For Docker environment
                || err_msg.contains("no such file or directory"), // For Docker environment
            "Unexpected error message: {}",
            err_msg
        );
    }

    #[test]
    fn test_cargo_autodd_with_args() {
        let rt = tokio::runtime::Runtime::new().unwrap();
        let cargo_commands = setup_test_commands();
        let test_args = vec![
            vec!["update"],
            vec!["report"],
            vec!["security"],
            vec!["--debug"],
            vec!["update", "--debug"],
        ];

        for args in test_args {
            let result = rt.block_on(async { cargo_commands.cargo_autodd(&args).await });
            assert!(result.is_err());
            let err_msg = result.unwrap_err().to_string().to_lowercase();

            assert!(
                err_msg.contains("failed to check cargo commands")
                    || err_msg.contains("cargo-autodd is not installed")
                    || err_msg.contains("no valid version found")
                    || err_msg.contains("cargo autodd failed")
                    || err_msg.contains("command not found") // For Docker environment
                    || err_msg.contains("no such file or directory") // For Docker environment
                    || err_msg.contains("status code 404"),
                "Unexpected error message: {}",
                err_msg
            );
        }
    }
}