import latest java converted to kotlin

.github/workflows/pull_request.yml

@@ -1,8 +1,6 @@
 name: Pull Request
 
-on:
-  pull_request:
-    branches: [ master ]
+on: pull_request
 
 jobs:
   build:
@@ -29,8 +27,7 @@ jobs:
       - name: Change package version
         uses: eskatos/gradle-command-action@v1
         with:
-          arguments: :updateVersion
-
+          arguments: updateVersion
       - name: Build
         uses: eskatos/gradle-command-action@v1
         with:
@@ -56,7 +53,11 @@ jobs:
         run: npm config set //npm.pkg.github.com/:_authToken=$token
         env:
           token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Setup package name
+        uses: eskatos/gradle-command-action@v1
+        with:
+          arguments: prepareForGithubNpmPublish
       - name: Publish npm
         uses: eskatos/gradle-command-action@v1
         with:
-          arguments: prepareForGithubNpmPublish publishToNpm
+          arguments: publishToNpm

build.gradle.kts

@@ -6,8 +6,8 @@ version = project.property("version") as String
 plugins {
     `maven-publish`
     signing
-    kotlin("native.cocoapods") version "1.5.30"
-    kotlin("multiplatform") version "1.5.30"
+    kotlin("multiplatform") version "1.5.32"
+    kotlin("native.cocoapods") version "1.5.32"
 }
 
 repositories {
@@ -19,7 +19,9 @@ repositories {
 kotlin {
     jvm {
         compilations.all {
-            kotlinOptions.jvmTarget = "1.8"
+            kotlinOptions {
+                jvmTarget = "1.8"
+            }
         }
         testRuns["test"].executionTask.configure { useJUnit() }
     }
@@ -36,24 +38,38 @@ kotlin {
         }
     }
 
-    iosArm64()
-    iosX64()
+//    iosArm64()
+//    iosX64()
 
     sourceSets {
         val commonMain by getting {
             dependencies {
+                implementation("org.jetbrains.kotlin:kotlin-stdlib")
+            }
+        }
+        val commonTest by getting {
+            dependencies {
+                implementation(kotlin("test-common"))
+                implementation(kotlin("test-annotations-common"))
+            }
+        }
+        val jsMain by getting {
+            dependencies {
+                implementation("org.jetbrains.kotlin:kotlin-stdlib-js")
+                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core-js:${project.property("kotlinx-coroutines.version")}")
             }
         }
-        val jsMain by getting
 
         val jvmMain by getting {
             dependencies {
             }
         }
         val jvmTest by getting {
             dependencies {
+                implementation(kotlin("test-junit"))
                 implementation("junit:junit:4.12")
                 implementation("org.assertj:assertj-core:3.11.1")
+                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:${project.property("kotlinx-coroutines.version")}")
             }
         }
     }
@@ -100,7 +116,8 @@ tasks {
     }
 
     val updateVersion by registering(Exec::class) {
-        commandLine("npm", "--allow-same-version", "--no-git-tag-version", "--prefix", projectDir, "version", "${project.property("version")}")
+        commandLine("npm", "--allow-same-version", "--no-git-tag-version", "--prefix", projectDir, "version",
+            (project.property("version") as String).replace("""[_;\",\[\]]""".toRegex(), ""))
     }
 
     val prepareForGithubNpmPublish by registering(Copy::class) {
@@ -117,7 +134,7 @@ val javadocJar by tasks.creating(Jar::class) {
     archiveClassifier.value("javadoc")
 }
 
-var shouldSign = true
+var shouldSign = false
 
 tasks.withType<Sign>().configureEach {
     onlyIf { shouldSign }

gradle.properties

@@ -1,6 +1,9 @@
+version=4.11.4
+kotlin_version = 1.5.32
+kotlinx-coroutines.version=1.5.2
+
 kotlin.code.style=official
-kotlin_version=1.5.30
+kotlin.incremental.multiplatform=true
 kotlin.mpp.enableGranularSourceSetsMetadata=true
 kotlin.native.enableDependencyPropagation=false
-version=5.1.4
-kotlin.js.compiler=both
+kotlin.js.compiler=both

kotlin_diff_utils.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |spec|
     spec.name                     = 'kotlin_diff_utils'
-    spec.version                  = '5.1.4'
+    spec.version                  = '4.11.3-kotlin1.5.32'
     spec.homepage                 = ''
     spec.source                   = { :git => "Not Published", :tag => "Cocoapods/#{spec.name}/#{spec.version}" }
     spec.authors                  = ''

package.json

@@ -1,5 +1,5 @@
 {
-  "name": "kotlin-diff-utils-js-legacy",
+  "name": "@gitliveapp/kotlin-diff-utils",
   "version": "0",
   "description": "The DiffUtils library for computing diffs, applying patches, generating side-by-side view in Java.",
   "main": "kotlin-diff-utils-js-legacy.js",
@@ -11,7 +11,7 @@
     "url": "git+https://github.com/GitLiveApp/kotlin-diff-utils"
   },
   "publishConfig": {
-    "registry":"https://registry.npmjs.org/"
+    "registry": "https://npm.pkg.github.com/"
   },
   "keywords": [
     "diffs",

src/commonMain/kotlin/dev/gitlive/difflib/DiffUtils.kt

@@ -15,124 +15,172 @@
  */
 package dev.gitlive.difflib
 
+import dev.gitlive.difflib.algorithm.DiffAlgorithmFactory
 import dev.gitlive.difflib.algorithm.DiffAlgorithmI
 import dev.gitlive.difflib.algorithm.DiffAlgorithmListener
-import dev.gitlive.difflib.algorithm.DiffException
-import dev.gitlive.difflib.algorithm.myers.MyersDiff
-import dev.gitlive.difflib.patch.AbstractDelta
+import dev.gitlive.difflib.algorithm.myers.MeyersDiff
 import dev.gitlive.difflib.patch.Patch
 import dev.gitlive.difflib.patch.PatchFailedException
 
 internal typealias Predicate<T> = (T) -> Boolean
-internal typealias BiPredicate<T,R> = (T, R) -> Boolean
+internal typealias BiPredicate<T, R> = (T, R) -> Boolean
 internal typealias Consumer<T> = (T) -> Unit
-internal typealias Function<T,R> = (T) -> R
+internal typealias Function<T, R> = (T) -> R
+internal typealias BiFunction<T, T2, R> = (T, T2) -> R
+internal typealias BiConsumer<T, U> = (T, U) -> Unit
+internal typealias LineReader = suspend () -> String?
 
 /**
  * Implements the difference and patching engine
- *
- * @author [Dmitry Naumenko](dm.naumenko@gmail.com)
  */
 object DiffUtils {
+    /**
+     * This factory generates the DEFAULT_DIFF algorithm for all these routines.
+     */
+    var DEFAULT_DIFF: DiffAlgorithmFactory = MeyersDiff.Companion.factory()
+    @kotlin.jvm.JvmStatic
+    fun withDefaultDiffAlgorithmFactory(factory: DiffAlgorithmFactory) {
+        DEFAULT_DIFF = factory
+    }
 
     /**
-     * Computes the difference between the original and revised list of elements with default diff algorithm
+     * Computes the difference between the original and revised list of elements
+     * with default diff algorithm
      *
+     * @param <T> types to be diffed
      * @param original The original text. Must not be `null`.
      * @param revised The revised text. Must not be `null`.
      * @param progress progress listener
-     * @return The patch describing the difference between the original and revised sequences. Never `null`.
-     * @throws dev.gitlive.difflib.algorithm.DiffException
-     */
-//    @Throws(DiffException::class)
-    fun <T> diff(original: List<T>, revised: List<T>, progress: DiffAlgorithmListener): Patch<T> {
-        return diff(original, revised, MyersDiff(), progress)
+     * @return The patch describing the difference between the original and
+     * revised sequences. Never `null`.
+    </T> */
+    fun <T> diff(original: List<T>, revised: List<T>, progress: DiffAlgorithmListener?): Patch<T> {
+        return diff<T>(original, revised, DEFAULT_DIFF.create(), progress)
     }
 
-//    @Throws(DiffException::class)
     fun <T> diff(original: List<T>, revised: List<T>): Patch<T> {
-        return diff(original, revised, MyersDiff(), null)
+        return diff<T>(original, revised, DEFAULT_DIFF.create(), null)
+    }
+
+    fun <T> diff(original: List<T>, revised: List<T>, includeEqualParts: Boolean): Patch<T> {
+        return diff<T>(original, revised, DEFAULT_DIFF.create(), null, includeEqualParts)
     }
 
     /**
      * Computes the difference between the original and revised text.
      */
-//    @Throws(DiffException::class)
-    fun diff(sourceText: String, targetText: String,
-             progress: DiffAlgorithmListener): Patch<String> {
-        return diff(sourceText.lines(), targetText.lines(), progress)
+    fun diff(
+        sourceText: String, targetText: String,
+        progress: DiffAlgorithmListener?
+    ): Patch<String> {
+        return diff(sourceText.trimEnd('\n').lines(), targetText.trimEnd('\n').lines(), progress)
     }
 
     /**
-     * Computes the difference between the original and revised list of elements with default diff algorithm
+     * Computes the difference between the original and revised list of elements
+     * with default diff algorithm
      *
      * @param source The original text. Must not be `null`.
      * @param target The revised text. Must not be `null`.
      *
-     * @param equalizer the equalizer object to replace the default compare algorithm (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. Never `null`.
+     * @param equalizer the equalizer object to replace the default compare
+     * algorithm (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. Never `null`.
      */
-//    @Throws(DiffException::class)
-    fun <T> diff(source: List<T>, target: List<T>,
-                 equalizer: BiPredicate<T, T>?): Patch<T> {
+    fun <T> diff(
+        source: List<T>, target: List<T>,
+        equalizer: BiPredicate<T, T>?
+    ): Patch<T> {
+        return if (equalizer != null) {
+            diff(
+                source, target,
+                DEFAULT_DIFF.create(equalizer)
+            )
+        } else diff(source, target, MeyersDiff())
+    }
+
+    fun <T> diff(
+        source: List<T>, target: List<T>,
+        includeEqualParts: Boolean,
+        equalizer: BiPredicate<T, T>?
+    ): Patch<T> {
         return if (equalizer != null) {
-            diff(source, target,
-                    MyersDiff(equalizer))
-        } else diff(source, target, MyersDiff())
+            diff(source, target, DEFAULT_DIFF.create(equalizer), null, includeEqualParts)
+        } else diff(source, target, MeyersDiff())
+    }
+
+    fun <T> diff(
+        original: List<T>, revised: List<T>,
+        algorithm: DiffAlgorithmI<T>, progress: DiffAlgorithmListener?
+    ): Patch<T> {
+        return diff(original, revised, algorithm, progress, false)
     }
 
     /**
-     * Computes the difference between the original and revised list of elements with default diff algorithm
+     * Computes the difference between the original and revised list of elements
+     * with default diff algorithm
      *
      * @param original The original text. Must not be `null`.
      * @param revised The revised text. Must not be `null`.
      * @param algorithm The diff algorithm. Must not be `null`.
      * @param progress The diff algorithm listener.
-     * @return The patch describing the difference between the original and revised sequences. Never `null`.
+     * @param includeEqualParts Include equal data parts into the patch.
+     * @return The patch describing the difference between the original and
+     * revised sequences. Never `null`.
      */
-//    @Throws(DiffException::class)
-    fun <T> diff(original: List<T>, revised: List<T>,
-                 algorithm: DiffAlgorithmI<T>, progress: DiffAlgorithmListener?): Patch<T> {
-        return Patch.generate(original, revised, algorithm.computeDiff(original, revised, progress))
+    fun <T> diff(
+        original: List<T>, revised: List<T>,
+        algorithm: DiffAlgorithmI<T>, progress: DiffAlgorithmListener?,
+        includeEqualParts: Boolean
+    ): Patch<T> {
+        return Patch.Companion.generate<T>(
+            original,
+            revised,
+            algorithm.computeDiff(original, revised, progress),
+            includeEqualParts
+        )
     }
 
     /**
-     * Computes the difference between the original and revised list of elements with default diff algorithm
+     * Computes the difference between the original and revised list of elements
+     * with default diff algorithm
      *
      * @param original The original text. Must not be `null`.
      * @param revised The revised text. Must not be `null`.
      * @param algorithm The diff algorithm. Must not be `null`.
-     * @return The patch describing the difference between the original and revised sequences. Never `null`.
+     * @return The patch describing the difference between the original and
+     * revised sequences. Never `null`.
      */
-//    @Throws(DiffException::class)
-    fun <T> diff(original: List<T>, revised: List<T>,
-                 algorithm: DiffAlgorithmI<T>): Patch<T> {
+    @kotlin.jvm.JvmStatic
+    fun <T> diff(original: List<T>, revised: List<T>, algorithm: DiffAlgorithmI<T>): Patch<T> {
         return diff(original, revised, algorithm, null)
     }
 
     /**
-     * Computes the difference between the given texts inline. This one uses the "trick" to make out of texts lists of
-     * characters, like DiffRowGenerator does and merges those changes at the end together again.
+     * Computes the difference between the given texts inline. This one uses the
+     * "trick" to make out of texts lists of characters, like DiffRowGenerator
+     * does and merges those changes at the end together again.
      *
      * @param original
      * @param revised
      * @return
      */
-//    @Throws(DiffException::class)
+    @kotlin.jvm.JvmStatic
     fun diffInline(original: String, revised: String): Patch<String> {
-        val origList = ArrayList<String>()
-        val revList = ArrayList<String>()
+        val origList: MutableList<String> = ArrayList()
+        val revList: MutableList<String> = ArrayList()
         for (character in original) {
             origList.add(character.toString())
         }
         for (character in revised) {
             revList.add(character.toString())
         }
-        val patch = diff(origList, revList)
+        val patch: Patch<String> = diff(origList, revList)
         for (delta in patch.getDeltas()) {
-            delta.source.lines = compressLines(delta.source.lines!!, "")
-            delta.target.lines = compressLines(delta.target.lines!!, "")
+            delta.source.lines = compressLines(delta.source.lines, "")
+            delta.target.lines = compressLines(delta.target.lines, "")
         }
         return patch
     }
@@ -151,6 +199,7 @@ object DiffUtils {
      * @return the revised text
      * @throws PatchFailedException if can't apply patch
      */
+    @kotlin.jvm.JvmStatic
 //    @Throws(PatchFailedException::class)
     fun <T> patch(original: List<T>, patch: Patch<T>): List<T> {
         return patch.applyTo(original)
@@ -166,4 +215,4 @@ object DiffUtils {
     fun <T> unpatch(revised: List<T>, patch: Patch<T>): List<T> {
         return patch.restore(revised)
     }
-}
+}