Continuous development

buildSrc/build.gradle.kts

@@ -3,50 +3,37 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 plugins {
   idea
   `kotlin-dsl`
-  kotlin("jvm") version "1.6.10"
+  kotlin("jvm") version "1.6.20"
   `project-report`
 }
 
 
-object Versions {
-  const val jvmTarget = "11"
-  const val kotlin = "1.6.10"
-  const val kotlinTarget = "1.6"
-  const val kotlinxKnit = "0.3.0"
-  const val kotlinxKover = "0.5.0"
-  const val kotlinxSerialization = "1.3.2"
-  const val ksp = "1.6.10-1.0.4"
-  const val gradleNodePlugin = "3.2.1"
-
-  const val kotest = "5.2.3"
-}
-
-
 dependencies {
-  implementation(enforcedPlatform("org.jetbrains.kotlin:kotlin-bom:${Versions.kotlin}"))
+  implementation(enforcedPlatform(libs.kotlin.bom))
   implementation("org.jetbrains.kotlin:kotlin-serialization")
-  implementation("org.jetbrains.kotlin:kotlin-reflect")
-  implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:${Versions.kotlin}")
+//  implementation("org.jetbrains.kotlin:kotlin-reflect")
 
-  implementation("com.google.devtools.ksp:com.google.devtools.ksp.gradle.plugin:${Versions.ksp}")
+  implementation(libs.kotlin.gradlePlugin)
+  implementation(libs.kotlinSymbolProcessing.gradlePlugin)
 
-  implementation(platform("org.jetbrains.kotlinx:kotlinx-serialization-bom:${Versions.kotlinxSerialization}"))
+  implementation(libs.kotest.gradlePlugin)
 
-  implementation("io.kotest:kotest-framework-multiplatform-plugin-gradle:${Versions.kotest}")
+  implementation(libs.kotlinx.kover.gradlePlugin)
 
-  implementation("org.jetbrains.kotlinx:kotlinx-knit:${Versions.kotlinxKnit}")
-  implementation("org.jetbrains.kotlinx:kover:${Versions.kotlinxKover}")
+  implementation(libs.kotlinx.knit.gradlePlugin)
 
-  implementation("com.github.node-gradle:gradle-node-plugin:${Versions.gradleNodePlugin}")
+  implementation(libs.gradleNodePlugin)
 }
 
