@node-core/utils 4.0.0

package/lib/team_info.js

@@ -0,0 +1,95 @@
+import { readFile, writeFile } from './file.js';
+import { ascending } from './utils.js';
+
+const TEAM_QUERY = 'Team';
+
+function byLogin(a, b) {
+  return ascending(a.login.toLowerCase(), b.login.toLowerCase());
+}
+
+function getContact({ login, url, name, email }) {
+  if (!name) return `* [@${login}](${url})`;
+  return `* [@${login}](${url}) - ${name}`;
+}
+
+function key(org, team) {
+  return `${org}/${team}`;
+}
+
+export default class TeamInfo {
+  constructor(cli, request, org, team) {
+    this.cli = cli;
+    this.request = request;
+    this.org = org;
+    this.team = team;
+    this.members = [];
+  }
+
+  async getMembers() {
+    const { cli, request, org, team } = this;
+    cli.startSpinner(`Getting member information of ${org}/${team}`);
+    const members = await request.gql(TEAM_QUERY, { org, team }, [
+      'organization', 'team', 'members'
+    ]);
+    cli.stopSpinner(`Received member information of ${org}/${team}`);
+    const sorted = members.sort(byLogin);
+    this.members = sorted;
+    return sorted;
+  }
+
+  async getMemberContacts() {
+    const members = await this.getMembers();
+    return members.map(getContact).join('\n');
+  }
+
+  async listMembers() {
+    const contacts = await this.getMemberContacts();
+    this.cli.log(contacts);
+  }
+}
+
+TeamInfo.syncFile = async function(cli, request, input, output) {
+  output = output || input;
+  const content = readFile(input);
+  if (content === '') {
+    cli.error('input file `' + input + '` is empty or missing');
+    process.exit(1);
+  }
+  const newContent = await TeamInfo.update(cli, request, content);
+  writeFile(output, newContent);
+  cli.log(`Updated ${output}`);
+};
+
+TeamInfo.update = async function(cli, request, content) {
+  const RE = new RegExp('<!-- ncu-team-sync\\.team\\((.+)\\/(.+)\\) -->' +
+                        '[\\s\\S]+?' +
+                        '<!-- ncu-team-sync end -->', 'mg');
+
+  const blocks = new Map();
+  let m;
+  // eslint-disable-next-line no-cond-assign
+  while ((m = RE.exec(content))) {
+    const [, org, team] = m;
+    const mapKey = key(org, team);
+    if (!blocks.get(mapKey)) {
+      const info = new TeamInfo(cli, request, org, team);
+      const teamData = await info.getMemberContacts();
+      const opening = `<!-- ncu-team-sync.team(${org}/${team}) -->`;
+      const ending = '<!-- ncu-team-sync end -->';
+      blocks.set(mapKey, `${opening}\n\n${teamData}\n\n${ending}`);
+    };
+  }
+
+  if (blocks.size === 0) {
+    throw new Error(
+      'Could not find blocks matching <!-- ncu-team-sync.team($org/$team)>'
+    );
+  }
+
+  const RE_CLONE = new RegExp(RE.source, 'mg');
+  const newContent = content.replace(RE_CLONE,
+    (match, org, team, offset, string) => blocks.get(key(org, team))
+  );
+
+  return newContent;
+};

package/lib/update-v8/applyNodeChanges.js

@@ -0,0 +1,49 @@
+import path from 'node:path';
+
+import Enquirer from 'enquirer';
+import { Listr } from 'listr2';
+
+import {
+  getNodeV8Version,
+  filterForVersion,
+  replaceGitignore,
+  removeDirectory
+} from './util.js';
+
+const nodeChanges = [
+  {
+    since: 66,
+    task: removeEuStrip
+  }
+];
+
+export default function applyNodeChanges() {
+  return {
+    title: 'Apply Node-specific changes',
+    task: async(ctx) => {
+      const v8Version = await getNodeV8Version(ctx.nodeDir);
+      const list = filterForVersion(nodeChanges, v8Version);
+      return new Listr(list.map((change) => change.task()), {
+        injectWrapper: {
+          enquirer: new Enquirer()
+        }
+      });
+    }
+  };
+}
+
+// Ref: https://github.com/nodejs/node/pull/20304
+function removeEuStrip() {
+  return {
+    title: 'Remove eu-strip binary',
+    task: async(ctx) => {
+      await replaceGitignore(ctx.nodeDir, {
+        match: '!/third_party/eu-strip\n',
+        replace: ''
+      });
+      await removeDirectory(
+        path.join(ctx.nodeDir, 'deps/v8/third_party/eu-strip')
+      );
+    }
+  };
+}

package/lib/update-v8/backport.js

