@node-core/utils 4.0.0

package/lib/update-v8/majorUpdate.js

@@ -0,0 +1,171 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+
+import Enquirer from 'enquirer';
+import { Listr } from 'listr2';
+
+import { getCurrentV8Version } from './common.js';
+import {
+  getNodeV8Version,
+  filterForVersion,
+  addToGitignore,
+  replaceGitignore,
+  removeDirectory,
+  isVersionString
+} from './util.js';
+import applyNodeChanges from './applyNodeChanges.js';
+import { chromiumGit, v8Deps } from './constants.js';
+import { runAsync } from '../run.js';
+
+export default function majorUpdate() {
+  return {
+    title: 'Major V8 update',
+    task: () => {
+      return new Listr([
+        getCurrentV8Version(),
+        checkoutBranch(),
+        removeDepsV8(),
+        cloneLocalV8(),
+        removeDepsV8Git(),
+        addDepsV8(),
+        updateV8Deps(),
+        applyNodeChanges()
+      ], {
+        injectWrapper: {
+          enquirer: new Enquirer()
+        }
+      });
+    }
+  };
+};
+
+function checkoutBranch() {
+  return {
+    title: 'Checkout V8 branch',
+    task: async(ctx) => {
+      let version = ctx.branch;
+      await ctx.execGitV8('checkout', 'origin/main');
+      if (!isVersionString(version)) {
+        // try to get the latest tag
+        const res = await ctx.execGitV8(
+          'tag',
+          '--contains',
+          `origin/${version}`,
+          '--sort',
+          'version:refname'
+        );
+        const tags = res.split('\n').filter(isVersionString);
+        const lastTag = tags[tags.length - 1];
+        if (lastTag) version = lastTag;
+        if (version.split('.').length === 3) {
+          // Prerelease versions are branched and 'lkgr' does not include
+          // the version commit
+          ctx.branch = version;
+        }
+      }
+      if (version === ctx.currentVersion.toString()) {
+        throw new Error(`Current version is already ${version}`);
+      }
+      ctx.newVersion = version.split('.').map((s) => parseInt(s, 10));
+      try {
+        await ctx.execGitV8('branch', '-D', ctx.branch);
+      } catch (e) {
+        // ignore
+      }
+      await ctx.execGitV8('branch', ctx.branch, `origin/${ctx.branch}`);
+    }
+  };
+}
+
+function removeDepsV8() {
+  return {
+    title: 'Remove deps/v8',
+    task: (ctx) => removeDirectory(path.join(ctx.nodeDir, 'deps/v8'))
+  };
+}
+
+function cloneLocalV8() {
+  return {
+    title: 'Clone branch to deps/v8',
+    task: (ctx) =>
+      runAsync('git', ['clone', '-b', ctx.branch, ctx.v8Dir, 'deps/v8'], {
+        spawnArgs: { cwd: ctx.nodeDir, stdio: 'ignore' }
+      })
+  };
+}
+
+function removeDepsV8Git() {
+  return {
+    title: 'Remove deps/v8/.git',
+    task: (ctx) => removeDirectory(path.join(ctx.nodeDir, 'deps/v8/.git'))
+  };
+}
+
+function addDepsV8() {
+  return {
+    title: 'Track all files in deps/v8',
+    // Add all V8 files with --force before updating DEPS. We have to do this
+    // because some files are checked in by V8 despite .gitignore rules.
+    task: (ctx) => runAsync('git', ['add', '--force', 'deps/v8'], {
+      spawnArgs: { cwd: ctx.nodeDir, stdio: 'ignore' }
+    })
+  };
+}
+
+function updateV8Deps() {
+  return {
+    title: 'Update V8 DEPS',
+    task: async(ctx) => {
+      const newV8Version = await getNodeV8Version(ctx.nodeDir);
+      const repoPrefix = newV8Version.majorMinor >= 86 ? '' : 'v8/';
+      const deps = filterForVersion(v8Deps.map((v8Dep) => ({
+        ...v8Dep,
+        repo: `${repoPrefix}${v8Dep.repo}`,
+        path: v8Dep.repo
+      })), newV8Version);
+      if (deps.length === 0) return;
+      /* eslint-disable no-await-in-loop */
+      for (const dep of deps) {
+        if (dep.gitignore) {
+          if (typeof dep.gitignore === 'string') {
+            await addToGitignore(ctx.nodeDir, dep.gitignore);
+          } else {
+            await replaceGitignore(ctx.nodeDir, dep.gitignore);
+          }
+        }
+        const [repo, commit] = await readDeps(ctx.nodeDir, dep.repo);
+        const thePath = path.join(ctx.nodeDir, 'deps/v8', dep.path);
+        await fetchFromGit(thePath, repo, commit);
+      }
+      /* eslint-enable */
+    }
+  };
+}
+
+async function readDeps(nodeDir, depName) {
+  const depsStr = await fs.readFile(path.join(nodeDir, 'deps/v8/DEPS'), 'utf8');
+  const start = depsStr.indexOf('deps = {');
+  const end = depsStr.indexOf('\n}', start) + 2;
+  const depsDeclaration = depsStr.substring(start, end).replace(/^ *#.*/gm, '');
+  const Var = () => chromiumGit; // eslint-disable-line no-unused-vars
+  let deps;
+  eval(depsDeclaration); // eslint-disable-line no-eval
+  const dep = deps[depName];
+  if (typeof dep === 'object') {
+    return dep.url.split('@');
+  }
+  return dep.split('@');
+}
+
+async function fetchFromGit(cwd, repo, commit) {
+  await fs.mkdir(cwd, { recursive: true });
+  await exec('init');
+  await exec('remote', 'add', 'origin', repo);
+  await exec('fetch', 'origin', commit);
+  await exec('reset', '--hard', 'FETCH_HEAD');
+  await removeDirectory(path.join(cwd, '.git'));
+
+  function exec(...options) {
+    return runAsync('git', options, { spawnArgs: { cwd, stdio: 'ignore' } });
+  }
+}

package/lib/update-v8/minorUpdate.js

@@ -0,0 +1,105 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+
+import Enquirer from 'enquirer';
+import { Listr } from 'listr2';
+
+import { getCurrentV8Version } from './common.js';
+import { isVersionString } from './util.js';
+import { runAsync } from '../run.js';
+
+export default function minorUpdate() {
+  return {
+    title: 'Minor V8 update',
+    task: () => {
+      return new Listr([
+        getCurrentV8Version(),
+        getLatestV8Version(),
+        doMinorUpdate()
+      ], {
+        injectWrapper: {
+          enquirer: new Enquirer()
+        }
+      });
+    }
+  };
+};
+
+function getLatestV8Version() {
+  return {
+    title: 'Get latest V8 version',
+    task: async(ctx) => {
+      const version = ctx.currentVersion;
+      const currentV8Tag = `${version.major}.${version.minor}.${version.build}`;
+      const result = await runAsync('git', ['tag', '-l', `${currentV8Tag}.*`], {
+        captureStdout: true,
+        spawnArgs: {
+          cwd: ctx.v8Dir,
+          stdio: ['ignore', 'pipe', 'ignore']
+        }
+      });
+      const tags = filterAndSortTags(result);
+      ctx.latestVersion = tags[0];
+    }
+  };
+}
+
+function doMinorUpdate() {
+  return {
+    title: 'Do minor update',
+    task: (ctx, task) => {
+      if (ctx.latestVersion.length === 3) {
+        throw new Error('minor update can only be done on release branches');
+      }
+      const latestStr = ctx.latestVersion.join('.');
+      task.title = `Do minor update to ${latestStr}`;
+      return applyPatch(ctx, latestStr);
+    },
+    skip: (ctx) => {
+      if (ctx.currentVersion.patch >= ctx.latestVersion[3]) {
+        ctx.skipped = 'V8 is up-to-date';
+        return ctx.skipped;
+      }
+      return false;
+    }
+  };
+}
+
+async function applyPatch(ctx, latestStr) {
+  const diff = spawn(
+    'git',
+    ['format-patch', '--stdout', `${ctx.currentVersion}...${latestStr}`],
+    { cwd: ctx.v8Dir, stdio: ['ignore', 'pipe', 'ignore'] }
+  );
+  try {
+    await runAsync('git', ['apply', '--directory', 'deps/v8'], {
+      spawnArgs: {
+        cwd: ctx.nodeDir,
+        stdio: [diff.stdout, 'ignore', 'ignore']
+      }
+    });
+  } catch (e) {
+    const file = path.join(ctx.nodeDir, `${latestStr}.diff`);
+    await fs.writeFile(file, diff);
+    throw new Error(`Could not apply patch.\n${e}\nDiff was stored in ${file}`);
+  }
+  if (diff.exitCode !== 0) {
+    const err = new Error(`git format-patch failed: ${diff.exitCode}`);
+    err.code = diff.exitCode;
+    err.messageOnly = true;
+    throw err;
+  }
+}
+
+function filterAndSortTags(tags) {
+  return tags
+    .split(/[\r\n]+/)
+    .filter(isVersionString)
+    .map((tag) => tag.split('.'))
+    .sort(sortVersions);
+}
+
+function sortVersions(v1, v2) {
+  return v2[3] - v1[3];
+}

package/lib/update-v8/updateMaintainingDependencies.js

@@ -0,0 +1,34 @@
+import { promises as fs } from 'node:fs';
+import { getNodeV8Version } from './util.js';
+
+export default function updateMaintainingDependencies() {
+  return {
+    title: 'Update V8 version in maintaining-dependencies.md',
+    task: async(ctx) => {
+      const path = `${ctx.nodeDir}/doc/contributing/maintaining/maintaining-dependencies.md`;
+      let maintainingDependenciesMd = await fs.readFile(path, 'utf8');
+      const v8Version = (await getNodeV8Version(ctx.nodeDir)).toString();
+      const v8VersionNoDots = v8Version.replaceAll('.', '');
+      // V8 itemlist link
+      maintainingDependenciesMd = maintainingDependenciesMd.replace(
+        /\* \[V8.*/,
+        `* [V8 ${v8Version}][]`
+      );
+      // V8 link to section
+      maintainingDependenciesMd = maintainingDependenciesMd.replace(
+        /\[v8.*\]: #v8.*/,
+        `[v8 ${v8Version}]: #v8-${v8VersionNoDots}`
+      );
+      // V8 section title
+      maintainingDependenciesMd = maintainingDependenciesMd.replace(
+        /### V8.*/,
+        `### V8 ${v8Version}`
+      );
+      await fs.writeFile(path, maintainingDependenciesMd);
+      await ctx.execGitNode(
+        'add',
+        ['doc/contributing/maintaining/maintaining-dependencies.md']
+      );
+    }
+  };
+};

package/lib/update-v8/updateV8Clone.js

@@ -0,0 +1,53 @@
+import { promises as fs } from 'node:fs';
+
+import Enquirer from 'enquirer';
+import { Listr } from 'listr2';
+
+import { v8Git } from './constants.js';
+import { runAsync } from '../run.js';
+
+export default function updateV8Clone() {
+  return {
+    title: 'Update local V8 clone',
+    task: () => {
+      return new Listr([fetchOrigin(), createClone()], {
+        injectWrapper: {
+          enquirer: new Enquirer()
+        }
+      });
+    }
+  };
+};
+
+function fetchOrigin() {
+  return {
+    title: 'Fetch V8',
+    task: async(ctx, task) => {
+      try {
+        await runAsync('git', ['fetch', 'origin'], {
+          spawnArgs: { cwd: ctx.v8Dir, stdio: 'ignore' }
+        });
+      } catch (e) {
+        if (e.code === 'ENOENT') {
+          ctx.shouldClone = true;
+          task.skip('V8 clone not present, create it.');
+        } else {
+          throw e;
+        }
+      }
+    }
+  };
+}
+
+function createClone() {
+  return {
+    title: 'Clone V8',
+    task: async(ctx) => {
+      await fs.mkdir(ctx.baseDir, { recursive: true });
+      await runAsync('git', ['clone', v8Git], {
+        spawnArgs: { cwd: ctx.baseDir, stdio: 'ignore' }
+      });
+    },
+    enabled: (ctx) => ctx.shouldClone
+  };
+}

package/lib/update-v8/updateVersionNumbers.js

@@ -0,0 +1,122 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+
+import Enquirer from 'enquirer';
+import { Listr } from 'listr2';
+
+import { getNodeV8Version } from './util.js';
+
+export default function updateVersionNumbers() {
+  return {
+    title: 'Update version numbers',
+    task: () => {
+      return new Listr([resetEmbedderString(), bumpNodeModule()], {
+        injectWrapper: {
+          enquirer: new Enquirer()
+        }
+      });
+    }
+  };
+};
+
+function bumpNodeModule() {
+  return {
+    title: 'Bump NODE_MODULE_VERSION',
+    task: async(ctx) => {
+      const v8Version = await getNodeV8Version(ctx.nodeDir);
+      const newModuleVersion = await updateModuleVersionRegistry(
+        ctx.nodeDir,
+        v8Version,
+        ctx.nodeMajorVersion
+      );
+      await updateModuleVersion(ctx.nodeDir, newModuleVersion);
+      await ctx.execGitNode(
+        'add',
+        ['doc/abi_version_registry.json', 'src/node_version.h']
+      );
+      await ctx.execGitNode(
+        'commit',
+        [
+          '-m',
+          getCommitTitle(newModuleVersion),
+          '-m',
+          getCommitBody(v8Version)
+        ]
+      );
+    },
+    skip: (ctx) => !ctx.versionBump
+  };
+}
+
+async function updateModuleVersionRegistry(
+  nodeDir,
+  v8Version,
+  nodeMajorVersion
+) {
+  const registryFile = `${nodeDir}/doc/abi_version_registry.json`;
+  const registryStr = await fs.readFile(registryFile, 'utf8');
+  const registry = JSON.parse(registryStr);
+  const newVersion = registry.NODE_MODULE_VERSION[0].modules + 1;
+  const newLine =
+    `{ "modules": ${newVersion}, "runtime": "node", ` +
+    `"variant": "v8_${v8Version.major}.${v8Version.minor}", ` +
+    `"versions": "${nodeMajorVersion}.0.0-pre" },\n    `;
+  const firstLineIndex = registryStr.indexOf('{ "modules"');
+  const newRegistry =
+    registryStr.substring(0, firstLineIndex) +
+    newLine +
+    registryStr.substring(firstLineIndex);
+  await fs.writeFile(registryFile, newRegistry);
+  return newVersion;
+}
+
+async function updateModuleVersion(nodeDir, newVersion) {
+  const path = `${nodeDir}/src/node_version.h`;
+  let nodeVersionH = await fs.readFile(path, 'utf8');
+  nodeVersionH = nodeVersionH.replace(
+    /NODE_MODULE_VERSION \d+/,
+    `NODE_MODULE_VERSION ${newVersion}`
+  );
+  await fs.writeFile(path, nodeVersionH);
+}
+
+function getCommitTitle(moduleVersion) {
+  return `src: update NODE_MODULE_VERSION to ${moduleVersion}`;
+}
+
+function getCommitBody(v8Version) {
+  return `Major V8 updates are usually API/ABI incompatible with previous
+versions. This commit adapts NODE_MODULE_VERSION for V8 ${v8Version.major}.${
+  v8Version.minor
+}.
+
+Refs: https://github.com/nodejs/CTC/blob/master/meetings/2016-09-28.md`;
+}
+
+const embedderRegex = /'v8_embedder_string': '-node\.(\d+)'/;
+const embedderString = "'v8_embedder_string': '-node.0'";
+function resetEmbedderString() {
+  return {
+    title: 'Reset V8 embedder version string',
+    task: async(ctx, task) => {
+      const commonGypiPath = path.join(ctx.nodeDir, 'common.gypi');
+      const commonGypi = await fs.readFile(commonGypiPath, 'utf8');
+      const embedderValue = embedderRegex.exec(commonGypi)[1];
+      if (embedderValue !== '0') {
+        await fs.writeFile(
+          commonGypiPath,
+          commonGypi.replace(embedderRegex, embedderString)
+        );
+        await ctx.execGitNode('add', ['common.gypi']);
+        await ctx.execGitNode(
+          'commit',
+          ['-m', 'build: reset embedder string to "-node.0"']
+        );
+      } else {
+        return task.skip('Embedder version is already 0');
+      }
+      return null;
+    },
+    skip: (ctx) => ctx.nodeMajorVersion < 9
+  };
+}

package/lib/update-v8/util.js

@@ -0,0 +1,62 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+export async function getNodeV8Version(cwd) {
+  try {
+    const v8VersionH = await fs.readFile(
+      `${cwd}/deps/v8/include/v8-version.h`,
+      'utf8'
+    );
+    const major = parseInt(/V8_MAJOR_VERSION (\d+)/.exec(v8VersionH)[1], 10);
+    const minor = parseInt(/V8_MINOR_VERSION (\d+)/.exec(v8VersionH)[1], 10);
+    const build = parseInt(/V8_BUILD_NUMBER (\d+)/.exec(v8VersionH)[1], 10);
+    const patch = parseInt(/V8_PATCH_LEVEL (\d+)/.exec(v8VersionH)[1], 10);
+    return {
+      major,
+      minor,
+      build,
+      patch,
+      majorMinor: major * 10 + minor,
+      toString() {
+        return this.patch
+          ? `${this.major}.${this.minor}.${this.build}.${this.patch}`
+          : `${this.major}.${this.minor}.${this.build}`;
+      }
+    };
+  } catch (e) {
+    throw new Error('Could not find V8 version');
+  }
+};
+
+export function filterForVersion(list, version) {
+  return list.filter((dep) => {
+    return dep.since <= version.majorMinor &&
+      (dep.until || Infinity) >= version.majorMinor;
+  });
+}
+
+export async function addToGitignore(nodeDir, value) {
+  const gitignorePath = path.join(nodeDir, 'deps/v8/.gitignore');
+  await fs.appendFile(gitignorePath, `${value}\n`);
+}
+
+export async function replaceGitignore(nodeDir, options) {
+  const gitignorePath = path.join(nodeDir, 'deps/v8/.gitignore');
+  let gitignore = await fs.readFile(gitignorePath, 'utf8');
+  gitignore = gitignore.replace(options.match, options.replace);
+  await fs.writeFile(gitignorePath, gitignore);
+}
+
+export function removeDirectory(path) {
+  if (typeof fs.rm !== 'undefined') {
+    return fs.rm(path, { recursive: true, force: true });
+  } else {
+    // Node.js 12 doesn't have `rm`, and `rmdir` emits a deprecation warning in
+    // Node.js 16+.
+    return fs.rmdir(path, { recursive: true });
+  }
+}
+
+export function isVersionString(str) {
+  return /^\d+(\.\d+)+$/.test(str);
+}

package/lib/user.js

@@ -0,0 +1,4 @@
+export function isTheSamePerson(actor, b) {
+  if (!actor || !actor.login) return false; // ghost
+  return actor.login.toLowerCase() === b.toLowerCase();
+}

package/lib/user_status.js

@@ -0,0 +1,5 @@
+export const FIRST_TIME_CONTRIBUTOR = 'FIRST_TIME_CONTRIBUTOR';
+export const NONE = 'NONE';
+export const OWNER = 'OWNER';  // TSC
+export const FIRST_TIMER = 'FIRST_TIMER';  // New to Github
+export const COLLABORATOR = 'COLLABORATOR';

package/lib/utils.js

@@ -0,0 +1,66 @@
+import which from 'which';
+
+import { forceRunAsync } from './run.js';
+
+export function ascending(a, b) {
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+};
+
+export function descending(a, b) {
+  if (a === b) return 0;
+  return a > b ? -1 : 1;
+};
+
+export function flatten(arr) {
+  let result = [];
+  for (const item of arr) {
+    if (Array.isArray(item)) {
+      result = result.concat(flatten(item));
+    } else {
+      result.push(item);
+    }
+  }
+  return result;
+}
+
+export function shortSha(sha) {
+  return sha.slice(0, 12);
+};
+
+let isGhAvailableCache;
+export function isGhAvailable() {
+  if (isGhAvailableCache === undefined) {
+    isGhAvailableCache = which.sync('gh', { nothrow: true }) !== null;
+  }
+  return isGhAvailableCache;
+};
+
+/**
+ * Returns the user's preferred text editor command.
+ * @param {object} [options]
+ * @param {boolean} [options.git] - Whether to try the GIT_EDITOR environment
+ * variable or `git config`.
+ * @returns {Promise<string|null>}
+ */
+export async function getEditor(options = {}) {
+  const {
+    git = false
+  } = options;
+
+  if (git) {
+    if (process.env.GIT_EDITOR) {
+      return process.env.GIT_EDITOR;
+    }
+    const out = await forceRunAsync(
+      'git',
+      ['config', 'core.editor'],
+      { captureStdout: 'lines' }
+    );
+    if (out && out[0]) {
+      return out[0];
+    }
+  }
+
+  return process.env.VISUAL || process.env.EDITOR || null;
+};

package/lib/verbosity.js

@@ -0,0 +1,26 @@
+import util from 'node:util';
+
+import chalk from 'chalk';
+
+const VERBOSITY = {
+  NONE: 0,
+  DEBUG: 2
+};
+
+export let verbosity = VERBOSITY.NONE;
+
+export function isDebugVerbosity() {
+  return verbosity === VERBOSITY.DEBUG;
+};
+
+export function setVerbosityFromEnv() {
+  const env = (process.env.NCU_VERBOSITY || '').toUpperCase();
+  if (Object.keys(VERBOSITY).includes(env)) {
+    verbosity = VERBOSITY[env];
+  }
+};
+
+export function debuglog(...args) {
+  // Prepend a line break in case it's logged while the spinner is running
+  console.error(chalk.green(util.format('\n[DEBUG]', ...args)));
+};