@node-core/utils 4.0.0

package/lib/landing_session.js

@@ -0,0 +1,506 @@
+import os from 'node:os';
+
+import {
+  runAsync, runSync, forceRunAsync
+} from './run.js';
+import Session from './session.js';
+import {
+  shortSha, isGhAvailable, getEditor
+} from './utils.js';
+
+const isWindows = process.platform === 'win32';
+
+const LINT_RESULTS = {
+  SKIPPED: 'skipped',
+  FAILED: 'failed',
+  SUCCESS: 'success'
+};
+
+export default class LandingSession extends Session {
+  constructor(cli, req, dir, {
+    prid, backport, lint, autorebase, fixupAll,
+    checkCI, oneCommitMax, ...argv
+  } = {}) {
+    super(cli, dir, prid);
+    this.req = req;
+    this.backport = backport;
+    this.lint = lint;
+    this.autorebase = autorebase;
+    this.fixupAll = fixupAll;
+    this.gpgSign = argv?.['gpg-sign']
+      ? (argv['gpg-sign'] === true ? ['-S'] : ['-S', argv['gpg-sign']])
+      : [];
+    this.oneCommitMax = oneCommitMax;
+    this.expectedCommitShas = [];
+    this.checkCI = !!checkCI;
+  }
+
+  get argv() {
+    const args = super.argv;
+    args.backport = this.backport;
+    args.lint = this.lint;
+    args.autorebase = this.autorebase;
+    args.fixupAll = this.fixupAll;
+    args.oneCommitMax = this.oneCommitMax;
+    return args;
+  }
+
+  async start(metadata) {
+    const { cli } = this;
+    this.startLanding();
+    this.expectedCommitShas =
+      metadata.data.commits.map(({ commit }) => commit.oid);
+    const status = metadata.status ? 'should be ready' : 'is not ready';
+    // NOTE(mmarchini): default answer is yes. If --yes is given, we need to be
+    // more careful though, and we change the default to the result of our
+    // metadata check.
+    const defaultAnswer = !cli.assumeYes ? true : metadata.status;
+    const shouldContinue = await cli.prompt(
+      `This PR ${status} to land, do you want to continue?`, { defaultAnswer });
+    if (!shouldContinue) {
+      await this.abort(false);
+      return process.exit(1);
+    }
+
+    this.saveMetadata(metadata);
+    this.startApplying();
+    return this.apply();
+  }
+
+  async abort(tryResetBranch = true) {
+    try {
+      const { cli } = this;
+      this.cleanFiles();
+      if (tryResetBranch) {
+        await this.tryResetBranch();
+      }
+      cli.ok(`Aborted \`git node land\` session in ${this.ncuDir}`);
+    } catch (ex) {
+      const { cli } = this;
+      cli.setExitCode(1);
+      cli.error(`Couldn't abort \`git node land\` session in ${this.ncuDir}`);
+      throw ex;
+    }
+  }
+
+  async downloadAndPatch() {
+    const { cli, repo, owner, prid, expectedCommitShas } = this;
+
+    cli.startSpinner(`Downloading patch for ${prid}`);
+    await runAsync('git', [
+      'fetch', `https://github.com/${owner}/${repo}.git`,
+      `refs/pull/${prid}/merge`]);
+    // We fetched the commit that would result if we used `git merge`.
+    // ^1 and ^2 refer to the PR base and the PR head, respectively.
+    const [base, head] = await runAsync('git',
+      ['rev-parse', 'FETCH_HEAD^1', 'FETCH_HEAD^2'],
+      { captureStdout: 'lines' });
+    const commitShas = await runAsync('git',
+      ['rev-list', `${base}..${head}`],
+      { captureStdout: 'lines' });
+    cli.stopSpinner(`Fetched commits as ${shortSha(base)}..${shortSha(head)}`);
+    cli.separator();
+
+    const mismatchedCommits = [
+      ...commitShas.filter((sha) => !expectedCommitShas.includes(sha))
+        .map((sha) => `Unexpected commit ${sha}`),
+      ...expectedCommitShas.filter((sha) => !commitShas.includes(sha))
+        .map((sha) => `Missing commit ${sha}`)
+    ].join('\n');
+    if (mismatchedCommits.length > 0) {
+      cli.error(`Mismatched commits:\n${mismatchedCommits}`);
+      process.exit(1);
+    }
+
+    const commitInfo = { base, head, shas: commitShas };
+    this.saveCommitInfo(commitInfo);
+
+    try {
+      await forceRunAsync('git',
+        ['cherry-pick', '--allow-empty', ...this.gpgSign, `${base}..${head}`],
+        { ignoreFailure: false });
+    } catch (ex) {
+      cli.error('Failed to apply patches');
+      process.exit(1);
+    }
+
+    cli.ok('Patches applied');
+    return commitInfo;
+  }
+
+  getRebaseSuggestion(subjects) {
+    const { upstream, branch } = this;
+    let command = `git rebase ${upstream}/${branch} --no-keep-empty -i`;
+    command += ' -x "git node land --amend"';
+
+    const squashes = subjects.filter(
+      line => line.includes('fixup!') || line.includes('squash!') || line.includes('amend!'));
+
+    if (squashes.length !== 0) {
+      command += ' --autosquash';
+    }
+
+    if (this.gpgSign) {
+      command += ' ' + this.gpgSign.join(' ');
+    }
+
+    return command;
+  }
+
+  makeRebaseSuggestion(subjects) {
+    const suggestion = this.getRebaseSuggestion(subjects);
+    this.cli.log('Please run the following commands to complete landing\n\n' +
+      `$ ${suggestion}\n` +
+      '$ git node land --continue');
+  }
+
+  canAutomaticallyRebase(subjects) {
+    return subjects.every(line => !line.startsWith('squash!'));
+  }
+
+  async validateLint() {
+    // The linter is currently only run on non-Windows platforms.
+    if (os.platform() === 'win32') {
+      return LINT_RESULTS.SKIPPED;
+    }
+
+    if (!this.lint) {
+      return LINT_RESULTS.SKIPPED;
+    }
+
+    try {
+      await runAsync('make', ['lint']);
+      return LINT_RESULTS.SUCCESS;
+    } catch {
+      return LINT_RESULTS.FAILED;
+    }
+  }
+
+  async tryCompleteLanding(commitInfo) {
+    const { cli } = this;
+    const subjects = await runAsync('git',
+      ['log', '--pretty=format:%s', `${commitInfo.base}..${commitInfo.head}`],
+      { captureStdout: 'lines' });
+
+    if (commitInfo.shas.length === 1) {
+      const shouldAmend = await cli.prompt(
+        'There is only one commit in this PR.\n' +
+        'do you want to amend the commit message?');
+      if (!shouldAmend) {
+        return;
+      }
+      const canFinal = await this.amend();
+      if (!canFinal) {
+        return;
+      }
+
+      return this.final();
+    } else if (this.fixupAll) {
+      cli.log(`There are ${subjects.length} commits in the PR. ` +
+        'Attempting to fixup everything into first commit.');
+      await runAsync('git', ['reset', '--soft', `HEAD~${subjects.length - 1}`]);
+      await runAsync('git', ['commit', '--amend', '--no-edit', ...this.gpgSign]);
+      return await this.amend() && this.final();
+    } else if (this.autorebase && this.canAutomaticallyRebase(subjects)) {
+      // Run git rebase in interactive mode with autosquash but without editor
+      // so that it will perform everything automatically.
+      cli.log(`There are ${subjects.length} commits in the PR. ` +
+        'Attempting autorebase.');
+      const { upstream, branch } = this;
+      const assumeYes = this.cli.assumeYes ? '--yes' : '';
+      const msgAmend = `-x "git node land --amend ${assumeYes}"`;
+      try {
+        await forceRunAsync('git',
+          ['rebase', ...this.gpgSign, `${upstream}/${branch}`,
+            '--no-keep-empty', '-i', '--autosquash', msgAmend],
+          {
+            ignoreFailure: false,
+            spawnArgs: {
+              shell: true,
+              env: { ...process.env, GIT_SEQUENCE_EDITOR: ':' }
+            }
+          });
+        return this.final();
+      } catch (e) {
+        await runAsync('git', ['rebase', '--abort']);
+        const count = subjects.length;
+        cli.log(`Couldn't rebase ${count} commits in the PR automatically`);
+        this.makeRebaseSuggestion(subjects);
+      }
+    } else {
+      this.makeRebaseSuggestion(subjects);
+    }
+  }
+
+  async apply() {
+    const { cli } = this;
+
+    // Bail if another landing session is currently in progress.
+    if (!this.isApplying()) {
+      cli.warn('Landing session already in progress - ' +
+        'to start a new one run `git node land --abort`');
+      return;
+    }
+    await this.tryResetBranch();
+
+    const commitInfo = await this.downloadAndPatch();
+
+    const cleanLint = await this.validateLint();
+    if (cleanLint === LINT_RESULTS.FAILED) {
+      const tryFixLint = await cli.prompt(
+        'Lint failed - try fixing with \'make lint-js-fix\'?');
+      if (tryFixLint) {
+        await runAsync('make', ['lint-js-fix']);
+        const fixed = await this.validateLint();
+        if (fixed === LINT_RESULTS.FAILED) {
+          cli.warn('Patch still contains lint errors. ' +
+            'Please fix manually before proceeding');
+        }
+      }
+
+      const correctedLint = await cli.prompt('Corrected all lint errors?');
+      if (correctedLint) {
+        await runAsync('git', ['add', '.']);
+
+        // Final message will be edited later - don't try to change it here.
+        await runAsync('git', ['commit', '--amend', '--no-edit', ...this.gpgSign]);
+      } else {
+        cli.info('Please fix lint errors and then run ' +
+        '`git node land --amend` followed by ' +
+        '`git node land --continue`.');
+        process.exit(1);
+      }
+    } else if (cleanLint === LINT_RESULTS.SUCCESS) {
+      cli.ok('Lint passed cleanly');
+    }
+
+    this.startAmending();
+
+    await this.tryCompleteLanding(commitInfo);
+  }
+
+  async amend() {
+    const { cli } = this;
+    if (!this.readyToAmend()) {
+      cli.warn('Not yet ready to amend, run `git node land --abort`');
+      return;
+    }
+    this.startAmending();
+
+    const rev = this.getCurrentRev();
+    const original = runSync('git', [
+      'show', 'HEAD', '-s', '--format=%B'
+    ]).trim();
+
+    // git has very specific rules about what is a trailer and what is not.
+    // Instead of trying to implement those ourselves, let git parse the
+    // original commit message and see if it outputs any trailers.
+    const originalHasTrailers = runSync('git', [
+      'interpret-trailers', '--parse', '--no-divider'
+    ], {
+      input: `${original}\n`
+    }).trim().length !== 0;
+
+    const metadata = this.metadata.trim().split('\n');
+    const amended = original.split('\n');
+
+    // If the original commit message already contains trailers (such as
+    // "Co-authored-by"), we simply add our own metadata after those. Otherwise,
+    // we have to add an empty line so that git recognizes our own metadata as
+    // trailers in the amended commit message.
+    if (!originalHasTrailers) {
+      amended.push('');
+    }
+
+    const BACKPORT_RE = /BACKPORT-PR-URL\s*:\s*(\S+)/i;
+    const PR_RE = /PR-URL\s*:\s*(\S+)/i;
+    const REVIEW_RE = /Reviewed-By\s*:\s*(\S+)/i;
+
+    for (const line of metadata) {
+      if (line.length !== 0 && original.includes(line)) {
+        if (originalHasTrailers) {
+          cli.warn(`Found ${line}, skipping..`);
+        } else {
+          cli.error('Git found no trailers in the original commit message, ' +
+                    `but '${line}' is present and should be a trailer.`);
+          process.exit(1);  // make it work with git rebase -x
+        }
+      } else {
+        if (line.match(BACKPORT_RE)) {
+          let prIndex = amended.findIndex(datum => datum.match(PR_RE));
+          if (prIndex === -1) {
+            prIndex = amended.findIndex(datum => datum.match(REVIEW_RE)) - 1;
+          }
+          amended.splice(prIndex + 1, 0, line);
+        } else {
+          amended.push(line);
+        }
+      }
+    }
+
+    const message = amended.join('\n');
+    const messageFile = this.saveMessage(rev, message);
+    cli.separator('New Message');
+    cli.log(message.trim());
+    const takeMessage = await cli.prompt('Use this message?');
+    if (takeMessage) {
+      await runAsync('git', ['commit', '--amend', '-F', messageFile, ...this.gpgSign]);
+      return true;
+    }
+
+    const editor = await getEditor({ git: true });
+    if (editor) {
+      try {
+        await forceRunAsync(
+          editor,
+          [`"${messageFile}"`],
+          { ignoreFailure: false, spawnArgs: { shell: true } }
+        );
+        await runAsync('git', ['commit', '--amend', '-F', messageFile, ...this.gpgSign]);
+        return true;
+      } catch {
+        cli.error('Failed to edit the message using the configured editor');
+      }
+    }
+
+    cli.log(`Please manually edit ${messageFile}, then run\n` +
+      `\`git commit --amend -F ${messageFile}\` ` +
+      'to finish amending the message');
+    process.exit(1);  // make it work with git rebase -x
+  }
+
+  async final() {
+    const {
+      cli, owner, repo, upstream, branch, prid, oneCommitMax
+    } = this;
+
+    // Check that git rebase/am has been completed.
+    if (!this.readyToFinal()) {
+      cli.warn('Not yet ready to final');
+      cli.log('A git rebase/am is in progress.' +
+        ' Please complete it before running git node land --final');
+      return;
+    };
+
+    const stray = this.getStrayCommits();
+    if (stray.length > 1) {
+      const forceLand = await cli.prompt(
+        'There is more than one commit in the PR. ' +
+        'Do you still want to land it?',
+        { defaultAnswer: !oneCommitMax });
+
+      if (!forceLand) {
+        cli.info(
+          'GITHUB_ACTION' in process.env
+
+            ? 'Add `commit-queue-squash` label to land the PR as one commit, ' +
+            'or `commit-queue-rebase` to land as separate commits.'
+
+            : 'Use --fixupAll option, squash the PR manually or land the PR ' +
+            'from the command line.'
+        );
+        process.exit(1);
+      }
+    }
+    const strayVerbose = this.getStrayCommits(true);
+    const validateCommand = new URL(
+      '../node_modules/.bin/core-validate-commit' + (isWindows ? '.cmd' : ''),
+      import.meta.url
+    );
+
+    try {
+      await forceRunAsync(validateCommand, stray, { ignoreFailure: false });
+    } catch (e) {
+      let forceLand = false;
+      if (e.code === 1) {
+        forceLand = await cli.prompt(
+          'The commit did not pass the validation. ' +
+          'Do you still want to land it?',
+          { defaultAnswer: false });
+      }
+
+      if (!forceLand) {
+        cli.info('Please fix the commit message and try again.');
+        cli.log('Please manually ammend the commit message, by running\n' +
+          '`git commit --amend`\n' +
+          'Once commit message is fixed, finish the landing command running\n' +
+          '`git node land --continue`');
+        process.exit(1);
+      }
+    }
+
+    cli.separator();
+    cli.log('The following commits are ready to be pushed to ' +
+      `${upstream}/${branch}`);
+    cli.log(`- ${strayVerbose.join('\n- ')}`);
+    cli.separator();
+
+    let willBeLanded = shortSha(stray[stray.length - 1]);
+    if (stray.length > 1) {
+      const head = shortSha(this.getUpstreamHead());
+      willBeLanded = `${head}...${willBeLanded}`;
+    }
+
+    this.cleanFiles();
+    cli.log('Temporary files removed.');
+    cli.log('To finish landing:');
+    cli.log('1. Run: ');
+    cli.log(`   git push ${upstream} ${branch}`);
+    const url = `https://github.com/${owner}/${repo}/pull/${prid}`;
+    cli.log(`2. Post "Landed in ${willBeLanded}" in ${url}`);
+    if (isGhAvailable()) {
+      cli.log(`   gh pr comment ${prid} --body "Landed in ${willBeLanded}"`);
+      cli.log(`   gh pr close ${prid}`);
+    }
+  }
+
+  async continue() {
+    const { cli } = this;
+    if (this.readyToFinal()) {
+      cli.log('Running `final`..');
+      return this.final();
+    }
+    if (this.readyToAmend()) {
+      cli.log('Running `amend`..');
+      return this.amend();
+    }
+    if (this.isApplying()) {
+      // We're still resolving conflicts.
+      if (this.cherryPickInProgress()) {
+        cli.log('Looks like you are resolving a `git cherry-pick` conflict');
+        cli.log('Please run `git status` for help');
+      } else {
+        // Conflicts has been resolved - amend.
+        this.startAmending();
+        return this.tryCompleteLanding(this.commitInfo);
+      }
+      return;
+    }
+    if (this.hasStarted()) {
+      cli.log('Running `apply`..');
+      return this.apply();
+    }
+    cli.log(
+      'Please run `git node land <PRID> to start a landing session`');
+  }
+
+  async status() {
+    // TODO
+  }
+
+  async warnForWrongBranch() {
+    if (super.warnForWrongBranch()) {
+      return true;
+    }
+    const rev = this.getCurrentBranch();
+    const { repository: { defaultBranchRef } } = await this.req.gql(
+      'DefaultBranchRef',
+      { owner: this.owner, repo: this.repo });
+    if ((rev === 'master' || rev === 'main') && defaultBranchRef.name !== rev) {
+      this.cli.warn(`You are running git-node-land on \`${rev}\`,` +
+                    ` but the default branch is \`${defaultBranchRef.name}\`.`);
+      this.cli.setExitCode(1);
+      return true;
+    }
+  }
+}

