Update project to Gradle 6.9

build.gradle

@@ -16,45 +16,48 @@
  */
 
 plugins {
-    id 'net.wooga.plugins' version '1.4.0'
+    id 'net.wooga.plugins' version '3.0.0-rc.2'
 }
 
 group 'net.wooga.gradle'
 description = 'Node release plugin for Gradle.'
 
 repositories {
-    jcenter()
     mavenCentral()
     maven {
         url "https://plugins.gradle.org/m2/"
     }
 }
 
 dependencies {
-    testCompile('org.jfrog.artifactory.client:artifactory-java-client-services:2.+') {
+    testImplementation('org.jfrog.artifactory.client:artifactory-java-client-services:2.9.2') {
         exclude module: 'logback-classic'
     }
-    testCompile 'org.kohsuke:github-api:latest.release'
-    testCompile 'com.github.stefanbirkner:system-rules:1.18.0'
+    testImplementation 'org.kohsuke:github-api:1.301'
+    testImplementation 'com.wooga.gradle:gradle-commons-test:0.3.0'
 
-    compile 'com.netflix.nebula:nebula-release-plugin:6.+'
-    compile 'com.moowork.gradle:gradle-node-plugin:1.2.0'
-    compile "gradle.plugin.net.wooga.gradle:atlas-github:1.+"
-    compile "gradle.plugin.net.wooga.gradle:atlas-release:1.+"
-    compile gradleApi()
-    compile localGroovy()
+    implementation 'org.ajoberstar.grgit:grgit-core:(4.1,5]'
+    implementation 'org.ajoberstar.grgit:grgit-gradle:(4.1,5]'
+    // TODO: Perhaps upgrade to 1.3.1
+    implementation 'com.moowork.gradle:gradle-node-plugin:1.3.1'
+    implementation 'gradle.plugin.net.wooga.gradle:atlas-version:1+'
+    implementation 'gradle.plugin.net.wooga.gradle:atlas-github:(2, 3]'
+    implementation 'gradle.plugin.net.wooga.gradle:atlas-release:(2, 3]'
 }
 
 pluginBundle {
     website = 'https://wooga.github.io/atlas-node-release'
     vcsUrl = 'https://github.com/wooga/atlas-node-release'
     tags = ['Wooga', 'release', 'node', 'npm']
+}
 
+gradlePlugin {
     plugins {
         nodeRelease {
             id = 'net.wooga.node-release'
             displayName = 'Gradle Wooga Node Release plugin'
             description = 'Plugin for wooga npm library releases'
+            implementationClass = "wooga.gradle.node.NodeReleasePlugin"
         }
     }
 }

gradle/wrapper/gradle-wrapper.properties

@@ -20,4 +20,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.10-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.9-bin.zip

src/main/groovy/wooga/gradle/node/NodeReleasePlugin.groovy

@@ -18,18 +18,20 @@
 package wooga.gradle.node
 
 import com.moowork.gradle.node.NodePlugin
-import nebula.plugin.release.ReleasePlugin
-import org.ajoberstar.gradle.git.release.base.ReleasePluginExtension
 import org.gradle.api.Action
 import org.gradle.api.Plugin
 import org.gradle.api.Project
+import org.gradle.api.Task
 import org.gradle.api.plugins.BasePlugin
+import org.gradle.api.publish.plugins.PublishingPlugin
 import org.gradle.language.base.plugins.LifecycleBasePlugin
 import wooga.gradle.github.publish.GithubPublishPlugin
 import wooga.gradle.github.publish.tasks.GithubPublish
 import wooga.gradle.node.tasks.ModifyPackageJsonTask
 import wooga.gradle.node.tasks.NpmCredentialsTask
-import wooga.gradle.release.version.semver2.VersionStrategies
+import wooga.gradle.version.VersionPlugin
+import wooga.gradle.version.VersionPluginExtension
+import wooga.gradle.version.VersionScheme
 
 enum Engine {
     npm,
@@ -43,6 +45,10 @@ class NodeReleasePlugin implements Plugin<Project> {
     static final String NODE_TEST_TASK = 'node_run_test'
     static final String NODE_PUBLISH_TASK = 'node_publish'
 
+    public static final String RC_TASK_NAME = "rc"
+    public static final String FINAL_TASK_NAME = "final"
+    public static final String SNAPSHOT_TASK_NAME = "snapshot"
+
     static final String MODIFY_PACKAGE_VERSION_TASK = 'modifyPackageJson_version'
     static final String CREATE_CREDENTIALS_TASK = 'ensureNpmrc'
 
@@ -72,9 +78,10 @@ class NodeReleasePlugin implements Plugin<Project> {
         extension = createExtension(project)
 
         if (project == project.rootProject) {
-            project.pluginManager.apply(ReleasePlugin.class)
+            //project.pluginManager.apply(ReleasePlugin.class)
+            // Detect whether the project is using yarn or npm
             detectEngine(project)
-            configureVersionStrategy(project)
+            applyVersionPlugin(project)
             configureReleaseLifecycle(project)
             configureModifyPackageJsonVersionTask(project)
             configureNpmCredentialsTasks(project, extension)
@@ -86,6 +93,12 @@ class NodeReleasePlugin implements Plugin<Project> {
 
     }
 
+    private static void applyVersionPlugin(Project project) {
+        project.pluginManager.apply(VersionPlugin)
+        VersionPluginExtension versionExtension = project.extensions.findByType(VersionPluginExtension)
+        versionExtension.versionScheme(VersionScheme.semver2)
+    }
+
     private static detectEngine(Project project) {
         engine = project.file(YARN_LOCK_JSON).exists() ? Engine.yarn : Engine.npm
     }
@@ -116,9 +129,12 @@ class NodeReleasePlugin implements Plugin<Project> {
         def checkTask = tasks.getByName(LifecycleBasePlugin.CHECK_TASK_NAME)
         def assembleTask = tasks.getByName(LifecycleBasePlugin.ASSEMBLE_TASK_NAME)
         def cleanTask = tasks.getByName(BasePlugin.CLEAN_TASK_NAME)
-        def postReleaseTask = tasks.getByName(ReleasePlugin.POST_RELEASE_TASK_NAME)
-        def releaseTask = tasks.getByName('release')
-        def publishTask = project.tasks.getByName(engineScopedTaskName(NODE_PUBLISH_TASK))
+        def publishTask = tasks.getByName(PublishingPlugin.PUBLISH_LIFECYCLE_TASK_NAME)
+
+        // TODO: Replace?
+        //def postReleaseTask = tasks.getByName(ReleasePlugin.POST_RELEASE_TASK_NAME)
+        //def releaseTask = tasks.getByName('release')
+        //def publishTask = project.tasks.getByName(engineScopedTaskName(NODE_PUBLISH_TASK))
         def githubPublishTask = project.tasks.getByName(GithubPublishPlugin.PUBLISH_TASK_NAME)
 
         def nodeCleanTask = tasks.create(NODE_CLEAN_TASK)
@@ -133,17 +149,31 @@ class NodeReleasePlugin implements Plugin<Project> {
 
         nodeCleanTask.dependsOn engineScopedCleanTask
         nodeTestTask.dependsOn engineScopedTestTask
+
+        // Set up assemble lifecycle dependencies
         nodeBuildTask.dependsOn engineScopedBuildTask
+        assembleTask.dependsOn nodeBuildTask
+        // Set up publish lifecycle dependencies
         nodePublishTask.dependsOn engineScopedPublishTask
+        publishTask.dependsOn nodePublishTask
+        githubPublishTask.mustRunAfter nodePublishTask
+
+        // TODO: Add custom tasks previously provided by the nebula release plugin
+        Task finalTask = project.tasks.create(FINAL_TASK_NAME)
+        Task rcTask = project.tasks.create(RC_TASK_NAME)
+        Task snapshotTask = project.tasks.create(SNAPSHOT_TASK_NAME)
+
+        [finalTask, rcTask, snapshotTask].each {
+            it.dependsOn publishTask
+        }
 
         cleanTask.dependsOn nodeCleanTask
         checkTask.dependsOn nodeTestTask
-        releaseTask.dependsOn assembleTask
-        assembleTask.dependsOn nodeBuildTask
-        tasks.release.dependsOn assembleTask
-        postReleaseTask.dependsOn nodePublishTask, githubPublishTask
-        publishTask.mustRunAfter releaseTask
-        githubPublishTask.mustRunAfter nodePublishTask
+        //releaseTask.dependsOn assembleTask
+        //tasks.release.dependsOn assembleTask
+        // TODO: Replace?
+        //postReleaseTask.dependsOn nodePublishTask, githubPublishTask
+        //publishTask.mustRunAfter releaseTask
     }
 
     private static void configureModifyPackageJsonVersionTask(Project project) {
@@ -182,28 +212,27 @@ class NodeReleasePlugin implements Plugin<Project> {
 
             @Override
             void execute(GithubPublish githubPublishTask) {
-                githubPublishTask.tagName = "v${project.version}"
-                githubPublishTask.releaseName = project.version
+                githubPublishTask.tagName.set("v${project.version}")
+                githubPublishTask.releaseName.set( project.version.toString())
                 githubPublishTask.body = null
-                githubPublishTask.draft = false
-                githubPublishTask.prerelease = { project.status != 'release' }
+                githubPublishTask.draft.set(false)
+                githubPublishTask.prerelease.set(project.provider { project.status != 'final' })
                 githubPublishTask.onlyIf {
-                    ['candidate', 'release'].contains(project.status)
+                    ['rc', 'final'].contains(project.status)
                 }
             }
         })
     }
 
-    private static void configureVersionStrategy(Project project) {
-        ReleasePluginExtension releaseExtension = project.extensions.findByType(ReleasePluginExtension)
-
-        releaseExtension.with {
-            releaseExtension.versionStrategy(VersionStrategies.SNAPSHOT)
-            releaseExtension.versionStrategy(VersionStrategies.DEVELOPMENT)
-            releaseExtension.versionStrategy(VersionStrategies.PRE_RELEASE)
-            releaseExtension.versionStrategy(VersionStrategies.FINAL)
-            releaseExtension.defaultVersionStrategy = VersionStrategies.DEVELOPMENT
-
-        }
-    }
+//    private static void configureVersionStrategy(Project project) {
+//        ReleasePluginExtension releaseExtension = project.extensions.findByType(ReleasePluginExtension)
+//
+//        releaseExtension.with {
+//            releaseExtension.versionStrategy(VersionStrategies.SNAPSHOT)
+//            releaseExtension.versionStrategy(VersionStrategies.DEVELOPMENT)
+//            releaseExtension.versionStrategy(VersionStrategies.PRE_RELEASE)
+//            releaseExtension.versionStrategy(VersionStrategies.FINAL)
+//            releaseExtension.defaultVersionStrategy = VersionStrategies.DEVELOPMENT
+//        }
+//    }
 }

src/main/groovy/wooga/gradle/node/NodeReleasePluginExtension.groovy

@@ -23,15 +23,29 @@ import org.gradle.api.provider.Property
 
 class NodeReleasePluginExtension {
 
-    final Property<String> npmUser
-    final Property<String> npmPass
-    final Property<String> npmAuthUrl
-    final RegularFileProperty npmrcFile
+    private final Property<String> npmUser
+    Property<String> getNpmUser() {
+        npmUser
+    }
+
+    private final Property<String> npmPass
+    Property<String> getNpmPass() {
+        npmUser
+    }
+
+    private final Property<String> npmAuthUrl
+    Property<String> getNpmAuthUrl() {
+        npmAuthUrl
+    }
+    private final RegularFileProperty npmrcFile
+    RegularFileProperty getNpmrcFile(){
+        npmrcFile
+    }
 
     NodeReleasePluginExtension(Project project) {
         npmUser = project.objects.property(String)
         npmPass = project.objects.property(String)
         npmAuthUrl = project.objects.property(String)
-        npmrcFile = project.layout.fileProperty()
+        npmrcFile = project.objects.fileProperty()
     }
 }

src/main/groovy/wooga/gradle/node/tasks/NpmCredentialsTask.groovy

@@ -39,7 +39,7 @@ class NpmCredentialsTask extends DefaultTask {
     final Property<String> npmAuthUrl = project.objects.property(String)
 
     @OutputFile
-    final RegularFileProperty npmrcFile = newOutputFile()
+    final RegularFileProperty npmrcFile = project.objects.fileProperty()
 
     @TaskAction
     protected void exec() {