Files
pkl/pkl-cli/pkl-cli.gradle.kts
T

290 lines
9.3 KiB
Kotlin

/*
* Copyright © 2024-2026 Apple Inc. and the Pkl project authors. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.io.ByteArrayOutputStream
import java.io.OutputStream
import org.gradle.kotlin.dsl.support.serviceOf
plugins {
id("pklAllProjects")
id("pklKotlinLibrary")
id("pklPublishLibrary")
id("pklJavaExecutable")
id("pklNativeExecutable")
`maven-publish`
// already on build script class path (see build-logic/build.gradle.kts),
// hence must only specify plugin ID here
id(libs.plugins.shadow.get().pluginId)
alias(libs.plugins.checksum)
}
// make Java executable available to other subprojects
val javaExecutableConfiguration: Configuration = configurations.create("javaExecutable")
publishing {
publications {
named<MavenPublication>("library") {
pom {
url.set("https://github.com/apple/pkl/tree/main/pkl-cli")
description.set("Pkl CLI Java library.")
}
}
}
}
dependencies {
implementation(libs.truffleRuntime)
compileOnly(libs.graalSdk)
// CliEvaluator exposes PClass
api(projects.pklCore)
// CliEvaluatorOptions exposes CliBaseOptions
api(projects.pklCommonsCli)
implementation(projects.pklCommons)
implementation(libs.jlineReader)
implementation(libs.jlineTerminal)
implementation(libs.jlineTerminalJni)
implementation(projects.pklServer)
implementation(projects.pklFormatter)
implementation(projects.pklProfiler)
implementation(libs.truffleProfiler)
implementation(libs.clikt)
testImplementation(projects.pklCommonsTest)
testImplementation(libs.wiremock)
testImplementation(libs.protobuf)
// used by `pklJavaExecutable` plugin (ideally this would be inferred automatically)
firstPartySourcesJars(project(":pkl-cli", "sourcesJar"))
firstPartySourcesJars(project(":pkl-commons", "sourcesJar"))
firstPartySourcesJars(project(":pkl-commons-cli", "sourcesJar"))
firstPartySourcesJars(project(":pkl-core", "sourcesJar"))
firstPartySourcesJars(project(":pkl-formatter", "sourcesJar"))
firstPartySourcesJars(project(":pkl-parser", "sourcesJar"))
firstPartySourcesJars(project(":pkl-server", "sourcesJar"))
firstPartySourcesJars(project(":pkl-profiler", "sourcesJar"))
}
tasks.jar {
manifest.attributes +=
mapOf("Main-Class" to "org.pkl.cli.Main", "Add-Exports" to buildInfo.jpmsExportsForJarManifest)
}
tasks.javadoc { enabled = false }
// subprocess tests have their own dedicated tasks; see `testProfilerOutput` and
// `testNativeProfilerOutput` below
tasks.test { exclude("**/Subprocess*Test.class") }
tasks.shadowJar {
archiveFileName.set("jpkl")
exclude("META-INF/maven/**")
exclude("META-INF/upgrade/**")
exclude("module-info.*")
}
val testJavaExecutable =
tasks.register<Test>("testJavaExecutable") {
testClassesDirs = tasks.test.get().testClassesDirs
classpath =
// compiled test classes
sourceSets.test.get().output +
// java executable
tasks.javaExecutable.get().outputs.files +
// test-only dependencies
// (test dependencies that are also main dependencies must already be contained in java
// executable;
// to verify that, we don't want to include them here)
(configurations.testRuntimeClasspath.get() - configurations.runtimeClasspath.get())
// subprocess tests have their own dedicated tasks; see `testProfilerOutput` and
// `testNativeProfilerOutput` below
exclude("**/Subprocess*Test.class")
}
// Setup `testJavaExecutable` tasks for multi-JDK testing.
val testJavaExecutableOnOtherJdks = buildInfo.multiJdkTestingWith(testJavaExecutable)
// Prepare a run of the fat JAR, optionally with a specific Java launcher.
private fun setupJavaExecutableRun(
name: String,
args: Array<String>,
launcher: Provider<JavaLauncher>? = null,
configurator: Exec.() -> Unit = {},
) =
tasks.register(name, Exec::class) {
dependsOn(tasks.javaExecutable)
val outputFile = layout.buildDirectory.file(name) // dummy output to satisfy up-to-date check
outputs.file(outputFile)
executable =
when (launcher) {
null -> "java"
else -> launcher.get().executablePath.asFile.absolutePath
}
standardOutput = OutputStream.nullOutputStream()
args("-jar", tasks.javaExecutable.get().outputs.files.singleFile.toString(), *args)
doFirst { outputFile.get().asFile.delete() }
doLast { outputFile.get().asFile.writeText("OK") }
configurator()
}
val evalTestFlags = arrayOf("eval", "-x", "1 + 1", "pkl:base")
fun Exec.useRootDirAndSuppressOutput() {
workingDir = rootProject.layout.projectDirectory.asFile
standardOutput = ByteArrayOutputStream() // we only care that this exec doesn't fail
}
// 0.28 Preparing for JDK21 toolchains revealed that `testStartJavaExecutable` may pass, even though
// the evaluator fails. To catch this, we eval a simple expression using the fat jar.
val testEvalJavaExecutable =
setupJavaExecutableRun("testEvalJavaExecutable", evalTestFlags) { useRootDirAndSuppressOutput() }
// Run the same evaluator tests on all configured JDK test versions.
val testEvalJavaExecutableOnOtherJdks =
buildInfo.jdkTestRange.map { jdkTarget ->
setupJavaExecutableRun(
"testEvalJavaExecutableJdk${jdkTarget.asInt()}",
evalTestFlags,
serviceOf<JavaToolchainService>().launcherFor { languageVersion = jdkTarget },
) {
useRootDirAndSuppressOutput()
}
}
val generateReachabilityMetadata =
tasks.register<JavaExec>("generateReachabilityMetadata") {
dependsOn(tasks.javaExecutable)
// The native-image-agent requires GraalVM's java, not a regular JDK.
val graalVm =
if (buildInfo.arch == Target.Arch.AMD64) buildInfo.graalVmAmd64 else buildInfo.graalVmAarch64
dependsOn(
if (buildInfo.arch == Target.Arch.AMD64) ":installGraalVmAmd64" else ":installGraalVmAarch64"
)
executable(
File(graalVm.baseDir)
.resolve("bin")
.resolve(if (buildInfo.os.isWindows) "java.exe" else "java")
.absolutePath
)
val outputDir = layout.buildDirectory.dir("generated-reachability-metadata")
val outputFile = outputDir.map {
it.asFile.resolve("META-INF/native-image/org.pkl-lang/pkl-cli/reachability-metadata.json")
}
val profilerOutput = layout.buildDirectory.file("tmp/profile.pb.gz")
outputs.file(outputFile)
classpath = tasks.javaExecutable.get().outputs.files
// invoke the profiler to include metadata for protobuf serdes
args("eval", "--profile-cpu-output", profilerOutput.get().asFile.absolutePath, "pkl:settings")
setStandardOutput(OutputStream.nullOutputStream())
jvmArgumentProviders.add(
CommandLineArgumentProvider {
buildList {
add("-agentlib:native-image-agent=config-output-dir=${outputFile.get().parent}")
}
}
)
doLast {
if (!outputFile.get().exists()) {
throw GradleException("Did not create expected file: ${outputFile.get()}")
}
}
}
val testProfilerOutput =
tasks.register<Test>("testProfilerOutput") {
group = "verification"
dependsOn(tasks.javaExecutable)
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
include("**/Subprocess*Test.class")
systemProperty(
"org.pkl.cli.testJar",
tasks.javaExecutable.get().outputs.files.singleFile.absolutePath,
)
}
val testNativeProfilerOutput =
tasks.register<Test>("testNativeProfilerOutput") {
group = "verification"
dependsOn(tasks.assembleNative)
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
include("**/Subprocess*Test.class")
systemProperty(
"org.pkl.cli.testExecutable",
tasks.assembleNative.get().outputs.files.singleFile.absolutePath,
)
}
tasks.withType<NativeImageBuild>().configureEach {
dependsOn(generateReachabilityMetadata)
classpath.from(layout.buildDirectory.dir("generated-reachability-metadata"))
}
tasks.check {
dependsOn(
testJavaExecutable,
testJavaExecutableOnOtherJdks,
testEvalJavaExecutable,
testEvalJavaExecutableOnOtherJdks,
testProfilerOutput,
)
}
tasks.checkNative {
dependsOn(":pkl-core:checkNative")
dependsOn(":pkl-server:checkNative")
dependsOn(testNativeProfilerOutput)
}
executable {
name = "pkl"
javaName = "jpkl"
documentationName = "Pkl CLI"
publicationName = "pkl-cli"
javaPublicationName = "pkl-cli-java"
mainClass = "org.pkl.cli.Main"
website = "https://pkl-lang.org/main/current/pkl-cli/index.html"
}
// make Java executable available to other subprojects
// (we don't do the same for native executables because we don't want tasks assemble/build to build
// them)
artifacts {
add("javaExecutable", tasks.javaExecutable.map { it.outputs.files.singleFile }) {
name = "pkl-cli-java"
classifier = null
extension = "jar"
builtBy(tasks.javaExecutable)
}
}