mk 0.7.0

Yet another simple task runner 🦀
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use serde::Deserialize;
use std::process::Command as ProcessCommand;

#[derive(Debug, Default, Deserialize, Clone, PartialEq, Eq)]
pub struct ShellArgs {
  /// The shell command to run
  pub command: String,

  /// The flags to pass to the shell command
  pub args: Option<Vec<String>>,
}

#[derive(Debug, Deserialize, Clone, PartialEq, Eq)]
#[serde(untagged)]
pub enum Shell {
  String(String),
  Shell(Box<ShellArgs>),
}

impl Default for Shell {
  fn default() -> Self {
    Shell::String("sh".to_string())
  }
}

impl Shell {
  pub fn new() -> anyhow::Result<Self> {
    Ok(Shell::default())
  }

  pub fn new_with_flags(command: &str, args: Vec<String>) -> anyhow::Result<Self> {
    let shell_def = ShellArgs {
      command: command.to_string(),
      args: Some(args),
    };
    Ok(Shell::Shell(Box::new(shell_def)))
  }

  pub fn from_shell(shell: &Shell) -> Self {
    match shell {
      Shell::String(command) => Shell::String(command.to_string()),
      Shell::Shell(args) => Shell::Shell(args.clone()),
    }
  }

  pub fn cmd(&self) -> String {
    match self {
      Shell::String(command) => ShellArgs {
        command: command.to_string(),
        args: None,
      }
      .cmd(),
      Shell::Shell(args) => args.cmd(),
    }
  }

  pub fn args(&self) -> Vec<String> {
    match self {
      Shell::String(command) => ShellArgs {
        command: command.to_string(),
        args: None,
      }
      .shell_args(),
      Shell::Shell(args) => args.shell_args(),
    }
  }

  pub fn proc(&self) -> ProcessCommand {
    let shell = self.cmd();
    let args = self.args();

    let mut cmd = ProcessCommand::new(&shell);
    for arg in args {
      cmd.arg(arg);
    }

    cmd
  }
}

impl From<Shell> for ProcessCommand {
  fn from(shell: Shell) -> Self {
    shell.proc()
  }
}

impl ShellArgs {
  pub fn cmd(&self) -> String {
    self.command.clone()
  }

  pub fn shell_args(&self) -> Vec<String> {
    let command = self.command.clone();
    let args = self.args.clone().unwrap_or_default();
    let posix_shell = ["sh", "bash", "zsh", "fish"];

    // If the shell is not a POSIX shell, we don't need to add the `-c` flag
    // to the command. We can just return the arguments as is.
    if !posix_shell.contains(&command.as_str()) {
      return args;
    }

    // If the shell is a POSIX shell, we need to add the `-c` flag
    // to the command. If it's already present, we don't need to add it.
    if args.iter().any(|arg| arg == "-c") {
      return args;
    }

    // If the `-c` flag is not present, we need to add it
    let mut args = args;
    args.push("-c".to_string());
    args
  }
}