com.wallstop-studios.dxmessaging 2.1.4 → 2.1.6

package/scripts/__tests__/validate-workflows.test.js

@@ -0,0 +1,188 @@
+/**
+ * @fileoverview Tests for validate-workflows.js logic.
+ *
+ * These tests validate the core detection logic for problematic
+ * git add --renormalize patterns in GitHub Actions workflows.
+ */
+
+"use strict";
+
+const {
+    isForbiddenRenormalizePattern,
+    hasExistenceCheck,
+} = require('../validate-workflows.js');
+
+describe("isForbiddenRenormalizePattern", () => {
+    describe("should detect FORBIDDEN patterns", () => {
+        test("single line with multiple distinct extensions", () => {
+            const line =
+                "git add --renormalize -- '*.md' '**/*.md' '*.json' '**/*.json'";
+            expect(isForbiddenRenormalizePattern(line)).toBe(true);
+        });
+
+        test("single line with three extensions", () => {
+            const line =
+                "git add --renormalize -- '*.md' '*.json' '*.yml'";
+            expect(isForbiddenRenormalizePattern(line)).toBe(true);
+        });
+
+        test("double-quoted patterns", () => {
+            const line =
+                'git add --renormalize -- "*.md" "**/*.md" "*.json" "**/*.json"';
+            expect(isForbiddenRenormalizePattern(line)).toBe(true);
+        });
+
+        test("mixed quote styles", () => {
+            const line =
+                "git add --renormalize -- '*.cs' \"*.md\"";
+            expect(isForbiddenRenormalizePattern(line)).toBe(true);
+        });
+
+        test("indented in workflow file", () => {
+            const line =
+                "          git add --renormalize -- '*.md' '*.json' '*.yml'";
+            expect(isForbiddenRenormalizePattern(line)).toBe(true);
+        });
+    });
+
+    describe("should ALLOW safe patterns", () => {
+        test("single extension with recursive pattern", () => {
+            const line = "git add --renormalize -- '*.md' '**/*.md'";
+            expect(isForbiddenRenormalizePattern(line)).toBe(false);
+        });
+
+        test("variable-based pattern in loop", () => {
+            const line = 'git add --renormalize -- "*.$ext" "**/*.$ext"';
+            expect(isForbiddenRenormalizePattern(line)).toBe(false);
+        });
+
+        test("variable-based pattern with braces", () => {
+            const line = 'git add --renormalize -- "*.${ext}" "**/*.${ext}"';
+            expect(isForbiddenRenormalizePattern(line)).toBe(false);
+        });
+
+        test("single specific file", () => {
+            const line =
+                "git add --renormalize -- '.config/dotnet-tools.json'";
+            expect(isForbiddenRenormalizePattern(line)).toBe(false);
+        });
+
+        test("line without git add", () => {
+            const line = "echo 'renormalize'";
+            expect(isForbiddenRenormalizePattern(line)).toBe(false);
+        });
+
+        test("line without renormalize", () => {
+            const line = "git add -- '*.md' '*.json'";
+            expect(isForbiddenRenormalizePattern(line)).toBe(false);
+        });
+
+        test("add_options: --renormalize (YAML key)", () => {
+            const line = "add_options: --renormalize";
+            expect(isForbiddenRenormalizePattern(line)).toBe(false);
+        });
+
+        test("comment describing renormalize", () => {
+            const line =
+                "# Use --renormalize to ensure line endings";
+            expect(isForbiddenRenormalizePattern(line)).toBe(false);
+        });
+    });
+});
+
+describe("hasExistenceCheck", () => {
+    describe("should detect proper guards", () => {
+        test("if statement with git ls-files and grep", () => {
+            const lines = [
+                "for ext in cs md json; do",
+                '  if git ls-files "*.$ext" "**/*.$ext" | grep -q .; then',
+                '    git add --renormalize -- "*.$ext" "**/*.$ext"',
+                "  fi",
+                "done",
+            ];
+            expect(hasExistenceCheck(lines, 2)).toBe(true);
+        });
+
+        test("for loop with existence check", () => {
+            const lines = [
+                "for ext in cs md json asmdef yml yaml; do",
+                '  if git ls-files "*.$ext" "**/*.$ext" | grep -q .; then',
+                '    git add --renormalize -- "*.$ext" "**/*.$ext"',
+                "  fi",
+                "done",
+            ];
+            expect(hasExistenceCheck(lines, 2)).toBe(true);
+        });
+    });
+
+    describe("should detect missing guards", () => {
+        test("direct command without check", () => {
+            const lines = [
+                "- name: Renormalize line endings",
+                "  run: |",
+                "    git add --renormalize -- '*.md' '**/*.md'",
+            ];
+            expect(hasExistenceCheck(lines, 2)).toBe(false);
+        });
+
+        test("guard too far away", () => {
+            const lines = [
+                'if git ls-files "*.md" | grep -q .; then',
+                "  echo 'files exist'",
+                "fi",
+                "",
+                "",
+                "",
+                "",
+                "git add --renormalize -- '*.md' '**/*.md'",
+            ];
+            // Index 7, lookback 5 won't reach index 0
+            expect(hasExistenceCheck(lines, 7)).toBe(false);
+        });
+    });
+});
+
+describe("Real workflow patterns", () => {
+    describe("should correctly handle actual workflow content", () => {
+        test("correct per-extension loop pattern", () => {
+            const workflowContent = `
+      - name: Renormalize line endings
+        shell: bash
+        run: |
+          # Renormalize each extension separately to avoid "pathspec did not match" failures
+          for ext in cs md json asmdef yml yaml; do
+            if git ls-files "*.$ext" "**/*.$ext" | grep -q .; then
+              git add --renormalize -- "*.$ext" "**/*.$ext"
+            fi
+          done
+`;
+            const lines = workflowContent.split("\n");
+            const renormalizeLine = lines.findIndex((l) =>
+                l.includes("git add --renormalize")
+            );
+
+            // Should NOT be forbidden (uses variable)
+            expect(isForbiddenRenormalizePattern(lines[renormalizeLine])).toBe(
+                false
+            );
+            // Should have existence check
+            expect(hasExistenceCheck(lines, renormalizeLine)).toBe(true);
+        });
+
+        test("problematic single-line pattern", () => {
+            const workflowContent = `
+      - name: Renormalize line endings
+        run: git add --renormalize -- '*.md' '*.markdown' '*.json'
+`;
+            const lines = workflowContent.split("\n");
+            const renormalizeLine = lines.findIndex((l) =>
+                l.includes("git add --renormalize")
+            );
+
+            // Should BE forbidden (multiple extensions on single line)
+            expect(isForbiddenRenormalizePattern(lines[renormalizeLine])).toBe(
+                true
+            );
+        });
+    });
+});

