more re-organisation to new name

buildSrc/src/main/kotlin/dev/adamko/kafkatorio/base.gradle.kts

@@ -0,0 +1,32 @@
+package dev.adamko.kafkatorio
+
+import org.gradle.kotlin.dsl.base
+import org.gradle.kotlin.dsl.extra
+import org.gradle.kotlin.dsl.idea
+
+plugins {
+  idea
+  base
+}
+
+group = "${rootProject.group}.${project.name}"
+version = rootProject.version
+
+val licenseFile: RegularFile by extra(rootProject.layout.projectDirectory.file("LICENSE"))
+
+val tokens: Map<String, String> by extra(
+  mapOf(
+    "project.version" to "$version",
+  )
+)
+
+idea {
+  module {
+    isDownloadSources = true
+    isDownloadJavadoc = true
+  }
+}
+
+//group = "dev.adamko.factoriowebmap"
+//version = "0.0.1"
+

buildSrc/src/main/kotlin/dev/adamko/kafkatorio/gradle/artifactDistribution.kt

@@ -0,0 +1,41 @@
+package dev.adamko.kafkatorio.gradle
+
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.attributes.Bundling
+import org.gradle.api.attributes.Bundling.BUNDLING_ATTRIBUTE
+import org.gradle.api.attributes.Category
+import org.gradle.api.attributes.Category.CATEGORY_ATTRIBUTE
+import org.gradle.api.attributes.LibraryElements
+import org.gradle.api.attributes.LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE
+import org.gradle.api.attributes.Usage.USAGE_ATTRIBUTE
+import org.gradle.api.model.ObjectFactory
+import org.gradle.kotlin.dsl.named
+
+
+fun Configuration.asProvider() {
+  isVisible = false
+  isCanBeResolved = false
+  isCanBeConsumed = true
+}
+
+fun Configuration.asConsumer() {
+  isVisible = false
+  isCanBeResolved = true
+  isCanBeConsumed = false
+}
+
+fun Configuration.factorioModAttributes(objects: ObjectFactory): Configuration =
+  attributes {
+    attribute(USAGE_ATTRIBUTE, objects.named("factorio"))
+    attribute(CATEGORY_ATTRIBUTE, objects.named(Category.LIBRARY))
+    attribute(LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements.CLASSES_AND_RESOURCES))
+    attribute(BUNDLING_ATTRIBUTE, objects.named(Bundling.EMBEDDED))
+  }
+
+fun Configuration.typescriptAttributes(objects: ObjectFactory) =
+  attributes {
+    attribute(USAGE_ATTRIBUTE, objects.named("typescript"))
+    attribute(CATEGORY_ATTRIBUTE, objects.named(Category.LIBRARY))
+    attribute(LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements.OBJECTS))
+    attribute(BUNDLING_ATTRIBUTE, objects.named(Bundling.EXTERNAL))
+  }

buildSrc/src/main/kotlin/dev/adamko/kafkatorio/gradle/extensions.kt

@@ -0,0 +1,21 @@
+package dev.adamko
+
+import java.io.ByteArrayOutputStream
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.api.specs.Spec
+import org.gradle.kotlin.dsl.invoke
+
+operator fun <T> Spec<T>.not(): Spec<T> = Spec<T> { !this(it) }
+
+fun Project.isProcessRunning(process: String, ignoreCase: Boolean = true): Spec<Task> =
+  Spec<Task> {
+    ByteArrayOutputStream().use { outputStream ->
+      project.exec {
+        commandLine("tasklist")
+        standardOutput = outputStream
+      }
+      outputStream.toString()
+        .contains(process, ignoreCase)
+    }
+  }

buildSrc/src/main/kotlin/dev/adamko/kafkatorio/lang/kotlin-js.gradle.kts

