fix: only read from stdin if it's not a terminal #17

src/format.rs

@@ -68,10 +68,21 @@ pub struct FormatOptions {
     #[arg(short = 'z', long)]
     /// format to base32
     base32: bool,
-    #[clap(value_parser=numf_parser::<NumberType>, required=true)]
+    #[clap(value_parser=numf_parser::<NumberType>, required=false)]
     /// at least one number that should be formatted
     ///
-    /// supports either base 10 or base 16 inputs (with 0xaaaa)
+    /// Any of the [Formats](Format::format) are supported, but the prefixes are needed for formats
+    /// other than decimal.
+    ///
+    /// Formats:
+    ///
+    /// - '0x' - Hexadecimal
+    /// - '0b' - Binary
+    /// - '0o' - Octal
+    /// - '0s' - Base64
+    /// - '032s' - Base32
+    ///
+    /// The numbers may be left empty at first, if numbers are provided with the stdin.
     numbers: Vec<NumberType>,
 }
 
@@ -142,6 +153,11 @@ impl FormatOptions {
     pub fn set_prefix(&mut self, value: bool) {
         self.prefix = value;
     }
+
+    /// manually add a number
+    pub fn push_number(&mut self, value: NumberType) {
+        self.numbers.push(value)
+    }
 }
 
 impl Default for FormatOptions {

src/main.rs

@@ -3,41 +3,53 @@
 //! This binary should just take any amount of numbers and print them out formatted to some other
 //! system.
 
-use std::io::Read;
+use std::io::{IsTerminal, Read};
 use std::process::exit;
 
-use clap::Parser;
+use clap::{CommandFactory, Parser};
 
 mod format;
 use format::*;
+use numf::format::numf_parser;
 
 fn main() {
     // try to read from stdin first, appending the numbers we read to the FormatOptions
-    let mut args: Vec<String> = std::env::args_os()
-        .map(|x| x.into_string().unwrap())
-        .collect();
+    let mut options = FormatOptions::parse();
     let mut stdin_nums = Vec::new();
-    match std::io::stdin().lock().read_to_end(&mut stdin_nums) {
-        Ok(_) => {
-            let whole: String = match String::from_utf8(stdin_nums) {
-                Ok(r) => r,
-                Err(e) => {
-                    eprintln!("stdin for this program only accepts text: {e:#?}");
-                    exit(1);
+    let stdin = std::io::stdin();
+    if !stdin.is_terminal() {
+        match stdin.lock().read_to_end(&mut stdin_nums) {
+            Ok(_) => {
+                let whole: String = match String::from_utf8(stdin_nums) {
+                    Ok(r) => r,
+                    Err(e) => {
+                        eprintln!("stdin for this program only accepts text: {e:#?}");
+                        exit(1);
+                    }
+                };
+                let split = whole.split_whitespace();
+                for s in split {
+                    let number = match numf_parser(s) {
+                        Ok(n) => n,
+                        Err(e) => {
+                            eprintln!("could not parse number from stdin: {e:#?}");
+                            exit(2);
+                        }
+                    };
+                    options.push_number(number)
                 }
-            };
-            let split = whole.split_whitespace();
-            for s in split {
-                args.push(s.to_string());
             }
-        }
-        Err(e) => {
-            eprintln!("could not read from stdin: {e:#?}");
-            exit(2);
-        }
-    };
+            Err(e) => {
+                eprintln!("could not read from stdin: {e:#?}");
+                exit(2);
+            }
+        };
+    }
 
-    let options = FormatOptions::parse_from(args);
+    if options.numbers().is_empty() {
+        format!("{}", FormatOptions::command().render_usage());
+        exit(1);
+    }
 
     let mut out: Vec<String> = Vec::new();