reslop 0.2.5 → 0.2.6

package/lib/report-run.js

@@ -7,20 +7,16 @@ const { spawn } = childProcess;
 const utilities = require('./utilities.js');
 const { spawnBase } = utilities;
 const npmCommands = require('./npm-commands.js');
-const { writeLog } = npmCommands;
+const { nextLogFile, saveLogs } = npmCommands;
 const reportParse = require('./report-parse.js');
 const { toolHint, buildDocument } = reportParse;
 const reportRender = require('./report-render.js');
 const { renderDocument } = reportRender;
+const runs = require('./runs.js');
+const { RunRecorder, commandLabel, summarizeDocument } = runs;
 
-const OUTPUTS = new Set(['md', 'raw']);
-
-const outputMode = (env) => {
-  const value = env.RESLOP_OUTPUT;
-  if (value) return OUTPUTS.has(value) ? value : '';
-  return 'md';
-};
-
+const OUTPUTS = ['md', 'raw'];
+const PIPE = ['ignore', 'pipe', 'pipe'];
 const CMD_SAFE = /^[\w./:=@+-]+$/;
 
 const quoteCmdArg = (arg) => {
@@ -35,34 +31,18 @@ const winCommand = (program, args) => {
   return `"${parts.join(' ')}"`;
 };
 
-const spawnCommand = (program, args, options) => {
-  const { cwd, env, stdio } = options;
-  const base = { cwd, env, stdio };
+const spawnCommand = (command, options) => {
+  const { program, args } = command;
   if (process.platform !== 'win32') {
-    return spawn(program, args, spawnBase(base));
+    return spawn(program, args, spawnBase(options));
   }
-  const command = winCommand(program, args);
   const shell = process.env.comspec || 'cmd.exe';
-  return spawn(
-    shell,
-    ['/d', '/s', '/c', command],
-    spawnBase({ ...base, windowsVerbatimArguments: true }),
-  );
+  const line = winCommand(program, args);
+  const opts = spawnBase({ ...options, windowsVerbatimArguments: true });
+  return spawn(shell, ['/d', '/s', '/c', line], opts);
 };
 
-const waitStatus = (child) =>
-  new Promise((resolve) => {
-    let settled = false;
-    const finish = (status) => {
-      if (settled) return;
-      settled = true;
-      resolve(status);
-    };
-    child.on('error', () => finish(1));
-    child.on('close', (status) => finish(status === null ? 1 : status));
-  });
-
-const collect = (child) =>
+const collect = (child, onOut, onErr) =>
   new Promise((resolve) => {
     let out = '';
     let err = '';
@@ -76,89 +56,119 @@ const collect = (child) =>
       child.stdout.setEncoding('utf8');
       child.stdout.on('data', (chunk) => {
         out += chunk;
+        if (onOut) onOut(chunk);
       });
     }
     if (child.stderr) {
       child.stderr.setEncoding('utf8');
       child.stderr.on('data', (chunk) => {
         err += chunk;
+        if (onErr) onErr(chunk);
       });
     }
     child.on('error', (error) => {
       err += `${error.message}\n`;
       finish(1);
     });
-    child.on('close', (status) => finish(status === null ? 1 : status));
+    child.on('close', (status) => finish(status ?? 1));
   });
 
-const commandArgs = (argv) => {
-  if (argv[0] !== 't' || argv[1] !== '--' || !argv[2]) return null;
-  return { program: argv[2], args: argv.slice(3) };
+const beginRun = (cwd, command) =>
+  new RunRecorder(cwd, commandLabel(command.program, command.args));
+
+const documentOf = (command, result, cwd) => {
+  const hint = toolHint(command.program, command.args);
+  const { stdout, stderr, status } = result;
+  return buildDocument(stdout, stderr, cwd, status, hint);
 };
 
-const usage = (stderr) => {
-  stderr.write('reslop: missing command\n');
-  stderr.write('Usage: reslop t -- <program> [args]\n');
-  return 1;
+const rawStreams = (stdout, stderr) => {
+  if (!stderr.trim()) return stdout;
+  const lead = stdout.endsWith('\n') || !stdout ? stdout : `${stdout}\n`;
+  return `${lead}# stderr\n${stderr}`;
 };
 
-const runInherit = async (spawnFn, program, args, options) => {
-  let child;
+const runInherit = async (command, cwd, env) => {
   try {
-    child = spawnFn(program, args, { ...options, stdio: 'inherit' });
+    const child = spawnCommand(command, { cwd, env, stdio: 'inherit' });
+    return (await collect(child)).status;
   } catch {
     return 1;
   }
-  return waitStatus(child);
 };
 
-const runCapture = async (proc, deps = {}) => {
-  const env = proc.env || {};
-  const argv = proc.argv.slice(2);
-  const command = commandArgs(argv);
-  if (!command) return usage(proc.stderr);
-  const mode = outputMode(env);
-  if (!mode) {
-    proc.stderr.write(`reslop: unknown RESLOP_OUTPUT ${env.RESLOP_OUTPUT}\n`);
+const runRaw = async (proc, command, cwd, env) => {
+  const recorder = beginRun(cwd, command);
+  let child;
+  try {
+    child = spawnCommand(command, { cwd, env, stdio: PIPE });
+  } catch {
+    recorder.finish(1);
     return 1;
   }
-  const cwd = deps.cwd ? deps.cwd : proc.cwd();
-  const spawnFn = deps.spawn || spawnCommand;
-  const capture = env.RESLOP_CAPTURE === '1';
-  if (mode === 'raw' || capture) {
-    return runInherit(spawnFn, command.program, command.args, { cwd, env });
-  }
-  const childEnv = { ...env, RESLOP_CAPTURE: '1' };
+  const onOut = (chunk) => {
+    proc.stdout.write(chunk);
+    recorder.feed(chunk);
+  };
+  const onErr = (chunk) => proc.stderr.write(chunk);
+  const result = await collect(child, onOut, onErr);
+  const doc = documentOf(command, result, cwd);
+  recorder.finish(result.status, summarizeDocument(doc));
+  return result.status;
+};
+
+const runReport = async (proc, command, cwd, env) => {
+  const recorder = beginRun(cwd, command);
+  const fail = (error) => proc.stderr.write(`reslop: ${error.message}\n`);
   let child;
   try {
-    child = spawnFn(command.program, command.args, {
-      cwd,
-      env: childEnv,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
+    const childEnv = { ...env, RESLOP_CAPTURE: '1' };
+    child = spawnCommand(command, { cwd, env: childEnv, stdio: PIPE });
   } catch (error) {
-    proc.stderr.write(`reslop: ${error.message}\n`);
+    fail(error);
+    recorder.finish(1);
     return 1;
   }
-  const result = await collect(child);
-  const hint = toolHint(command.program, command.args);
-  const doc = buildDocument(
-    result.stdout,
-    result.stderr,
-    cwd,
-    result.status,
-    hint,
-  );
-  const text = renderDocument(doc);
+  const result = await collect(child, (chunk) => recorder.feed(chunk));
+  const doc = documentOf(command, result, cwd);
+  let slot = null;
+  try {
+    slot = nextLogFile(cwd, path.basename(command.program));
+  } catch (error) {
+    fail(error);
+  }
+  const text = renderDocument(doc, slot ? slot.rawName : '');
+  recorder.finish(result.status, summarizeDocument(doc));
   proc.stdout.write(text);
+  if (!slot) return result.status;
   try {
-    writeLog(cwd, path.basename(command.program), text);
+    await saveLogs(slot, text, rawStreams(result.stdout, result.stderr));
   } catch (error) {
-    proc.stderr.write(`reslop: ${error.message}\n`);
+    fail(error);
   }
   return result.status;
 };
 
+const runCapture = async (proc, deps = {}) => {
+  const argv = proc.argv.slice(2);
+  if (argv[1] !== '--' || !argv[2]) {
+    proc.stderr.write('reslop: missing command\n');
+    proc.stderr.write('Usage: reslop t -- <program> [args]\n');
+    return 1;
+  }
+  const command = { program: argv[2], args: argv.slice(3) };
+  const env = proc.env ?? {};
+  const mode = env.RESLOP_OUTPUT || 'md';
+  if (!OUTPUTS.includes(mode)) {
+    proc.stderr.write(`reslop: unknown RESLOP_OUTPUT ${env.RESLOP_OUTPUT}\n`);
+    return 1;
+  }
+  const cwd = deps.cwd ?? proc.cwd();
+  if (env.RESLOP_CAPTURE === '1') return runInherit(command, cwd, env);
+  if (mode === 'raw') return runRaw(proc, command, cwd, env);
+  return runReport(proc, command, cwd, env);
+};
+
 module.exports = {
   winCommand,
   runCapture,