@invarn/cibuild 2.9.4 → 2.9.7

package/dist/src/commands/android-gms-guard.test.js

@@ -1,78 +0,0 @@
-/**
- * A plugin applied inside `if (file("…").exists()) { … }` is conditional on a
- * file the build may not have. Counting it as a hard credential requirement
- * sends the user looking for a file the build never asks for — and, when the
- * same rule is used to predict outcomes, reports projects as blocked that
- * build green with no credential at all.
- */
-import { describe, test, expect } from '@jest/globals';
-import { stripExistenceGuardedBlocks } from './android-scanner.js';
-describe('stripExistenceGuardedBlocks', () => {
-    test('removes a Kotlin DSL existence guard and its body', () => {
-        const content = `
-plugins {
-  id("com.android.application")
-}
-
-if (file("google-services.json").exists()) {
-  apply(plugin = libs.plugins.gms.googleServices.get().pluginId)
-}
-`;
-        const stripped = stripExistenceGuardedBlocks(content);
-        expect(stripped).toContain('com.android.application');
-        expect(stripped).not.toContain('googleServices');
-    });
-    test('removes a Groovy existence guard', () => {
-        const content = `
-if (file('google-services.json').exists()) {
-    apply plugin: 'com.google.gms.google-services'
-}
-`;
-        expect(stripExistenceGuardedBlocks(content)).not.toContain('google-services');
-    });
-    test('removes a guard qualified by a project receiver', () => {
-        const content = `
-if (rootProject.file("app/google-services.json").exists()) {
-  apply(plugin = "com.google.gms.google-services")
-}
-`;
-        expect(stripExistenceGuardedBlocks(content)).not.toContain('google-services');
-    });
-    test('keeps nested braces inside the guard body together', () => {
-        const content = `
-if (file("google-services.json").exists()) {
-  android { buildTypes { release { } } }
-  apply(plugin = "com.google.gms.google-services")
-}
-val keep = "after"
-`;
-        const stripped = stripExistenceGuardedBlocks(content);
-        expect(stripped).not.toContain('google-services');
-        expect(stripped).toContain('val keep = "after"');
-    });
-    test('is not fooled by a brace inside a string literal', () => {
-        const content = `
-if (file("google-services.json").exists()) {
-  val template = "\${'{'}not a block"
-  apply(plugin = "com.google.gms.google-services")
-}
-val keep = "after"
-`;
-        const stripped = stripExistenceGuardedBlocks(content);
-        expect(stripped).not.toContain('google-services');
-        expect(stripped).toContain('val keep = "after"');
-    });
-    test('leaves an unguarded declaration exactly where it was', () => {
-        const content = `
-plugins {
-  id("com.google.gms.google-services")
-}
-`;
-        expect(stripExistenceGuardedBlocks(content)).toBe(content);
-    });
-    test('leaves content alone when the guard never closes', () => {
-        const content = 'if (file("google-services.json").exists()) {\n  apply(plugin = "x")\n';
-        expect(stripExistenceGuardedBlocks(content)).toBe(content);
-    });
-});
-//# sourceMappingURL=android-gms-guard.test.js.map

package/dist/src/commands/android-java-version.test.d.ts

@@ -1,12 +0,0 @@
-/**
- * Which JDK a generated Android pipeline asks for.
- *
- * Two constraints decide it and the old `Math.max(detected ?? 17, 17)` knew
- * neither: build machines install a fixed set of JDKs, and Gradle refuses to
- * start on a JDK newer than it knows about. Naming a JDK that is not
- * installed fails at "Set the Java version", before a line compiles; raising
- * a project onto a JDK its Gradle cannot run makes an old wrapper
- * unbuildable by construction.
- */
-export {};
-//# sourceMappingURL=android-java-version.test.d.ts.map

package/dist/src/commands/android-java-version.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"android-java-version.test.d.ts","sourceRoot":"","sources":["../../../src/commands/android-java-version.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG"}

package/dist/src/commands/android-java-version.test.js

