Use late init to support libjf plugin after lom, add taskgraph plugin

convention/src/main/kotlin/io/gitlab/jfronny/scripts/Either.kt

@@ -0,0 +1,40 @@
+package io.gitlab.jfronny.scripts
+
+interface Either<L, R> {
+    val isLeft: Boolean
+    val isRight: Boolean
+    val left: L?
+    val right: R?
+    fun <U> mapLeft(f: (L) -> U): Either<U, R>
+    fun <U> mapRight(f: (R) -> U): Either<L, U>
+    fun <U> fold(l: (L) -> U, r: (R) -> U): U
+    fun foldLeft(f: (L) -> R): R
+    fun foldRight(f: (R) -> L): L
+    fun apply(l: (L) -> Unit, r: (R) -> Unit)
+
+    data class Left<L, R>(override val left: L) : Either<L, R> {
+        override val isLeft = true
+        override val isRight = false
+        override val right = null
+        override fun <U> mapLeft(f: (L) -> U): Either<U, R> =  Left(f(left))
+        override fun <U> mapRight(f: (R) -> U): Either<L, U> = Left(left)
+        override fun <U> fold(l: (L) -> U, r: (R) -> U): U = l(left)
+        override fun foldRight(f: (R) -> L): L = left
+        override fun foldLeft(f: (L) -> R): R = f(left)
+        override fun apply(l: (L) -> Unit, r: (R) -> Unit) = l(left)
+    }
+
+    data class Right<L, R>(override val right: R) : Either<L, R> {
+        override val isLeft = false
+        override val isRight = true
+        override val left = null
+        override fun <U> mapLeft(f: (L) -> U): Either<U, R> = Right(right)
+        override fun <U> mapRight(f: (R) -> U): Either<L, U> = Right(f(right))
+        override fun <U> fold(l: (L) -> U, r: (R) -> U): U = r(right)
+        override fun foldRight(f: (R) -> L): L = f(right)
+        override fun foldLeft(f: (L) -> R): R = right
+        override fun apply(l: (L) -> Unit, r: (R) -> Unit) = r(right)
+    }
+}
+
+fun <T> Either<T, T>.fold(): T = if (isLeft) left!! else right!!

convention/src/main/kotlin/jf.codegen.gradle.kts

@@ -26,10 +26,6 @@ val jfCodegen by tasks.registering {
     }
 }
 
-tasks.compileJava {
-    dependsOn(jfCodegen.get())
-}
+tasks.compileJava { dependsOn(jfCodegen) }
 
-tasks.processResources {
-    dependsOn(jfCodegen.get())
-}
+tasks.processResources { dependsOn(jfCodegen) }

convention/src/main/kotlin/jf.taskgraph.gradle.kts

@@ -0,0 +1,36 @@
+import io.gitlab.jfronny.scripts.*
+
+plugins {
+    base
+}
+
+tasks.register("printTaskGraph") {
+    doLast {
+        fun getTask(task: Any): Either<Task, String> {
+            return when (task) {
+                is Provider<*> -> getTask(task.get())
+                is String -> Either.Left(tasks.getByPath(task))
+                is Task -> Either.Left(task)
+                else -> Either.Right("$task")
+            }
+        }
+
+        fun printTaskGraph(task: Task, indent: Int, known: MutableSet<Task>) {
+            if (known.contains(task)) {
+                println("  ".repeat(indent) + "- ${task.name} (*)")
+                return
+            }
+            known.add(task)
+            println("  ".repeat(indent) + "- ${task.name}")
+            task.dependsOn.forEach {
+                getTask(it).apply({ dependency ->
+                    printTaskGraph(dependency, indent + 1, known)
+                }, { error ->
+                    println("  ".repeat(indent + 1) + "- UNEXPECTED!: $error")
+                })
+            }
+        }
+
+        printTaskGraph(tasks.getByPath(prop("taskGraph", "build")), 0, LinkedHashSet())
+    }
+}

jfmod/src/main/kotlin/jfmod.gradle.kts

