stop scanning inside discovered repositories

crates/signed_git/src/diff.rs

@@ -110,6 +110,74 @@ impl CommitDiff {
     }
 }
 
+pub(crate) struct HunkBuilder {
+    old_start: u32,
+    old_lines: u32,
+    new_start: u32,
+    new_lines: u32,
+    old: u32,
+    new: u32,
+    lines: Vec<DiffLine>,
+    insertions: usize,
+    deletions: usize,
+}
+
+impl HunkBuilder {
+    /// Starts a hunk spanning the given old and new ranges.
+    pub(crate) fn new(old_start: u32, old_lines: u32, new_start: u32, new_lines: u32) -> Self {
+        Self {
+            old_start,
+            old_lines,
+            new_start,
+            new_lines,
+            old: old_start,
+            new: new_start,
+            lines: Vec::new(),
+            insertions: 0,
+            deletions: 0,
+        }
+    }
+
+    /// Appends a line, numbering it and counting insertions and deletions.
+    pub(crate) fn push(&mut self, kind: DiffLineKind, text: impl Into<String>) {
+        let (old_no, new_no) = match kind {
+            DiffLineKind::Context => {
+                let numbers = (Some(self.old), Some(self.new));
+                self.old += 1;
+                self.new += 1;
+                numbers
+            }
+            DiffLineKind::Addition => {
+                self.insertions += 1;
+                let number = Some(self.new);
+                self.new += 1;
+                (None, number)
+            }
+            DiffLineKind::Deletion => {
+                self.deletions += 1;
+                let number = Some(self.old);
+                self.old += 1;
+                (number, None)
+            }
+        };
+
+        self.lines
+            .push(DiffLine::new(kind, old_no, new_no, text.into()));
+    }
+
+    /// Finishes the hunk and returns it with its insertion and deletion counts.
+    pub(crate) fn finish(self) -> (DiffHunk, usize, usize) {
+        let hunk = DiffHunk::new(
+            self.old_start,
+            self.old_lines,
+            self.new_start,
+            self.new_lines,
+            self.lines,
+        );
+        (hunk, self.insertions, self.deletions)
+    }
+}
+
 pub(crate) struct HunkCollector<'a> {
     hunks: &'a mut Vec<DiffHunk>,
     insertions: &'a mut usize,
@@ -140,43 +208,26 @@ impl ConsumeHunk for HunkCollector<'_> {
         header: HunkHeader,
         lines: &[(GixLineKind, &[u8])],
     ) -> std::io::Result<()> {
-        let mut old_ln = header.before_hunk_start;
-        let mut new_ln = header.after_hunk_start;
-        let mut out = Vec::with_capacity(lines.len());
-
-        for (kind, content) in lines {
-            let text = String::from_utf8_lossy(content).into_owned();
-            let line = match kind {
-                GixLineKind::Context => {
-                    let line =
-                        DiffLine::new(DiffLineKind::Context, Some(old_ln), Some(new_ln), text);
-                    old_ln += 1;
-                    new_ln += 1;
-                    line
-                }
-                GixLineKind::Remove => {
-                    *self.deletions += 1;
-                    let line = DiffLine::new(DiffLineKind::Deletion, Some(old_ln), None, text);
-                    old_ln += 1;
-                    line
-                }
-                GixLineKind::Add => {
-                    *self.insertions += 1;
-                    let line = DiffLine::new(DiffLineKind::Addition, None, Some(new_ln), text);
-                    new_ln += 1;
-                    line
-                }
-            };
-            out.push(line);
-        }
-
-        self.hunks.push(DiffHunk::new(
+        let mut builder = HunkBuilder::new(
             header.before_hunk_start,
             header.before_hunk_len,
             header.after_hunk_start,
             header.after_hunk_len,
-            out,
-        ));
+        );
+
+        for (kind, content) in lines {
+            let kind = match kind {
+                GixLineKind::Context => DiffLineKind::Context,
+                GixLineKind::Remove => DiffLineKind::Deletion,
+                GixLineKind::Add => DiffLineKind::Addition,
+            };
+            builder.push(kind, String::from_utf8_lossy(content).into_owned());
+        }
+
+        let (hunk, insertions, deletions) = builder.finish();
+        *self.insertions += insertions;
+        *self.deletions += deletions;
+        self.hunks.push(hunk);
 
         Ok(())
     }