Support publishing to Maven Central

Author: jjohannes

build.gradle.kts

@@ -11,51 +11,75 @@ dependencies {
     implementation("com.gradle.publish:plugin-publish-plugin:2.0.0")
     implementation("com.gradle:common-custom-user-data-gradle-plugin:2.4.0")
     implementation("com.gradle:develocity-gradle-plugin:4.2.2")
+    implementation("com.gradleup.nmcp:nmcp:1.2.0")
     implementation("org.asciidoctor:asciidoctor-gradle-jvm:4.0.5")
     implementation("org.gradlex:jvm-dependency-conflict-resolution:2.4")
     implementation("org.gradlex:reproducible-builds:1.1")
 }
 
+dependencies.constraints {
+    implementation("org.jetbrains:annotations:13.0!!") {
+        because("This version is enforced by Gradle through the Kotlin plugin")
+    }
+}
+
 // ==== the following can be remove once we update the onventions to '0.7'
 group = "org.gradlex"
 java { toolchain.languageVersion = JavaLanguageVersion.of(17) }
 tasks.checkstyleMain { exclude("buildparameters/**") }
+// ====
+
 buildParameters {
-    pluginId("gradlexbuild.build-parameters")
+    pluginId("org.gradlex.internal.gradlex-build-parameters")
     bool("ci") {
-        description.set("Whether or not the build is running in a CI environment")
+        description = "Whether or not the build is running in a CI environment"
         fromEnvironment()
-        defaultValue.set(false)
+        defaultValue = false
     }
     group("signing") {
+        // allow to disable signing for locat testing
+        bool("disable") {
+            defaultValue = false
+        }
         // key and passphrase need default values because SigningExtension.useInMemoryPgpKeys does not accept providers
-        description.set("Details about artifact signing")
+        description = "Details about artifact signing"
         string("key") {
-            description.set("The ID of the PGP key to use for signing artifacts")
+            description = "The ID of the PGP key to use for signing artifacts"
             fromEnvironment()
-            defaultValue.set("UNSET")
+            defaultValue = "UNSET"
         }
         string("passphrase") {
-            description.set("The passphrase for the PGP key specified by signing.key")
+            description = "The passphrase for the PGP key specified by signing.key"
             fromEnvironment()
-            defaultValue.set("UNSET")
+            defaultValue = "UNSET"
         }
     }
     group("pluginPortal") {
         // The publish-plugin reads these values directly from System.env. We model them here
         // for completeness and documentation purposes.
-        description.set("Credentials for publishing to the plugin portal")
+        description = "Credentials for publishing to the plugin portal"
         string("key") {
-            description.set("The Plugin portal key for publishing the plugin")
+            description = "The Plugin portal key for publishing the plugin"
             fromEnvironment("GRADLE_PUBLISH_KEY")
         }
         string("secret") {
-            description.set("The Plugin portal secret for publishing the plugin")
+            description = "The Plugin portal secret for publishing the plugin"
             fromEnvironment("GRADLE_PUBLISH_SECRET")
         }
     }
+
+    group("mavenCentral") {
+        description = "Credentials for publishing to Maven Central"
+        string("username") {
+            description = "The Maven Central username for publishing"
+            fromEnvironment()
+        }
+        string("password") {
+            description = "The Maven Central password for publishing"
+            fromEnvironment()
+        }
+    }
 }
