runner-run 0.19.1

Universal project 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
115
116
117

//! npm — the default Node.js package manager.

use std::path::Path;
use std::process::Command;

use super::ScriptDirective;

/// Detected via `package-lock.json`.
pub(crate) fn detect(dir: &Path) -> bool {
    dir.join("package-lock.json").exists()
}

/// `npm run <task> [-- args...]`
pub(crate) fn run_cmd(task: &str, args: &[String]) -> Command {
    let mut c = super::program::command("npm");
    c.arg("run").arg(task);
    if !args.is_empty() {
        c.arg("--").args(args);
    }
    c
}

/// `npm install` or `npm ci` when `frozen`.
///
/// [`ScriptDirective::Deny`] appends `--ignore-scripts` (skips both root and
/// dependency lifecycle scripts); [`ScriptDirective::ForceOn`] appends
/// `--no-ignore-scripts`, the nopt negation of the `ignore-scripts` boolean
/// config (same mechanism as `--no-save`/`--no-audit`), so scripts run even
/// if a future npm flips `ignore-scripts` on by default.
pub(crate) fn install_cmd(frozen: bool, scripts: ScriptDirective) -> Command {
    let mut c = super::program::command("npm");
    c.arg(if frozen { "ci" } else { "install" });
    match scripts {
        ScriptDirective::Deny => {
            c.arg("--ignore-scripts");
        }
        ScriptDirective::ForceOn => {
            c.arg("--no-ignore-scripts");
        }
        ScriptDirective::Default => {}
    }
    c
}

/// `npx <args...>`
///
/// Uses the standalone `npx` entrypoint for npm 6 compatibility, where
/// `npm exec` is unavailable.
pub(crate) fn exec_cmd(args: &[String]) -> Command {
    let mut c = super::program::command("npx");
    c.args(args);
    c
}

#[cfg(test)]
mod tests {
    use super::{ScriptDirective, exec_cmd, install_cmd};

    fn args_of(cmd: &std::process::Command) -> Vec<String> {
        cmd.get_args()
            .map(|arg| arg.to_string_lossy().into_owned())
            .collect()
    }

    #[test]
    fn frozen_install_uses_ci() {
        assert_eq!(
            args_of(&install_cmd(true, ScriptDirective::Default)),
            ["ci"]
        );
    }

    #[test]
    fn non_frozen_install_uses_install() {
        assert_eq!(
            args_of(&install_cmd(false, ScriptDirective::Default)),
            ["install"]
        );
    }

    #[test]
    fn deny_scripts_appends_ignore_scripts() {
        assert_eq!(
            args_of(&install_cmd(false, ScriptDirective::Deny)),
            ["install", "--ignore-scripts"]
        );
    }

    #[test]
    fn force_on_appends_no_ignore_scripts() {
        // The nopt negation of the `ignore-scripts` boolean config — keeps
        // scripts running even if npm flips the default to off.
        assert_eq!(
            args_of(&install_cmd(false, ScriptDirective::ForceOn)),
            ["install", "--no-ignore-scripts"]
        );
    }

    #[test]
    fn frozen_and_deny_scripts_combine() {
        assert_eq!(
            args_of(&install_cmd(true, ScriptDirective::Deny)),
            ["ci", "--ignore-scripts"]
        );
    }

    #[test]
    fn exec_uses_npx_passthrough() {
        let args = [String::from("eslint"), String::from("--fix")];
        let built: Vec<_> = exec_cmd(&args)
            .get_args()
            .map(|arg| arg.to_string_lossy().into_owned())
            .collect();

        assert_eq!(built, ["eslint", "--fix"]);
    }
}