add support for multiple repositories in publishing definition

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

@@ -2,6 +2,7 @@ package dev.poolside.gradle.semanticversion
 
 import org.gradle.api.DefaultTask
 import org.gradle.api.internal.artifacts.DependencyManagementServices
+import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.Version
 import org.gradle.api.internal.artifacts.repositories.ResolutionAwareRepository
 import org.gradle.api.publish.PublishingExtension
 import org.gradle.api.publish.maven.MavenPublication
@@ -37,17 +38,21 @@ abstract class SemanticVersionTask : DefaultTask() {
     }
 
     private fun automatic() {
-        extension.repositories.forEach {
-            if (it is ResolutionAwareRepository) {
-                val resolver = it.createResolver()
-                extension.publications.forEach { publication ->
-                    val pub = publication as MavenPublication
-                    checkVersion(pub.version)
-                    val (key, version) = VersionFinder.findVersion(logger, dependencyService, resolver, pub)
-                    pub.version = version
-                    versions[key] = version
+        extension.publications.forEach { publication ->
+            val pub = publication as MavenPublication
+            checkVersion(pub.version)
+            val fetchedVersions = mutableListOf<Version>()
+            extension.repositories.forEach {
+                if (it is ResolutionAwareRepository) {
+                    val resolver = it.createResolver()
+                    val version = VersionFinder.findVersion(logger, dependencyService, resolver, pub)
+                    fetchedVersions.add(version)
                 }
             }
+            val max = VersionFinder.findMaxVersion(fetchedVersions)
+            val key = "${pub.groupId}:${pub.artifactId}"
+            pub.version = max.toString()
+            versions[key] = max.toString()
         }
         extension.publications.forEach { publication ->
             val pub = publication as MavenPublication

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

@@ -18,7 +18,7 @@ object VersionFinder {
     private val versionParser = VersionParser()
     private val versionComparator = DefaultVersionComparator().asVersionComparator()
 
-    fun findVersion(logger: Logger, dependencyService: DependencyManagementServices, resolver: ConfiguredModuleComponentRepository, publication: MavenPublication): Pair<String, String> {
+    fun findVersion(logger: Logger, dependencyService: DependencyManagementServices, resolver: ConfiguredModuleComponentRepository, publication: MavenPublication): Version {
         val versions = listVersions(logger, dependencyService, resolver, publication, "${publication.version}+")
         var latestVersion: Version? = null
         versions.map { version -> versionParser.transform(version) }.forEach { version ->
@@ -36,7 +36,7 @@ object VersionFinder {
             logger.lifecycle("Resolved published version of '${publication.groupId}:${publication.artifactId}:${publication.version}' to '$newVersion'")
             newVersion
         }
-        return "${publication.groupId}:${publication.artifactId}" to version
+        return VersionParser().transform(version)
     }
 
     fun versionExists(logger: Logger, dependencyService: DependencyManagementServices, resolver: ConfiguredModuleComponentRepository, publication: MavenPublication): Boolean {
@@ -74,4 +74,14 @@ object VersionFinder {
         val last = parts.last() + 1
         return parts.dropLast(1).joinToString(".") + ".$last"
     }
+
+    fun findMaxVersion(versions: List<Version>): Version {
+        var max = versions[0]
+        for (version in versions) {
+            if (versionComparator.compare(version, max) > 0) {
+                max = version
+            }
+        }
+        return max
+    }
 }

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

@@ -33,6 +33,8 @@ class SemanticVersionPluginTest {
     lateinit var testProjectDir: File
     @TempDir
     lateinit var mavenRepo: File
+    @TempDir
+    lateinit var secondMavenRepo: File
 
     @ParameterizedTest(name = "{index} gradle version {0}")
     @MethodSource("gradleVersions")
@@ -97,6 +99,70 @@ class SemanticVersionPluginTest {
         assertEquals("0.1.1", pom.version)
     }
 
+    @ParameterizedTest(name = "{index} gradle version {0}")
+    @MethodSource("gradleVersions")
+    fun `project version set correctly with two repos`(gradleVersion: String) {
+        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"
+            publishing {
+                repositories {
+                    maven { url = uri("${mavenRepo.absolutePath}") }
+                    maven { url = uri("${secondMavenRepo.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)
+            .withGradleVersion(gradleVersion)
+            .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("my-library-0.1.0.jar") }.first()
+        assertTrue(jarFile.absolutePath.endsWith("/dev/poolside/test/my-library/0.1.0/my-library-0.1.0.jar"), jarFile.absolutePath)
+        var 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 +1
+        GradleRunner.create()
+            .withPluginClasspath()
+            .withProjectDir(testProjectDir)
+            .withGradleVersion(gradleVersion)
+            .withArguments("publish")
+//            .withDebug(true)
+            .build()
+        pomFile = testProjectDir.walk().filter { it.name.startsWith("pom") }.last()
+        pom = PomParser.parse(pomFile.absolutePath)
+        assertEquals("0.1.1", pom.version)
+        jarFile = mavenRepo.walk().filter { it.name.endsWith("my-library-0.1.1.jar") }.last()
+        assertTrue(jarFile.absolutePath.endsWith("/dev/poolside/test/my-library/0.1.1/my-library-0.1.1.jar"), jarFile.absolutePath)
+        publishedPom = mavenRepo.walk().filter { it.name.equals("my-library-0.1.1.pom") }.last()
+        pom = PomParser.parse(publishedPom.absolutePath)
+        assertEquals("0.1.1", pom.version)
+    }
+
     @ParameterizedTest(name = "{index} gradle version {0}")
     @MethodSource("gradleVersions")
     fun `minor version bump`(gradleVersion: String) {