fix(editor): split CRLF files into lines in the conflict diff

Claude-Session: https://claude.ai/code/session_01WKxR4tvL8bPU4NfsULyYNA

Author: datlechin

TablePro/Core/Diff/FileConflictDiff.swift

@@ -0,0 +1,27 @@
+//
+//  FileConflictDiff.swift
+//  TablePro
+//
+
+import Foundation
+
+/// Line splitting for the file-conflict sheet. This deliberately does not reuse
+/// `SqlNormalizer`, which trims boundary whitespace and rewrites line endings:
+/// a conflict sheet compares file bytes, so leading or trailing blank lines are a
+/// real difference the user needs to see.
+enum FileConflictDiff {
+    /// Swift treats "\r\n" as one Character, so splitting on "\n" alone leaves a
+    /// CRLF file as a single line. Line endings are folded before splitting, then
+    /// blank lines are kept.
+    static func lines(_ content: String) -> [String] {
+        content
+            .replacingOccurrences(of: "\r\n", with: "\n")
+            .replacingOccurrences(of: "\r", with: "\n")
+            .split(separator: "\n", omittingEmptySubsequences: false)
+            .map(String.init)
+    }
+
+    static func pairs(mine: String, disk: String) -> [DiffPair] {
+        DiffComputer.computeSplit(before: lines(mine), after: lines(disk))
+    }
+}

TablePro/Views/Sidebar/FileConflictDiffSheet.swift

@@ -16,9 +16,7 @@ internal struct FileConflictDiffSheet: View {
     @Environment(\.dismiss) private var dismiss
 
     private var diffLines: [DiffPair] {
-        let mineLines = mineContent.split(separator: "\n", omittingEmptySubsequences: false).map(String.init)
-        let diskLines = diskContent.split(separator: "\n", omittingEmptySubsequences: false).map(String.init)
-        return DiffComputer.computeSplit(before: mineLines, after: diskLines)
+        FileConflictDiff.pairs(mine: mineContent, disk: diskContent)
     }
 
     var body: some View {

TableProTests/Core/Diff/FileConflictDiffTests.swift

@@ -0,0 +1,55 @@
+//
+//  FileConflictDiffTests.swift
+//  TableProTests
+//
+
+import Foundation
+@testable import TablePro
+import Testing
+
+@Suite("FileConflictDiff")
+struct FileConflictDiffTests {
+    @Test("identical content produces only unchanged pairs")
+    func identicalContentIsUnchanged() {
+        let pairs = FileConflictDiff.pairs(mine: "a\nb", disk: "a\nb")
+
+        #expect(pairs.count == 2)
+        #expect(pairs.allSatisfy { $0.kind == .unchanged })
+    }
+
+    @Test("a replaced line is reported as changed with both sides")
+    func replacedLineIsChanged() {
+        let pairs = FileConflictDiff.pairs(mine: "a\nb", disk: "a\nc")
+
+        #expect(pairs.contains(DiffPair(before: "b", after: "c", kind: .changed)))
+    }
+
+    @Test("conflict lines keep boundary whitespace that SQL normalization would trim")
+    func conflictLinesKeepBoundaryWhitespace() {
+        let content = "\nSELECT 1\n"
+
+        #expect(FileConflictDiff.lines(content) == ["", "SELECT 1", ""])
+        #expect(SqlNormalizer.lines(content) == ["SELECT 1"])
+    }
+
+    @Test("a file that gained a trailing blank line reads as a real difference")
+    func trailingBlankLineIsADifference() {
+        let pairs = FileConflictDiff.pairs(mine: "a", disk: "a\n")
+
+        #expect(pairs.contains { $0.kind != .unchanged })
+    }
+
+    @Test("a CRLF file splits into lines instead of collapsing into one")
+    func crlfSplitsIntoLines() {
+        #expect(FileConflictDiff.lines("a\r\nb") == ["a", "b"])
+        #expect(FileConflictDiff.lines("a\rb") == ["a", "b"])
+    }
+
+    @Test("a CRLF file diffs line by line against its LF twin")
+    func crlfDiffsLineByLine() {
+        let pairs = FileConflictDiff.pairs(mine: "a\r\nb\r\nc", disk: "a\nx\nc")
+
+        #expect(pairs.count == 3)
+        #expect(pairs.contains(DiffPair(before: "b", after: "x", kind: .changed)))
+    }
+}