@@ -1,209 +0,0 @@
-/**
- * Which JDK a generated Android pipeline asks for.
- *
- * Two constraints decide it and the old `Math.max(detected ?? 17, 17)` knew
- * neither: build machines install a fixed set of JDKs, and Gradle refuses to
- * start on a JDK newer than it knows about. Naming a JDK that is not
- * installed fails at "Set the Java version", before a line compiles; raising
- * a project onto a JDK its Gradle cannot run makes an old wrapper
- * unbuildable by construction.
- */
-import { describe, test, expect } from '@jest/globals';
-import { AVAILABLE_JAVA_VERSIONS, gradleJavaCeiling, gradleJavaFloor, javaVersionProblem, parseGradleWrapperVersion, runnableJavaVersion, } from './android-scanner.js';
-describe('parseGradleWrapperVersion', () => {
-    test('reads the version out of a distributionUrl', () => {
-        expect(parseGradleWrapperVersion('distributionUrl=https\\://services.gradle.org/distributions/gradle-8.9-bin.zip')).toBe('8.9');
-    });
-    test('reads an -all distribution and a three-part version', () => {
-        expect(parseGradleWrapperVersion('distributionUrl=https\\://services.gradle.org/distributions/gradle-5.2.1-all.zip')).toBe('5.2.1');
-    });
-    test('reads a release-candidate version', () => {
-        expect(parseGradleWrapperVersion('distributionUrl=https\\://services.gradle.org/distributions/gradle-9.0-rc-1-bin.zip')).toBe('9.0-rc-1');
-    });
-    test('returns undefined for a properties file that pins nothing', () => {
-        expect(parseGradleWrapperVersion('distributionBase=GRADLE_USER_HOME')).toBeUndefined();
-        expect(parseGradleWrapperVersion('')).toBeUndefined();
-    });
-});
-describe('gradleJavaCeiling / gradleJavaFloor', () => {
-    test('tracks what each Gradle line can run on', () => {
-        expect(gradleJavaCeiling('4.10.2')).toBe(8);
-        expect(gradleJavaCeiling('5.2.1')).toBe(11);
-        expect(gradleJavaCeiling('6.9')).toBe(11);
-        expect(gradleJavaCeiling('7.6.1')).toBe(17);
-        expect(gradleJavaCeiling('8.9')).toBe(21);
-        expect(gradleJavaCeiling('9.4.0')).toBe(25);
-    });
-    // The boundaries are minor releases, and preferring the newest JDK makes
-    // them load-bearing: JDK 21 arrived in Gradle 8.5, JDK 17 in 7.3, JDK 11 in
-    // 5.0.
-    test('knows the minor release each JDK arrived in', () => {
-        expect(gradleJavaCeiling('8.4')).toBe(17);
-        expect(gradleJavaCeiling('8.5')).toBe(21);
-        expect(gradleJavaCeiling('7.2')).toBe(11);
-        expect(gradleJavaCeiling('7.3')).toBe(17);
-    });
-    test('knows Gradle 9 dropped everything below 17', () => {
-        expect(gradleJavaFloor('8.9')).toBe(8);
-        expect(gradleJavaFloor('9.0')).toBe(17);
-    });
-    test('says nothing about a version it cannot read', () => {
-        expect(gradleJavaCeiling(undefined)).toBeUndefined();
-        expect(gradleJavaCeiling('nightly')).toBeUndefined();
-        expect(gradleJavaFloor(undefined)).toBeUndefined();
-    });
-});
-describe('runnableJavaVersion', () => {
-    // DECIDED 2026-09-06 (Alex): the newest JDK the wrapper allows, reversing
-    // PRD decision #15. A declaration is a floor — 11 is installed, and a
-    // project declaring sourceCompatibility 11 gets 21, which it compiles
-    // perfectly well on and which AGP 8.x needs anyway.
-    test('takes the newest available JDK that covers the declaration', () => {
-        expect(runnableJavaVersion(11)).toBe(25);
-        expect(runnableJavaVersion(17)).toBe(25);
-        expect(runnableJavaVersion(25)).toBe(25);
-    });
-    // Nothing declared and no wrapper to read is nothing to go on. It used to
-    // answer 25 anyway, which is a guess wearing a number; the generator's own
-    // default stands instead, and that is not news worth a warning.
-    test('abstains when there is nothing to go on', () => {
-        expect(runnableJavaVersion(undefined)).toBeUndefined();
-    });
-    test('still answers from the wrapper alone, with nothing declared', () => {
-        expect(runnableJavaVersion(undefined, '8.9')).toBe(21);
-    });
-    // 8 joined the images on 2026-09-07 and must stay unreachable except where
-    // a wrapper ceiling forces it: a project declaring `sourceCompatibility 1.8`
-    // is declaring a floor, and AGP will not run on 8 at all.
-    test('never picks 8 for a project that merely declares it', () => {
-        // 8.13's own ceiling is 21 — JDK 25 needs Gradle 9.1.
-        expect(runnableJavaVersion(8, '8.13')).toBe(21);
-        expect(runnableJavaVersion(8)).toBe(25);
-    });
-    // AutoJs6: Gradle 4.10.2 tops out at Java 8, and now there is a Java 8.
-    test('picks 8 when the wrapper leaves nothing else', () => {
-        expect(runnableJavaVersion(undefined, '4.10.2')).toBe(8);
-        expect(runnableJavaVersion(8, '4.10.2')).toBe(8);
-    });
-    test('steps down to 11 only when the wrapper rules everything else out', () => {
-        expect(runnableJavaVersion(undefined, '5.2.1')).toBe(11);
-        expect(runnableJavaVersion(11, '5.2.1')).toBe(11);
-        expect(runnableJavaVersion(undefined, '6.9')).toBe(11);
-    });
-    // No answer is ever a JDK the build machines lack.
-    test('never names a JDK no build machine has', () => {
-        for (const answer of [runnableJavaVersion(23), runnableJavaVersion(25, '8.9')]) {
-            if (answer !== undefined)
-                expect(AVAILABLE_JAVA_VERSIONS).toContain(answer);
-        }
-    });
-    /**
-     * And no answer is ever above the wrapper's own ceiling.
-     *
-     * This is the defect. Nothing satisfied both the declaration and the
-     * ceiling, so the chooser fell back to the newest installed JDK — which is
-     * *above* the ceiling by construction, because the ceiling is why nothing
-     * fitted. The build then died selecting the JDK, exactly as a too-new JDK
-     * always does, and `javaVersionProblem` had no branch for the shape so
-     * nothing anywhere said a choice had been made.
-     *
-     * The ceiling is hard: Gradle starts before it reads a single
-     * `sourceCompatibility`. The declaration is a floor. So where they conflict
-     * the ceiling wins, and the caller says so.
-     */
-    test('never answers above the wrapper ceiling', () => {
-        // Gradle 7.x tops out at 17. Declaring 21 cannot raise that.
-        expect(runnableJavaVersion(21, '7.6.1')).toBe(17);
-        expect(runnableJavaVersion(17, '7.6.1')).toBe(17);
-    });
-    // Gradle 6.5 runs on Java 11 at most, and a workflow pins java-version 12.
-    // The old chooser answered 25 and said nothing.
-    test('caps a modern declaration under an old wrapper', () => {
-        expect(runnableJavaVersion(12, '6.5')).toBe(11);
-    });
-    // Every shape the corpus has, held to both properties at once: the answer
-    // is installed, and it is not above the ceiling.
-    test.each([
-        [8, '4.10.2'],
-        [11, '5.2.1'],
-        [12, '6.5'],
-        [17, '7.6.1'],
-        [21, '7.6.1'],
-        [8, '9.0'],
-        [30, '8.9'],
-        [25, '9.1'],
-        [undefined, '6.9'],
-    ])('declared %s on Gradle %s answers within both bounds', (declared, gradle) => {
-        const answer = runnableJavaVersion(declared, gradle);
-        if (answer === undefined)
-            return; // abstention is always allowed
-        expect(AVAILABLE_JAVA_VERSIONS).toContain(answer);
-        const ceiling = gradleJavaCeiling(gradle);
-        if (ceiling !== undefined)
-            expect(answer).toBeLessThanOrEqual(ceiling);
-    });
-    test('honours the Gradle 9 floor of 17', () => {
-        // The floor rules 11 out; the newest above it is what gets written.
-        expect(runnableJavaVersion(8, '9.0')).toBe(21);
-    });
-});
-describe('javaVersionProblem', () => {
-    // There is no longer a Gradle version no installed JDK can run: the ceiling
-    // bottoms out at Java 8 and since 2026-09-07 the images carry one. The
-    // branch that says so is kept for an installed set that drops 8 again.
-    test('no longer calls an old wrapper a problem', () => {
-        expect(javaVersionProblem(undefined, '4.10.2')).toBeUndefined();
-        expect(javaVersionProblem(undefined, '3.5')).toBeUndefined();
-    });
-    test('names a declaration above every installed JDK', () => {
-        const problem = javaVersionProblem(30, '8.9');
-        expect(problem).toContain('Java 30');
-        expect(problem).toContain('8, 11, 17, 21 and 25');
-    });
-    test('is silent when every constraint was honoured', () => {
-        expect(javaVersionProblem(17, '8.9')).toBeUndefined();
-        expect(javaVersionProblem(undefined, '8.9')).toBeUndefined();
-        expect(javaVersionProblem(undefined, undefined)).toBeUndefined();
-        // 5.2.1 used to be a problem. The images carry 11 now, so it is not.
-        expect(javaVersionProblem(undefined, '5.2.1')).toBeUndefined();
-        // Nor is 4.10.2, since the images carry 8.
-        expect(javaVersionProblem(undefined, '4.10.2')).toBeUndefined();
-    });
-    /**
-     * The shape that used to fall through every branch, and the reason this
-     * function is resolved from the same place as the answer.
-     *
-     * A wrapper on Gradle 6.5 under a workflow pinning java-version 12: the
-     * ceiling is not below every installed JDK and the declaration is not above
-     * every installed JDK, so neither old branch fired. The chooser answered 25
-     * — above the ceiling — and nothing said the project had asked for something
-     * else and been overruled.
-     */
-    test('speaks when an old wrapper overrules a newer declaration', () => {
-        const problem = javaVersionProblem(12, '6.5');
-        expect(problem).toContain('Java 12');
-        expect(problem).toContain('Gradle 6.5');
-        expect(problem).toContain('Java 11 at most');
-        expect(problem).toContain('Building on 11');
-    });
-    // An answer that is not what was asked for always speaks, whichever
-    // constraint did the overruling.
-    test.each([
-        [12, '6.5'],
-        [21, '7.6.1'],
-        [30, '8.9'],
-    ])('declared %s on Gradle %s never passes silently', (declared, gradle) => {
-        expect(javaVersionProblem(declared, gradle)).toBeDefined();
-    });
-    // Naming a version with no provenance sends a reader through every Gradle
-    // file looking for a number that is in none of them. The scan knows which
-    // file asked, so the sentence can say.
-    test('names the file that asked, when it is known', () => {
-        const problem = javaVersionProblem(12, '6.5', '.github/workflows/Build.yml');
-        expect(problem).toContain('Java 12 (.github/workflows/Build.yml)');
-    });
-    test('reads correctly without a source', () => {
-        expect(javaVersionProblem(12, '6.5')).not.toContain('(');
-    });
-});
-//# sourceMappingURL=android-java-version.test.js.map

