@invarn/cibuild 2.8.0 → 2.8.2

package/dist/src/shared/detect-project.js

@@ -33,6 +33,62 @@ function readOrNull(path) {
         return null;
     }
 }
+/**
+ * True when a path that is *named* like an Xcode container actually is one.
+ *
+ * **The** predicate — every question of the form "is this `.xcodeproj` a
+ * project" goes through here, and nothing else in cibuild joins a directory
+ * name to "there is a project there".
+ *
+ * A `.xcodeproj` is a directory whose whole content is `project.pbxproj`;
+ * without it `xcodebuild` refuses to open the project at all — "missing its
+ * project.pbxproj file". A `.xcworkspace` is `contents.xcworkspacedata` in
+ * the same way. Anything else ending in those suffixes is a directory with a
+ * suggestive name, and offering one is offering something Xcode would reject.
+ *
+ * `Uwi0/Oakane` is the row that found it. Its `iosApp/` ships two: a tracked
+ * `iosApp.xcodeproj` holding nothing but `project.xcworkspace/`, and the real
+ * `oakane.xcodeproj` beside it with a 20 217-byte `project.pbxproj`. The husk
+ * carries the name the KMM wizard gives, so the conventional name outranked
+ * the project that exists — and it supplied BOTH `IOS_PROJECT_PATH` and, via
+ * the scheme scan's project-name fallback, `IOS_SCHEME`. The build reached
+ * step 9 and died on "Unable to read project 'iosApp.xcodeproj'".
+ *
+ * This is the iOS twin of the Gradle module scan once treating "a directory
+ * holding a file called build.gradle" as a module: wrong in the same
+ * direction, and fixed the same way — one reader, used by everyone.
+ *
+ * The `.pbxproj` is deliberately NOT parsed. Its existence and non-emptiness
+ * is the whole question; a shared `.xcscheme` remains the oracle for what a
+ * project builds.
+ */
+export function isXcodeContainer(path) {
+    const manifest = path.endsWith(".xcworkspace")
+        ? "contents.xcworkspacedata"
+        : path.endsWith(".xcodeproj")
+            ? "project.pbxproj"
+            : null;
+    if (manifest === null)
+        return false;
+    try {
+        return statSync(resolve(path, manifest)).size > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/** The entries of `dir` that are real Xcode containers, in `readdir` order. */
+export function xcodeContainersIn(dir) {
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    return entries.filter((e) => (e.endsWith(".xcodeproj") || e.endsWith(".xcworkspace")) &&
+        isXcodeContainer(resolve(dir, e)));
+}
 /** True when this directory holds something an Apple build reads. */
 function holdsAppleConsumer(dir) {
     let entries;
@@ -42,7 +98,7 @@ function holdsAppleConsumer(dir) {
     catch {
         return false;
     }
-    if (entries.some((e) => e.endsWith(".xcodeproj") || e.endsWith(".xcworkspace"))) {
+    if (xcodeContainersIn(dir).length > 0) {
         return true;
     }
     if (entries.includes("Podfile"))
@@ -144,15 +200,11 @@ export function detectMobileProjectRoot(dir) {
     const iosFileIndicators = ["Podfile"];
     const hasIosFile = iosFileIndicators.some((f) => existsSync(resolve(dir, f)));
     if (!hasIosFile) {
-        try {
-            const entries = readdirSync(dir);
-            const hasXcodeDir = entries.some((e) => e.endsWith(".xcodeproj") || e.endsWith(".xcworkspace"));
-            if (hasXcodeDir)
-                return "ios";
-        }
-        catch {
-            // Unreadable directory — fall through.
-        }
+        // A husk — a directory named `*.xcodeproj` with no `project.pbxproj` —
+        // does not make this an iOS project root. Saying `ios` on the strength of
+        // one writes a pipeline aimed at something xcodebuild cannot open.
+        if (xcodeContainersIn(dir).length > 0)
+            return "ios";
     }
     else {
         return "ios";

package/dist/src/shared/xcode-container.test.d.ts

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

package/dist/src/shared/xcode-container.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xcode-container.test.d.ts","sourceRoot":"","sources":["../../../src/shared/xcode-container.test.ts"],"names":[],"mappings":""}

package/dist/src/shared/xcode-container.test.js

@@ -0,0 +1,123 @@
+/**
+ * A `.xcodeproj` with no `project.pbxproj` is not a project.
+ *
+ * `Uwi0/Oakane` is the row. Its `iosApp/` ships two Xcode projects: a tracked
+ * `iosApp.xcodeproj` holding nothing but `project.xcworkspace/`, and the real
+ * `oakane.xcodeproj` beside it. The scan chose the husk — `iosApp` is the name
+ * the KMM wizard gives, so the conventional name outranked the project that
+ * exists — and the build died at step 9 on
+ *
+ *   xcodebuild: error: Unable to read project 'iosApp.xcodeproj' …
+ *     Reason: … missing its project.pbxproj file.
+ *
+ * The husk supplied `IOS_SCHEME` too: with no shared schemes anywhere in that
+ * repository, `detectSchemes` falls back to each project's own directory name,
+ * so the husk contributed the scheme `iosApp` as well as the project path.
+ *
+ * This is the iOS twin of the Gradle module scan once treating "a directory
+ * holding a file called build.gradle" as a module, and it is fixed the same
+ * way: one reader, used by everyone.
+ */
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { isXcodeContainer, xcodeContainersIn, detectMobileProjectRoot } from "./detect-project.js";
+import { scanIosProject } from "../commands/ios-scanner.js";
+let root;
+beforeEach(() => {
+    root = mkdtempSync(join(tmpdir(), "cibuild-husk-"));
+});
+afterEach(() => {
+    rmSync(root, { recursive: true, force: true });
+});
+/** A project Xcode could open. */
+function project(name) {
+    mkdirSync(join(root, `${name}.xcodeproj`), { recursive: true });
+    writeFileSync(join(root, `${name}.xcodeproj`, "project.pbxproj"), "// !$*UTF8*$!\n");
+}
+/** Oakane's shape: the name, the inner workspace, and no project at all. */
+function husk(name) {
+    mkdirSync(join(root, `${name}.xcodeproj`, "project.xcworkspace"), { recursive: true });
+    writeFileSync(join(root, `${name}.xcodeproj`, "project.xcworkspace", "contents.xcworkspacedata"), '<?xml version="1.0" encoding="UTF-8"?>\n<Workspace version = "1.0"></Workspace>\n');
+}
+function workspace(name) {
+    mkdirSync(join(root, `${name}.xcworkspace`), { recursive: true });
+    writeFileSync(join(root, `${name}.xcworkspace`, "contents.xcworkspacedata"), '<?xml version="1.0" encoding="UTF-8"?>\n<Workspace version = "1.0"></Workspace>\n');
+}
+describe("isXcodeContainer", () => {
+    test("a project with a project.pbxproj is one", () => {
+        project("Real");
+        expect(isXcodeContainer(join(root, "Real.xcodeproj"))).toBe(true);
+    });
+    test("a project with no project.pbxproj is not", () => {
+        husk("iosApp");
+        expect(isXcodeContainer(join(root, "iosApp.xcodeproj"))).toBe(false);
+    });
+    test("an empty project.pbxproj is not a project either", () => {
+        mkdirSync(join(root, "Empty.xcodeproj"), { recursive: true });
+        writeFileSync(join(root, "Empty.xcodeproj", "project.pbxproj"), "");
+        expect(isXcodeContainer(join(root, "Empty.xcodeproj"))).toBe(false);
+    });
+    test("a workspace needs its contents.xcworkspacedata", () => {
+        workspace("Real");
+        mkdirSync(join(root, "Husk.xcworkspace"), { recursive: true });
+        expect(isXcodeContainer(join(root, "Real.xcworkspace"))).toBe(true);
+        expect(isXcodeContainer(join(root, "Husk.xcworkspace"))).toBe(false);
+    });
+    test("a path that is not named like a container is never one", () => {
+        mkdirSync(join(root, "Sources"), { recursive: true });
+        expect(isXcodeContainer(join(root, "Sources"))).toBe(false);
+        expect(isXcodeContainer(join(root, "does-not-exist"))).toBe(false);
+    });
+});
+describe("xcodeContainersIn", () => {
+    test("keeps the real projects and drops the husks", () => {
+        husk("iosApp");
+        project("oakane");
+        expect(xcodeContainersIn(root)).toEqual(["oakane.xcodeproj"]);
+    });
+    test("an unreadable directory is empty, not a throw", () => {
+        expect(xcodeContainersIn(join(root, "nowhere"))).toEqual([]);
+    });
+});
+describe("detectMobileProjectRoot", () => {
+    test("a husk alone is not an iOS project root", () => {
+        husk("iosApp");
+        expect(detectMobileProjectRoot(root)).toBeNull();
+    });
+    test("a real project beside a husk still is", () => {
+        husk("iosApp");
+        project("oakane");
+        expect(detectMobileProjectRoot(root)).toBe("ios");
+    });
+});
+describe("scanIosProject", () => {
+    test("Oakane's shape resolves the project that exists, and its scheme", async () => {
+        husk("iosApp");
+        project("oakane");
+        const scan = await scanIosProject(root);
+        expect(scan.projectPath).toBe("oakane.xcodeproj");
+        // No shared schemes anywhere, so each project falls back to its own name —
+        // and only one of them is a project.
+        expect(scan.detectedSchemes).toEqual(["oakane"]);
+    });
+    test("a repository whose only project is a husk resolves nothing", async () => {
+        husk("iosApp");
+        const scan = await scanIosProject(root);
+        expect(scan.projectPath).toBe("");
+        expect(scan.detectedSchemes).toEqual([]);
+    });
+    test("a single valid project is unchanged", async () => {
+        project("Contributions");
+        const scan = await scanIosProject(root);
+        expect(scan.projectPath).toBe("Contributions.xcodeproj");
+        expect(scan.detectedSchemes).toEqual(["Contributions"]);
+    });
+    test("a workspace still outranks a project beside it", async () => {
+        project("QiniuSDK");
+        workspace("QiniuSDK");
+        const scan = await scanIosProject(root);
+        expect(scan.projectPath).toBe("QiniuSDK.xcworkspace");
+    });
+});
+//# sourceMappingURL=xcode-container.test.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@invarn/cibuild",
-  "version": "2.8.0",
+  "version": "2.8.2",
   "description": "CI Build CLI — local pipeline orchestration and validation",
   "type": "module",
   "main": "dist/cli.cjs",