Add nmcpPublishAggregationToMavenLocal (#192)

* Add nmcpPublishAggregationToMavenLocal

fixes #171

* fix task name

Author: martinbonnin

nmcp/src/main/kotlin/nmcp/internal/DefaultNmcpAggregationExtension.kt

@@ -24,7 +24,7 @@ internal abstract class DefaultNmcpAggregationExtension(private val project: Pro
         centralPortalConfigured = true
 
         project.registerPublishToCentralPortalTasks(
-            name = "aggregation",
+            kind = Kind.aggregation,
             inputFiles = allFiles,
             action = action
         )

nmcp/src/main/kotlin/nmcp/internal/DefaultNmcpExtension.kt

@@ -76,7 +76,7 @@ internal abstract class DefaultNmcpExtension(private val project: Project): Nmcp
         centralPortalConfigured = true
 
         project.registerPublishToCentralPortalTasks(
-            name = "allPublications",
+            kind = Kind.allPublications,
             inputFiles = m2Files,
             action = action
         )

nmcp/src/main/kotlin/nmcp/internal/task/nmcpPublishFileByFileToMavenLocal.kt

@@ -0,0 +1,27 @@
+package nmcp.internal.task
+
+import gratatouille.tasks.GInputFiles
+import gratatouille.tasks.GInternal
+import gratatouille.tasks.GLogger
+import gratatouille.tasks.GTask
+import java.io.File
+import kotlin.io.path.Path
+import nmcp.transport.FilesystemTransport
+import nmcp.transport.publishFileByFile
+
+@GTask(pure = false)
+internal fun nmcpPublishFileByFileToFileSystem(
+    logger: GLogger,
+    @GInternal
+    m2AbsolutePath: String,
+    inputFiles: GInputFiles,
+    parallelism: Int,
+) {
+    check(Path(m2AbsolutePath).isAbsolute) {
+        "Nmcp: path '$m2AbsolutePath' is not an absolute path"
+    }
+    logger.lifecycle("Nmcp: copying files to $m2AbsolutePath")
+
+    File(m2AbsolutePath).mkdirs()
+    publishFileByFile(FilesystemTransport(m2AbsolutePath), inputFiles, parallelism)
+}

nmcp/src/main/kotlin/nmcp/internal/utils.kt

@@ -1,13 +1,12 @@
 package nmcp.internal
 
 import gratatouille.wiring.capitalizeFirstLetter
+import java.io.File
 import nmcp.CentralPortalOptions
-import nmcp.internal.task.NmcpPublishWithPublisherApiTask
 import nmcp.internal.task.registerNmcpFindDeploymentNameTask
+import nmcp.internal.task.registerNmcpPublishFileByFileToFileSystemTask
 import nmcp.internal.task.registerNmcpPublishFileByFileToSnapshotsTask
 import nmcp.internal.task.registerNmcpPublishWithPublisherApiTask
-import nmcp.nmcpAggregationExtensionName
-import nmcp.nmcpExtensionName
 import nmcp.transport.defaultParallelism
 import org.gradle.api.Action
 import org.gradle.api.Named
@@ -17,7 +16,6 @@ import org.gradle.api.attributes.HasConfigurableAttributes
 import org.gradle.api.attributes.Usage
 import org.gradle.api.attributes.Usage.USAGE_ATTRIBUTE
 import org.gradle.api.file.FileCollection
-import org.gradle.api.provider.Property
 import org.gradle.api.publish.plugins.PublishingPlugin.PUBLISH_TASK_GROUP
 import org.gradle.api.tasks.bundling.Zip
 
@@ -52,31 +50,33 @@ internal fun HasConfigurableAttributes<*>.configureAttributes(project: Project)
     }
 }
 
