Take offset into account only once for addition

Simplify a branch that processes unchanged lines.

Author: cruessler

gix-blame/tests/blame.rs

@@ -356,26 +356,13 @@ fn process_change(
                     && unchanged.end <= hunk.range_in_destination.end,
             ) {
                 (_, true) => {
-                    let line_range_in_next_destination = LineRange::with_offset(
-                        (unchanged.start.max(hunk.range_in_destination.start))..unchanged.end,
-                        *offset_in_destination,
-                    );
-
-                    new_hunks_to_blame.push(UnblamedHunk::from_destination(
-                        line_range_in_next_destination.into(),
-                        hunk.offset() + *offset_in_destination,
-                    ));
-
-                    let new_hunk = if hunk.range_in_destination.end > unchanged.end {
-                        Some(UnblamedHunk::from_destination(
-                            unchanged.end..hunk.range_in_destination.end,
-                            hunk.offset(),
-                        ))
-                    } else {
-                        None
-                    };
+                    //     <------>  (hunk)
+                    // <------->     (unchanged)
+                    //
+                    // <---------->  (hunk)
+                    //     <--->     (unchanged)
 
-                    (new_hunk, None)
+                    (Some(hunk), None)
                 }
                 (true, false) => {
                     // <-------->     (hunk)
@@ -488,24 +475,17 @@ fn process_change(
                         ));
                     }
 
-                    *offset_in_destination += added.end - added.start;
-                    *offset_in_destination -= number_of_lines_deleted;
-
                     lines_blamed.push(BlameEntry::with_offset(
                         added.start..hunk.range_in_destination.end,
                         suspect,
                         hunk.offset(),
                     ));
 
-                    let new_change = if added.end > hunk.range_in_destination.end {
-                        let line_range = hunk.range_in_destination.end..added.end;
-
-                        Some(Change::Added(line_range, number_of_lines_deleted))
+                    if added.end > hunk.range_in_destination.end {
+                        (None, Some(Change::Added(added, number_of_lines_deleted)))
                     } else {
                         todo!();
-                    };
-
-                    (None, new_change)
+                    }
                 }
                 (false, true) => {
                     //    <------->  (hunk)
@@ -1398,7 +1378,7 @@ fn process_change_works_added_hunk_8() {
     );
 
     assert_eq!(hunk, None);
-    assert_eq!(change, Some(Change::Added(26..27, 1)));
+    assert_eq!(change, Some(Change::Added(25..27, 1)));
     assert_eq!(
         lines_blamed,
         vec![BlameEntry {
@@ -1408,7 +1388,7 @@ fn process_change_works_added_hunk_8() {
         }]
     );
     assert_eq!(new_hunks_to_blame, vec![]);
-    assert_eq!(offset_in_destination, Offset::Added(2));
+    assert_eq!(offset_in_destination, Offset::Added(1));
 }
 
 #[test]
@@ -1442,6 +1422,80 @@ fn process_change_works_added_hunk_9() {
     assert_eq!(offset_in_destination, Offset::Added(1));
 }
 
+#[test]
+fn process_change_works_added_hunk_10() {
+    let mut lines_blamed: Vec<BlameEntry> = vec![];
+    let mut new_hunks_to_blame: Vec<UnblamedHunk> = vec![];
+    let mut offset_in_destination: Offset = Offset::Added(0);
+    let suspect = ObjectId::null(gix_hash::Kind::Sha1);
+
+    let (hunk, change) = process_change(
+        &mut lines_blamed,
+        &mut new_hunks_to_blame,
+        &mut offset_in_destination,
+        suspect,
+        // range_in_destination: 70..108
+        Some(UnblamedHunk::new(71..109, Offset::Added(1))),
+        Some(Change::Added(106..109, 0)),
+    );
+
+    assert_eq!(hunk, None);
+    assert_eq!(change, Some(Change::Added(106..109, 0)));
+    assert_eq!(
+        lines_blamed,
+        vec![BlameEntry {
+            range_in_blamed_file: 107..109,
+            range_in_original_file: 106..108,
+            commit_id: suspect
+        }]
+    );
+    assert_eq!(
+        new_hunks_to_blame,
+        vec![UnblamedHunk {
+            range_in_blamed_file: 71..107,
+            range_in_destination: 70..106
+        }]
+    );
+    assert_eq!(offset_in_destination, Offset::Added(0));
+}
+
+#[test]
+fn process_change_works_added_hunk_11() {
+    let mut lines_blamed: Vec<BlameEntry> = vec![];
+    let mut new_hunks_to_blame: Vec<UnblamedHunk> = vec![];
+    let mut offset_in_destination: Offset = Offset::Added(0);
+    let suspect = ObjectId::null(gix_hash::Kind::Sha1);
+
+    let (hunk, change) = process_change(
+        &mut lines_blamed,
+        &mut new_hunks_to_blame,
+        &mut offset_in_destination,
+        suspect,
+        // range_in_destination: 137..144
+        Some(UnblamedHunk::new(149..156, Offset::Added(12))),
+        Some(Change::Added(143..146, 0)),
+    );
+
+    assert_eq!(hunk, None);
+    assert_eq!(change, Some(Change::Added(143..146, 0)));
+    assert_eq!(
+        lines_blamed,
+        vec![BlameEntry {
+            range_in_blamed_file: 155..156,
+            range_in_original_file: 143..144,
+            commit_id: suspect
+        }]
+    );
+    assert_eq!(
+        new_hunks_to_blame,
+        vec![UnblamedHunk {
+            range_in_blamed_file: 149..155,
+            range_in_destination: 137..143
+        }]
+    );
+    assert_eq!(offset_in_destination, Offset::Added(0));
+}
+
 #[test]
 fn process_change_works_no_overlap() {
     let mut lines_blamed: Vec<BlameEntry> = vec![];
@@ -1738,19 +1792,13 @@ fn process_change_works_unchanged_hunk() {
     assert_eq!(
         hunk,
         Some(UnblamedHunk {
-            range_in_blamed_file: 3..5,
-            range_in_destination: 3..5
+            range_in_blamed_file: 0..5,
+            range_in_destination: 0..5
         })
     );
     assert_eq!(change, None);
     assert_eq!(lines_blamed, vec![]);
-    assert_eq!(
-        new_hunks_to_blame,
-        vec![UnblamedHunk {
-            range_in_blamed_file: 0..3,
-            range_in_destination: 0..3
-        }]
-    );
+    assert_eq!(new_hunks_to_blame, vec![]);
     assert_eq!(offset_in_destination, Offset::Added(0));
 }
 
@@ -1805,19 +1853,13 @@ fn process_change_works_unchanged_hunk_3() {
     assert_eq!(
         hunk,
         Some(UnblamedHunk {
-            range_in_blamed_file: 24..30,
-            range_in_destination: 23..29
+            range_in_blamed_file: 22..30,
+            range_in_destination: 21..29,
         })
     );
     assert_eq!(change, None);
     assert_eq!(lines_blamed, vec![]);
-    assert_eq!(
-        new_hunks_to_blame,
-        vec![UnblamedHunk {
-            range_in_blamed_file: 22..24,
-            range_in_destination: 23..25
-        }]
-    );
+    assert_eq!(new_hunks_to_blame, vec![]);
     assert_eq!(offset_in_destination, Offset::Deleted(2));
 }