Merge pull request #83 from simonhauck/16-support-alpha-beta-and-rc-releases-for-automatic-version-release

#16 Add support for releases with a pre-release type

Author: simonhauck

README.md

@@ -68,10 +68,19 @@ You can set the release and post-release version explicitly with the following g
 Alternately, if you have a [semver](https://semver.org/) compatible version you can use the simplified API:
 
 ```shell
+# Current version: 1.0.0, release-type=major -> Release Version: 2.0.0, Post Release Version: 2.0.1-SNAPSHOT
 ./gradlew release -PreleaseType=<release-type>
+
+# Or 
+
+# Current version: 1.0.0, release-type=major, preReleaseType=RC -> Release Version: 2.0.0-RC1, Post Release Version: 1.0.0
+./gradlew release -PreleaseType=<release-type> -PpreReleaseType=<pre-release-type>
 ```
 
 Replace the _release-type_ with ``major``, ``minor`` or ``patch``. This will determine the version automatically.
+The _pre-release-type_ is an optional string (e.g. ALPHA). If set, the plugin will automatically apply a counter based
+on the existing git tags and set the post release version back to the current project version, so when you create the "
+final" release, you can select the same release type - just without the _pre-release-type_.
 
 ### What does the plugin do?
 

release-plugin/src/main/kotlin/io/github/simonhauck/release/git/api/GitCommandApi.kt

@@ -38,6 +38,8 @@ interface GitCommandApi {
 
     fun tag(tagName: String, tagMessage: String): GitVoidResult
 
+    fun fetchRemoteTags(): GitVoidResult
+
     fun listTags(): GitResult<List<String>>
 
     fun deleteLocalTag(tagName: String): GitVoidResult

release-plugin/src/main/kotlin/io/github/simonhauck/release/git/api/GitCommandResult.kt

@@ -1,6 +1,7 @@
 package io.github.simonhauck.release.git.api
 
 import arrow.core.Either
+import org.gradle.api.GradleException
 
 typealias GitVoidResult = Either<GitError, GitOk>
 
@@ -29,4 +30,11 @@ data class GitStatusResult(
     fun notEmpty() = !allEmpty()
 }
 
-fun Either<GitError, *>.isOk(): Boolean = isRight()
+internal fun Either<GitError, *>.isOk(): Boolean = isRight()
+
+internal fun <T> GitResult<T>.getOrThrowGradleException(): T {
+    return when (this) {
+        is Either.Left -> throw GradleException(this.value.message, this.value.throwable)
+        is Either.Right -> this.value
+    }
+}

release-plugin/src/main/kotlin/io/github/simonhauck/release/git/internal/commands/GitCommandProcessWrapper.kt

@@ -134,6 +134,10 @@ internal class GitCommandProcessWrapper(
         return gitVoidCommand(listOf("tag", "-d", tagName))
     }
 
+    override fun fetchRemoteTags(): GitVoidResult {
+        return gitVoidCommand(listOf("fetch", "--tags"))
+    }
+
     override fun listTags(): GitResult<List<String>> {
         return gitCommand(listOf("tag")).map { processSuccess ->
             processSuccess.output.map { it.trim() }

release-plugin/src/main/kotlin/io/github/simonhauck/release/plugin/ReleasePlugin.kt

@@ -164,7 +164,7 @@ class ReleasePlugin : Plugin<Project> {
         tasks.register("calculateReleaseVersion", CalculateReleaseVersionTask::class.java) {
             val stringMap = properties.map { (key, value) -> key to value.toString() }.toMap()
             it.commandLineParameters.set(stringMap)
-            it.releaseVersionStorePath.set(releaseVersionStore.get().asFile)
+            it.releaseTagName.set(extension.tagName)
             it.versionPropertyFile.set(extension.versionPropertyFile)
             it.releaseVersionStore.set(releaseVersionStore)
             it.dependsOn(preCheckTask)

release-plugin/src/main/kotlin/io/github/simonhauck/release/tasks/CalculateReleaseVersionTask.kt

@@ -9,22 +9,25 @@ import org.gradle.api.file.RegularFileProperty
 import org.gradle.api.logging.Logging
 import org.gradle.api.provider.MapProperty
 import org.gradle.api.provider.Property
-import org.gradle.api.tasks.Input
-import org.gradle.api.tasks.InputFile
-import org.gradle.api.tasks.OutputFile
-import org.gradle.api.tasks.TaskAction
+import org.gradle.api.tasks.*
 
-abstract class CalculateReleaseVersionTask : BaseReleaseTask() {
+abstract class CalculateReleaseVersionTask : BaseReleaseTask(), GitTask {
 
     private val log = Logging.getLogger(CalculateReleaseVersionTask::class.java)
 
     init {
         description = "Calculate the release version and the next development version"
+        // Run this task always, because the git repository could have changed, (e.g. the tags)
+        outputs.upToDateWhen { false }
     }
 
     @get:InputFile abstract val versionPropertyFile: RegularFileProperty
-    @get:Input abstract val releaseVersionStorePath: Property<File>
+    @get:Deprecated("Use releaseVersionStore instead")
+    @get:Input
+    @get:Optional
+    abstract val releaseVersionStorePath: Property<File>
     @get:Input abstract val commandLineParameters: MapProperty<String, String>
+    @get:Input abstract val releaseTagName: Property<String>
 
     @get:OutputFile abstract val releaseVersionStore: RegularFileProperty
 
@@ -41,6 +44,6 @@ abstract class CalculateReleaseVersionTask : BaseReleaseTask() {
     }
 
     private fun getReleaseVersions(currentVersion: Version): ReleaseVersions =
-        VersionIncrementStrategyParserApi.create()
+        VersionIncrementStrategyParserApi.create(gitCommandApi(), releaseTagName.get())
             .parseOrThrow(currentVersion, commandLineParameters.get())
 }

release-plugin/src/main/kotlin/io/github/simonhauck/release/tasks/CheckForUncommittedFilesTask.kt

@@ -1,6 +1,7 @@
 package io.github.simonhauck.release.tasks
 
 import io.github.simonhauck.release.git.api.GitStatusResult
+import io.github.simonhauck.release.git.api.getOrThrowGradleException
 import org.gradle.api.GradleException
 import org.gradle.api.tasks.TaskAction
 

release-plugin/src/main/kotlin/io/github/simonhauck/release/tasks/CommitAndTagTask.kt

@@ -3,6 +3,7 @@ package io.github.simonhauck.release.tasks
 import arrow.core.fold
 import io.github.simonhauck.release.file.internal.PropertiesFileUtil
 import io.github.simonhauck.release.git.api.RevertCommand
+import io.github.simonhauck.release.git.api.getOrThrowGradleException
 import java.io.File
 import org.gradle.api.file.RegularFileProperty
 import org.gradle.api.provider.ListProperty

release-plugin/src/main/kotlin/io/github/simonhauck/release/tasks/GitTask.kt

@@ -3,7 +3,6 @@ package io.github.simonhauck.release.tasks
 import arrow.core.Either
 import io.github.simonhauck.release.git.api.*
 import java.io.File
-import org.gradle.api.GradleException
 import org.gradle.api.Task
 import org.gradle.api.file.RegularFileProperty
 import org.gradle.api.provider.Property
@@ -37,11 +36,4 @@ interface GitTask : Task {
     ): Either<GitError, T> {
         return onRight { gitCommandHistoryApi.get().registerRevertCommand(revertCommand) }
     }
-
-    fun <T> GitResult<T>.getOrThrowGradleException(): T {
-        return when (this) {
-            is Either.Left -> throw GradleException(this.value.message, this.value.throwable)
-            is Either.Right -> this.value
-        }
-    }
 }

release-plugin/src/main/kotlin/io/github/simonhauck/release/tasks/PushTask.kt

@@ -1,6 +1,7 @@
 package io.github.simonhauck.release.tasks
 
 import io.github.simonhauck.release.git.api.RevertCommand
+import io.github.simonhauck.release.git.api.getOrThrowGradleException
 import java.time.Duration
 import org.gradle.api.logging.Logging
 import org.gradle.api.provider.Property

release-plugin/src/main/kotlin/io/github/simonhauck/release/version/api/VersionIncrementStrategyParserApi.kt

@@ -1,12 +1,17 @@
 package io.github.simonhauck.release.version.api
 
+import io.github.simonhauck.release.git.api.GitCommandApi
 import io.github.simonhauck.release.version.internal.VersionIncrementStrategyParser
 
 interface VersionIncrementStrategyParserApi {
 
     fun parseOrThrow(currentVersion: Version, parameters: Map<String, String>): ReleaseVersions
 
     companion object {
-        fun create(): VersionIncrementStrategyParserApi = VersionIncrementStrategyParser()
+        fun create(
+            gitCommandApi: GitCommandApi,
+            releaseTagTemplate: String,
+        ): VersionIncrementStrategyParserApi =
+            VersionIncrementStrategyParser(gitCommandApi, releaseTagTemplate)
     }
 }

release-plugin/src/main/kotlin/io/github/simonhauck/release/version/internal/ManualVersionSelectionStrategy.kt

@@ -0,0 +1,33 @@
+package io.github.simonhauck.release.version.internal
+
+import io.github.simonhauck.release.version.api.ReleaseVersions
+import io.github.simonhauck.release.version.api.Version
+
+internal class ManualVersionSelectionStrategy() : VersionIncrementStrategy {
+    override val strategyName: String = "Manual Version Selection"
+
+    override val requiredPropertyDescription =
+        listOf(
+            "$RELEASE_VERSION_KEY - The version to release",
+            "$POST_RELEASE_VERSION_KEY - The version after the release",
+        )
+
+    override fun tryParse(
+        currentVersion: Version,
+        parameters: Map<String, String>,
+    ): ReleaseVersions? {
+        val releaseVersion = parameters[RELEASE_VERSION_KEY]
+        val postReleaseVersion = parameters[POST_RELEASE_VERSION_KEY]
+
+        if (releaseVersion == null || postReleaseVersion == null) {
+            return null
+        }
+
+        return ReleaseVersions(Version(releaseVersion), Version(postReleaseVersion))
+    }
+
+    companion object {
+        private const val RELEASE_VERSION_KEY = "releaseVersion"
+        private const val POST_RELEASE_VERSION_KEY = "postReleaseVersion"
+    }
+}

release-plugin/src/main/kotlin/io/github/simonhauck/release/version/internal/ReleaseTypeSelectionStrategy.kt

@@ -0,0 +1,89 @@
+package io.github.simonhauck.release.version.internal
+
+import arrow.core.Either
+import arrow.core.flatten
+import io.github.simonhauck.release.git.api.GitCommandApi
+import io.github.simonhauck.release.git.api.GitError
+import io.github.simonhauck.release.version.api.ReleaseVersions
+import io.github.simonhauck.release.version.api.Version
+import org.gradle.api.logging.Logging
+
+internal class ReleaseTypeSelectionStrategy(
+    private val gitCommandApi: GitCommandApi,
+    private val releaseTagName: String,
+) : VersionIncrementStrategy {
+
+    private val log = Logging.getLogger(ReleaseTypeSelectionStrategy::class.java)
+
+    override val strategyName: String
+        get() = "ReleaseType selection"
+
+    override val requiredPropertyDescription: List<String>
+        get() =
+            listOf(
+                "$RELEASE_TYPE - The type of release ($MAJOR_KEY, $MINOR_KEY, $PATCH_KEY)",
+                "$PRE_RELEASE_TYPE - (Optional) Type of pre-release (e.g. alpha, RC, beta, ...). A counter will be automatically applied.",
+            )
+
+    override fun tryParse(
+        currentVersion: Version,
+        parameters: Map<String, String>,
+    ): ReleaseVersions? {
+        val releaseType = parameters[RELEASE_TYPE] ?: return null
+        val preReleaseType = parameters[PRE_RELEASE_TYPE]
+
+        val currentVersionInfo = VersionInfo.fromVersion(currentVersion)
+
+        val releaseVersion =
+            when (releaseType) {
+                "major" -> currentVersionInfo.bumpMajor(preReleaseType)
+                "minor" -> currentVersionInfo.bumpMinor(preReleaseType)
+                "patch" ->
+                    if (currentVersionInfo.isPreRelease()) currentVersionInfo.dropPreReleaseSuffix()
+                    else currentVersionInfo.bumpPatch(preReleaseType)
+                else -> return null
+            }.applyPreReleaseTypeIfAvailable(preReleaseType)
+
+        // If the next version is a pre-release, the post-release version is reverted so that the
+        // next release can be triggered with the same level again
+        val postReleaseVersion =
+            if (preReleaseType == null) releaseVersion.bumpPatch("SNAPSHOT") else currentVersionInfo
+
+        return ReleaseVersions(releaseVersion.toVersion(), postReleaseVersion.toVersion())
+    }
+
+    private fun VersionInfo.applyPreReleaseTypeIfAvailable(preReleaseSuffix: String?): VersionInfo {
+        if (preReleaseSuffix == null) return this
+
+        val tags =
+            gitCommandApi
+                .fetchRemoteTags()
+                .map { gitCommandApi.listTags() }
+                .flatten()
+                .logErrorOnLeft()
+                .getOrNull()
+                ?.toSet() ?: return this
+
+        return generateSequence(1) { it + 1 }
+            .map { index -> this.copy(preReleaseSuffix = "$preReleaseSuffix$index") }
+            .first { version -> !tags.containsVersion(version) }
+    }
+
+    private fun Set<String>.containsVersion(version: VersionInfo): Boolean {
+        val expectedReleaseTag = releaseTagName.replace("{version}", version.toVersion().value)
+        return contains(expectedReleaseTag)
+    }
+
+    private fun <B> Either<GitError, B>.logErrorOnLeft(): Either<GitError, B> = onLeft {
+        log.info("Failed to get all local and remote tags - This will not fail the build")
+        log.info(it.message)
+    }
+
+    companion object {
+        private const val RELEASE_TYPE = "releaseType"
+        private const val PRE_RELEASE_TYPE = "preReleaseType"
+        private const val MAJOR_KEY = "major"
+        private const val MINOR_KEY = "minor"
+        private const val PATCH_KEY = "patch"
+    }
+}

release-plugin/src/main/kotlin/io/github/simonhauck/release/version/internal/VersionIncrementStrategy.kt

@@ -11,70 +11,3 @@ internal sealed interface VersionIncrementStrategy {
 
     fun tryParse(currentVersion: Version, parameters: Map<String, String>): ReleaseVersions?
 }
-
-internal class ManualVersionSelectionStrategy() : VersionIncrementStrategy {
-    override val strategyName: String = "Manual Version Selection"
-
-    override val requiredPropertyDescription =
-        listOf(
-            "$RELEASE_VERSION_KEY - The version to release",
-            "$POST_RELEASE_VERSION_KEY - The version after the release",
-        )
-
-    override fun tryParse(
-        currentVersion: Version,
-        parameters: Map<String, String>,
-    ): ReleaseVersions? {
-        val releaseVersion = parameters[RELEASE_VERSION_KEY]
-        val postReleaseVersion = parameters[POST_RELEASE_VERSION_KEY]
-
-        if (releaseVersion == null || postReleaseVersion == null) {
-            return null
-        }
-
-        return ReleaseVersions(Version(releaseVersion), Version(postReleaseVersion))
-    }
-
-    companion object {
-        private const val RELEASE_VERSION_KEY = "releaseVersion"
-        private const val POST_RELEASE_VERSION_KEY = "postReleaseVersion"
-    }
-}
-
-internal class ReleaseTypeSelectionStrategy : VersionIncrementStrategy {
-    override val strategyName: String
-        get() = "ReleaseType selection"
-
-    override val requiredPropertyDescription: List<String>
-        get() = listOf("$RELEASE_TYPE - The type of release ($MAJOR_KEY, $MINOR_KEY, $PATCH_KEY)")
-
-    override fun tryParse(
-        currentVersion: Version,
-        parameters: Map<String, String>,
-    ): ReleaseVersions? {
-        val releaseType = parameters[RELEASE_TYPE] ?: return null
-
-        val versionInfo = VersionInfo.fromVersion(currentVersion)
-
-        val releaseVersion =
-            when (releaseType) {
-                "major" -> versionInfo.bumpMajor()
-                "minor" -> versionInfo.bumpMinor()
-                "patch" ->
-                    if (versionInfo.isPreRelease()) versionInfo.bumpToRelease()
-                    else versionInfo.bumpPatch()
-                else -> return null
-            }
-
-        val postReleaseVersion = releaseVersion.bumpPatch("SNAPSHOT")
-
-        return ReleaseVersions(releaseVersion.toVersion(), postReleaseVersion.toVersion())
-    }
-
-    companion object {
-        private const val RELEASE_TYPE = "releaseType"
-        private const val MAJOR_KEY = "major"
-        private const val MINOR_KEY = "minor"
-        private const val PATCH_KEY = "patch"
-    }
-}