@@ -58,7 +58,7 @@ subprojects {
     self.tasks.deployDebug.dependsOn(tasks.deployDebug)
     self.tasks.deployRelease.dependsOn(tasks.deployRelease)
 
-    tasks.named("javadoc").get().enabled = false
+    tasks.named("javadoc") { enabled = false }
 
     if (name !in devOnlyModules && !sourceSets.testmod.get().resources.isEmpty) {
         //TODO register testmods of subprojects as testmodInclude automatically
@@ -83,10 +83,10 @@ subprojects {
     }
 
     afterEvaluate {
-        tasks.genClientOnlySources.get().enabled = false
-        tasks.genCommonSources.get().enabled = false
-        tasks.unpickClientOnlyJar.get().enabled = false
-        tasks.unpickCommonJar.get().enabled = false
+        tasks.genClientOnlySources { enabled = false }
+        tasks.genCommonSources { enabled = false }
+        tasks.unpickClientOnlyJar { enabled = false }
+        tasks.unpickCommonJar { enabled = false }
     }
 }
 

lom/src/main/kotlin/lom.gradle.kts

@@ -101,17 +101,18 @@ earlyAfterEvaluate {
 tasks.jar.get().archiveClassifier.set("dev")
 
 // Used for referencing the unremapped jars of other projects
-artifacts.add(configurations.create("dev").name, tasks.jar.get().archiveFile.get().asFile) {
+artifacts.add(configurations.create("dev").name, tasks.jar) {
     type = "jar"
-    builtBy(tasks.jar.get())
+    builtBy(tasks.jar)
 }
 
 // configure the shadow task to not shadow by default and output to builds/devlibs
 tasks.shadowJar {
-    val inputTask: Jar = tasks.findByName("injectCompiledConfig") as Jar? ?: tasks.jar.get() // get injectCompiledConfig task if present (-> LibJF) or use normal jar task
+    // get injectCompiledConfig task if present (-> LibJF) or use normal jar task
+    val inputTask = providers.provider { tasks.findByName("injectCompiledConfig") as Jar? }.orElse(tasks.jar)
     dependsOn(inputTask)
     configurations.clear()
-    from(project.configurations.shadow.get(), inputTask.archiveFile.get())
+    from(project.configurations.shadow, inputTask)
     archiveClassifier.set("shadow")
     destinationDirectory.set(devlibs)
 }
@@ -122,24 +123,24 @@ java {
 }
 
 // attempt to allow reproducible builds by removing unneeded metadata from jars
-tasks.withType<AbstractArchiveTask>() {
+tasks.withType<AbstractArchiveTask> {
     isPreserveFileTimestamps = false
     isReproducibleFileOrder = false
 }
 
 // generate remapped jar without JiJ'd dependencies for maven publish
 val remapMavenJar by tasks.registering(RemapJarTask::class) {
-    dependsOn(tasks.shadowJar.get())
-    inputFile.set(tasks.shadowJar.get().archiveFile.get())
+    dependsOn(tasks.shadowJar)
+    inputFile.set(tasks.shadowJar.get().archiveFile)
     archiveFileName.set("${archiveBaseName.get()}-${project.versionS}-maven.jar")
     addNestedDependencies.set(false)
 }
-tasks.assemble.get().dependsOn(remapMavenJar.get())
+tasks.assemble { dependsOn(remapMavenJar) }
 
 // configure remapJar to use the output of shadow
 tasks.remapJar {
-    dependsOn(tasks.shadowJar.get())
-    inputFile.set(tasks.shadowJar.get().archiveFile.get())
+    dependsOn(tasks.shadowJar)
+    inputFile.set(tasks.shadowJar.get().archiveFile)
     archiveFileName.set("${archiveBaseName.get()}-${project.versionS}.jar")
 }
 
@@ -155,12 +156,12 @@ publishing {
     publications {
         create<MavenPublication>("lom") {
             from(components["java"])
-            setArtifacts(listOf(remapMavenJar.get(), tasks.sourcesJar.get()))
+            setArtifacts(listOf(remapMavenJar, tasks.sourcesJar))
         }
     }
 }
-tasks.publish.get().dependsOn(tasks.build.get())
-tasks.deployDebug.dependsOn(tasks.publish.get())
+tasks.publish { dependsOn(tasks.build) }
+tasks.deployDebug.dependsOn(tasks.publish)
 
 // create testmodInclude configuration
 val testmodIncludeConfiguration = configurations.create("testmodInclude")
@@ -176,14 +177,14 @@ if (hasTestmod) {
     afterEvaluate {
         // remap configuration for outputting usable testmod jar
         val remapTestmodJar by tasks.registering(RemapJarTask::class) {
-            dependsOn(testmodJar.get())
-            inputFile.set(testmodJar.get().archiveFile.get())
+            dependsOn(testmodJar)
+            inputFile.set(testmodJar.get().archiveFile)
             archiveClassifier.set("testmod")
             // add nested jars from testmodInclude
             addNestedDependencies.set(true)
             nestedJars.setFrom(*testmodIncludeConfiguration.files.toTypedArray())
         }
-        tasks.assemble.get().dependsOn(remapTestmodJar.get())
+        tasks.assemble { dependsOn(remapTestmodJar) }
     }
 }
 
@@ -205,7 +206,7 @@ afterEvaluate {
     tasks.configureEach {
         if (this is RemapJarTask) {
             this.dependsOn.filterIsInstance<PrepareJarRemapTask>().forEach { prepareTask ->
-                prepareTask.dependsOn(*this.dependsOn.filter { it != prepareTask }.toTypedArray())
+                prepareTask.dependsOn(*this.dependsOn.filterNot { it == prepareTask }.toTypedArray())
             }
         }
     }