refactor: do a general cleanup

Author: lppedd

src/commonMain/kotlin/io/github/petertrr/diffutils/text/StringUtils.kt renamed to src/commonMain/kotlin/io/github/petertrr/diffutils/StringUtils.kt

@@ -18,57 +18,57 @@
  */
 @file:JvmName("StringUtils")
 
-package io.github.petertrr.diffutils.text
+package io.github.petertrr.diffutils
 
 import kotlin.jvm.JvmName
 
 /**
  * Replaces all opening and closing tags (`<` and `>`)
  * with their escaped sequences (`&lt;` and `&gt;`).
  */
-internal fun htmlEntities(str: String): String =
-    str.replace("<", "&lt;").replace(">", "&gt;")
+internal fun String.htmlEntities(): String =
+    replace("<", "&lt;").replace(">", "&gt;")
 
 /**
  * Normalizes a string by escaping some HTML meta characters
  * and replacing tabs with 4 spaces each.
  */
-internal fun normalize(str: String): String =
-    htmlEntities(str).replace("\t", "    ")
+internal fun String.normalize(): String =
+    htmlEntities().replace("\t", "    ")
 
 /**
- * Wrap the text with the given column width
+ * Wrap the text with the given column width.
  */
-internal fun wrapText(line: String, columnWidth: Int): String {
+internal fun String.wrapText(columnWidth: Int): String {
     require(columnWidth >= 0) { "Column width must be greater than or equal to 0" }
 
     if (columnWidth == 0) {
-        return line
+        return this
     }
 
-    val length = line.length
-    val delimiter = "<br/>".length
+    val length = length
+    val delimiterLength = "<br/>".length
     var widthIndex = columnWidth
-    val b = StringBuilder(line)
+    val sb = StringBuilder(this)
     var count = 0
 
     while (length > widthIndex) {
-        var breakPoint = widthIndex + delimiter * count
+        var breakPoint = widthIndex + delimiterLength * count
 
-        if (b[breakPoint - 1].isHighSurrogate() && b[breakPoint].isLowSurrogate()) {
+        if (sb[breakPoint - 1].isHighSurrogate() && sb[breakPoint].isLowSurrogate()) {
             // Shift a breakpoint that would split a supplemental code-point.
             breakPoint += 1
 
-            if (breakPoint == b.length) {
+            if (breakPoint == sb.length) {
                 // Break before instead of after if this is the last code-point.
                 breakPoint -= 2
             }
         }
 
-        b.insert(breakPoint, "<br/>")
+        sb.insert(breakPoint, "<br/>")
         widthIndex += columnWidth
         count++
     }
 
-    return b.toString()
+    return sb.toString()
 }

src/commonMain/kotlin/io/github/petertrr/diffutils/algorithm/myers/MyersDiff.kt

@@ -58,7 +58,7 @@ public class MyersDiff<T>(private val equalizer: DiffEqualizer<T> = EqualsDiffEq
         val max = origSize + revSize + 1
         val size = 1 + 2 * max
         val middle = size / 2
-        val diagonal: Array<PathNode?> = arrayOfNulls(size)
+        val diagonal = arrayOfNulls<PathNode>(size)
         diagonal[middle + 1] = PathNode(0, -1, snake = true, bootstrap = true, prev = null)
 
         for (d in 0..<max) {

src/commonMain/kotlin/io/github/petertrr/diffutils/algorithm/myers/MyersDiffWithLinearSpace.kt

@@ -50,7 +50,6 @@ public class MyersDiffWithLinearSpace<T>(
         progress: DiffAlgorithmListener,
     ) {
         progress.diffStep((end1 - start1) / 2 + (end2 - start2) / 2, -1)
-
         val middle = getMiddleSnake(data, start1, end1, start2, end2)
 
         if (middle == null ||

src/commonMain/kotlin/io/github/petertrr/diffutils/algorithm/myers/PathNode.kt

@@ -55,11 +55,7 @@ internal class PathNode(
             return null
         }
 
-        return if (!snake && prev != null) {
-            prev.previousSnake()
-        } else {
-            this
-        }
+        return if (!snake && prev != null) prev.previousSnake() else this
     }
 
     override fun toString(): String {

src/commonMain/kotlin/io/github/petertrr/diffutils/text/DiffRowGenerator.kt

@@ -29,6 +29,7 @@ import io.github.petertrr.diffutils.patch.Delta
 import io.github.petertrr.diffutils.patch.DeltaType
 import io.github.petertrr.diffutils.patch.InsertDelta
 import io.github.petertrr.diffutils.patch.Patch
+import io.github.petertrr.diffutils.wrapText
 import kotlin.math.max
 import kotlin.math.min
 
@@ -84,8 +85,8 @@ public class DiffRowGenerator(
     inlineDiffByWord: Boolean = false,
     private val inlineDiffSplitter: DiffSplitter = if (inlineDiffByWord) WordDiffSplitter() else CharDiffSplitter(),
     private val mergeOriginalRevised: Boolean = false,
-    private val newTag: DiffTagGenerator = NewDiffTagGenerator(),
-    private val oldTag: DiffTagGenerator = OldDiffTagGenerator(),
+    private val newTag: DiffTagGenerator = HtmlDiffTagGenerator("editNewInline"),
+    private val oldTag: DiffTagGenerator = HtmlDiffTagGenerator("editOldInline"),
     private val reportLinesUnchanged: Boolean = false,
     private val lineNormalizer: DiffLineNormalizer = HtmlLineNormalizer(),
     private val processDiffs: DiffLineProcessor? = null,
@@ -138,8 +139,8 @@ public class DiffRowGenerator(
         return diffRows
     }
 
-    internal fun normalizeLines(list: List<String>): List<String> =
-        if (reportLinesUnchanged) list else list.map { lineNormalizer.normalize(it) }
+    private fun normalizeLines(list: List<String>): List<String> =
+        if (reportLinesUnchanged) list else list.map(lineNormalizer::normalize)
 
     /**
      * Transforms one patch delta into a [DiffRow] object.
@@ -262,7 +263,7 @@ public class DiffRowGenerator(
     }
 
     private fun buildDiffRowWithoutNormalizing(type: DiffRow.Tag, oldLine: String, newLine: String): DiffRow =
-        DiffRow(type, wrapText(oldLine, columnWidth), wrapText(newLine, columnWidth))
+        DiffRow(type, oldLine.wrapText(columnWidth), newLine.wrapText(columnWidth))
 
     /**
      * Add the inline diffs for given delta
@@ -364,8 +365,8 @@ public class DiffRowGenerator(
             }
         }
 
-        val origResult = StringBuilder()
-        val revResult = StringBuilder()
+        val origResult = StringBuilder(origList.size)
+        val revResult = StringBuilder(revList.size)
 
         for (character in origList) {
             origResult.append(character)
@@ -379,9 +380,11 @@ public class DiffRowGenerator(
         //  trailing empty string by default
         val original = origResult.split("\n").dropLastWhile(String::isEmpty)
         val revised = revResult.split("\n").dropLastWhile(String::isEmpty)
-        val diffRows = ArrayList<DiffRow>()
 
-        for (j in 0..<max(original.size, revised.size)) {
+        val size = max(original.size, revised.size)
+        val diffRows = ArrayList<DiffRow>(size)
+
+        for (j in 0..<size) {
             diffRows.add(
                 buildDiffRowWithoutNormalizing(
                     type = DiffRow.Tag.CHANGE,
@@ -396,7 +399,7 @@ public class DiffRowGenerator(
 
     private fun preprocessLine(line: String): String {
         val normalized = lineNormalizer.normalize(line)
-        return if (columnWidth == 0) normalized else wrapText(normalized, columnWidth)
+        return if (columnWidth == 0) normalized else normalized.wrapText(columnWidth)
     }
 
     /**

src/commonMain/kotlin/io/github/petertrr/diffutils/text/NewDiffTagGenerator.kt renamed to src/commonMain/kotlin/io/github/petertrr/diffutils/text/HtmlDiffTagGenerator.kt

@@ -15,9 +15,9 @@
  */
 package io.github.petertrr.diffutils.text
 
-internal class NewDiffTagGenerator : DiffTagGenerator {
+internal class HtmlDiffTagGenerator(private val className: String) : DiffTagGenerator {
     override fun generateOpen(tag: DiffRow.Tag): String =
-        "<span class=\"editNewInline\">"
+        "<span class=\"$className\">"
 
     override fun generateClose(tag: DiffRow.Tag): String =
         "</span>"

src/commonMain/kotlin/io/github/petertrr/diffutils/text/HtmlLineNormalizer.kt

@@ -15,9 +15,9 @@
  */
 package io.github.petertrr.diffutils.text
 
-import io.github.petertrr.diffutils.text.normalize as normalizeFn
+import io.github.petertrr.diffutils.normalize
 
 internal class HtmlLineNormalizer : DiffLineNormalizer {
     override fun normalize(line: String): String =
-        normalizeFn(line)
+        line.normalize()
 }

src/commonMain/kotlin/io/github/petertrr/diffutils/text/OldDiffTagGenerator.kt

@@ -15,10 +15,13 @@
  */
 package io.github.petertrr.diffutils.text
 
+// As a "global" variable to avoid re-compiling the regex each time
+private val defaultPattern = Regex("\\s+|[,.\\[\\](){}/\\\\*+\\-#]")
+
 /**
  * Splitting lines by word to achieve word by word diff checking.
  */
-internal class WordDiffSplitter(private val pattern: Regex = Regex("\\s+|[,.\\[\\](){}/\\\\*+\\-#]")) : DiffSplitter {
+internal class WordDiffSplitter(private val pattern: Regex = defaultPattern) : DiffSplitter {
     override fun split(line: String): MutableList<String> {
         val matchResults = pattern.findAll(line)
         val list = ArrayList<String>()

src/commonMain/kotlin/io/github/petertrr/diffutils/text/WordDiffSplitter.kt

@@ -40,8 +40,8 @@ class DiffRowGeneratorTest {
      */
     @Test
     fun testNormalize_List() {
-        val generator = DiffRowGenerator()
-        assertEquals(listOf("    test"), generator.normalizeLines(listOf("\ttest")))
+        val normalizer = HtmlLineNormalizer()
+        assertEquals("    test", normalizer.normalize("\ttest"))
     }
 
     @Test

src/commonTest/kotlin/io/github/petertrr/diffutils/text/DiffRowGeneratorTest.kt

@@ -18,6 +18,9 @@
  */
 package io.github.petertrr.diffutils.text
 
+import io.github.petertrr.diffutils.htmlEntities
+import io.github.petertrr.diffutils.normalize
+import io.github.petertrr.diffutils.wrapText
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
@@ -27,32 +30,32 @@ class StringUtilsTest {
      * Test of htmlEntities method, of class StringUtils.
      */
     @Test
-    fun testHtmlEntites() {
-        assertEquals("&lt;test&gt;", htmlEntities("<test>"))
+    fun testHtmlEntities() {
+        assertEquals("&lt;test&gt;", "<test>".htmlEntities())
     }
 
     /**
      * Test of normalize method, of class StringUtils.
      */
     @Test
     fun testNormalize_String() {
-        assertEquals("    test", normalize("\ttest"))
+        assertEquals("    test", "\ttest".normalize())
     }
 
     /**
      * Test of wrapText method, of class
      */
     @Test
     fun testWrapText_String_int() {
-        assertEquals("te<br/>st", wrapText("test", 2))
-        assertEquals("tes<br/>t", wrapText("test", 3))
-        assertEquals("test", wrapText("test", 10))
-        assertEquals(".\uD800\uDC01<br/>.", wrapText(".\uD800\uDC01.", 2))
-        assertEquals("..<br/>\uD800\uDC01", wrapText("..\uD800\uDC01", 3))
+        assertEquals("te<br/>st", "test".wrapText(2))
+        assertEquals("tes<br/>t", "test".wrapText(3))
+        assertEquals("test", "test".wrapText(10))
+        assertEquals(".\uD800\uDC01<br/>.", ".\uD800\uDC01.".wrapText(2))
+        assertEquals("..<br/>\uD800\uDC01", "..\uD800\uDC01".wrapText(3))
     }
 
     @Test
     fun testWrapText_String_int_zero() {
-        assertFailsWith<IllegalArgumentException> { wrapText("test", -1) }
+        assertFailsWith<IllegalArgumentException> { "test".wrapText(-1) }
     }
 }