reslop 0.2.4 → 0.2.6

package/lib/report-render.js

@@ -1,78 +1,111 @@
 'use strict';
 
+const utilities = require('./utilities.js');
+const { unquote } = utilities;
+
 const NOTICE_HEAD =
   'reslop: reduced output; passing results are omitted ' +
   'and similar problems are grouped';
 
-const NOTICE = [
-  NOTICE_HEAD,
-  'If reduced output hides information needed for debugging,',
-  'rerun the same command with RESLOP_OUTPUT=raw.',
-].join('\n');
+const notice = (rawFile) => {
+  const target = rawFile
+    ? `the raw log \`.log/${rawFile}\``
+    : 'the matching raw log under `.log/`';
+  const hint = `Agent: if this report hides a needed detail, read ${target}.`;
+  return `${NOTICE_HEAD}\n${hint}`;
+};
 
-const SUMMARY_ROWS = 6;
-const PROBLEM_FIELDS = 7;
+const addRow = (rows, key, value) => {
+  if (value === null || value === undefined || value === '') return;
+  rows.push([key, `${value}`]);
+};
 
-const writeRow = (rows, index, key, value) => {
-  if (value === null || value === undefined || value === '') return index;
-  rows[index] = [key, `${value}`];
-  return index + 1;
+const isComparison = (line) => {
+  const match = /^(.*) (?:!==|===|!=|==) (\S.*)$/.exec(line.trim());
+  return !!match && match[1].trim() !== '';
 };
 
-const summaryRows = (stats) => {
-  const rows = new Array(SUMMARY_ROWS);
-  let index = 0;
-  index = writeRow(rows, index, 'passed', stats.passed);
-  index = writeRow(rows, index, 'failed', stats.failed);
-  index = writeRow(rows, index, 'skipped', stats.skipped);
-  index = writeRow(rows, index, 'errors', stats.errors);
-  index = writeRow(rows, index, 'warnings', stats.warnings);
-  index = writeRow(rows, index, 'duration', stats.duration);
-  rows.length = index;
-  return rows;
+const isDiffHeader = (line) => {
+  const text = line.trim().replace(/^[+-]\s*/, '');
+  return /^actual\s+[+-]?\s*expected$/.test(text);
 };
 
-const problemRows = (item) => {
-  const extra = item.extra;
-  let size = PROBLEM_FIELDS + extra.length;
-  if (item.count > 1) size += 1;
-  if (item.omitted > 0) size += 1;
-  const rows = new Array(size);
-  let index = 0;
-  index = writeRow(rows, index, 'severity', item.severity);
-  index = writeRow(rows, index, 'duration', item.duration);
-  index = writeRow(rows, index, 'code', item.code);
-  index = writeRow(rows, index, 'operator', item.operator);
-  index = writeRow(rows, index, 'expected', item.expected);
-  index = writeRow(rows, index, 'actual', item.actual);
-  index = writeRow(rows, index, 'message', item.message);
-  for (let i = 0; i < extra.length; i++) {
-    const pair = extra[i];
-    index = writeRow(rows, index, pair[0], pair[1]);
+const isMarkedDiff = (line) => /^[+-](?:\s|$)/.test(line.trim());
+
+const sameValue = (line, value) => {
+  if (!value) return false;
+  const text = line.trim();
+  return text === value || unquote(text) === value;
+};
+
+const startsDiff = (line, item) =>
+  isComparison(line) ||
+  isDiffHeader(line) ||
+  isMarkedDiff(line) ||
+  sameValue(line, item.expected) ||
+  sameValue(line, item.actual);
+
+const displayMessage = (item) => {
+  const values = item.expected !== '' || item.actual !== '';
+  const lines = [];
+  for (const line of `${item.message}`.split('\n')) {
+    if (line.trim() === '') continue;
+    if (values && startsDiff(line, item)) break;
+    lines.push(line);
   }
-  if (item.count > 1) index = writeRow(rows, index, 'count', item.count);
-  if (item.omitted > 0) {
-    index = writeRow(rows, index, 'omitted', item.omitted);
+  if (lines.length && lines[0].trimEnd().endsWith(':')) {
+    lines[0] = lines[0].trimEnd().slice(0, -1);
   }
-  rows.length = index;
+  if (lines.length && lines[0].trim() === '') lines.shift();
+  return lines.join('\n');
+};
+
+const summaryRows = (stats) => {
+  const rows = [];
+  addRow(rows, 'passed', stats.passed);
+  addRow(rows, 'failed', stats.failed);
+  addRow(rows, 'skipped', stats.skipped);
+  addRow(rows, 'errors', stats.errors);
+  addRow(rows, 'warnings', stats.warnings);
+  addRow(rows, 'duration', stats.duration);
   return rows;
 };
 
-const markdownValue = (value) => {
-  const text = `${value}`;
-  if (!text.includes('\n')) return text;
-  return `\n${text}`;
+const problemRows = (item) => {
+  const rows = [];
+  if (item.severity !== 'error') addRow(rows, 'severity', item.severity);
+  addRow(rows, 'duration', item.duration);
+  addRow(rows, 'code', item.code);
+  addRow(rows, 'operator', item.operator);
+  addRow(rows, 'expected', item.expected);
+  addRow(rows, 'actual', item.actual);
+  for (const pair of item.extra) addRow(rows, pair[0], pair[1]);
+  if (item.count > 1) addRow(rows, 'count', item.count);
+  if (item.omitted > 0) addRow(rows, 'omitted', item.omitted);
+  return rows;
 };
 
+const prefixLines = (prefix, text) =>
+  `${text}`
+    .replace(/\n+$/, '')
+    .split('\n')
+    .map((line) => `${prefix}${line}`);
+
+const quoteLines = (text) => prefixLines('│ ', text);
+
 const markdownProblem = (item) => {
   const title = item.name || item.message || item.code || 'problem';
   const lines = ['', `## ${title}`, ''];
   for (const row of problemRows(item)) {
-    lines.push(`- ${row[0]}: ${markdownValue(row[1])}`);
+    const value = row[1].includes('\n') ? `\n${row[1]}` : row[1];
+    lines.push(`- ${row[0]}: ${value}`);
   }
-  for (const trace of item.traces) {
-    if (!trace) continue;
-    lines.push(`- trace:\n${trace}`);
+  const message = displayMessage(item);
+  if (message) lines.push('', ...prefixLines('> ', message), '');
+  if (item.trace) lines.push(`- trace:\n${item.trace}`);
+  if (item.related.length) {
+    lines.push('- related:');
+    for (const row of item.related) lines.push(`  - ${row}`);
   }
   return lines;
 };
@@ -82,23 +115,33 @@ const markdownReport = (item) => {
   for (const row of summaryRows(item.summary)) {
     lines.push(`${row[0]}: ${row[1]}`);
   }
-  for (const problem of item.problems) {
-    lines.push(...markdownProblem(problem));
-  }
+  for (const entry of item.problems) lines.push(...markdownProblem(entry));
   return lines;
 };
 
-const renderMarkdown = (doc) => {
-  const lines = [NOTICE, '', `exit: ${doc.exit}`];
+const renderDocument = (doc, rawFile) => {
+  const lines = [notice(rawFile)];
   for (const item of doc.reports) lines.push(...markdownReport(item));
   if (doc.stderr) lines.push('', '# stderr', '', doc.stderr);
+  lines.push('', `exit: ${doc.exit}`);
   return `${lines.join('\n').replace(/\n+$/, '')}\n`;
 };
 
-const renderDocument = (doc) => renderMarkdown(doc);
+const loggedText = (text, rawFile) => {
+  const body = `${text ?? ''}`;
+  if (body.startsWith(NOTICE_HEAD)) return body;
+  const head = notice(rawFile);
+  if (!body.trim()) return `${head}\n`;
+  return `${head}\n\n${body}`;
+};
 
 module.exports = {
-  NOTICE,
-  renderMarkdown,
+  NOTICE_HEAD,
+  notice,
+  summaryRows,
+  problemRows,
+  displayMessage,
+  quoteLines,
+  loggedText,
   renderDocument,
 };

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,91 +56,120 @@ 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 = {
-  outputMode,
   winCommand,
   runCapture,
 };