package/lib/links.js

@@ -0,0 +1,123 @@
+import * as cheerio from 'cheerio';
+
+const FIXES_RE = /(Close[ds]?|Fix(e[ds])?|Resolve[sd]?)\s*:\s*(\S+)/mgi;
+const FIX_RE = /(Close[ds]?|Fix(e[ds])?|Resolve[sd]?)\s*:\s*(\S+)/i;
+const REFS_RE = /Refs?\s*:\s*(\S+)/mgi;
+const REF_RE = /Refs?\s*:\s*(\S+)/i;
+const PR_RE = /PR-URL\s*:\s*(\S+)/i;
+
+/**
+ * Most of this class is ported from node-review
+ */
+export class LinkParser {
+  constructor(owner, repo, html) {
+    this.owner = owner;
+    this.repo = repo;
+    this.$ = cheerio.load(html);
+  }
+
+  getFixesUrlsFromArray(arr) {
+    const result = new Set();
+    for (const item of arr) {
+      const m = item.match(FIX_RE);
+      if (!m) continue;
+      const ref = m[3];
+      const url = this.getUrlFromOP(ref);
+      if (url) result.add(url);
+    }
+    return Array.from(result);
+  }
+
+  getRefsUrlsFromArray(arr) {
+    const result = new Set();
+    for (const item of arr) {
+      const m = item.match(REF_RE);
+      if (!m) continue;
+      const ref = m[1];
+      const url = this.getUrlFromOP(ref);
+      if (url) result.add(url);
+    }
+    return Array.from(result);
+  }
+
+  getPRUrlsFromArray(arr) {
+    const result = new Set();
+    for (const item of arr) {
+      const m = item.match(PR_RE);
+      if (!m) continue;
+      const prUrl = m[1];
+      const url = this.getUrlFromOP(prUrl);
+      if (url) result.add(url);
+    }
+    return Array.from(result);
+  }
+
+  // Do this so we can reliably get the correct url.
+  // Otherwise, the number could reference a PR or an issue.
+  getUrlFromOP(ref) {
+    const as = this.$('a');
+    const links = as.map((i, el) => this.$(el)).get();
+    for (const link of links) {
+      const text = link.text();
+      if (text === ref) {
+        const href = link.attr('href');
+        if (href) return href;
+      }
+    }
+  }
+
+  getFixes() {
+    const text = this.$.text();
+    const fixes = text.match(FIXES_RE) || [];
+    return this.getFixesUrlsFromArray(fixes);
+  }
+
+  getRefs() {
+    const text = this.$.text();
+    const refs = text.match(REFS_RE) || [];
+    return this.getRefsUrlsFromArray(refs);
+  }
+
+  getAltPrUrl() {
+    const text = this.$.text();
+    const refs = text.match(PR_RE) || [];
+    return this.getPRUrlsFromArray(refs);
+  }
+}
+
+const GITHUB_PULL_REQUEST_URL = /github.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/;
+
+export function parsePRFromURL(url) {
+  if (typeof url !== 'string') {
+    return undefined;
+  }
+  const match = url.match(GITHUB_PULL_REQUEST_URL);
+  if (match) {
+    return {
+      owner: match[1],
+      repo: match[2],
+      prid: parseInt(match[3])
+    };
+  }
+  return undefined;
+};
+
+export function getPrURL({ owner, repo, prid }) {
+  return `https://github.com/${owner}/${repo}/pull/${prid}`;
+};
+
+export function getMachineUrl(name) {
+  return `[${name}](https://ci.nodejs.org/computer/${name}/)`;
+};
+
+const PR_URL_RE = /PR-URL: https:\/\/github.com\/.+/;
+export function parsePrURL(text) {
+  if (typeof text !== 'string') {
+    return undefined;
+  }
+  const match = text.match(PR_URL_RE);
+  if (!match) {
+    return undefined;
+  }
+  return parsePRFromURL(match[0]);
+};

