multiproject setup testing and fixes

.github/workflows/nebula.yml

@@ -9,15 +9,8 @@ on:
   pull_request:
 
 jobs:
-  validation:
-    name: "Gradle Wrapper Validation"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: gradle/wrapper-validation-action@v1
   buildmultijdk:
     if: (!startsWith(github.ref, 'refs/tags/v'))
-    needs: validation
     runs-on: ubuntu-latest
     strategy:
       matrix:
@@ -38,27 +31,16 @@ jobs:
             17
             ${{ matrix.java }}
           java-package: jdk
-      - uses: actions/cache@v4
-        id: gradle-cache
-        with:
-          path: ~/.gradle/caches
-          key: ${{ runner.os }}-gradle-${{ hashFiles('**/gradle/dependency-locks/*.lockfile') }}
-          restore-keys: |
-            - ${{ runner.os }}-gradle-
-      - uses: actions/cache@v4
-        id: gradle-wrapper-cache
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v5
         with:
-          path: ~/.gradle/wrapper
-          key: ${{ runner.os }}-gradlewrapper-${{ hashFiles('gradle/wrapper/*') }}
-          restore-keys: |
-            - ${{ runner.os }}-gradlewrapper-
+          cache-overwrite-existing: true
       - name: Gradle build
         run: ./gradlew --info --stacktrace build
         env:
           JDK_VERSION_FOR_TESTS: ${{ matrix.java }}
   validatepluginpublication:
     if: startsWith(github.ref, 'refs/tags/v')
-    needs: validation
     runs-on: ubuntu-latest
     name: Gradle Plugin Publication Validation
     env:
@@ -78,20 +60,10 @@ jobs:
             17
             21
           java-package: jdk
-      - uses: actions/cache@v4
-        id: gradle-cache
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v5
         with:
-          path: ~/.gradle/caches
-          key: ${{ runner.os }}-gradle-${{ hashFiles('**/gradle/dependency-locks/*.lockfile') }}
-          restore-keys: |
-            - ${{ runner.os }}-gradle-
-      - uses: actions/cache@v4
-        id: gradle-wrapper-cache
-        with:
-          path: ~/.gradle/wrapper
-          key: ${{ runner.os }}-gradlewrapper-${{ hashFiles('gradle/wrapper/*') }}
-          restore-keys: |
-            - ${{ runner.os }}-gradlewrapper-
+          cache-overwrite-existing: true
       - name: Verify plugin publication
         if: |
           startsWith(github.ref, 'refs/tags/v') &&
@@ -123,20 +95,10 @@ jobs:
             17
             21
           java-package: jdk
-      - uses: actions/cache@v4
-        id: gradle-cache
-        with:
-          path: ~/.gradle/caches
-          key: ${{ runner.os }}-gradle-${{ hashFiles('**/gradle/dependency-locks/*.lockfile') }}
-          restore-keys: |
-            - ${{ runner.os }}-gradle-
-      - uses: actions/cache@v4
-        id: gradle-wrapper-cache
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v5
         with:
-          path: ~/.gradle/wrapper
-          key: ${{ runner.os }}-gradlewrapper-${{ hashFiles('gradle/wrapper/*') }}
-          restore-keys: |
-            - ${{ runner.os }}-gradlewrapper-
+          cache-overwrite-existing: true
       - name: Publish candidate
         if: |
           startsWith(github.ref, 'refs/tags/v') &&

build.gradle.kts

