@node-core/utils 4.0.0

package/lib/reviews.js

@@ -0,0 +1,178 @@
+import {
+  PENDING, COMMENTED, APPROVED, CHANGES_REQUESTED, DISMISSED
+} from './review_state.js';
+import { isCollaborator } from './collaborators.js';
+import { ascending } from './utils.js';
+
+const LGTM_RE = /^lgtm\W?$/i;
+const FROM_REVIEW = 'review';
+const FROM_COMMENT = 'comment';
+const FROM_REVIEW_COMMENT = 'review_comment';
+
+export class Review {
+  /**
+   * @param {string} state
+   * @param {string} date  // ISO date string
+   * @param {string} ref
+   * @param {string} source
+   */
+  constructor(state, date, ref, source) {
+    this.state = state;
+    this.date = date;
+    this.ref = ref;
+    this.source = source;
+  }
+}
+
+/**
+  * @typedef  {Object} GHReview
+  * @property {string} bodyText
+  * @property {string} state
+  * @property {{login: string}} author
+  * @property {string} url
+  * @property {string} publishedAt
+  *
+  * @typedef  {Object} GHComment
+  * @property {string} bodyText
+  * @property {{login: string}} author
+  * @property {string} publishedAt
+  *
+ */
+export class ReviewAnalyzer {
+  /**
+   * @param {PRData} data
+   */
+  constructor(data) {
+    const { reviews, comments, collaborators } = data;
+    this.reviews = reviews;
+    this.comments = comments;
+    this.collaborators = collaborators;
+  }
+
+  /**
+   * @returns {Map<string, Review>}
+   */
+  mapByGithubReviews() {
+    const map = new Map();
+    const collaborators = this.collaborators;
+    const list = this.reviews
+      .filter((r) => r.state !== PENDING)
+      .filter((r) => {
+        if (r.state === COMMENTED) {
+          return this.isApprovedInComment(r);
+        } else {
+          return true;
+        }
+      })
+      .filter((r) => {
+        return (isCollaborator(collaborators, r.author));
+      }).sort((a, b) => {
+        return ascending(a.publishedAt, b.publishedAt);
+      });
+
+    for (const r of list) {
+      const login = r.author.login.toLowerCase();
+      const entry = map.get(login);
+      if (!entry) {  // initialize
+        map.set(
+          login,
+          new Review(r.state, r.publishedAt, r.url, FROM_REVIEW)
+        );
+      }
+      switch (r.state) {
+        case APPROVED:
+        case CHANGES_REQUESTED:
+          // Overwrite previous reviews, whether initalized or not
+          map.set(
+            login,
+            new Review(r.state, r.publishedAt, r.url, FROM_REVIEW)
+          );
+          break;
+        case COMMENTED:
+          map.set(
+            login,
+            new Review(APPROVED, r.publishedAt, r.bodyText, FROM_REVIEW_COMMENT)
+          );
+          break;
+        case DISMISSED:
+          // TODO: check the state of the dismissed review?
+          map.delete(login);
+          break;
+      }
+    }
+    return map;
+  }
+
+  // TODO: count -1 ...? But they should just make it explicit
+  /**
+   * @param {Map<string, Review>} oldMap
+   * @returns {Map<string, Review>}
+   */
+  updateMapByRawReviews(oldMap) {
+    const comments = this.comments;
+    const collaborators = this.collaborators;
+    const withLgtm = comments.filter((c) => this.hasLGTM(c))
+      .filter((c) => {
+        return (isCollaborator(collaborators, c.author));
+      }).sort((a, b) => {
+        return ascending(a.publishedAt, b.publishedAt);
+      });
+
+    for (const c of withLgtm) {
+      const login = c.author.login.toLowerCase();
+      const entry = oldMap.get(login);
+      if (!entry || entry.date < c.publishedAt) {
+        oldMap.set(
+          login,
+          // no url, have to use bodyText for refs
+          new Review(APPROVED, c.publishedAt, c.bodyText, FROM_COMMENT)
+        );
+      }
+    }
+    return oldMap;
+  }
+
+  /**
+   * @typedef {{reviwewer: Collaborator, review: Review}[]} ReviewerList
+   * @returns {{approved: ReviewerList, requestedChanges: ReviewerList}}
+   */
+  getReviewers() {
+    const ghReviews = this.mapByGithubReviews();
+    const reviewers = this.updateMapByRawReviews(ghReviews);
+    const result = {
+      approved: [],
+      requestedChanges: []
+    };
+    const collaborators = this.collaborators;
+    for (const [login, review] of reviewers) {
+      const reviewer = collaborators.get(login.toLowerCase());
+      if (review.state === APPROVED) {
+        result.approved.push({ reviewer, review });
+      } else if (review.state === CHANGES_REQUESTED) {
+        result.requestedChanges.push({ reviewer, review });
+      }
+    }
+    return result;
+  }
+
+  /**
+   * @param review
+   * @returns {boolean}
+   */
+  isApprovedInComment(review) {
+    return review.state === COMMENTED && this.hasLGTM(review);
+  }
+
+  /**
+   * @param object
+   * @param prop: string
+   * @returns {boolean}
+   */
+  hasLGTM(object) {
+    return LGTM_RE.test(object.bodyText.trim());
+  }
+}
+
+export const REVIEW_SOURCES = {
+  FROM_COMMENT, FROM_REVIEW, FROM_REVIEW_COMMENT
+};

