Merge pull request #329 from rahulsom/make-publishing-config-conditional

fix: Make publishing config conditional

Author: rahulsom

README.adoc

@@ -70,6 +70,24 @@ export ORG_GRADLE_PROJECT_signingKey=???
 export ORG_GRADLE_PROJECT_signingPassword=???
 ----
 
+=== Remote Publishing Setup
+
+Waena does not configure remote Sonatype/JReleaser publishing in included/composite builds by default.
+For standalone builds, it configures remote publishing only when a publishing-related task is requested
+(`snapshot`, `candidate`, `final`, tasks containing `publish`, `release`, `sonatype`, or `jreleaser`).
+This keeps regular `build`/`test` runs and composite builds from eagerly creating remote publishing repositories.
+
+You can override this behavior with a project property:
+
+[source,shell]
+----
+# Force-enable remote publishing setup
+./gradlew -PwaenaConfigureRemotePublishing=true test
+
+# Force-disable remote publishing setup
+./gradlew -PwaenaConfigureRemotePublishing=false final
+----
+
 === Publishing snapshots
 
 [source,shell]

waena-plugin/src/main/kotlin/com/github/rahulsom/waena/WaenaPublishedPlugin.kt

@@ -57,11 +57,11 @@ class WaenaPublishedPlugin : Plugin<Project> {
 
     if (target.rootProject == target) {
       target.rootProject.tasks.findByPath("release")?.dependsOn(":publish")
-      target.rootProject.tasks.getByPath("closeSonatypeStagingRepository").mustRunAfter(":publish")
+      target.rootProject.tasks.findByPath("closeSonatypeStagingRepository")?.mustRunAfter(":publish")
       target.rootProject.tasks.findByPath("jreleaserDeploy")?.mustRunAfter(":publish")
     } else {
       target.rootProject.tasks.findByPath("release")?.dependsOn(":${target.name}:publish")
-      target.rootProject.tasks.getByPath("closeSonatypeStagingRepository").mustRunAfter(":${target.name}:publish")
+      target.rootProject.tasks.findByPath("closeSonatypeStagingRepository")?.mustRunAfter(":${target.name}:publish")
       target.rootProject.tasks.findByPath("jreleaserDeploy")?.mustRunAfter(":${target.name}:publish")
     }
 
@@ -146,7 +146,7 @@ class WaenaPublishedPlugin : Plugin<Project> {
     val scmInfoPlugin = project.rootProject.plugins.getAt(ScmInfoPlugin::class.java)
     val originUrl = origin ?: scmInfoPlugin.findProvider(project).calculateOrigin(project)
 
-    val hostedRepoRegex =
+    @Suppress("RegExpRepeatedSpace", "RegExpUnexpectedAnchor") val hostedRepoRegex =
       Regex("""
         ^                               # Start of the string
         (?:https?://|git://|git@)       # Match the protocol (http, https, git) or git@

waena-plugin/src/main/kotlin/com/github/rahulsom/waena/WaenaRootPlugin.kt

@@ -22,6 +22,7 @@ class WaenaRootPlugin : Plugin<Project> {
 
   companion object {
     val CENTRAL = Pair("https://central.sonatype.com/repository/maven-snapshots/", "https://central.sonatype.com/api/v1/publisher")
+    const val CONFIGURE_REMOTE_PUBLISHING_PROPERTY = "waenaConfigureRemotePublishing"
   }
 
   override fun apply(target: Project) {
@@ -37,25 +38,37 @@ class WaenaRootPlugin : Plugin<Project> {
     rootProject.plugins.apply(TaskTreePlugin::class.java)
     rootProject.plugins.apply(InfoPlugin::class.java)
     val waenaExtension = rootProject.extensions.create("waena", WaenaExtension::class.java, rootProject)
+    val configureRemotePublishing = shouldConfigureRemotePublishing(rootProject)
 
     rootProject.allprojects.forEach { target ->
       target.plugins.apply(ContactsPlugin::class.java)
     }
 
-    configureNexusPublishPlugin(rootProject, waenaExtension)
+    if (configureRemotePublishing) {
+      configureNexusPublishPlugin(rootProject, waenaExtension)
 
-    rootProject.afterEvaluate {
-      if (!useNexusPublishPlugin(rootProject)) {
-        configureJReleaser(rootProject)
+      rootProject.afterEvaluate {
+        if (!useNexusPublishPlugin(rootProject)) {
+          configureJReleaser(rootProject)
+        }
       }
+    } else {
+      rootProject.logger.info(
+        "Skipping remote publishing configuration. " +
+            "Set -P$CONFIGURE_REMOTE_PUBLISHING_PROPERTY=true to force-enable it."
+      )
     }
   }
 
   private fun Project.configureJReleaser(rootProject: Project) {
     val isSnapshot = rootProject.version.toString().endsWith("-SNAPSHOT")
-    rootProject.tasks.getByPath(":initializeSonatypeStagingRepository").enabled = isSnapshot
-    rootProject.tasks.getByPath(":closeSonatypeStagingRepository").enabled = isSnapshot
-    rootProject.tasks.getByPath(":releaseSonatypeStagingRepository").enabled = isSnapshot
+    listOf(
+      ":initializeSonatypeStagingRepository",
+      ":closeSonatypeStagingRepository",
+      ":releaseSonatypeStagingRepository"
+    ).forEach { taskPath ->
+      rootProject.tasks.findByPath(taskPath)?.enabled = isSnapshot
+    }
     rootProject.allprojects.forEach { project ->
       project.afterEvaluate {
         project.tasks.findByName("publishNebulaPublicationToSonatypeRepository")?.enabled = isSnapshot
@@ -131,6 +144,36 @@ class WaenaRootPlugin : Plugin<Project> {
     return publishMode != WaenaExtension.PublishMode.Central
   }
 
+  private fun shouldConfigureRemotePublishing(rootProject: Project): Boolean {
+    rootProject.findProperty(CONFIGURE_REMOTE_PUBLISHING_PROPERTY)?.toString()?.let { configuredValue ->
+      configuredValue.toBooleanStrictOrNull()?.let { return it }
+      rootProject.logger.warn(
+        "Ignoring invalid value '$configuredValue' for $CONFIGURE_REMOTE_PUBLISHING_PROPERTY. " +
+            "Expected true or false."
+      )
+    }
+
+    if (rootProject.gradle.parent != null) {
+      return false
+    }
+
+    val requestedTasks = rootProject.gradle.startParameter.taskNames
+    if (requestedTasks.isEmpty()) {
+      return true
+    }
+    return requestedTasks
+      .map { taskPath -> taskPath.substringAfterLast(':') }
+      .any { taskName ->
+        taskName.equals("snapshot", ignoreCase = true)
+            || taskName.equals("candidate", ignoreCase = true)
+            || taskName.equals("final", ignoreCase = true)
+            || taskName.contains("publish", ignoreCase = true)
+            || taskName.contains("release", ignoreCase = true)
+            || taskName.contains("sonatype", ignoreCase = true)
+            || taskName.contains("jreleaser", ignoreCase = true)
+      }
+  }
+
   fun provideUrls(extension: WaenaExtension) = DefaultProvider({
     when (extension.publishMode.get()) {
       WaenaExtension.PublishMode.Central -> CENTRAL

waena-plugin/src/test/kotlin/com/github/rahulsom/waena/WaenaPluginFunctionalTest.kt

@@ -154,7 +154,7 @@ class WaenaPluginFunctionalTest {
 
   private fun showConfig(projectDir: File, gradleVersion: String?): String? {
     val showConfigRunner = baseRunner(projectDir, gradleVersion)
-    showConfigRunner.withArguments("showconfig")
+    showConfigRunner.withArguments("-P${WaenaRootPlugin.CONFIGURE_REMOTE_PUBLISHING_PROPERTY}=true", "showconfig")
     val showConfigResult = showConfigRunner.build().output
     return showConfigResult
   }