@@ -39,6 +39,9 @@ dependencies {
     implementation("org.apache.maven:maven-model:3.6.2")
     testImplementation("org.spockframework:spock-core:2.3-groovy-4.0")
     testImplementation("org.junit.vintage:junit-vintage-engine:5.14.0")
+    testImplementation("org.ajoberstar.grgit:grgit-core:4.1.1") {
+        exclude (group= "org.codehaus.groovy", module= "groovy")
+    }
 }
 
 gradlePlugin {

gradle.lockfile

@@ -2,15 +2,18 @@
 # Manual edits can break the build and are not advised.
 # This file is expected to be part of source control.
 cglib:cglib-nodep:3.2.2=integTestRuntimeClasspath,testRuntimeClasspath
-com.netflix.nebula:nebula-test:11.5.0=integTestCompileClasspath,integTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath
+com.googlecode.javaewah:JavaEWAH:1.1.12=integTestCompileClasspath,integTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath
+com.netflix.nebula:nebula-test:11.6.3=integTestCompileClasspath,integTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath
 io.github.gradle-nexus:publish-plugin:2.0.0=compileClasspath,integTestCompileClasspath,integTestRuntimeClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
 junit:junit:4.13.2=integTestCompileClasspath,integTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath
 net.bytebuddy:byte-buddy:1.15.11=integTestCompileClasspath,integTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath
+org.ajoberstar.grgit:grgit-core:4.1.1=integTestCompileClasspath,integTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath
 org.apache.groovy:groovy:4.0.4=integTestCompileClasspath,integTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath
 org.apache.maven:maven-model:3.6.2=compileClasspath,integTestCompileClasspath,integTestRuntimeClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
 org.apiguardian:apiguardian-api:1.1.2=integTestCompileClasspath,integTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath
 org.assertj:assertj-core:3.27.3=integTestCompileClasspath,integTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath
 org.codehaus.plexus:plexus-utils:3.2.1=compileClasspath,integTestCompileClasspath,integTestRuntimeClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
+org.eclipse.jgit:org.eclipse.jgit:5.13.0.202109080827-r=integTestCompileClasspath,integTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath
 org.hamcrest:hamcrest-core:1.3=integTestCompileClasspath,integTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath
 org.hamcrest:hamcrest:2.2=integTestCompileClasspath,integTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath
 org.jetbrains.kotlin:kotlin-reflect:2.2.0=compileClasspath,embeddedKotlin,integTestCompileClasspath,integTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath
@@ -27,5 +30,6 @@ org.junit.platform:junit-platform-launcher:1.14.0=integTestCompileClasspath,inte
 org.junit.vintage:junit-vintage-engine:5.14.0=integTestCompileClasspath,integTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath
 org.objenesis:objenesis:2.4=integTestRuntimeClasspath,testRuntimeClasspath
 org.opentest4j:opentest4j:1.3.0=integTestCompileClasspath,integTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath
+org.slf4j:slf4j-api:1.7.30=integTestCompileClasspath,integTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath
 org.spockframework:spock-core:2.3-groovy-4.0=integTestCompileClasspath,integTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath
 empty=annotationProcessor,integTestAnnotationProcessor,testAnnotationProcessor

src/main/kotlin/nebula/plugin/publishing/MavenCentralPublishingPlugin.kt

@@ -66,11 +66,11 @@ class MavenCentralPublishingPlugin  @Inject constructor(private val providerFact
             throw GradleException("Could not find registered NexusPublishExtension")
         }
 
-        nexusPublishExtension.packageGroup.set(nebulaOssPublishingExtension.packageGroup.get())
+        nexusPublishExtension.packageGroup.set(nebulaOssPublishingExtension.packageGroup)
         nexusPublishExtension.repositories.sonatype {
             nexusUrl.set(URI(sonatypeOssRepositoryUrl))
-            username.set(nebulaOssPublishingExtension.sonatypeUsername.get())
-            password.set(nebulaOssPublishingExtension.sonatypePassword.get())
+            username.set(nebulaOssPublishingExtension.sonatypeUsername)
+            password.set(nebulaOssPublishingExtension.sonatypePassword)
             stagingProfileId.set(getStagingProfileId(project))
         }
 

src/main/kotlin/nebula/plugin/publishing/NebulaOssPublishingPlugin.kt

@@ -18,13 +18,16 @@ package nebula.plugin.publishing
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.provider.ProviderFactory
+import org.gradle.api.publish.maven.tasks.PublishToMavenRepository
 import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.withType
 import javax.inject.Inject
 
 /**
  * Configures artifact signing and publication to NetflixOSS and Maven Central
  */
-open class NebulaOssPublishingPlugin @Inject constructor(private val providerFactory: ProviderFactory): Plugin<Project> {
+open class NebulaOssPublishingPlugin @Inject constructor(private val providerFactory: ProviderFactory) :
+    Plugin<Project> {
     companion object {
         const val netflixOssDefaultRepositoryBaseUrl = "https://artifacts-oss.netflix.net/artifactory"
         const val netflixOssGradlePluginsRepository = "gradle-plugins"
@@ -43,6 +46,16 @@ open class NebulaOssPublishingPlugin @Inject constructor(private val providerFac
         project.pluginManager.apply(MavenCentralPublishingPlugin::class)
         project.pluginManager.apply(NebulaOssRepositoriesPlugin::class)
 
+        project.plugins.withId("com.netflix.nebula.release") {
+            project.afterEvaluate {
+                project.tasks.withType<PublishToMavenRepository> {
+                    mustRunAfter(project.rootProject.tasks.named("release"))
+                }
+                project.rootProject.tasks.named("postRelease") {
+                    dependsOn(project.tasks.withType<PublishToMavenRepository>())
+                }
+            }
+        }
     }
 
     private fun setExtensionDefaults(nebulaOssPublishingExtension: NebulaOssPublishingExtension, project: Project) {
@@ -64,7 +77,7 @@ open class NebulaOssPublishingPlugin @Inject constructor(private val providerFac
             "sonatypeStagingProfileId"
         ) ?: netflixDefaultStagingProfile
 
-        if(!stagingProfileId.isNotBlank()) {
+        if (!stagingProfileId.isNotBlank()) {
             extension.stagingProfileId.convention(stagingProfileId)
         }
     }
@@ -77,14 +90,14 @@ open class NebulaOssPublishingPlugin @Inject constructor(private val providerFac
             "sonatypePackageGroup"
         ) ?: project.group.toString().split(".").take(2).joinToString(".")
 
-        if(packageGroup.isNotBlank()) {
+        if (packageGroup.isNotBlank()) {
             extension.packageGroup.convention(packageGroup)
         }
     }
 
     private fun setSigningKey(extension: NebulaOssPublishingExtension, project: Project) {
         val signingKeyFile = project.rootProject.file(signingKeyFileLocation)
-        if(signingKeyFile.exists()) {
+        if (signingKeyFile.exists()) {
             extension.signingKey.convention(signingKeyFile.readText())
         } else {
             val signingKey = findPropertyValue(
@@ -93,54 +106,64 @@ open class NebulaOssPublishingPlugin @Inject constructor(private val providerFac
                 "sonatype.signingKey",
                 "netflixOssSigningKey"
             )
-            if(!signingKey.isNullOrBlank()) {
+            if (!signingKey.isNullOrBlank()) {
                 extension.signingKey.convention(signingKey)
             }
         }
     }
 
     private fun setSigningPassword(extension: NebulaOssPublishingExtension, project: Project) {
-        val signingPassword = findPropertyValue(project,
+        val signingPassword = findPropertyValue(
+            project,
             "NETFLIX_OSS_SIGNING_PASSWORD",
             "sonatype.signingPassword",
-            "netflixOssSigningPassword")
-        if(!signingPassword.isNullOrBlank()) {
+            "netflixOssSigningPassword"
+        )
+        if (!signingPassword.isNullOrBlank()) {
             extension.signingPassword.convention(signingPassword)
         }
     }
 
     private fun setNetflixOssCredentials(extension: NebulaOssPublishingExtension, project: Project) {
-        val netflixOssUsername = findPropertyValue(project,
+        val netflixOssUsername = findPropertyValue(
+            project,
             "NETFLIX_OSS_REPO_USERNAME",
             "netflixOss.username",
-            "netflixOssUsername")
-        if(!netflixOssUsername.isNullOrBlank()) {
+            "netflixOssUsername"
+        )
+        if (!netflixOssUsername.isNullOrBlank()) {
             extension.netflixOssUsername.convention(netflixOssUsername)
         }
 
-        val netflixOssPassword = findPropertyValue(project,
+        val netflixOssPassword = findPropertyValue(
+            project,
             "NETFLIX_OSS_REPO_PASSWORD",
             "netflixOss.password",
-            "netflixOssPassword")
-        if(!netflixOssPassword.isNullOrBlank()) {
+            "netflixOssPassword"
+        )
+        if (!netflixOssPassword.isNullOrBlank()) {
             extension.netflixOssPassword.convention(netflixOssPassword)
         }
     }
 
     private fun setMavenCentralCredentials(extension: NebulaOssPublishingExtension, project: Project) {
-        val sonatypeUsername = findPropertyValue(project,
+        val sonatypeUsername = findPropertyValue(
+            project,
             "NETFLIX_OSS_SONATYPE_USERNAME",
             "sonatype.username",
-            "sonatypeUsername")
-        if(!sonatypeUsername.isNullOrBlank()) {
+            "sonatypeUsername"
+        )
+        if (!sonatypeUsername.isNullOrBlank()) {
             extension.sonatypeUsername.convention(sonatypeUsername)
         }
 
-        val sonatypePassword = findPropertyValue(project,
+        val sonatypePassword = findPropertyValue(
+            project,
             "NETFLIX_OSS_SONATYPE_PASSWORD",
             "sonatype.password",
-            "sonatypePassword")
-        if(!sonatypePassword.isNullOrBlank()) {
+            "sonatypePassword"
+        )
+        if (!sonatypePassword.isNullOrBlank()) {
             extension.sonatypePassword.convention(sonatypePassword)
         }
     }
@@ -152,7 +175,7 @@ open class NebulaOssPublishingPlugin @Inject constructor(private val providerFac
             "netflixOss.repositoryBaseUrl",
             "netflixOssRepositoryBaseUrl"
         )
-        if(!repositoryBaseUrl.isNullOrBlank()) {
+        if (!repositoryBaseUrl.isNullOrBlank()) {
             extension.netflixOssRepositoryBaseUrl.convention(repositoryBaseUrl)
         } else {
             extension.netflixOssRepositoryBaseUrl.convention(netflixOssDefaultRepositoryBaseUrl)
@@ -195,32 +218,38 @@ open class NebulaOssPublishingPlugin @Inject constructor(private val providerFac
     }
 
     private fun projectExecutionHasTask(project: Project, task: String): Boolean {
-        return project.gradle.startParameter.taskNames.contains(task) || project.gradle.startParameter.taskNames.contains(":${task}")
+        return project.gradle.startParameter.taskNames.contains(task) || project.gradle.startParameter.taskNames.contains(
+            ":${task}"
+        )
     }
 
-    private fun findPropertyValue(project: Project,
-                                  envVariableName: String,
-                                  namespacedPropertyName: String,
-                                  propertyName: String
-    ) : String? {
+    private fun findPropertyValue(
+        project: Project,
+        envVariableName: String,
+        namespacedPropertyName: String,
+        propertyName: String
+    ): String? {
         val propertyValueFromEnv = readEnvVariable(envVariableName)
         return when {
             propertyValueFromEnv != null -> {
                 propertyValueFromEnv
             }
+
             project.hasProperty(propertyName) -> {
                 project.prop(propertyName)
             }
+
             project.hasProperty(namespacedPropertyName) -> {
                 project.prop(namespacedPropertyName)
             }
+
             else -> null
         }
     }
 
-    private fun readEnvVariable(envVariableName: String) : String? {
+    private fun readEnvVariable(envVariableName: String): String? {
         val envVariable = providerFactory.environmentVariable(envVariableName)
-        return if(envVariable.isPresent) envVariable.get() else null
+        return if (envVariable.isPresent) envVariable.get() else null
     }
 
     private fun Project.prop(s: String): String? = project.findProperty(s) as String?

src/test/kotlin/nebula/plugin/publishing/GitUtil.kt

@@ -0,0 +1,36 @@
+package nebula.plugin.publishing
+
+import nebula.test.dsl.TestProjectRunner
+import org.ajoberstar.grgit.Grgit
+import java.io.File
+
+fun withGitTag(
+    projectDir: File,
+    remoteGitDir: File,
+    tag: String,
+    block: () -> TestProjectRunner
+): TestProjectRunner {
+    Grgit.init {
+        dir = remoteGitDir
+    }
+    val localCopy = Grgit.clone {
+        dir = projectDir
+        uri = remoteGitDir.toURI().toString()
+    }
+    projectDir.resolve(".gitignore").writeText(
+        """
+.gradle/
+"""
+    )
+    val runner = block()
+    localCopy.add {
+        this.patterns = setOf(".")
+    }
+    localCopy.commit {
+        message = "Initial"
+    }
+    localCopy.tag.add {
+        name = tag
+    }
+    return runner
+}