package/lib/run.js

@@ -0,0 +1,106 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+import {
+  isDebugVerbosity,
+  debuglog
+} from './verbosity.js';
+
+export const IGNORE = '__ignore__';
+
+function runAsyncBase(cmd, args, {
+  ignoreFailure = true,
+  spawnArgs,
+  input,
+  captureStdout = false
+} = {}) {
+  if (cmd instanceof URL) {
+    cmd = fileURLToPath(cmd);
+  }
+  let stdio = 'inherit';
+  if (captureStdout || input != null) {
+    stdio = [input == null ? 'inherit' : 'pipe', captureStdout ? 'pipe' : 'inherit', 'inherit'];
+  }
+  return new Promise((resolve, reject) => {
+    const opt = Object.assign({
+      cwd: process.cwd(),
+      stdio
+    }, spawnArgs);
+    if (isDebugVerbosity()) {
+      debuglog('[Spawn]', `${cmd} ${(args || []).join(' ')}`, opt);
+    }
+    const child = spawn(cmd, args, opt);
+    let stdout;
+    if (captureStdout) {
+      stdout = '';
+      child.stdout.setEncoding('utf8');
+      child.stdout.on('data', (chunk) => { stdout += chunk; });
+    }
+    child.on('close', (code) => {
+      if (code !== 0) {
+        if (ignoreFailure) {
+          return reject(new Error(IGNORE));
+        }
+        const err = new Error(`${cmd} ${args} failed: ${code}`);
+        err.code = code;
+        err.messageOnly = true;
+        return reject(err);
+      }
+      if (captureStdout === 'lines') {
+        stdout = stdout.split(/\r?\n/g);
+        if (stdout[stdout.length - 1] === '') stdout.pop();
+      }
+      return resolve(stdout);
+    });
+    if (input != null) child.stdin.end(input);
+  });
+}
+
+export function forceRunAsync(cmd, args, options) {
+  return runAsyncBase(cmd, args, options).catch((error) => {
+    if (error.message !== IGNORE) {
+      if (!error.messageOnly) {
+        console.error(error);
+      }
+      throw error;
+    }
+  });
+};
+
+export function runPromise(promise) {
+  return promise.catch((error) => {
+    if (error.message !== IGNORE) {
+      console.error(error);
+    }
+    exit();
+  });
+};
+
+export function runAsync(cmd, args, options) {
+  return runPromise(runAsyncBase(cmd, args, options));
+};
+
+export function runSync(cmd, args, options) {
+  if (cmd instanceof URL) {
+    cmd = fileURLToPath(cmd);
+  }
+  const opt = Object.assign({
+    cwd: process.cwd()
+  }, options);
+  if (isDebugVerbosity()) {
+    debuglog('[SpawnSync]', `${cmd} ${(args || []).join(' ')}`, opt);
+  }
+  const child = spawnSync(cmd, args, opt);
+  if (child.error) {
+    throw child.error;
+  } else if (child.status !== 0) {
+    throw new Error(`${cmd} ${args} failed with stderr: ` +
+                    child.stderr.toString());
+  } else {
+    return child.stdout.toString();
+  }
+};
+
+export function exit() {
+  process.exit(1);
+};

package/lib/session.js