-// ====
 
 pluginPublishConventions {
     id("${project.group}.internal.gradlex-build-conventions")

src/main/java/org/gradlex/conventions/feature/PluginDefinition.java

@@ -17,6 +17,7 @@
 package org.gradlex.conventions.feature;
 
 import org.gradle.api.Action;
+import org.gradle.api.GradleException;
 import org.gradle.api.Project;
 import org.gradle.api.provider.Provider;
 import org.gradle.api.publish.maven.MavenPomDeveloper;
@@ -25,32 +26,39 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Set;
 
 @NullMarked
-public abstract class PluginPublishConventionsExtension extends PluginDefinition {
+public abstract class PublishingConventionsExtension {
 
-    public static final String NAME = "pluginPublishConventions";
+    public static final String NAME = "publishingConventions";
 
     private final Project project;
     private final GradlePluginDevelopmentExtension gradlePlugin;
+    private final List<PublishingDefinition> definitions = new ArrayList<>();
 
     List<Action<MavenPomDeveloper>> developers = new ArrayList<>();
 
-    public PluginPublishConventionsExtension(
+    public PublishingConventionsExtension(
             Project project,
             GradlePluginDevelopmentExtension gradlePlugin
     ) {
-        super(project.getName(), gradlePlugin);
         this.project = project;
         this.gradlePlugin = gradlePlugin;
     }
 
-    public void additionalPlugin(String id, Action<PluginDefinition> action) {
-        PluginDefinition plugin = project.getObjects().newInstance(PluginDefinition.class, id, gradlePlugin);
-        plugin.id(id);
-        plugin.pluginDefinition.getTags().set(getTags());
-        action.execute(plugin);
+    public void pluginPortal(String id, Action<PublishingPluginPortalDefinition> action) {
+        var definition = project.getObjects().newInstance(
+                PublishingPluginPortalDefinition.class, id, gradlePlugin, project.getProviders());
+        definitions.stream().filter(d -> d instanceof PublishingPluginPortalDefinition).findFirst().ifPresent(
+                d -> definition.getTags().set(((PublishingPluginPortalDefinition) d).getTags()));
+        action.execute(definition);
+        definitions.add(definition);
+    }
+
+    public void mavenCentral(Action<PublishingMavenCentralDefinition> action) {
+        var definition = project.getObjects().newInstance(PublishingMavenCentralDefinition.class);
+        action.execute(definition);
+        definitions.add(definition);
     }
 
     public void gitHub(String gitHub) {
@@ -66,31 +74,21 @@ public void developer(Action<MavenPomDeveloper> action) {
         developers.add(action);
     }
 
-    public Provider<String> getId() {
-        return project.getProviders().provider(pluginDefinition::getId);
+    public Provider<String> getGitHub() {
+        return gradlePlugin.getVcsUrl();
     }
 
-    public Provider<String> getImplementationClass() {
-        return project.getProviders().provider(pluginDefinition::getImplementationClass);
+    public Provider<String> getWebsite() {
+        return gradlePlugin.getWebsite();
     }
 
     public Provider<String> getDisplayName() {
-        return project.getProviders().provider(pluginDefinition::getDisplayName);
+        if (definitions.isEmpty()) { throw new GradleException("No publication defined"); }
+        return definitions.get(0).getDisplayName();
     }
 
     public Provider<String> getDescription() {
-        return project.getProviders().provider(pluginDefinition::getDescription);
-    }
-
-    public Provider<Set<String>> getTags() {
-        return pluginDefinition.getTags();
-    }
-
-    public Provider<String> getGitHub() {
-        return gradlePlugin.getVcsUrl();
-    }
-
-    public Provider<String> getWebsite() {
-        return gradlePlugin.getWebsite();
+        if (definitions.isEmpty()) { throw new GradleException("No publication defined"); }
+        return definitions.get(0).getDescription();
     }
 }

src/main/java/org/gradlex/conventions/feature/PluginPublishConventionsExtension.java renamed to src/main/java/org/gradlex/conventions/feature/PublishingConventionsExtension.java

@@ -19,6 +19,9 @@
 import buildparameters.BuildParametersExtension;
 import buildparameters.GeneratedBuildParametersPlugin;
 import com.gradle.publish.PublishPlugin;
+import nmcp.NmcpAggregationExtension;
+import nmcp.NmcpAggregationPlugin;
+import nmcp.NmcpPlugin;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.plugins.JavaPluginExtension;
@@ -32,36 +35,53 @@
 import static org.gradle.language.base.plugins.LifecycleBasePlugin.CHECK_TASK_NAME;
 
 @NullMarked
-public abstract class PluginPublishConventionsPlugin implements Plugin<Project> {
+public abstract class PublishingConventionsPlugin implements Plugin<Project> {
     @Override
     public void apply(Project project) {
         var plugins = project.getPlugins();
         var extensions = project.getExtensions();
         var tasks = project.getTasks();
+        var dependencies = project.getDependencies();
 
         plugins.apply(PublishPlugin.class);
+        plugins.apply(NmcpPlugin.class);
+        plugins.apply(NmcpAggregationPlugin.class);
         plugins.apply(SigningPlugin.class);
         plugins.apply(GeneratedBuildParametersPlugin.class);
 
         var java = extensions.getByType(JavaPluginExtension.class);
         var gradlePlugin = extensions.getByType(GradlePluginDevelopmentExtension.class);
         var publishing = extensions.getByType(PublishingExtension.class);
+        var nmcpAggregation = extensions.getByType(NmcpAggregationExtension.class);
         var signing = extensions.getByType(SigningExtension.class);
         var buildParameters = extensions.getByType(BuildParametersExtension.class);
         var pluginPublishConventions = extensions.create(
-                PluginPublishConventionsExtension.NAME, PluginPublishConventionsExtension.class,
+                PublishingConventionsExtension.NAME, PublishingConventionsExtension.class,
                 project, gradlePlugin);
 
         tasks.named("publishPlugins", task -> task.dependsOn(CHECK_TASK_NAME));
 
         java.withJavadocJar();
         java.withSourcesJar();
 
-        signing.useInMemoryPgpKeys(
-                buildParameters.getSigning().getKey(),
-                buildParameters.getSigning().getPassphrase()
-        );
+        // signing
+        signing.setRequired(!buildParameters.getSigning().getDisable());
+        if (signing.isRequired()) {
+            signing.useInMemoryPgpKeys(
+                    buildParameters.getSigning().getKey(),
+                    buildParameters.getSigning().getPassphrase()
+            );
+        }
 
+        // Maven Central
+        dependencies.add("nmcpAggregation", project.project(project.getPath())); // for NmcpAggregationPlugin
+        nmcpAggregation.centralPortal(central -> {
+            central.getUsername().set(buildParameters.getMavenCentral().getUsername());
+            central.getPassword().set(buildParameters.getMavenCentral().getPassword());
+            central.getPublishingType().set("AUTOMATIC"); // "USER_MANAGED"
+        });
+
+        // Metadata for all publications
         publishing.getPublications().withType(MavenPublication.class).configureEach(p -> {
             p.getPom().getName().set(pluginPublishConventions.getDisplayName());
             p.getPom().getDescription().set(pluginPublishConventions.getDescription());

src/main/java/org/gradlex/conventions/feature/PluginPublishConventionsPlugin.java renamed to src/main/java/org/gradlex/conventions/feature/PublishingConventionsPlugin.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright the GradleX team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.gradlex.conventions.feature;
+
+import org.gradle.api.provider.Provider;
+import org.jspecify.annotations.NullMarked;
+
+@NullMarked
+public interface PublishingDefinition {
+    Provider<String> getDisplayName();
+
+    Provider<String> getDescription();
+}

src/main/java/org/gradlex/conventions/feature/PublishingDefinition.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright the GradleX team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.gradlex.conventions.feature;
+
+import org.gradle.api.provider.Property;
+import org.jspecify.annotations.NullMarked;
+
+@NullMarked
+public abstract class PublishingMavenCentralDefinition implements PublishingDefinition {
+
+    public abstract Property<String> getDisplayName();
+
+    public abstract Property<String> getDescription();
+
+    public void displayName(String displayName) {
+        getDisplayName().set(displayName);
+    }
+
+    public void description(String description) {
+        getDescription().set(description);
+    }
+}