package/scripts/__tests__/validate-workflows.test.js.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: cfde2601b3671e813b015ff9eddfb824
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/scripts/__tests__.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b8c4d0e2f6a9583b0c7d1e3f5a7b9c1d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/scripts/check-eol.js

@@ -5,8 +5,33 @@
 */
 const fs = require('fs');
 const path = require('path');
+const { spawnSync } = require('child_process');
 
-const repoRoot = process.cwd();
+function getGitRepoRoot() {
+  const result = spawnSync('git', ['rev-parse', '--show-toplevel'], {
+    cwd: process.cwd(),
+    encoding: 'utf8'
+  });
+  if (result.status === 0 && result.stdout) {
+    return result.stdout.trim();
+  }
+  // Fallback to cwd if not in a git repo
+  return process.cwd();
+}
+
+const repoRoot = getGitRepoRoot();
+const argv = process.argv.slice(2);
+let checkEntireRepo = false;
+const targetArgs = [];
+
+// Parse arguments: --all checks entire repo, otherwise paths are checked
+for (const arg of argv) {
+  if (arg === '--all') {
+    checkEntireRepo = true;
+    continue;
+  }
+  targetArgs.push(arg);
+}
 
 // Exclude directory patterns (match anywhere in path)
 const excludeRegexes = [
@@ -16,12 +41,16 @@ const excludeRegexes = [
   /(^|[\/\\])(Obj|obj)([\/\\]|$)/,
   /(^|[\/\\])Temp([\/\\]|$)/,
   /(^|[\/\\])Samples~([\/\\]|$)/,
-  /(^|[\/\\])\.vs([\/\\]|$)/
+  /(^|[\/\\])\.vs([\/\\]|$)/,
+  /(^|[\/\\])\.venv([\/\\]|$)/,
+  /(^|[\/\\])\.artifacts([\/\\]|$)/,
+  /(^|[\/\\])site([\/\\]|$)/
 ];
 
-// Text file extensions to validate
-const exts = new Set([
+// Text file extensions that require CRLF line endings
+const crlfExts = new Set([
   '.cs', '.csproj', '.sln',
+  '.js', '.cjs', '.mjs',
   '.json', '.jsonc', '.toml',
   '.yaml', '.yml',
   '.md', '.markdown',
@@ -31,9 +60,39 @@ const exts = new Set([
   '.ps1'
 ]);
 
-/** Recursively collect file paths under dir */
+// Shell scripts require LF line endings for Unix compatibility
+const lfExts = new Set(['.sh', '.bash', '.zsh', '.ksh', '.fish']);
+
+// Git hooks directory - files here need LF regardless of extension
+const hooksDir = path.join('scripts', 'hooks');
+
+// All text file extensions we validate
+const exts = new Set([...crlfExts, ...lfExts]);
+
+/**
+ * Check if a file is a git hook (no extension, in hooks directory)
+ * @param {string} filePath - Absolute path to the file.
+ * @returns {boolean} True if the file is a git hook.
+ */
+function isGitHook(filePath) {
+  const rel = path.relative(repoRoot, filePath);
+  return rel.startsWith(hooksDir + path.sep) && path.extname(filePath) === '';
+}
+
+/**
+ * Recursively collect file paths under dir, excluding paths matching excludeRegexes.
+ * @param {string} dir - Absolute path to the directory to walk.
+ * @param {string[]} files - Accumulator array for collected file paths.
+ * @returns {string[]} Array of absolute file paths.
+ */
 function walk(dir, files = []) {
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    console.warn(`Warning: cannot read directory, skipping: ${dir} (${err.code || err.message})`);
+    return files;
+  }
   for (const ent of entries) {
     const full = path.join(dir, ent.name);
     if (excludeRegexes.some((re) => re.test(full))) {
@@ -48,10 +107,148 @@ function walk(dir, files = []) {
   return files;
 }
 
+/**
+ * Resolve target paths (files or directories) to an array of absolute file paths.
+ * Paths are resolved relative to the git repository root.
+ * @param {string[]} targets - Array of relative or absolute paths (files or directories).
+ * @returns {string[]} Array of absolute file paths, deduplicated and filtered by exclusions.
+ */
+function resolveTargets(targets) {
+  if (!targets || targets.length === 0) {
+    return [];
+  }
+
+  const seen = new Set();
+  const resolved = [];
+
+  for (const rawTarget of targets) {
+    // Paths are resolved relative to git repo root (not cwd), matching git's behavior
+    const targetPath = path.resolve(repoRoot, rawTarget);
+    if (!fs.existsSync(targetPath)) {
+      console.warn(`Warning: path does not exist, skipping: ${rawTarget} (resolved to: ${targetPath})`);
+      continue;
+    }
+
+    const isExcluded = excludeRegexes.some((re) => re.test(targetPath));
+    if (isExcluded) {
+      continue;
+    }
+
+    const stats = fs.statSync(targetPath);
+    if (stats.isDirectory()) {
+      for (const file of walk(targetPath)) {
+        if (!seen.has(file)) {
+          resolved.push(file);
+          seen.add(file);
+        }
+      }
+    } else if (stats.isFile()) {
+      if (!seen.has(targetPath)) {
+        resolved.push(targetPath);
+        seen.add(targetPath);
+      }
+    }
+  }
+
+  return resolved;
+}
+
+/**
+ * Get list of staged files from git (Added, Copied, Modified, Renamed).
+ * Returns paths relative to repoRoot, suitable for passing to resolveTargets().
+ * @returns {string[]} Array of staged file paths relative to repo root.
+ */
+function getStagedFiles() {
+  const result = spawnSync('git', ['diff', '--cached', '--name-only', '--diff-filter=ACMR'], {
+    cwd: repoRoot,
+    encoding: 'utf8'
+  });
+
+  if (result.status !== 0) {
+    return [];
+  }
+
+  return result.stdout
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+/**
+ * Check for non-normalized line endings in the git index for tracked text files.
+ * The repository should store LF even when working tree uses CRLF.
+ * @param {string[]} files - Absolute file paths to check.
+ * @returns {Array<{path: string, indexEol: string}>} Array of index EOL issues.
+ */
+function getIndexEolIssues(files) {
+  if (!files || files.length === 0) {
+    return [];
+  }
+
+  const relPaths = files.map((file) => path.relative(repoRoot, file));
+  const result = spawnSync('git', ['ls-files', '--eol', '--', ...relPaths], {
+    cwd: repoRoot,
+    encoding: 'utf8'
+  });
+
+  if (result.status !== 0 || !result.stdout) {
+    return [];
+  }
+
+  const issues = [];
+  const lines = result.stdout.split(/\r?\n/);
+  for (const line of lines) {
+    if (!line) {
+      continue;
+    }
+    const tabIndex = line.indexOf('\t');
+    if (tabIndex < 0) {
+      continue;
+    }
+    const meta = line.slice(0, tabIndex).trim();
+    const filePath = line.slice(tabIndex + 1).trim();
+    const ext = path.extname(filePath).toLowerCase();
+    const fullPath = path.resolve(repoRoot, filePath);
+    const isHook = isGitHook(fullPath);
+    
+    // Skip if not a known text file extension and not a git hook
+    if (!exts.has(ext) && !isHook) {
+      continue;
+    }
+
+    // git ls-files --eol output format: i/[eol] w/[eol] attr/[attrs] [path]
+    const parts = meta.split(/\s+/);
+    const indexToken = parts.find((part) => part.startsWith('i/'));
+    const attrToken = parts.find((part) => part.startsWith('attr/'));
+    if (!indexToken) {
+      continue;
+    }
+    if (attrToken === 'attr/-text') {
+      continue;
+    }
+
+    if (indexToken !== 'i/lf' && indexToken !== 'i/none') {
+      issues.push({ path: filePath, indexEol: indexToken });
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * Check if a buffer starts with UTF-8 BOM (byte order mark).
+ * @param {Buffer} buf - File content buffer.
+ * @returns {boolean} True if BOM is present.
+ */
 function hasBom(buf) {
   return buf.length >= 3 && buf[0] === 0xef && buf[1] === 0xbb && buf[2] === 0xbf;
 }
 
+/**
+ * Check if buffer contains non-CRLF line endings (bare LF or CR).
+ * @param {Buffer} buf - File content buffer.
+ * @returns {boolean} True if non-CRLF line endings are found.
+ */
 function hasNonCrlfEol(buf) {
   const txt = buf.toString('utf8');
   // Strip all valid CRLF pairs; any remaining bare \n or \r is invalid
@@ -59,36 +256,110 @@ function hasNonCrlfEol(buf) {
   return stripped.includes('\n') || stripped.includes('\r');
 }
 
-const allFiles = walk(repoRoot);
+/**
+ * Check if buffer contains non-LF line endings (CRLF or bare CR).
+ * Used for shell scripts that must use LF only.
+ * @param {Buffer} buf - File content buffer.
+ * @returns {boolean} True if non-LF line endings are found.
+ */
+function hasNonLfEol(buf) {
+  const txt = buf.toString('utf8');
+  // CRLF or bare CR are invalid for LF-only files
+  return txt.includes('\r');
+}
+
+const candidateFiles = checkEntireRepo
+  ? walk(repoRoot)
+  : resolveTargets(targetArgs.length > 0 ? targetArgs : getStagedFiles());
+
+const textFiles = [];
+const seenFiles = new Set();
+
+for (const file of candidateFiles) {
+  const ext = path.extname(file).toLowerCase();
+  const isHook = isGitHook(file);
+  
+  // Process if it has a known extension OR if it's a git hook
+  if (!exts.has(ext) && !isHook) {
+    continue;
+  }
+
+  // candidateFiles already contains absolute paths from walk() or resolveTargets()
+  if (seenFiles.has(file)) {
+    continue;
+  }
+
+  seenFiles.add(file);
+  textFiles.push(file);
+}
+
+if (textFiles.length === 0) {
+  console.log('EOL check skipped: no matching files to verify.');
+  process.exit(0);
+}
+
 const bomFiles = [];
 const badEolFiles = [];
+const indexEolIssues = getIndexEolIssues(textFiles);
 
-for (const file of allFiles) {
-  const ext = path.extname(file).toLowerCase();
-  if (!exts.has(ext)) continue;
+for (const file of textFiles) {
   let buf;
   try {
     buf = fs.readFileSync(file);
-  } catch {
+  } catch (err) {
+    console.warn(`Warning: cannot read file, skipping: ${file} (${err.code || err.message})`);
     continue;
   }
   if (hasBom(buf)) bomFiles.push(path.relative(repoRoot, file));
-  if (hasNonCrlfEol(buf)) badEolFiles.push(path.relative(repoRoot, file));
+  
+  const ext = path.extname(file).toLowerCase();
+  const isHook = isGitHook(file);
+  
+  // Shell scripts and git hooks must use LF only
+  const needsLf = lfExts.has(ext) || isHook;
+  if (needsLf) {
+    if (hasNonLfEol(buf)) badEolFiles.push(path.relative(repoRoot, file));
+  } else {
+    // All other text files must use CRLF
+    if (hasNonCrlfEol(buf)) badEolFiles.push(path.relative(repoRoot, file));
+  }
 }
 
-if (bomFiles.length === 0 && badEolFiles.length === 0) {
-  console.log('EOL check passed: CRLF only and no BOMs detected.');
+if (bomFiles.length === 0 && badEolFiles.length === 0 && indexEolIssues.length === 0) {
+  console.log(`EOL check passed: ${textFiles.length} file(s) verified (CRLF for text files, LF for shell scripts), no BOMs detected.`);
   process.exit(0);
 }
 
 if (bomFiles.length) {
-  console.log('Files contain a UTF-8 BOM (should be no BOM):');
-  for (const f of bomFiles) console.log(`  ${f}`);
+  console.error('Files contain a UTF-8 BOM (should be no BOM):');
+  for (const f of bomFiles) console.error(`  ${f}`);
 }
 if (badEolFiles.length) {
-  console.log('Files contain non-CRLF line endings (found LF or bare CR):');
-  for (const f of badEolFiles) console.log(`  ${f}`);
+  // Separate CRLF-required files from LF-required files (shell scripts + git hooks)
+  const crlfViolations = badEolFiles.filter((f) => {
+    const fullPath = path.resolve(repoRoot, f);
+    return !lfExts.has(path.extname(f).toLowerCase()) && !isGitHook(fullPath);
+  });
+  const lfViolations = badEolFiles.filter((f) => {
+    const fullPath = path.resolve(repoRoot, f);
+    return lfExts.has(path.extname(f).toLowerCase()) || isGitHook(fullPath);
+  });
+  
+  if (crlfViolations.length) {
+    console.error('Files require CRLF line endings but contain LF or bare CR:');
+    for (const f of crlfViolations) console.error(`  ${f}`);
+  }
+  if (lfViolations.length) {
+    console.error('Shell scripts and git hooks require LF line endings but contain CRLF or bare CR:');
+    for (const f of lfViolations) console.error(`  ${f}`);
+  }
+}
+if (indexEolIssues.length) {
+  console.error('Git index contains non-normalized line endings (expected LF in repo for text files):');
+  for (const issue of indexEolIssues) {
+    console.error(`  ${issue.path} (${issue.indexEol})`);
+  }
+  console.error('Fix: Run "node scripts/fix-eol.js" then re-stage affected files.');
 }
 console.error('EOL/BOM policy violations detected.');
 process.exit(1);
-