@@ -0,0 +1,415 @@
+import path from 'node:path';
+import fs from 'node:fs';
+
+import { getMergedConfig, getNcuDir } from './config.js';
+import { readJson, writeJson, readFile, writeFile } from './file.js';
+import {
+  runAsync, runSync, forceRunAsync
+} from './run.js';
+import {
+  shortSha
+} from './utils.js';
+
+const APPLYING = 'APPLYING';
+const STARTED = 'STARTED';
+const AMENDING = 'AMENDING';
+
+export default class Session {
+  constructor(cli, dir, prid, argv, warnForMissing = true) {
+    this.cli = cli;
+    this.dir = dir;
+    this.prid = prid;
+    this.config = { ...getMergedConfig(this.dir), ...argv };
+
+    if (warnForMissing) {
+      const { upstream, owner, repo } = this;
+      if (this.warnForMissing()) {
+        throw new Error('Failed to create new session');
+      }
+
+      const upstreamHref = runSync('git', [
+        'config', '--get',
+      `remote.${upstream}.url`]).trim();
+      if (!new RegExp(`${owner}/${repo}(?:.git)?$`).test(upstreamHref)) {
+        cli.warn('Remote repository URL does not point to the expected ' +
+        `repository ${owner}/${repo}`);
+        cli.setExitCode(1);
+      }
+    }
+  }
+
+  get session() {
+    return readJson(this.sessionPath);
+  }
+
+  get gitDir() {
+    return path.join(this.dir, '.git');
+  }
+
+  get ncuDir() {
+    return getNcuDir(this.dir);
+  }
+
+  get argv() {
+    // TODO(joyeecheung): remove this and make argv an object
+    return {
+      owner: this.owner,
+      repo: this.repo,
+      upstream: this.upstream,
+      branch: this.branch,
+      readme: this.readme,
+      waitTimeSingleApproval: this.waitTimeSingleApproval,
+      waitTimeMultiApproval: this.waitTimeMultiApproval,
+      updateDeprecations: this.updateDeprecations,
+      ciType: this.ciType,
+      prid: this.prid,
+      checkCI: this.checkCI
+    };
+  }
+
+  get sessionPath() {
+    return path.join(this.ncuDir, 'land');
+  }
+
+  get owner() {
+    return this.config.owner || 'nodejs';
+  }
+
+  get repo() {
+    return this.config.repo || 'node';
+  }
+
+  get upstream() {
+    return this.config.upstream;
+  }
+
+  get branch() {
+    return this.config.branch;
+  }
+
+  get readme() {
+    return this.config.readme;
+  }
+
+  get waitTimeSingleApproval() {
+    return this.config.waitTimeSingleApproval;
+  }
+
+  get waitTimeMultiApproval() {
+    return this.config.waitTimeMultiApproval;
+  }
+
+  get ciType() {
+    return this.config.ciType || 'nodejs';
+  }
+
+  get pullName() {
+    return `${this.owner}/${this.repo}/pulls/${this.prid}`;
+  }
+
+  get pullDir() {
+    return path.join(this.ncuDir, `${this.prid}`);
+  }
+
+  get updateDeprecations() {
+    return this.config.updateDeprecations || 'yes';
+  }
+
+  startLanding() {
+    writeJson(this.sessionPath, {
+      state: STARTED,
+      prid: this.prid,
+      config: this.config
+    });
+  }
+
+  // TODO(joyeecheung): more states
+  // - STARTED (fetching metadata)
+  // - DOWNLOADING (downloading the patch)
+  // - PATCHING (git am)
+  // - AMENDING (git rebase or just amending messages)
+  // - DONE
+
+  startApplying() {
+    this.updateSession({
+      state: APPLYING
+    });
+  }
+
+  startAmending() {
+    this.updateSession({
+      state: AMENDING
+    });
+  }
+
+  cleanFiles() {
+    let sess;
+    try {
+      sess = this.session;
+    } catch (err) {
+      return fs.rmSync(this.sessionPath, { recursive: true, force: true });
+    }
+
+    if (sess.prid && sess.prid === this.prid) {
+      fs.rmSync(this.pullDir, { recursive: true, force: true });
+    }
+    fs.rmSync(this.sessionPath, { recursive: true, force: true });
+  }
+
+  get statusPath() {
+    return path.join(this.pullDir, 'status');
+  }
+
+  get status() {
+    return readJson(this.statusPath);
+  }
+
+  get metadataPath() {
+    return path.join(this.pullDir, 'metadata');
+  }
+
+  get metadata() {
+    return readFile(this.metadataPath);
+  }
+
+  get commitInfoPath() {
+    return path.join(this.pullDir, 'commit-info');
+  }
+
+  get commitInfo() {
+    return readJson(this.commitInfoPath);
+  }
+
+  getMessagePath(rev) {
+    return path.join(this.pullDir, `${shortSha(rev)}.COMMIT_EDITMSG`);
+  }
+
+  updateSession(update) {
+    const old = this.session;
+    writeJson(this.sessionPath, Object.assign(old, update));
+  }
+
+  saveStatus(status) {
+    writeJson(this.statusPath, status);
+  }
+
+  saveMetadata(status) {
+    writeFile(this.metadataPath, status.metadata);
+  }
+
+  saveCommitInfo(commitInfo) {
+    writeJson(this.commitInfoPath, commitInfo);
+  }
+
+  saveMessage(rev, message) {
+    const file = this.getMessagePath(rev);
+    writeFile(file, message);
+    return file;
+  }
+
+  hasStarted() {
+    return !!this.session.prid && this.session.prid === this.prid;
+  }
+
+  isApplying() {
+    return this.session.state === APPLYING;
+  }
+
+  readyToAmend() {
+    if (this.session.state === AMENDING) {
+      return true;
+    } else if (this.isApplying()) {
+      return !this.cherryPickInProgress();
+    } else {
+      return false;
+    }
+  }
+
+  readyToFinal() {
+    if (this.amInProgress() || this.cherryPickInProgress()) {
+      return false;  // git am/rebase in progress
+    }
+    return this.session.state === AMENDING;
+  }
+
+  // Refs: https://github.com/git/git/blob/99de064/git-rebase.sh#L208-L228
+  // XXX: This may be unused at this point?
+  amInProgress() {
+    const amPath = path.join(this.gitDir, 'rebase-apply', 'applying');
+    return fs.existsSync(amPath);
+  }
+
+  rebaseInProgress() {
+    if (this.amInProgress()) {
+      return false;
+    }
+
+    const normalRebasePath = path.join(this.gitDir, 'rebase-apply');
+    const mergeRebasePath = path.join(this.gitDir, 'rebase-merge');
+    return fs.existsSync(normalRebasePath) || fs.existsSync(mergeRebasePath);
+  }
+
+  cherryPickInProgress() {
+    const cpPath = path.join(this.gitDir, 'CHERRY_PICK_HEAD');
+    return fs.existsSync(cpPath);
+  }
+
+  restore() {
+    const sess = this.session;
+    if (sess.prid) {
+      this.prid = sess.prid;
+      this.config = sess.config;
+    }
+    return this;
+  }
+
+  async tryAbortAm() {
+    const { cli } = this;
+    if (!this.amInProgress()) {
+      return cli.ok('No git am in progress');
+    }
+    const shouldAbortAm = await cli.prompt(
+      'Abort previous git am sessions?');
+    if (shouldAbortAm) {
+      await forceRunAsync('git', ['am', '--abort']);
+      cli.ok('Aborted previous git am sessions');
+    }
+  }
+
+  async tryAbortCherryPick() {
+    const { cli } = this;
+    if (!this.cherryPickInProgress()) {
+      return cli.ok('No git cherry-pick in progress');
+    }
+    const shouldAbortCherryPick = await cli.prompt(
+      'Abort previous git cherry-pick sessions?');
+    if (shouldAbortCherryPick) {
+      await forceRunAsync('git', ['cherry-pick', '--abort']);
+      cli.ok('Aborted previous git cherry-pick sessions');
+    }
+  }
+
+  async tryAbortRebase() {
+    const { cli } = this;
+    if (!this.rebaseInProgress()) {
+      return cli.ok('No git rebase in progress');
+    }
+    const shouldAbortRebase = await cli.prompt(
+      'Abort previous git rebase sessions?');
+    if (shouldAbortRebase) {
+      await forceRunAsync('git', ['rebase', '--abort']);
+      cli.ok('Aborted previous git rebase sessions');
+    }
+  }
+
+  async tryResetBranch() {
+    const { cli, upstream, branch } = this;
+    await this.tryAbortCherryPick();
+    await this.tryAbortAm();
+    await this.tryAbortRebase();
+
+    const branchName = `${upstream}/${branch}`;
+    const shouldResetHead = await cli.prompt(
+      `Do you want to try reset the local ${branch} branch to ${branchName}?`);
+    if (shouldResetHead) {
+      await this.tryResetHead();
+    }
+  }
+
+  getCurrentRev() {
+    return runSync('git', ['rev-parse', 'HEAD']).trim();
+  }
+
+  getCurrentBranch() {
+    return runSync('git', ['rev-parse', '--abbrev-ref', 'HEAD']).trim();
+  }
+
+  getUpstreamHead() {
+    const { upstream, branch } = this;
+    return runSync('git', ['rev-parse', `${upstream}/${branch}`]).trim();
+  }
+
+  getStrayCommits(verbose) {
+    const { upstream, branch } = this;
+    const ref = `${upstream}/${branch}...HEAD`;
+    const gitCmd = verbose
+      ? ['log', '--oneline', '--reverse', ref]
+      : ['rev-list', '--reverse', ref];
+    const revs = runSync('git', gitCmd).trim();
+    return revs ? revs.split('\n') : [];
+  }
+
+  async tryResetHead() {
+    const { cli, upstream, branch } = this;
+    const branchName = `${upstream}/${branch}`;
+    cli.startSpinner(`Bringing ${branchName} up to date...`);
+    await runAsync('git', ['fetch', upstream, branch]);
+    cli.stopSpinner(`${branchName} is now up-to-date`);
+    const stray = this.getStrayCommits(true);
+    if (!stray.length) {
+      return;
+    }
+    cli.log(`${branch} is out of sync with ${branchName}. ` +
+            'Mismatched commits:\n' +
+      ` - ${stray.join('\n - ')}`);
+    const shouldReset = await cli.prompt(`Reset to ${branchName}?`);
+    if (shouldReset) {
+      await runAsync('git', ['reset', '--hard', branchName]);
+      cli.ok(`Reset to ${branchName}`);
+    }
+  }
+
+  warnForMissing() {
+    const { upstream, branch, cli } = this;
+    const missing = !upstream || !branch;
+    if (!branch) {
+      cli.warn('You have not told git-node what branch you are trying' +
+               ' to land commits on.');
+      cli.separator();
+      cli.info(
+        'For example, if your want to land commits on the ' +
+        '`main` branch, you can run:\n\n' +
+        '  $ ncu-config set branch main');
+      cli.separator();
+      cli.setExitCode(1);
+    }
+    if (!upstream) {
+      cli.warn('You have not told git-node the remote you want to sync with.');
+      cli.separator();
+      cli.info(
+        'For example, if your remote pointing to nodejs/node is' +
+        ' `remote-upstream`, you can run:\n\n' +
+        '  $ ncu-config set upstream remote-upstream');
+      cli.separator();
+      cli.setExitCode(1);
+    }
+    return missing;
+  }
+
+  warnForWrongBranch() {
+    const { branch, cli } = this;
+    const rev = this.getCurrentBranch();
+    if (rev === 'HEAD') {
+      cli.warn(
+        'You are in detached HEAD state. Please run git-node on a valid ' +
+        'branch');
+      cli.setExitCode(1);
+      return true;
+    }
+    if (rev === branch) {
+      return false;
+    }
+    cli.warn(
+      `You are running git-node-land on \`${rev}\`,\n   but you have` +
+      ` configured \`${branch}\` to be the branch to land commits.`);
+    cli.separator();
+    cli.info(
+      `You can switch to \`${branch}\` with \`git checkout ${branch}\`, or\n` +
+      '   reconfigure the target branch with:\n\n' +
+      `  $ ncu-config set branch ${rev}`);
+    cli.separator();
+    cli.setExitCode(1);
+    return true;
+  // TODO warn if backporting onto master branch
+  }
+}

package/lib/sync_session.js

@@ -0,0 +1,15 @@
+import Session from './session.js';
+
+export default class SyncSession extends Session {
+  // eslint-disable-next-line no-useless-constructor
+  constructor(cli, dir) {
+    super(cli, dir);
+  }
+
+  async sync() {
+    if (this.warnForWrongBranch()) {
+      return;
+    }
+    return this.tryResetHead();
+  }
+}