stylelint-plugin-rhythmguard 3.2.0 → 3.4.0

package/src/audit/contract.js

@@ -3,10 +3,10 @@
 const fs = require('node:fs');
 const {
   addDefinition,
-  collectScssTokens,
+  collectCssTokens,
   createTokenKindMatcher,
   getNormalizedValueKeys,
-} = require('../utils/token-sources');
+} = require('../core/token-sources');
 const { formatPath } = require('./shared');
 
 function collectTokenContract({
@@ -95,33 +95,10 @@ function collectTokenContract({
   };
 }
 
+/** Custom properties and Sass tokens declared in one stylesheet, added to the definitions map. */
 function collectTokenDefinitions(source, file, definitions, matchesKind, baseFontSize) {
-  const declarationPattern = /(--[\w-]+)\s*:\s*([^;{}]+)/g;
-  let match;
-
-  while ((match = declarationPattern.exec(source)) !== null) {
-    const token = match[1];
-    if (!matchesKind(token)) {
-      continue;
-    }
-
-    addDefinition(definitions, {
-      baseFontSize,
-      file,
-      source: file,
-      token,
-      value: match[2].trim(),
-    });
-  }
-
-  for (const sassToken of collectScssTokens(source, matchesKind)) {
-    addDefinition(definitions, {
-      baseFontSize,
-      file,
-      source: file,
-      token: sassToken.token,
-      value: sassToken.value,
-    });
+  for (const { scope, token, value } of collectCssTokens(source, matchesKind)) {
+    addDefinition(definitions, { baseFontSize, file, scope, source: file, token, value });
   }
 }
 
@@ -394,6 +371,7 @@ function toAuditContractReport(report) {
         files: report.scale ? report.scale.files : [],
         offScaleProperties: report.offScaleProperties || {},
         offScaleValues: report.offScaleValues,
+        rejected: report.scale && report.scale.rejected ? report.scale.rejected : null,
         source: report.scale ? report.scale.source : 'default',
         tokenOpportunities: report.tokenOpportunities,
         values: report.scale ? report.scale.values : null,

package/src/audit/index.js

@@ -1,12 +1,9 @@
 'use strict';
 
-const {
-  AUDIT_JSON_SCHEMA,
-  createAuditReport,
-  loadAuditConfig,
-  toAuditContractReport,
-} = require('../cli/audit');
-const { parseTokenSources } = require('../utils/token-sources');
+const { loadAuditConfig } = require('./config');
+const { AUDIT_JSON_SCHEMA, toAuditContractReport } = require('./contract');
+const { createAuditReport } = require('./report');
+const { parseTokenSources } = require('../core/token-sources');
 
 module.exports = {
   AUDIT_JSON_SCHEMA,

package/src/audit/render-markdown.js

@@ -4,6 +4,9 @@ const { sortCountMap } = require('./contract');
 const { escapeMarkdown } = require('./render-utils');
 
 function describeScaleSource(scale) {
+  if (scale.rejected) {
+    return `${scale.source} (${scale.rejected.source} rejected: ${scale.rejected.reasons.join(', ')})`;
+  }
   return scale.files.length > 0
     ? `${scale.source} (${scale.files.join(', ')})`
     : scale.source;

package/src/audit/render-text.js

@@ -28,7 +28,8 @@ function renderText(report) {
   if (report.scale) {
     lines.push(`  Scale                    ${report.scale.values.join(', ')}`);
     const files = report.scale.files.length > 0 ? ` (${report.scale.files.join(', ')})` : '';
-    lines.push(`  Scale source             ${report.scale.source}${files}`);
+    const rejected = report.scale.rejected ? ` (${report.scale.rejected.source} rejected: ${report.scale.rejected.reasons.join(', ')})` : '';
+    lines.push(`  Scale source             ${report.scale.source}${files}${rejected}`);
   }
   lines.push('');
 

package/src/audit/report.js

@@ -5,7 +5,7 @@ const fs = require('node:fs');
 const {
   createTokenKindMatcher,
   parseTokenSources,
-} = require('../utils/token-sources');
+} = require('../core/token-sources');
 const {
   applyBaselineComparison,
   writeBaseline,
@@ -18,15 +18,15 @@ const {
 } = require('./config');
 const { buildReport, collectTokenDefinitions } = require('./contract');
 const { DEFAULT_SCALE, formatPath } = require('./shared');
-const { discoverTokenPackages, scaleFromDefinitions } = require('../utils/scale-inference');
 const {
-  assertDirectory,
-  collectCssFindings,
-  collectTailwindFindings,
-  collectTailwindMotionFindings,
-  getScanFiles,
-  runStylelintAudit,
-} = require('./scan');
+  assessScale,
+  discoverTokenPackages,
+  inferScaleFromDefinitions,
+  scaleFromDefinitions,
+} = require('../core/scale-inference');
+const { assertDirectory, getScanFiles } = require('./scan/files');
+const { collectCssFindings, runStylelintAudit } = require('./scan/stylesheets');
+const { collectTailwindFindings, collectTailwindMotionFindings } = require('./scan/templates');
 
 async function createAuditReport(options) {
   const parsed = normalizeCreateAuditOptions(options);
@@ -129,6 +129,7 @@ function resolveAuditScale({ baseFontSize, cssFiles, requested, tokenSourceResul
     }
   }
 
+  let rejected = null;
   const definitions = new Map();
   const matchesKind = createTokenKindMatcher('spacing');
   for (const filePath of cssFiles) {
@@ -147,20 +148,26 @@ function resolveAuditScale({ baseFontSize, cssFiles, requested, tokenSourceResul
   }
 
   if (definitions.size > 0) {
-    const values = scaleFromDefinitions(definitions, baseFontSize);
-    if (values) {
+    const inferred = inferScaleFromDefinitions(definitions, baseFontSize);
+    if (inferred) {
+      const { values } = inferred;
       const files = new Set();
-      for (const definition of definitions.values()) {
+      for (const definition of inferred.definitions.values()) {
         for (const file of definition.files) {
           files.add(file);
         }
       }
-      return {
-        files: Array.from(files).sort(),
-        source: 'scanned-css',
-        tokenCount: definitions.size,
-        values,
-      };
+      const sortedFiles = Array.from(files).sort();
+      const assessment = assessScale({ files: sortedFiles, source: 'scanned-css', values });
+      if (assessment.plausible) {
+        return {
+          files: sortedFiles,
+          source: 'scanned-css',
+          tokenCount: inferred.definitions.size,
+          values,
+        };
+      }
+      rejected = { files: sortedFiles, reasons: assessment.reasons, source: 'scanned-css', values };
     }
   }
 
@@ -178,7 +185,7 @@ function resolveAuditScale({ baseFontSize, cssFiles, requested, tokenSourceResul
     }
   }
 
-  return { files: [], source: 'fallback', tokenCount: 0, values: DEFAULT_SCALE };
+  return { files: [], ...(rejected ? { rejected } : {}), source: 'fallback', tokenCount: 0, values: DEFAULT_SCALE };
 }
 
 function normalizeCreateAuditOptions(options = {}) {

package/src/audit/scan/files.js

@@ -0,0 +1,262 @@
+'use strict';
+
+/**
+ * Which files the audit looks at: directory walking, ignore patterns (root-relative
+ * paths and globs), git-scoped selection (--since, --staged), and the file-type
+ * predicates. Nothing here parses CSS.
+ */
+const { execFileSync } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  SKIP_DIRS,
+  TEMPLATE_EXTENSIONS,
+} = require('../shared');
+
+function assertDirectory(dir) {
+  if (!dir) {
+    throw new Error('Missing audit directory.');
+  }
+
+  const resolvedDir = path.resolve(dir);
+  if (!fs.existsSync(resolvedDir)) {
+    throw new Error(`Directory not found: ${dir}`);
+  }
+
+  if (!fs.statSync(resolvedDir).isDirectory()) {
+    throw new Error(`Not a directory: ${dir}`);
+  }
+
+  return resolvedDir;
+}
+
+function walkFiles(rootDir, ignorePatterns = []) {
+  const cssFiles = [];
+  const templateFiles = [];
+  const ignoreMatchers = createIgnoreMatchers(ignorePatterns);
+
+  function walk(currentDir) {
+    for (const entry of fs.readdirSync(currentDir, { withFileTypes: true })) {
+      const fullPath = path.join(currentDir, entry.name);
+      const relativePath = toPosixRelativePath(rootDir, fullPath);
+
+      if (shouldIgnorePath(relativePath, entry, ignoreMatchers)) {
+        continue;
+      }
+
+      if (entry.isDirectory()) {
+        walk(fullPath);
+        continue;
+      }
+
+      if (entry.isFile()) {
+        if (isCssFile(fullPath)) {
+          cssFiles.push(fullPath);
+        } else if (isTemplateFile(fullPath)) {
+          templateFiles.push(fullPath);
+        }
+      }
+    }
+  }
+
+  walk(rootDir);
+  return { cssFiles, templateFiles };
+}
+
+function getScanFiles(rootDir, ignorePatterns, parsed) {
+  if (parsed.staged || parsed.since) {
+    return getGitChangedScanFiles(rootDir, ignorePatterns, parsed);
+  }
+
+  return {
+    ...walkFiles(rootDir, ignorePatterns),
+    scanScope: {
+      mode: 'full',
+    },
+  };
+}
+
+function getGitChangedScanFiles(rootDir, ignorePatterns, parsed) {
+  const args = parsed.staged
+    ? ['diff', '--name-only', '--cached', '--diff-filter=ACMR', '--']
+    : ['diff', '--name-only', '--diff-filter=ACMR', parsed.since, '--'];
+  let output = '';
+
+  try {
+    output = execFileSync('git', args, {
+      cwd: process.cwd(),
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+  } catch (err) {
+    const stderr = err.stderr ? String(err.stderr).trim() : err.message;
+    throw new Error(`Unable to read changed files from git: ${stderr}`);
+  }
+
+  const cssFiles = [];
+  const templateFiles = [];
+  const ignoreMatchers = createIgnoreMatchers(ignorePatterns);
+  const seen = new Set();
+  const changedFiles = output.split(/\r?\n/)
+    .map((filePath) => filePath.trim())
+    .filter(Boolean);
+
+  for (const filePath of changedFiles) {
+    const fullPath = path.resolve(process.cwd(), filePath);
+
+    if (!isPathInside(rootDir, fullPath) || seen.has(fullPath) || !fs.existsSync(fullPath)) {
+      continue;
+    }
+
+    const stat = fs.statSync(fullPath);
+    if (!stat.isFile()) {
+      continue;
+    }
+
+    const relativePath = toPosixRelativePath(rootDir, fullPath);
+    if (shouldIgnoreRelativeFile(relativePath, ignoreMatchers)) {
+      continue;
+    }
+
+    seen.add(fullPath);
+    if (isCssFile(fullPath)) {
+      cssFiles.push(fullPath);
+    } else if (isTemplateFile(fullPath)) {
+      templateFiles.push(fullPath);
+    }
+  }
+
+  return {
+    cssFiles,
+    scanScope: {
+      changedFiles: changedFiles.length,
+      mode: parsed.staged ? 'staged' : 'since',
+      since: parsed.since,
+    },
+    templateFiles,
+  };
+}
+
+function isPathInside(rootDir, filePath) {
+  const relativePath = path.relative(rootDir, filePath);
+  return relativePath === '' || (!relativePath.startsWith('..') && !path.isAbsolute(relativePath));
+}
+
+function shouldIgnorePath(relativePath, entry, ignoreMatchers) {
+  return ignoreMatchers.some((matcher) => matcher.test(relativePath))
+    || (entry.isDirectory() && SKIP_DIRS.has(entry.name));
+}
+
+function shouldIgnoreRelativeFile(relativePath, ignoreMatchers) {
+  const segments = relativePath.split('/');
+  return segments.some((segment) => SKIP_DIRS.has(segment))
+    || ignoreMatchers.some((matcher) => matcher.test(relativePath));
+}
+
+function createIgnoreMatchers(patterns) {
+  const variants = new Set();
+
+  for (const pattern of patterns) {
+    addIgnorePatternVariants(variants, pattern);
+  }
+
+  return Array.from(variants, (pattern) => globToRegExp(pattern));
+}
+
+function addIgnorePatternVariants(variants, pattern) {
+  if (!pattern) {
+    return;
+  }
+
+  variants.add(pattern);
+
+  if (!pattern.includes('/')) {
+    variants.add(`${pattern}/**`);
+    variants.add(`**/${pattern}`);
+    variants.add(`**/${pattern}/**`);
+    return;
+  }
+
+  if (pattern.endsWith('/**')) {
+    variants.add(pattern.slice(0, -3));
+    return;
+  }
+
+  if (!hasGlob(pattern)) {
+    variants.add(`${pattern}/**`);
+  }
+}
+
+function hasGlob(pattern) {
+  return /[*?]/.test(pattern);
+}
+
+function globToRegExp(pattern) {
+  let source = '^';
+
+  for (let index = 0; index < pattern.length; index++) {
+    const char = pattern[index];
+    const nextChar = pattern[index + 1];
+
+    if (char === '*' && nextChar === '*') {
+      source += '.*';
+      index++;
+      continue;
+    }
+
+    if (char === '*') {
+      source += '[^/]*';
+      continue;
+    }
+
+    if (char === '?') {
+      source += '[^/]';
+      continue;
+    }
+
+    source += escapeRegExp(char);
+  }
+
+  return new RegExp(`${source}$`);
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&');
+}
+
+function toPosixRelativePath(rootDir, filePath) {
+  return path.relative(rootDir, filePath).split(path.sep).join('/');
+}
+
+function isScssFile(filePath) {
+  return filePath.endsWith('.scss');
+}
+
+// "CSS files" in the audit means authored stylesheets: .css always, .scss too;
+// whether .scss can be parsed is decided when the run starts (stylesheets.js).
+function isCssFile(filePath) {
+  return filePath.endsWith('.css') || isScssFile(filePath);
+}
+
+function isTemplateFile(filePath) {
+  return TEMPLATE_EXTENSIONS.has(path.extname(filePath));
+}
+
+module.exports = {
+  addIgnorePatternVariants,
+  assertDirectory,
+  createIgnoreMatchers,
+  escapeRegExp,
+  getGitChangedScanFiles,
+  getScanFiles,
+  globToRegExp,
+  hasGlob,
+  isCssFile,
+  isPathInside,
+  isScssFile,
+  isTemplateFile,
+  shouldIgnorePath,
+  shouldIgnoreRelativeFile,
+  toPosixRelativePath,
+  walkFiles,
+};