Refactor MyersDiff to simplify line-by-line comparison

This commit simplifies the `MyersDiff.kt` implementation. Instead of using the traditional Myers algorithm for line-level diffing, it now performs a simpler line-by-line comparison.

Key changes:
- Removed the complex Myers algorithm logic (trace, v-array, buildDiff) from `MyersDiff.kt`.
- `calculateDiff` now iterates through the maximum number of lines in the old and new texts.
- For each line index, it compares `oldLines.getOrNull(i)` and `newLines.getOrNull(i)`:
    - If `oldLine` is null and `newLine` is not, it's an `ADDED` line.
    - If `oldLine` is not null and `newLine` is null, it's a `DELETED` line.
    - If both lines are equal, it's an `UNCHANGED` line.
    - If lines differ, it's marked as `CHANGED`, and `charLevelDiff` is used to find character differences.
- Removed the `mergeChangedEntries` method as the new approach directly identifies `CHANGED` lines without needing a separate merge step.
- Updated `MyersDiffTest.kt` by removing tests related to `mergeChangedEntries` and tests that were specific to the previous Myers algorithm behavior (e.g., `calculateDiff with all lines changed`, `calculateDiff with lines containing only whitespace`).
- Removed `border` modifier from `CharDiffText.kt` as it's no longer used.

Author: JahidHasanCO

app/src/main/java/dev/jahidhasanco/diffly/domain/util/MyersDiff.kt

@@ -11,146 +11,55 @@ class MyersDiff {
     fun calculateDiff(
         oldLines: List<String>,
         newLines: List<String>
-    ): List<DiffEntry> {
-        val n = oldLines.size
-        val m = newLines.size
-        val max = n + m
-        val v = mutableMapOf<Int, Int>()
-        v[1] = 0
-        val trace = mutableListOf<Map<Int, Int>>()
-
-        for (d in 0..max) {
-            val vCopy = v.toMutableMap()
-            trace.add(vCopy)
-
-            for (k in -d..d step 2) {
-                val x = when {
-                    k == -d -> v[k + 1]!!
-                    k != d && v[k - 1]!! < v[k + 1]!! -> v[k + 1]!!
-                    else -> v[k - 1]!! + 1
-                }
-
-                var y = x - k
-                var xCopy = x
-
-                while (xCopy < n && y < m && oldLines[xCopy] == newLines[y]) {
-                    xCopy++
-                    y++
-                }
-
-                v[k] = xCopy
-
-                if (xCopy >= n && y >= m) {
-                    val rawDiff = buildDiff(trace, oldLines, newLines)
-                    return mergeChangedEntries(rawDiff)
-                }
-            }
-        }
-
-        throw IllegalStateException("Diff computation failed")
-    }
-
-    private fun buildDiff(
-        trace: List<Map<Int, Int>>,
-        oldLines: List<String>,
-        newLines: List<String>
     ): List<DiffEntry> {
         val result = mutableListOf<DiffEntry>()
-        var x = oldLines.size
-        var y = newLines.size
+        val maxLines = maxOf(oldLines.size, newLines.size)
 
-        for (d in trace.size - 1 downTo 0) {
-            val v = trace[d]
-            val k = x - y
-            val prevK = when {
-                k == -d || (k != d && v[k - 1]!! < v[k + 1]!!) -> k + 1
-                else -> k - 1
-            }
-            val prevX = v[prevK]!!
-            val prevY = prevX - prevK
+        for (i in 0 until maxLines) {
+            val oldLine = oldLines.getOrNull(i)
+            val newLine = newLines.getOrNull(i)
 
-            // Handle unchanged lines
-            while (x > prevX && y > prevY) {
-                result.add(
+            val entry = when {
+                oldLine == null && newLine != null -> {
                     DiffEntry(
-                        oldLine = oldLines[x - 1],
-                        newLine = newLines[y - 1],
-                        type = DiffType.UNCHANGED,
-                        charDiffs = null
+                        oldLine = null,
+                        newLine = newLine,
+                        type = DiffType.ADDED
                     )
-                )
-                x--
-                y--
-            }
+                }
 
-            // Handle inserted or deleted lines (only if d > 0)
-            if (d > 0) {
-                if (x == prevX) {
-                    // Inserted line(s)
-                    result.add(
-                        DiffEntry(
-                            oldLine = null,
-                            newLine = newLines[y - 1],
-                            type = DiffType.ADDED,
-                            charDiffs = null
-                        )
-                    )
-                    y--
-                } else if (y == prevY) {
-                    // Deleted line(s)
-                    result.add(
-                        DiffEntry(
-                            oldLine = oldLines[x - 1],
-                            newLine = null,
-                            type = DiffType.DELETED,
-                            charDiffs = null
-                        )
+                oldLine != null && newLine == null -> {
+                    DiffEntry(
+                        oldLine = oldLine,
+                        newLine = null,
+                        type = DiffType.DELETED
                     )
-                    x--
-                } else {
-                    // Changed line: Both old and new lines exist but differ
-                    val oldLine = oldLines[x - 1]
-                    val newLine = newLines[y - 1]
-
-                    val charDiffs = charLevelDiff.diff(oldLine, newLine)
+                }
 
-                    result.add(
-                        DiffEntry(
-                            oldLine = oldLine,
-                            newLine = newLine,
-                            type = DiffType.CHANGED,
-                            charDiffs = charDiffs
-                        )
+                oldLine == newLine -> {
+                    DiffEntry(
+                        oldLine = oldLine,
+                        newLine = newLine,
+                        type = DiffType.UNCHANGED
                     )
-                    x--
-                    y--
                 }
-            }
-        }
-
-        return result.reversed()
-    }
 
-    fun mergeChangedEntries(diffEntries: List<DiffEntry>): List<DiffEntry> {
-        val merged = mutableListOf<DiffEntry>()
-        var i = 0
-        while (i < diffEntries.size) {
-            if (i < diffEntries.size - 1) {
-                val curr = diffEntries[i]
-                val next = diffEntries[i + 1]
-                if (curr.type == DiffType.DELETED && next.type == DiffType.ADDED) {
-                    val oldLine = curr.oldLine ?: ""
-                    val newLine = next.newLine ?: ""
-                    val charDiffs = charLevelDiff.diff(oldLine, newLine)
-                    merged.add(DiffEntry(oldLine, newLine, DiffType.CHANGED, charDiffs))
-                    i += 2
-                    continue
+                else -> {
+                    // Lines differ: compute char-level diff
+                    val charDiffs = charLevelDiff.diff(oldLine!!, newLine!!)
+                    DiffEntry(
+                        oldLine = oldLine,
+                        newLine = newLine,
+                        type = DiffType.CHANGED,
+                        charDiffs = charDiffs
+                    )
                 }
             }
-            merged.add(diffEntries[i])
-            i++
+
+            result.add(entry)
         }
-        return merged
+
+        return result
     }
 
 }

app/src/main/java/dev/jahidhasanco/diffly/presentation/component/CharDiffText.kt

@@ -1,7 +1,6 @@
 package dev.jahidhasanco.diffly.presentation.component
 
 import androidx.compose.foundation.background
-import androidx.compose.foundation.border
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer