Allow running partial test and lint, fixes #160

Author: fulldecent

.github/workflows/code-lint.yml

@@ -34,7 +34,7 @@ jobs:
         run: yarn install --immutable
 
       - name: Check with prettier # Use yarn script instead of a prettier action, in order to load plugins from .prettierrc.js
-        run: yarn run prettier-check
+        run: yarn run lint:prettier
 
   markdownlint:
     name: Markdownlint code lint
@@ -63,4 +63,4 @@ jobs:
         run: yarn install --immutable
 
       - name: Check with markdownlint
-        run: yarn run markdownlint-check
+        run: yarn run lint:markdown

package.json

@@ -1,4 +1,12 @@
 {
+  "--": [
+    "Notes:",
+    "Our scripts use a special POSIX shim that allows you to run i.e. yarn markdownlint-check and specify files to check, or omit the files and it has a default.",
+    "The magic is in the ${@:-\"**/*.md\"} part:",
+    "$@: This represents all the arguments passed to the script (e.g., the files you want to lint).",
+    "${...:-...}: This is the shell's 'use default value' operator.",
+    "In plain English, it means: If $@ (the list of arguments) is empty or not set, use the default value **/*.md. Otherwise, use the arguments that were provided."
+  ],
   "license": "UNLICENSED",
   "devDependencies": {
     "@fulldecent/nice-checkers-plugin": "^0.2.1",
@@ -11,15 +19,15 @@
     "prettier": "^3.6.2"
   },
   "scripts": {
+    "lint": "sh -c 'yarn lint:prettier \"$@\" && yarn lint:markdown \"$@\"' --",
+    "lint:prettier": "sh -c 'yarn prettier --check ${@:-\".\"}' --",
+    "lint:markdown": "sh -c 'yarn markdownlint-cli2 ${@:-\"**/*.md\"}' --",
+    "format-all": "yarn prettier --write . && yarn markdownlint-cli2 --fix '**/*.md'",
     "build": "bundle exec jekyll build",
-    "test": "yarn node test/html-validate.mjs && yarn node test/dirty-file-paths-checker.mjs",
-    "lint": "yarn prettier-check && yarn markdownlint-check",
-    "lint-fix": "yarn prettier-fix && yarn markdownlint-fix",
     "generate-sitemap": "node scripts/generate-sitemap.mjs",
-    "prettier-check": "yarn prettier --check .",
-    "markdownlint-check": "yarn markdownlint-cli2 '**/*.md'",
-    "prettier-fix": "yarn prettier --write .",
-    "markdownlint-fix": "yarn markdownlint-cli2 --fix '**/*.md'",
+    "test": "sh -c 'yarn test:html-validate \"$@\" && yarn test:dirty-file-paths-checker \"$@\"' --",
+    "test:html-validate": "node test/html-validate.mjs",
+    "test:dirty-file-paths-checker": "node test/dirty-file-paths-checker.mjs",
     "postinstall": "yarn dlx @yarnpkg/sdks vscode"
   },
   "packageManager": "[email protected]",

test/dirty-file-paths-checker.mjs

@@ -1,47 +1,82 @@
 import fs from "fs";
 import path from "path";
-import { glob } from "glob";
+import { globSync } from "glob";
 
 const CONFIG_FILE = path.join(process.cwd(), "test", "dirty-file-paths.json");
 const BUILD_DIR = path.join(process.cwd(), "build");
 
-// Load and parse the configuration file
+/**
+ * Loads and parses the configuration file for dirty path rules.
+ * @returns {object[]} The parsed configuration.
+ */
 function loadConfig() {
+  if (!fs.existsSync(CONFIG_FILE)) {
+    console.error(`❌ Error: Configuration file not found at ${CONFIG_FILE}`);
+    process.exit(1);
+  }
   try {
     const configContent = fs.readFileSync(CONFIG_FILE, "utf-8");
     return JSON.parse(configContent);
   } catch (error) {
-    console.error("Error loading configuration:", error.message);
+    console.error("❌ Error loading or parsing configuration:", error.message);
     process.exit(1);
   }
 }
 
-// Find all files in the build directory
-function findTargetFiles() {
-  return glob
-    .sync("**/*", {
-      cwd: BUILD_DIR,
-      nocase: false, // Case sensitive as per requirements
-      dot: false,
-    })
-    .filter((file) => {
-      const fullPath = path.join(BUILD_DIR, file);
-      return fs.lstatSync(fullPath).isFile();
+/**
+ * Gathers target files from command-line arguments or the default build directory.
+ * @returns {string[]} An array of absolute file paths to check.
+ */
+function getTargetFiles() {
+  const args = process.argv.slice(2);
+
+  // If no arguments, default to all files in the build directory.
+  if (args.length === 0) {
+    return globSync(path.join(BUILD_DIR, "**", "*"), {
+      nodir: true,
+      absolute: true,
     });
+  }
+
+  // Process arguments as file paths, directory paths, or glob patterns.
+  const patterns = args.map((arg) => {
+    try {
+      if (fs.statSync(arg).isDirectory()) {
+        // If it's a directory, create a glob to find all files within it.
+        return path.join(arg, "**", "*");
+      }
+    } catch (e) {
+      // Not a directory or doesn't exist, treat as a file/glob.
+    }
+    return arg;
+  });
+
+  console.log(`ℹ️  Searching for files matching: ${patterns.join(", ")}`);
+  return globSync(patterns, {
+    nodir: true,
+    absolute: true,
+  });
 }
 
-// Convert relative file path to the format expected by rules (starting with /)
+/**
+ * Converts a file path to the format expected by rules (e.g., /path/to/file.html).
+ * @param {string} filePath - The file path relative to the build directory.
+ * @returns {string} The normalized path.
+ */
 function normalizePathForMatching(filePath) {
   // Convert backslashes to forward slashes and ensure it starts with /
   const normalized = filePath.replace(/\\/g, "/");
   return normalized.startsWith("/") ? normalized : "/" + normalized;
 }
 
-// Check a single file's path against the dirty path rules
-function checkFile(filePath, config) {
-  const normalizedPath = normalizePathForMatching(filePath);
-
-  // Process rules in order, later rules take precedence
+/**
+ * Checks a single file's path against the dirty path rules.
+ * @param {string} relativeFilePath - The path of the file relative to the build directory.
+ * @param {object[]} config - The array of rules.
+ * @returns {object | null} A violation object or null if the path is clean.
+ */
+function checkFile(relativeFilePath, config) {
+  const normalizedPath = normalizePathForMatching(relativeFilePath);
   let finalRule = null;
 
   for (const rule of config) {
@@ -51,12 +86,12 @@ function checkFile(filePath, config) {
         finalRule = rule;
       }
     } catch (error) {
-      console.error(`Invalid regex pattern in rule: ${rule.path}`, error.message);
+      console.error(`❌ Invalid regex in rule: ${rule.path}`, error.message);
       process.exit(1);
     }
   }
 
-  // Return violation only if the final matching rule is dirty
+  // Return a violation only if the final matching rule is 'dirty: true'.
   if (finalRule && finalRule.dirty) {
     return { path: normalizedPath, advice: finalRule.advice };
   }
@@ -67,32 +102,51 @@ function checkFile(filePath, config) {
 console.log("🧪 Testing files for dirty file paths");
 
 const config = loadConfig();
-const files = findTargetFiles();
+const absoluteFilePaths = getTargetFiles();
 let hasErrors = false;
-const violationsByPath = new Map();
+const violations = [];
+const cleanFiles = [];
+
+if (absoluteFilePaths.length === 0) {
+  console.log("⚠️  No files found to check.");
+  process.exit(0);
+}
+
+// Collect all violations and clean files
+for (const absolutePath of absoluteFilePaths) {
+  // Rules are based on the path relative to the site root (the build dir).
+  const relativeToBuildDir = path.relative(BUILD_DIR, absolutePath);
+  const violation = checkFile(relativeToBuildDir, config);
+
+  // Use a path relative to the current working directory for user-friendly logging.
+  const relativeToCwd = path.relative(process.cwd(), absolutePath);
 
-// Collect violations
-files.forEach((file) => {
-  const violation = checkFile(file, config);
   if (violation) {
     hasErrors = true;
-    console.log(`❌ ${file}: ${violation.advice}`);
-    violationsByPath.set(violation.path, violation.advice);
+    violations.push({ path: relativeToCwd, advice: violation.advice });
+  } else {
+    cleanFiles.push(relativeToCwd);
   }
-});
+}
 
-// Summary of clean files
-const cleanFiles = files.filter((file) => !checkFile(file, config));
-console.log(`✅ Site includes ${cleanFiles.length} clean files`);
+// --- Report results ---
 
-// Summary of dirty paths
+// First, log all the individual failures.
 if (hasErrors) {
-  console.log("Following are dirty file paths:");
-  violationsByPath.forEach((advice, path) => {
-    console.log(`${path} ${advice}`);
+  console.log("\n---");
+  violations.forEach(({ path, advice }) => {
+    console.log(`❌ ${path}: ${advice}`);
   });
-  console.error("\n❌ Dirty paths check failed");
+  console.log("---\n");
+}
+
+console.log(`📊 Results Summary:`);
+console.log(`✅ Found ${cleanFiles.length} clean file paths.`);
+
+if (hasErrors) {
+  console.log(`❌ Found ${violations.length} dirty file paths.`);
+  console.error("\n❌ Dirty paths check failed.");
   process.exit(1);
 } else {
-  console.log("✨ All files passed dirty paths check!\n");
+  console.log("✨ All file paths passed the check!\n");
 }

test/html-validate.mjs

@@ -1,28 +1,64 @@
-import { glob } from "glob";
+import { globSync } from "glob";
 import { Worker } from "worker_threads";
 import path from "path";
 import { fileURLToPath } from "url";
+import fs from "fs";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+// --- Configuration ---
 // In the future, the CLI may improve and this script may be unnecessary.
 // SEE: https://gitlab.com/html-validate/html-validate/-/issues/273
-
-// Configuration
 const MAX_WORKERS = parseInt(process.env.HTML_VALIDATE_WORKERS) || 4;
 const WORKER_SCRIPT_PATH = path.join(__dirname, "html-validate-worker.mjs");
 
-// Find and sort all HTML files in the 'build' directory
-const targets = glob.sync("build/**/*.html").sort();
+/**
+ * Gathers target HTML files from command-line arguments or a default directory.
+ * @returns {string[]} A sorted and deduplicated array of HTML file paths.
+ */
+function getTargetFiles() {
+  const args = process.argv.slice(2);
+
+  // If no arguments are provided, use the default glob pattern.
+  if (args.length === 0) {
+    console.log("ℹ️  No paths provided. Searching for HTML files in `build/` directory...");
+    return globSync("build/**/*.html").sort();
+  }
+
+  // If arguments are provided, process them into a list of glob patterns.
+  const patterns = args.map((arg) => {
+    try {
+      // Check if the argument is a directory.
+      if (fs.statSync(arg).isDirectory()) {
+        // If it is, create a glob pattern to find all HTML files within it.
+        return path.join(arg, "**", "*.html");
+      }
+    } catch (error) {
+      // If fs.statSync fails, the path might not exist or isn't a directory.
+      // In that case, we assume it's a file path or a glob pattern and use it directly.
+    }
+    // Return the argument as-is for glob to process.
+    return arg;
+  });
+
+  console.log(`ℹ️  Searching for files matching: ${patterns.join(", ")}`);
+  // Use glob to find all files matching the generated patterns.
+  const files = globSync(patterns, { nodir: true });
+
+  // Return a deduplicated and sorted list of files.
+  return [...new Set(files)].sort();
+}
+
+const targets = getTargetFiles();
 
 if (targets.length === 0) {
   console.log("⚠️  No HTML files found in build directory");
   console.log("   Make sure to build the site first");
   process.exit(0);
 }
 
-console.log(`🧪 Validating ${targets.length} files with ${MAX_WORKERS} parallel workers...`);
+console.log(`🧪 Validating ${targets.length} files with up to ${MAX_WORKERS} parallel workers...`);
 
 await validateParallel();
 
@@ -95,16 +131,18 @@ async function validateParallel() {
   }
 
   function startParallelProcessing() {
-    for (let i = 0; i < MAX_WORKERS; i++) {
+    const workerCount = Math.min(MAX_WORKERS, taskQueue.length);
+    for (let i = 0; i < workerCount; i++) {
       const worker = createWorker(i);
       workers.push(worker);
     }
 
-    const initialTasks = Math.min(MAX_WORKERS, taskQueue.length);
-    for (let i = 0; i < initialTasks; i++) {
-      const task = taskQueue.shift();
-      workers[i].postMessage({ filePath: task, workerId: i });
-    }
+    workers.forEach((worker, i) => {
+      if (taskQueue.length > 0) {
+        const task = taskQueue.shift();
+        worker.postMessage({ filePath: task, workerId: i });
+      }
+    });
   }
 
   return new Promise((resolve) => {
@@ -113,6 +151,10 @@ async function validateParallel() {
       originalComplete();
       resolve();
     };
-    startParallelProcessing();
+    if (targets.length > 0) {
+      startParallelProcessing();
+    } else {
+      completeParallelProcessing();
+    }
   });
 }