Use only lazy task configuration where possible

Author: ileasile

build-plugin/src/build/CreateResourcesTask.kt

@@ -1,6 +1,8 @@
 package build
 
+import org.gradle.api.Action
 import org.gradle.api.DefaultTask
+import org.gradle.api.Project
 import org.gradle.api.provider.Property
 import org.gradle.api.tasks.Copy
 import org.gradle.api.tasks.OutputDirectory
@@ -54,14 +56,25 @@ abstract class CreateResourcesTask : DefaultTask() {
         addPropertiesFile(subPath, values.associate { it })
     }
 
-    fun setupDependencies(resourceTask: Copy) {
+    private fun setupDependencies(resourceTask: Copy) {
         resourceTask.apply {
             dependsOn(this@CreateResourcesTask)
             from(outputResourceDir)
         }
     }
 
-    fun setupDependencies(resourceTaskProvider: TaskProvider<out Copy>) {
-        setupDependencies(resourceTaskProvider.get())
+    companion object {
+        fun register(
+            project: Project,
+            name: String,
+            resourceTaskProvider: TaskProvider<out Copy>,
+            action: Action<CreateResourcesTask>,
+        ): TaskProvider<CreateResourcesTask> {
+            val task = project.tasks.register(name, CreateResourcesTask::class.java, action)
+            resourceTaskProvider.configure {
+                task.get().setupDependencies(this)
+            }
+            return task
+        }
     }
 }

build-plugin/src/build/InstallTasksConfigurator.kt

@@ -14,7 +14,7 @@ class InstallTasksConfigurator(
     private val project: Project,
     private val settings: RootSettingsExtension,
 ) {
-    fun createLocalInstallTasks() {
+    fun registerLocalInstallTasks() {
         project.tasks.register<Copy>(COPY_RUN_KERNEL_PY_TASK) {
             group = LOCAL_INSTALL_GROUP
             dependsOn(makeTaskName(settings.cleanInstallDirTaskPrefix, true))
@@ -31,19 +31,19 @@ class InstallTasksConfigurator(
             into(settings.localInstallDir)
         }
 
-        createInstallTasks(true, settings.localInstallDir, settings.localInstallDir)
+        registerInstallTasks(true, settings.localInstallDir, settings.localInstallDir)
 
-        project.task(UNINSTALL_TASK) {
+        project.tasks.register(UNINSTALL_TASK) {
             group = LOCAL_INSTALL_GROUP
             dependsOn(makeTaskName(settings.cleanInstallDirTaskPrefix, false))
         }
     }
 
-    fun createInstallTasks(local: Boolean, specPath: File, mainInstallPath: File) {
+    fun registerInstallTasks(local: Boolean, specPath: File, mainInstallPath: File) {
         val groupName = if (local) LOCAL_INSTALL_GROUP else DISTRIBUTION_GROUP
         val cleanDirTask = project.tasks.getByName(makeTaskName(settings.cleanInstallDirTaskPrefix, local))
         val shadowJar = project.tasks.getByName(SHADOW_JAR_TASK)
-        val updateLibrariesTask = project.tasks.named(UPDATE_LIBRARIES_TASK_NAME)
+        val updateLibrariesTask = project.tasks.named(UPDATE_LIBRARIES_TASK)
 
         project.tasks.register<Copy>(makeTaskName(settings.copyLibrariesTaskPrefix, local)) {
             dependsOn(cleanDirTask, updateLibrariesTask)
@@ -67,12 +67,12 @@ class InstallTasksConfigurator(
         }
 
         listOf(true, false).forEach { debug ->
-            val specTaskName = createTaskForSpecs(debug, local, groupName, cleanDirTask, shadowJar, specPath, mainInstallPath)
-            createMainInstallTask(debug, local, groupName, specTaskName)
+            val specTaskName = registerTaskForSpecs(debug, local, groupName, cleanDirTask, shadowJar, specPath, mainInstallPath)
+            registerMainInstallTask(debug, local, groupName, specTaskName)
         }
     }
 
-    private fun createTaskForSpecs(debug: Boolean, local: Boolean, group: String, cleanDir: Task, shadowJar: Task, specPath: File, mainInstallPath: File): String {
+    private fun registerTaskForSpecs(debug: Boolean, local: Boolean, group: String, cleanDir: Task, shadowJar: Task, specPath: File, mainInstallPath: File): String {
         val taskName = makeTaskName(if (debug) "createDebugSpecs" else "createSpecs", local)
         project.tasks.register(taskName) {
             this.group = group
@@ -101,7 +101,7 @@ class InstallTasksConfigurator(
         return taskName
     }
 
-    private fun createMainInstallTask(debug: Boolean, local: Boolean, group: String, specsTaskName: String) {
+    private fun registerMainInstallTask(debug: Boolean, local: Boolean, group: String, specsTaskName: String) {
         val taskNamePrefix = if (local) "install" else "prepare"
         val taskNameMiddle = if (debug) "Debug" else ""
         val taskNameSuffix = if (local) "" else "Package"
@@ -116,7 +116,7 @@ class InstallTasksConfigurator(
             makeTaskName(settings.copyLibrariesTaskPrefix, local)
         )
 
-        project.task(taskName) {
+        project.tasks.register(taskName) {
             this.group = group
             dependsOn(dependencies)
         }

build-plugin/src/build/KernelBuildConfigurator.kt

@@ -20,8 +20,8 @@ import org.gradle.api.Project
 import org.gradle.api.tasks.Copy
 import org.gradle.jvm.tasks.Jar
 import org.gradle.kotlin.dsl.configure
-import org.gradle.kotlin.dsl.create
 import org.gradle.kotlin.dsl.named
+import org.gradle.kotlin.dsl.register
 import org.gradle.kotlin.dsl.withType
 import org.jlleitschuh.gradle.ktlint.KtlintExtension
 import kotlin.collections.component1
@@ -44,7 +44,7 @@ internal class KernelBuildConfigurator(private val project: Project) {
         setupVersionsPlugin()
         setupKtLintForAllProjects()
 
-        createUpdateLibrariesTask()
+        registerUpdateLibrariesTask()
 
         println("##teamcity[buildNumber '${settings.pyPackageVersion}']")
         println("##teamcity[setParameter name='mavenVersion' value='${settings.mavenVersion}']")
@@ -74,16 +74,16 @@ internal class KernelBuildConfigurator(private val project: Project) {
         registerLibrariesUpdateTasks()
 
         /****** Build tasks ******/
-        createPropertiesTask()
+        registerPropertiesTask()
         registerCleanTasks()
 
         /****** Local install ******/
         val installTasksConfigurator = InstallTasksConfigurator(project, settings)
-        installTasksConfigurator.createLocalInstallTasks()
+        installTasksConfigurator.registerLocalInstallTasks()
 
         /****** Distribution ******/
         registerDistributionTasks()
-        installTasksConfigurator.createInstallTasks(false, settings.distribKernelDir, settings.runKernelDir)
+        installTasksConfigurator.registerInstallTasks(false, settings.distribKernelDir, settings.runKernelDir)
         registerPythonPackageTasks()
         registerAggregateUploadTasks()
 
@@ -110,8 +110,8 @@ internal class KernelBuildConfigurator(private val project: Project) {
         }
     }
 
-    private fun createUpdateLibrariesTask() {
-        UpdateLibrariesTask.getOrCreate(project)
+    private fun registerUpdateLibrariesTask() {
+        project.tasks.register<UpdateLibrariesTask>(UPDATE_LIBRARIES_TASK)
     }
 
     private fun registerCleanTasks() {
@@ -169,7 +169,7 @@ internal class KernelBuildConfigurator(private val project: Project) {
         LibraryUpdateTasksConfigurator(project, settings).registerTasks()
     }
 
-    private fun createPropertiesTask() {
+    private fun registerPropertiesTask() {
         val properties = buildProperties {
             add("version" to settings.pyPackageVersion)
             add("currentBranch" to project.getCurrentBranch())
@@ -182,15 +182,18 @@ internal class KernelBuildConfigurator(private val project: Project) {
             add("librariesFormatVersion" to librariesProperties["formatVersion"].orEmpty())
         }
 
-        project.tasks.create<CreateResourcesTask>(BUILD_PROPERTIES_TASK) {
+        CreateResourcesTask.register(
+            project,
+            BUILD_PROPERTIES_TASK,
+            project.tasks.named<Copy>(PROCESS_RESOURCES_TASK)
+        ) {
             addPropertiesFile(settings.runtimePropertiesFile, properties)
-            setupDependencies(this@KernelBuildConfigurator.project.tasks.named<Copy>(PROCESS_RESOURCES_TASK))
         }
     }
 
     private fun registerReadmeTasks() {
         ReadmeGenerator(project, settings).registerTasks {
-            dependsOn(UPDATE_LIBRARIES_TASK_NAME)
+            dependsOn(UPDATE_LIBRARIES_TASK)
         }
     }
 

build-plugin/src/build/PythonPackageTasksConfigurator.kt

@@ -35,7 +35,7 @@ class PythonPackageTasksConfigurator(
             dependsOn(CONDA_PACKAGE_TASK)
         }
 
-        specs.createTasks(settings) { taskSpec ->
+        specs.registerTasks(settings) { taskSpec ->
             project.tasks.register(taskSpec.taskName) {
                 group = CONDA_GROUP
                 val artifactPath = settings.artifactsDir.resolve(packageSettings.fileName)
@@ -98,7 +98,7 @@ class PythonPackageTasksConfigurator(
             dependsOn(PYPI_PACKAGE_TASK)
         }
 
-        specs.createTasks(settings) { taskSpec ->
+        specs.registerTasks(settings) { taskSpec ->
             project.tasks.register<Exec>(taskSpec.taskName) {
                 group = PYPI_GROUP
                 workingDir(settings.artifactsDir)

build-plugin/src/build/UpdateLibrariesTask.kt

@@ -2,12 +2,10 @@ package build
 
 import build.util.BUILD_LIBRARIES
 import org.gradle.api.DefaultTask
-import org.gradle.api.Project
 import org.gradle.api.provider.Property
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.OutputDirectory
 import org.gradle.api.tasks.TaskAction
-import org.gradle.kotlin.dsl.create
 import org.gradle.kotlin.dsl.property
 import java.io.File
 
@@ -28,12 +26,4 @@ abstract class UpdateLibrariesTask : DefaultTask() {
         if (BUILD_LIBRARIES.checkIfRefUpToDate(latestSha)) return
         BUILD_LIBRARIES.downloadLibraries(latestSha)
     }
-
-    companion object {
-        fun getOrCreate(project: Project): UpdateLibrariesTask {
-            val task = project.tasks.findByName(UPDATE_LIBRARIES_TASK_NAME)
-            if (task != null) return task as UpdateLibrariesTask
-            return project.tasks.create<UpdateLibrariesTask>(UPDATE_LIBRARIES_TASK_NAME)
-        }
-    }
 }

build-plugin/src/build/taskNames.kt

@@ -37,4 +37,4 @@ const val UNINSTALL_TASK = "uninstall"
 const val MAKE_CHANGES_PR_TASK = "makeChangesPR"
 const val PREPARE_PACKAGE_TASK = "preparePackage"
 
-const val UPDATE_LIBRARIES_TASK_NAME = "updateLibraryDescriptors"
+const val UPDATE_LIBRARIES_TASK = "updateLibraryDescriptors"

build-plugin/src/build/util/common.kt

@@ -7,16 +7,10 @@ import org.gradle.api.Task
 import org.gradle.api.artifacts.ModuleDependency
 import org.gradle.api.plugins.ExtensionContainer
 import org.gradle.kotlin.dsl.exclude
-import org.gradle.kotlin.dsl.extra
-import org.gradle.tooling.BuildException
 import org.jetbrains.kotlinx.jupyter.common.LibraryDescriptorsManager
 import java.io.File
 import java.nio.file.Path
 import java.util.Optional
-import kotlin.reflect.KClass
-import kotlin.reflect.KProperty
-import kotlin.reflect.KType
-import kotlin.reflect.typeOf
 
 val BUILD_LIBRARIES = LibraryDescriptorsManager.getInstance()
 
@@ -42,82 +36,12 @@ fun <T> Project.typedProperty(name: String): T {
     return findProperty(name) as T
 }
 
-class ProjectPropertyDelegate<T>(
-    private val project: Project,
-    private val type: KType,
-    private val projectPropertyName: String? = null,
-    private val default: T? = null,
-) {
-    private val kClass = type.classifier as KClass<*>
-    private val isNullable = type.isMarkedNullable
-
-    private var externallyDefined: T? = null
-    private var externallySet = false
-
-    private var projectDefined: T? = null
-    private var calculated = false
-
-    @Suppress("UNCHECKED_CAST")
-    private fun calculate(propertyName: String): T {
-        val value: String? = project.typedProperty(propertyName)
-        return if (value == null) {
-            default ?: if (isNullable) null as T
-            else throw BuildException("Property $propertyName is not set", null)
-        } else {
-            when (kClass) {
-                String::class -> value as T
-                Boolean::class -> value.booleanValue as T
-                Int::class -> value.toInt() as T
-                else -> throw BuildException("Unsupported option type: $type", null)
-            }
-        }
-    }
-
-    @Suppress("UNCHECKED_CAST")
-    operator fun getValue(thisRef: Any?, property: KProperty<*>): T {
-        return if (externallySet) {
-            externallyDefined as T
-        } else {
-            if (calculated) {
-                projectDefined as T
-            } else {
-                calculated = true
-                val res = calculate(projectPropertyName ?: property.name)
-                projectDefined = res
-                res
-            }
-        }
-    }
-
-    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
-        externallySet = true
-        externallyDefined = value
-    }
-}
-
-@OptIn(ExperimentalStdlibApi::class)
-inline fun <reified T> Project.prop(
-    projectPropertyName: String? = null,
-    default: T? = null
-) = ProjectPropertyDelegate(this, typeOf<T>(), projectPropertyName, default)
-
-fun Project.stringPropOrEmpty(name: String) = rootProject.findProperty(name) as String? ?: ""
-
 fun readProperties(propertiesFile: File): Map<String, String> =
     propertiesFile.readText().lineSequence()
         .map { it.split("=") }
         .filter { it.size == 2 }
         .map { it[0] to it[1] }.toMap()
 
-fun <T> Project.getOrInitProperty(name: String, initializer: () -> T): T {
-    @Suppress("UNCHECKED_CAST")
-    return (if (extra.has(name)) extra[name] as? T else null) ?: run {
-        val value = initializer()
-        extra[name] = value
-        value
-    }
-}
-
 val Any.booleanValueOrNull get() = when (this) {
     "true", true -> true
     "false", false -> false
@@ -126,10 +50,6 @@ val Any.booleanValueOrNull get() = when (this) {
 
 val Any.booleanValue get() = booleanValueOrNull ?: throw IllegalArgumentException("Cannot cast $this to boolean")
 
-fun Project.getFlag(propertyName: String, default: Boolean = false): Boolean {
-    return rootProject.findProperty(propertyName)?.booleanValueOrNull ?: default
-}
-
 fun Task.taskTempFile(path: String): File {
     return temporaryDir.resolve(path).apply {
         createNewFile()

build-plugin/src/build/util/distribution.kt

@@ -25,16 +25,16 @@ class UploadTaskSpecs <T : TaskSpec>(
 
     private fun taskName(type: String) = repoName + "Upload" + type
 
-    fun createTasks(options: RootSettingsExtension, taskCreationAction: (T) -> Unit) {
+    fun registerTasks(options: RootSettingsExtension, taskCreationAction: (T) -> Unit) {
         val project = options.project
         if (options.isOnProtectedBranch) {
             taskCreationAction(stable)
         }
         taskCreationAction(dev)
 
-        project.task(taskName("Protected")) {
-            dependsOn(project.tasks.getByName(makeTaskName(options.cleanInstallDirTaskPrefix, false)))
+        project.tasks.register(taskName("Protected")) {
             group = taskGroup
+            dependsOn(project.tasks.getByName(makeTaskName(options.cleanInstallDirTaskPrefix, false)))
             if (options.isOnProtectedBranch) {
                 dependsOn(dev.taskName)
             }