diff --git a/README.adoc b/README.adoc deleted file mode 100644 index 891365d..0000000 --- a/README.adoc +++ /dev/null @@ -1,14 +0,0 @@ -= Semantic Version Gradle Plugin - -* link:https://semantic-version.gradle.poolside.dev/[docs] -* link:https://plugins.gradle.org/plugin/dev.poolside.gradle.semantic-version[plugin site] - -tldr: determines and sets patch version based on what already exists in maven repository. - -[source,kotlin] ----- -plugins { - `maven-publish` - id("dev.poolside.gradle.semantic-version") version "" -} ----- diff --git a/README.md b/README.md new file mode 100644 index 0000000..1fb6bf1 --- /dev/null +++ b/README.md @@ -0,0 +1,13 @@ +# Semantic Version Gradle Plugin + +* [docs](https://github.com/countableSet/semantic-version-plugin/tree/main/docs) +* [gradle plugin portal](https://plugins.gradle.org/plugin/dev.poolside.gradle.semantic-version) + +Based on a given `major.minor` version, plugin determines patch version based on what is already maven repository by auto incrementing it to produce the next version number. Major or minor versions must be manually changed. + +```groovy +plugins { + id 'maven-publish' + id 'dev.poolside.gradle.semantic-version' version '' +} +``` diff --git a/build.gradle.kts b/build.gradle.kts index 621ee84..e381293 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -19,7 +19,7 @@ dependencies { } gradlePlugin { - website.set("https://semantic-version.gradle.poolside.dev") + website.set("https://github.com/countableSet/semantic-version-plugin") vcsUrl.set("https://github.com/countableSet/semantic-version-plugin") plugins { @@ -31,7 +31,7 @@ gradlePlugin { displayName = "Poolside Semantic Version Plugin" description = "Based on a given major.minor version, plugin determines patch version based on what is already " + "maven repository by auto incrementing it to produce the next version number. Major or minor versions " + - "must be manually changed" + "must be manually changed." tags.set(listOf("semantic version", "maven", "publish", "auto increment")) } } diff --git a/docs/README.md b/docs/README.md new file mode 100644 index 0000000..27b1048 --- /dev/null +++ b/docs/README.md @@ -0,0 +1,109 @@ + + + +**Table of Contents** + +- [Change Log](#change-log) +- [Usage](#usage) + - [Auto mode](#auto-mode) + - [Manual mode](#manual-mode) +- [Gradle Version Requirement](#gradle-version-requirement) + + + +Gradle plugin to auto-increments the patch version on each call to the `publish` task by looking up the most recent version published in the publishing maven repository and adds it by one. + +Tested to work in the following scenarios: + +* Single root project publication +* Single and multiple subprojects publication +* BOM references via `api(platform(project(":bom")))` and `java-platform` plugin +* Manual versioning, prevents the task from publishing if the version isn't different from the one in maven + +![example](semantic-version-plugin.svg) + +## Change Log + +See [releases](https://github.com/countableSet/semantic-version-plugin/releases) for changes. + +## Usage + +[Plugins Portal](https://plugins.gradle.org/plugin/dev.poolside.gradle.semantic-version) + +```kotlin +plugins { + `maven-publish` + id("dev.poolside.gradle.semantic-version") version "{version}" +} +``` + +```sh +$ ./gradlw publish +[...] +> Task :semanticVersion +Resolved published version of 'dev.poolside.test:my-library:0.1.4' to '0.1.5' +[...] +``` + +### Auto mode + +Basic full example, but it can also be used for subprojects and bom subprojects. However, make sure the publication version number is in the format of `[\d]+\.[\d]+`. + +```kotlin +plugins { + java + `maven-publish` + id("dev.poolside.gradle.semantic-version") version "{version}" +} +repositories { + mavenCentral() +} + +group = "dev.poolside.test" +version = "0.1" + +publishing { + publications { + create("mavenJava") { + artifactId = "my-library" + from(components["java"]) + } + } +} +``` + +### Manual mode + +If there's a scenario in which you want to manually increment the semantic version. Therefore, the plugin will disable publishing if the version already exists in the repository. + +```kotlin +semanticVersion { + manual = true +} +``` + +## Gradle Version Requirement + +The plugin now requires Gradle version 8.13+ to access new methods and public api changes from gradle. + +```sh +❯ gr semanticVersion +> Task :client:semanticVersion FAILED + +FAILURE: Build failed with an exception. + +* What went wrong: + Execution failed for task ':client:semanticVersion'. +> org/gradle/api/internal/initialization/StandaloneDomainObjectContext + +* Try: +> Run with --stacktrace option to get the stack trace. +> Run with --info or --debug option to get more log output. +> Run with --scan to get full insights. +> Get more help at https://help.gradle.org. + +BUILD FAILED in 1s +2 actionable tasks: 2 executed +``` diff --git a/docs/antora.yml b/docs/antora.yml deleted file mode 100644 index f9df2a5..0000000 --- a/docs/antora.yml +++ /dev/null @@ -1,6 +0,0 @@ -name: ROOT -title: Semantic Version Plugin -version: ~ -nav: - - modules/ROOT/nav.adoc - - modules/research/nav.adoc diff --git a/docs/development.md b/docs/development.md new file mode 100644 index 0000000..9df37c5 --- /dev/null +++ b/docs/development.md @@ -0,0 +1,92 @@ + + + +**Table of Contents** + +- [Development](#development) +- [Gradle Plugin Publishing](#gradle-plugin-publishing) +- [References](#references) + - [General](#general) + - [pom.withXml](#pomwithxml) + + + +## Development + +[Gradle docs](https://docs.gradle.org/current/userguide/writing_plugins.html) on writing plugins. + +Publish to mavenLocal + +```sh +❯ gr publishToMavenLocal + +BUILD SUCCESSFUL in 5s +11 actionable tasks: 8 executed, 3 up-to-date +``` + +Add to `settings.gradle` file in client project and change the version `id 'dev.poolside.gradle.semantic-version' version '1.0.0'` + +```groovy +pluginManagement { + repositories { + mavenLocal() + } +} +``` + +## Gradle Plugin Publishing + +* [plugin docs](https://plugins.gradle.org/docs/publish-plugin-new) +* [user account](https://plugins.gradle.org/u/poolside) + + +It's easier to set up credentials via the login task then doing it manually in the gradle.properties file + +```sh +❯ gr login +``` + +Then run the publishing task: + +```sh +❯ gr publishPlugins + +> Task :publishPlugins +Publishing plugin dev.poolside.gradle.semantic-version version 0.1.0 +Thank you. Your new plugin dev.poolside.gradle.semantic-version has been submitted for approval by Gradle engineers. The request should be processed within the next few days, at which point you will be contacted via email. +Publishing artifact build/publications/pluginMaven/module.json +Publishing artifact build/publications/pluginMaven/pom-default.xml +Publishing artifact build/libs/semantic-version-plugin-0.1.0.jar +Publishing artifact build/libs/semantic-version-plugin-0.1.0-sources.jar +Publishing artifact build/libs/semantic-version-plugin-0.1.0-javadoc.jar +Activating plugin dev.poolside.gradle.semantic-version version 0.1.0 + +Deprecated Gradle features were used in this build, making it incompatible with Gradle 8.0. + +You can use '--warning-mode all' to show the individual deprecation warnings and determine if they come from your own scripts or plugins. + +See https://docs.gradle.org/7.4.2/userguide/command_line_interface.html#sec:command_line_warnings + +BUILD SUCCESSFUL in 5s +10 actionable tasks: 7 executed, 3 up-to-date +``` + +## References + +Information that I found helpful when writing this plugin + +### General + +* https://github.com/nebula-plugins/nebula-publishing-plugin + * [MavenResolvedDependenciesPlugin](https://github.com/nebula-plugins/nebula-publishing-plugin/blob/aee3fb093c622e7b7c9eb75cb6dc2838c2bcf340/src/main/groovy/nebula/plugin/publishing/maven/MavenResolvedDependenciesPlugin.groovy) +* [editing pom info](https://stackoverflow.com/questions/20959558/in-gradle-how-can-i-generate-a-pom-file-with-dynamic-dependencies-resolved-to-t) + +### pom.withXml + +Editing groovy dom nodes/nodelists/etc is a pain in kotlin. I found these links helpful. + +* [kotlinx.dom](https://github.com/Kotlin/kotlinx.dom/blob/0fe219d942047468b361dc0594f1c443ebcf26c3/src/main/kotlin/Dom.kt) +* [kotlin-dsl-sample issue](https://github.com/gradle/kotlin-dsl-samples/issues/225) +* [groovy example](https://github.com/nebula-plugins/nebula-publishing-plugin/blob/575b55c72151e0fae35c4aea69ff77ae8db57455/src/main/groovy/nebula/plugin/publishing/maven/MavenRemoveInvalidDependenciesPlugin.groovy) diff --git a/docs/modules/ROOT/nav.adoc b/docs/modules/ROOT/nav.adoc deleted file mode 100644 index 31f850e..0000000 --- a/docs/modules/ROOT/nav.adoc +++ /dev/null @@ -1 +0,0 @@ -* xref:index.adoc[] diff --git a/docs/modules/ROOT/pages/index.adoc b/docs/modules/ROOT/pages/index.adoc deleted file mode 100644 index 9ea4aee..0000000 --- a/docs/modules/ROOT/pages/index.adoc +++ /dev/null @@ -1,87 +0,0 @@ -= Home -:version: 0.2.0 - -Gradle plugin to auto-increments the patch version on each call to the `publish` task by looking up the most recent version published in the publishing maven repository and adds it by one. - -Tested to work in the following scenarios: - -. Single root project publication -. Single and multiple subprojects publication -. BOM references via `api(platform(project(":bom")))` and `java-platform` plugin -. Manual versioning, prevents the task from publishing if the version isn't different from the one in maven - -image::semantic-version-plugin.svg[] - -== Change Log - -* 0.2.x compatible with Java 11 -** 0.2.0 set compatability to Java 11, bump dependency versions, and upgrade gradle to 8.1 -* 0.1.x compatible with Java 8 -** 0.1.5 fix bug when the plugin wasn't applying correct to root projects without jars -** 0.1.4 fix bug when major or minor version was bump was computed incorrectly -** 0.1.3 adds manual mode flag to skip publishing when artifact already exists -** 0.1.2 fix bug with version finder -** 0.1.1 unknown -** 0.1.0 unknown - -== Import - -link:https://plugins.gradle.org/plugin/dev.poolside.gradle.semantic-version[Plugins Page] - -[source,kotlin,subs="attributes"] ----- -plugins { - `maven-publish` - id("dev.poolside.gradle.semantic-version") version "{version}" -} ----- - -[source,bash] ----- -$ ./gradlw publish -[...] -> Task :semanticVersion -Resolved published version of 'dev.poolside.test:my-library:0.1.4' to '0.1.5' -[...] ----- - -== Usage - -=== Auto mode - -Basic full example, but it can also be used for subprojects and bom subprojects. However, make sure the publication version number is in the format of `[\d]+\.[\d]+`. - -[source,kotlin,subs="attributes"] ----- -plugins { - java - `maven-publish` - id("dev.poolside.gradle.semantic-version") version "{version}" -} -repositories { - mavenCentral() -} - -group = "dev.poolside.test" -version = "0.1" - -publishing { - publications { - create("mavenJava") { - artifactId = "my-library" - from(components["java"]) - } - } -} ----- - -=== Manual mode - -If there's a scenario in which you want to manually increment the semantic version. Therefore, the plugin will disable publishing if the version already exists in the repository. - -[source,kotlin] ----- -semanticVersion { - manual = true -} ----- diff --git a/docs/modules/research/nav.adoc b/docs/modules/research/nav.adoc deleted file mode 100644 index 4accf55..0000000 --- a/docs/modules/research/nav.adoc +++ /dev/null @@ -1,2 +0,0 @@ -* xref:references.adoc[] -* xref:gradle-plugin.adoc[] diff --git a/docs/modules/research/pages/gradle-plugin.adoc b/docs/modules/research/pages/gradle-plugin.adoc deleted file mode 100644 index 7fd5bb3..0000000 --- a/docs/modules/research/pages/gradle-plugin.adoc +++ /dev/null @@ -1,38 +0,0 @@ -= Gradle Plugin Publishing - -* link:https://plugins.gradle.org/docs/publish-plugin-new[plugin docs] -* link:https://plugins.gradle.org/u/poolside[user account] - - -It's easier to setup credentials via the login task then doing it manually in the gradle.properties file - -[source,bash] ----- -❯ gr login ----- - -Then run the publish task: - -[source,bash] ----- -❯ gr publishPlugins - -> Task :publishPlugins -Publishing plugin dev.poolside.gradle.semantic-version version 0.1.0 -Thank you. Your new plugin dev.poolside.gradle.semantic-version has been submitted for approval by Gradle engineers. The request should be processed within the next few days, at which point you will be contacted via email. -Publishing artifact build/publications/pluginMaven/module.json -Publishing artifact build/publications/pluginMaven/pom-default.xml -Publishing artifact build/libs/semantic-version-plugin-0.1.0.jar -Publishing artifact build/libs/semantic-version-plugin-0.1.0-sources.jar -Publishing artifact build/libs/semantic-version-plugin-0.1.0-javadoc.jar -Activating plugin dev.poolside.gradle.semantic-version version 0.1.0 - -Deprecated Gradle features were used in this build, making it incompatible with Gradle 8.0. - -You can use '--warning-mode all' to show the individual deprecation warnings and determine if they come from your own scripts or plugins. - -See https://docs.gradle.org/7.4.2/userguide/command_line_interface.html#sec:command_line_warnings - -BUILD SUCCESSFUL in 5s -10 actionable tasks: 7 executed, 3 up-to-date ----- diff --git a/docs/modules/research/pages/references.adoc b/docs/modules/research/pages/references.adoc deleted file mode 100644 index 38f9a85..0000000 --- a/docs/modules/research/pages/references.adoc +++ /dev/null @@ -1,17 +0,0 @@ -= References - -Information that I found helpful when writing this plugin - -== General - -. link:https://github.com/nebula-plugins/nebula-publishing-plugin[] -.. link:https://github.com/nebula-plugins/nebula-publishing-plugin/blob/aee3fb093c622e7b7c9eb75cb6dc2838c2bcf340/src/main/groovy/nebula/plugin/publishing/maven/MavenResolvedDependenciesPlugin.groovy[MavenResolvedDependenciesPlugin] -. link:https://stackoverflow.com/questions/20959558/in-gradle-how-can-i-generate-a-pom-file-with-dynamic-dependencies-resolved-to-t[editing pom info] - -== pom.withXml - -Editing groovy dom nodes/nodelists/etc is a pain in kotlin. I found these links helpful. - -. link:https://github.com/Kotlin/kotlinx.dom/blob/0fe219d942047468b361dc0594f1c443ebcf26c3/src/main/kotlin/Dom.kt[kotlinx.dom] -. link:https://github.com/gradle/kotlin-dsl-samples/issues/225[kotlin-dsl-sample issue] -. link:https://github.com/nebula-plugins/nebula-publishing-plugin/blob/575b55c72151e0fae35c4aea69ff77ae8db57455/src/main/groovy/nebula/plugin/publishing/maven/MavenRemoveInvalidDependenciesPlugin.groovy[groovy example] diff --git a/docs/modules/ROOT/images/semantic-version-plugin.svg b/docs/semantic-version-plugin.svg similarity index 100% rename from docs/modules/ROOT/images/semantic-version-plugin.svg rename to docs/semantic-version-plugin.svg diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar index e644113..a4b76b9 100644 Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index cea7a79..37f853b 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,6 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-8.12-bin.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip networkTimeout=10000 validateDistributionUrl=true zipStoreBase=GRADLE_USER_HOME diff --git a/gradlew b/gradlew index b740cf1..f3b75f3 100755 --- a/gradlew +++ b/gradlew @@ -15,6 +15,8 @@ # See the License for the specific language governing permissions and # limitations under the License. # +# SPDX-License-Identifier: Apache-2.0 +# ############################################################################## # @@ -84,7 +86,7 @@ done # shellcheck disable=SC2034 APP_BASE_NAME=${0##*/} # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) -APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit +APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit # Use the maximum available, or set MAX_FD != -1 to use that value. MAX_FD=maximum diff --git a/gradlew.bat b/gradlew.bat index 7101f8e..9b42019 100755 --- a/gradlew.bat +++ b/gradlew.bat @@ -13,6 +13,8 @@ @rem See the License for the specific language governing permissions and @rem limitations under the License. @rem +@rem SPDX-License-Identifier: Apache-2.0 +@rem @if "%DEBUG%"=="" @echo off @rem ########################################################################## diff --git a/src/main/kotlin/dev/poolside/gradle/semanticversion/SemanticVersionPlugin.kt b/src/main/kotlin/dev/poolside/gradle/semanticversion/SemanticVersionPlugin.kt index 8e64c28..de65866 100644 --- a/src/main/kotlin/dev/poolside/gradle/semanticversion/SemanticVersionPlugin.kt +++ b/src/main/kotlin/dev/poolside/gradle/semanticversion/SemanticVersionPlugin.kt @@ -2,17 +2,23 @@ package dev.poolside.gradle.semanticversion import org.gradle.api.Plugin import org.gradle.api.Project +import org.gradle.api.publish.PublishingExtension import org.gradle.api.publish.maven.tasks.GenerateMavenPom +import org.gradle.api.publish.maven.tasks.PublishToMavenRepository import org.gradle.api.tasks.compile.JavaCompile import org.gradle.kotlin.dsl.withType class SemanticVersionPlugin : Plugin { override fun apply(project: Project) { val extension = project.extensions.create("semanticVersion", SemanticVersionExtension::class.java) + val pubExtension = project.extensions.getByType(PublishingExtension::class.java) + val pubTasks = project.tasks.withType(PublishToMavenRepository::class.java) project.tasks.register("semanticVersion", SemanticVersionTask::class.java) { this.description = "Determines and sets the semantic version" this.group = "publishing" this.manual = extension.manual + this.extension = pubExtension + this.tasks = pubTasks } project.tasks.withType { this.dependsOn("semanticVersion") diff --git a/src/main/kotlin/dev/poolside/gradle/semanticversion/SemanticVersionTask.kt b/src/main/kotlin/dev/poolside/gradle/semanticversion/SemanticVersionTask.kt index 856d62b..a358e1e 100644 --- a/src/main/kotlin/dev/poolside/gradle/semanticversion/SemanticVersionTask.kt +++ b/src/main/kotlin/dev/poolside/gradle/semanticversion/SemanticVersionTask.kt @@ -1,22 +1,32 @@ package dev.poolside.gradle.semanticversion import org.gradle.api.DefaultTask +import org.gradle.api.internal.artifacts.DependencyManagementServices 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.gradle.api.tasks.TaskCollection import org.w3c.dom.Element +import javax.inject.Inject abstract class SemanticVersionTask : DefaultTask() { private val versionRegex = "^\\d+\\.\\d+\$".toRegex() private val versions = mutableMapOf() + @Input + lateinit var extension: PublishingExtension + @Input + lateinit var tasks: TaskCollection @Input var manual: Boolean = false + @get:Inject + abstract val dependencyService: DependencyManagementServices + @TaskAction fun setVersion() { if (manual) { @@ -27,43 +37,37 @@ abstract class SemanticVersionTask : DefaultTask() { } private fun automatic() { - 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 - checkVersion(pub.version) - val (key, version) = VersionFinder.findVersion(logger, project, resolver, pub) - pub.version = version - versions[key] = version - } + 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 - rewrite(pub) - } + } + extension.publications.forEach { publication -> + val pub = publication as MavenPublication + rewrite(pub) } } 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 + 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, dependencyService, resolver, pub) + tasks.configureEach { + onlyIf { + if (exists) { + logger.lifecycle("Resolved published version of '${publication.groupId}:${publication.artifactId}:${publication.version}' already exists") } + !exists } } } @@ -102,4 +106,4 @@ abstract class SemanticVersionTask : DefaultTask() { } } } -} \ No newline at end of file +} diff --git a/src/main/kotlin/dev/poolside/gradle/semanticversion/VersionFinder.kt b/src/main/kotlin/dev/poolside/gradle/semanticversion/VersionFinder.kt index fbb00b5..5046648 100644 --- a/src/main/kotlin/dev/poolside/gradle/semanticversion/VersionFinder.kt +++ b/src/main/kotlin/dev/poolside/gradle/semanticversion/VersionFinder.kt @@ -1,25 +1,25 @@ package dev.poolside.gradle.semanticversion -import org.gradle.api.Project +import org.gradle.api.internal.artifacts.DependencyManagementServices import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.ConfiguredModuleComponentRepository import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.DefaultVersionComparator import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.Version import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.VersionParser +import org.gradle.api.internal.initialization.StandaloneDomainObjectContext import org.gradle.api.logging.Logger import org.gradle.api.publish.maven.MavenPublication import org.gradle.internal.component.external.model.DefaultModuleComponentSelector -import org.gradle.internal.component.external.model.GradleDependencyMetadata +import org.gradle.internal.component.model.DefaultComponentOverrideMetadata import org.gradle.internal.resolve.result.DefaultBuildableModuleVersionListingResolveResult import org.gradle.kotlin.dsl.create -import java.util.Collections object VersionFinder { private val versionParser = VersionParser() private val versionComparator = DefaultVersionComparator().asVersionComparator() - fun findVersion(logger: Logger, project: Project, resolver: ConfiguredModuleComponentRepository, publication: MavenPublication): Pair { - val versions = listVersions(logger, project, resolver, publication, "${publication.version}+") + fun findVersion(logger: Logger, dependencyService: DependencyManagementServices, resolver: ConfiguredModuleComponentRepository, publication: MavenPublication): Pair { + val versions = listVersions(logger, dependencyService, resolver, publication, "${publication.version}+") var latestVersion: Version? = null versions.map { version -> versionParser.transform(version) }.forEach { version -> if (latestVersion == null || versionComparator.compare(version, latestVersion) > 0) { @@ -39,22 +39,22 @@ 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) + fun versionExists(logger: Logger, dependencyService: DependencyManagementServices, resolver: ConfiguredModuleComponentRepository, publication: MavenPublication): Boolean { + val versions = listVersions(logger, dependencyService, resolver, publication, publication.version) return versions.contains(publication.version) } - private fun listVersions(logger: Logger, project: Project, resolver: ConfiguredModuleComponentRepository, publication: MavenPublication, versionSearch: String): Set { + private fun listVersions(logger: Logger, dependencyService: DependencyManagementServices, resolver: ConfiguredModuleComponentRepository, publication: MavenPublication, versionSearch: String): Set { val remote = resolver.remoteAccess val local = resolver.localAccess - val dep = project.dependencies.create(group = publication.groupId, name = publication.artifactId, version = versionSearch) + val handler = dependencyService.newDetachedResolver(StandaloneDomainObjectContext.ANONYMOUS).dependencyHandler + val dep = handler.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) + remote.listModuleVersions(selector, DefaultComponentOverrideMetadata.EMPTY, result) + local.listModuleVersions(selector, DefaultComponentOverrideMetadata.EMPTY, result) logger.debug("Resolved versions ${result.versions}") diff --git a/src/test/kotlin/dev/poolside/gradle/semanticversion/SemanticVersionPluginTest.kt b/src/test/kotlin/dev/poolside/gradle/semanticversion/SemanticVersionPluginTest.kt index b0a2fe2..adcc5a8 100644 --- a/src/test/kotlin/dev/poolside/gradle/semanticversion/SemanticVersionPluginTest.kt +++ b/src/test/kotlin/dev/poolside/gradle/semanticversion/SemanticVersionPluginTest.kt @@ -25,10 +25,7 @@ class SemanticVersionPluginTest { companion object { @JvmStatic private fun gradleVersions(): Stream = Stream.of( - Arguments.of("7.6.1"), - Arguments.of("8.1"), - Arguments.of("8.8"), - Arguments.of("8.12"), + Arguments.of("8.13"), ) } @@ -322,6 +319,7 @@ class SemanticVersionPluginTest { plugins { `java-library` `maven-publish` + id("dev.poolside.gradle.semantic-version") } repositories { mavenCentral() @@ -578,6 +576,7 @@ class SemanticVersionPluginTest { plugins { `java-library` `maven-publish` + id("dev.poolside.gradle.semantic-version") } repositories { mavenCentral() @@ -603,6 +602,7 @@ class SemanticVersionPluginTest { plugins { `java-platform` `maven-publish` + id("dev.poolside.gradle.semantic-version") } repositories { mavenCentral()