Merge pull request #47 from oSoMoN/handle-stdin-filename

Handle the rewrite of "-" to "/dev/stdin" in main to leave the filenames unchanged (fixes #46)

Author: sylvestre

src/main.rs

@@ -5,9 +5,9 @@
 
 use crate::params::{parse_params, Format};
 use std::env;
-
+use std::ffi::OsString;
 use std::fs;
-use std::io::{self, Write};
+use std::io::{self, Read, Write};
 use std::process::{exit, ExitCode};
 
 mod context_diff;
@@ -38,19 +38,29 @@ fn main() -> ExitCode {
             );
         }
     };
-    if same_file::is_same_file(&params.from, &params.to).unwrap_or(false) {
+    if params.from == "-" && params.to == "-"
+        || same_file::is_same_file(&params.from, &params.to).unwrap_or(false)
+    {
         maybe_report_identical_files();
         return ExitCode::SUCCESS;
     }
     // read files
-    let from_content = match fs::read(&params.from) {
+    fn read_file_contents(filepath: &OsString) -> io::Result<Vec<u8>> {
+        if filepath == "-" {
+            let mut content = Vec::new();
+            io::stdin().read_to_end(&mut content).and(Ok(content))
+        } else {
+            fs::read(filepath)
+        }
+    }
+    let from_content = match read_file_contents(&params.from) {
         Ok(from_content) => from_content,
         Err(e) => {
             eprintln!("Failed to read from-file: {e}");
             return ExitCode::from(2);
         }
     };
-    let to_content = match fs::read(&params.to) {
+    let to_content = match read_file_contents(&params.to) {
         Ok(to_content) => to_content,
         Err(e) => {
             eprintln!("Failed to read to-file: {e}");

src/params.rs

@@ -67,9 +67,9 @@ pub fn parse_params<I: IntoIterator<Item = OsString>>(opts: I) -> Result<Params,
         }
         if param == "-" {
             if from.is_none() {
-                from = Some(OsString::from("/dev/stdin"));
+                from = Some(param);
             } else if to.is_none() {
-                to = Some(OsString::from("/dev/stdin"));
+                to = Some(param);
             } else {
                 return Err(format!("Usage: {} <from> <to>", exe.to_string_lossy()));
             }
@@ -461,23 +461,23 @@ mod tests {
         assert_eq!(
             Ok(Params {
                 from: os("foo"),
-                to: os("/dev/stdin"),
+                to: os("-"),
                 ..Default::default()
             }),
             parse_params([os("diff"), os("foo"), os("-")].iter().cloned())
         );
         assert_eq!(
             Ok(Params {
-                from: os("/dev/stdin"),
+                from: os("-"),
                 to: os("bar"),
                 ..Default::default()
             }),
             parse_params([os("diff"), os("-"), os("bar")].iter().cloned())
         );
         assert_eq!(
             Ok(Params {
-                from: os("/dev/stdin"),
-                to: os("/dev/stdin"),
+                from: os("-"),
+                to: os("-"),
                 ..Default::default()
             }),
             parse_params([os("diff"), os("-"), os("-")].iter().cloned())

tests/integration.rs

@@ -22,25 +22,30 @@ fn unknown_param() -> Result<(), Box<dyn std::error::Error>> {
 }
 
 #[test]
-fn cannot_read_from_file() -> Result<(), Box<dyn std::error::Error>> {
+fn cannot_read_files() -> Result<(), Box<dyn std::error::Error>> {
+    let file = NamedTempFile::new()?;
+
     let mut cmd = Command::cargo_bin("diffutils")?;
-    cmd.arg("foo.txt").arg("bar.txt");
+    cmd.arg("foo.txt").arg(file.path());
     cmd.assert()
         .code(predicate::eq(2))
         .failure()
         .stderr(predicate::str::starts_with("Failed to read from-file"));
-    Ok(())
-}
 
-#[test]
-fn cannot_read_to_file() -> Result<(), Box<dyn std::error::Error>> {
-    let file = NamedTempFile::new()?;
     let mut cmd = Command::cargo_bin("diffutils")?;
-    cmd.arg(file.path()).arg("bar.txt");
+    cmd.arg(file.path()).arg("foo.txt");
     cmd.assert()
         .code(predicate::eq(2))
         .failure()
         .stderr(predicate::str::starts_with("Failed to read to-file"));
+
+    let mut cmd = Command::cargo_bin("diffutils")?;
+    cmd.arg("foo.txt").arg("foo.txt");
+    cmd.assert()
+        .code(predicate::eq(2))
+        .failure()
+        .stderr(predicate::str::starts_with("Failed to read from-file"));
+
     Ok(())
 }
 
@@ -177,7 +182,7 @@ fn read_from_stdin() -> Result<(), Box<dyn std::error::Error>> {
         .code(predicate::eq(1))
         .failure()
         .stdout(predicate::eq(format!(
-            "--- {}\t\n+++ /dev/stdin\t\n@@ -1 +1 @@\n-foo\n+bar\n",
+            "--- {}\t\n+++ -\t\n@@ -1 +1 @@\n-foo\n+bar\n",
             file1.path().to_string_lossy()
         )));
 
@@ -190,16 +195,32 @@ fn read_from_stdin() -> Result<(), Box<dyn std::error::Error>> {
         .code(predicate::eq(1))
         .failure()
         .stdout(predicate::eq(format!(
-            "--- /dev/stdin\t\n+++ {}\t\n@@ -1 +1 @@\n-foo\n+bar\n",
+            "--- -\t\n+++ {}\t\n@@ -1 +1 @@\n-foo\n+bar\n",
             file2.path().to_string_lossy()
         )));
 
     let mut cmd = Command::cargo_bin("diffutils")?;
-    cmd.arg("-u").arg("-").arg("-").write_stdin("foo\n");
+    cmd.arg("-u").arg("-").arg("-");
     cmd.assert()
         .code(predicate::eq(0))
         .success()
         .stdout(predicate::str::is_empty());
 
+    #[cfg(unix)]
+    {
+        let mut cmd = Command::cargo_bin("diffutils")?;
+        cmd.arg("-u")
+            .arg(file1.path())
+            .arg("/dev/stdin")
+            .write_stdin("bar\n");
+        cmd.assert()
+            .code(predicate::eq(1))
+            .failure()
+            .stdout(predicate::eq(format!(
+                "--- {}\t\n+++ /dev/stdin\t\n@@ -1 +1 @@\n-foo\n+bar\n",
+                file1.path().to_string_lossy()
+            )));
+    }
+
     Ok(())
 }