slice

Author: srid

crates/nix_rs/src/command.rs

@@ -76,27 +76,29 @@ impl NixCmd {
     }
 
     /// Return a [Command] for this [NixCmd] configuration
-    pub fn command(&self, msubcommand: Option<&str>) -> Command {
+    ///
+    /// Arguments:
+    /// - `subcommands`: Optional subcommands to pass. Note that `NixArgs` will
+    ///    be passed *after* these subcommands.
+    pub fn command(&self, subcommands: &[&str]) -> Command {
         let mut cmd = Command::new("nix");
         cmd.kill_on_drop(true);
-        if let Some(subcommand) = msubcommand {
-            cmd.arg(subcommand);
-        }
+        cmd.args(subcommands);
         cmd.args(&self.args);
         cmd
     }
 
     /// Run nix with given args, interpreting stdout as JSON, parsing into `T`
     pub async fn run_with_args_expecting_json<T>(
         &self,
-        msubcommand: Option<&str>,
+        subcommands: &[&str],
         args: &[&str],
     ) -> Result<T, NixCmdError>
     where
         T: serde::de::DeserializeOwned,
     {
         let stdout: Vec<u8> = self
-            .run_with_returning_stdout(msubcommand, |c| {
+            .run_with_returning_stdout(subcommands, |c| {
                 c.args(args);
             })
             .await?;
@@ -107,15 +109,15 @@ impl NixCmd {
     /// Run nix with given args, interpreting parsing stdout, via [std::str::FromStr], into `T`
     pub async fn run_with_args_expecting_fromstr<T>(
         &self,
-        msubcommand: Option<&str>,
+        subcommands: &[&str],
         args: &[&str],
     ) -> Result<T, NixCmdError>
     where
         T: std::str::FromStr,
         <T as std::str::FromStr>::Err: std::fmt::Display,
     {
         let stdout = self
-            .run_with_returning_stdout(msubcommand, |c| {
+            .run_with_returning_stdout(subcommands, |c| {
                 c.args(args);
             })
             .await?;
@@ -127,13 +129,13 @@ impl NixCmd {
     /// Like [Self::run_with] but returns stdout as a [`Vec<u8>`]
     pub async fn run_with_returning_stdout<F>(
         &self,
-        msubcommand: Option<&str>,
+        subcommands: &[&str],
         f: F,
     ) -> Result<Vec<u8>, CommandError>
     where
         F: FnOnce(&mut Command),
     {
-        let mut cmd = self.command(msubcommand);
+        let mut cmd = self.command(subcommands);
         f(&mut cmd);
         trace_cmd(&cmd);
 
@@ -156,15 +158,11 @@ impl NixCmd {
     /// Run Nix with given [Command] customizations, while also tracing the command being run.
     ///
     /// Return the stdout bytes returned by [tokio::process::Child::wait_with_output]. In order to capture stdout, you must call `cmd.stdout(Stdio::piped());` inside the handler.
-    pub async fn run_with<F>(
-        &self,
-        msubcommand: Option<&str>,
-        f: F,
-    ) -> Result<Vec<u8>, CommandError>
+    pub async fn run_with<F>(&self, subcommands: &[&str], f: F) -> Result<Vec<u8>, CommandError>
     where
         F: FnOnce(&mut Command),
     {
-        let mut cmd = self.command(msubcommand);
+        let mut cmd = self.command(subcommands);
         f(&mut cmd);
         trace_cmd(&cmd);
         let out = cmd.spawn()?.wait_with_output().await?;

crates/nix_rs/src/config.rs

@@ -80,11 +80,11 @@ impl NixConfig {
     ) -> Result<NixConfig, super::command::NixCmdError> {
         let v = if nix_version >= &NIX_2_20_0 {
             nix_cmd
-                .run_with_args_expecting_json(Some("config"), &["show", "--json"])
+                .run_with_args_expecting_json(&["config", "show"], &["--json"])
                 .await?
         } else {
             nix_cmd
-                .run_with_args_expecting_json(Some("show-config"), &["--json"])
+                .run_with_args_expecting_json(&["show-config"], &["--json"])
                 .await?
         };
         Ok(v)

crates/nix_rs/src/copy.rs

@@ -32,7 +32,7 @@ where
     I: IntoIterator<Item = P>,
     P: AsRef<Path> + AsRef<OsStr>,
 {
-    cmd.run_with(Some("copy"), |cmd| {
+    cmd.run_with(&["copy"], |cmd| {
         cmd.arg("-v");
         if let Some(uri) = options.from {
             cmd.arg("--from").arg(uri.to_string());

crates/nix_rs/src/flake/command.rs

@@ -20,7 +20,7 @@ pub async fn run(
     args: Vec<String>,
 ) -> Result<(), CommandError> {
     nixcmd
-        .run_with(Some("run"), |cmd| {
+        .run_with(&["run"], |cmd| {
             opts.use_in_command(cmd);
             cmd.args([url.to_string(), "--".to_string()]);
             cmd.args(args);
@@ -37,7 +37,7 @@ pub async fn develop(
     command: NonEmpty<String>,
 ) -> Result<(), CommandError> {
     nixcmd
-        .run_with(Some("develop"), |cmd| {
+        .run_with(&["develop"], |cmd| {
             opts.use_in_command(cmd);
             cmd.args([url.to_string(), "-c".to_string()]);
             cmd.args(command);
@@ -53,7 +53,7 @@ pub async fn build(
     url: FlakeUrl,
 ) -> Result<Vec<OutPath>, NixCmdError> {
     let stdout: Vec<u8> = cmd
-        .run_with_returning_stdout(Some("build"), |c| {
+        .run_with_returning_stdout(&["build"], |c| {
             opts.use_in_command(c);
             c.args(["--no-link", "--json", &url]);
         })
@@ -72,8 +72,8 @@ pub async fn lock(
     let mut cmd = cmd.clone();
     // Remove --override-input x y arguments, since they don't make sense for flake.lock check
     remove_override_inputs(&mut cmd.args.extra_nix_args);
-    cmd.run_with(Some("flake"), |c| {
-        c.args(["lock", url]); // XXX
+    cmd.run_with(&["flake", "lock"], |c| {
+        c.arg(url.to_string());
         opts.use_in_command(c);
         c.args(args);
     })
@@ -95,8 +95,8 @@ fn remove_override_inputs(vec: &mut Vec<String>) {
 
 /// Run `nix flake check`
 pub async fn check(cmd: &NixCmd, opts: &FlakeOptions, url: &FlakeUrl) -> Result<(), NixCmdError> {
-    cmd.run_with(Some("flake"), |c| {
-        c.args(["check", url]); // XXX
+    cmd.run_with(&["flake", "check"], |c| {
+        c.arg(url.to_string());
         opts.use_in_command(c);
     })
     .await?;

crates/nix_rs/src/flake/eval.rs

@@ -46,7 +46,7 @@ where
     T: serde::de::DeserializeOwned,
 {
     let stdout = nixcmd
-        .run_with(Some("eval"), |cmd| {
+        .run_with(&["eval"], |cmd| {
             cmd.stdout(Stdio::piped());
             if capture_stderr {
                 cmd.stderr(Stdio::piped());

crates/nix_rs/src/flake/functions/core.rs

@@ -60,7 +60,7 @@ pub trait FlakeFn {
         Self::Output: Sync + for<'de> Deserialize<'de>,
     {
         async move {
-            let mut cmd = nixcmd.command(Some("build"));
+            let mut cmd = nixcmd.command(&["build"]);
             cmd.args([Self::flake(), "-L", "--print-out-paths"]);
 
             if impure {

crates/nix_rs/src/system_list.rs

@@ -85,7 +85,7 @@ where
     T: Default + serde::de::DeserializeOwned,
 {
     let v = cmd
-        .run_with_args_expecting_json::<T>(Some("eval"), &["--impure", "--json", "--expr", &expr])
+        .run_with_args_expecting_json::<T>(&["eval"], &["--impure", "--json", "--expr", &expr])
         .await?;
     Ok(v)
 }

crates/nix_rs/src/version.rs

@@ -76,7 +76,7 @@ impl NixVersion {
     #[instrument(name = "version")]
     pub async fn from_nix(cmd: &NixCmd) -> Result<NixVersion, super::command::NixCmdError> {
         let v = cmd
-            .run_with_args_expecting_fromstr(None, &["--version"])
+            .run_with_args_expecting_fromstr(&[], &["--version"])
             .await?;
         Ok(v)
     }