@@ -0,0 +1,258 @@
+import path from 'node:path';
+import {
+  promises as fs
+} from 'node:fs';
+
+import Enquirer from 'enquirer';
+import inquirer from 'inquirer';
+import { Listr } from 'listr2';
+
+import { shortSha } from '../utils.js';
+
+import { getCurrentV8Version } from './common.js';
+
+export async function checkOptions(options) {
+  if (options.sha.length > 1 && options.squash) {
+    const { wantSquash } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'wantSquash',
+      message: 'Squashing commits should be avoided if possible, because it ' +
+        'can make git bisection difficult. Only squash commits if they would ' +
+        'break the build when applied individually. Are you sure?',
+      default: false
+    }]);
+
+    if (!wantSquash) {
+      return true;
+    }
+  }
+};
+
+export function doBackport(options) {
+  const todo = [
+    getCurrentV8Version(),
+    generatePatches()
+  ];
+
+  if (options.squash) {
+    todo.push(applyPatches());
+    if (options.bump !== false) {
+      if (options.nodeMajorVersion < 9) {
+        todo.push(incrementV8Version());
+      } else {
+        todo.push(incrementEmbedderVersion());
+      }
+    }
+    todo.push(commitSquashedBackport());
+  } else {
+    todo.push(applyAndCommitPatches());
+  }
+
+  return {
+    title: 'V8 commit backport',
+    task: () => {
+      return new Listr(todo, {
+        injectWrapper: {
+          enquirer: new Enquirer()
+        }
+      });
+    }
+  };
+};
+
+function commitSquashedBackport() {
+  return {
+    title: 'Commit backport',
+    task: async(ctx) => {
+      const { patches } = ctx;
+      const messageTitle = formatMessageTitle(patches);
+      let messageBody;
+      if (patches.length === 1) {
+        const [patch] = patches;
+        messageBody = formatMessageBody(patch, false);
+      } else {
+        messageBody = '';
+        for (const patch of patches) {
+          const formatted = formatMessageBody(patch, true);
+          messageBody += formatted + '\n\n';
+        }
+      }
+      await ctx.execGitNode('add', ['deps/v8']);
+      await ctx.execGitNode('commit', ['-m', messageTitle, '-m', messageBody]);
+    }
+  };
+};
+
+function commitPatch(patch) {
+  return {
+    title: 'Commit patch',
+    task: async(ctx) => {
+      const messageTitle = formatMessageTitle([patch]);
+      const messageBody = formatMessageBody(patch, false);
+      await ctx.execGitNode('add', ['deps/v8']);
+      await ctx.execGitNode('commit', ['-m', messageTitle, '-m', messageBody]);
+    }
+  };
+}
+
+function formatMessageTitle(patches) {
+  const action =
+    patches.some(patch => patch.hadConflicts) ? 'backport' : 'cherry-pick';
+  if (patches.length === 1) {
+    return `deps: V8: ${action} ${shortSha(patches[0].sha)}`;
+  } else if (patches.length === 2) {
+    return `deps: V8: ${action} ${shortSha(patches[0].sha)} and ${
+      shortSha(patches[1].sha)
+    }`;
+  } else if (patches.length === 3) {
+    return `deps: V8: ${action} ${shortSha(patches[0].sha)}, ${
+      shortSha(patches[1].sha)
+    } and ${shortSha(patches[2].sha)}`;
+  } else {
+    return `deps: V8: ${action} ${patches.length} commits`;
+  }
+}
+
+function formatMessageBody(patch, prefixTitle) {
+  const indentedMessage = patch.message.replace(/\n/g, '\n    ');
+  const body =
+    'Original commit message:\n\n' +
+    `    ${indentedMessage}\n\n` +
+    `Refs: https://github.com/v8/v8/commit/${patch.sha}`;
+
+  if (prefixTitle) {
+    const action = patch.hadConflicts ? 'Backport' : 'Cherry-pick';
+    return `${action} ${shortSha(patch.sha)}.\n` + body;
+  }
+  return body;
+}
+
+function generatePatches() {
+  return {
+    title: 'Generate patches',
+    task: async(ctx) => {
+      const shas = ctx.sha;
+      const fullShas = await Promise.all(
+        shas.map(async(sha) => {
+          const stdout = await ctx.execGitV8('rev-parse', sha);
+          return stdout.trim();
+        })
+      );
+      ctx.patches = await Promise.all(fullShas.map(async(sha) => {
+        const [patch, message] = await Promise.all([
+          ctx.execGitV8('format-patch', '--stdout', `${sha}^..${sha}`),
+          ctx.execGitV8('log', '--format=%B', '-n', '1', sha)
+        ]);
+        return {
+          sha,
+          data: patch,
+          message
+        };
+      }));
+    }
+  };
+}
+
+function applyPatches() {
+  return {
+    title: 'Apply patches to deps/v8',
+    task: async(ctx, task) => {
+      const { patches } = ctx;
+      for (const patch of patches) {
+        await applyPatch(ctx, task, patch);
+      }
+    }
+  };
+}
+
+function applyAndCommitPatches() {
+  return {
+    title: 'Apply and commit patches to deps/v8',
+    task: (ctx) => {
+      return new Listr(ctx.patches.map(applyPatchTask), {
+        injectWrapper: {
+          enquirer: new Enquirer()
+        }
+      });
+    }
+  };
+}
+
+function applyPatchTask(patch) {
+  return {
+    title: `Commit ${shortSha(patch.sha)}`,
+    task: (ctx) => {
+      const todo = [
+        {
+          title: 'Apply patch',
+          task: (ctx, task) => applyPatch(ctx, task, patch)
+        }
+      ];
+      if (ctx.bump !== false) {
+        if (ctx.nodeMajorVersion < 9) {
+          todo.push(incrementV8Version());
+        } else {
+          todo.push(incrementEmbedderVersion());
+        }
+      }
+      todo.push(commitPatch(patch));
+      return new Listr(todo, {
+        injectWrapper: {
+          enquirer: new Enquirer()
+        }
+      });
+    }
+  };
+}
+
+async function applyPatch(ctx, task, patch) {
+  try {
+    await ctx.execGitNode(
+      'apply',
+      ['-p1', '--3way', '--directory=deps/v8'],
+      patch.data /* input */
+    );
+  } catch (e) {
+    patch.hadConflicts = true;
+    return task.prompt({
+      type: 'input',
+      message: "Resolve merge conflicts and enter 'RESOLVED'",
+      validate: value => value.toUpperCase() === 'RESOLVED'
+    });
+  }
+}
+
+function incrementV8Version() {
+  return {
+    title: 'Increment V8 version',
+    task: async(ctx) => {
+      const incremented = ++ctx.currentVersion.patch;
+      const versionHPath = `${ctx.nodeDir}/deps/v8/include/v8-version.h`;
+      let versionH = await fs.readFile(versionHPath, 'utf8');
+      versionH = versionH.replace(
+        /V8_PATCH_LEVEL (\d+)/,
+        `V8_PATCH_LEVEL ${incremented}`
+      );
+      await fs.writeFile(versionHPath, versionH);
+    }
+  };
+}
+
+const embedderRegex = /'v8_embedder_string': '-node\.(\d+)'/;
+function incrementEmbedderVersion() {
+  return {
+    title: 'Increment embedder version number',
+    task: async(ctx) => {
+      const commonGypiPath = path.join(ctx.nodeDir, 'common.gypi');
+      const commonGypi = await fs.readFile(commonGypiPath, 'utf8');
+      const embedderValue = parseInt(embedderRegex.exec(commonGypi)[1], 10);
+      const embedderString = `'v8_embedder_string': '-node.${embedderValue +
+        1}'`;
+      await fs.writeFile(
+        commonGypiPath,
+        commonGypi.replace(embedderRegex, embedderString)
+      );
+      await ctx.execGitNode('add', ['common.gypi']);
+    }
+  };
+}

