stylelint-plugin-rhythmguard 3.11.0 → 3.13.0

package/src/audit/codemod.js

@@ -9,7 +9,7 @@ const { numbersEqual, parseLengthToken, toPx } = require('../core/length');
 const { negateReplacement } = require('../core/token-index');
 const { isTokenFunction, propertyMatches, walkRootValueNodes } = require('../core/value-nodes');
 const { formatPath } = require('./shared');
-const { isCssFile, isScssFile, walkFiles } = require('./scan/files');
+const { isCssFile, isPathInside, isScssFile, isTemplateFile, walkFiles } = require('./scan/files');
 const { resolveScssSyntax } = require('./scan/stylesheets');
 
 /**
@@ -22,10 +22,21 @@ const { resolveScssSyntax } = require('./scan/stylesheets');
 const TOKEN_FUNCTIONS = ['var', 'theme', 'token'];
 const ANY_TOKEN = /./;
 
-function replaceLength(root, { baseFontSize = 16, properties = null, px, replacement }) {
+/**
+ * Several replacements (`rhythmguard fix --decided`) run in one pass over the
+ * original values: each literal is matched against the list once, and a value
+ * one replacement writes is never matched again, so decisions 10px -> 14px and
+ * 14px -> 16px leave padding: 10px at 14px. The first matching entry wins.
+ */
+function normalizeReplacements({ px, replacement, replacements }) {
+  return Array.isArray(replacements) ? replacements : [{ px, replacement }];
+}
+
+function replaceLength(root, { baseFontSize = 16, properties = null, px, replacement, replacements }) {
   const patterns = properties && properties.length > 0
     ? properties.map((property) => property.toLowerCase())
     : PROPERTY_GROUP_PATTERNS.spacing;
+  const planned = normalizeReplacements({ px, replacement, replacements });
   const changes = [];
 
   root.walkDecls((decl) => {
@@ -48,14 +59,16 @@ function replaceLength(root, { baseFontSize = 16, properties = null, px, replace
         return false;
       }
       const nodePx = toPx(Math.abs(length.number), length.unit, baseFontSize);
-      if (nodePx === null || !numbersEqual(nodePx, px)) {
+      const match = nodePx === null ? null : planned.find((entry) => numbersEqual(nodePx, entry.px));
+      if (!match) {
         return false;
       }
-      const to = length.number < 0 ? negateReplacement(replacement) : replacement;
+      const to = length.number < 0 ? negateReplacement(match.replacement) : match.replacement;
+      const position = positionInDeclaration(decl, declarationValueOffset(decl) + node.sourceIndex);
       changes.push({
-        column: (decl.source && decl.source.start ? decl.source.start.column : 1) + declarationValueOffset(decl) + node.sourceIndex,
+        column: position.column,
         from: node.value,
-        line: decl.source && decl.source.start ? decl.source.start.line : 1,
+        line: position.line,
         property: decl.prop,
         to,
       });
@@ -77,6 +90,22 @@ function declarationValueOffset(decl) {
   return decl.prop.length + between.length;
 }
 
+/**
+ * The line and column of `index`, an offset into the declaration as written
+ * (property, separator, value), counted from where the declaration starts. A
+ * value that spans lines puts later literals on later lines (#288).
+ */
+function positionInDeclaration(decl, index) {
+  const start = decl.source && decl.source.start ? decl.source.start : { column: 1, line: 1 };
+  const raws = decl.raws || {};
+  const text = `${decl.prop}${typeof raws.between === 'string' ? raws.between : ': '}${decl.value}`.slice(0, index);
+  const lastBreak = text.lastIndexOf('\n');
+  const breaks = text.split('\n').length - 1;
+  return breaks === 0
+    ? { column: start.column + index, line: start.line }
+    : { column: index - lastBreak, line: start.line + breaks };
+}
+
 /**
  * Parse with the syntax that will write the file back. SCSS goes through
  * postcss-scss's own parse and stringify: `postcss.parse` ignores a `syntax`
@@ -97,18 +126,36 @@ function parseStylesheet(filePath, source) {
 }
 
 /**
- * Apply one replacement across a directory. Dry run unless `write`; returns
+ * Apply one replacement (`px` and `replacement`), or several in one pass
+ * (`replacements: [{ px, replacement }]`), across a directory. Dry run unless
+ * `write`; the dry run reports exactly what a write would write. Returns
  * the per-file changes and which files were skipped (unparseable, or SCSS
  * without postcss-scss). `ignorePatterns` are root-relative paths and globs,
  * as the audit takes them; the audit's generated and vendored directories
  * (node_modules, dist, build and the rest of SKIP_DIRS) are always skipped.
  */
-function runCodemod({ baseFontSize = 16, dir, ignorePatterns = [], properties = null, px, replacement, write = false }) {
+function runCodemod({ baseFontSize = 16, dir, ignorePatterns = [], properties = null, px, replacement, replacements, write = false }) {
   const rootDir = path.resolve(process.cwd(), dir);
-  const files = walkFiles(rootDir, ignorePatterns).cssFiles.filter(isCssFile).sort();
+  const walked = walkFiles(rootDir, ignorePatterns);
+  const files = walked.cssFiles.filter(isCssFile).sort();
   const results = [];
-  const skipped = [];
+  const skipped = walked.linksOutsideRoot
+    .filter((link) => !isTemplateFile(link))
+    .map((link) => ({ file: formatPath(path.join(rootDir, link)), reason: 'symbolic link to a path outside the directory; not followed' }));
+  const realRoot = fs.realpathSync(rootDir);
+  const rewritten = new Set();
   for (const filePath of files) {
+    // Never write through a symbolic link: a file is rewritten only at its own
+    // path inside the directory, and only once (#289).
+    const realPath = writableRealPath(filePath, rootDir, realRoot);
+    if (!realPath) {
+      skipped.push({ file: formatPath(filePath), reason: 'reached through a symbolic link; rewrite the file it points to instead' });
+      continue;
+    }
+    if (rewritten.has(realPath)) {
+      continue;
+    }
+    rewritten.add(realPath);
     const source = fs.readFileSync(filePath, 'utf8');
     let parsed;
     try {
@@ -122,7 +169,7 @@ function runCodemod({ baseFontSize = 16, dir, ignorePatterns = [], properties =
       continue;
     }
     const { root, syntax } = parsed;
-    const changes = replaceLength(root, { baseFontSize, properties, px, replacement });
+    const changes = replaceLength(root, { baseFontSize, properties, px, replacement, replacements });
     if (changes.length === 0) {
       continue;
     }
@@ -134,6 +181,24 @@ function runCodemod({ baseFontSize = 16, dir, ignorePatterns = [], properties =
   return { results, skipped };
 }
 
+/**
+ * The real path of `filePath` when it is the file's own path: no symbolic link
+ * between `rootDir` and the file, and the file inside `rootDir`. Null otherwise.
+ */
+function writableRealPath(filePath, rootDir, realRoot) {
+  let realPath;
+  try {
+    if (fs.lstatSync(filePath).isSymbolicLink()) {
+      return null;
+    }
+    realPath = fs.realpathSync(filePath);
+  } catch {
+    return null;
+  }
+  const expected = path.join(realRoot, path.relative(rootDir, filePath));
+  return realPath === expected && isPathInside(realRoot, realPath) ? realPath : null;
+}
+
 module.exports = {
   replaceLength,
   runCodemod,

package/src/audit/config.js

@@ -3,11 +3,10 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { normalizeDecisions } = require('../core/decisions');
+const { readJsonFile } = require('../core/json');
 const { SCALED_GROUPS, isGroupScalesMap } = require('../core/options');
-const {
-  normalizeTokenKind,
-  normalizeTokenSourceFormat,
-} = require('../core/token-sources');
+const { normalizeTokenKind } = require('../core/token-sources');
+const { normalizeTokenSourceEntry } = require('../core/token-source-entries');
 const {
   parseBaseFontSize,
   parseNonNegativeInteger,
@@ -45,7 +44,7 @@ function loadAuditConfig(parsed) {
 
   let config;
   try {
-    config = JSON.parse(fs.readFileSync(resolvedPath, 'utf8'));
+    config = readJsonFile(resolvedPath);
   } catch (err) {
     throw new Error(`Invalid Rhythmguard config ${parsed.configPath}: ${err.message}`, { cause: err });
   }
@@ -190,33 +189,14 @@ function normalizeConfigTokenSources(sources, baseDir) {
     throw new Error('Invalid Rhythmguard config: audit.tokenSources must be an array.');
   }
 
+  // The lint reads the same entries through the same normaliser, so both see the same files.
   return sources.map((source) => {
-    if (typeof source === 'string') {
-      return {
-        baseDir,
-        format: 'auto',
-        path: source,
-      };
-    }
-
-    if (!source || typeof source !== 'object' || Array.isArray(source)) {
-      throw new Error('Invalid Rhythmguard config: audit.tokenSources entries must be strings or objects.');
-    }
-
-    if (typeof source.path !== 'string' || source.path.trim().length === 0) {
-      throw new Error('Invalid Rhythmguard config: token source objects must include a path.');
-    }
-
-    if (source.tokenPattern !== undefined && (typeof source.tokenPattern !== 'string' || source.tokenPattern.trim().length === 0)) {
-      throw new Error('Invalid Rhythmguard config: token source tokenPattern must be a non-empty string.');
+    const { error, source: normalized } = normalizeTokenSourceEntry(source, baseDir);
+    if (error) {
+      // A bad format already reads "Invalid token source format ..."; structural problems name the config.
+      throw new Error(/^Invalid /.test(error) ? error : `Invalid Rhythmguard config: ${error}`);
     }
-
-    return {
-      baseDir,
-      format: normalizeTokenSourceFormat(source.format || 'auto'),
-      path: source.path,
-      ...(source.tokenPattern ? { tokenPattern: source.tokenPattern } : {}),
-    };
+    return normalized;
   });
 }
 

package/src/audit/contract.js

@@ -6,6 +6,7 @@ const {
   collectCssTokens,
   createTokenKindMatcher,
   getNormalizedValueKeys,
+  hasLineComments,
 } = require('../core/token-sources');
 const { formatPath } = require('./shared');
 
@@ -15,6 +16,7 @@ function collectTokenContract({
   cssFindings,
   externalTokenDefinitions,
   minCandidateCount,
+  readSource = (filePath) => fs.readFileSync(filePath, 'utf8'),
   tailwindFindings,
   tokenKind,
   tokenSourceReports,
@@ -28,7 +30,7 @@ function collectTokenContract({
   for (const filePath of cssFiles) {
     let source;
     try {
-      source = fs.readFileSync(filePath, 'utf8');
+      source = readSource(filePath);
     } catch {
       continue;
     }
@@ -97,7 +99,7 @@ function collectTokenContract({
 
 /** Custom properties and Sass tokens declared in one stylesheet, added to the definitions map. */
 function collectTokenDefinitions(source, file, definitions, matchesKind, baseFontSize) {
-  for (const { scope, token, value } of collectCssTokens(source, matchesKind)) {
+  for (const { scope, token, value } of collectCssTokens(source, matchesKind, { lineComments: hasLineComments(file) })) {
     addDefinition(definitions, { baseFontSize, file, scope, source: file, token, value });
   }
 }
@@ -230,7 +232,10 @@ function buildReport({
   dir,
   externalTokenDefinitions,
   includeMotion,
+  linksOutsideRoot = [],
   motionFindings,
+  parseErrorFindings = [],
+  readSource,
   scale,
   scanScope,
   scssFiles = 0,
@@ -267,18 +272,24 @@ function buildReport({
     ...tailwindFindings.map((finding) => finding.file),
   ])).slice(0, 10);
 
-  const totalFiles = cssFiles.length + templateFiles.length;
+  // A stylesheet skipped for want of postcss-scss, or excluded by the project's
+  // .stylelintignore, was not audited: it is neither scanned nor clean.
+  const cssFilesScanned = Math.max(0, cssFiles.length - scssSkipped - stylelintIgnored);
+  const totalFiles = cssFilesScanned + templateFiles.length;
   const totalWarnings = cssFindings.length + motionFindings.length + tailwindFindings.length;
   const filesWithIssues = issueFiles.size;
-  const scaleCleanliness = totalFiles > 0
-    ? Math.max(0, Math.round(((totalFiles - filesWithIssues) / totalFiles) * 100))
-    : 100;
+  const scaleCleanliness = Math.floor(computeScaleCleanliness({
+    filesWithIssues,
+    parseErrorFiles: countFiles(parseErrorFindings),
+    totalFiles,
+  }));
   const tokenContract = collectTokenContract({
     baseFontSize,
     cssFiles,
     cssFindings,
     externalTokenDefinitions,
     minCandidateCount: tokenCandidateMinCount,
+    readSource,
     tailwindFindings,
     tokenKind,
     tokenSourceReports,
@@ -286,12 +297,13 @@ function buildReport({
 
   return {
     config,
-    cssFilesScanned: cssFiles.length,
+    cssFilesScanned,
     directory: dir,
     filesWithIssues,
     findings: {
       css: cssFindings,
       motion: motionFindings,
+      parseErrors: parseErrorFindings,
       tailwind: tailwindFindings,
     },
     formatVersion: 5,
@@ -306,17 +318,20 @@ function buildReport({
     scaleCleanliness,
     scanScope,
     scanned: {
-      cssFiles: cssFiles.length,
+      cssFiles: cssFilesScanned,
       scssFiles,
       scssSkipped,
       stylelintIgnored,
       templateFiles: templateFiles.length,
       totalFiles,
+      // Symbolic links that resolve outside the scanned directory: not followed (#289).
+      ...(linksOutsideRoot.length > 0 ? { linksOutsideRoot: linksOutsideRoot.length } : {}),
     },
     summary: {
       cssWarnings: cssFindings.length,
       filesWithIssues,
       motionFindings: motionFindings.length,
+      parseErrors: parseErrorFindings.length,
       rawValueMatches: tokenContract.summary.rawValueMatches,
       missingTokens: tokenContract.summary.missingTokens,
       rawValueCandidates: tokenContract.summary.rawValueCandidates,
@@ -338,6 +353,36 @@ function buildReport({
   };
 }
 
+/**
+ * The share of audited files with no finding, unrounded. A file that failed to
+ * parse was not audited, so it is out of the denominator. The report shows the
+ * floor of this, so it never reads 100% while a file has a finding, and the
+ * --min-cleanliness gate compares this exact value.
+ */
+function computeScaleCleanliness({ filesWithIssues, parseErrorFiles = 0, totalFiles }) {
+  const auditedFiles = totalFiles - parseErrorFiles;
+  if (auditedFiles <= 0) {
+    return 100;
+  }
+  return Math.max(0, ((auditedFiles - filesWithIssues) * 100) / auditedFiles);
+}
+
+/** The unrounded cleanliness of a built report. */
+function exactScaleCleanliness(report) {
+  if (!Number.isFinite(report.totalFiles) || !Number.isFinite(report.filesWithIssues)) {
+    return report.scaleCleanliness;
+  }
+  return computeScaleCleanliness({
+    filesWithIssues: report.filesWithIssues,
+    parseErrorFiles: countFiles((report.findings && report.findings.parseErrors) || []),
+    totalFiles: report.totalFiles,
+  });
+}
+
+function countFiles(findings) {
+  return new Set(findings.map((finding) => finding.file)).size;
+}
+
 function countByValue(values) {
   const counts = {};
 
@@ -395,10 +440,52 @@ const AUDIT_JSON_SCHEMA = Object.freeze({
     baseline: { type: ['object', 'null'] },
     command: { type: 'object' },
     contracts: { type: 'object' },
-    findings: { type: 'object' },
+    findings: {
+      additionalProperties: true,
+      properties: {
+        css: { type: 'array' },
+        motion: { type: 'array' },
+        parseErrors: {
+          description: 'Stylesheets that could not be parsed and so were not audited. Not counted as findings or in cleanliness.',
+          items: {
+            additionalProperties: true,
+            properties: {
+              column: { type: 'integer' },
+              file: { type: 'string' },
+              line: { type: 'integer' },
+              rule: { const: 'CssSyntaxError' },
+              text: { type: 'string' },
+              type: { const: 'parse-error' },
+            },
+            required: ['file', 'text', 'type'],
+            type: 'object',
+          },
+          type: 'array',
+        },
+        tailwind: { type: 'array' },
+      },
+      type: 'object',
+    },
     scanned: { type: 'object' },
     schemaVersion: { const: '2.0' },
-    summary: { type: 'object' },
+    summary: {
+      additionalProperties: true,
+      properties: {
+        parseErrors: {
+          description: 'Number of stylesheets that could not be parsed.',
+          minimum: 0,
+          type: 'integer',
+        },
+        scaleCleanliness: {
+          description: 'Percentage of audited files with no finding, rounded down.',
+          maximum: 100,
+          minimum: 0,
+          type: 'integer',
+        },
+        totalFindings: { minimum: 0, type: 'integer' },
+      },
+      type: 'object',
+    },
   },
   required: ['schemaVersion', 'command', 'summary', 'scanned', 'contracts', 'findings'],
   title: 'Rhythmguard Audit Report',
@@ -414,8 +501,10 @@ module.exports = {
   collectTokenContract,
   collectTokenDefinitions,
   collectTokenUses,
+  computeScaleCleanliness,
   countByValue,
   createValueToTokensMap,
+  exactScaleCleanliness,
   mapTokenEntries,
   sortCountMap,
   sumCounts,

package/src/audit/decisions.js

@@ -1,7 +1,8 @@
 'use strict';
 
+const { propertyKindOf } = require('../core/css-vocabulary');
 const { decisionFor } = require('../core/decisions');
-const { formatLength, nearestScaleValues, parseLengthToken, toPx } = require('../core/length');
+const { formatLength, nearestScaleValues, normalizeScale, parseLengthToken, toPx } = require('../core/length');
 
 /**
  * Decisions applied to audit findings, and the plan that proposes them.
@@ -43,18 +44,43 @@ function applyDecisions({ baseFontSize, cssFindings, decisions, tailwindFindings
   return { cssFindings: nextCss, suppressed, summary: { ...summary, suppressed }, tailwindFindings: nextTailwind };
 }
 
+/**
+ * Which scale a finding was checked against, as use-scale picks it: the
+ * `audit.scales` entry for the property's group, else the project scale. The
+ * spacing group's entry is already the project scale (report.js). `key` names
+ * the group when it has a scale of its own; `scalePx` is null for a group set
+ * to "auto", whose scale the rule infers and the audit cannot see (#283).
+ */
+function createFindingScaleResolver({ baseFontSize, groupScales, scale }) {
+  const projectScale = { key: '', scalePx: Array.isArray(scale) ? normalizeScale(scale, baseFontSize) : [] };
+  const byGroup = new Map();
+  for (const [group, entry] of Object.entries(groupScales || {})) {
+    if (group === 'spacing' || !entry) continue;
+    byGroup.set(group, { key: group, scalePx: Array.isArray(entry.scale) ? normalizeScale(entry.scale, baseFontSize) : null });
+  }
+  return (finding) => {
+    if (finding.token || !finding.property) return projectScale;
+    return byGroup.get(propertyKindOf(finding.property)) || projectScale;
+  };
+}
+
 /**
  * One proposed entry per distinct off-scale px value: the most common spelling,
- * how often it occurs, the properties it sits on, the two nearest scale steps,
- * and the decision so far (`undecided` for anything nobody has looked at).
+ * how often it occurs, the properties it sits on, the two nearest steps of the
+ * scale it was checked against, and the decision so far (`undecided` for
+ * anything nobody has looked at). A value found in groups with different
+ * scales (`15px` as a font size and as a padding) gets one entry per scale.
  */
-function buildDecisionPlan({ baseFontSize, decisions, offScaleFindings, scale }) {
+function buildDecisionPlan({ baseFontSize, decisions, groupScales = {}, offScaleFindings, scale }) {
+  const scaleOf = createFindingScaleResolver({ baseFontSize, groupScales, scale });
+  const projectScale = scaleOf({});
   const groups = new Map();
   for (const finding of offScaleFindings) {
     const px = findingPx(finding, baseFontSize);
     if (px === null) continue;
-    const key = String(px);
-    const group = groups.get(key) || { count: 0, properties: new Map(), px, spellings: new Map() };
+    const checkedAgainst = scaleOf(finding);
+    const key = `${px}|${checkedAgainst.key}`;
+    const group = groups.get(key) || { count: 0, properties: new Map(), px, scale: checkedAgainst, spellings: new Map() };
     group.count += 1;
     const spelling = (finding.value || finding.rawValue).trim();
     group.spellings.set(spelling, (group.spellings.get(spelling) || 0) + 1);
@@ -64,35 +90,38 @@ function buildDecisionPlan({ baseFontSize, decisions, offScaleFindings, scale })
   }
 
   const mostCommon = (map) => [...map.entries()].sort((a, b) => b[1] - a[1]).map(([name]) => name);
-  const scalePx = Array.isArray(scale) ? scale.map(Number).filter(Number.isFinite) : [];
-  const nearestFor = (px) => {
-    const nearest = nearestScaleValues(px, scalePx);
+  const nearestFor = (px, scalePx) => {
+    const nearest = scalePx ? nearestScaleValues(px, scalePx) : null;
     return nearest ? [formatLength(nearest.lower, 'px'), formatLength(nearest.upper, 'px')] : [];
   };
+  const groupsForPx = (px) => [...groups.values()].filter((group) => group.px === px);
 
   const entries = [];
   const decided = new Set();
   for (const decision of decisions || []) {
-    const group = groups.get(String(decision.px));
-    decided.add(String(decision.px));
+    const found = groupsForPx(decision.px);
+    decided.add(decision.px);
+    // A decision covers the value on every property it names; its nearest steps
+    // come from the one scale its findings were checked against, if just one.
+    const scales = [...new Set(found.map((group) => group.scale))];
     entries.push({
       value: decision.value,
       decision: decision.decision,
       ...(decision.as ? { as: decision.as } : {}),
       ...(decision.reason ? { reason: decision.reason } : {}),
       ...(decision.properties ? { properties: decision.properties } : {}),
-      count: group ? group.count : 0,
-      nearest: nearestFor(decision.px),
+      count: found.reduce((sum, group) => sum + group.count, 0),
+      nearest: nearestFor(decision.px, (scales.length === 1 ? scales[0] : projectScale).scalePx),
     });
   }
-  for (const [key, group] of groups) {
-    if (decided.has(key)) continue;
+  for (const group of groups.values()) {
+    if (decided.has(group.px)) continue;
     entries.push({
       value: mostCommon(group.spellings)[0],
       decision: 'undecided',
       count: group.count,
       properties: mostCommon(group.properties).slice(0, 3),
-      nearest: nearestFor(group.px),
+      nearest: nearestFor(group.px, group.scale.scalePx),
     });
   }
   entries.sort((a, b) => b.count - a.count || String(a.value).localeCompare(String(b.value)));

package/src/audit/render-github.js

@@ -7,6 +7,10 @@ function renderGithub(report) {
   const lines = report.baseline
     ? [`::notice title=Rhythmguard audit::Since baseline: ${report.baseline.resolvedFindingsCount} resolved, ${report.baseline.newFindingsCount} new`]
     : [];
+  // A stylesheet that failed to parse was not audited: an error on its line.
+  lines.push(...((report.findings && report.findings.parseErrors) || []).map((finding) =>
+    `::error file=${escapeGithubProperty(finding.file)},line=${finding.line || 1},col=${finding.column || 1},title=${escapeGithubProperty(finding.rule || 'CssSyntaxError')}::${escapeGithubData(`Not audited: ${finding.text || ''}`)}`,
+  ));
   lines.push(...findings.map((finding) =>
     `::warning file=${escapeGithubProperty(finding.file)},line=${finding.line || 1},col=${finding.column || 1},title=${escapeGithubProperty(finding.rule || 'rhythmguard')}::${escapeGithubData(finding.text || '')}`,
   ));

package/src/audit/render-html.js

@@ -33,7 +33,9 @@ function renderHtml(report) {
     metricHtml('Scale cleanliness', `${report.scaleCleanliness}%`),
     metricHtml('CSS files', report.cssFilesScanned),
     metricHtml('Template files', report.templateFilesScanned),
+    ...(parseErrorRows(report).length > 0 ? [metricHtml('Parse errors (not audited)', parseErrorRows(report).length)] : []),
     '</section>',
+    renderHtmlTable('Parse Errors (not audited)', ['File', 'Error'], parseErrorRows(report)),
     renderHtmlTable('CSS Off-Scale Properties', ['Property', 'Count'], Object.entries(report.offScaleProperties || {})),
     renderHtmlTable('Top Affected Files', ['File', 'Findings'], report.topAffectedFiles.map(({ file, count }) => [file, count])),
     renderHtmlTable('Token Contract Sources', ['File', 'Format', 'Tokens'], report.tokenContract.sources.map((source) => [
@@ -52,6 +54,11 @@ function renderHtml(report) {
   return `${lines.join('\n')}\n`;
 }
 
+function parseErrorRows(report) {
+  return ((report.findings && report.findings.parseErrors) || [])
+    .map((finding) => [`${finding.file}:${finding.line}:${finding.column}`, finding.text]);
+}
+
 function metricHtml(label, value) {
   return `<div class="metric"><span>${escapeHtml(label)}</span><strong>${escapeHtml(value)}</strong></div>`;
 }