From ce189f208796419341415d9693acfdf01532c22f Mon Sep 17 00:00:00 2001 From: JFronny Date: Tue, 13 Dec 2022 23:07:05 +0100 Subject: [PATCH] Use late init to support libjf plugin after lom, add taskgraph plugin --- .../io/gitlab/jfronny/scripts/Either.kt | 40 +++++++++++++++++++ .../src/main/kotlin/jf.codegen.gradle.kts | 8 +--- .../src/main/kotlin/jf.taskgraph.gradle.kts | 36 +++++++++++++++++ jfmod/src/main/kotlin/jfmod.gradle.kts | 10 ++--- lom/src/main/kotlin/lom.gradle.kts | 35 ++++++++-------- 5 files changed, 101 insertions(+), 28 deletions(-) create mode 100644 convention/src/main/kotlin/io/gitlab/jfronny/scripts/Either.kt create mode 100644 convention/src/main/kotlin/jf.taskgraph.gradle.kts diff --git a/convention/src/main/kotlin/io/gitlab/jfronny/scripts/Either.kt b/convention/src/main/kotlin/io/gitlab/jfronny/scripts/Either.kt new file mode 100644 index 0000000..1a5b7a0 --- /dev/null +++ b/convention/src/main/kotlin/io/gitlab/jfronny/scripts/Either.kt @@ -0,0 +1,40 @@ +package io.gitlab.jfronny.scripts + +interface Either { + val isLeft: Boolean + val isRight: Boolean + val left: L? + val right: R? + fun mapLeft(f: (L) -> U): Either + fun mapRight(f: (R) -> U): Either + fun 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(override val left: L) : Either { + override val isLeft = true + override val isRight = false + override val right = null + override fun mapLeft(f: (L) -> U): Either = Left(f(left)) + override fun mapRight(f: (R) -> U): Either = Left(left) + override fun 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(override val right: R) : Either { + override val isLeft = false + override val isRight = true + override val left = null + override fun mapLeft(f: (L) -> U): Either = Right(right) + override fun mapRight(f: (R) -> U): Either = Right(f(right)) + override fun 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 Either.fold(): T = if (isLeft) left!! else right!! \ No newline at end of file diff --git a/convention/src/main/kotlin/jf.codegen.gradle.kts b/convention/src/main/kotlin/jf.codegen.gradle.kts index 6da0094..bafefb8 100644 --- a/convention/src/main/kotlin/jf.codegen.gradle.kts +++ b/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()) -} \ No newline at end of file +tasks.processResources { dependsOn(jfCodegen) } \ No newline at end of file diff --git a/convention/src/main/kotlin/jf.taskgraph.gradle.kts b/convention/src/main/kotlin/jf.taskgraph.gradle.kts new file mode 100644 index 0000000..411c8db --- /dev/null +++ b/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 { + 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) { + 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()) + } +} diff --git a/jfmod/src/main/kotlin/jfmod.gradle.kts b/jfmod/src/main/kotlin/jfmod.gradle.kts index 4f741a2..aae866f 100644 --- a/jfmod/src/main/kotlin/jfmod.gradle.kts +++ b/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 } } } diff --git a/lom/src/main/kotlin/lom.gradle.kts b/lom/src/main/kotlin/lom.gradle.kts index d9ca801..7284502 100644 --- a/lom/src/main/kotlin/lom.gradle.kts +++ b/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() { +tasks.withType { 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("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().forEach { prepareTask -> - prepareTask.dependsOn(*this.dependsOn.filter { it != prepareTask }.toTypedArray()) + prepareTask.dependsOn(*this.dependsOn.filterNot { it == prepareTask }.toTypedArray()) } } }