Merge pull request #56 from rustcoreutils/hacking

PathBuf conversions

Author: jgarzik

text/src/wc.rs

@@ -13,8 +13,9 @@ extern crate plib;
 use clap::Parser;
 use gettextrs::{bind_textdomain_codeset, textdomain};
 use plib::PROJECT_NAME;
-use std::fs;
+use std::ffi::OsStr;
 use std::io::{self, BufRead, Read};
+use std::path::PathBuf;
 
 /// wc - word, line, and byte or character count
 #[derive(Parser, Debug)]
@@ -37,7 +38,7 @@ struct Args {
     words: bool,
 
     /// Files to read as input.
-    files: Vec<String>,
+    files: Vec<PathBuf>,
 }
 
 struct CountInfo {
@@ -62,7 +63,7 @@ impl CountInfo {
     }
 }
 
-fn build_display_str(args: &Args, count: &CountInfo, filename: &str) -> String {
+fn build_display_str(args: &Args, count: &CountInfo, filename: &OsStr) -> String {
     let mut output = String::with_capacity(filename.len() + (3 * 10));
 
     let multi_file = args.files.len() > 1;
@@ -104,20 +105,15 @@ fn build_display_str(args: &Args, count: &CountInfo, filename: &str) -> String {
         if filename == "" {
             output.push_str("(stdin)");
         } else {
-            output.push_str(filename);
+            output.push_str(filename.to_string_lossy().as_ref());
         }
     }
 
     output
 }
 
-fn wc_file_bytes(count: &mut CountInfo, filename: &str) -> io::Result<()> {
-    let mut file: Box<dyn Read>;
-    if filename == "" {
-        file = Box::new(io::stdin().lock());
-    } else {
-        file = Box::new(fs::File::open(filename)?);
-    }
+fn wc_file_bytes(count: &mut CountInfo, pathname: &PathBuf) -> io::Result<()> {
+    let mut file = plib::io::input_stream(pathname, false)?;
 
     let mut buffer = [0; plib::BUFSZ];
     let mut in_word = false;
@@ -161,15 +157,8 @@ fn wc_file_bytes(count: &mut CountInfo, filename: &str) -> io::Result<()> {
     Ok(())
 }
 
-fn wc_file_chars(args: &Args, count: &mut CountInfo, filename: &str) -> io::Result<()> {
-    let file: Box<dyn Read>;
-    if filename == "" {
-        file = Box::new(io::stdin().lock());
-    } else {
-        file = Box::new(fs::File::open(filename)?);
-    }
-
-    let mut reader = io::BufReader::new(file);
+fn wc_file_chars(args: &Args, count: &mut CountInfo, pathname: &PathBuf) -> io::Result<()> {
+    let mut reader = plib::io::input_reader(pathname, false)?;
 
     loop {
         let mut buffer = String::new();
@@ -205,14 +194,19 @@ fn wc_file_chars(args: &Args, count: &mut CountInfo, filename: &str) -> io::Resu
     Ok(())
 }
 
-fn wc_file(args: &Args, chars_mode: bool, filename: &str, count: &mut CountInfo) -> io::Result<()> {
+fn wc_file(
+    args: &Args,
+    chars_mode: bool,
+    pathname: &PathBuf,
+    count: &mut CountInfo,
+) -> io::Result<()> {
     if chars_mode {
-        wc_file_chars(args, count, filename)?;
+        wc_file_chars(args, count, pathname)?;
     } else {
-        wc_file_bytes(count, filename)?;
+        wc_file_bytes(count, pathname)?;
     }
 
-    let output = build_display_str(&args, count, filename);
+    let output = build_display_str(&args, count, pathname.as_os_str());
 
     println!("{}", output);
 
@@ -245,7 +239,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     if args.files.is_empty() {
         let mut count = CountInfo::new();
 
-        if let Err(e) = wc_file(&args, chars_mode, "", &mut count) {
+        if let Err(e) = wc_file(&args, chars_mode, &PathBuf::new(), &mut count) {
             exit_code = 1;
             eprintln!("stdin: {}", e);
         }
@@ -257,15 +251,15 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
             if let Err(e) = wc_file(&args, chars_mode, filename, &mut count) {
                 exit_code = 1;
-                eprintln!("{}: {}", filename, e);
+                eprintln!("{}: {}", filename.display(), e);
             }
 
             totals.accum(&count);
         }
     }
 
     if args.files.len() > 1 {
-        let output = build_display_str(&args, &totals, "total");
+        let output = build_display_str(&args, &totals, &OsStr::new("total"));
         println!("{}", output);
     }
 

xform/src/uudecode.rs

@@ -15,45 +15,41 @@ use base64::prelude::*;
 use clap::Parser;
 use gettextrs::{bind_textdomain_codeset, textdomain};
 use plib::PROJECT_NAME;
-use std::fs::{self, OpenOptions};
+use std::fs::OpenOptions;
 use std::io::{self, Error, ErrorKind, Read, Write};
+use std::path::PathBuf;
 
 /// uudecode - decode a binary file
 #[derive(Parser, Debug)]
 #[command(author, version, about, long_about)]
 struct Args {
     /// A pathname of a file that shall be used instead of any pathname contained in the input data.
     #[arg(short, long)]
-    outfile: Option<String>,
+    outfile: Option<PathBuf>,
 
-    /// The pathname of a file containing the output of uuencode.
-    file: Option<String>,
+    /// The pathname of a file containing uuencoded data.
+    file: Option<PathBuf>,
 }
 
-fn write_file(filename: &str, bindata: &[u8]) -> io::Result<()> {
+fn write_file(pathname: &PathBuf, bindata: &[u8]) -> io::Result<()> {
     let f_res = OpenOptions::new()
         .read(false)
         .write(true)
         .create(true)
         .truncate(true)
-        .open(filename);
+        .open(pathname);
 
     match f_res {
         Err(e) => {
-            eprintln!("{}: {}", filename, e);
+            eprintln!("{}: {}", pathname.display(), e);
             return Err(e);
         }
         Ok(mut file) => file.write_all(bindata),
     }
 }
 
 fn decode_file(args: &Args) -> io::Result<()> {
-    let mut file: Box<dyn Read>;
-    if let Some(filename) = &args.file {
-        file = Box::new(fs::File::open(filename)?);
-    } else {
-        file = Box::new(io::stdin().lock());
-    }
+    let mut file = plib::io::input_stream_opt(&args.file)?;
 
     // read entire file into memory.
     // ugly but necessary due to uudecode crate implementation.
@@ -68,7 +64,7 @@ fn decode_file(args: &Args) -> io::Result<()> {
 
         // decode succeeded. exit here.
         Ok(bindata) => match &args.outfile {
-            None => return write_file("bindata.out", &bindata[..]),
+            None => return write_file(&PathBuf::from("bindata.out"), &bindata[..]),
             Some(outfn) => return write_file(outfn, &bindata[..]),
         },
     }
@@ -77,12 +73,19 @@ fn decode_file(args: &Args) -> io::Result<()> {
     match uuencode::uudecode(&buffer) {
         None => return Err(Error::new(ErrorKind::Other, "invalid input data")),
         Some((bindata, filename)) => match &args.outfile {
-            None => write_file(&filename, &bindata[..]),
+            None => write_file(&PathBuf::from(filename), &bindata[..]),
             Some(outfn) => write_file(outfn, &bindata[..]),
         },
     }
 }
 
+fn pathname_display(path: &Option<PathBuf>) -> String {
+    match path {
+        None => "stdin".to_string(),
+        Some(p) => p.display().to_string(),
+    }
+}
+
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     // parse command line arguments
     let args = Args::parse();
@@ -94,7 +97,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     if let Err(e) = decode_file(&args) {
         exit_code = 1;
-        eprintln!("{:?}: {}", args.file, e);
+        eprintln!("{:?}: {}", pathname_display(&args.file), e);
     }
 
     std::process::exit(exit_code)