Rename publish to release terminology and add comprehensive Javadoc

- Rename classes: RegistryPublishConfig -> RegistryReleaseConfig, RegistryPublishException -> RegistryReleaseException, RegistryUploadTask -> RegistryReleaseTask
- Rename methods: publish() -> release()
- Update API endpoint: v1/plugins/publish -> v1/plugins/release
- Update form field: file -> artifact
- Update variable names and comments from publish to release terminology
- Add comprehensive Javadoc documentation to all registry classes and methods

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: pditommaso

src/main/groovy/io/nextflow/gradle/NextflowPlugin.groovy

@@ -1,6 +1,6 @@
 package io.nextflow.gradle
 
-import io.nextflow.gradle.registry.RegistryUploadTask
+import io.nextflow.gradle.registry.RegistryReleaseTask
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.plugins.GroovyPlugin
@@ -124,26 +124,26 @@ class NextflowPlugin implements Plugin<Project> {
 
         project.afterEvaluate {
             if (config.publishing) {
-                // track the publish tasks
-                def publishTasks = []
+                // track the release tasks
+                def releaseTasks = []
 
-                // add registry publish task, if configured
+                // add registry release task, if configured
                 if (config.publishing.registry) {
-                    // releasePluginToRegistry - publishes plugin to a plugin registry
-                    project.tasks.register('releasePluginToRegistry', RegistryUploadTask)
+                    // releasePluginToRegistry - releases plugin to a plugin registry
+                    project.tasks.register('releasePluginToRegistry', RegistryReleaseTask)
                     project.tasks.releasePluginToRegistry.dependsOn << project.tasks.packagePlugin
-                    publishTasks << project.tasks.releasePluginToRegistry
+                    releaseTasks << project.tasks.releasePluginToRegistry
                 }
 
 
                 // finally, configure the destination-agnostic 'release' task
-                if (!publishTasks.isEmpty()) {
-                    // releasePlugin - all the release/publishing actions
+                if (!releaseTasks.isEmpty()) {
+                    // releasePlugin - all the release actions
                     project.tasks.register('releasePlugin', {
                         group = 'Nextflow Plugin'
                         description = 'Release plugin to configured destination'
                     })
-                    for (task in publishTasks) {
+                    for (task in releaseTasks) {
                         project.tasks.releasePlugin.dependsOn << task
                     }
                 }

src/main/groovy/io/nextflow/gradle/NextflowPluginConfig.groovy

@@ -57,9 +57,9 @@ class NextflowPluginConfig {
     List<String> extensionPoints = []
 
     /**
-     * Configure how the plugin will be published (optional)
+     * Configure how the plugin will be released (optional)
      */
-    PluginPublishConfig publishing
+    PluginReleaseConfig publishing
 
     NextflowPluginConfig(Project project) {
         this.project = project
@@ -89,7 +89,7 @@ class NextflowPluginConfig {
 
     // initialises the 'publishing' sub-config
     def publishing(Closure config) {
-        publishing = new PluginPublishConfig(project)
+        publishing = new PluginReleaseConfig(project)
         project.configure(publishing, config)
         publishing.validate()
     }

src/main/groovy/io/nextflow/gradle/PluginPublishConfig.groovy renamed to src/main/groovy/io/nextflow/gradle/PluginReleaseConfig.groovy

@@ -1,30 +1,30 @@
 package io.nextflow.gradle
 
 import groovy.transform.CompileStatic
-import io.nextflow.gradle.registry.RegistryPublishConfig
+import io.nextflow.gradle.registry.RegistryReleaseConfig
 import org.gradle.api.Project
 
 /**
  * A gradle 'extension' to hold the 'nextflowPlugin.publishing'
  * configuration from build.gradle.
  */
 @CompileStatic
-class PluginPublishConfig {
+class PluginReleaseConfig {
     private final Project project
 
     /**
-     * Configuration for publishing to a registry
+     * Configuration for releasing to a registry
      */
-    RegistryPublishConfig registry
+    RegistryReleaseConfig registry
 
-    PluginPublishConfig(Project project) {
+    PluginReleaseConfig(Project project) {
         this.project = project
     }
 
     def validate() {}
 
     def registry(Closure config) {
-        registry = new RegistryPublishConfig(project)
+        registry = new RegistryReleaseConfig(project)
         project.configure(registry, config)
     }
 }

src/main/groovy/io/nextflow/gradle/registry/RegistryClient.groovy

@@ -8,38 +8,62 @@ import org.apache.http.entity.mime.MultipartEntityBuilder
 import org.apache.http.impl.client.HttpClients
 import org.apache.http.util.EntityUtils
 
+/**
+ * HTTP client for communicating with a Nextflow plugin registry.
+ * 
+ * This client handles authentication and multipart form uploads
+ * to release plugins to a registry service via REST API.
+ */
 @Slf4j
 @CompileStatic
 class RegistryClient {
     private final URI url
     private final String authToken
 
+    /**
+     * Creates a new registry client.
+     * 
+     * @param url The base URL of the registry API endpoint
+     * @param authToken The bearer token for authentication
+     * @throws RegistryReleaseException if authToken is null or empty
+     */
     RegistryClient(URI url, String authToken) {
         if (!authToken)
-            throw new RegistryPublishException("Authentication token not specified - Provide a valid token in 'publishing.registry' configuration")
+            throw new RegistryReleaseException("Authentication token not specified - Provide a valid token in 'publishing.registry' configuration")
         this.url = !url.toString().endsWith("/")
             ? URI.create(url.toString() + "/")
             : url
         this.authToken = authToken
     }
 
-    def publish(String id, String version, File file) {
-        def req = new HttpPost(url.resolve("v1/plugins/publish"))
+    /**
+     * Releases a plugin to the registry.
+     * 
+     * Uploads the plugin zip file along with metadata to the registry
+     * using a multipart HTTP POST request to the v1/plugins/release endpoint.
+     * 
+     * @param id The plugin identifier/name
+     * @param version The plugin version (must be valid semver)
+     * @param file The plugin zip file to upload
+     * @throws RegistryReleaseException if the upload fails or returns an error
+     */
+    def release(String id, String version, File file) {
+        def req = new HttpPost(url.resolve("v1/plugins/release"))
         req.addHeader("Authorization", "Bearer ${authToken}")
         req.setEntity(MultipartEntityBuilder.create()
             .addTextBody("id", id)
             .addTextBody("version", version)
-            .addBinaryBody("file", file)
+            .addBinaryBody("artifact", file)
             .build())
 
         try (def http = HttpClients.createDefault();
              def rep = http.execute(req)) {
 
             if (rep.statusLine.statusCode != 200) {
-                throw new RegistryPublishException(getErrorMessage(rep))
+                throw new RegistryReleaseException(getErrorMessage(rep))
             }
         } catch (ConnectException | UnknownHostException e) {
-            throw new RegistryPublishException("Unable to connect to plugin repository: ${e.message}", e)
+            throw new RegistryReleaseException("Unable to connect to plugin repository: ${e.message}", e)
         }
     }
 

src/main/groovy/io/nextflow/gradle/registry/RegistryPublishConfig.groovy

@@ -0,0 +1,31 @@
+package io.nextflow.gradle.registry
+
+import groovy.transform.CompileStatic
+import org.gradle.api.Project
+
+/**
+ * Configuration for releasing plugins to a registry.
+ * 
+ * This class holds the registry URL and authentication token
+ * needed to upload plugins to a registry service.
+ */
+@CompileStatic
+class RegistryReleaseConfig {
+    private final Project project
+
+    /**
+     * The registry API base URL.
+     * Defaults to the official Nextflow registry.
+     */
+    String url = 'https://registry.nextflow.io/api'
+
+    /**
+     * The authentication token (bearer token) for registry access.
+     * Required for uploading plugins to the registry.
+     */
+    String authToken
+
+    RegistryReleaseConfig(Project project) {
+        this.project = project
+    }
+}

src/main/groovy/io/nextflow/gradle/registry/RegistryPublishException.groovy

@@ -0,0 +1,31 @@
+package io.nextflow.gradle.registry
+
+import org.gradle.api.GradleException
+
+/**
+ * Exception thrown when plugin registry operations fail.
+ * 
+ * This exception is used to wrap and report errors that occur
+ * during plugin upload to a registry, including network errors,
+ * authentication failures, and API response errors.
+ */
+class RegistryReleaseException extends GradleException{
+    /**
+     * Creates a new registry release exception with the given message.
+     * 
+     * @param message The error message
+     */
+    RegistryReleaseException(String message) {
+        super(message)
+    }
+
+    /**
+     * Creates a new registry release exception with the given message and cause.
+     * 
+     * @param message The error message
+     * @param cause The underlying exception that caused this error
+     */
+    RegistryReleaseException(String message, Throwable cause) {
+        super(message, cause)
+    }
+}

src/main/groovy/io/nextflow/gradle/registry/RegistryReleaseConfig.groovy

@@ -0,0 +1,54 @@
+package io.nextflow.gradle.registry
+
+import groovy.transform.CompileStatic
+import io.nextflow.gradle.NextflowPluginConfig
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.TaskAction
+
+/**
+ * Gradle task for releasing a Nextflow plugin to a registry.
+ * 
+ * This task uploads the assembled plugin zip file to a configured registry
+ * using the registry's REST API. The plugin zip file is sent as a multipart
+ * form request along with the plugin ID and version metadata.
+ */
+@CompileStatic
+class RegistryReleaseTask extends DefaultTask {
+    /**
+     * The plugin zip file to be uploaded to the registry.
+     * By default, this points to the zip file created by the packagePlugin task.
+     */
+    @InputFile
+    final RegularFileProperty zipFile
+
+    RegistryReleaseTask() {
+        group = 'Nextflow Plugin'
+        description = 'Release the assembled plugin to the registry'
+
+        final buildDir = project.layout.buildDirectory.get()
+        zipFile = project.objects.fileProperty()
+        zipFile.convention(project.provider {
+            buildDir.file("distributions/${project.name}-${project.version}.zip")
+        })
+    }
+
+    /**
+     * Executes the registry release task.
+     * 
+     * This method retrieves the plugin configuration and creates a RegistryClient
+     * to upload the plugin zip file to the configured registry endpoint.
+     * 
+     * @throws RegistryReleaseException if the upload fails
+     */
+    @TaskAction
+    def run() {
+        final version = project.version.toString()
+        final plugin = project.extensions.getByType(NextflowPluginConfig)
+        final config = plugin.publishing.registry
+
+        def client = new RegistryClient(new URI(config.url), config.authToken)
+        client.release(project.name, version, project.file(zipFile))
+    }
+}