reslop 0.2.1 → 0.2.4

package/lib/report-render.js

@@ -0,0 +1,104 @@
+'use strict';
+
+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 SUMMARY_ROWS = 6;
+const PROBLEM_FIELDS = 7;
+
+const writeRow = (rows, index, key, value) => {
+  if (value === null || value === undefined || value === '') return index;
+  rows[index] = [key, `${value}`];
+  return index + 1;
+};
+
+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 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]);
+  }
+  if (item.count > 1) index = writeRow(rows, index, 'count', item.count);
+  if (item.omitted > 0) {
+    index = writeRow(rows, index, 'omitted', item.omitted);
+  }
+  rows.length = index;
+  return rows;
+};
+
+const markdownValue = (value) => {
+  const text = `${value}`;
+  if (!text.includes('\n')) return text;
+  return `\n${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])}`);
+  }
+  for (const trace of item.traces) {
+    if (!trace) continue;
+    lines.push(`- trace:\n${trace}`);
+  }
+  return lines;
+};
+
+const markdownReport = (item) => {
+  const lines = ['', `# ${item.tool}`, '', `ok: ${item.ok}`];
+  for (const row of summaryRows(item.summary)) {
+    lines.push(`${row[0]}: ${row[1]}`);
+  }
+  for (const problem of item.problems) {
+    lines.push(...markdownProblem(problem));
+  }
+  return lines;
+};
+
+const renderMarkdown = (doc) => {
+  const lines = [NOTICE, '', `exit: ${doc.exit}`];
+  for (const item of doc.reports) lines.push(...markdownReport(item));
+  if (doc.stderr) lines.push('', '# stderr', '', doc.stderr);
+  return `${lines.join('\n').replace(/\n+$/, '')}\n`;
+};
+
+const renderDocument = (doc) => renderMarkdown(doc);
+
+module.exports = {
+  NOTICE,
+  renderMarkdown,
+  renderDocument,
+};

package/lib/report-run.js

@@ -0,0 +1,166 @@
+'use strict';
+
+const path = require('node:path');
+const childProcess = require('node:child_process');
+const { spawn } = childProcess;
+
+const utilities = require('./utilities.js');
+const { spawnBase } = utilities;
+const npmCommands = require('./npm-commands.js');
+const { writeLog } = npmCommands;
+const reportParse = require('./report-parse.js');
+const { toolHint, buildDocument } = reportParse;
+const reportRender = require('./report-render.js');
+const { renderDocument } = reportRender;
+
+const OUTPUTS = new Set(['md', 'raw']);
+
+const outputMode = (env) => {
+  const value = env.RESLOP_OUTPUT;
+  if (value) return OUTPUTS.has(value) ? value : '';
+  return 'md';
+};
+
+const CMD_SAFE = /^[\w./:=@+-]+$/;
+
+const quoteCmdArg = (arg) => {
+  const text = `${arg}`;
+  if (text && CMD_SAFE.test(text)) return text;
+  const escaped = text.replaceAll('"', '""').replaceAll('%', '"%"');
+  return `"${escaped}"`;
+};
+
+const winCommand = (program, args) => {
+  const parts = [program, ...args].map(quoteCmdArg);
+  return `"${parts.join(' ')}"`;
+};
+
+const spawnCommand = (program, args, options) => {
+  const { cwd, env, stdio } = options;
+  const base = { cwd, env, stdio };
+  if (process.platform !== 'win32') {
+    return spawn(program, args, spawnBase(base));
+  }
+  const command = winCommand(program, args);
+  const shell = process.env.comspec || 'cmd.exe';
+  return spawn(
+    shell,
+    ['/d', '/s', '/c', command],
+    spawnBase({ ...base, windowsVerbatimArguments: true }),
+  );
+};
+
+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) =>
+  new Promise((resolve) => {
+    let out = '';
+    let err = '';
+    let settled = false;
+    const finish = (status) => {
+      if (settled) return;
+      settled = true;
+      resolve({ status, stdout: out, stderr: err });
+    };
+    if (child.stdout) {
+      child.stdout.setEncoding('utf8');
+      child.stdout.on('data', (chunk) => {
+        out += chunk;
+      });
+    }
+    if (child.stderr) {
+      child.stderr.setEncoding('utf8');
+      child.stderr.on('data', (chunk) => {
+        err += chunk;
+      });
+    }
+    child.on('error', (error) => {
+      err += `${error.message}\n`;
+      finish(1);
+    });
+    child.on('close', (status) => finish(status === null ? 1 : status));
+  });
+
+const commandArgs = (argv) => {
+  if (argv[0] !== 't' || argv[1] !== '--' || !argv[2]) return null;
+  return { program: argv[2], args: argv.slice(3) };
+};
+
+const usage = (stderr) => {
+  stderr.write('reslop: missing command\n');
+  stderr.write('Usage: reslop t -- <program> [args]\n');
+  return 1;
+};
+
+const runInherit = async (spawnFn, program, args, options) => {
+  let child;
+  try {
+    child = spawnFn(program, args, { ...options, stdio: 'inherit' });
+  } 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`);
+    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' };
+  let child;
+  try {
+    child = spawnFn(command.program, command.args, {
+      cwd,
+      env: childEnv,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+  } catch (error) {
+    proc.stderr.write(`reslop: ${error.message}\n`);
+    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);
+  proc.stdout.write(text);
+  try {
+    writeLog(cwd, path.basename(command.program), text);
+  } catch (error) {
+    proc.stderr.write(`reslop: ${error.message}\n`);
+  }
+  return result.status;
+};
+
+module.exports = {
+  outputMode,
+  winCommand,
+  runCapture,
+};