create gradle sign-publish plugin

cqp-build/build.gradle.kts

@@ -0,0 +1,23 @@
+plugins {
+    `kotlin-dsl`
+}
+
+group = "com.quantori.cqp-build"
+
+repositories {
+    mavenLocal()
+    mavenCentral()
+}
+
+gradlePlugin {
+    plugins {
+        create("cqpJavaLibrary") {
+            id = "com.quantori.cqp-build"
+            implementationClass = "com.quantori.cqp.build.CqpJavaLibraryPlugin"
+        }
+    }
+}
+
+dependencies {
+    compileOnly(gradleApi())
+}

cqp-build/src/main/kotlin/com/quantori/cqp/build/CqpJavaLibraryPlugin.kt

@@ -0,0 +1,135 @@
+package com.quantori.cqp.build
+
+import org.gradle.api.JavaVersion
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.publish.maven.MavenPublication
+import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.api.plugins.JavaLibraryPlugin
+import org.gradle.external.javadoc.StandardJavadocDocletOptions
+import org.gradle.jvm.toolchain.JavaLanguageVersion
+import org.gradle.api.tasks.testing.Test
+import org.gradle.kotlin.dsl.*
+
+class CqpJavaLibraryPlugin : Plugin<Project> {
+    override fun apply(project: Project) {
+        project.pluginManager.apply(JavaLibraryPlugin::class)
+        project.pluginManager.apply("maven-publish")
+        project.pluginManager.apply("signing")
+
+        project.group = "com.quantori"
+        project.version = project.findProperty("version") ?: "0.0.1-SNAPSHOT"
+
+        project.repositories {
+            mavenLocal()
+            mavenCentral()
+        }
+
+        project.extensions.configure<JavaPluginExtension> {
+            toolchain.languageVersion.set(JavaLanguageVersion.of(17))
+            withSourcesJar()
+            withJavadocJar()
+        }
+
+        project.tasks.withType<org.gradle.api.tasks.javadoc.Javadoc>().configureEach {
+            if (JavaVersion.current().isJava9Compatible) {
+                (options as StandardJavadocDocletOptions).apply {
+                    addStringOption("Xdoclint:none", "-quiet")
+                    addBooleanOption("html5", true)
+                }
+            }
+        }
+
+        project.extensions.configure<org.gradle.api.publish.PublishingExtension> {
+            publications {
+                create<MavenPublication>("mavenJava") {
+                    from(project.components["java"])
+
+                    pom {
+                        artifactId = project.name
+                        name.set(project.name)
+                        description.set(project.description ?: "")
+                        url.set("https://github.com/quantori/chem-query-platform")
+
+                        licenses {
+                            license {
+                                name.set("The Apache License, Version 2.0")
+                                url.set("https://www.apache.org/licenses/LICENSE-2.0.txt")
+                            }
+                        }
+
+                        developers {
+                            developer {
+                                id.set("artem.chukin")
+                                name.set("Artem Chukin")
+                                email.set("artem.chukin@quantori.com")
+                            }
+                            developer {
+                                id.set("dmitriy.gusev")
+                                name.set("Dmitriy Gusev")
+                                email.set("dmitriy.gusev@quantori.com")
+                            }
+                            developer {
+                                id.set("valeriy.burmistrov")
+                                name.set("Valeriy Burmistrov")
+                                email.set("valeriy.burmistrov@quantori.com")
+                            }
+                            developer {
+                                id.set("boris.sukhodoev")
+                                name.set("Boris Sukhodoev")
+                                email.set("boris.sukhodoev@quantori.com")
+                            }
+                        }
+
+                        scm {
+                            connection.set("scm:git:git://github.com/quantori/chem-query-platform.git")
+                            developerConnection.set("scm:git:ssh://github.com/quantori/chem-query-platform.git")
+                            url.set("https://github.com/quantori/chem-query-platform")
+                        }
+                    }
+                }
+            }
+
+            repositories {
+                maven {
+                    val releasesRepoUrl = project.layout.buildDirectory.dir("repos/releases")
+                    val snapshotsRepoUrl = project.layout.buildDirectory.dir("repos/snapshots")
+                    url = project.uri(
+                            if (project.version.toString().endsWith("SNAPSHOT"))
+                                snapshotsRepoUrl
+                            else
+                                releasesRepoUrl
+                    )
+                }
+            }
+        }
+
+        project.extensions.configure<org.gradle.plugins.signing.SigningExtension> {
+            setRequired {
+                !project.version.toString().endsWith("SNAPSHOT") &&
+                        project.gradle.taskGraph.hasTask("publish")
+            }
+
+            val signingSecretKey = project.findProperty("signing.secretKey") as String?
+                    ?: System.getenv("GPG_SIGNING_SECRET_KEY")
+            val signingPassword = project.findProperty("signing.password") as String?
+                    ?: System.getenv("GPG_SIGNING_PASSWORD")
+
+            if (!signingSecretKey.isNullOrBlank() && !signingPassword.isNullOrBlank()) {
+                useInMemoryPgpKeys(signingSecretKey, signingPassword)
+
+                sign(project.configurations.getByName("archives"))
+                sign(project.extensions.getByType(org.gradle.api.publish.PublishingExtension::class).publications["mavenJava"])
+            } else {
+                project.logger.lifecycle("GPG signing skipped: missing credentials")
+            }
+        }
+
+        project.tasks.named("test", Test::class) {
+            useJUnitPlatform()
+            testLogging {
+                events("passed", "skipped", "failed")
+            }
+        }
+    }
+}