+val gradleJvmTarget = "11"
+val gradleKotlinTarget = "1.6"
 
 tasks.withType<KotlinCompile>().configureEach {
 
   kotlinOptions {
-    jvmTarget = Versions.jvmTarget
-    apiVersion = Versions.kotlinTarget
-    languageVersion = Versions.kotlinTarget
+    jvmTarget = gradleJvmTarget
+    apiVersion = gradleKotlinTarget
+    languageVersion = gradleKotlinTarget
   }
 
   kotlinOptions.freeCompilerArgs += listOf(
@@ -58,11 +45,11 @@ tasks.withType<KotlinCompile>().configureEach {
 
 kotlin {
   jvmToolchain {
-    (this as JavaToolchainSpec).languageVersion.set(JavaLanguageVersion.of(Versions.jvmTarget))
+    (this as JavaToolchainSpec).languageVersion.set(JavaLanguageVersion.of(gradleJvmTarget))
   }
 
   kotlinDslPluginOptions {
-    jvmTarget.set(Versions.jvmTarget)
+    jvmTarget.set(gradleJvmTarget)
   }
 }
 

buildSrc/settings.gradle.kts

@@ -1 +1,10 @@
 apply(from = "./repositories.settings.gradle.kts")
+
+dependencyResolutionManagement {
+  @Suppress("UnstableApiUsage")
+  versionCatalogs {
+    create("libs") {
+      from(files("../gradle/libs.versions.toml"))
+    }
+  }
+}

buildSrc/src/main/kotlin/buildsrc/config/publishing.kt

@@ -0,0 +1,44 @@
+package buildsrc.config
+
+import org.gradle.api.Project
+import org.gradle.api.publish.PublishingExtension
+import org.gradle.api.publish.maven.MavenPublication
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.getByType
+import org.gradle.plugins.signing.SigningExtension
+
+
+fun MavenPublication.kxsTsGenPom() = pom {
+  url.set("https://github.com/adamko-dev/kotlinx-serialization-typescript-generator")
+  packaging = "jar"
+  licenses {
+    license {
+      name.set("The Apache License, Version 2.0")
+      url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
+    }
+  }
+  scm {
+    connection.set("scm:git:git://github.com/adamko-dev/kotlinx-serialization-typescript-generator.git")
+    url.set("https://github.com/adamko-dev/kotlinx-serialization-typescript-generator")
+  }
+}
+
+
+
+
+
+// hacks because IntelliJ still doesn't properly load DSL accessors for buildSrc
+
+/** Configure [PublishingExtension] */
+fun Project.publishing(action: PublishingExtension.() -> Unit): Unit =
+  extensions.configure(action)
+
+val Project.publishing: PublishingExtension
+  get() = extensions.getByType<PublishingExtension>()
+
+/** Configure [SigningExtension] */
+fun Project.signing(action: SigningExtension.() -> Unit): Unit =
+  extensions.configure(action)
+
+val Project.signing: SigningExtension
+  get() = extensions.getByType<SigningExtension>()

buildSrc/src/main/kotlin/buildsrc/convention/kotlin-jvm.gradle.kts

@@ -13,7 +13,7 @@ plugins {
 }
 
 dependencies {
-  testImplementation(platform("io.kotest:kotest-bom:5.2.3"))
+  // versions provided by versions-platform subproject
   testImplementation("io.kotest:kotest-runner-junit5")
   testImplementation("io.kotest:kotest-assertions-core")
   testImplementation("io.kotest:kotest-property")
@@ -33,7 +33,7 @@ java {
 
 tasks.withType<KotlinCompile> {
   kotlinOptions {
-    jvmTarget = "11"
+    jvmTarget = "1.8"
     apiVersion = "1.6"
     languageVersion = "1.6"
   }

buildSrc/src/main/kotlin/buildsrc/convention/maven-publish.gradle.kts

@@ -1,26 +1,88 @@
 package buildsrc.convention
 
+import buildsrc.config.publishing
+import buildsrc.config.signing
+import org.gradle.api.credentials.PasswordCredentials
+import org.gradle.internal.credentials.DefaultPasswordCredentials
+
 plugins {
+  id("buildsrc.convention.subproject")
   `maven-publish`
+  signing
+}
+
+
+//val sonatypeRepositoryCredentials: Provider<PasswordCredentials> =
+//  providers.credentials(PasswordCredentials::class, "sonatypeRepositoryCredentials")
+
+val sonatypeRepositoryUsername: String? by project.extra
+val sonatypeRepositoryPassword: String? by project.extra
+val sonatypeRepositoryCredentials: Provider<PasswordCredentials> = providers.provider {
+  if (sonatypeRepositoryUsername.isNullOrBlank() || sonatypeRepositoryPassword.isNullOrBlank()) {
+    null
+  } else {
+    DefaultPasswordCredentials(sonatypeRepositoryUsername, sonatypeRepositoryPassword)
+  }
+}
+
+
+val sonatypeRepositoryId: String by project.extra
+
+val sonatypeRepositoryReleaseUrl: Provider<String> = provider {
+  if (version.toString().endsWith("SNAPSHOT")) {
+    "https://oss.sonatype.org/content/repositories/snapshots/"
+  } else {
+    "https://oss.sonatype.org/service/local/staging/deployByRepositoryId/$sonatypeRepositoryId/"
+  }
 }
 
-//plugins.withType(JavaPlugin::class.java) {
-//  publishing {
-//    publications {
-//      create<MavenPublication>("mavenJava") {
-//        from(components["java"])
-//      }
-//    }
-//  }
-//}
-
-tasks
-  .matching {
-    it.name.startsWith(PublishingPlugin.PUBLISH_LIFECYCLE_TASK_NAME)
-      && it.group == PublishingPlugin.PUBLISH_TASK_GROUP
+
+tasks.matching {
+  it.name.startsWith(PublishingPlugin.PUBLISH_LIFECYCLE_TASK_NAME)
+    && it.group == PublishingPlugin.PUBLISH_TASK_GROUP
+}.configureEach {
+  doLast {
+    logger.lifecycle("[${this.name}] ${project.group}:${project.name}:${project.version}")
   }
-  .configureEach {
-    doLast {
-      logger.lifecycle("[${this.name}] ${project.group}:${project.name}:${project.version}")
+}
+
+
+
+publishing {
+  repositories {
+    if (sonatypeRepositoryCredentials.isPresent) {
+      maven(sonatypeRepositoryReleaseUrl) {
+        name = "oss"
+        credentials {
+          username = sonatypeRepositoryCredentials.get().username
+          password = sonatypeRepositoryCredentials.get().password
+        }
+      }
     }
   }
+}
+
+signing {
+  val signingKeyId: String? by project
+  val signingKey: String? by project
+  val signingPassword: String? by project
+  useInMemoryPgpKeys(signingKeyId, signingKey, signingPassword)
+  setRequired(false)
+}
+
+
+plugins.withType<JavaPlugin> {
+  if (!plugins.hasPlugin(KotlinMultiplatformPlugin::class)) {
+    val publication = publishing.publications.create<MavenPublication>("mavenJava") {
+      from(components["java"])
+    }
+    signing { sign(publication) }
+  }
+}
+
+plugins.withType<JavaPlatformPlugin> {
+  val publication = publishing.publications.create<MavenPublication>("mavenJavaPlatform") {
+    from(components["javaPlatform"])
+  }
+  signing { sign(publication) }
+}

docs/code/build.gradle.kts

@@ -7,25 +7,24 @@ plugins {
   id("org.jetbrains.kotlinx.knit")
 }
 
-val kotlinxSerializationVersion = "1.3.2"
-
 dependencies {
+  implementation(platform(projects.modules.versionsPlatform))
+
   implementation(projects.modules.kxsTsGenCore)
 
-  implementation(platform("org.jetbrains.kotlinx:kotlinx-serialization-bom:${kotlinxSerializationVersion}"))
-  implementation("org.jetbrains.kotlinx:kotlinx-serialization-core")
-  implementation("org.jetbrains.kotlinx:kotlinx-serialization-json")
+  implementation(libs.kotlinx.serialization.core)
+  implementation(libs.kotlinx.serialization.json)
 
-  implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.1")
+  implementation(libs.kotlinx.coroutines.core)
 
-  implementation("org.jetbrains.kotlinx:kotlinx-knit:0.3.0")
+  implementation(libs.kotlinx.knit)
 
   implementation(kotlin("reflect"))
 
   testImplementation(kotlin("test"))
 
-  testImplementation("org.jetbrains.kotlinx:kotlinx-knit-test:0.3.0")
-  testImplementation("com.github.pgreze:kotlin-process:1.3.1")
+  testImplementation(libs.kotlinx.knit.test)
+  testImplementation(libs.kotlinProcess)
 }
 
 tasks.withType<KotlinCompile> {

docs/code/example/example-customising-output-03.kt

@@ -32,4 +32,3 @@ fun main() {
 
   println(tsGenerator.generate(ItemHolder.serializer()))
 }
-

docs/code/example/example-customising-output-04.kt

@@ -43,5 +43,3 @@ fun main() {
 
   println(tsGenerator.generate(ItemHolder.serializer()))
 }
-
-

docs/code/example/example-polymorphic-sealed-class-02.kt

@@ -10,20 +10,23 @@ sealed class Dog {
   abstract val name: String
 
   @Serializable
+  @SerialName("Dog.Mutt")
   class Mutt(override val name: String, val loveable: Boolean = true) : Dog()
 
   @Serializable
   sealed class Retriever : Dog() {
     abstract val colour: String
 
     @Serializable
+    @SerialName("Dog.Retriever.Golden")
     data class Golden(
       override val name: String,
       override val colour: String,
       val cute: Boolean = true,
     ) : Retriever()
 
     @Serializable
+    @SerialName("Dog.Retriever.NovaScotia")
     data class NovaScotia(
       override val name: String,
       override val colour: String,

docs/code/example/example-tuple-01.kt

@@ -28,7 +28,7 @@ data class SimpleTypes(
     }
   ) {
     override fun tupleConstructor(elements: Iterator<*>): SimpleTypes {
-      // When deserializing, the elements will be available as a list, in the order defined
+      // When deserializing, the elements will be available as a list, in the order defined above
       return SimpleTypes(
         elements.next() as String,
         elements.next() as Int,

docs/code/example/example-tuple-05.kt

@@ -13,6 +13,7 @@ class GameLocations(
   val homeLocation: Coordinates,
   val allLocations: List<Coordinates>,
   val namedLocations: Map<String, Coordinates>,
+  val locationsInfo: Map<Coordinates, String>,
 )
 
 fun main() {

docs/code/knit-test.ftl

@@ -16,10 +16,12 @@ import kotlinx.knit.test.*
 class ${test.name} : FunSpec({
 
   tags(Knit)
-
-<#list cases as case><#assign method = test["mode.${case.param}"]!"custom">
+<#--<#assign method = test["mode.${case.param}"]!"custom">-->
+<#list cases as case>
   context("${case.name}") {
-    val actual = captureOutput("${case.name}") {
+    val caseName = testCase.name.testName
+
+    val actual = captureOutput(caseName) {
       ${case.knit.package}.${case.knit.name}.main()
     }.normalizeJoin()
 
@@ -40,11 +42,11 @@ class ${test.name} : FunSpec({
     <#if case.param == "TS_COMPILE_OFF">
     // TS_COMPILE_OFF
     // test("expect actual compiles").config(tags = tsCompile) {
-    //   actual.shouldTypeScriptCompile()
+    //   actual.shouldTypeScriptCompile(caseName)
     // }
     <#else>
     test("expect actual compiles").config(tags = tsCompile) {
-      actual.shouldTypeScriptCompile()
+      actual.shouldTypeScriptCompile(caseName)
     }
     </#if>
   }