live-cli/src/command.rs

use anyhow::bail;
use anyhow::Context;
use anyhow::Result;
use std::{
    io::Write,
    process::{Command, Stdio},
};

use crate::App;

pub struct CommandResult {
    pub status_success: bool,
    pub stdout: Vec<u8>,
    pub stderr: Vec<u8>,
}

impl Default for CommandResult {
    fn default() -> Self {
        Self {
            status_success: true,
            stdout: vec![],
            stderr: vec![],
        }
    }
}

pub fn run(app: &mut App) {
    match run_inner(app) {
        Ok(c) => {
            // If there was no stdout and the command failed, don't touch stdout
            if !c.status_success && c.stdout.is_empty() {
                app.command_result.stderr = c.stderr;
                app.command_result.status_success = c.status_success;
            } else {
                app.command_result = c;
            }
        }
        Err(e) => {
            println!("asdf");
            app.command_result.status_success = false;
            app.command_result.stderr = e.to_string().as_bytes().to_vec();
        }
    }
}

fn run_inner(app: &mut App) -> Result<CommandResult> {
    let mut command = Command::new(&app.command);
    command
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .args(&app.hidden_options);

    if app.wordsplit {
        match shellwords::split(&app.cmdline) {
            Ok(a) => {
                command.args(a);
            }
            Err(e) => {
                bail!("Argument error: {e:?}");
            }
        }
    } else {
        // TODO: Avoid cloning here
        command.arg(&app.cmdline);
    }
    let mut child = command.spawn().context("Could not spawn child process")?;

    let mut stdin = child.stdin.take().context("Could not take stdin")?;
    let text_orig_clone = app.text_orig.clone();
    std::thread::spawn(move || {
        let _result = stdin.write_all(text_orig_clone.as_bytes());
    });

    // Collect the output
    let output = child.wait_with_output().context("Failed to read stdout")?;

    Ok(CommandResult {
        status_success: output.status.success(),
        stdout: output.stdout,
        stderr: output.stderr,
    })
}