diff: write a one-line add or delete range as a single number

The normal format printed a single added or deleted line as a range,
"1a2,2" and "2,2d1", where GNU diff and POSIX write "1a2" and "2d1",
and -e printed "2,2d" for "2d". Changed lines already had this
(see #10); do the same for added and deleted ones.

Author: jayhemnani9910

src/ed_diff.rs

@@ -126,6 +126,7 @@ pub fn diff(expected: &[u8], actual: &[u8], params: &Params) -> Result<Vec<u8>,
         match (expected_count, actual_count) {
             (0, 0) => unreachable!(),
             (0, _) => writeln!(&mut output, "{}a", line_number_expected - 1).unwrap(),
+            (1, 0) => writeln!(&mut output, "{line_number_expected}d").unwrap(),
             (_, 0) => writeln!(
                 &mut output,
                 "{},{}d",
@@ -180,6 +181,12 @@ mod tests {
         assert_eq!(diff, expected.as_bytes());
     }
 
+    #[test]
+    fn test_single_line_deleted() {
+        let diff = diff(b"a\nb\n", b"a\n", &Params::default()).unwrap();
+        assert_eq!(diff, b"2d\n");
+    }
+
     #[test]
     fn test_permutations() {
         let target = "target/ed-diff/";

src/normal_diff.rs

@@ -133,6 +133,13 @@ pub fn diff(expected: &[u8], actual: &[u8], params: &Params) -> Vec<u8> {
         let actual_count = result.actual.len();
         match (expected_count, actual_count) {
             (0, 0) => unreachable!(),
+            (0, 1) => writeln!(
+                // exactly one line added
+                &mut output,
+                "{}a{line_number_actual}",
+                line_number_expected - 1
+            )
+            .unwrap(),
             (0, _) => writeln!(
                 // 'a' stands for "Add lines"
                 &mut output,
@@ -142,6 +149,13 @@ pub fn diff(expected: &[u8], actual: &[u8], params: &Params) -> Vec<u8> {
                 line_number_actual + actual_count - 1
             )
             .unwrap(),
+            (1, 0) => writeln!(
+                // exactly one line deleted
+                &mut output,
+                "{line_number_expected}d{}",
+                line_number_actual - 1
+            )
+            .unwrap(),
             (_, 0) => writeln!(
                 // 'd' stands for "Delete lines"
                 &mut output,
@@ -228,6 +242,15 @@ mod tests {
         assert_eq!(diff, expected);
     }
 
+    #[test]
+    fn test_single_line_added_or_deleted() {
+        // A one-line range is written as a single number, as for c.
+        let added = diff(b"a\n", b"a\nb\n", &Params::default());
+        assert_eq!(added, b"1a2\n> b\n".to_vec());
+        let deleted = diff(b"a\nb\n", b"a\n", &Params::default());
+        assert_eq!(deleted, b"2d1\n< b\n".to_vec());
+    }
+
     #[test]
     fn test_permutations() {
         let target = "target/normal-diff/";