Fixed DiffRowGenerator, ported tests

Author: petertrr

Diff for: build.gradle.kts

@@ -15,6 +15,8 @@ repositories {
 }
 
 kotlin {
+    explicitApi()
+
     jvm()
     js(IR) {
         browser()

Diff for: src/commonMain/kotlin/com/github/petertrr/diffutils/DiffUtils.kt

@@ -25,7 +25,6 @@ package io.github.petertrr.diffutils
 import io.github.petertrr.diffutils.algorithm.DiffAlgorithm
 import io.github.petertrr.diffutils.algorithm.DiffAlgorithmListener
 import io.github.petertrr.diffutils.algorithm.myers.MyersDiff
-import io.github.petertrr.diffutils.patch.Chunk
 import io.github.petertrr.diffutils.patch.Patch
 import io.github.petertrr.diffutils.patch.PatchFailedException
 
@@ -39,22 +38,22 @@ import io.github.petertrr.diffutils.patch.PatchFailedException
  * @param progress progress listener
  * @return The patch describing the difference between the original and revised sequences.
  */
-fun <T> diff(original: List<T>, revised: List<T>, progress: DiffAlgorithmListener?): Patch<T> {
+public fun <T> diff(original: List<T>, revised: List<T>, progress: DiffAlgorithmListener?): Patch<T> {
     return diff(original, revised, MyersDiff<T>(), progress)
 }
 
-fun <T> diff(original: List<T>, revised: List<T>): Patch<T> {
+public fun <T> diff(original: List<T>, revised: List<T>): Patch<T> {
     return diff(original, revised, MyersDiff(), null)
 }
 
-fun <T> diff(original: List<T>, revised: List<T>, includeEqualParts: Boolean): Patch<T> {
+public fun <T> diff(original: List<T>, revised: List<T>, includeEqualParts: Boolean): Patch<T> {
     return diff(original, revised, MyersDiff(), null, includeEqualParts)
 }
 
 /**
  * Computes the difference between the original and revised text.
  */
-fun diff(sourceText: String, targetText: String,
+public fun diff(sourceText: String, targetText: String,
          progress: DiffAlgorithmListener?): Patch<String> {
     return diff(sourceText.split("\n"),
         targetText.split("\n"),
@@ -73,7 +72,7 @@ fun diff(sourceText: String, targetText: String,
  * (Object.equals). If `null` the default equalizer of the default algorithm is used..
  * @return The patch describing the difference between the original and revised sequences.
  */
-fun <T> diff(
+public fun <T> diff(
     source: List<T>, target: List<T>,
     equalizer: ((T, T) -> Boolean)?
 ): Patch<T> {
@@ -85,7 +84,7 @@ fun <T> diff(
     } else diff(source, target, MyersDiff())
 }
 
-fun <T> diff(
+public fun <T> diff(
     original: List<T>, revised: List<T>,
     algorithm: DiffAlgorithm<T>, progress: DiffAlgorithmListener?
 ): Patch<T> {
@@ -104,7 +103,7 @@ fun <T> diff(
  * @return The patch describing the difference between the original and revised sequences. Never
  * `null`.
  */
-fun <T> diff(
+public fun <T> diff(
     original: List<T>, revised: List<T>,
     algorithm: DiffAlgorithm<T>, progress: DiffAlgorithmListener?,
     includeEqualParts: Boolean
@@ -122,7 +121,7 @@ fun <T> diff(
  * @return The patch describing the difference between the original and revised sequences. Never
  * `null`.
  */
-fun <T> diff(original: List<T>, revised: List<T>, algorithm: DiffAlgorithm<T>): Patch<T> {
+public fun <T> diff(original: List<T>, revised: List<T>, algorithm: DiffAlgorithm<T>): Patch<T> {
     return diff(original, revised, algorithm, null)
 }
 
@@ -135,7 +134,7 @@ fun <T> diff(original: List<T>, revised: List<T>, algorithm: DiffAlgorithm<T>):
  * @param revised
  * @return
  */
-fun diffInline(original: String, revised: String): Patch<String> {
+public fun diffInline(original: String, revised: String): Patch<String> {
     val origList: MutableList<String> = arrayListOf()
     val revList: MutableList<String> = arrayListOf()
     for (character in original.toCharArray()) {
@@ -145,13 +144,13 @@ fun diffInline(original: String, revised: String): Patch<String> {
         revList.add(character.toString())
     }
     val patch: Patch<String> = diff(origList, revList)
-    patch.getDeltas().map { delta ->
+    patch.deltas.map { delta ->
         delta.withChunks(
             delta.source.copy(lines = compressLines(delta.source.lines, "")),
             delta.target.copy(lines = compressLines(delta.target.lines, ""))
         )
     }
-        .let { patch.setDeltas(it) }
+        .let { patch.deltas = it.toMutableList() }
     return patch
 }
 
@@ -170,7 +169,7 @@ private fun compressLines(lines: List<String>, delimiter: String): List<String>
  * @throws PatchFailedException if can't apply patch
  */
 @kotlin.Throws(PatchFailedException::class)
-fun <T> patch(original: List<T>, patch: Patch<T>): List<T> {
+public fun <T> patch(original: List<T>, patch: Patch<T>): List<T> {
     return patch.applyTo(original)
 }
 
@@ -181,6 +180,7 @@ fun <T> patch(original: List<T>, patch: Patch<T>): List<T> {
  * @param patch the given patch
  * @return the original text
  */
-fun <T> unpatch(revised: List<T>, patch: Patch<T>): List<T> {
+@Suppress("UNUSED")
+public fun <T> unpatch(revised: List<T>, patch: Patch<T>): List<T> {
     return patch.restore(revised)
 }

Diff for: src/commonMain/kotlin/com/github/petertrr/diffutils/algorithm/Change.kt

@@ -20,9 +20,9 @@ package io.github.petertrr.diffutils.algorithm
 
 import io.github.petertrr.diffutils.patch.DeltaType
 
-data class Change(val deltaType: DeltaType,
-             val startOriginal: Int,
-             val endOriginal: Int,
-             val startRevised: Int,
-             val endRevised: Int
+public data class Change(val deltaType: DeltaType,
+                         val startOriginal: Int,
+                         val endOriginal: Int,
+                         val startRevised: Int,
+                         val endRevised: Int
 )

Diff for: src/commonMain/kotlin/com/github/petertrr/diffutils/algorithm/DiffAlgorithm.kt

@@ -23,7 +23,7 @@ package io.github.petertrr.diffutils.algorithm
  *
  * @param T type of data that is diffed.
  */
-interface DiffAlgorithm<T> {
+public interface DiffAlgorithm<T> {
     /**
      * Computes the changeset to patch the source list to the target list.
      *
@@ -32,7 +32,7 @@ interface DiffAlgorithm<T> {
      * @param progress progress listener
      * @return
      */
-    fun computeDiff(source: List<T>, target: List<T>, progress: DiffAlgorithmListener?): List<Change>
+    public fun computeDiff(source: List<T>, target: List<T>, progress: DiffAlgorithmListener?): List<Change>
 
     /**
      * Simple extension to compute a changeset using arrays.
@@ -42,7 +42,7 @@ interface DiffAlgorithm<T> {
      * @param progress
      * @return
      */
-    fun computeDiff(source: Array<T>, target: Array<T>, progress: DiffAlgorithmListener?): List<Change> {
+    public fun computeDiff(source: Array<T>, target: Array<T>, progress: DiffAlgorithmListener?): List<Change> {
         return computeDiff(source.toList(), target.toList(), progress)
     }
 }

Diff for: src/commonMain/kotlin/com/github/petertrr/diffutils/algorithm/DiffAlgorithmListener.kt

@@ -18,8 +18,8 @@
  */
 package io.github.petertrr.diffutils.algorithm
 
-interface DiffAlgorithmListener {
-    fun diffStart()
+public interface DiffAlgorithmListener {
+    public fun diffStart()
 
     /**
      * This is a step within the diff algorithm. Due to different implementations the value
@@ -29,6 +29,7 @@ interface DiffAlgorithmListener {
      * @param value
      * @param max
      */
-    fun diffStep(value: Int, max: Int)
-    fun diffEnd()
+    public fun diffStep(value: Int, max: Int)
+
+    public fun diffEnd()
 }

Diff for: src/commonMain/kotlin/com/github/petertrr/diffutils/algorithm/myers/MyersDiff.kt

@@ -26,7 +26,7 @@ import io.github.petertrr.diffutils.patch.DeltaType
 /**
  * A clean-room implementation of Eugene Myers greedy differencing algorithm.
  */
-class MyersDiff<T>(private val equalizer: (T, T) -> Boolean = { t1, t2 -> t1 == t2 }) : DiffAlgorithm<T> {
+internal class MyersDiff<T>(private val equalizer: (T, T) -> Boolean = { t1, t2 -> t1 == t2 }) : DiffAlgorithm<T> {
     /**
      * Return empty diff if get the error while procession the difference.
      */

Diff for: src/commonMain/kotlin/com/github/petertrr/diffutils/algorithm/myers/PathNode.kt

@@ -21,7 +21,7 @@ package io.github.petertrr.diffutils.algorithm.myers
 /**
  * A node in a diffpath.
  */
-class PathNode(
+internal class PathNode(
     /**
      * Position in the original sequence.
      */

Diff for: src/commonMain/kotlin/com/github/petertrr/diffutils/patch/Chunk.kt

@@ -27,7 +27,7 @@ package io.github.petertrr.diffutils.patch
  * correctly can be subject to differencing using this library.
  * @param T The type of the compared elements in the 'lines'.
 ) */
-data class Chunk<T>(
+public data class Chunk<T>(
     /**
      * the start position of chunk in the text
      */
@@ -48,7 +48,7 @@ data class Chunk<T>(
      * @throws com.github.difflib.patch.PatchFailedException
      */
     @Throws(PatchFailedException::class)
-    fun verify(target: List<T>) {
+    public fun verify(target: List<T>) {
         if (position > target.size || last() > target.size) {
             throw PatchFailedException("Incorrect Chunk: the position of chunk > target size")
         }
@@ -61,14 +61,14 @@ data class Chunk<T>(
         }
     }
 
-    fun size() = lines.size
+    public fun size(): Int = lines.size
 
     /**
      * Returns the index of the last line of the chunk.
      */
-    fun last(): Int {
+    public fun last(): Int {
         return position + size() - 1
     }
 
-    override fun toString() = "[position: $position, size: ${size()}, lines: $lines]"
+    override fun toString(): String = "[position: $position, size: ${size()}, lines: $lines]"
 }

Diff for: src/commonMain/kotlin/com/github/petertrr/diffutils/patch/Delta.kt

@@ -33,7 +33,7 @@ package io.github.petertrr.diffutils.patch
  * which is no change at all.
  *
  */
-enum class DeltaType {
+public enum class DeltaType {
     /**
      * A change in the original.
      */
@@ -52,9 +52,9 @@ enum class DeltaType {
     EQUAL
 }
 
-sealed class Delta<T>(val type: DeltaType) {
-    abstract val source: Chunk<T>
-    abstract val target: Chunk<T>
+public sealed class Delta<T>(public val type: DeltaType) {
+    public abstract val source: Chunk<T>
+    public abstract val target: Chunk<T>
 
     /**
      * Verify the chunk of this delta, to fit the target.
@@ -67,16 +67,16 @@ sealed class Delta<T>(val type: DeltaType) {
     }
 
     @Throws(PatchFailedException::class)
-    abstract fun applyTo(target: MutableList<T>)
+    public abstract fun applyTo(target: MutableList<T>)
 
-    abstract fun restore(target: MutableList<T>)
+    public abstract fun restore(target: MutableList<T>)
 
     /**
      * Create a new delta of the actual instance with customized chunk data.
      */
-    abstract fun withChunks(original: Chunk<T>, revised: Chunk<T>): Delta<T>
+    public abstract fun withChunks(original: Chunk<T>, revised: Chunk<T>): Delta<T>
 }
-data class ChangeDelta<T>(override val source: Chunk<T>, override val target: Chunk<T>) : Delta<T>(DeltaType.CHANGE) {
+public data class ChangeDelta<T>(override val source: Chunk<T>, override val target: Chunk<T>) : Delta<T>(DeltaType.CHANGE) {
     override fun applyTo(target: MutableList<T>) {
         verifyChunk(target)
         val position: Int = source.position
@@ -103,7 +103,7 @@ data class ChangeDelta<T>(override val source: Chunk<T>, override val target: Ch
     override fun withChunks(original: Chunk<T>, revised: Chunk<T>): Delta<T> = ChangeDelta(original, revised)
 }
 
-data class DeleteDelta<T>(override val source: Chunk<T>, override val target: Chunk<T>) : Delta<T>(DeltaType.DELETE) {
+public data class DeleteDelta<T>(override val source: Chunk<T>, override val target: Chunk<T>) : Delta<T>(DeltaType.DELETE) {
     override fun applyTo(target: MutableList<T>) {
         verifyChunk(target)
         val position = source.position
@@ -120,10 +120,10 @@ data class DeleteDelta<T>(override val source: Chunk<T>, override val target: Ch
         }
     }
 
-    override fun withChunks(original: Chunk<T>, revised: Chunk<T>) = DeleteDelta(original, revised)
+    override fun withChunks(original: Chunk<T>, revised: Chunk<T>): Delta<T> = DeleteDelta(original, revised)
 }
 
-data class InsertDelta<T>(override val source: Chunk<T>, override val target: Chunk<T>) : Delta<T>(DeltaType.INSERT) {
+public data class InsertDelta<T>(override val source: Chunk<T>, override val target: Chunk<T>) : Delta<T>(DeltaType.INSERT) {
     override fun applyTo(target: MutableList<T>) {
         verifyChunk(target)
         val position = this.source.position
@@ -139,13 +139,13 @@ data class InsertDelta<T>(override val source: Chunk<T>, override val target: Ch
         }
     }
 
-    override fun withChunks(original: Chunk<T>, revised: Chunk<T>) = InsertDelta(original, revised)
+    override fun withChunks(original: Chunk<T>, revised: Chunk<T>): Delta<T> = InsertDelta(original, revised)
 }
 
-data class EqualDelta<T>(override val source: Chunk<T>, override val target: Chunk<T>) : Delta<T>(DeltaType.EQUAL) {
-    override fun applyTo(target: MutableList<T>) = verifyChunk(target)
+public data class EqualDelta<T>(override val source: Chunk<T>, override val target: Chunk<T>) : Delta<T>(DeltaType.EQUAL) {
+    override fun applyTo(target: MutableList<T>): Unit = verifyChunk(target)
 
-    override fun restore(target: MutableList<T>) = Unit
+    override fun restore(target: MutableList<T>): Unit = Unit
 
-    override fun withChunks(original: Chunk<T>, revised: Chunk<T>) = EqualDelta(original, revised)
+    override fun withChunks(original: Chunk<T>, revised: Chunk<T>): Delta<T> = EqualDelta(original, revised)
 }