@@ -0,0 +1,61 @@
+package dev.adamko.kafkatorio.lang
+
+import org.gradle.kotlin.dsl.kotlin
+import com.github.gradle.node.npm.task.NpmTask
+import com.github.gradle.node.task.NodeTask
+import org.gradle.kotlin.dsl.dependencies
+import org.gradle.kotlin.dsl.extra
+import org.gradle.kotlin.dsl.getting
+import org.jetbrains.kotlin.gradle.targets.js.dukat.DtsResolver
+import org.jetbrains.kotlin.gradle.targets.js.npm.tasks.RootPackageJsonTask
+import org.jetbrains.kotlin.gradle.targets.js.npm.tasks.KotlinPackageJsonTask
+import org.jetbrains.kotlin.util.parseSpaceSeparatedArgs
+import org.jetbrains.kotlin.gradle.targets.js.npm.NpmProject
+
+
+plugins {
+  kotlin("js")
+  id("dev.adamko.kafkatorio.base")
+  id("dev.adamko.kafkatorio.lang.node")
+}
+
+kotlin {
+  js(IR) {
+    binaries.executable()
+
+    useCommonJs()
+    nodejs()
+  }
+}
+
+dependencies {
+  val kotlinWrappersVersion = "0.0.1-pre.270-kotlin-1.6.0"
+  implementation(
+      project.dependencies.enforcedPlatform(
+          "org.jetbrains.kotlin-wrappers:kotlin-wrappers-bom:${kotlinWrappersVersion}"
+      )
+  )
+}
+
+val rootPackageJson by rootProject.tasks.getting(RootPackageJsonTask::class)
+
+//fun NpmTask.setNodeModulesPath(path: String): Unit =
+//    environment.put("NODE_PATH", path)
+//
+//fun NpmTask.setNodeModulesPath(folder: File): Unit =
+//    setNodeModulesPath(folder.normalize().absolutePath)
+
+// https://github.com/node-gradle/gradle-node-plugin/issues/150
+// https://github.com/lamba92/kotlingram/blob/master/examples/js-bot/build.gradle.kts
+
+val nodePath: Directory by extra {
+  val file = rootPackageJson.rootPackageJson.parentFile.normalize()
+  logger.lifecycle("Kotlin/JS NODE_PATH: $file")
+  project.layout.dir(project.provider { file }).get()
+}
+
+val nodeModulesDir: Directory by extra {
+  val file = nodePath.dir(NpmProject.NODE_MODULES)
+  logger.lifecycle("Kotlin/JS NODE_MODULES: $file")
+  file
+}

buildSrc/src/main/kotlin/dev/adamko/kafkatorio/lang/kotlin-jvm.gradle.kts

@@ -0,0 +1,69 @@
+package dev.adamko.kafkatorio.lang
+
+import org.gradle.kotlin.dsl.dependencies
+import org.gradle.kotlin.dsl.kotlin
+import org.gradle.kotlin.dsl.withType
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+  id("dev.adamko.kafkatorio.base")
+  kotlin("jvm")
+}
+
+kotlin {
+  jvmToolchain {
+    (this as JavaToolchainSpec).languageVersion.set(JavaLanguageVersion.of(11))
+  }
+}
+
+dependencies {
+
+  //<editor-fold desc="Main">
+
+  implementation(platform("org.jetbrains.kotlin:kotlin-bom"))
+  implementation(kotlin("stdlib"))
+
+  //</editor-fold>
+
+  //<editor-fold desc="Test">
+
+  val junitVersion = "5.8.1"
+  testImplementation(enforcedPlatform("org.junit:junit-bom:$junitVersion"))
+  testImplementation("org.junit.jupiter:junit-jupiter-api")
+  testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
+  testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+
+  val kotestVersion = "4.6.3"
+  testImplementation(enforcedPlatform("io.kotest:kotest-bom:$kotestVersion"))
+  testImplementation("io.kotest:kotest-runner-junit5-jvm:$kotestVersion")
+  testImplementation("io.kotest:kotest-assertions-core-jvm:$kotestVersion")
+  testImplementation("io.kotest:kotest-property-jvm:$kotestVersion")
+  testImplementation("io.kotest:kotest-assertions-json:$kotestVersion")
+
+  testImplementation("io.mockk:mockk:1.12.0")
+
+  //</editor-fold>
+
+}
+
+tasks.withType<KotlinCompile>().configureEach {
+
+  kotlinOptions {
+    jvmTarget = "11"
+    apiVersion = "1.6"
+    languageVersion = "1.6"
+  }
+
+  kotlinOptions.freeCompilerArgs += listOf(
+    "-Xopt-in=kotlin.OptIn",
+    "-Xopt-in=kotlin.RequiresOptIn",
+    "-Xopt-in=kotlin.ExperimentalStdlibApi",
+    "-Xopt-in=kotlin.time.ExperimentalTime",
+    "-Xopt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
+    "-Xopt-in=kotlinx.serialization.ExperimentalSerializationApi",
+  )
+}
+
+tasks.compileTestKotlin {
+  kotlinOptions.freeCompilerArgs += "-Xopt-in=io.kotest.common.ExperimentalKotest"
+}

buildSrc/src/main/kotlin/dev/adamko/kafkatorio/lang/kotlin-multiplatform.gradle.kts