cqp-core/build.gradle.kts

@@ -1,183 +1,12 @@
-import java.net.HttpURLConnection
-import kotlin.io.encoding.Base64
-import kotlin.io.encoding.ExperimentalEncodingApi
-
 plugins {
     `java-library`
-    `maven-publish`
-    signing
     id("com.diffplug.spotless") version "7.0.2"
+    id("com.quantori.cqp-build")
 }
 
-group = "com.quantori"
 description = "Chem query platform. Compound quick search"
 version = "0.0.10"
 
-repositories {
-    mavenLocal()
-    mavenCentral()
-}
-
-java {
-    toolchain {
-        languageVersion = JavaLanguageVersion.of(17)
-    }
-    withSourcesJar()
-    withJavadocJar()
-}
-
-publishing {
-    publications {
-        create<MavenPublication>("mavenJava") {
-            from(components["java"])
-
-            pom {
-                artifactId = "cqp-core"
-                name = project.name
-                description = project.description
-                packaging = "jar"
-                url = "https://github.com/quantori/chem-query-platform"
-
-                licenses {
-                    license {
-                        name = "The Apache License, Version 2.0"
-                        url = "https://www.apache.org/licenses/LICENSE-2.0.txt"
-                    }
-                }
-
-                developers {
-                    developer {
-                        id = "artem.chukin"
-                        name = "Artem Chukin"
-                        email = "artem.chukin@quantori.com"
-                    }
-                    developer {
-                        id = "dmitriy gusev"
-                        name = "Dmitriy Gusev"
-                        email = "dmitriy.gusev@quantori.com"
-                    }
-
-                    developer {
-                        id = "valeriy burmistrov"
-                        name = "Valeriy Burmistrov"
-                        email = "valeriy.burmistrov@quantori.com"
-                    }
-
-                    developer {
-                        id = "boris sukhodoev"
-                        name = "Boris Sukhodoev"
-                        email = "boris.sukhodoev@quantori.com"
-                    }
-                }
-
-                scm {
-                    connection = "scm:git:git://github.com/quantori/chem-query-platform.git"
-                    developerConnection = "scm:git:ssh://github.com/quantori/chem-query-platform.git"
-                    url = "https://github.com/quantori/chem-query-platform"
-                }
-            }
-        }
-    }
-    repositories {
-        maven {
-            name = "localStaging"
-            // change URLs to point to your repos, e.g. http://my.org/repo
-            val releasesRepoUrl = uri(layout.buildDirectory.dir("repos/releases"))
-            val snapshotsRepoUrl = uri(layout.buildDirectory.dir("repos/snapshots"))
-            url = if (version.toString().endsWith("SNAPSHOT")) snapshotsRepoUrl else releasesRepoUrl
-        }
-    }
-}
-
-tasks.test {
-    useJUnitPlatform()
-    testLogging {
-        events("passed", "skipped", "failed")
-    }
-}
-
-artifacts {
-    archives(tasks.named("javadocJar"))
-    archives(tasks.named("sourcesJar"))
-}
-
-signing {
-    setRequired {
-        !version.toString().endsWith("SNAPSHOT") && gradle.taskGraph.hasTask("publish")
-    }
-    val signingSecretKey = findProperty("signing.secretKey") as String? ?: System.getenv("GPG_SIGNING_SECRET_KEY")
-    val signingPassword = findProperty("signing.password") as String? ?: System.getenv("GPG_SIGNING_PASSWORD")
-
-    useInMemoryPgpKeys(signingSecretKey, signingPassword)
-    sign(publishing.publications["mavenJava"])
-    sign(configurations.archives.get())
-}
-
-// Fix Javadoc warnings on JDK 9+ (optional but recommended)
-if (JavaVersion.current().isJava9Compatible) {
-    tasks.withType<Javadoc>().configureEach {
-        (options as StandardJavadocDocletOptions).addStringOption("Xdoclint:none", "-quiet")
-        (options as StandardJavadocDocletOptions).addBooleanOption("html5", true)
-    }
-}
-
-@OptIn(ExperimentalEncodingApi::class)
-fun String.toBase64(): String {
-    return Base64.encode(this.toByteArray(Charsets.UTF_8))
-}
-
-val publishToLocalStaging = tasks.getByName("publishMavenJavaPublicationToLocalStagingRepository")
-
-publishToLocalStaging.outputs.dir(layout.buildDirectory.dir("repos/releases"))
-
-val zipBundle by tasks.registering(Zip::class) {
-    archiveFileName = "central-bundle.zip"
-    destinationDirectory = project.layout.buildDirectory.dir("distributions")
-    inputs.files(publishToLocalStaging.outputs.files)
-    from(publishToLocalStaging.outputs.files.files)
-}
-
-val uploadToMavenCentral by tasks.registering {
-    val url = uri("https://central.sonatype.com/api/v1/publisher/upload").toURL()
-    val boundary = "----WebKitFormBoundary7MA4YWxkTrZu0gW"
-    inputs.file(zipBundle.map { it.archiveFile }.get())
-    doLast {
-        val file = zipBundle.get().archiveFile.get().asFile
-        val mavenCentralUsername =
-            findProperty("mavenCentralUsername") as String? ?: System.getenv("MAVEN_CENTRAL_USERNAME")
-        val mavenCentralPassword =
-            findProperty("mavenCentralPassword") as String? ?: System.getenv("MAVEN_CENTRAL_PASSWORD")
-        val token = "$mavenCentralUsername:$mavenCentralPassword\n".toBase64()
-
-        val connection = (url.openConnection() as HttpURLConnection).apply {
-            requestMethod = "POST"
-            doOutput = true
-            setRequestProperty("Authorization", "Bearer $token")
-            setRequestProperty("Content-Type", "multipart/form-data; boundary=$boundary")
-        }
-
-        val outputStream = connection.outputStream
-        outputStream.bufferedWriter().use { writer ->
-            writer.append("--$boundary\r\n")
-            writer.append("Content-Disposition: form-data; name=\"bundle\"; filename=\"${file.name}\"\r\n")
-            writer.append("Content-Type: application/octet-stream\r\n\r\n")
-            writer.flush()
-
-            file.inputStream().use { it.copyTo(outputStream) }
-
-            writer.append("\r\n--$boundary--\r\n")
-            writer.flush()
-        }
-
-        val responseCode = connection.responseCode
-        println("Response Code: $responseCode")
-        println("Response Message: ${connection.inputStream.bufferedReader().readText()}")
-    }
-}
-
-
-
-
 dependencies {
     implementation("com.lightbend.akka.discovery:akka-discovery-aws-api_2.13:1.5.0-M1")
     implementation("com.typesafe.akka:akka-discovery_2.13:2.9.0-M2")

settings.gradle.kts

@@ -1,3 +1,7 @@
+plugins {
+    id("org.gradle.toolchains.foojay-resolver-convention") version "0.5.0"
+}
 rootProject.name = "chem-query-platform"
 
 include("cqp-core")
+includeBuild("cqp-build")