+internal enum class Kind {
+    aggregation,
+    allPublications
+}
+
 internal fun Project.registerPublishToCentralPortalTasks(
-    name: String,
+    kind: Kind,
     inputFiles: FileCollection,
     action: Action<CentralPortalOptions>,
 ) {
+    val name = kind.name
     val spec = objects.newInstance(CentralPortalOptions::class.java)
     action.execute(spec)
 
     val releaseTaskName = "nmcpPublish${name.capitalizeFirstLetter()}ToCentralPortal"
     val snapshotTaskName = "nmcpPublish${name.capitalizeFirstLetter()}ToCentralPortalSnapshots"
+    val localTaskName = "nmcpPublish${name.capitalizeFirstLetter()}ToMavenLocal"
     val zipTaskName = "nmcpZip${name.capitalizeFirstLetter()}"
     val findDeploymentNameTaskName = "nmcpFind${name.capitalizeFirstLetter()}DeploymentName"
 
-    val shortcut = when(name) {
-        "aggregation",
-        "allPublications" -> name
-        else ->  null
-    }
     val description = when(name) {
         "aggregation" -> "Publishes the aggregation"
         "allPublications" -> "Publishes all the maven publications"
         else ->  null
     }
-    val lifecycleTaskName = shortcut?.let { "publish${it.capitalizeFirstLetter()}ToCentralPortal" }
-    val snapshotsLifecycleTaskName = shortcut?.let { "publish${it.capitalizeFirstLetter()}ToCentralPortalSnapshots" }
+    val centralPortalLifecycleTaskName = "publish${name.capitalizeFirstLetter()}ToCentralPortal"
+    val snapshotsLifecycleTaskName = "publish${name.capitalizeFirstLetter()}ToCentralPortalSnapshots"
 
     val zipName = "${name}.zip"
     val zipTaskProvider = tasks.register(zipTaskName, Zip::class.java) {
@@ -107,31 +107,34 @@ internal fun Project.registerPublishToCentralPortalTasks(
         validationTimeoutSeconds = spec.validationTimeout.map { it.seconds },
         publishingTimeoutSeconds = spec.publishingTimeout.map { it.seconds },
     )
-
-    if (lifecycleTaskName != null) {
-        project.tasks.register(lifecycleTaskName) {
-            it.group = PUBLISH_TASK_GROUP
-            it.description = "$description to the Central Releases repository."
-            it.dependsOn(task)
-        }
+    project.tasks.register(centralPortalLifecycleTaskName) {
+        it.group = PUBLISH_TASK_GROUP
+        it.description = "$description to the Central Releases repository."
+        it.dependsOn(task)
     }
 
-    val snapshots = registerNmcpPublishFileByFileToSnapshotsTask(
+    val centralSnapshots = registerNmcpPublishFileByFileToSnapshotsTask(
         taskName = snapshotTaskName,
         username = spec.username,
         password = spec.password,
         snapshotsUrl = project.provider { "https://central.sonatype.com/repository/maven-snapshots/" },
         inputFiles = inputFiles,
         parallelism = spec.uploadSnapshotsParallelism.orElse(defaultParallelism),
     )
-    if (snapshotsLifecycleTaskName != null) {
-        project.tasks.register(snapshotsLifecycleTaskName) {
-            it.group = PUBLISH_TASK_GROUP
-            it.description = "$description to the Central Snapshots repository."
-            it.dependsOn(snapshots)
-        }
+    project.tasks.register(snapshotsLifecycleTaskName) {
+        it.group = PUBLISH_TASK_GROUP
+        it.description = "$description to the Central Snapshots repository."
+        it.dependsOn(centralSnapshots)
     }
 
+    val m2File = File(System.getProperty("user.home")).resolve(".m2/repository")
+    registerNmcpPublishFileByFileToFileSystemTask(
+        taskName = localTaskName,
+        m2AbsolutePath = project.provider { m2File.absolutePath },
+        inputFiles = inputFiles,
+        parallelism = spec.uploadSnapshotsParallelism.orElse(defaultParallelism),
+    )
+
     /**
      * Detect early if the username and/or password are missing.
      * This gives feedback to the user before compiling all projects.