Skip to content

Home

Jump to bottom
rust-shell-script edited this page Dec 19, 2025 · 6 revisions

Bash script to Rust Conversion Guide

Introduction

cmd_lib lets you write shell-script-like code in Rust with compile-time safety and proper error handling. By default, it behaves like bash with set -euo pipefail - commands fail fast and errors propagate. You can check some real project examples, where rust is being used for xtask and DevOps.

Quick Reference

Bash Rust (cmd_lib)
Error Handling
set -euo pipefail Built-in default
echo "Error at $LINENO" Automatic (includes cmd + file:line)
set -x / set +x ScopedDebug::set(true) / drops
set -x (env var) RUST_LOG=debug RUST_CMD_LIB_DEBUG=1 ./program
set -o pipefail ScopedPipefail::set(true)
cmd || true run_cmd!(ignore cmd)?
Commands
cmd arg1 arg2 run_cmd!(cmd arg1 arg2)?
output=$(cmd) let output = run_fun!(cmd)?
cmd & spawn!(cmd)?
Pipes
cmd1 | cmd2 run_cmd!(cmd1 | cmd2)?
cmd1 | cmd2 | cmd3 run_cmd!(cmd1 | cmd2 | cmd3)?
cmd1 |& cmd2 run_cmd!(cmd1 |& cmd2)?
Redirections
cmd > file run_cmd!(cmd > file)?
cmd >> file run_cmd!(cmd >> file)?
cmd < file run_cmd!(cmd < file)?
cmd 2> file run_cmd!(cmd 2> file)?
cmd 2>&1 run_cmd!(cmd 2>&1)?
cmd 1>&2 run_cmd!(cmd 1>&2)?
cmd 1>&2 run_cmd!(cmd 1>&2)?
Variables
echo $var run_cmd!(echo $var)?
echo ${var} run_cmd!(echo ${var})?
echo '$var' (literal) run_cmd!(echo r"$var")?
VAR=val cmd run_cmd!(VAR=val cmd)?
export VAR=val std::env::set_var("VAR", "val")
Directory
cd dir; cmd; cd - run_cmd!{ cd dir; cmd; }? (auto-restores)
Global Variables
VAR=value (global) tls_init!(VAR, Type, default)
echo $VAR tls_get!(VAR)
VAR=new_value tls_set!(VAR, |v| *v = new_value)

Detailed Conversions

1. Basic Command Execution

Bash:

ls -la
echo "hello world"

Rust:

run_cmd!(ls -la)?;
run_cmd!(echo "hello world")?;

2. Capturing Output

Bash:

version=$(rustc --version)
count=$(wc -l < file.txt)

Rust:

let version = run_fun!(rustc --version)?;
let count = run_fun!(wc -l < file.txt)?;

3. Variables

Bash:

name="world"
echo "hello $name"
echo "path is ${HOME}/bin"

Rust:

let name = "world";
run_cmd!(echo "hello $name")?;
let home = std::env::var("HOME")?;
run_cmd!(echo "path is ${home}/bin")?;

Vector expansion (no bash equivalent):

let args = vec!["-l", "-a", "/tmp"];
run_cmd!(ls $[args])?;  // expands to: ls -l -a /tmp

Raw strings (disable interpolation):

run_cmd!(echo r"$HOME")?;  // prints literal $HOME

4. Pipes

Bash:

cat file.txt | grep pattern | wc -l
ps aux | grep nginx | awk '{print $2}'

Rust:

run_cmd!(cat file.txt | grep pattern | wc -l)?;
let pids = run_fun!(ps aux | grep nginx | awk r"{print $2}")?;

5. Redirections

Bash:

echo "text" > output.txt
echo "more" >> output.txt
cmd 2>/dev/null
cmd 2>&1
cmd &> all.log
cmd < input.txt

Rust:

run_cmd!(echo "text" > output.txt)?;
run_cmd!(echo "more" >> output.txt)?;
run_cmd!(cmd 2>/dev/null)?;
run_cmd!(cmd 2>&1)?;
run_cmd!(cmd &> all.log)?;
run_cmd!(cmd < input.txt)?;

6. Error Handling

Bash (set -e is default in cmd_lib):

set -e
cmd1
cmd2  # won't run if cmd1 fails

Rust (default behavior):

run_cmd! {
    cmd1;
    cmd2;  // won't run if cmd1 fails
}?;

Automatic error reporting:

Unlike bash, cmd_lib automatically includes the failed command and source location in error messages:

Error: Running ["ls" "/nonexistent"] exited with error; status code: 2
    at src/main.rs:15

No need for manual echo "Error at line $LINENO" - it's built-in.

Bash (ignore errors):

rm -f file.txt || true
set +e
risky_command
set -e

Rust:

run_cmd!(ignore rm -f file.txt)?;
// or in a block:
run_cmd! {
    ignore risky_command;
    next_command;
}?;

Bash (pipefail):

set -o pipefail
false | true  # fails
set +o pipefail
false | true  # succeeds

Rust:

// pipefail is ON by default
run_cmd!(false | true)?;  // fails

// disable temporarily:
let _pf = ScopedPipefail::set(false);
run_cmd!(false | true)?;  // succeeds
// pipefail restored when _pf drops

7. Directory Changes (cd)

Bash:

cd /tmp
ls
cd -

Rust (cd is scoped - auto restores):

run_cmd! {
    cd /tmp;
    ls;
}?;
// automatically back to original dir

8. Environment Variables

Bash:

export FOO=bar
FOO=bar ./script.sh

Rust:

std::env::set_var("FOO", "bar");
run_cmd!(FOO=bar ./script.sh)?;  // per-command env

9. Command Groups

Bash:

{
    echo "step 1"
    echo "step 2"
    ls /tmp
}

Rust:

run_cmd! {
    echo "step 1";
    echo "step 2";
    ls /tmp;
}?;

10. Background Processes

Bash:

long_running_cmd &
pid=$!
# do other work
wait $pid

Rust:

let mut proc = spawn!(long_running_cmd)?;
// do other work
proc.wait()?;

// or with output capture:
let mut proc = spawn_with_output!(cmd)?;
let output = proc.wait_with_output()?;

11. Debug Mode (set -x)

Bash:

set -x
ls /tmp
set +x

Rust (in code):

// Global (affects all threads)
cmd_lib::set_debug(true);
run_cmd!(ls /tmp)?;
cmd_lib::set_debug(false);

// Scoped (thread-local, auto-restores)
{
    let _debug = ScopedDebug::set(true);
    run_cmd!(ls /tmp)?;  // prints: [DEBUG] Running ["ls" "/tmp"] ...
}
// debug mode restored when _debug drops

Rust (via environment variables):

# Enable debug output at runtime without code changes
RUST_CMD_LIB_DEBUG=1 ./my_program

# With full log output (requires env_logger init)
RUST_LOG=debug RUST_CMD_LIB_DEBUG=1 ./my_program

12. Global/Thread-Local Variables

Bash:

COUNT=0
increment() {
    COUNT=$((COUNT + 1))
}
increment
echo $COUNT

Rust (thread-local variables):

use cmd_lib::*;

tls_init!(COUNT, i32, 0);

fn increment() {
    tls_set!(COUNT, |c| *c += 1);
}

fn main() {
    increment();
    println!("{}", tls_get!(COUNT));  // prints: 1
}

13. Logging (replaces echo for debugging)

Bash:

echo "INFO: Starting process"
echo "ERROR: Failed" >&2

Rust:

run_cmd!(info "Starting process")?;
run_cmd!(error "Failed")?;
// Also: warn, debug, trace

Complete Script Conversion Example

Bash script:

#!/bin/bash
set -euo pipefail

DIR="/tmp/test"
FILES=$(find . -name "*.txt")

mkdir -p "$DIR"
cd "$DIR"

for f in $FILES; do
    cp "$f" .
done

tar czf archive.tar.gz *.txt
echo "Done: $(ls *.txt | wc -l) files archived"

Rust equivalent:

use cmd_lib::*;
use glob::glob;

#[cmd_lib::main]
fn main() -> CmdResult {
    let dir = "/tmp/test";

    // Use glob crate instead of find with wildcard
    let files: Vec<String> = glob("./**/*.txt")
        .expect("Failed to read glob pattern")
        .filter_map(|e| e.ok())
        .map(|p| p.display().to_string())
        .collect();

    run_cmd!(mkdir -p $dir)?;
    for f in &files {
        run_cmd!(cd $dir; cp $f .)?;
    }

    // Get txt files in target dir for tar
    let txt_files: Vec<String> = glob(&format!("{}/*.txt", dir))
        .expect("Failed to read glob pattern")
        .filter_map(|e| e.ok())
        .map(|p| p.display().to_string())
        .collect();

    if !txt_files.is_empty() {
        run_cmd!(cd $dir; tar czf archive.tar.gz $[txt_files])?;
    }

    let count = txt_files.len();
    run_cmd!(info "Done: $count files archived")?;

    Ok(())
}

Key Differences from Bash

  1. No shell injection - Variables are parsed before substitution
  2. Compile-time checking - Syntax errors caught at compile time
  3. Scoped cd - Directory changes are automatically restored
  4. Type-safe - Rust's type system prevents many errors
  5. No glob expansion - Use external commands or Rust's glob crate
  6. Explicit error handling - Use ? or ignore keyword
  7. Automatic error context - Failed commands report command + source location

Clone this wiki locally