package/lib/update-v8/commitUpdate.js

@@ -0,0 +1,26 @@
+import { getNodeV8Version } from './util.js';
+
+export default function commitUpdate() {
+  return {
+    title: 'Commit V8 update',
+    task: async(ctx) => {
+      const newV8Version = await getNodeV8Version(ctx.nodeDir);
+      await ctx.execGitNode('add', ['deps/v8']);
+      const moreArgs = [];
+      let message;
+      if (ctx.minor) {
+        const prev = ctx.currentVersion.toString();
+        const next = ctx.latestVersion.join('.');
+        moreArgs.push(
+          '-m',
+          `Refs: https://github.com/v8/v8/compare/${prev}...${next}`
+        );
+        message = `deps: patch V8 to ${newV8Version}`;
+      } else {
+        message = `deps: update V8 to ${newV8Version}`;
+      }
+      await ctx.execGitNode('commit', ['-m', message, ...moreArgs]);
+    },
+    skip: (ctx) => ctx.skipped
+  };
+};

package/lib/update-v8/common.js

@@ -0,0 +1,35 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+
+import { getNodeV8Version } from './util.js';
+
+export function getCurrentV8Version() {
+  return {
+    title: 'Get current V8 version',
+    task: async(ctx) => {
+      ctx.currentVersion = await getNodeV8Version(ctx.nodeDir);
+    }
+  };
+};
+
+export async function checkCwd(ctx) {
+  let isNode = false;
+  try {
+    const nodeVersion = await fs.readFile(
+      path.join(ctx.nodeDir, 'src/node_version.h')
+    );
+    const match = /#define NODE_MAJOR_VERSION (\d+)/.exec(nodeVersion);
+    if (match) {
+      isNode = true;
+      ctx.nodeMajorVersion = parseInt(match[1], 10);
+    }
+  } catch (e) {
+    // ignore
+  }
+  if (!isNode) {
+    throw new Error(
+      'This does not seem to be the Node.js repository.\n' +
+      `node-dir: ${ctx.nodeDir}`
+    );
+  }
+};