package/dist/src/commands/android-scanner-java.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=android-scanner-java.test.d.ts.map

package/dist/src/commands/android-scanner-java.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"android-scanner-java.test.d.ts","sourceRoot":"","sources":["../../../src/commands/android-scanner-java.test.ts"],"names":[],"mappings":""}

package/dist/src/commands/android-scanner-java.test.js

@@ -1,130 +0,0 @@
-/**
- * Which JDK a project needs, from every place it says so.
- *
- * Two rows of the thirty-app study died at root-project configuration on a
- * JDK the images already carry, and neither was a repository problem:
- *
- *  - `SimonSchubert/LinuxCommandLibrary` declares eight modules in a single
- *    `include(...)` call. The scanner's own include regex captured only the
- *    first argument, so seven modules were never opened — including the one
- *    with `jvmToolchain(21)` in it. It answered 17, and a Gradle plugin
- *    requiring a 21 runtime failed the build.
- *  - `mihonapp/mihon` declares no Java level in any Gradle file. It pins 21
- *    in `.github/.java-version`, which its own workflows consume through
- *    `setup-java`'s `java-version-file:`. Nothing of ours read either.
- */
-import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { scanAndroidProject } from "./android-scanner.js";
-let root;
-beforeEach(() => {
-    root = mkdtempSync(join(tmpdir(), "cibuild-java-"));
-});
-afterEach(() => {
-    rmSync(root, { recursive: true, force: true });
-});
-function write(relative, content) {
-    const path = join(root, relative);
-    mkdirSync(join(path, ".."), { recursive: true });
-    writeFileSync(path, content);
-}
-async function detectedJava() {
-    const result = await scanAndroidProject(root);
-    return result.detectedJavaVersion;
-}
-describe("the Java version a project asks for", () => {
-    describe("every module the build includes", () => {
-        // The exact settings line from LinuxCommandLibrary, and the two build
-        // files that decide the answer: 17 in the first module, 21 in the last.
-        test("reads all eight modules of one include call", async () => {
-            write("settings.gradle.kts", 'include(":android", ":common", ":websiteBuilder", ":cli", ":composeApp", ":desktopApp", ":viewmodels", ":screenshotTests")\n');
-            write("build.gradle.kts", "// root\n");
-            write("android/build.gradle.kts", "kotlin {\n  compilerOptions {\n    jvmTarget.set(JvmTarget.JVM_17)\n  }\n}\n");
-            write("screenshotTests/build.gradle.kts", "kotlin {\n  jvmToolchain(21)\n}\n");
-            expect(await detectedJava()).toBe(21);
-        });
-        test("reads the Groovy multi-argument form too", async () => {
-            write("settings.gradle", "include ':app', ':feature:home'\n");
-            write("app/build.gradle", "android { compileOptions { sourceCompatibility JavaVersion.VERSION_17 } }\n");
-            write("feature/home/build.gradle", "kotlin { jvmToolchain(21) }\n");
-            expect(await detectedJava()).toBe(21);
-        });
-        // A7 lite: a convention plugin's own build file is where a monorepo's
-        // Java level often lives, and `includeBuild` is how it gets there.
-        test("follows includeBuild into a build-logic root", async () => {
-            write("settings.gradle.kts", 'includeBuild("build-logic")\ninclude(":app")\n');
-            write("app/build.gradle.kts", "// nothing\n");
-            write("build-logic/build.gradle.kts", "kotlin { jvmToolchain(21) }\n");
-            expect(await detectedJava()).toBe(21);
-        });
-    });
-    describe("the forms a Kotlin build writes jvmTarget in", () => {
-        test.each([
-            ["jvmTarget.set(JvmTarget.JVM_17)", 17],
-            ["jvmTarget = JvmTarget.JVM_21", 21],
-            ['jvmTarget.set(JvmTarget.fromTarget("17"))', 17],
-            ['jvmTarget = "21"', 21],
-            ["jvmTarget.set(JvmTarget.JVM_1_8)", 8],
-        ])("reads %s", async (form, expected) => {
-            write("settings.gradle.kts", 'include(":app")\n');
-            write("app/build.gradle.kts", `kotlin { compilerOptions { ${form} } }\n`);
-            expect(await detectedJava()).toBe(expected);
-        });
-    });
-    describe("the files that pin a JDK outside Gradle", () => {
-        // mihon. The floor is 21 and no Gradle file says anything at all.
-        test("reads .github/.java-version", async () => {
-            write("settings.gradle.kts", 'include(":app")\n');
-            write("app/build.gradle.kts", "// nothing\n");
-            write(".github/.java-version", "21\n");
-            expect(await detectedJava()).toBe(21);
-        });
-        // thunderbird pins at the root.
-        test("reads a root .java-version", async () => {
-            write("settings.gradle.kts", 'include(":app")\n');
-            write(".java-version", "21\n");
-            expect(await detectedJava()).toBe(21);
-        });
-        test("reads a java entry in .tool-versions", async () => {
-            write("settings.gradle.kts", 'include(":app")\n');
-            write(".tool-versions", "nodejs 20.11.0\njava temurin-21.0.3+9\n");
-            expect(await detectedJava()).toBe(21);
-        });
-        test("reads .sdkmanrc", async () => {
-            write("settings.gradle.kts", 'include(":app")\n');
-            write(".sdkmanrc", "# comment\njava=17.0.9-tem\ngradle=8.13\n");
-            expect(await detectedJava()).toBe(17);
-        });
-        test("reads java-version from a workflow", async () => {
-            write("settings.gradle.kts", 'include(":app")\n');
-            write(".github/workflows/build.yml", "jobs:\n  build:\n    steps:\n      - uses: actions/setup-java@v4\n        with:\n          java-version: 21\n");
-            expect(await detectedJava()).toBe(21);
-        });
-        // A matrix declares several; the highest is the one that has to work.
-        test("takes the highest of a workflow matrix", async () => {
-            write("settings.gradle.kts", 'include(":app")\n');
-            write(".github/workflows/ci.yml", "strategy:\n  matrix:\n    java-version: [17, 21]\n");
-            expect(await detectedJava()).toBe(21);
-        });
-        // A pin is a floor, not a ceiling, and a Gradle declaration above it wins.
-        test("is a floor, not an override", async () => {
-            write("settings.gradle.kts", 'include(":app")\n');
-            write("app/build.gradle.kts", "kotlin { jvmToolchain(21) }\n");
-            write(".java-version", "17\n");
-            expect(await detectedJava()).toBe(21);
-        });
-        test("says nothing when nothing pins anything", async () => {
-            write("settings.gradle.kts", 'include(":app")\n');
-            write("app/build.gradle.kts", "// nothing\n");
-            expect(await detectedJava()).toBeUndefined();
-        });
-        // A version this scanner cannot make sense of must not become a number.
-        test("ignores an unreadable pin", async () => {
-            write("settings.gradle.kts", 'include(":app")\n');
-            write(".java-version", "graalvm-community\n");
-            expect(await detectedJava()).toBeUndefined();
-        });
-    });
-});
-//# sourceMappingURL=android-scanner-java.test.js.map