xargs: Implement -I to replace

sylvestre · sylvestre · commit ed2cbe60886f · 2024-02-25T18:38:41.000+01:00
diff --git a/src/xargs/mod.rs b/src/xargs/mod.rs
@@ -28,6 +28,7 @@ mod options {
     pub const NO_RUN_IF_EMPTY: &str = "no-run-if-empty";
     pub const NULL: &str = "null";
     pub const SIZE: &str = "size";
+    pub const REPLACE: &str = "replace";
     pub const VERBOSE: &str = "verbose";
 }
 
@@ -40,6 +41,7 @@ struct Options {
     no_run_if_empty: bool,
     null: bool,
     size: Option<usize>,
+    replace: Option<String>,
     verbose: bool,
 }
 
@@ -340,13 +342,15 @@ struct CommandBuilderOptions {
     limiters: LimiterCollection,
     verbose: bool,
     close_stdin: bool,
+    replace: Option<String>,
 }
 
 impl CommandBuilderOptions {
     fn new(
         action: ExecAction,
         env: HashMap<OsString, OsString>,
         mut limiters: LimiterCollection,
+        replace: Option<String>,
     ) -> Result<Self, ExhaustedCommandSpace> {
         let initial_args = match &action {
             ExecAction::Command(args) => args.iter().map(|arg| arg.as_ref()).collect(),
@@ -366,6 +370,7 @@ impl CommandBuilderOptions {
             limiters,
             verbose: false,
             close_stdin: false,
+            replace,
         })
     }
 }
@@ -396,16 +401,42 @@ impl CommandBuilder<'_> {
             ExecAction::Command(args) => (&args[0], &args[1..]),
             ExecAction::Echo => (OsStr::new("echo"), &[]),
         };
-
         let mut command = Command::new(entry_point);
-        command
-            .args(initial_args)
-            .args(&self.extra_args)
-            .env_clear()
-            .envs(&self.options.env);
+
+        if let Some(replace_str) = &self.options.replace {
+            // we replace the first instance of the replacement string with
+            // the extra args, and then replace all instances of the replacement
+            let replacement = self
+                .extra_args
+                .iter()
+                .map(|s| s.to_string_lossy())
+                .collect::<Vec<_>>()
+                .join(" ");
+            let initial_args: Vec<OsString> = initial_args
+                .iter()
+                .map(|arg| {
+                    let arg_str = arg.to_string_lossy();
+                    OsString::from(arg_str.replace(replace_str, &replacement))
+                })
+                .collect();
+
+            command
+                .args(&initial_args)
+                .env_clear()
+                .envs(&self.options.env);
+        } else {
+            // don't do any replacement
+            command
+                .args(initial_args)
+                .args(&self.extra_args)
+                .env_clear()
+                .envs(&self.options.env);
+        };
+
         if self.options.close_stdin {
             command.stdin(Stdio::null());
         }
+
         if self.options.verbose {
             eprintln!("{command:?}");
         }
@@ -810,6 +841,15 @@ fn do_xargs(args: &[&str]) -> Result<CommandResult, XargsError> {
                     invocation",
                 ),
         )
+        .arg(
+            Arg::with_name(options::REPLACE)
+                .long(options::REPLACE)
+                .short("R")
+                .takes_value(true)
+                .value_name("R")
+                .visible_aliases(&["i", "I"])
+                .help("Replace R in INITIAL-ARGS with names read from standard input; if R is unspecified, assume {}"),
+        )
         .arg(
             Arg::with_name(options::VERBOSE)
                 .short("t")
@@ -837,6 +877,16 @@ fn do_xargs(args: &[&str]) -> Result<CommandResult, XargsError> {
         size: matches
             .value_of(options::SIZE)
             .map(|value| value.parse().unwrap()),
+        replace: if matches.is_present(options::REPLACE) {
+            Some(
+                matches
+                    .value_of(options::REPLACE)
+                    .unwrap_or("{}")
+                    .to_string(),
+            )
+        } else {
+            None
+        },
         verbose: matches.is_present(options::VERBOSE),
     };
 
@@ -891,9 +941,10 @@ fn do_xargs(args: &[&str]) -> Result<CommandResult, XargsError> {
 
     limiters.add(MaxCharsCommandSizeLimiter::new_system(&env));
 
-    let mut builder_options = CommandBuilderOptions::new(action, env, limiters).map_err(|_| {
-        "Base command and environment are too large to fit into one command execution"
-    })?;
+    let mut builder_options =
+        CommandBuilderOptions::new(action, env, limiters, options.replace.clone()).map_err(
+            |_| "Base command and environment are too large to fit into one command execution",
+        )?;
 
     builder_options.verbose = options.verbose;
     builder_options.close_stdin = options.arg_file.is_none();
diff --git a/tests/xargs_tests.rs b/tests/xargs_tests.rs
@@ -384,3 +384,27 @@ fn xargs_zero_lines() {
         .stderr(predicate::str::contains("Value must be > 0, not: 0"))
         .stdout(predicate::str::is_empty());
 }
+
+#[test]
+fn xargs_replace() {
+    Command::cargo_bin("xargs")
+        .expect("found binary")
+        .args(["-R", "{}", "echo", "{} bar"])
+        .write_stdin("foo")
+        .assert()
+        .stdout(predicate::str::contains("foo bar"));
+
+    Command::cargo_bin("xargs")
+        .expect("found binary")
+        .args(["-R", "_", "echo", "_ bar"])
+        .write_stdin("foo")
+        .assert()
+        .stdout(predicate::str::contains("foo bar"));
+
+    Command::cargo_bin("xargs")
+        .expect("found binary")
+        .args(["-R", "_", "echo", "_ _ bar"])
+        .write_stdin("foo")
+        .assert()
+        .stdout(predicate::str::contains("foo foo bar"));
+}