package/lib/update-v8/constants.js

@@ -0,0 +1,86 @@
+import os from 'node:os';
+import path from 'node:path';
+
+const homedir = os.homedir();
+
+export const chromiumGit = 'https://chromium.googlesource.com';
+
+export const defaultBaseDir = path.join(homedir, '.update-v8');
+
+export const v8Git = `${chromiumGit}/v8/v8.git`;
+
+const gtestReplace = `/testing/gtest/*
+!/testing/gtest/include
+/testing/gtest/include/*
+!/testing/gtest/include/gtest
+/testing/gtest/include/gtest/*
+!/testing/gtest/include/gtest/gtest_prod.h`;
+
+const googleTestReplace = `/third_party/googletest/src/*
+!/third_party/googletest/src/googletest
+/third_party/googletest/src/googletest/*
+!/third_party/googletest/src/googletest/include
+/third_party/googletest/src/googletest/include/*
+!/third_party/googletest/src/googletest/include/gtest
+/third_party/googletest/src/googletest/include/gtest/*
+!/third_party/googletest/src/googletest/include/gtest/gtest_prod.h`;
+
+const zlibIgnore = `!/third_party/zlib
+/third_party/zlib/contrib/bench
+/third_party/zlib/contrib/tests
+/third_party/zlib/google/test`;
+
+export const v8Deps = [
+  {
+    name: 'trace_event',
+    repo: 'base/trace_event/common',
+    gitignore: {
+      match: '/base\n',
+      replace: ''
+    },
+    since: 55
+  },
+  {
+    name: 'gtest',
+    repo: 'testing/gtest',
+    gitignore: {
+      match: '/testing/gtest',
+      replace: gtestReplace
+    },
+    since: 55,
+    until: 66
+  },
+  {
+    name: 'jinja2',
+    repo: 'third_party/jinja2',
+    gitignore: '!/third_party/jinja2',
+    since: 56
+  },
+  {
+    name: 'markupsafe',
+    repo: 'third_party/markupsafe',
+    gitignore: '!/third_party/markupsafe',
+    since: 56
+  },
+  {
+    name: 'googletest',
+    repo: 'third_party/googletest/src',
+    gitignore: {
+      match: '/third_party/googletest/src',
+      replace: googleTestReplace
+    },
+    since: 67
+  },
+  {
+    name: 'zlib',
+    repo: 'third_party/zlib',
+    gitignore: zlibIgnore,
+    since: 80
+  },
+  {
+    name: 'ittapi',
+    repo: 'third_party/ittapi',
+    gitignore: '!/third_party/ittapi',
+    since: 81
+  }
+];

package/lib/update-v8/index.js

@@ -0,0 +1,56 @@
+import Enquirer from 'enquirer';
+import { Listr } from 'listr2';
+
+import { checkOptions, doBackport } from './backport.js';
+import updateVersionNumbers from './updateVersionNumbers.js';
+import commitUpdate from './commitUpdate.js';
+import majorUpdate from './majorUpdate.js';
+import minorUpdate from './minorUpdate.js';
+import updateMaintainingDependencies from './updateMaintainingDependencies.js';
+import updateV8Clone from './updateV8Clone.js';
+
+export function major(options) {
+  const tasks = new Listr(
+    [
+      updateV8Clone(),
+      majorUpdate(),
+      updateMaintainingDependencies(),
+      commitUpdate(),
+      updateVersionNumbers()
+    ],
+    getOptions(options)
+  );
+  return tasks.run(options);
+};
+
+export function minor(options) {
+  const tasks = new Listr(
+    [updateV8Clone(), minorUpdate(), commitUpdate()],
+    getOptions(options)
+  );
+  return tasks.run(options);
+};
+
+export async function backport(options) {
+  const shouldStop = await checkOptions(options);
+  if (shouldStop) return;
+  const tasks = new Listr(
+    [updateV8Clone(), doBackport(options)],
+    getOptions(options)
+  );
+  return tasks.run(options);
+};
+
+/**
+ * Get the listr2 options.
+ * @param {{ verbose?: boolean }} options The original options.
+ * @return {import('listr2').ListrOptions} The listr2 options.
+ */
+function getOptions(opts) {
+  return {
+    renderer: opts.verbose ? 'verbose' : 'default',
+    injectWrapper: {
+      enquirer: new Enquirer()
+    }
+  };
+}