Files
umamo/build.gradle.kts
litruv 8bd8fa7a0b Snapshot of the Umamo working tree as it is
Uploaded as-is from /home/litruv/dev/vtsmaker/umamo on 2026-11-03. 1347 files.
Includes the uncommitted work in progress in :edit, :runtime, and :ui, and the
untracked files under module/edit/src/jvmAndroidMain/.

History is not carried over. The source repo is https://github.com/umamoorg/umamo.
2026-11-03 18:20:25 +11:00

172 lines
9.2 KiB
Kotlin

// Root build script. Plugins are declared here with `apply false` purely to pin their
// versions for the whole build; each module opts in by `alias(...)`-ing the ones it needs.
// This avoids every module repeating version numbers (the version catalog holds those).
// ルートビルドスクリプト。プラグインは `apply false` でバージョン固定のみを行い、各モジュールが
// 必要なものを `alias(...)` で取り込む。
plugins {
alias(libs.plugins.kotlinMultiplatform) apply false
alias(libs.plugins.composeCompiler) apply false
alias(libs.plugins.composeMultiplatform) apply false
alias(libs.plugins.androidApplication) apply false
alias(libs.plugins.androidKmpLibrary) apply false
alias(libs.plugins.ktlint)
}
// Apply ktlint to every subproject so tab-based style (see .editorconfig) is enforced
// uniformly. ktlint reads .editorconfig, so no rule config is needed here.
subprojects {
apply(plugin = "org.jlleitschuh.gradle.ktlint")
// Compose Multiplatform generates Kotlin under build/generated (JetBrains space-indent style); lint
// our own sources, not generated output (e.g. the resources `Res` collectors).
configure<org.jlleitschuh.gradle.ktlint.KtlintExtension> {
filter {
exclude { element -> element.file.path.contains("/generated/") }
}
}
// Name every test as it runs, and print failures in full.
//
// Gradle's defaults report a passing run as a single count, which is the one shape this build must
// not have: the corpus- and GL-gated tests self-skip when their input is missing, and "239 tests
// completed" reads identically whether the GL suite rendered pixels or sat out the whole run. Naming
// passed AND skipped tests is what tells those two apart in a CI log.
//
// FULL rather than the default SHORT because SHORT prints only "AssertionError at File.kt:120" and
// drops the message - which is where a failure says what it actually was (HeadlessGlGate puts the
// GLFW error code and description there). Standard streams stay off: the tests print per-pixel
// diagnostics that would bury everything else.
tasks.withType<Test>().configureEach {
testLogging {
events("passed", "skipped", "failed")
exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL
}
}
}
// Keeps the common source sets free of JVM-only APIs.
//
// This is NOT redundant with the compiler. Every target today is JVM-based (desktop JVM +
// Android/ART), so the common source set resolves `java.*` and the `kotlin.jvm.*` default import
// perfectly happily — a commonMain file can call java.util.zip and still compile. That only
// stops being true the day a non-JVM target (Kotlin/Native, for iPadOS) is added, at which point
// every accumulated leak surfaces at once, in code nobody has touched for months. This task
// turns that latent debt into an immediate failure instead.
//
// commonTest is in scope too, and deliberately: it has to compile for every target its commonMain
// does, so a JVM-only API there is the same latent break, and a test source set is exactly where one
// slips in unnoticed (a test that only ever runs on the JVM still has to *build* everywhere). It is
// also where the leaks were: `"ABCD".toByteArray(Charsets.US_ASCII)` in a shared test reads as
// harmless until the day it isn't.
//
// Three rules, each from a real leak found in this tree. Note that none of them is only about imports:
// the JVM's default imports (`java.lang.*`, `kotlin.jvm.*`, `kotlin.text.Charsets`) mean JVM-only APIs
// can appear with no import line to grep for, and even a non-default API can be written out in full at
// the use site — `catch (_: java.util.zip.DataFormatException)` needs no import and was exactly how the
// old ClipRaster reached zlib.
// 1. No `java.*` / `javax.*`, whether imported or spelled out at the use site — put the code in
// jvmAndroidMain, or hide the platform behind an expect/actual (see
// org.umamo.format.clip.useClipDatabase for the pattern). Reach for a common-code library
// before either: okio covers DEFLATE and buffers, which is how org.umamo.format.binary.Deflate
// retired the expect/actual it used to need.
// 2. `@Jvm*` annotations must be imported explicitly from `kotlin.jvm`. They are optional
// expectations, so non-JVM targets ignore them — but `kotlin.jvm.*` is a default import only
// on JVM, so an unimported `@JvmInline` is an unresolved reference off-JVM.
// 3. No `Charsets` — `kotlin.text.Charsets` is JVM-only, so `String(bytes, US_ASCII)` and
// `toByteArray(UTF_16BE)` do not exist off-JVM. Use org.umamo.format.binary.BinaryText, or
// `encodeToByteArray()` when the bytes really are meant to be UTF-8.
// (`decodeToString()` is NOT a general substitute: it is UTF-8 only.)
//
// This check is a net, not a proof: it catches the leak classes we have actually hit. The definitive
// check is compiling against a real non-JVM target — and `:format` now does exactly that: it carries
// an `iosArm64()` target, so its commonMain purity is a compiler guarantee and this task is only a
// faster pre-check there. (The two blockers this note used to name — CArrayList/CHashMap extending
// java.util collections — were resolved by delegating instead of inheriting.) Every other module is
// still JVM-only, and for those this task remains the only thing holding the line; the way to upgrade
// one is to copy :format's target, not to grow this regex.
val commonSources =
fileTree(rootDir) {
include(
"module/*/src/commonMain/**/*.kt",
"module/*/src/commonTest/**/*.kt",
"app/*/src/commonMain/**/*.kt",
"app/*/src/commonTest/**/*.kt",
)
}
val checkCommonSourcePurity =
tasks.register("checkCommonSourcePurity") {
group = "verification"
description = "Fails if any module's commonMain/commonTest uses a JVM-only API, which would break a future Kotlin/Native target."
inputs.files(commonSources).withPropertyName("commonSources")
// A marker output, so a green run stays UP-TO-DATE instead of re-reading every common source
// file on every `check`. The task's real product is the failure, not the file.
val report = layout.buildDirectory.file("reports/commonSourcePurity.txt")
outputs.file(report).withPropertyName("report")
val sourceFiles = commonSources
val repositoryRoot = rootDir
doLast {
val jvmImport = Regex("""^import (java|javax)\.""")
// Qualified use with no import: `catch (_: java.util.zip.DataFormatException)`. The
// lookbehind keeps `org.foo.java.Bar` and an identifier ending in "java" from matching.
val jvmQualifiedUse = Regex("""(?<![A-Za-z0-9_.$])(java|javax)\.[a-z][A-Za-z0-9_]*\.""")
val jvmAnnotationUse = Regex("""@(Jvm[A-Za-z]+)""")
val jvmAnnotationImport = Regex("""^import kotlin\.jvm\.(Jvm[A-Za-z]+)""")
val charsetsUse = Regex("""\bCharsets\.""")
val violations = mutableListOf<String>()
for (sourceFile in sourceFiles.files.sortedBy { it.path }) {
val lines = sourceFile.readLines()
val relativePath = sourceFile.relativeTo(repositoryRoot).path
val importedJvmAnnotations =
lines.mapNotNull { line ->
jvmAnnotationImport.find(line.trim())?.groupValues?.get(1)
}.toSet()
lines.forEachIndexed { lineIndex, line ->
val trimmed = line.trim()
if (jvmImport.containsMatchIn(trimmed)) {
violations += "$relativePath:${lineIndex + 1}: a common source set must not import a JVM-only API -> $trimmed"
return@forEachIndexed
}
// Only flag real code, not prose in comments or docblocks.
if (!trimmed.startsWith("*") && !trimmed.startsWith("//") && !trimmed.startsWith("/*")) {
if (jvmQualifiedUse.containsMatchIn(line)) {
violations +=
"$relativePath:${lineIndex + 1}: a common source set must not reference a JVM-only API, even fully " +
"qualified (a qualified use needs no import, so rule 1 alone would miss it) -> $trimmed"
}
jvmAnnotationUse.findAll(line).forEach { match ->
val annotation = match.groupValues[1]
if (annotation !in importedJvmAnnotations) {
violations +=
"$relativePath:${lineIndex + 1}: @$annotation needs an explicit `import kotlin.jvm.$annotation` " +
"(kotlin.jvm.* is a default import only on JVM targets)"
}
}
if (charsetsUse.containsMatchIn(line)) {
violations +=
"$relativePath:${lineIndex + 1}: Charsets is JVM-only (kotlin.text.Charsets); use " +
"encodeToByteArray()/decodeToString() when the bytes are UTF-8, else " +
"org.umamo.format.binary.decodeAscii / encodeUtf16Be -> $trimmed"
}
}
}
}
if (violations.isNotEmpty()) {
throw GradleException(
"common-source purity check failed (${violations.size} violation(s)):\n" +
violations.joinToString("\n") { " $it" },
)
}
val reportFile = report.get().asFile
reportFile.parentFile.mkdirs()
reportFile.writeText("common-source purity: ${sourceFiles.files.size} file(s) checked, no violations.\n")
}
}
// Wire into `check` so the guard runs with the normal verification lifecycle rather than needing to be
// remembered. Gradle runs the task once however many subprojects depend on it.
subprojects {
tasks.matching { task -> task.name == "check" }.configureEach {
dependsOn(checkCommonSourcePurity)
}
}