pob 38.10.0 → 38.12.0

package/lib/generators/core/git/CoreGitGenerator.js

@@ -1,8 +1,15 @@
 import remoteUrl from "git-remote-url";
 import githubUsername from "github-username";
 import Generator from "yeoman-generator";
+import { getRepoName, parseRepositoryUrl } from "../../../utils/git.js";
 import * as packageUtils from "../../../utils/package.js";
 
+const gitHostDomains = {
+  github: "github.com",
+  gitlab: "gitlab.com",
+  bitbucket: "bitbucket.org",
+};
+
 export default class CoreGitGenerator extends Generator {
   constructor(args, opts) {
     super(args, opts);
@@ -34,29 +41,29 @@ export default class CoreGitGenerator extends Generator {
   }
 
   async initializing() {
-    let originUrl = await remoteUrl(this.destinationPath(), "origin").catch(
+    // the real remote, kept apart from the package.json fallback: only a real
+    // remote means the repository already exists
+    this.originUrl = await remoteUrl(this.destinationPath(), "origin").catch(
       () => "",
     );
 
-    if (!originUrl) {
+    let repository = parseRepositoryUrl(this.originUrl);
+
+    if (!this.originUrl) {
       const pkg = this.fs.readJSON(this.destinationPath("package.json"), {});
-      originUrl = pkg.repository;
+      repository = parseRepositoryUrl(pkg.repository);
+      if (pkg.repository && !repository) {
+        console.warn(
+          `git: ignoring invalid repository in package.json: ${JSON.stringify(pkg.repository)}`,
+        );
+      }
     }
 
-    this.originUrl = originUrl;
-    const match =
-      originUrl &&
-      typeof originUrl === "string" &&
-      originUrl.match(
-        /^(?:git@|https?:\/\/)(?:([^./:]+)(?:\.com)?[/:])?([^/:]+)\/([^./:]+)(?:.git)?/,
-      );
-    if (!match) return;
-    const [, gitHost, gitAccount, repoName] = match;
-    this.gitHost = gitHost || "github";
-    this.gitHostAccount = gitAccount;
-    if (repoName !== "undefined") {
-      this.repoName = repoName;
-    }
+    this.hasRepositoryUrl = !!(this.originUrl || repository);
+    if (!repository) return;
+    this.gitHost = repository.gitHost;
+    this.gitHostAccount = repository.gitAccount;
+    this.repoName = repository.repoName;
   }
 
   async prompting() {
@@ -72,9 +79,12 @@ export default class CoreGitGenerator extends Generator {
         type: "list",
         name: "gitHost",
         message: "Which git host service would you like ?",
-        default: this.gitHost || (this.originUrl ? "none" : "github"),
+        default: this.gitHost || (this.hasRepositoryUrl ? "none" : "github"),
         choices: [
-          { value: "none", name: !this.originUrl ? "none" : "don't change" },
+          {
+            value: "none",
+            name: !this.hasRepositoryUrl ? "none" : "don't change",
+          },
           "github",
           "bitbucket",
           "gitlab",
@@ -121,23 +131,35 @@ export default class CoreGitGenerator extends Generator {
   writing() {
     console.log("git: writing");
 
-    if (this.gitHost === "none") {
+    if (this.gitHost === "none" || !this.gitHostAccount) {
       return;
     }
 
     const pkg = this.fs.readJSON(this.destinationPath("package.json"), {});
-    const repoName = this.repoName || this.options.name || pkg.name;
-
-    if (!pkg.homepage && this.gitHostAccount) {
-      pkg.homepage = `https://${this.gitHost}.com/${this.gitHostAccount}/${repoName}`;
-    }
-    if (this.gitHostAccount) {
-      pkg.bugs = {
-        url: `https://${this.gitHost}.com/${this.gitHostAccount}/${repoName}/issues`,
-      };
+    const repoName = this.repoName || getRepoName(pkg.name);
+    const repositoryUrl = `https://${this.gitHost}.com/${this.gitHostAccount}/${repoName}`;
+
+    // keep a custom homepage, but fix one pointing to another repository on the
+    // same host
+    const isHomepageInRepository = (homepage) => {
+      const lowerHomepage = homepage.toLowerCase();
+      const lowerRepositoryUrl = repositoryUrl.toLowerCase();
+      return (
+        lowerHomepage === lowerRepositoryUrl ||
+        lowerHomepage.startsWith(`${lowerRepositoryUrl}/`) ||
+        lowerHomepage.startsWith(`${lowerRepositoryUrl}#`)
+      );
+    };
+    if (
+      !pkg.homepage ||
+      (pkg.homepage.startsWith(`https://${this.gitHost}.com/`) &&
+        !isHomepageInRepository(pkg.homepage))
+    ) {
+      pkg.homepage = repositoryUrl;
     }
+    pkg.bugs = { url: `${repositoryUrl}/issues` };
 
-    const repository = `https://${this.gitHost}.com/${this.gitHostAccount}/${repoName}.git`;
+    const repository = `${repositoryUrl}.git`;
 
     if (pkg.repository !== repository) {
       pkg.repository = repository;
@@ -147,37 +169,30 @@ export default class CoreGitGenerator extends Generator {
 
     const cwd = this.destinationPath();
 
-    this.initGitRepository =
-      this.spawnCommandSync("git status", {
+    const isGitRepository =
+      this.spawnSync("git", ["rev-parse", "--git-dir"], {
         cwd,
         stdio: "ignore",
         reject: false,
-      }).status === 128;
-    if (this.initGitRepository) {
-      this.spawnCommandSync("git init", { cwd });
-
-      if (!this.originUrl) {
-        let repoSSH = pkg.repository;
-        if (pkg.repository && !pkg.repository.includes(".git")) {
-          /* this.spawnCommandSync('curl', [
-                        '--silent',
-                        '--write-out',
-                        '"%{http_code}"',
-                        '--output',
-                        '/dev/null',
-                        '-i',
-                        '-u',
-                        this.options.githubAccount,
-                        `-d "{"name": "${this.options.name}", "auto_init": true}`,
-                        'https://api.github.com/user/repos',
-                    ], { cwd }); */
-
-          repoSSH = pkg.repository;
-        }
+      }).exitCode === 0;
+    if (!isGitRepository) {
+      this.spawnSync("git", ["init"], { cwd });
+    }
 
-        this.spawnCommandSync(`git remote add origin ${repoSSH}`, {
-          cwd,
-        });
+    if (!this.originUrl) {
+      const remoteHost = gitHostDomains[this.gitHost];
+      if (remoteHost) {
+        const originSSH = `git@${remoteHost}:${this.gitHostAccount}/${repoName}.git`;
+        const { exitCode } = this.spawnSync(
+          "git",
+          ["remote", "add", "origin", originSSH],
+          { cwd, reject: false },
+        );
+        if (exitCode !== 0) {
+          console.warn(
+            `git: failed to add origin, run by hand: git remote add origin ${originSSH}`,
+          );
+        }
       }
     }
   }

package/lib/generators/core/git/generators/github/CoreGitGithubGenerator.js

@@ -1,10 +1,10 @@
-/* eslint-disable camelcase */
+/* oxlint-disable eslint-js/camelcase */
 
 import { spawnSync } from "node:child_process";
 import * as os from "node:os";
 import Generator from "yeoman-generator";
+import { getRepoName } from "../../../../../utils/git.js";
 import { ciContexts } from "../../../ci/CoreCIGenerator.js";
-// const packageUtils = require('../../../../../utils/package');
 
 const readTokenFromKeychain = () => {
   if (process.platform !== "darwin") return undefined;
@@ -26,71 +26,36 @@ const readTokenFromKeychain = () => {
 
 const GITHUB_TOKEN = process.env.POB_GITHUB_TOKEN || readTokenFromKeychain();
 
-const postJson = (url, jsonBody) =>
-  fetch(`https://api.github.com/${url}`, {
-    method: "POST",
-    body: JSON.stringify(jsonBody),
-    headers: {
-      authorization: `token ${GITHUB_TOKEN}`,
-    },
-  }).then((res) => (res.ok ? res.json() : null));
+const MISSING_TOKEN_HELP =
+  'Create a token with https://github.com/settings/tokens/new?scopes=repo&description=POB%20Generator and set it in the POB_GITHUB_TOKEN env variable, or store it in the macOS keychain with: security add-generic-password -s pob-github-token -a "$USER" -w';
+
+class GithubRequestError extends Error {
+  constructor(method, url, status, body) {
+    super(`${method} ${url} failed with status ${status}: ${body}`);
+    this.name = "GithubRequestError";
+    this.status = status;
+  }
+}
 
-const putJson = (url, jsonBody) =>
-  fetch(`https://api.github.com/${url}`, {
-    method: "PUT",
-    body: JSON.stringify(jsonBody),
+const githubRequest = async (method, url, jsonBody) => {
+  const res = await fetch(`https://api.github.com/${url}`, {
+    method,
+    body: jsonBody === undefined ? undefined : JSON.stringify(jsonBody),
     headers: {
+      accept: "application/vnd.github+json",
       authorization: `token ${GITHUB_TOKEN}`,
     },
-  }).then((res) => (res.ok ? res.json() : null));
-
-const configureProtectionRule = async (
-  owner,
-  repo,
-  onlyLatestLTS,
-  spawnCommandSync,
-) => {
-  if (!ciContexts || ciContexts.length === 0) {
-    throw new Error("Invalid ciContexts: []");
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new GithubRequestError(method, url, res.status, body);
   }
+  return res.json();
+};
 
-  for (const branch of ["main", "master"]) {
-    try {
-      const result = spawnCommandSync(
-        "git",
-        ["ls-remote", "--heads", `git@github.com:${owner}/${repo}.git`, branch],
-        { stdio: "pipe" },
-      );
-
-      const isBranchExists =
-        result.exitCode === 0 && result.stdout.toString().trim() !== "";
-
-      if (isBranchExists) {
-        await putJson(`repos/${owner}/${repo}/branches/${branch}/protection`, {
-          required_status_checks: {
-            strict: false,
-            contexts: ciContexts,
-          },
-          enforce_admins: false, // true,
-          required_pull_request_reviews: null,
-          restrictions: null,
-          required_linear_history: true,
-          allow_force_pushes: true, // false
-          allow_deletions: false,
-        });
-        if (branch === "master") {
-          console.warn('You should rename your "master" branch to "main"');
-        }
-      } else if (branch === "main") {
-        throw new Error(`Branch ${branch} does not exist`);
-      }
-    } catch (error) {
-      if (branch === "main") {
-        console.error(`Failed to configure ${branch} branch protection`);
-        console.error(error.stack || error.message || error);
-      }
-    }
-  }
+const printError = (message, error) => {
+  console.error(message);
+  console.error(error.stack || error.message || error);
 };
 
 const githubRepoConfig = {
@@ -123,8 +88,8 @@ export default class CoreGitGithubGenerator extends Generator {
 
     this.option("repoName", {
       type: String,
-      required: true,
-      description: "repo name",
+      required: false,
+      description: "repo name, computed from the package name when missing",
     });
 
     this.option("onlyLatestLTS", {
@@ -139,107 +104,189 @@ export default class CoreGitGithubGenerator extends Generator {
       description: "split CI jobs for faster result",
     });
 
-    if (!GITHUB_TOKEN && process.env.CI !== "true") {
-      console.warn(
-        'Missing POB_GITHUB_TOKEN. Create one with https://github.com/settings/tokens/new?scopes=repo&description=POB%20Generator and add it in your env variables, or store it in the macOS keychain with: security add-generic-password -s pob-github-token -a "$USER" -w',
-      );
-    }
+    this.option("ciEnabled", {
+      type: Boolean,
+      required: true,
+      description: "ci enabled",
+    });
   }
 
-  async end() {
-    if (!GITHUB_TOKEN) return;
-    const owner = this.options.gitHostAccount;
-    const repo = this.options.repoName;
+  async configureProtectionRule(owner, repo) {
+    if (!this.options.ciEnabled) return;
+    if (ciContexts.length === 0) {
+      console.warn("No ci contexts: branch protection not configured");
+      return;
+    }
 
-    const pkg = this.fs.readJSON(this.destinationPath("package.json"), {});
-    const name = pkg.name.endsWith("-monorepo")
-      ? pkg.name.slice(0, -"-monorepo".length)
-      : pkg.name;
+    const cwd = this.destinationPath();
 
-    if (this.options.shouldCreate) {
+    for (const branch of ["main", "master"]) {
       try {
-        if (this.options.shouldCreate) {
-          try {
-            await postJson("user/repos", {
-              name,
-              description: pkg.description,
-              homepage: null,
-              private: false,
-              auto_init: false,
-              ...githubRepoConfig,
-            });
-          } catch (error) {
-            console.error("Failed to create repository");
-            console.error(error.stack || error.message || error);
+        const result = this.spawnSync(
+          "git",
+          ["ls-remote", "--heads", "origin", branch],
+          { cwd, stdio: "pipe", reject: false },
+        );
+
+        const isBranchExists =
+          result.exitCode === 0 && result.stdout.toString().trim() !== "";
+
+        if (isBranchExists) {
+          await githubRequest(
+            "PUT",
+            `repos/${owner}/${repo}/branches/${branch}/protection`,
+            {
+              required_status_checks: {
+                strict: false,
+                contexts: ciContexts,
+              },
+              enforce_admins: false, // true,
+              required_pull_request_reviews: null,
+              restrictions: null,
+              required_linear_history: true,
+              allow_force_pushes: true, // false
+              allow_deletions: false,
+            },
+          );
+          if (branch === "master") {
+            console.warn('You should rename your "master" branch to "main"');
           }
+        } else if (branch === "main") {
+          throw new Error(`Branch ${branch} does not exist`);
+        }
+      } catch (error) {
+        if (branch === "main") {
+          printError(`Failed to configure ${branch} branch protection`, error);
         }
+      }
+    }
+  }
+
+  /**
+   * Runs a step of the repository setup, printing which step failed and what
+   * to run by hand instead of stopping the run.
+   */
+  runStep(description, manualCommand, fn) {
+    try {
+      fn();
+      return true;
+    } catch (error) {
+      printError(
+        `Failed to ${description}. Run by hand: ${manualCommand}`,
+        error,
+      );
+      return false;
+    }
+  }
+
+  async createRepository(owner, repo, pkg) {
+    const cwd = this.destinationPath();
 
-        const cwd = this.destinationPath();
-        try {
-          this.spawnCommandSync("git", ["add", "--all", "."], { cwd });
-        } catch (error) {
-          this.spawnCommandSync("git", ["init"], { cwd });
-          this.spawnCommandSync("git", ["add", "--all", "."], { cwd });
-          this.spawnCommandSync(
+    try {
+      const user = await githubRequest("GET", "user");
+      const isOrganization = user.login.toLowerCase() !== owner.toLowerCase();
+      await githubRequest(
+        "POST",
+        isOrganization ? `orgs/${owner}/repos` : "user/repos",
+        {
+          name: repo,
+          description: pkg.description,
+          homepage: null,
+          // only projects with an open source license are public: making a
+          // pushed public repository private does not undo its exposure
+          private: !pkg.license || pkg.license === "UNLICENSED",
+          auto_init: false,
+          ...githubRepoConfig,
+        },
+      );
+    } catch (error) {
+      if (error.status !== 422) {
+        printError(
+          `Failed to create github repository ${owner}/${repo}: nothing was committed or pushed`,
+          error,
+        );
+        return;
+      }
+      console.warn(
+        `github repository ${owner}/${repo} already exists, syncing its settings`,
+      );
+      await this.syncRepository(owner, repo, pkg);
+    }
+
+    const hasCommit =
+      this.spawnSync("git", ["rev-parse", "--verify", "HEAD"], {
+        cwd,
+        stdio: "ignore",
+        reject: false,
+      }).exitCode === 0;
+
+    if (!hasCommit) {
+      const committed = this.runStep(
+        "create the initial commit",
+        'git add --all . && git commit -m "chore: initial commit [skip ci]"',
+        () => {
+          this.spawnSync("git", ["add", "--all", "."], { cwd });
+          // generated files are already formatted by pob, and hooks may need
+          // tools not installed yet
+          this.spawnSync(
             "git",
-            [
-              "remote",
-              "add",
-              "origin",
-              `git@github.com:christophehurpeau/${name}.git`,
-            ],
-            { cwd },
+            ["commit", "-m", "chore: initial commit [skip ci]"],
+            { cwd, env: { POB_GIT_HOOKS: "0" } },
           );
-          console.error("Failed to create repository");
-          console.error(error.stack || error.message || error);
-        }
-        this.spawnCommandSync(
-          "git",
-          ["commit", "-m", "chore: initial commit [skip ci]"],
-          { cwd },
-        );
-        this.spawnCommandSync("git", ["branch", "-M", "main"], {
-          cwd,
-        });
-        this.spawnCommandSync("git", ["push", "-u", "origin", "main"], {
-          cwd,
-        });
-
-        await configureProtectionRule(
-          owner,
-          repo,
-          this.options.onlyLatestLTS,
-          this.spawnCommandSync.bind(this),
-        );
+        },
+      );
+      if (!committed) return;
+    }
 
-        // await gh.put(`/repos/${owner}/${repo}/topics`, {
-        //   names: pkg.keywords,
-        // });
-      } catch (error) {
-        console.error("Failed to create github repository");
-        console.error(error.stack || error.message || error);
-      }
-    } else {
-      console.log("sync github info");
+    const pushed = this.runStep(
+      "push to github",
+      "git branch -M main && git push -u origin main",
+      () => {
+        this.spawnSync("git", ["branch", "-M", "main"], { cwd });
+        this.spawnSync("git", ["push", "-u", "origin", "main"], { cwd });
+      },
+    );
+    if (!pushed) return;
+
+    await this.configureProtectionRule(owner, repo);
+  }
 
-      await postJson(`repos/${owner}/${repo}`, {
+  async syncRepository(owner, repo, pkg) {
+    try {
+      await githubRequest("PATCH", `repos/${owner}/${repo}`, {
         name: repo,
-        /* pkg.name
-            .replace(/-(lerna|monorepo)$/, '')
-            .replace(/^@([^-]*)-/, '$1-') */
         description: pkg.description,
-        // homepage: null,
         ...githubRepoConfig,
       });
+    } catch (error) {
+      printError(`Failed to sync github repository ${owner}/${repo}`, error);
+    }
+  }
 
-      if (this.options.ci) {
-        await configureProtectionRule(
-          owner,
-          repo,
-          this.options.onlyLatestLTS,
-          this.spawnCommandSync.bind(this),
+  async end() {
+    const pkg = this.fs.readJSON(this.destinationPath("package.json"), {});
+    const owner = this.options.gitHostAccount;
+    const repo = this.options.repoName || getRepoName(pkg.name);
+
+    if (!GITHUB_TOKEN) {
+      if (this.options.shouldCreate) {
+        console.warn(
+          `Missing POB_GITHUB_TOKEN: the github repository ${owner}/${repo} was not created, nothing was committed or pushed. ${MISSING_TOKEN_HELP}`,
+        );
+      } else if (process.env.CI !== "true") {
+        console.warn(
+          `Missing POB_GITHUB_TOKEN: github repository settings not synced. ${MISSING_TOKEN_HELP}`,
         );
       }
+      return;
+    }
+
+    if (this.options.shouldCreate) {
+      await this.createRepository(owner, repo, pkg);
+    } else {
+      console.log("sync github info");
+      await this.syncRepository(owner, repo, pkg);
+      await this.configureProtectionRule(owner, repo);
     }
   }
 }

package/lib/generators/core/gitignore/templates/gitignore.ejs

@@ -1,3 +1,4 @@
+# Generated by pob: do not edit, it is overwritten on each pob run.
 <% if (root) { -%>
 # dependencies
 node_modules

package/lib/generators/core/npm/templates/npmignore.ejs

@@ -1 +1,2 @@
+# Generated by pob: do not edit, it is overwritten on each pob run.
 # keep an empty file to avoid using gitignore.

package/lib/generators/core/package/CorePackageGenerator.js

@@ -121,6 +121,18 @@ export default class CorePackageGenerator extends Generator {
       pkg.type = this.options.packageType;
     }
 
+    // packages of a monorepo share the author, the license and the type of the
+    // root package.json
+    const rootPkg =
+      inMonorepo && !inMonorepo.root ? inMonorepo.rootMonorepoPkg : undefined;
+    if (rootPkg) {
+      if (!pkg.author && !pkg.authors && rootPkg.author) {
+        pkg.author = rootPkg.author;
+      }
+      if (!pkg.type && rootPkg.type) pkg.type = rootPkg.type;
+    }
+    const defaultLicense = rootPkg?.license;
+
     let author = packageUtils.parsePkgAuthor(pkg);
 
     const props = await this.prompt(
@@ -160,7 +172,7 @@ export default class CorePackageGenerator extends Generator {
           message: "License Type",
           type: "list",
           choices: ["MIT", "ISC", "UNLICENSED"],
-          when: !pkg.license,
+          when: !pkg.license && !defaultLicense,
         },
       ].filter(Boolean),
     );
@@ -257,15 +269,16 @@ export default class CorePackageGenerator extends Generator {
     }
 
     if (!pkg.license) {
-      pkg.license = props.license;
-      this.fs.copyTpl(
-        this.templatePath(`licenses/${props.license}.ejs`),
-        this.destinationPath("LICENSE"),
-        {
+      pkg.license = props.license || defaultLicense;
+      const licenseTemplatePath = this.templatePath(
+        `licenses/${pkg.license}.ejs`,
+      );
+      if (fs.existsSync(licenseTemplatePath)) {
+        this.fs.copyTpl(licenseTemplatePath, this.destinationPath("LICENSE"), {
           year: new Date().getFullYear(),
           author: pkg.author,
-        },
-      );
+        });
+      }
     }
 
     if (pkg.private) {