@@ -0,0 +1,24 @@
+package dev.adamko.kafkatorio.lang
+
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.kotlin
+import org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootExtension
+
+
+plugins {
+  id("dev.adamko.kafkatorio.base")
+  id("dev.adamko.kafkatorio.lang.node")
+  kotlin("multiplatform")
+}
+
+
+afterEvaluate {
+
+  rootProject.extensions.configure<NodeJsRootExtension> {
+    val projectNodeInstallDir = file("$rootDir/.gradle").resolve("nodejs")
+    if (installationDir != projectNodeInstallDir) {
+      installationDir = projectNodeInstallDir
+    }
+  }
+
+}

buildSrc/src/main/kotlin/dev/adamko/kafkatorio/lang/node.gradle.kts

@@ -0,0 +1,87 @@
+package dev.adamko.kafkatorio.lang
+
+import com.github.gradle.node.NodePlugin
+import dev.adamko.kafkatorio.task.UpdatePackageJson
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import org.gradle.kotlin.dsl.registering
+import org.gradle.kotlin.dsl.support.useToRun
+import org.gradle.kotlin.dsl.withType
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinMultiplatformPlugin
+import org.jetbrains.kotlin.gradle.targets.js.KotlinJsPlugin
+import org.jetbrains.kotlin.util.suffixIfNot
+
+plugins {
+  id("com.github.node-gradle.node")
+  id("dev.adamko.kafkatorio.base")
+}
+
+node {
+  download.set(true)
+  version.set("14.18.0")
+
+  distBaseUrl.set(null as String?) // set by dependencyResolutionManagement
+}
+
+project.plugins.withType<KotlinJsPlugin>()
+project.plugins.withType<KotlinMultiplatformPlugin>()
+
+
+val jsonMapper = Json {
+  prettyPrint = true
+  prettyPrintIndent = "  "
+}
+
+
+val packageJsonFile: RegularFile = layout.projectDirectory.file("src/main/typescript/package.json")
+
+fun arePropertiesUpToDate(properties: () -> Map<String, String>): Spec<Task> =
+  Spec<Task> {
+    val packageJsonContent = packageJsonFile.asFile.readText()
+    val packageJson = jsonMapper.parseToJsonElement(packageJsonContent).jsonObject
+
+    properties().all { (key, expectedVal) ->
+      val actualVal = packageJson[key]?.jsonPrimitive?.content
+      val isUpToDate = expectedVal == actualVal
+      if (!isUpToDate) {
+        logger.lifecycle("package.json has outdated property $key=$actualVal (expected: $expectedVal)")
+      }
+      isUpToDate
+    }
+  }
+
+val updatePackageJson by tasks.registering(UpdatePackageJson::class) {
+  group = NodePlugin.NODE_GROUP
+
+  group = project.name
+  description = "Read the package.json file and update the version and name, based on the project."
+
+  propertiesToCheck["version"] = "${project.version}"
+
+  outputs.file(packageJsonFile)
+
+  // check to see if the properties are already up-to-date
+  onlyIf(arePropertiesUpToDate { propertiesToCheck })
+
+  doLast {
+    val packageJsonContent = packageJsonFile.asFile.readText()
+    val packageJson = jsonMapper.parseToJsonElement(packageJsonContent).jsonObject
+
+    val newJsonProps = propertiesToCheck.mapValues { (_, newVal) -> JsonPrimitive(newVal) }
+
+    val packageJsonUpdate = JsonObject(packageJson + newJsonProps)
+    val packageJsonContentUpdated =
+      jsonMapper
+        .encodeToString(packageJsonUpdate)
+        .suffixIfNot("\n")
+
+    packageJsonFile.asFile.writer().useToRun {
+      write(packageJsonContentUpdated)
+    }
+
+  }
+}

buildSrc/src/main/kotlin/dev/adamko/kafkatorio/process-runner.gradle.kts

@@ -0,0 +1,26 @@
+package dev.adamko.kafkatorio
+
+import org.gradle.kotlin.dsl.extra
+import org.gradle.kotlin.dsl.registering
+
+plugins {
+  id("dev.adamko.kafkatorio.base")
+}
+
+val processRunnerTaskGroup: String by extra("processes")
+
+val processRun by tasks.registering {
+  group = processRunnerTaskGroup
+}
+
+val processKill by tasks.registering {
+  group = processRunnerTaskGroup
+}
+
+val processRestart by tasks.registering {
+  group = processRunnerTaskGroup
+
+  processKill.get().state
+  dependsOn(processKill)
+  finalizedBy(processRun)
+}

buildSrc/src/main/kotlin/dev/adamko/kafkatorio/task/UpdatePackageJson.kt

@@ -0,0 +1,9 @@
+package dev.adamko.kafkatorio.task
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.tasks.Input
+
+abstract class UpdatePackageJson : DefaultTask() {
+  @get:Input
+  val propertiesToCheck: MutableMap<String, String> = mutableMapOf()
+}