From 76bbc1df6a0519606b0ffdcc3d98f163e0fa01d6 Mon Sep 17 00:00:00 2001
From: Anthony DePasquale <anthony@depasquale.org>
Date: Fri, 2 Oct 2026 19:21:02 +0200
Subject: [PATCH] sed: write appended text, R text and e output as GNU sed does

---
 src/sed/fast_io.rs        | 19 ++++++---
 src/sed/processor.rs      |  4 +-
 tests/by-util/test_sed.rs | 83 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 98 insertions(+), 8 deletions(-)

diff --git a/src/sed/fast_io.rs b/src/sed/fast_io.rs
index 5ea8bf3d..1fe73c87 100644
--- a/src/sed/fast_io.rs
+++ b/src/sed/fast_io.rs
@@ -678,13 +678,20 @@ impl OutputBuffer {
         )))
     }
 
-    /// Copy the specified file to the output.
-    pub fn copy_file(&mut self, path: &PathBuf) -> io::Result<()> {
-        // Flush mmap writes, if any.
+    /// Schedule the specified text for output unchanged, after any
+    /// deferred newline.
+    pub fn write_raw(&mut self, bytes: &[u8]) -> io::Result<()> {
+        self.flush_pending_newline()?;
         #[cfg(unix)]
-        {
-            self.flush_mmap(WriteRange::Complete)?;
-        }
+        self.flush_mmap(WriteRange::Complete)?;
+        self.out.write_all(bytes)
+    }
+
+    /// Copy the specified file to the output, after any deferred newline.
+    pub fn copy_file(&mut self, path: &PathBuf) -> io::Result<()> {
+        // As in GNU sed, write the deferred newline even when the file is
+        // empty or cannot be read.
+        self.write_raw(b"")?;
 
         let Ok(file) = File::open(path) else {
             // Per POSIX, if the file can't be read treat it as empty.
diff --git a/src/sed/processor.rs b/src/sed/processor.rs
index 298a974e..7f3dc42b 100644
--- a/src/sed/processor.rs
+++ b/src/sed/processor.rs
@@ -467,7 +467,7 @@ fn flush_appends(output: &mut OutputBuffer, context: &mut ProcessingContext) ->
     for elem in &context.append_elements {
         match elem {
             AppendElement::Text(text) => {
-                output.write_bytes(text.as_ref())?;
+                output.write_raw(text.as_ref())?;
             }
             AppendElement::Path(path) => {
                 output.copy_file(path)?;
@@ -738,7 +738,7 @@ fn process_file(
                     }
                     CommandData::Text(cmd_bytes) => {
                         let shell_out = shell_stdout(cmd_bytes.to_vec(), &command, context)?;
-                        output.write_bytes(&shell_out)?;
+                        output.write_raw(&shell_out)?;
                     }
                     _ => panic!("invalid 'e' command data"),
                 },
diff --git a/tests/by-util/test_sed.rs b/tests/by-util/test_sed.rs
index 5597d2fe..10477a7f 100644
--- a/tests/by-util/test_sed.rs
+++ b/tests/by-util/test_sed.rs
@@ -3132,3 +3132,86 @@ fn test_posix_reject_flags() {
         .code_is(1)
         .stderr_is("sed: <script argument 1>:1:7: error: unknown option to 's'\n");
 }
+
+/// `r` first writes a newline that the line lacks, even when the file is
+/// missing, and then copies the file unchanged, as GNU sed does.
+#[test]
+fn read_file_after_line_without_newline() -> std::io::Result<()> {
+    let dir = tempfile::tempdir()?;
+    let (one, two, text) = (
+        dir.path().join("1"),
+        dir.path().join("2"),
+        dir.path().join("text"),
+    );
+    fs::write(&one, "a")?;
+    fs::write(&two, "b\n")?;
+    fs::write(&text, "X\nY")?;
+    new_ucmd!()
+        .arg(format!("1r {}", text.display()))
+        .arg(&one)
+        .arg(&two)
+        .succeeds()
+        .stdout_is("a\nX\nYb\n");
+
+    let missing = dir.path().join("missing");
+    new_ucmd!()
+        .arg(format!("r {}", missing.display()))
+        .pipe_in("x")
+        .succeeds()
+        .stdout_is("x\n");
+    // `n` reads the next line without starting a new cycle, so `r` is not
+    // applied to it.
+    new_ucmd!()
+        .args(&["-e", &format!("r {}", missing.display()), "-e", "n"])
+        .pipe_in("x\ny")
+        .succeeds()
+        .stdout_is("x\ny");
+
+    // Text queued by `R` that lacks a newline is not ended before `r`.
+    let unterminated = dir.path().join("unterminated");
+    fs::write(&unterminated, "R")?;
+    new_ucmd!()
+        .args(&["-e", &format!("R {}", unterminated.display())])
+        .args(&["-e", &format!("r {}", text.display())])
+        .pipe_in("x\ny\n")
+        .succeeds()
+        .stdout_is("x\nRX\nYy\nX\nY");
+    new_ucmd!()
+        .args(&["-n", "-e", &format!("R {}", unterminated.display())])
+        .args(&["-e", &format!("r {}", text.display())])
+        .pipe_in("x\ny\n")
+        .succeeds()
+        .stdout_is("RX\nYX\nY");
+    Ok(())
+}
+
+/// `R` copies a line lacking a newline unchanged, as GNU sed does.
+#[test]
+fn read_one_line_without_newline_is_copied_unchanged() -> std::io::Result<()> {
+    let temp = NamedTempFile::new()?;
+    fs::write(temp.path(), "x")?;
+    new_ucmd!()
+        .arg(format!("R {}", temp.path().display()))
+        .pipe_in("a\nb\n")
+        .succeeds()
+        .stdout_is("a\nxb\n");
+    Ok(())
+}
+
+/// The output of the `e` command is copied unchanged, as GNU sed does.
+#[cfg(unix)]
+#[test]
+fn execute_command_output_is_copied_unchanged() {
+    new_ucmd!()
+        .arg("1e printf hi")
+        .pipe_in("a\nb\n")
+        .succeeds()
+        .stdout_is("hia\nb\n");
+    // A line that lacks its newline is ended before the output, even when
+    // there is none.
+    new_ucmd!()
+        .args(&["-n", "p;e true"])
+        .pipe_in("a")
+        .succeeds()
+        .stdout_is("a\n");
+}