Merge kmp-dev to master

.github/workflows/release/versions.json

@@ -54,7 +54,7 @@
       "clearedSuffix": false
     }
   ],
-  "pubnub-core/pubnub-core-impl/src/test/kotlin/com/pubnub/api/legacy/PubNubCoreTest.kt": [
+  "pubnub-kotlin/pubnub-kotlin-impl/src/test/kotlin/com/pubnub/api/legacy/PubNubImplTest.kt": [
     {
       "pattern": "assertEquals\\(\"(v?(\\d+\\.?){2,}([a-zA-Z0-9-]+(\\.?\\d+)?)?)\", version\\)$",
       "clearedPrefix": true,

.github/workflows/run-tests.yml

@@ -31,6 +31,12 @@ jobs:
       - name: Build and run tests
         run: |
           ./gradlew check
+        env:
+          SDK_PUB_KEY: ${{ secrets.SDK_PUB_KEY }}
+          SDK_SUB_KEY: ${{ secrets.SDK_SUB_KEY }}
+          SDK_PAM_SUB_KEY: ${{ secrets.SDK_PAM_SUB_KEY }}
+          SDK_PAM_PUB_KEY: ${{ secrets.SDK_PAM_PUB_KEY }}
+          SDK_PAM_SEC_KEY: ${{ secrets.SDK_PAM_SEC_KEY }}
       - name: Cancel workflow runs for commit on error
         if: failure()
         uses: ./.github/.release/actions/actions/utils/fast-jobs-failure

.github/workflows/run-validations.yml

@@ -49,7 +49,7 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-gradle-
       - name: Validate clean build
-        run: ./gradlew build
+        run: ./gradlew ktlintFormat publishAllPublicationsToRepoRepository -PRELEASE_SIGNING_ENABLED=false
       - name: Cancel workflow runs for commit on error
         if: failure()
         uses: ./.github/.release/actions/actions/utils/fast-jobs-failure

.gitignore

@@ -1,3 +1,4 @@
+.kotlin
 examples
 .gradle/
 .idea/

.gitmodules

@@ -0,0 +1,4 @@
+[submodule "swift"]
+	path = swift
+	url = https://github.com/pubnub/swift
+	branch = feat/kmp2

build-logic/gradle-plugins/build.gradle.kts

@@ -3,10 +3,6 @@ plugins {
     alias(libs.plugins.kotlin.jvm)
 }
 
-kotlin {
-    jvmToolchain(8)
-}
-
 dependencies {
     compileOnly(gradleKotlinDsl())
     compileOnly(libs.nexus.gradlePlugin)
@@ -30,5 +26,25 @@ gradlePlugin {
             id = "pubnub.integration-test"
             implementationClass = "com.pubnub.gradle.PubNubIntegrationTestPlugin"
         }
+        register("pubnubTest") {
+            id = "pubnub.test"
+            implementationClass = "com.pubnub.gradle.PubNubTestPlugin"
+        }
+        register("pubnubJavaLibrary") {
+            id = "pubnub.java-library"
+            implementationClass = "com.pubnub.gradle.PubNubJavaLibraryPlugin"
+        }
+        register("pubnubKotlinLibrary") {
+            id = "pubnub.kotlin-library"
+            implementationClass = "com.pubnub.gradle.PubNubKotlinLibraryPlugin"
+        }
+        register("pubnubIosSimulatorTest") {
+            id = "pubnub.ios-simulator-test"
+            implementationClass = "com.pubnub.gradle.PubNubIosSimulatorTestPlugin"
+        }
+        register("pubnubMultiplatform") {
+            id = "pubnub.multiplatform"
+            implementationClass = "com.pubnub.gradle.PubNubKotlinMultiplatformPlugin"
+        }
     }
 }

build-logic/gradle-plugins/gradle.properties

@@ -1,3 +1,3 @@
-org.gradle.parallel=true
+org.gradle.parallel=false
 org.gradle.caching=true
-org.gradle.configureondemand=true
+org.gradle.configuration-cache=true

build-logic/gradle-plugins/src/main/kotlin/com/pubnub/gradle/PubNubDokkaPlugin.kt

@@ -14,12 +14,13 @@ class PubNubDokkaPlugin : Plugin<Project> {
             apply<DokkaPlugin>()
 
             tasks.withType<DokkaTask>().configureEach { task ->
-                task.dokkaSourceSets.configureEach {
-                    it.perPackageOption {
+                task.notCompatibleWithConfigurationCache("https://github.com/Kotlin/dokka/issues/2231")
+                task.dokkaSourceSets.configureEach { sourceSetBuilder ->
+                    sourceSetBuilder.perPackageOption {
                         it.matchingRegex.set(".*internal.*")
                         it.suppress.set(true)
                     }
-                    it.skipEmptyPackages.set(true)
+                    sourceSetBuilder.skipEmptyPackages.set(true)
                 }
             }
 

build-logic/gradle-plugins/src/main/kotlin/com/pubnub/gradle/PubNubIosSimulatorTestPlugin.kt

@@ -0,0 +1,62 @@
+package com.pubnub.gradle
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.tasks.Exec
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.register
+import org.gradle.kotlin.dsl.withType
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformPluginWrapper
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
+import org.jetbrains.kotlin.gradle.plugin.mpp.TestExecutable
+import org.jetbrains.kotlin.gradle.targets.native.tasks.KotlinNativeSimulatorTest
+import java.io.ByteArrayOutputStream
+
+class PubNubIosSimulatorTestPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            apply<KotlinMultiplatformPluginWrapper>()
+
+            val deviceName = project.findProperty("IOS_SIMULATOR_ID") as? String ?: "iPhone 15 Pro"
+            val isMacOs = providers.systemProperty("os.name").map { it.contains("mac", ignoreCase = true) }
+
+            val bootTask = tasks.register<Exec>("bootIOSSimulator") {
+                onlyIf { isMacOs.get() }
+                isIgnoreExitValue = true
+                commandLine("xcrun", "simctl", "boot", deviceName)
+                doLast {
+                    val result = executionResult.get()
+                    if (result.exitValue != 148 && result.exitValue != 149) { // ignoring device already booted errors
+                        result.assertNormalExitValue()
+                    }
+                }
+            }
+
+//            val shutdownTask = tasks.register<Exec>("shutdownIOSSimulator") {
+//                onlyIf { isMacOs.get() }
+//                commandLine("xcrun", "simctl", "shutdown", deviceName)
+//                dependsOn(tasks.withType<KotlinNativeSimulatorTest>())
+//            }
+
+            tasks.withType<KotlinNativeSimulatorTest>().configureEach {
+                it.onlyIf { isMacOs.get() }
+                it.standalone.set(false)
+                it.device.set(deviceName)
+                it.dependsOn(bootTask)
+//                it.finalizedBy(shutdownTask)
+            }
+
+            extensions.configure<KotlinMultiplatformExtension> {
+                targets.withType<KotlinNativeTarget> {
+                    if (konanTarget.family.isAppleFamily) {
+                        binaries.withType<TestExecutable> {
+                            freeCompilerArgs += listOf("-e", "testlauncher.mainBackground")
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

build-logic/gradle-plugins/src/main/kotlin/com/pubnub/gradle/PubNubJavaLibraryPlugin.kt

@@ -0,0 +1,44 @@
+package com.pubnub.gradle
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.plugins.JavaLibraryPlugin
+import org.gradle.api.plugins.quality.Checkstyle
+import org.gradle.api.plugins.quality.CheckstyleExtension
+import org.gradle.api.plugins.quality.CheckstylePlugin
+import org.gradle.api.tasks.SourceSetContainer
+import org.gradle.api.tasks.compile.JavaCompile
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.getByType
+import org.gradle.kotlin.dsl.withType
+
+class PubNubJavaLibraryPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            apply<PubNubSharedPlugin>()
+            apply<JavaLibraryPlugin>()
+            apply<CheckstylePlugin>()
+
+            tasks.withType<JavaCompile>().configureEach {
+                it.options.compilerArgs.add("-parameters")
+            }
+
+            extensions.configure<CheckstyleExtension> {
+                toolVersion = "8.14"
+                configFile = rootProject.file("config/checkstyle/checkstyle.xml")
+                sourceSets = listOf(extensions.getByType<SourceSetContainer>().getByName("main"))
+            }
+
+            tasks.withType<Checkstyle>().configureEach {
+                it.exclude("**/vendor/**", "**/*Test*")
+
+                it.reports { report ->
+                    report.xml.required.set(true)
+                    report.html.required.set(true)
+                }
+            }
+
+        }
+    }
+}

build-logic/gradle-plugins/src/main/kotlin/com/pubnub/gradle/PubNubKotlinLibraryPlugin.kt

@@ -0,0 +1,31 @@
+package com.pubnub.gradle
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.configure
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
+import org.jetbrains.kotlin.gradle.plugin.KotlinPluginWrapper
+import org.jetbrains.kotlin.gradle.tasks.KotlinJvmCompile
+
+class PubNubKotlinLibraryPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            apply<PubNubSharedPlugin>()
+            apply<KotlinPluginWrapper>()
+
+            // Kotlin
+            extensions.configure<KotlinJvmProjectExtension> {
+                jvmToolchain(8)
+            }
+
+            tasks.named("compileKotlin", KotlinJvmCompile::class.java) {
+                it.compilerOptions {
+                    javaParameters.set(true)
+                    freeCompilerArgs.add("-Xjvm-default=all")
+                }
+            }
+
+        }
+    }
+}

build-logic/gradle-plugins/src/main/kotlin/com/pubnub/gradle/PubNubKotlinMultiplatformPlugin.kt

@@ -0,0 +1,143 @@
+package com.pubnub.gradle
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.plugins.ExtensionAware
+import org.gradle.api.tasks.testing.AbstractTestTask
+import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.withType
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformPluginWrapper
+import org.jetbrains.kotlin.gradle.plugin.cocoapods.CocoapodsExtension
+import org.jetbrains.kotlin.gradle.plugin.cocoapods.KotlinCocoapodsPlugin
+import org.jetbrains.kotlin.gradle.plugin.mpp.NativeBuildType
+import org.jetbrains.kotlin.gradle.targets.js.yarn.YarnLockMismatchReport
+import org.jetbrains.kotlin.gradle.targets.js.yarn.yarn
+
+class PubNubKotlinMultiplatformPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            apply<KotlinMultiplatformPluginWrapper>()
+            if (enableAnyIosTarget) {
+                apply<KotlinCocoapodsPlugin>()
+            }
+
+            // Kotlin
+            extensions.configure<KotlinMultiplatformExtension> {
+                compilerOptions.freeCompilerArgs.add("-Xexpect-actual-classes")
+                jvmToolchain(8)
+
+                if (enableJsTarget) {
+                    js { ->
+                        useEsModules()
+                        browser {
+                            testTask {
+                                it.useMocha {
+                                    timeout = "10s"
+                                }
+                            }
+                        }
+//                    nodejs {
+//                        testTask {
+//                            it.useMocha {
+//                                timeout = "5s"
+//                            }
+//                        }
+//                    }
+                    }
+                }
+
+                jvm { ->
+                    compilations.configureEach { compilation ->
+                        compilation.compileTaskProvider.configure { task ->
+                            task.compilerOptions {
+                                javaParameters.set(true)
+                                freeCompilerArgs.add("-Xjvm-default=all")
+                            }
+                        }
+                    }
+                }
+
+
+                if (enableIosTarget) {
+                    iosArm64()
+                }
+                if (enableIosSimulatorTarget) {
+                    iosSimulatorArm64()
+                }
+
+                applyDefaultHierarchyTemplate()
+                with (sourceSets) {
+                    val commonMain = getByName("commonMain")
+
+                    val nonJvm = create("nonJvm") {
+                        it.dependsOn(commonMain)
+                    }
+
+                    if (enableJsTarget) {
+                        getByName("jsMain") {
+                            it.dependsOn(nonJvm)
+                        }
+                    }
+
+                    if (enableAnyIosTarget) {
+                        getByName("iosMain") {
+                            it.dependsOn(nonJvm)
+                        }
+                    }
+                }
+
+                if (enableAnyIosTarget) {
+                    (this as? ExtensionAware)?.extensions?.configure<CocoapodsExtension> {
+                        ios.deploymentTarget = "14"
+//
+//                    summary = "Some description for a Kotlin/Native module"
+//                    homepage = "Link to a Kotlin/Native module homepage"
+
+                        // Maps custom Xcode configuration to NativeBuildType
+                        xcodeConfigurationToNativeBuildType["CUSTOM_DEBUG"] = NativeBuildType.DEBUG
+                        xcodeConfigurationToNativeBuildType["CUSTOM_RELEASE"] = NativeBuildType.RELEASE
+
+                        framework {
+                            isStatic = true
+                            transitiveExport = true
+                        }
+
+                        pod("PubNubSwift") {
+                            val swiftPath = project.findProperty("SWIFT_PATH") as? String ?: "swift"
+//                        source = git("https://github.com/pubnub/swift") {
+//                            branch = "feat/kmp"
+//                        }
+//                        version = "7.1.0"
+                            source = path(rootProject.file(swiftPath))
+                            moduleName = "PubNubSDK"
+                            extraOpts += listOf("-compiler-option", "-fmodules")
+                        }
+                    }
+                }
+            }
+            if (enableJsTarget) {
+                yarn.yarnLockMismatchReport = YarnLockMismatchReport.WARNING
+                yarn.yarnLockAutoReplace = true
+            }
+            tasks.withType<AbstractTestTask> {
+                testLogging {
+                    it.showStackTraces = true
+                    it.showCauses = true
+                    it.showExceptions = true
+                    it.exceptionFormat = TestExceptionFormat.FULL
+                }
+//                if (providers.environmentVariable("CI").isPresent && !providers.environmentVariable("CI_FORCE_RUN_INTEGRATION_TESTS").isPresent) {
+//                    filter.excludeTestsMatching("com.pubnub.test.integration.*")
+//                }
+            }
+        }
+    }
+}
+
+val Project.enableJsTarget get() = project.findProperty("ENABLE_TARGET_JS") == "true"
+val Project.enableIosTarget get() = project.findProperty("ENABLE_TARGET_IOS") == "true"
+val Project.enableIosSimulatorTarget get() = project.findProperty("ENABLE_TARGET_IOS_SIMULATOR") == "true"
+val Project.enableAnyIosTarget get() = enableIosTarget || enableIosSimulatorTarget