@rtorcato/repo-tooling 3.32.0 → 3.33.0

package/dist/cli/commands/fix-targets.js

@@ -76,6 +76,8 @@ const SWIFT_FIX_TARGETS = {
     // `Swift tests` is deliberately absent: when it fails for the manifest half
     // (no `.testTarget(`) there's nothing to run, and rewriting Package.swift
     // isn't safe. The check's own hint covers both halves.
+    // `Swift targets` too (#575): the repair is either adding a target or
+    // deleting the directory, and only the project knows which.
 };
 /** The same shadowing for the Python module (#290). */
 const PYTHON_FIX_TARGETS = {

package/dist/languages/swift/checks.js

@@ -16,6 +16,7 @@
 import path from 'node:path';
 import fs from 'fs-extra';
 import { checkFile } from '../../base/checks.js';
+import { parsePackageSwift } from './ci.js';
 import { SWIFT_HOOKS_DIR } from './git-hooks.js';
 const SWIFT_FILE_CHECKS = [
     {
@@ -118,19 +119,82 @@ export async function checkPackageSwift(dir) {
         detail: `Package.swift declares tools ${toolsVersion} and explicit platforms`,
     };
 }
+/** Subdirectory names of `<dir>/<root>`, or none when that root doesn't exist. */
+async function subdirectories(dir, root) {
+    try {
+        const entries = await fs.readdir(path.join(dir, root), { withFileTypes: true });
+        return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    }
+    catch {
+        return [];
+    }
+}
 /**
  * Directory names under `Sources/`. For a SwiftPM package these are the target
  * names — a target's sources and its DocC catalogue live in the same folder,
  * so this is where both the check and the `docc` fixer have to look.
  */
 export async function swiftSourceTargets(dir) {
-    try {
-        const entries = await fs.readdir(path.join(dir, 'Sources'), { withFileTypes: true });
-        return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    return subdirectories(dir, 'Sources');
+}
+/** Where SwiftPM looks for a target's sources when the manifest gives no `path:`. */
+const TARGET_ROOTS = ['Sources', 'Tests'];
+/**
+ * Sources that belong to no declared target (#575). SwiftPM silently ignores a
+ * directory under `Sources/` that no `.target(` names — so `swift build` and
+ * `swift test` both exit 0 while the code in it is never compiled and the tests
+ * in it are never run. There is no red X anywhere, which is the whole reason
+ * this check exists: a renamed target, a dropped `.target(...)` line, or a
+ * generator that rewrote the manifest all leave the same invisible hole.
+ *
+ * No fixer: repairing it means either adding a target or deleting the
+ * directory, and nothing outside the project can tell which.
+ */
+export async function checkSwiftTargets(dir) {
+    const check = 'Swift targets';
+    const filepath = path.join(dir, 'Package.swift');
+    if (!(await fs.pathExists(filepath))) {
+        return { check, status: 'missing', detail: 'no Package.swift' };
     }
-    catch {
-        return [];
+    const contents = await fs.readFile(filepath, 'utf-8');
+    // A custom `path:` puts a target's sources anywhere, so directory names stop
+    // meaning target names and every comparison below becomes a guess. Bail out
+    // rather than report something we can't stand behind. Deliberately crude:
+    // `.package(path:)` for a local dependency trips this too, which costs a
+    // skipped check on repos that use one — cheaper than a false accusation.
+    if (/\bpath:\s*"/.test(contents)) {
+        return {
+            check,
+            status: 'ok',
+            detail: 'not checked — Package.swift uses a custom `path:`, so directories need not match targets',
+        };
     }
+    const declared = new Set(parsePackageSwift(contents).targets);
+    const orphans = [];
+    let scanned = 0;
+    for (const root of TARGET_ROOTS) {
+        for (const name of await subdirectories(dir, root)) {
+            scanned++;
+            if (!declared.has(name))
+                orphans.push(`${root}/${name}`);
+        }
+    }
+    if (scanned === 0) {
+        return { check, status: 'ok', detail: 'no directories under Sources/ or Tests/' };
+    }
+    if (orphans.length > 0) {
+        return {
+            check,
+            status: 'drift',
+            detail: `no target declares ${orphans.join(', ')} — SwiftPM ignores them, so \`swift build\` passes without building them`,
+            hint: `Add a target named after each directory to Package.swift, or delete the directory: ${orphans.join(', ')}`,
+        };
+    }
+    return {
+        check,
+        status: 'ok',
+        detail: `all ${scanned} source directories are declared as targets`,
+    };
 }
 async function findDoccCatalogue(dir) {
     for (const target of await swiftSourceTargets(dir)) {
@@ -270,6 +334,7 @@ export async function runSwiftChecks(dir) {
         await checkPackageSwift(dir),
         ...(await Promise.all(SWIFT_FILE_CHECKS.map((spec) => checkFile(dir, spec)))),
         await checkSwiftGitignore(dir),
+        await checkSwiftTargets(dir),
         await checkSwiftTests(dir),
         await checkDocC(dir),
         await checkSwiftRelease(dir),

package/dist/languages/swift/ci.js

@@ -13,23 +13,38 @@ import { renderGitHubWorkflow, renderGitLabCI } from '../../base/ci.js';
 /** SwiftPM runs on macOS runners — Xcode isn't available anywhere else. */
 const MACOS = 'macos-latest';
 /**
- * Pull the two facts CI needs out of a Package.swift. A regex rather than a
- * SwiftPM invocation: `swift package dump-package` would need a Swift toolchain
- * on the machine running `repo-tooling`, which is usually a Node environment.
+ * Every SwiftPM target factory. `name:` is their first parameter and Swift
+ * enforces argument order, so a literal name always follows the open paren.
+ * `binaryTarget` owns no source directory but is matched anyway: the only
+ * consumer uses this set to *suppress* a report, so over-matching costs a
+ * missed finding while under-matching costs a false one.
+ */
+const TARGET_DECL = /\.(?:target|executableTarget|testTarget|macro|plugin|systemLibrary|binaryTarget)\(\s*name:\s*"([^"]+)"/g;
+/**
+ * Pull the facts doctor and CI need out of a Package.swift. A regex rather than
+ * a SwiftPM invocation: `swift package dump-package` would need a Swift
+ * toolchain on the machine running `repo-tooling`, which is usually a Node
+ * environment.
+ *
+ * ponytail: literal string arguments only. A manifest that builds its target
+ * list in a loop, behind `#if`, or from a variable parses as fewer targets than
+ * it declares — callers that act on the result must fail open. Upgrade path is
+ * `swift package dump-package` on a machine that has Swift.
  */
 export function parsePackageSwift(contents) {
     const products = [...contents.matchAll(/\.library\(\s*name:\s*"([^"]+)"/g)].map((m) => m[1]);
+    const targets = [...contents.matchAll(TARGET_DECL)].map((m) => m[1]);
     // Only the `platforms:` array declares deployment targets — matching
     // `.iOS(` across the whole manifest would also catch `.iOS` in target
     // conditionals.
     const platformsClause = contents.match(/platforms:\s*\[([^\]]*)\]/s)?.[1] ?? '';
     const platforms = [...platformsClause.matchAll(/\.(iOS|macOS|tvOS|watchOS|visionOS)\s*\(/g)].map((m) => m[1]);
-    return { products, platforms: [...new Set(platforms)] };
+    return { products, platforms: [...new Set(platforms)], targets };
 }
 export async function readSwiftPackage(dir) {
     const filepath = path.join(dir, 'Package.swift');
     if (!(await fs.pathExists(filepath)))
-        return { products: [], platforms: [] };
+        return { products: [], platforms: [], targets: [] };
     return parsePackageSwift(await fs.readFile(filepath, 'utf-8'));
 }
 /** Checkout + pin Xcode. Every Swift job needs both before it can do anything. */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rtorcato/repo-tooling",
-	"version": "3.32.0",
+	"version": "3.33.0",
 	"description": "One CLI to scaffold, audit and fix your repo's whole toolchain — linting, tests, commits, releases & CI.",
 	"type": "module",
 	"keywords": [