Add manual mode to skip publishing when artifact already exists

Author: countableSet

build.gradle.kts

@@ -32,7 +32,7 @@ gradlePlugin {
             id = "dev.poolside.gradle.semantic-version"
             group = "dev.poolside.gradle.semanticversion"
             implementationClass = "dev.poolside.gradle.semanticversion.SemanticVersionPlugin"
-            version = "0.1.2"
+            version = "0.1.3"
             displayName = "Poolside Semantic Version Plugin"
         }
     }

src/main/kotlin/dev/poolside/gradle/semanticversion/SemanticVersionExtension.kt

@@ -0,0 +1,5 @@
+package dev.poolside.gradle.semanticversion
+
+open class SemanticVersionExtension {
+    var manual = false
+}

src/main/kotlin/dev/poolside/gradle/semanticversion/SemanticVersionPlugin.kt

@@ -8,9 +8,11 @@ import org.gradle.kotlin.dsl.withType
 
 class SemanticVersionPlugin : Plugin<Project> {
     override fun apply(project: Project) {
+        val extension = project.extensions.create("semanticVersion", SemanticVersionExtension::class.java)
         project.tasks.register("semanticVersion", SemanticVersionTask::class.java) {
             this.description = "Determines and sets the semantic version"
             this.group = "publishing"
+            this.manual = extension.manual
         }
         project.tasks.withType<JavaCompile> {
             this.dependsOn("semanticVersion")

src/main/kotlin/dev/poolside/gradle/semanticversion/SemanticVersionTask.kt

@@ -4,6 +4,8 @@ import org.gradle.api.DefaultTask
 import org.gradle.api.internal.artifacts.repositories.ResolutionAwareRepository
 import org.gradle.api.publish.PublishingExtension
 import org.gradle.api.publish.maven.MavenPublication
+import org.gradle.api.publish.maven.tasks.PublishToMavenRepository
+import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.TaskAction
 import org.w3c.dom.Element
 
@@ -12,8 +14,19 @@ abstract class SemanticVersionTask : DefaultTask() {
     private val versionRegex = "^\\d+\\.\\d+\$".toRegex()
     private val versions = mutableMapOf<String, String>()
 
+    @Input
+    var manual: Boolean = false
+
     @TaskAction
     fun setVersion() {
+        if (manual) {
+            manual()
+        } else {
+            automatic()
+        }
+    }
+
+    private fun automatic() {
         project.allprojects.forEach { p ->
             val extension = p.extensions.getByType(PublishingExtension::class.java)
             extension.repositories.forEach {
@@ -35,6 +48,29 @@ abstract class SemanticVersionTask : DefaultTask() {
         }
     }
 
+    private fun manual() {
+        project.allprojects.forEach { p ->
+            val extension = p.extensions.getByType(PublishingExtension::class.java)
+            extension.repositories.forEach {
+                if (it is ResolutionAwareRepository) {
+                    val resolver = it.createResolver()
+                    extension.publications.forEach { publication ->
+                        val pub = publication as MavenPublication
+                        val exists = VersionFinder.versionExists(logger, project, resolver, pub)
+                        project.tasks.withType(PublishToMavenRepository::class.java).configureEach {
+                            onlyIf {
+                                if (exists) {
+                                    logger.lifecycle("Resolved published version of '${publication.groupId}:${publication.artifactId}:${publication.version}' already exists")
+                                }
+                                !exists
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     private fun checkVersion(version: String) {
         if (!versionRegex.matches(version)) {
             throw IllegalArgumentException("Invalid version, must be in format $versionRegex")

src/main/kotlin/dev/poolside/gradle/semanticversion/VersionFinder.kt

@@ -19,21 +19,9 @@ object VersionFinder {
     private val versionComparator = DefaultVersionComparator().asVersionComparator()
 
     fun findVersion(logger: Logger, project: Project, resolver: ConfiguredModuleComponentRepository, publication: MavenPublication): Pair<String, String> {
-        val remote = resolver.remoteAccess
-        val local = resolver.localAccess
-
-        val dep = project.dependencies.create(group = publication.groupId, name = publication.artifactId, version = "${publication.version}+")
-        val selector = DefaultModuleComponentSelector.newSelector(dep.module, dep.versionConstraint)
-        val metadata = GradleDependencyMetadata(selector, Collections.emptyList(), false, false, null, false, null)
-
-        val result = DefaultBuildableModuleVersionListingResolveResult()
-        remote.listModuleVersions(metadata, result)
-        local.listModuleVersions(metadata, result)
-
-        logger.debug("Resolved versions ${result.versions}")
-
+        val versions = listVersions(logger, project, resolver, publication, "${publication.version}+")
         var latestVersion: Version? = null
-        result.versions.map { version -> versionParser.transform(version) }.forEach { version ->
+        versions.map { version -> versionParser.transform(version) }.forEach { version ->
             if (latestVersion == null || versionComparator.compare(version, latestVersion) > 0) {
                 latestVersion = version
             }
@@ -51,6 +39,28 @@ object VersionFinder {
         return "${publication.groupId}:${publication.artifactId}" to version
     }
 
+    fun versionExists(logger: Logger, project: Project, resolver: ConfiguredModuleComponentRepository, publication: MavenPublication): Boolean {
+        val versions = listVersions(logger, project, resolver, publication, publication.version)
+        return versions.contains(publication.version)
+    }
+
+    private fun listVersions(logger: Logger, project: Project, resolver: ConfiguredModuleComponentRepository, publication: MavenPublication, versionSearch: String): Set<String> {
+        val remote = resolver.remoteAccess
+        val local = resolver.localAccess
+
+        val dep = project.dependencies.create(group = publication.groupId, name = publication.artifactId, version = versionSearch)
+        val selector = DefaultModuleComponentSelector.newSelector(dep.module, dep.versionConstraint)
+        val metadata = GradleDependencyMetadata(selector, Collections.emptyList(), false, false, null, false, null)
+
+        val result = DefaultBuildableModuleVersionListingResolveResult()
+        remote.listModuleVersions(metadata, result)
+        local.listModuleVersions(metadata, result)
+
+        logger.debug("Resolved versions ${result.versions}")
+
+        return result.versions
+    }
+
     private fun incrementVersion(version: Version): String {
         val parts = version.numericParts.filterNotNull()
         val last = parts.last() + 1

src/test/kotlin/dev/poolside/gradle/semanticversion/SemanticVersionPluginTest.kt

@@ -4,9 +4,11 @@ import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.DefaultV
 import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.Version
 import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.VersionParser
 import org.gradle.testkit.runner.GradleRunner
+import org.gradle.testkit.runner.TaskOutcome
 import org.gradle.testkit.runner.TaskOutcome.FAILED
 import org.gradle.testkit.runner.UnexpectedBuildFailure
 import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertFalse
 import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Assertions.fail
 import org.junit.jupiter.api.Test
@@ -343,4 +345,65 @@ class SemanticVersionPluginTest {
         }
         assertEquals("0.1.2", latestVersion.toString())
     }
+
+    @Test
+    fun `manual versioning`() {
+        val build = """
+            plugins {
+                java
+                `maven-publish`
+                id("dev.poolside.gradle.semantic-version")
+            }
+            repositories {
+                maven { url = uri("${mavenRepo.absolutePath}") }
+            }
+            group = "dev.poolside.test"
+            version = "0.1.0"
+            semanticVersion {
+                manual = true
+            }
+            publishing {
+                repositories {
+                    maven { url = uri("${mavenRepo.absolutePath}") }
+                }
+                publications {
+                    create<MavenPublication>("mavenJava") {
+                        artifactId = "my-library"
+                        from(components["java"])
+                    }
+                }
+            }
+        """.trimIndent()
+        val settings = """rootProject.name = "testing""""
+        File(testProjectDir, "build.gradle.kts").writeText(build)
+        File(testProjectDir, "settings.gradle.kts").writeText(settings)
+        GradleRunner.create()
+            .withPluginClasspath()
+            .withProjectDir(testProjectDir)
+            .withArguments("publish")
+//            .withDebug(true)
+            .build()
+        var pomFile = testProjectDir.walk().filter { it.name.startsWith("pom") }.first()
+        var pom = PomParser.parse(pomFile.absolutePath)
+        assertEquals("0.1.0", pom.version)
+        var jarFile = mavenRepo.walk().filter { it.name.endsWith("jar") }.first()
+        assertTrue(jarFile.absolutePath.endsWith("/dev/poolside/test/my-library/0.1.0/my-library-0.1.0.jar"))
+        val publishedPom = mavenRepo.walk().filter { it.name.equals("my-library-0.1.0.pom") }.first()
+        pom = PomParser.parse(publishedPom.absolutePath)
+        assertEquals("0.1.0", pom.version)
+
+        // should skip
+        val result = GradleRunner.create()
+            .withPluginClasspath()
+            .withProjectDir(testProjectDir)
+            .withArguments("publish")
+//            .withDebug(true)
+            .build()
+        assertEquals(1, result.taskPaths(TaskOutcome.SKIPPED).size)
+        pomFile = testProjectDir.walk().filter { it.name.startsWith("pom") }.last()
+        pom = PomParser.parse(pomFile.absolutePath)
+        assertEquals("0.1.0", pom.version)
+        jarFile = mavenRepo.walk().filter { it.name.endsWith("jar") }.last()
+        assertFalse(jarFile.absolutePath.endsWith("/dev/poolside/test/my-library/0.1.1/my-library-0.1.1.jar"))
+    }
 }