#69 add task to check for snapshot versions

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

@@ -0,0 +1,81 @@
+package io.github.simonhauck.release.tasks
+
+import arrow.core.getOrElse
+import io.github.simonhauck.release.version.api.Version
+import io.github.simonhauck.release.version.internal.VersionInfo
+import org.gradle.api.GradleException
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.logging.Logging
+import org.gradle.api.provider.ListProperty
+import org.gradle.api.provider.SetProperty
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.Optional
+import org.gradle.api.tasks.TaskAction
+
+abstract class CheckForPreReleaseDependenciesTask : BaseReleaseTask() {
+
+    private val log = Logging.getLogger(CheckForPreReleaseDependenciesTask::class.java)
+
+    @get:InputFile @get:Optional abstract val ignorePreReleaseDependenciesFile: RegularFileProperty
+    @get:Input @get:Optional abstract val ignorePreReleaseDependencies: ListProperty<String>
+
+    @get:Input abstract val usedDependencies: SetProperty<String>
+
+    init {
+        outputs.upToDateWhen { true }
+    }
+
+    @TaskAction
+    fun action() {
+        val ignoredDependencies = combineIgnoredDependencies().toSet()
+
+        val preReleaseDependencies =
+            usedDependencies.get().filter { isPreReleaseVersion(it) }.sorted()
+
+        val notAllowedDependencies =
+            preReleaseDependencies.filterNot { it.startsWithAnyOf(ignoredDependencies) }
+
+        if (notAllowedDependencies.isEmpty()) return
+
+        val errorMessage = buildErrorMessage(notAllowedDependencies)
+        throw GradleException(errorMessage)
+    }
+
+    private fun isPreReleaseVersion(it: String): Boolean {
+        val split = it.split(":")
+        if (split.size > 3)
+            throw GradleException(
+                "Something went wrong. Expected a dependency in form of group:name:version but got $it")
+
+        if (split.size < 3) return false
+        val version = split[2]
+
+        return VersionInfo.parseVersionInfo(Version(version))
+            .map { it.isPreRelease() }
+            .getOrElse { false }
+    }
+
+    private fun buildErrorMessage(notAllowedDependencies: List<String>): String {
+        val header =
+            "Found ${notAllowedDependencies.size} dependencies with a pre-release version that are not allowed\n"
+
+        val list = notAllowedDependencies.joinToString("\n") { " - $it" }
+
+        val hint = "\nChange the versions or add them to the ignore list."
+        return header + list + hint
+    }
+
+    private fun String.startsWithAnyOf(list: Set<String>): Boolean {
+        return list.any { this.startsWith(it) }
+    }
+
+    private fun combineIgnoredDependencies(): List<String> {
+        val ignoreFromFile =
+            ignorePreReleaseDependenciesFile.map { it.asFile.readLines() }.getOrElse(emptyList())
+
+        val ignoredFromList = ignorePreReleaseDependencies.getOrElse(emptyList())
+
+        return ignoreFromFile + ignoredFromList
+    }
+}

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

@@ -59,7 +59,7 @@ internal data class VersionInfo(
             return parseVersionInfo(version).getOrElse { throw it }
         }
 
-        private fun parseVersionInfo(version: Version): Either<GradleException, VersionInfo> =
+        internal fun parseVersionInfo(version: Version): Either<GradleException, VersionInfo> =
             either {
                 val value = version.value
                 val regexString =

release-plugin/src/test/kotlin/io/github/simonhauck/release/tasks/CheckForPreReleaseDependenciesTaskTest.kt

@@ -0,0 +1,88 @@
+package io.github.simonhauck.release.tasks
+
+import io.github.simonhauck.release.testdriver.ReleasePluginTestDriver
+import org.assertj.core.api.Assertions.assertThat
+import org.gradle.testkit.runner.TaskOutcome
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.io.TempDir
+import java.io.File
+
+class CheckForPreReleaseDependenciesTaskTest {
+
+    @TempDir lateinit var tmpDir: File
+
+    private val testDriver = ReleasePluginTestDriver()
+
+    private val alphaVersionDependency = "\"some.group:lib:1.0.0-alpha\""
+    private val snapshotVersionDependency = "\"other.xy:lib2:1.0.0-SNAPSHOT\""
+    private val releaseVersionDependency = "\"released.dep:great:1.0.0\""
+
+    @Test
+    fun `should fail and list the dependencies that are a pre-release version`() =
+        testDriver(tmpDir) {
+            appendContentToBuildGradle(
+                """
+                |tasks.register<CheckForPreReleaseDependenciesTask>("testCheckForPreReleaseDependencies") {
+                |    usedDependencies = setOf(
+                |       $alphaVersionDependency,
+                |       $snapshotVersionDependency,
+                |       $releaseVersionDependency,
+                |    )
+                |}
+                """
+                    .trimMargin())
+
+            val runner =
+                testKitRunner().withArguments("testCheckForPreReleaseDependencies").buildAndFail()
+
+            val actual = runner.task(":testCheckForPreReleaseDependencies")
+
+            assertThat(actual?.outcome).isEqualTo(TaskOutcome.FAILED)
+            assertThat(runner.output.lines())
+                .containsSequence(
+                    "Found 2 pre-release dependencies with a pre-release version that are not allowed",
+                    " - other.xy:lib2:1.0.0-SNAPSHOT",
+                    " - some.group:lib:1.0.0-alpha",
+                    "Change the versions or add them to the ignore list.",
+                )
+        }
+
+    @Test
+    fun `task should be successful if no pre-release version is used`() =
+        testDriver(tmpDir) {
+            appendContentToBuildGradle(
+                """
+                |tasks.register<CheckForPreReleaseDependenciesTask>("testCheckForPreReleaseDependencies") {
+                |    usedDependencies = setOf(
+                |       $releaseVersionDependency,
+                |    )
+                |}
+                """
+                    .trimMargin())
+
+            val runner = testKitRunner().withArguments("testCheckForPreReleaseDependencies").build()
+            val actual = runner.task(":testCheckForPreReleaseDependencies")
+
+            assertThat(actual?.outcome).isEqualTo(TaskOutcome.SUCCESS)
+        }
+
+    @Test
+    fun `should not list snapshot dependencies that are specified in the ignore list`() {
+        TODO("Not yet implemented")
+    }
+
+    @Test
+    fun `should not list snapshot dependencies that are specified in the ignore file`() {
+        TODO("Not yet implemented")
+    }
+
+    @Test
+    fun `should not fail if a version has an unexpected format`() {
+        TODO("Not yet implemented")
+    }
+
+    @Test
+    fun `task should be up to date when invoked twice`() {
+        TODO("Not yet implemented")
+    }
+}