finished Cmd API

Anton-4 · Anton-4 · commit 7a2ba91482db · 2025-08-13T19:48:54.000+02:00
diff --git a/crates/roc_command/src/lib.rs b/crates/roc_command/src/lib.rs
@@ -63,26 +63,26 @@ impl From<&Command> for std::process::Command {
 #[derive(Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[repr(C)]
 pub struct OutputFromHostSuccess {
-    pub stdout_bytes: roc_std::RocList<u8>,
     pub stderr_bytes: roc_std::RocList<u8>,
+    pub stdout_bytes: roc_std::RocList<u8>,
 }
 
 #[derive(Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[repr(C)]
 pub struct OutputFromHostFailure {
-    pub status: i32,
-    pub stdout_bytes: roc_std::RocList<u8>,
     pub stderr_bytes: roc_std::RocList<u8>,
+    pub stdout_bytes: roc_std::RocList<u8>,
+    pub exit_code: i32,
 }
 
 impl roc_std::RocRefcounted for OutputFromHostSuccess {
     fn inc(&mut self) {
-        self.stderr_bytes.inc();
         self.stdout_bytes.inc();
+        self.stderr_bytes.inc();
     }
     fn dec(&mut self) {
-        self.stderr_bytes.dec();
         self.stdout_bytes.dec();
+        self.stderr_bytes.dec();
     }
     fn is_refcounted() -> bool {
         true
@@ -91,14 +91,14 @@ impl roc_std::RocRefcounted for OutputFromHostSuccess {
 
 impl roc_std::RocRefcounted for OutputFromHostFailure {
     fn inc(&mut self) {
-        self.status.inc();
-        self.stderr_bytes.inc();
+        self.exit_code.inc();
         self.stdout_bytes.inc();
+        self.stderr_bytes.inc();
     }
     fn dec(&mut self) {
-        self.status.dec();
-        self.stderr_bytes.dec();
+        self.exit_code.dec();
         self.stdout_bytes.dec();
+        self.stderr_bytes.dec();
     }
     fn is_refcounted() -> bool {
         true
@@ -132,15 +132,27 @@ pub fn command_exec_output(roc_cmd: &Command) -> RocResult<OutputFromHostSuccess
     match std::process::Command::from(roc_cmd).output() {
         Ok(output) =>
             match output.status.code() {
-                Some(status) if status == 0 => RocResult::ok(OutputFromHostSuccess {
-                    stdout_bytes: RocList::from(&output.stdout[..]),
-                    stderr_bytes: RocList::from(&output.stderr[..]),
-                }),
-                Some(status) => RocResult::err(RocResult::ok(OutputFromHostFailure {
-                    status: status,
-                    stdout_bytes: RocList::from(&output.stdout[..]),
-                    stderr_bytes: RocList::from(&output.stdout[..]),
-                })),
+                Some(status) => {
+
+                    let stdout_bytes = RocList::from(&output.stdout[..]);
+                    let stderr_bytes = RocList::from(&output.stderr[..]);
+
+                    if status == 0 {
+                        // Success case
+                        RocResult::ok(OutputFromHostSuccess {
+                            stderr_bytes,
+                            stdout_bytes,
+                        })
+                    } else {
+                        println!("{:?}", stderr_bytes);
+                        // Failure case
+                        RocResult::err(RocResult::ok(OutputFromHostFailure {
+                            stderr_bytes,
+                            stdout_bytes,
+                            exit_code: status,
+                        }))
+                    }
+                },
                 None => RocResult::err(RocResult::err(killed_by_signal_err()))
             }
         Err(err) => RocResult::err(RocResult::err(err.into()))
diff --git a/examples/command.roc b/examples/command.roc
@@ -6,6 +6,8 @@ import pf.Arg exposing [Arg]
 
 # Different ways to run commands like you do in a terminal. 
 
+# TODO add failure branch coverage to command test
+
 # To run this example: check the README.md in this folder
 
 main! : List Arg => Result {} _
@@ -20,35 +22,30 @@ main! = |_args|
         |> Cmd.args(["Hi"])
         |> Cmd.exec_output!()?
 
-    Stdout.line!(
-        """
-        stdout:${cmd_output.stdout_utf8}
-        stderr:${cmd_output.stderr_utf8_lossy}
-        """
-    )?
+    Stdout.line!("${Inspect.to_str(cmd_output)}")?
 
     # To run a command with environment variables.
-    cmd_output_env =
-        Cmd.new("env")
-        |> Cmd.clear_envs # You probably don't need to clear all other environment variables, this is just an example.
-        |> Cmd.env("FOO", "BAR")
-        |> Cmd.envs([("BAZ", "DUCK"), ("XYZ", "ABC")]) # Set multiple environment variables at once with `envs`
-        |> Cmd.args(["-v"])
-        |> Cmd.exec_output!()?
-
-    Stdout.line!(
-        """
-        stdout:${cmd_output_env.stdout_utf8}
-        stderr:${cmd_output_env.stderr_utf8_lossy}
-        """
-    )?
+    Cmd.new("env")
+    |> Cmd.clear_envs # You probably don't need to clear all other environment variables, this is just an example.
+    |> Cmd.env("FOO", "BAR")
+    |> Cmd.envs([("BAZ", "DUCK"), ("XYZ", "ABC")]) # Set multiple environment variables at once with `envs`
+    |> Cmd.args(["-v"])
+    |> Cmd.exec_cmd!()?
 
     # To execute and just get the exit code (prints to your terminal).
     exit_code =
-        Cmd.new("echo")
-        |> Cmd.args(["Yo"])
+        Cmd.new("cat")
+        |> Cmd.args(["temp.txt"])
         |> Cmd.exec_exit_code!()?
 
     Stdout.line!("Exit code: ${Num.to_str(exit_code)}")?
 
+    # To execute and capture the output in the original form as bytes (stdout, stderr, and exit code) without inheriting your terminal.
+    cmd_output_bytes =
+        Cmd.new("echo")
+        |> Cmd.args(["Hi"])
+        |> Cmd.exec_output_bytes!()?
+
+    Stdout.line!("${Inspect.to_str(cmd_output_bytes)}")?
+
     Ok({})
diff --git a/platform/Cmd.roc b/platform/Cmd.roc
@@ -7,6 +7,7 @@ module [
     envs,
     clear_envs,
     exec_output!,
+    exec_output_bytes!,
     exec!,
     exec_cmd!,
     exec_exit_code!,
@@ -25,12 +26,12 @@ Cmd := InternalCmd.Command
 ## # Call echo to print "hello world"
 ## Cmd.exec!("echo", ["hello world"])?
 ## ```
-exec! : Str, List Str => Result {} [ExecFailed Str I32, FailedToGetExitCode Str IOErr]
+exec! : Str, List Str => Result {} [ExecFailed Str I32, FailedToGetExitCode({ command : Str, err : IOErr})]
 exec! = |cmd_name, arguments|
     exit_code =
         new(cmd_name)
         |> args(arguments)
-        |> exec_exit_code!?
+        |> exec_exit_code!()?
 
     if exit_code == 0i32 then
         Ok({})
@@ -48,15 +49,15 @@ exec! = |cmd_name, arguments|
 ## |> Cmd.env("RUST_BACKTRACE", "1")
 ## |> Cmd.exec_cmd!()?
 ## ```
-exec_cmd! : Cmd => Result {} [ExecCmdFailed Str I32, FailedToGetExitCode Str IOErr]
+exec_cmd! : Cmd => Result {} [ExecCmdFailed({ command : Str, exit_code : I32 }), FailedToGetExitCode({ command : Str, err : IOErr})]
 exec_cmd! = |@Cmd(cmd)|
     exit_code =
         exec_exit_code!(@Cmd(cmd))?
 
     if exit_code == 0i32 then
         Ok({})
     else
-        Err(ExecCmdFailed(to_str(cmd), exit_code))
+        Err(ExecCmdFailed({ command: to_str(cmd), exit_code }))
 
 ## Execute command and capture stdout, stderr and the exit code in [Output].
 ##
@@ -68,50 +69,52 @@ exec_output! : Cmd =>
                     Result
                         {stdout_utf8 : Str, stderr_utf8_lossy : Str}
                         [
-                            StdoutContainsInvalidUtf8({ cmd : Str, err: [BadUtf8 { index : U64, problem : Str.Utf8Problem }]}),
-                            NonZeroExitCode({cmd : Str, exit_code: I32, stdout_utf8_lossy: Str, stderr_utf8_lossy: Str}),
-                            FailedToGetExitCode({ cmd : Str, err : IOErr})
+                            StdoutContainsInvalidUtf8({ cmd_str : Str, err: [BadUtf8 { index : U64, problem : Str.Utf8Problem }]}),
+                            NonZeroExitCode({command : Str, exit_code: I32, stdout_utf8_lossy: Str, stderr_utf8_lossy: Str}),
+                            FailedToGetExitCode({ command : Str, err : IOErr})
                         ]
 exec_output! = |@Cmd(cmd)|
     exec_res = Host.command_exec_output!(cmd)
     
     when exec_res is
-        Ok({stdout_bytes, stderr_bytes}) ->
-            stdout_utf8 = Str.from_utf8(stdout_bytes) ? |err| StdoutContainsInvalidUtf8({ cmd: to_str(cmd), err})
+        Ok({stderr_bytes, stdout_bytes}) ->
+            stdout_utf8 = Str.from_utf8(stdout_bytes) ? |err| StdoutContainsInvalidUtf8({cmd_str: to_str(cmd), err})#{ cmd: to_str(cmd), err})
             stderr_utf8_lossy = Str.from_utf8_lossy(stderr_bytes)
 
             Ok({stdout_utf8, stderr_utf8_lossy})
         Err(inside_res) ->
             when inside_res is
-                Ok({exit_code, stdout_bytes, stderr_bytes}) ->
-                    stdout_utf8_lossy = Str.from_utf8_lossy(stdout_bytes)
-                    stderr_utf8_lossy = Str.from_utf8_lossy(stderr_bytes)
+                Ok({exit_code, stderr_bytes, stdout_bytes}) ->
+                   stdout_utf8_lossy = Str.from_utf8_lossy(stdout_bytes)
+                   stderr_utf8_lossy = Str.from_utf8_lossy(stderr_bytes)
 
-                    Err(NonZeroExitCode({cmd : to_str(cmd), exit_code, stdout_utf8_lossy, stderr_utf8_lossy}))
+                   Err(NonZeroExitCode({command : to_str(cmd), exit_code, stdout_utf8_lossy, stderr_utf8_lossy}))
                 Err(err) ->
-                    Err(InternalIOErr.handle_err(err))
-                    |> Result.map_err(|er| FailedToGetExitCode({ cmd : to_str(cmd), err : er }))
+                    Err(FailedToGetExitCode({ command : to_str(cmd), err : InternalIOErr.handle_err(err) }))
 
-# TODO exec_output_bytes
+## TODO add type + explain command + when to use exec_output! + example 
+exec_output_bytes! = |@Cmd(cmd)|
+    exec_res = Host.command_exec_output!(cmd)
+    
+    when exec_res is
+        Ok({stderr_bytes, stdout_bytes}) ->
+            Ok({stdout_bytes, stderr_bytes})
+
+        Err(inside_res) ->
+            when inside_res is
+                Ok({exit_code, stderr_bytes, stdout_bytes}) ->
+                    Err(NonZeroExitCodeB({exit_code, stdout_bytes, stderr_bytes}))
+
+                Err(err) ->
+                    Err(FailedToGetExitCodeB(InternalIOErr.handle_err(err)))
 
 ## Execute command and inherit stdin, stdout and stderr from parent. Returns the exit code.
 ## Helper function.
-exec_exit_code! : Cmd => Result I32 [FailedToGetExitCode Str IOErr]
+exec_exit_code! : Cmd => Result I32 [FailedToGetExitCode({ command : Str, err : IOErr})]
 exec_exit_code! = |@Cmd(cmd)|
     Host.command_exec_exit_code!(cmd)
     |> Result.map_err(InternalIOErr.handle_err)
-    |> Result.map_err(|err| FailedToGetExitCode(to_str(cmd), err))
-
-# This hits a compiler bug: Alias `6.IdentId(11)` not registered in delayed aliases! ...
-# ## Converts output into a utf8 string. Invalid utf8 sequences in stderr are ignored.
-# to_str : Output -> Result Str [BadUtf8 { index : U64, problem : Str.Utf8Problem }]
-# to_str = |output|
-#     InternalCmd.output_to_str(output)
-
-# ## Converts output into a utf8 string, ignoring any invalid utf8 sequences.
-# to_str_lossy : Output -> Str
-# to_str_lossy = |output|
-#     InternalCmd.output_to_str_lossy(output)
+    |> Result.map_err(|err| FailedToGetExitCode({ command: to_str(cmd), err }))
 
 ## Create a new command to execute the given program in a child process.
 new : Str -> Cmd
diff --git a/platform/InternalCmd.roc b/platform/InternalCmd.roc
@@ -8,19 +8,21 @@ module [
 Command : {
     program : Str,
     args : List Str, # [arg0, arg1, arg2, arg3, ...]
-    envs : List Str, # [key0, value0, key1, value1, key2, value2, ...]
+    envs : List Str, # TODO change this to list of tuples? [key0, value0, key1, value1, key2, value2, ...]
     clear_envs : Bool,
 }
 
+# Do not change the order of the fields! It will lead to a segfault.
 OutputFromHostSuccess : {
-    stdout_bytes : List U8,
     stderr_bytes : List U8,
+    stdout_bytes : List U8,
 }
 
+# Do not change the order of the fields! It will lead to a segfault.
 OutputFromHostFailure : {
-    exit_code : I32,
-    stdout_bytes : List U8,
     stderr_bytes : List U8,
+    stdout_bytes : List U8,
+    exit_code : I32,
 }
 
 to_str : Command -> Str
@@ -29,12 +31,11 @@ to_str = |cmd|
         cmd.envs
         #|> List.map(|(key, value)| "${key}=${value}")
         |> Str.join_with(" ")
+        |> Str.trim()
+        |> (|trimmed_str| if Str.is_empty(trimmed_str) then "" else "envs: ${trimmed_str}")
 
-    clear_envs_str = if cmd.clear_envs then "true" else "false"
+    clear_envs_str = if cmd.clear_envs then ", clear_envs: true" else ""
     
     """
-    cmd: ${cmd.program}
-    args: ${Str.join_with(cmd.args, " ")}
-    envs: ${envs_str}
-    clear_envs: ${clear_envs_str}
+    { cmd: ${cmd.program}, args: ${Str.join_with(cmd.args, " ")}${envs_str}${clear_envs_str} }
     """
diff --git a/tests/cmd-test.roc b/tests/cmd-test.roc
@@ -6,6 +6,8 @@ import pf.Arg exposing [Arg]
 
 # Tests some error branches in Cmd functions.
 
+# TODO test all error branches in Cmd functions
+
 main! : List Arg => Result {} _
 main! = |_args|
     
@@ -19,7 +21,7 @@ main! = |_args|
 
     _ = when exec_res is
         Ok(_) ->
-            Err(BlaBlaCommandShouldHaveFailed)?
+            Err(FakeBlaBlaCommandShouldHaveFailed)?
         Err(err) ->
             Stdout.line!("Expected failure: ${Inspect.to_str(err)}")?
             Ok({})
