Use more extensions on TaskContainer and Project

api/shadow.api

@@ -4,17 +4,18 @@ public abstract class com/github/jengelman/gradle/plugins/shadow/ShadowApplicati
 	public static final field SHADOW_RUN_TASK_NAME Ljava/lang/String;
 	public static final field SHADOW_SCRIPTS_TASK_NAME Ljava/lang/String;
 	public fun <init> ()V
-	protected fun addCreateScriptsTask ()V
-	protected fun addRunTask ()V
+	protected fun addCreateScriptsTask (Lorg/gradle/api/Project;)V
+	protected fun addRunTask (Lorg/gradle/api/Project;)V
 	public synthetic fun apply (Ljava/lang/Object;)V
 	public fun apply (Lorg/gradle/api/Project;)V
-	protected fun configureDistSpec ()V
-	protected fun configureInstallTask ()V
-	protected fun configureJarMainClass ()V
-	protected final fun getShadowJar ()Lorg/gradle/api/tasks/TaskProvider;
+	protected fun configureDistSpec (Lorg/gradle/api/Project;)V
+	protected fun configureInstallTask (Lorg/gradle/api/Project;)V
+	protected fun configureJarMainClass (Lorg/gradle/api/Project;)V
 }
 
 public final class com/github/jengelman/gradle/plugins/shadow/ShadowApplicationPlugin$Companion {
+	public final fun getInstallShadowDist (Lorg/gradle/api/tasks/TaskContainer;)Lorg/gradle/api/tasks/TaskProvider;
+	public final fun getStartShadowScripts (Lorg/gradle/api/tasks/TaskContainer;)Lorg/gradle/api/tasks/TaskProvider;
 }
 
 public abstract class com/github/jengelman/gradle/plugins/shadow/ShadowBasePlugin : org/gradle/api/Plugin {
@@ -31,6 +32,7 @@ public abstract class com/github/jengelman/gradle/plugins/shadow/ShadowBasePlugi
 }
 
 public final class com/github/jengelman/gradle/plugins/shadow/ShadowBasePlugin$Companion {
+	public final fun getShadow (Lorg/gradle/api/artifacts/ConfigurationContainer;)Lorg/gradle/api/NamedDomainObjectProvider;
 }
 
 public abstract class com/github/jengelman/gradle/plugins/shadow/ShadowExtension {
@@ -45,9 +47,15 @@ public abstract class com/github/jengelman/gradle/plugins/shadow/ShadowJavaPlugi
 	public fun <init> (Lorg/gradle/api/component/SoftwareComponentFactory;)V
 	public synthetic fun apply (Ljava/lang/Object;)V
 	public fun apply (Lorg/gradle/api/Project;)V
+	protected fun configureComponents (Lorg/gradle/api/Project;)V
+	protected fun configureConfigurations (Lorg/gradle/api/Project;)V
+	protected fun configureJavaGradlePlugin (Lorg/gradle/api/Project;)V
+	protected fun configureShadowJar (Lorg/gradle/api/Project;)V
 }
 
 public final class com/github/jengelman/gradle/plugins/shadow/ShadowJavaPlugin$Companion {
+	public final fun getShadowJar (Lorg/gradle/api/tasks/TaskContainer;)Lorg/gradle/api/tasks/TaskProvider;
+	public final fun getShadowRuntimeElements (Lorg/gradle/api/artifacts/ConfigurationContainer;)Lorg/gradle/api/NamedDomainObjectProvider;
 }
 
 public abstract class com/github/jengelman/gradle/plugins/shadow/ShadowPlugin : org/gradle/api/Plugin {

src/main/kotlin/com/github/jengelman/gradle/plugins/shadow/ShadowApplicationPlugin.kt

@@ -1,99 +1,90 @@
 package com.github.jengelman.gradle.plugins.shadow
 
+import com.github.jengelman.gradle.plugins.shadow.ShadowBasePlugin.Companion.shadow
+import com.github.jengelman.gradle.plugins.shadow.ShadowJavaPlugin.Companion.shadowJar
+import com.github.jengelman.gradle.plugins.shadow.internal.applicationExtension
+import com.github.jengelman.gradle.plugins.shadow.internal.distributions
+import com.github.jengelman.gradle.plugins.shadow.internal.javaPluginExtension
+import com.github.jengelman.gradle.plugins.shadow.internal.javaToolchainService
 import com.github.jengelman.gradle.plugins.shadow.internal.requireResourceAsText
-import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 import org.gradle.api.GradleException
 import org.gradle.api.Plugin
 import org.gradle.api.Project
-import org.gradle.api.distribution.DistributionContainer
 import org.gradle.api.plugins.ApplicationPlugin
-import org.gradle.api.plugins.JavaApplication
-import org.gradle.api.plugins.JavaPluginExtension
 import org.gradle.api.tasks.JavaExec
 import org.gradle.api.tasks.Sync
+import org.gradle.api.tasks.TaskContainer
 import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.tasks.application.CreateStartScripts
 import org.gradle.jvm.application.scripts.TemplateBasedScriptGenerator
-import org.gradle.jvm.toolchain.JavaToolchainService
 
 public abstract class ShadowApplicationPlugin : Plugin<Project> {
-  private lateinit var project: Project
-  private lateinit var javaApplication: JavaApplication
-
   override fun apply(project: Project) {
-    this.project = project
-    this.javaApplication = project.extensions.getByType(JavaApplication::class.java)
-
-    addRunTask()
-    addCreateScriptsTask()
-    configureDistSpec()
-    configureJarMainClass()
-    configureInstallTask()
+    project.addRunTask()
+    project.addCreateScriptsTask()
+    project.configureDistSpec()
+    project.configureJarMainClass()
+    project.configureInstallTask()
   }
 
-  protected open fun configureJarMainClass() {
-    val classNameProvider = javaApplication.mainClass
-    shadowJar.configure { task ->
-      task.inputs.property("mainClassName", classNameProvider)
+  protected open fun Project.configureJarMainClass() {
+    val mainClassName = applicationExtension.mainClass
+    tasks.shadowJar.configure { task ->
+      task.inputs.property("mainClassName", mainClassName)
       task.doFirst {
         // Inject the Main-Class attribute if it is not already present.
         if (!task.manifest.attributes.contains("Main-Class")) {
-          task.manifest.attributes["Main-Class"] = classNameProvider.get()
+          task.manifest.attributes["Main-Class"] = mainClassName.get()
         }
       }
     }
   }
 
-  protected open fun addRunTask() {
-    project.tasks.register(SHADOW_RUN_TASK_NAME, JavaExec::class.java) { task ->
+  protected open fun Project.addRunTask() {
+    val extension = applicationExtension
+    tasks.register(SHADOW_RUN_TASK_NAME, JavaExec::class.java) { task ->
       task.description = "Runs this project as a JVM application using the shadow jar"
       task.group = ApplicationPlugin.APPLICATION_GROUP
-      task.dependsOn(installShadowDist)
 
-      val jarFile = installShadowDist.zip(shadowJar) { i, s ->
+      val jarFile = tasks.installShadowDist.zip(tasks.shadowJar) { i, s ->
         i.destinationDir.resolve("lib/${s.archiveFile.get().asFile.name}")
       }
       task.classpath(jarFile)
-      task.mainClass.set(javaApplication.mainClass)
-      task.conventionMapping.map("jvmArgs", javaApplication::getApplicationDefaultJvmArgs)
-      val toolchain = project.extensions.getByType(JavaPluginExtension::class.java).toolchain
-      val defaultLauncher = project.extensions.getByType(JavaToolchainService::class.java).launcherFor(toolchain)
-      task.javaLauncher.set(defaultLauncher)
+      task.mainClass.set(extension.mainClass)
+      task.conventionMapping.map("jvmArgs", extension::getApplicationDefaultJvmArgs)
+      task.javaLauncher.set(javaToolchainService.launcherFor(javaPluginExtension.toolchain))
     }
   }
 
   /**
    * Syncs with [ApplicationPlugin.addCreateScriptsTask](https://github.com/gradle/gradle/blob/bcecbb416f19438c7532e309456e3c3ed287f8f5/platforms/jvm/plugins-application/src/main/java/org/gradle/api/plugins/ApplicationPlugin.java#L184-L203).
    */
-  protected open fun addCreateScriptsTask() {
-    project.tasks.register(SHADOW_SCRIPTS_TASK_NAME, CreateStartScripts::class.java) { task ->
+  protected open fun Project.addCreateScriptsTask() {
+    val extension = applicationExtension
+    tasks.register(SHADOW_SCRIPTS_TASK_NAME, CreateStartScripts::class.java) { task ->
       task.description = "Creates OS specific scripts to run the project as a JVM application using the shadow jar"
       task.group = ApplicationPlugin.APPLICATION_GROUP
 
-      val unixStartScript =
-        requireResourceAsText("com/github/jengelman/gradle/plugins/shadow/internal/unixStartScript.txt")
-      val windowsStartScript =
-        requireResourceAsText("com/github/jengelman/gradle/plugins/shadow/internal/windowsStartScript.txt")
+      val dir = "com/github/jengelman/gradle/plugins/shadow/internal"
       (task.unixStartScriptGenerator as TemplateBasedScriptGenerator).template =
-        project.resources.text.fromString(unixStartScript)
+        resources.text.fromString(requireResourceAsText("$dir/unixStartScript.txt"))
       (task.windowsStartScriptGenerator as TemplateBasedScriptGenerator).template =
-        project.resources.text.fromString(windowsStartScript)
-
-      task.classpath = project.files(shadowJar)
-      task.mainModule.set(javaApplication.mainModule)
-      task.mainClass.set(javaApplication.mainClass)
-      task.conventionMapping.map("applicationName", javaApplication::getApplicationName)
-      task.conventionMapping.map("outputDir") { project.layout.buildDirectory.dir("scriptsShadow").get().asFile }
-      task.conventionMapping.map("executableDir", javaApplication::getExecutableDir)
-      task.conventionMapping.map("defaultJvmOpts", javaApplication::getApplicationDefaultJvmArgs)
-      val javaPluginExtension = project.extensions.getByType(JavaPluginExtension::class.java)
+        resources.text.fromString(requireResourceAsText("$dir/windowsStartScript.txt"))
+
+      task.classpath = files(tasks.shadowJar)
+      task.mainModule.set(extension.mainModule)
+      task.mainClass.set(extension.mainClass)
+      task.conventionMapping.map("applicationName", extension::getApplicationName)
+      task.conventionMapping.map("outputDir") { layout.buildDirectory.dir("scriptsShadow").get().asFile }
+      task.conventionMapping.map("executableDir", extension::getExecutableDir)
+      task.conventionMapping.map("defaultJvmOpts", extension::getApplicationDefaultJvmArgs)
       task.modularity.inferModulePath.convention(javaPluginExtension.modularity.inferModulePath)
     }
   }
 
-  protected open fun configureInstallTask() {
-    installShadowDist.configure { task ->
-      val applicationName = project.providers.provider { javaApplication.applicationName }
+  protected open fun Project.configureInstallTask() {
+    tasks.installShadowDist.configure { task ->
+      val applicationName = providers.provider { applicationExtension.applicationName }
 
       task.doFirst {
         if (
@@ -120,32 +111,31 @@ public abstract class ShadowApplicationPlugin : Plugin<Project> {
     }
   }
 
-  protected open fun configureDistSpec() {
-    project.extensions.getByType(DistributionContainer::class.java)
-      .register(ShadowBasePlugin.DISTRIBUTION_NAME) { distributions ->
-        distributions.contents { contents ->
-          contents.from(project.file("src/dist"))
-          contents.into("lib") { lib ->
-            lib.from(shadowJar)
-            lib.from(project.configurations.named(ShadowBasePlugin.CONFIGURATION_NAME))
-          }
-          contents.into("bin") { bin ->
-            bin.from(project.tasks.named(SHADOW_SCRIPTS_TASK_NAME))
-            bin.filePermissions { it.unix(493) }
-          }
+  protected open fun Project.configureDistSpec() {
+    distributions.register(ShadowBasePlugin.DISTRIBUTION_NAME) { distributions ->
+      distributions.contents { contents ->
+        contents.from(file("src/dist"))
+        contents.into("lib") { lib ->
+          lib.from(tasks.shadowJar)
+          lib.from(configurations.shadow)
+        }
+        contents.into("bin") { bin ->
+          bin.from(tasks.startShadowScripts)
+          bin.filePermissions { it.unix(493) }
         }
       }
+    }
   }
 
-  protected val shadowJar: TaskProvider<ShadowJar>
-    get() = project.tasks.named(ShadowJavaPlugin.SHADOW_JAR_TASK_NAME, ShadowJar::class.java)
-
-  private val installShadowDist: TaskProvider<Sync>
-    get() = project.tasks.named(SHADOW_INSTALL_TASK_NAME, Sync::class.java)
-
   public companion object {
     public const val SHADOW_RUN_TASK_NAME: String = "runShadow"
     public const val SHADOW_SCRIPTS_TASK_NAME: String = "startShadowScripts"
     public const val SHADOW_INSTALL_TASK_NAME: String = "installShadowDist"
+
+    public inline val TaskContainer.startShadowScripts: TaskProvider<CreateStartScripts>
+      get() = named(SHADOW_SCRIPTS_TASK_NAME, CreateStartScripts::class.java)
+
+    public inline val TaskContainer.installShadowDist: TaskProvider<Sync>
+      get() = named(SHADOW_INSTALL_TASK_NAME, Sync::class.java)
   }
 }

src/main/kotlin/com/github/jengelman/gradle/plugins/shadow/ShadowBasePlugin.kt

@@ -2,8 +2,11 @@ package com.github.jengelman.gradle.plugins.shadow
 
 import com.github.jengelman.gradle.plugins.shadow.tasks.KnowsTask
 import org.gradle.api.GradleException
+import org.gradle.api.NamedDomainObjectProvider
 import org.gradle.api.Plugin
 import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.artifacts.ConfigurationContainer
 import org.gradle.util.GradleVersion
 
 public abstract class ShadowBasePlugin : Plugin<Project> {
@@ -27,5 +30,8 @@ public abstract class ShadowBasePlugin : Plugin<Project> {
     public const val CONFIGURATION_NAME: String = SHADOW
     public const val COMPONENT_NAME: String = SHADOW
     public const val DISTRIBUTION_NAME: String = SHADOW
+
+    public inline val ConfigurationContainer.shadow: NamedDomainObjectProvider<Configuration>
+      get() = named(CONFIGURATION_NAME)
   }
 }