Add UnblamedHunk::split_at

This greatly simplifies some parts of the code. One possible follow-up
is the introduction of `BlameEntry::from_unblamed_hunk`.

- Remove `LineRange`. This is not necessary anymore.

Author: cruessler

gix-blame/src/lib.rs

@@ -82,37 +82,6 @@ impl SubAssign<u32> for Offset {
     }
 }
 
-#[derive(Clone, Copy, Debug)]
-struct LineRange {
-    start: u32,
-    end: u32,
-}
-
-impl LineRange {
-    fn with_offset(range: Range<u32>, offset: Offset) -> Self {
-        match offset {
-            Offset::Added(added) => {
-                assert!(range.start >= added, "{range:?} {offset:?}");
-
-                Self {
-                    start: range.start - added,
-                    end: range.end - added,
-                }
-            }
-            Offset::Deleted(deleted) => Self {
-                start: range.start + deleted,
-                end: range.end + deleted,
-            },
-        }
-    }
-}
-
-impl From<LineRange> for Range<u32> {
-    fn from(line_range: LineRange) -> Self {
-        line_range.start..line_range.end
-    }
-}
-
 #[derive(Debug, PartialEq)]
 pub struct BlameEntry {
     pub range_in_blamed_file: Range<u32>,
@@ -173,6 +142,12 @@ pub struct UnblamedHunk {
     pub range_in_destination: Range<u32>,
 }
 
+#[derive(Debug)]
+enum Either<T, U> {
+    Left(T),
+    Right(U),
+}
+
 impl UnblamedHunk {
     pub fn new(range_in_blamed_file: Range<u32>, offset: Offset) -> Self {
         assert!(
@@ -231,6 +206,22 @@ impl UnblamedHunk {
         Self::new(self.range_in_blamed_file.clone(), combined_offset)
     }
 
+    fn split_at(self, line_number_in_destination: u32) -> Either<Self, (Self, Self)> {
+        if line_number_in_destination > self.range_in_destination.start
+            && line_number_in_destination < self.range_in_destination.end
+        {
+            let first_range_in_destination = self.range_in_destination.start..line_number_in_destination;
+            let second_range_in_destination = line_number_in_destination..self.range_in_destination.end;
+
+            Either::Right((
+                Self::from_destination(first_range_in_destination, self.offset()),
+                Self::from_destination(second_range_in_destination, self.offset()),
+            ))
+        } else {
+            Either::Left(self)
+        }
+    }
+
     fn offset(&self) -> Offset {
         if self.range_in_blamed_file.start > self.range_in_destination.start {
             Offset::Added(self.range_in_blamed_file.start - self.range_in_destination.start)
@@ -379,59 +370,48 @@ pub fn process_change(
                     //     <--->     (added)
                     //     <--->     (blamed)
                     // <-->     <->  (new hunk)
-                    if added.start > hunk.range_in_destination.start {
-                        let line_range_in_next_destination = LineRange::with_offset(
-                            hunk.range_in_destination.start..added.start,
-                            *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 = match hunk.split_at(added.start) {
+                        Either::Left(hunk) => hunk,
+                        Either::Right((before, after)) => {
+                            new_hunks_to_blame.push(before.shift_by(*offset_in_destination));
+
+                            after
+                        }
+                    };
 
                     *offset_in_destination += added.end - added.start;
                     *offset_in_destination -= number_of_lines_deleted;
 
-                    out.push(BlameEntry::with_offset(added.clone(), suspect, hunk.offset()));
-
-                    let new_hunk = if hunk.range_in_destination.end > added.end {
-                        Some(UnblamedHunk::from_destination(
-                            added.end..hunk.range_in_destination.end,
-                            hunk.offset(),
-                        ))
-                    } else {
-                        None
-                    };
+                    out.push(BlameEntry::with_offset(added.clone(), suspect, new_hunk.offset()));
 
-                    (new_hunk, None)
+                    match new_hunk.split_at(added.end) {
+                        Either::Left(_) => (None, None),
+                        Either::Right((_, after)) => (Some(after), None),
+                    }
                 }
                 (true, false) => {
                     // <-------->     (hunk)
                     //     <------->  (added)
                     //     <---->     (blamed)
                     // <-->           (new hunk)
 
-                    if added.start > hunk.range_in_destination.start {
-                        let line_range_in_next_destination = LineRange::with_offset(
-                            hunk.range_in_destination.start..added.start,
-                            *offset_in_destination,
-                        );
+                    let new_hunk = match hunk.split_at(added.start) {
+                        Either::Left(hunk) => hunk,
+                        Either::Right((before, after)) => {
+                            new_hunks_to_blame.push(before.shift_by(*offset_in_destination));
 
-                        new_hunks_to_blame.push(UnblamedHunk::from_destination(
-                            line_range_in_next_destination.into(),
-                            hunk.offset() + *offset_in_destination,
-                        ));
-                    }
+                            after
+                        }
+                    };
 
                     out.push(BlameEntry::with_offset(
-                        added.start..hunk.range_in_destination.end,
+                        added.start..new_hunk.range_in_destination.end,
                         suspect,
-                        hunk.offset(),
+                        new_hunk.offset(),
                     ));
 
-                    if added.end > hunk.range_in_destination.end {
+                    if added.end > new_hunk.range_in_destination.end {
                         (None, Some(Change::Added(added, number_of_lines_deleted)))
                     } else {
                         todo!();
@@ -452,16 +432,10 @@ pub fn process_change(
                     *offset_in_destination += added.end - added.start;
                     *offset_in_destination -= number_of_lines_deleted;
 
-                    let new_hunk = if hunk.range_in_destination.end > added.end {
-                        Some(UnblamedHunk::from_destination(
-                            added.end..hunk.range_in_destination.end,
-                            hunk.offset(),
-                        ))
-                    } else {
-                        None
-                    };
-
-                    (new_hunk, None)
+                    match hunk.split_at(added.end) {
+                        Either::Left(_) => (None, None),
+                        Either::Right((_, after)) => (Some(after), None),
+                    }
                 }
                 (false, false) => {
                     // Any of the following cases are handled by this branch:
@@ -517,26 +491,18 @@ pub fn process_change(
                 //  <----->  (hunk)
                 //     |     (line_number_in_destination)
 
-                if hunk.range_in_destination.start < line_number_in_destination {
-                    let line_range_in_next_destination = LineRange::with_offset(
-                        hunk.range_in_destination.start..line_number_in_destination,
-                        *offset_in_destination,
-                    );
+                let new_hunk = match hunk.split_at(line_number_in_destination) {
+                    Either::Left(hunk) => hunk,
+                    Either::Right((before, after)) => {
+                        new_hunks_to_blame.push(before.shift_by(*offset_in_destination));
 
-                    new_hunks_to_blame.push(UnblamedHunk::from_destination(
-                        line_range_in_next_destination.into(),
-                        hunk.offset() + *offset_in_destination,
-                    ));
-                }
+                        after
+                    }
+                };
 
                 *offset_in_destination -= number_of_lines_deleted;
 
-                let new_hunk = Some(UnblamedHunk::from_destination(
-                    line_number_in_destination..hunk.range_in_destination.end,
-                    hunk.offset(),
-                ));
-
-                (new_hunk, None)
+                (Some(new_hunk), None)
             } else {
                 //  <--->     (hunk)
                 //         |  (line_number_in_destination)