kanri 0.8.2

Manage your projects within the terminal.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

use anyhow::Result;
use std::{
    io::ErrorKind,
    process::{Command, Stdio},
};
use thiserror::Error;

#[derive(Debug, Error)]
pub enum ProgramError {
    #[error("Failed to launch program: {0}")]
    ProgramNotFound(String),

    #[error("Process was interrupted")]
    ProcessInterrupted,

    #[error("No permission to execute the program")]
    NoPermission,

    #[error("Program exited with non-zero status: {0}")]
    NonZeroExitCode(i32),

    #[error("An unexpected error occurred: {0}")]
    UnexpectedError(String),
}

#[derive(Debug, Clone, Default)]
pub struct LaunchOptions {
    pub program: String,
    pub args: Vec<String>,
    pub cwd: Option<String>,
    pub fork_mode: bool,
    pub quiet: bool,
    pub env: Option<Vec<(String, String)>>,
}

pub fn launch_program(options: LaunchOptions) -> Result<(), ProgramError> {
    let mut cmd = Command::new(&options.program);

    if options.quiet {
        cmd.stdin(Stdio::null())
            .stdout(Stdio::null())
            .stderr(Stdio::null());
    } else {
        cmd.stdin(Stdio::inherit())
            .stdout(Stdio::inherit())
            .stderr(Stdio::inherit());
    }

    cmd.args(options.args);
    if let Some(cwd_path) = options.cwd {
        cmd.current_dir(cwd_path);
    }

    if let Some(env) = options.env {
        cmd.envs(env);
    }

    if options.fork_mode {
        // In fork mode, we just spawn and don't wait for completion
        cmd.spawn().map_err(|e| match e.kind() {
            ErrorKind::NotFound => ProgramError::ProgramNotFound(options.program.to_string()),
            ErrorKind::PermissionDenied => ProgramError::NoPermission,
            ErrorKind::Interrupted => ProgramError::ProcessInterrupted,
            _ => ProgramError::UnexpectedError(e.to_string()),
        })?;
    } else {
        // Required only for Windows because if user runs program inside a shell and presses Ctrl+C,
        // user will lose control over the shell. I can't figure out why it is happening.
        // On Linux and macOS Ctrl+C works as expected.
        #[cfg(windows)]
        let _ = ctrlc::set_handler(|| {});

        let status = cmd.status().map_err(|e| match e.kind() {
            ErrorKind::NotFound => ProgramError::ProgramNotFound(options.program.to_string()),
            ErrorKind::PermissionDenied => ProgramError::NoPermission,
            ErrorKind::Interrupted => ProgramError::ProcessInterrupted,
            _ => ProgramError::UnexpectedError(e.to_string()),
        })?;

        if !status.success() {
            return if let Some(code) = status.code() {
                Err(ProgramError::NonZeroExitCode(code))
            } else {
                Err(ProgramError::ProcessInterrupted)
            };
        }
    }

    Ok(())
}