reslop 0.1.2 → 0.1.4

package/lib/git.js

@@ -1,18 +1,24 @@
 'use strict';
 
-const { spawnSync } = require('node:child_process');
+const { spawn, spawnSync } = require('node:child_process');
 const fs = require('node:fs');
 const path = require('node:path');
 
 const diff = require('./diff.js');
 const { parseDiff, synthesizeNewFile, itemsFromFiles } = diff;
 const { itemPath, isPathInScope, REVIEW_DIR } = require('./files.js');
+const { npmBin, spawnBase } = require('./sys.js');
 const deps = require('./deps.js');
 const { foldDepItems, mergeDepFile, depFileMeta } = deps;
 const { collectUsedNames, parseAuditReport, parseOutdatedReport } = deps;
 const { mergeProposedItems, MANIFEST, LOCKFILE } = deps;
 
-const GIT_CONFIG = ['-c', 'core.quotepath=false'];
+const GIT_CONFIG = [
+  '-c',
+  'core.quotepath=false',
+  '-c',
+  'i18n.logOutputEncoding=utf-8',
+];
 const DIFF_OPTS = ['--no-color', '--no-ext-diff', '--no-renames', '-U3'];
 const GIT_ENCODING = 'utf8';
 const GIT_MAX_BUFFER = 32 * 1024 * 1024;
@@ -46,17 +52,114 @@ const dropReviewItems = (items) => {
   return kept;
 };
 
