Rewrite run_external.rs (#12921)

This PR is a complete rewrite of `run_external.rs`. The main goal of the
rewrite is improving readability, but it also fixes some bugs related to
argument handling and the PATH variable (fixes
#6011).

I'll discuss some technical details to make reviewing easier.

## Argument handling

Quoting arguments for external commands is hard. Like, *really* hard.
We've had more than a dozen issues and PRs dedicated to quoting
arguments (see Appendix) but the current implementation is still buggy.

Here's a demonstration of the buggy behavior:

```nu
let foo = "'bar'"
^touch $foo            # This creates a file named `bar`, but it should be `'bar'`
^touch ...[ "'bar'" ]  # Same
```

I'll describe how this PR deals with argument handling.

First, we'll introduce the concept of **bare strings**. Bare strings are
**string literals** that are either **unquoted** or **quoted by
backticks** [^1]. Strings within a list literal are NOT considered bare
strings, even if they are unquoted or quoted by backticks.

When a bare string is used as an argument to external process, we need
to perform tilde-expansion, glob-expansion, and inner-quotes-removal, in
that order. "Inner-quotes-removal" means transforming from
`--option="value"` into `--option=value`.

## `.bat` files and CMD built-ins

On Windows, `.bat` files and `.cmd` files are considered executable, but
they need `CMD.exe` as the interpreter. The Rust standard library
supports running `.bat` files directly and will spawn `CMD.exe` under
the hood (see
[documentation](https://doc.rust-lang.org/std/process/index.html#windows-argument-splitting)).
However, other extensions are not supported [^2].

Nushell also supports a selected number of CMD built-ins. The problem
with CMD is that it uses a different set of quoting rules. Correctly
quoting for CMD requires using
[Command::raw_arg()](https://doc.rust-lang.org/std/os/windows/process/trait.CommandExt.html#tymethod.raw_arg)
and manually quoting CMD special characters, on top of quoting from the
Nushell side. ~~I decided that this is too complex and chose to reject
special characters in CMD built-ins instead [^3]. Hopefully this will
not affact real-world use cases.~~ I've implemented escaping that works
reasonably well.

## `which-support` feature

The `which` crate is now a hard dependency of `nu-command`, making the
`which-support` feature essentially useless. The `which` crate is
already a hard dependency of `nu-cli`, and we should consider removing
the `which-support` feature entirely.

## Appendix

Here's a list of quoting-related issues and PRs in rough chronological
order.

* #4609
* #4631
* #4601
  * #5846
* #5978
  * #6014
* #6154
  * #6161
* #6399
  * #6420
  * #6426
* #6465
* #6559
  * #6560

[^1]: The idea that backtick-quoted strings act like bare strings was
introduced by Kubouch and briefly mentioned in [the language
reference](https://www.nushell.sh/lang-guide/chapters/strings_and_text.html#backtick-quotes).

[^2]: The documentation also said "running .bat scripts in this way may
be removed in the future and so should not be relied upon", which is
another reason to move away from this. But again, quoting for CMD is
hard.

[^3]: If anyone wants to try, the best resource I found on the topic is
[this](https://daviddeley.com/autohotkey/parameters/parameters.htm).

crates/nu-command/Cargo.toml

@@ -99,7 +99,7 @@ uu_whoami = { workspace = true }
 uuid = { workspace = true, features = ["v4"] }
 v_htmlescape = { workspace = true }
 wax = { workspace = true }
-which = { workspace = true, optional = true }
+which = { workspace = true }
 unicode-width = { workspace = true }
 
 [target.'cfg(windows)'.dependencies]
@@ -134,7 +134,7 @@ workspace = true
 plugin = ["nu-parser/plugin"]
 sqlite = ["rusqlite"]
 trash-support = ["trash"]
-which-support = ["which"]
+which-support = []
 
 [dev-dependencies]
 nu-cmd-lang = { path = "../nu-cmd-lang", version = "0.93.1" }
@@ -146,3 +146,4 @@ quickcheck = { workspace = true }
 quickcheck_macros = { workspace = true }
 rstest = { workspace = true, default-features = false }
 pretty_assertions = { workspace = true }
+tempfile = { workspace = true }

crates/nu-command/src/env/config/config_env.rs

@@ -1,6 +1,7 @@
-use super::utils::gen_command;
 use nu_cmd_base::util::get_editor;
 use nu_engine::{command_prelude::*, env_to_strings};
+use nu_protocol::{process::ChildProcess, ByteStream};
+use nu_system::ForegroundChild;
 
 #[derive(Clone)]
 pub struct ConfigEnv;
@@ -47,35 +48,67 @@ impl Command for ConfigEnv {
  engine_state: &EngineState,
  stack: &mut Stack,
  call: &Call,
- input: PipelineData,
+ _input: PipelineData,
  ) -> Result<PipelineData, ShellError> {
  // `--default` flag handling
  if call.has_flag(engine_state, stack, "default")? {
  let head = call.head;
  return Ok(Value::string(nu_utils::get_default_env(), head).into_pipeline_data());
  }
 
- let env_vars_str = env_to_strings(engine_state, stack)?;
- let nu_config = match engine_state.get_config_path("env-path") {
- Some(path) => path,
- None => {
- return Err(ShellError::GenericError {
- error: "Could not find $nu.env-path".into(),
- msg: "Could not find $nu.env-path".into(),
- span: None,
- help: None,
- inner: vec![],
- });
- }
+ // Find the editor executable.
+ let (editor_name, editor_args) = get_editor(engine_state, stack, call.head)?;
+ let paths = nu_engine::env::path_str(engine_state, stack, call.head)?;
+ let cwd = engine_state.cwd(Some(stack))?;
+ let editor_executable =
+ crate::which(&editor_name, &paths, &cwd).ok_or(ShellError::ExternalCommand {
+ label: format!("`{editor_name}` not found"),
+ help: "Failed to find the editor executable".into(),
+ span: call.head,
+ })?;
+
+ let Some(env_path) = engine_state.get_config_path("env-path") else {
+ return Err(ShellError::GenericError {
+ error: "Could not find $nu.env-path".into(),
+ msg: "Could not find $nu.env-path".into(),
+ span: None,
+ help: None,
+ inner: vec![],
+ });
  };
+ let env_path = env_path.to_string_lossy().to_string();
+
+ // Create the command.
+ let mut command = std::process::Command::new(editor_executable);
+
+ // Configure PWD.
+ command.current_dir(cwd);
+
+ // Configure environment variables.
+ let envs = env_to_strings(engine_state, stack)?;
+ command.env_clear();
+ command.envs(envs);
+
+ // Configure args.
+ command.arg(env_path);
+ command.args(editor_args);
 
- let (item, config_args) = get_editor(engine_state, stack, call.head)?;
+ // Spawn the child process. On Unix, also put the child process to
+ // foreground if we're in an interactive session.
+ #[cfg(windows)]
+ let child = ForegroundChild::spawn(command)?;
+ #[cfg(unix)]
+ let child = ForegroundChild::spawn(
+ command,
+ engine_state.is_interactive,
+ &engine_state.pipeline_externals_state,
+ )?;
 
- gen_command(call.head, nu_config, item, config_args, env_vars_str).run_with_input(
-  engine_state,
-  stack,
- input,
- true,
- )
+ // Wrap the output into a `PipelineData::ByteStream`.
+ let child = ChildProcess::new(child, None, false, call.head)?;
+ Ok(PipelineData::ByteStream(
+ ByteStream::child(child, call.head),
+ None,
+ ))
  }
 }

crates/nu-command/src/env/config/config_nu.rs

@@ -1,6 +1,7 @@
-use super::utils::gen_command;
 use nu_cmd_base::util::get_editor;
 use nu_engine::{command_prelude::*, env_to_strings};
+use nu_protocol::{process::ChildProcess, ByteStream};
+use nu_system::ForegroundChild;
 
 #[derive(Clone)]
 pub struct ConfigNu;
@@ -51,35 +52,67 @@ impl Command for ConfigNu {
  engine_state: &EngineState,
  stack: &mut Stack,
  call: &Call,
- input: PipelineData,
+ _input: PipelineData,
  ) -> Result<PipelineData, ShellError> {
  // `--default` flag handling
  if call.has_flag(engine_state, stack, "default")? {
  let head = call.head;
  return Ok(Value::string(nu_utils::get_default_config(), head).into_pipeline_data());
  }
 
- let env_vars_str = env_to_strings(engine_state, stack)?;
- let nu_config = match engine_state.get_config_path("config-path") {
- Some(path) => path,
- None => {
- return Err(ShellError::GenericError {
- error: "Could not find $nu.config-path".into(),
- msg: "Could not find $nu.config-path".into(),
- span: None,
- help: None,
- inner: vec![],
- });
- }
+ // Find the editor executable.
+ let (editor_name, editor_args) = get_editor(engine_state, stack, call.head)?;
+ let paths = nu_engine::env::path_str(engine_state, stack, call.head)?;
+ let cwd = engine_state.cwd(Some(stack))?;
+ let editor_executable =
+ crate::which(&editor_name, &paths, &cwd).ok_or(ShellError::ExternalCommand {
+ label: format!("`{editor_name}` not found"),
+ help: "Failed to find the editor executable".into(),
+ span: call.head,
+ })?;
+
+ let Some(config_path) = engine_state.get_config_path("config-path") else {
+ return Err(ShellError::GenericError {
+ error: "Could not find $nu.config-path".into(),
+ msg: "Could not find $nu.config-path".into(),
+ span: None,
+ help: None,
+ inner: vec![],
+ });
  };
+ let config_path = config_path.to_string_lossy().to_string();
+
+ // Create the command.
+ let mut command = std::process::Command::new(editor_executable);
+
+ // Configure PWD.
+ command.current_dir(cwd);
+
+ // Configure environment variables.
+ let envs = env_to_strings(engine_state, stack)?;
+ command.env_clear();
+ command.envs(envs);
+
+ // Configure args.
+ command.arg(config_path);
+ command.args(editor_args);
 
- let (item, config_args) = get_editor(engine_state, stack, call.head)?;
+ // Spawn the child process. On Unix, also put the child process to
+ // foreground if we're in an interactive session.
+ #[cfg(windows)]
+ let child = ForegroundChild::spawn(command)?;
+ #[cfg(unix)]
+ let child = ForegroundChild::spawn(
+ command,
+ engine_state.is_interactive,
+ &engine_state.pipeline_externals_state,
+ )?;
 
- gen_command(call.head, nu_config, item, config_args, env_vars_str).run_with_input(
-  engine_state,
-  stack,
- input,
- true,
- )
+ // Wrap the output into a `PipelineData::ByteStream`.
+ let child = ChildProcess::new(child, None, false, call.head)?;
+ Ok(PipelineData::ByteStream(
+ ByteStream::child(child, call.head),
+ None,
+ ))
  }
 }

crates/nu-command/src/env/config/mod.rs

@@ -2,7 +2,6 @@ mod config_;
 mod config_env;
 mod config_nu;
 mod config_reset;
-mod utils;
 pub use config_::ConfigMeta;
 pub use config_env::ConfigEnv;
 pub use config_nu::ConfigNu;