laneyard 0.3.0 → 0.4.1

package/dist/src/heuristics/env-example.js

@@ -0,0 +1,36 @@
+/**
+ * The variable names a `.env.example` advertises.
+ *
+ * A project that keeps its variables in `fastlane/.env` almost always commits a
+ * `.env.example` beside it — that is what the file is *for*: telling whoever
+ * clones the repository which variables they need. It is the one manifest of
+ * required variables that is both conventional and, unlike `.env` itself,
+ * actually present in the clone a build runs from.
+ *
+ * It catches what parsing the Fastfile cannot. `SENTRY_AUTH_TOKEN` is read by
+ * `sentry-cli`, not by any `ENV.fetch` in a lane, so no amount of reading the
+ * Fastfile finds it — and it sits in `.env.example`, named, all along.
+ *
+ * Only names are taken. The file is an example by definition, so its values are
+ * placeholders; reading them would be reading fiction, and a checklist that
+ * compared them to anything would be worse than one that did not look.
+ */
+export function parseEnvExample(content) {
+    const names = [];
+    for (const raw of content.split("\n")) {
+        const line = raw.trim();
+        if (line === "" || line.startsWith("#"))
+            continue;
+        // `export FOO=bar` is legal in these files and means the same thing.
+        const assignment = line.replace(/^export\s+/, "");
+        const eq = assignment.indexOf("=");
+        if (eq <= 0)
+            continue;
+        const name = assignment.slice(0, eq).trim();
+        // Shell-ish variable names only: anything else is a line this has
+        // misunderstood, and inventing a requirement is worse than missing one.
+        if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(name))
+            names.push(name);
+    }
+    return [...new Set(names)];
+}

package/dist/src/heuristics/platforms.js

@@ -1,17 +1,76 @@
+import { join } from "node:path";
 /**
- * Which platforms a project builds for.
+ * Where to look for the markers, given where the Fastfile turned out to be.
  *
- * Named knowledge of mobile toolchains — that `.xcodeproj` means Xcode, that
- * `build.gradle` means Gradle — hence its place in this module, and the
- * boundary that comes with it: nothing here refuses anything. It answers a
- * question; `setup` writes the answer down and the checklist reads it.
+ * Two places, and the order does not matter because the answer is a union.
  *
- * It lives here rather than in `cli/detect.ts` because two callers need the
- * same answer. Setup proposes a configuration from it, and the checklist
- * decides which sections apply from it. Two copies of this reasoning would be
- * free to disagree about the same repository, and the checklist would be the
- * one that looked wrong.
+ * The repository root is the obvious one, and used to be the only one. It is
+ * wrong on its own: the markers sit *beside* an app's fastlane folder, not
+ * beside the repository root — `ios/Runner.xcodeproj` and `fastlane/` are
+ * siblings, and both move together when the app is one directory of a
+ * monorepo. A repository holding `app/fastlane/Fastfile` and
+ * `app/ios/Runner.xcodeproj` reported "no Xcode project and no Gradle build",
+ * because that is three levels down and the table reaches two.
+ *
+ * The app's own directory is the second, and it is the one laneyard already
+ * knows: it asked where the Fastfile was during setup. Between them they cover
+ * the arrangements that actually occur —
+ *
+ * - `fastlane/` and `*.xcodeproj` both at the root: a plain native app;
+ * - `fastlane/`, `ios/`, `android/` at the root: React Native, Flutter;
+ * - `app/fastlane/`, `app/ios/`, `app/android/`: the same app inside a monorepo;
+ * - `ios/fastlane/`: a fastlane set up for one platform only, which then
+ *   reports that one platform and not its sibling — right, since those lanes
+ *   build one platform, and an irrelevant section is what teaches someone to
+ *   ignore the screen.
+ *
+ * Keeping both roots rather than replacing one with the other is what makes
+ * this strictly an addition: nothing the old behaviour found is lost.
+ *
+ * What is deliberately *not* done is deepening the table to `*​/*​/*` or `**`.
+ * A third level would match `node_modules/some-package/ios/X.xcodeproj` and
+ * `app/ios/Pods/Pods.xcodeproj`, and report iOS for an Android-only project on
+ * the strength of a dependency's own Xcode project. `**` would do that and walk
+ * every build directory to do it. Two levels from a root that is actually the
+ * app is a better question than four levels from a root that is not.
+ */
+export function appRootOf(fastlaneDir) {
+    if (!fastlaneDir)
+        return ".";
+    // Repository-relative and always forward-slashed, whatever the platform.
+    const parent = fastlaneDir.replace(/\/+$/, "").split("/").slice(0, -1).join("/");
+    return parent === "" ? "." : parent;
+}
+/**
+ * The one directory to list, given where the Fastfile turned out to be.
+ *
+ * Not the repository root, which is what it used to be and what made a
+ * repository holding `app/fastlane/Fastfile` and `app/ios/Runner.xcodeproj`
+ * report "no Xcode project and no Gradle build": that is three levels down and
+ * the table reaches two.
+ *
+ * Not both, either, though that was tempting — keeping the root as well would
+ * have made this purely additive. It also means a project configured with
+ * `ios/fastlane` is shown the Android section, on the strength of a sibling
+ * `android/` folder those lanes never touch. The fastlane directory is not a
+ * guess: setup asked for it and `laneyard.yml` records it, and it says which
+ * app this project *is*. Trusting it is the difference between a checklist
+ * about this project and a checklist about the repository it lives in.
+ *
+ * Anyone it gets wrong has the escape hatch the check itself names: `platforms`
+ * in `laneyard.yml` is read first and skips all of this.
+ *
+ * What is deliberately not done is deepening the table to `*​/*​/*` or `**`. A
+ * third level matches `node_modules/some-package/ios/X.xcodeproj` and
+ * `app/ios/Pods/Pods.xcodeproj`, and would report iOS for an Android-only
+ * project on the strength of a dependency. Two levels from a directory that is
+ * actually the app beats four from one that is not.
  */
+export function searchDir(from, appRoot) {
+    if (!appRoot || appRoot === "." || appRoot.startsWith(".."))
+        return from;
+    return join(from, appRoot);
+}
 /**
  * What a repository looks like from the outside, as a table.
  *