+const abortError = () => {
+  const error = new Error('aborted');
+  error.code = 'ABORT';
+  return error;
+};
+
+const isAbort = (error) => !!(error && error.code === 'ABORT');
+
+const runProc = (cmd, args, options = {}) =>
+  new Promise((resolve) => {
+    const cwd = options.cwd;
+    const env = options.env;
+    const encoding = options.encoding ?? GIT_ENCODING;
+    const maxBuffer = options.maxBuffer ?? GIT_MAX_BUFFER;
+    const timeout = options.timeout;
+    const input = options.input;
+    const signal = options.signal;
+    if (signal && signal.aborted) {
+      resolve({ status: null, error: abortError(), stdout: '', stderr: '' });
+      return;
+    }
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    let timer = null;
+    const child = spawn(cmd, args, spawnBase({ cwd, env }));
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      resolve(result);
+    };
+    const onAbort = () => {
+      child.kill();
+      finish({ status: null, error: abortError(), stdout, stderr });
+    };
+    const append = (kind, chunk) => {
+      if (kind === 'out') stdout += chunk;
+      else stderr += chunk;
+      if (stdout.length + stderr.length <= maxBuffer) return;
+      child.kill();
+      const error = new Error('maxBuffer exceeded');
+      error.code = 'ENOBUFS';
+      finish({ status: null, error, stdout, stderr });
+    };
+    if (signal) signal.addEventListener('abort', onAbort);
+    if (child.stdout) {
+      child.stdout.setEncoding(encoding);
+      child.stdout.on('data', (chunk) => append('out', chunk));
+    }
+    if (child.stderr) {
+      child.stderr.setEncoding(encoding);
+      child.stderr.on('data', (chunk) => append('err', chunk));
+    }
+    if (timeout) {
+      timer = setTimeout(() => {
+        child.kill();
+        const error = new Error('timed out');
+        error.code = 'ETIMEDOUT';
+        finish({ status: null, error, stdout, stderr });
+      }, timeout);
+    }
+    child.on('error', (error) => {
+      finish({ status: null, error, stdout, stderr });
+    });
+    child.on('close', (status) => {
+      finish({ status, stdout, stderr });
+    });
+    if (child.stdin) {
+      try {
+        if (input) child.stdin.end(input);
+        else child.stdin.end();
+      } catch {
+        // closed
+      }
+    }
+  });
+
+const gitResult = (result) => {
+  if (!result.error) return result;
+  if (isAbort(result.error)) throw result.error;
+  if (result.error.code === 'ENOENT') throw new Error('git not found');
+  throw result.error;
+};
+
 const runGit = (args, cwd, input) => {
   const env = { ...process.env, GIT_OPTIONAL_LOCKS: '0' };
   const encoding = GIT_ENCODING;
   const maxBuffer = GIT_MAX_BUFFER;
-  const options = { cwd, encoding, input, maxBuffer, env };
+  const options = spawnBase({ cwd, encoding, input, maxBuffer, env });
   const result = spawnSync('git', args, options);
-  if (result.error) {
-    if (result.error.code === 'ENOENT') throw new Error('git not found');
-    throw result.error;
-  }
-  return result;
+  return gitResult(result);
+};
+
+const runGitAsync = (args, cwd, extra = {}) => {
+  const env = { ...process.env, GIT_OPTIONAL_LOCKS: '0' };
+  const encoding = GIT_ENCODING;
+  const maxBuffer = GIT_MAX_BUFFER;
+  const input = extra.input;
+  const signal = extra.signal;
+  return runProc('git', args, {
+    cwd,
+    env,
+    encoding,
+    maxBuffer,
+    input,
+    signal,
+  }).then(gitResult);
 };
 
 const toplevel = (cwd) => {
@@ -76,12 +179,16 @@ const isBinaryBuffer = (buf) => {
   return buf.includes(0);
 };
 
+const namesFromLs = (stdout) => {
+  if (!stdout) return [];
+  return stdout.split('\0').filter(Boolean);
+};
+
 const listUntracked = (top, paths) => {
   const args = ['ls-files', '-o', '--exclude-standard', '-z'];
   if (paths.length) args.push('--', ...paths);
   const result = requireOk(runGit(args, top));
-  if (!result.stdout) return [];
-  return result.stdout.split('\0').filter(Boolean);
+  return namesFromLs(result.stdout);
 };
 
 const binaryNewFile = (rel) => ({
@@ -94,9 +201,9 @@ const binaryNewFile = (rel) => ({
   hunks: [],
 });
 
-const untrackedItems = (top, paths) => {
+const untrackedItemsFrom = (top, names) => {
   const files = [];
-  for (const rel of listUntracked(top, paths)) {
+  for (const rel of names) {
     if (isReviewFile(rel)) continue;
     const full = path.join(top, rel);
     let buf;
@@ -174,11 +281,27 @@ const readDepSides = (top, rev, origin, rel) => {
 };
 
 const runNpmJson = (top, args, timeout) => {
-  const result = spawnSync('npm', args, {
+  const result = spawnSync(
+    npmBin(),
+    args,
+    spawnBase({
+      cwd: top,
+      encoding: GIT_ENCODING,
+      maxBuffer: GIT_MAX_BUFFER,
+      timeout,
+    }),
+  );
+  if (result.error) return '';
+  return result.stdout || '';
+};
+
+const runNpmJsonAsync = async (top, args, timeout, signal) => {
+  const result = await runProc(npmBin(), args, {
     cwd: top,
     encoding: GIT_ENCODING,
     maxBuffer: GIT_MAX_BUFFER,
     timeout,
+    signal,
   });
   if (result.error) return '';
   return result.stdout || '';
@@ -200,30 +323,55 @@ const collectOutdated = (top) => {
   return parseOutdatedReport(text);
 };
 
+const collectAuditAsync = async (top, extra, signal) => {
+  if (extra.auditMap !== undefined) return extra.auditMap;
+  const lock = path.join(top, LOCKFILE);
+  if (!fs.existsSync(lock)) return null;
+  const args = ['audit', '--json', '--package-lock-only'];
+  const text = await runNpmJsonAsync(top, args, AUDIT_MS, signal);
+  return parseAuditReport(text);
+};
+
+const collectOutdatedAsync = async (top, extra, signal) => {
+  if (extra.outdatedMap !== undefined) return extra.outdatedMap;
+  const manifest = path.join(top, MANIFEST);
+  if (!fs.existsSync(manifest)) return null;
+  const args = ['outdated', '--json', '--long'];
+  const text = await runNpmJsonAsync(top, args, AUDIT_MS, signal);
+  return parseOutdatedReport(text);
+};
+
 const pickNpmMap = (override, collect, top) => {
   if (override !== undefined) return override;
   return collect(top);
 };
 
+const hasDepFile = (items) => {
+  for (const item of items) {
+    if (depFileMeta(itemPath(item))) return true;
+  }
+  return false;
+};
+
 const foldLoaded = (items, top, rev, extra = {}) => {
   const readSides = (origin, rel) => readDepSides(top, rev, origin, rel);
-  let usedNames = null;
-  let audit = null;
-  let outdated = null;
   const live = extra.audit === true && !rev;
-  let hasDepDiff = false;
-  for (const item of items) {
-    if (!depFileMeta(itemPath(item))) continue;
-    hasDepDiff = true;
-    break;
-  }
-  if (hasDepDiff || live) usedNames = collectUsedNames(top);
-  if (live) {
+  const hasDepDiff = hasDepFile(items);
+  const collect = extra.collect !== false;
+  let usedNames = extra.usedNames ?? null;
+  let audit = extra.auditMap;
+  let outdated = extra.outdatedMap;
+  if (collect && usedNames === null && (hasDepDiff || live)) {
+    usedNames = collectUsedNames(top);
+  }
+  if (collect && live) {
     audit = pickNpmMap(extra.auditMap, collectAudit, top);
     outdated = pickNpmMap(extra.outdatedMap, collectOutdated, top);
-  } else if (extra.audit && hasDepDiff) {
+  } else if (collect && extra.audit && hasDepDiff) {
     audit = pickNpmMap(extra.auditMap, collectAudit, top);
   }
+  if (audit === undefined) audit = null;
+  if (outdated === undefined) outdated = null;
   const folded = foldDepItems(items, readSides, usedNames, audit, outdated, {
     root: top,
   });
@@ -305,12 +453,16 @@ const applyDepWorktree = (top, rel, change, origin) => {
 };
 
 const runNpm = (cwd, args) =>
-  spawnSync('npm', args, {
-    cwd,
-    encoding: GIT_ENCODING,
-    maxBuffer: GIT_MAX_BUFFER,
-    timeout: INSTALL_MS,
-  });
+  spawnSync(
+    npmBin(),
+    args,
+    spawnBase({
+      cwd,
+      encoding: GIT_ENCODING,
+      maxBuffer: GIT_MAX_BUFFER,
+      timeout: INSTALL_MS,
+    }),
+  );
 
 const firstDepRel = (files, kind) => {
   for (const rel of files) {
@@ -408,40 +560,73 @@ const shortRev = (top, commit) => {
   return result.stdout.trim();
 };
 
-const loadCommit = (top, commit, extra) => {
-  const parent = runGit(['rev-parse', '--verify', `${commit}^`], top);
-  let args;
+const commitDiffArgs = (commit, parent, pathArgs) => {
   if (parent.status === 0) {
     const from = parent.stdout.trim();
-    args = [...GIT_CONFIG, 'diff', ...DIFF_OPTS, from, commit, ...extra];
-  } else {
-    args = [
-      ...GIT_CONFIG,
-      'diff-tree',
-      '--no-commit-id',
-      '--root',
-      '-p',
-      ...DIFF_OPTS,
-      commit,
-      ...extra,
-    ];
+    return [...GIT_CONFIG, 'diff', ...DIFF_OPTS, from, commit, ...pathArgs];
   }
+  return [
+    ...GIT_CONFIG,
+    'diff-tree',
+    '--no-commit-id',
+    '--root',
+    '-p',
+    ...DIFF_OPTS,
+    commit,
+    ...pathArgs,
+  ];
+};
+
+const pathArgsOf = (paths) => (paths.length ? ['--', ...paths] : []);
+
+const snapshotWorktree = (top, stagedOut, unstagedOut, names) => {
+  const stagedDiff = parseDiff(stagedOut);
+  const unstagedDiff = parseDiff(unstagedOut);
+  const staged = itemsFromFiles(stagedDiff, 'staged');
+  const unstaged = itemsFromFiles(unstagedDiff, 'unstaged');
+  const untracked = untrackedItemsFrom(top, names);
+  const combined = mergeItems([staged, unstaged, untracked]);
+  const parsed = dropReviewItems(combined);
+  return { top, parsed };
+};
+
+const snapshotCommit = (top, commit, files) => {
+  const commitItems = itemsFromFiles(files, 'commit');
+  const parsed = dropReviewItems(commitItems);
+  const revShort = shortRev(top, commit);
+  return { top, parsed, rev: commit, revShort };
+};
+
+const loadCommit = (top, commit, extra) => {
+  const parent = runGit(['rev-parse', '--verify', `${commit}^`], top);
+  const args = commitDiffArgs(commit, parent, extra);
   const result = requireOk(runGit(args, top));
   return parseDiff(result.stdout);
 };
 
-const load = (cwd, paths = [], options = {}) => {
+const needsExtras = (parsed, rev, extra) => {
+  const live = extra.audit === true && !rev;
+  if (live) return true;
+  if (!extra.audit) return false;
+  return hasDepFile(parsed);
+};
+
+const finishLoad = (snapshot, extra) => {
+  const options = { ...extra, paths: extra.paths ?? [] };
+  if (extra.deferExtras) options.collect = false;
+  const parsed = snapshot.parsed;
+  const top = snapshot.top;
+  const rev = snapshot.rev;
+  const items = foldLoaded(parsed, top, rev, options);
+  const pending = extra.deferExtras && needsExtras(parsed, rev, extra);
+  return { ...snapshot, items, pending };
+};
+
+const readSnapshotSync = (cwd, paths, options) => {
   const top = toplevel(cwd);
-  const extra = paths.length ? ['--', ...paths] : [];
+  const extra = pathArgsOf(paths);
   const rev = options.commit;
-  if (rev) {
-    const files = loadCommit(top, rev, extra);
-    const commitItems = itemsFromFiles(files, 'commit');
-    const parsed = dropReviewItems(commitItems);
-    const items = foldLoaded(parsed, top, rev, { ...options, paths });
-    const revShort = shortRev(top, rev);
-    return { top, items, rev, revShort };
-  }
+  if (rev) return snapshotCommit(top, rev, loadCommit(top, rev, extra));
   const stagedArgs = [
     ...GIT_CONFIG,
     'diff',
@@ -452,15 +637,95 @@ const load = (cwd, paths = [], options = {}) => {
   const unstagedArgs = [...GIT_CONFIG, 'diff', ...DIFF_OPTS, ...extra];
   const stagedRes = requireOk(runGit(stagedArgs, top));
   const unstagedRes = requireOk(runGit(unstagedArgs, top));
-  const stagedDiff = parseDiff(stagedRes.stdout);
-  const unstagedDiff = parseDiff(unstagedRes.stdout);
-  const staged = itemsFromFiles(stagedDiff, 'staged');
-  const unstaged = itemsFromFiles(unstagedDiff, 'unstaged');
-  const untracked = untrackedItems(top, paths);
-  const combined = mergeItems([staged, unstaged, untracked]);
-  const merged = dropReviewItems(combined);
-  const items = foldLoaded(merged, top, undefined, { ...options, paths });
-  return { top, items };
+  const names = listUntracked(top, paths);
+  return snapshotWorktree(top, stagedRes.stdout, unstagedRes.stdout, names);
+};
+
+const loadCommitAsync = async (top, commit, extra, signal) => {
+  const parent = await runGitAsync(
+    ['rev-parse', '--verify', `${commit}^`],
+    top,
+    { signal },
+  );
+  const args = commitDiffArgs(commit, parent, extra);
+  const result = requireOk(await runGitAsync(args, top, { signal }));
+  return parseDiff(result.stdout);
+};
+
+const readSnapshotAsync = async (cwd, paths, options) => {
+  const top = toplevel(cwd);
+  const extra = pathArgsOf(paths);
+  const rev = options.commit;
+  const signal = options.signal;
+  if (rev) {
+    const files = await loadCommitAsync(top, rev, extra, signal);
+    return snapshotCommit(top, rev, files);
+  }
+  const stagedArgs = [
+    ...GIT_CONFIG,
+    'diff',
+    '--cached',
+    ...DIFF_OPTS,
+    ...extra,
+  ];
+  const unstagedArgs = [...GIT_CONFIG, 'diff', ...DIFF_OPTS, ...extra];
+  const lsArgs = ['ls-files', '-o', '--exclude-standard', '-z'];
+  if (paths.length) lsArgs.push('--', ...paths);
+  const stagedP = runGitAsync(stagedArgs, top, { signal });
+  const unstagedP = runGitAsync(unstagedArgs, top, { signal });
+  const lsP = runGitAsync(lsArgs, top, { signal });
+  const stagedRes = requireOk(await stagedP);
+  const unstagedRes = requireOk(await unstagedP);
+  const names = namesFromLs(requireOk(await lsP).stdout);
+  return snapshotWorktree(top, stagedRes.stdout, unstagedRes.stdout, names);
+};
+
+const load = (cwd, paths = [], options = {}) => {
+  const snapshot = readSnapshotSync(cwd, paths, options);
+  return finishLoad(snapshot, { ...options, paths });
+};
+
+const loadAsync = async (cwd, paths = [], options = {}) => {
+  const snapshot = await readSnapshotAsync(cwd, paths, options);
+  return finishLoad(snapshot, { ...options, paths, deferExtras: true });
+};
+
+const usedNamesPromise = (parsed, rev, extra, top) => {
+  const live = extra.audit === true && !rev;
+  if (!live && !hasDepFile(parsed)) return Promise.resolve(null);
+  return Promise.resolve().then(() => collectUsedNames(top));
+};
+
+const loadExtras = async (snapshot, extra = {}) => {
+  const top = snapshot.top;
+  const rev = snapshot.rev;
+  const parsed = snapshot.parsed;
+  const signal = extra.signal;
+  const live = extra.audit === true && !rev;
+  const hasDepDiff = hasDepFile(parsed);
+  const usedP = usedNamesPromise(parsed, rev, extra, top);
+  let auditP = Promise.resolve(null);
+  let outdatedP = Promise.resolve(null);
+  if (live) {
+    auditP = collectAuditAsync(top, extra, signal);
+    outdatedP = collectOutdatedAsync(top, extra, signal);
+  } else if (extra.audit && hasDepDiff) {
+    auditP = collectAuditAsync(top, extra, signal);
+  }
+  const extras = await Promise.all([usedP, auditP, outdatedP]);
+  const usedNames = extras[0];
+  const audit = extras[1];
+  const outdated = extras[2];
+  if (signal && signal.aborted) throw abortError();
+  const folded = foldLoaded(parsed, top, rev, {
+    ...extra,
+    paths: extra.paths ?? [],
+    usedNames,
+    auditMap: audit,
+    outdatedMap: outdated,
+    collect: false,
+  });
+  return { ...snapshot, items: folded, pending: false };
 };
 
 const addItem = (top, item) => {
@@ -594,6 +859,9 @@ const revertFile = (top, rel, items) => {
 
 const createGitRepo = () => ({
   load,
+  loadAsync,
+  loadExtras,
+  toplevel,
   resolveRev,
   add: addItem,
   unstage: unstageItem,
@@ -603,6 +871,8 @@ const createGitRepo = () => ({
 
 module.exports = {
   load,
+  loadAsync,
+  loadExtras,
   addItem,
   unstageItem,
   revertItem,