package/lib/mergeable_state.js

@@ -0,0 +1,3 @@
+export const CONFLICTING = 'CONFLICTING';
+export const MERGEABLE = 'MERGEABLE';
+export const UNKNOWN = 'UNKNOWN';

package/lib/metadata_gen.js

@@ -0,0 +1,61 @@
+import { LinkParser } from './links.js';
+
+/**
+ * @typedef {{reviewer: Collaborator}} Reviewer
+ */
+export default class MetadataGenerator {
+  /**
+   * @param {PRData} data
+   */
+  constructor(data) {
+    const { owner, repo, pr, reviewers, argv, skipRefs } = data;
+    this.owner = owner;
+    this.skipRefs = skipRefs;
+    this.repo = repo;
+    this.pr = pr;
+    this.reviewers = reviewers;
+    this.argv = argv;
+  }
+
+  /**
+   * @returns {string}
+   */
+  getMetadata() {
+    const {
+      reviewers: { approved: reviewedBy },
+      pr: { url: prUrl, bodyHTML: op },
+      owner,
+      repo
+    } = this;
+
+    const parser = new LinkParser(owner, repo, op);
+    const fixes = parser.getFixes();
+    const refs = parser.getRefs().filter(f => f !== prUrl);
+    const altPrUrl = parser.getAltPrUrl();
+
+    const meta = [];
+
+    // If there are multiple commits in a PR, we may not want to add
+    // Fixes/Refs metadata to all of them.
+    if (!this.skipRefs) {
+      // Map all issues fixed by the commit(s) in this PR.
+      meta.push(...fixes.map((fix) => `Fixes: ${fix}`));
+      // Map all issues referenced by the commit(s) in this PR.
+      meta.push(...refs.map((ref) => `Refs: ${ref}`));
+    }
+    const backport = this.argv ? this.argv.backport : undefined;
+    if (backport) {
+      meta.unshift(`Backport-PR-URL: ${prUrl}`);
+      meta.unshift(`PR-URL: ${altPrUrl}`);
+    } else {
+      // Reviews are only added here as backports should not contain reviews
+      // for the backport itself in the metadata
+      meta.unshift(`PR-URL: ${prUrl}`);
+      meta.push(
+        ...reviewedBy.map((r) => `Reviewed-By: ${r.reviewer.getContact()}`)
+      );
+    }
+    meta.push(''); // creates final EOL
+    return meta.join('\n');
+  }
+}