Add a shell option for Command steps. (#958)

Co-authored-by: Dylan Anthony <[email protected]>

Author: dbanty

.changeset/add_a_shell_variable_for_command_steps.md

@@ -0,0 +1,15 @@
+---
+default: minor
+---
+
+# Add a `shell` variable for `Command` steps
+
+You can now add `shell=true` to a `Command` step to run the command in the current shell.
+This lets you opt in to the pre-0.15.0 behavior.
+
+```toml
+[[workflows.steps]]
+type = "Command"
+command = "echo $AN_ENV_VAR"
+shell = true
+```

docs/src/content/docs/reference/Config File/Steps/command.md

@@ -2,7 +2,7 @@
 title: Command
 ---
 
-Run a command in your current shell after optionally replacing some variables.
+Run a command after optionally replacing some variables.
 This step is here to cover the infinite things you might want to do that Knope doesn't yet know how to do itself.
 If you have a lot of these steps or a complex `command`,
 you might want to run a script in something like Bash or Python,
@@ -11,7 +11,7 @@ then call that script with a command.
 ## Example
 
 If the current version for your project is `1.0.0`,
-the following workflow step will run `git tag v.1.0.0` in your current shell.
+the following workflow step will run the `git` command with the arguments `tag` and `v.version`.
 
 ```toml
 [[workflows.steps]]
@@ -27,3 +27,17 @@ and the value is one of the [available variables](/reference/config-file/variabl
 **Take care when selecting a key to replace** as Knope will replace _any_ matching string that it finds.
 Replacements occur in the order they're declared in the config,
 so Knope may replace earlier substitutions with later ones.
+
+## Shell mode
+
+By default, Knope splits commands into the executable name and its arguments, and calls the executable directly.
+This works around common issues with Windows shells, particularly when quoting arguments.
+However, you may want to use your current shell to run the command, for example to access environment variables or
+to use shell features like pipes or redirection. You can do this by setting `shell=true` in the step configuration.
+
+```toml
+[[workflows.steps]]
+type = "Command"
+command = "echo $AN_ENV_VAR && echo $ANOTHER_ENV_VAR"
+shell = true
+```

knope.toml

@@ -27,6 +27,7 @@ type = "PrepareRelease"
 
 [[workflows.steps]]
 type = "Command"
+shell = true
 command = "npx prettier CHANGELOG.md --write && git add CHANGELOG.md"
 
 [[workflows.steps]]

src/config/mod.rs

@@ -369,10 +369,12 @@ fn generate_workflows(has_forge: bool, packages: &[Package]) -> Vec<Workflow> {
             Step::Command {
                 command: format!("git commit -m \"{commit_message}\"",),
                 variables,
+                shell: None,
             },
             Step::Command {
                 command: String::from("git push"),
                 variables: None,
+                shell: None,
             },
             Step::Release,
         ]
@@ -381,15 +383,18 @@ fn generate_workflows(has_forge: bool, packages: &[Package]) -> Vec<Workflow> {
             Step::Command {
                 command: format!("git commit -m \"{commit_message}\""),
                 variables,
+                shell: None,
             },
             Step::Release,
             Step::Command {
                 command: String::from("git push"),
                 variables: None,
+                shell: None,
             },
             Step::Command {
                 command: String::from("git push --tags"),
                 variables: None,
+                shell: None,
             },
         ]
     };

src/step/command.rs

@@ -12,6 +12,7 @@ use crate::{
 pub(crate) fn run_command(
     mut run_type: RunType,
     mut command: String,
+    shell: bool,
     variables: Option<IndexMap<String, Variable>>,
 ) -> Result<RunType, Error> {
     let (state, dry_run_stdout) = match &mut run_type {
@@ -31,7 +32,11 @@ pub(crate) fn run_command(
         writeln!(stdout, "Would run {command}")?;
         return Ok(run_type);
     }
-    let status = execute::command(command).status()?;
+    let status = if shell {
+        execute::shell(command).status()?
+    } else {
+        execute::command(command).status()?
+    };
     if status.success() {
         return Ok(run_type);
     }
@@ -66,6 +71,7 @@ mod test_run_command {
         let result = run_command(
             RunType::Real(State::new(None, None, None, Vec::new(), Verbose::No)),
             command.to_string(),
+            false,
             None,
         );
 
@@ -74,6 +80,7 @@ mod test_run_command {
         let result = run_command(
             RunType::Real(State::new(None, None, None, Vec::new(), Verbose::No)),
             String::from("exit 1"),
+            false,
             None,
         );
         assert!(result.is_err());

src/step/mod.rs

@@ -71,6 +71,9 @@ pub(crate) enum Step {
         /// A map of value-to-replace to [Variable][`crate::command::Variable`] to replace
         /// it with.
         variables: Option<IndexMap<String, Variable>>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        /// Whether to run the command in the platform's shell or not
+        shell: Option<bool>,
     },
     /// This will look through all commits since the last tag and parse any
     /// [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) it finds. It will
@@ -110,9 +113,11 @@ impl Step {
             Step::SwitchBranches => git::switch_branches(run_type)?,
             Step::RebaseBranch { to } => git::rebase_branch(&to, run_type)?,
             Step::BumpVersion(rule) => releases::bump_version(run_type, &rule)?,
-            Step::Command { command, variables } => {
-                command::run_command(run_type, command, variables)?
-            }
+            Step::Command {
+                command,
+                variables,
+                shell,
+            } => command::run_command(run_type, command, shell.is_some_and(|it| it), variables)?,
             Step::PrepareRelease(prepare_release) => {
                 releases::prepare_release(run_type, &prepare_release)?
             }

tests/commands/mod.rs

@@ -0,0 +1,2 @@
+#[cfg(not(windows))]
+mod shell;

tests/commands/shell/in/knope.toml

@@ -0,0 +1,7 @@
+[[workflows]]
+name = "shell-command"
+
+[[workflows.steps]]
+type = "Command"
+shell = true
+command = "echo $AN_ENV_VAR"

tests/commands/shell/mod.rs

@@ -0,0 +1,8 @@
+use crate::helpers::TestCase;
+
+#[test]
+fn shell() {
+    TestCase::new(file!())
+        .env("AN_ENV_VAR", "a value")
+        .run("shell-command");
+}

tests/commands/shell/stdout.log

@@ -0,0 +1 @@
+a value