rune-hex 0.1.1

Hex encoding and decoding for byte slices and files — lowercase, uppercase, and streaming output
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use clap::{Parser, Subcommand};
use rune_hex::{decode, encode, encode_upper};
use std::{
    io::{self, Read, Write},
    process::ExitCode,
};

/// Hex encode and decode bytes, files, and stdin.
#[derive(Parser)]
#[command(name = "rune-hex", version, author)]
struct Cli {
    #[command(subcommand)]
    command: Command,
}

#[derive(Subcommand)]
enum Command {
    /// Encode bytes to hex
    Encode {
        /// File to encode (omit or use - for stdin)
        file: Option<String>,
        /// Output uppercase hex
        #[arg(short, long)]
        upper: bool,
    },
    /// Decode a hex string to raw bytes
    Decode {
        /// Hex string to decode, or - to read from stdin
        input: Option<String>,
    },
}

fn main() -> ExitCode {
    let cli = Cli::parse();

    match cli.command {
        Command::Encode { file, upper } => {
            let data = match read_bytes(file.as_deref()) {
                Ok(d) => d,
                Err(e) => {
                    eprintln!("error: {e}");
                    return ExitCode::FAILURE;
                }
            };
            let hex = if upper {
                encode_upper(&data)
            } else {
                encode(&data)
            };
            println!("{hex}");
        }

        Command::Decode { input } => {
            let text = match read_text(input.as_deref()) {
                Ok(t) => t,
                Err(e) => {
                    eprintln!("error: {e}");
                    return ExitCode::FAILURE;
                }
            };
            match decode(text.trim()) {
                Ok(bytes) => {
                    if let Err(e) = io::stdout().write_all(&bytes) {
                        eprintln!("error: {e}");
                        return ExitCode::FAILURE;
                    }
                }
                Err(e) => {
                    eprintln!("error: {e}");
                    return ExitCode::FAILURE;
                }
            }
        }
    }

    ExitCode::SUCCESS
}

fn read_bytes(path: Option<&str>) -> io::Result<Vec<u8>> {
    match path {
        None | Some("-") => {
            let mut buf = Vec::new();
            io::stdin().read_to_end(&mut buf)?;
            Ok(buf)
        }
        Some(p) => std::fs::read(p),
    }
}

fn read_text(path: Option<&str>) -> io::Result<String> {
    match path {
        None | Some("-") => {
            let mut buf = String::new();
            io::stdin().read_to_string(&mut buf)?;
            Ok(buf)
        }
        Some(s) => Ok(s.to_owned()),
    }
}