fix: hash a hunk past the scanner's line limit

bufio.Scanner refuses a token longer than 64KB. hunkHash never checked Err(),
so on a longer line it hashed only what it had read and stopped. Two hunks
differing solely beyond that point therefore hashed alike, and a hunk matching
the approval-time diff is dropped as already reviewed -- so an approval could
survive a change nobody saw.

hunkBlocks does check Err() and declines the hunk, which is why this only
shows up here.

Split the body by hand instead. There is no limit to exceed, so the failure
mode is gone rather than pushed further out, and trailing carriage returns are
dropped so a CRLF file hashes like any other.

Author: asyncawaitpromise

internal/git/diff.go

@@ -1,7 +1,6 @@
 package git
 
 import (
-	"bufio"
 	"bytes"
 	"crypto/sha256"
 	"fmt"
@@ -231,17 +230,24 @@ func getGitDiff(data DiffContext, executor gitCommandExecutor) ([]*diff.FileDiff
 
 func hunkHash(hunk *diff.Hunk) [32]byte {
 	// Generate a hash for a hunk based on its added and removed lines.
+	// Split by hand: bufio.Scanner refuses a token past 64KB and stops there, so
+	// hashing what it read lets two hunks differing only beyond that collide.
 	var lines []byte
 	data := hunk.Body
 
 	if len(data) == 0 {
 		return sha256.Sum256(nil)
 	}
 
-	scanner := bufio.NewScanner(bytes.NewReader(data))
-
-	for scanner.Scan() {
-		line := scanner.Text()
+	for len(data) > 0 {
+		line := data
+		if i := bytes.IndexByte(data, '\n'); i >= 0 {
+			line, data = data[:i], data[i+1:]
+		} else {
+			data = nil
+		}
+		// Trailing carriage returns belong to the line ending, not the content.
+		line = bytes.TrimSuffix(line, []byte("\r"))
 		if len(line) == 0 {
 			continue
 		}

internal/git/diff_test.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"strings"
 	"testing"
 
 	"github.com/multimediallc/codeowners-plus/pkg/codeowners"
@@ -129,7 +130,7 @@ Binary files a/assets/img/offline.png and b/assets/img/offline.png differ`,
 			expectedErr:   false,
 			expectedFiles: 2,
 			expectedHunks: map[string]int{
-				"file1.go":                1,
+				"file1.go":               1,
 				"assets/img/offline.png": 0,
 			},
 		},
@@ -806,3 +807,28 @@ func TestDiffOfDiffs(t *testing.T) {
 		}
 	}
 }
+
+// A hunk matching the approval-time diff is dropped as already reviewed, so a
+// collision past the old 64KB read limit retained an approval over unseen change.
+func TestHunkHashReadsLinesPastScannerLimit(t *testing.T) {
+	long := strings.Repeat("x", 70*1024)
+	first := &diff.Hunk{Body: []byte("+keep()\n+" + long + "A")}
+	second := &diff.Hunk{Body: []byte("+keep()\n+" + long + "B")}
+
+	if hunkHash(first) == hunkHash(second) {
+		t.Error("hunks differing past 64KB must not hash alike")
+	}
+	same := &diff.Hunk{Body: []byte("+keep()\n+" + long + "A")}
+	if hunkHash(first) != hunkHash(same) {
+		t.Error("identical over-long hunks must still hash alike")
+	}
+	// Context lines stay excluded however long the hunk is.
+	withContext := &diff.Hunk{Body: []byte(" ctx\n+keep()\n+" + long + "A")}
+	if hunkHash(first) != hunkHash(withContext) {
+		t.Error("context lines must not enter the hash")
+	}
+	crlf := &diff.Hunk{Body: []byte("+keep()\r\n+" + long + "A")}
+	if hunkHash(first) != hunkHash(crlf) {
+		t.Error("a carriage return in the line ending must not change the hash")
+	}
+}