Initial commit.

Author: matanlurey

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.lock

@@ -0,0 +1,23 @@
+[package]
+name = "proc-result"
+version = "0.1.0"
+edition = "2024"
+
+[lints.clippy]
+pedantic = "deny"
+
+[features]
+std = []
+default = ["std"]
+serde = ["serde/derive"]
+
+[dependencies]
+serde = { version = "1.0.219", features = ["derive"], optional = true }
+
+[dependencies.num-traits]
+version = "0.2.19"
+default-features = false
+
+[dev-dependencies]
+libc = "0.2.172"
+serde_json = "1.0.140"

Cargo.toml

@@ -0,0 +1,19 @@
+Copyright (c) 2025 Matan Lurey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSE

@@ -0,0 +1,54 @@
+# proc-result
+
+A tiny cross-platform library containing exit status and code types.
+
+Unlike `std::process`, this crate does not require the standard library[^1], nor
+`libc`, and can create and interpret exit codes of non-current platforms. For
+example, on Windows, it can read and interpret exit codes that may have been
+recorded from a Linux process, or vice versa.
+
+[^1]: The `std` feature is enabled by default, but can be disabled.
+
+## Usage
+
+Most users of the crate will use the `ToProcResult` trait, which converts the
+result a run of a subprocess to a `ProcResult`, either a successful or an error
+explaining what exit code or (on Unix platforms) the signal the subprocess was
+prematurely terminated with, and is constructed from a
+`std::process::ExitStatus`:
+
+```rust
+use proc_result::ToProcResult;
+use std::error::Error;
+use std::process::Command;
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let result = Command::new("ls").status()?.to_proc_result()?;
+    Ok(())
+}
+```
+
+Advanced users, or users writing tests or interpreting exit codes from other
+platforms may import and use the platform-specific exit code types directly,
+from the `unix` or `windows` modules, respectively. For example, to create a
+Unix exit code from a raw integer:
+
+```rust
+use proc_result::unix::ExitCode;
+
+fn main() {
+    let code = ExitCode::from_raw(1);
+    if code.is_success() {
+        println!("Command succeeded!");
+    } else {
+        eprintln!("Command failed with exit code: {}", code);
+    }
+}
+```
+
+## Features
+
+Name    | Default | Description
+------- | ------- | -----------
+`serde` | `false` | Enables serialization support for most types using `serde`.
+`std`   | `true`  | Enables compatibility with `std::process::ExitStatus`.

README.md

@@ -0,0 +1 @@
+exit 0

examples/exit_code_0.sh

@@ -0,0 +1 @@
+exit 1

examples/exit_code_1.sh

@@ -0,0 +1,8 @@
+use proc_result::ToProcResult;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    std::process::Command::new("examples/exit_code_1.sh")
+        .status()?
+        .to_proc_result()?;
+    Ok(())
+}

examples/failure.rs

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+# Hangs forever, requiring CTRL-C to terminate.
+
+while true; do
+  sleep 1
+done

examples/hang_forever.sh

@@ -0,0 +1,23 @@
+use proc_result::ToProcResult;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut child = std::process::Command::new("examples/hang_forever.sh").spawn()?;
+    let pid = child.id();
+
+    // Spawn a thread, and in 1s, use the PID to kill the process (not the child handle).
+    std::thread::spawn(move || {
+        std::thread::sleep(std::time::Duration::from_secs(1));
+        println!("Using SIGTERM to kill process {pid}");
+        let _ = std::process::Command::new("kill")
+            .arg("-9")
+            .arg(pid.to_string())
+            .status();
+        println!("Done");
+    });
+
+    println!("Waiting for process to end");
+    child.wait()?.to_proc_result()?;
+
+    println!("Done!");
+    Ok(())
+}