test-pmd-rule 1.2.2 → 1.2.4

package/README.md

@@ -162,6 +162,10 @@ public class TestClass {
 1. **Extraction**: The tool reads all `<example>` tags from your rule XML file
 2. **Parsing**: Each example is parsed to identify violation and valid code sections
 3. **Test File Creation**: Temporary Apex test files are generated with the example code
+    - If an example contains a single top-level class, it's renamed to a test class name
+    - If an example contains multiple top-level classes, they're wrapped as inner classes within a test class
+    - If an example contains only methods/fields without a class, they're wrapped in a test class
+    - If an example contains only standalone code, it's wrapped in a test method within a test class
 4. **PMD Execution**: PMD is run against the test files to check if violations occur as expected
 5. **Validation**: The tool verifies that:
     - Violation examples actually trigger the rule
@@ -213,6 +217,7 @@ The AST nodes are color-coded to indicate which parts of your example code are b
 - **Dark Red (dim)**: Node is tested by **violation** examples but was already covered in previous examples
 - **Green (bright)**: Node is tested by **valid** examples in the current example
 - **Dark Green (dim)**: Node is tested by **valid** examples but was already covered in previous examples
+- **Orange**: Node matches both **violation** and **valid** sections (indicates ambiguity - the same code appears in both sections)
 - **No color**: Node is not tested or couldn't be matched to example code
 
 This color coding helps you understand:
@@ -220,6 +225,7 @@ This color coding helps you understand:
 - Which AST nodes correspond to your violation/valid markers
 - Whether nodes are being tested by the current example or were already covered
 - Which parts of the AST structure your XPath expression should target
+- When the same code appears in both violation and valid sections (orange indicates this ambiguity)
 
 **Notes:**
 
@@ -228,6 +234,7 @@ This color coding helps you understand:
 - If the generated test file has syntax errors, the tool will display the generated file content to help debug issues
 - The AST output includes all node attributes and can be quite verbose - use it when you need detailed insight into PMD's parsing
 - Colors use ANSI escape codes and will automatically be disabled if your terminal doesn't support them
+- **Wrapper class cleanup**: The tool automatically strips wrapper class prefixes from `DefiningType` attributes (e.g., `DefiningType='TestClass1.MyClassViolation'` becomes `DefiningType='MyClassViolation'`) to make the output cleaner and more readable
 
 ## Requirements
 

package/dist/test-pmd-rule.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
 // src/cli/main.ts
-import { existsSync as existsSync2, readdirSync, statSync } from "fs";
+import { existsSync as existsSync2, readdirSync, realpathSync as realpathSync2, statSync } from "fs";
 import { extname, resolve as resolve3 } from "path";
 import { argv } from "process";
 import { cpus } from "os";
-import { pathToFileURL } from "url";
+import { fileURLToPath } from "url";
 import { DOMParser as DOMParser4 } from "@xmldom/xmldom";
 import { stringifyTree } from "stringify-tree";
 
@@ -1392,6 +1392,7 @@ var SPACE_CHAR = " ";
 var DEFAULT_INDENT = "    ";
 var FIRST_ELEMENT_INDEX2 = 0;
 var LAST_ELEMENT_OFFSET = 1;
+var SINGLE_COUNT = 1;
 function removeInlineMarkers(line) {
   if (line.includes("// \u274C")) {
     const splitResult = line.split("// \u274C");
@@ -1611,16 +1612,15 @@ function createTestFile({
   const TEST_CLASS_NAME = `TestClass${String(exampleIndex)}`;
   const fullExampleContent = parsed.content;
   const ZERO_BRACE_DEPTH = 0;
-  const hasTopLevelClass = (() => {
-    let foundTopLevelClass = false;
+  const topLevelClassCount = (() => {
+    let count = 0;
     let braceDepth = ZERO_BRACE_DEPTH;
     const exampleLines = fullExampleContent.split("\n");
     for (const line of exampleLines) {
       const trimmed = line.trim();
       const isClassDef = trimmed.startsWith("public class ") || trimmed.startsWith("class ") || trimmed.startsWith("private class ");
       if (isClassDef && braceDepth === ZERO_BRACE_DEPTH) {
-        foundTopLevelClass = true;
-        break;
+        count++;
       }
       const openBracesMatch = line.match(/{/g);
       const closeBracesMatch = line.match(/}/g);
@@ -1628,12 +1628,20 @@ function createTestFile({
       const closeBraces = closeBracesMatch ? closeBracesMatch.length : ZERO_BRACE_DEPTH;
       braceDepth += openBraces - closeBraces;
     }
-    return foundTopLevelClass;
+    return count;
   })();
+  const classDefCountInIncluded = codeToInclude.filter((line) => {
+    const trimmed = line.trim();
+    return trimmed.startsWith("public class ") || trimmed.startsWith("class ") || trimmed.startsWith("private class ");
+  }).length;
+  const hasTopLevelClass = topLevelClassCount === SINGLE_COUNT || topLevelClassCount > SINGLE_COUNT && classDefCountInIncluded <= SINGLE_COUNT;
   const hasClassLikeStructures = (() => {
     if (hasTopLevelClass) {
       return false;
     }
+    if (topLevelClassCount > SINGLE_COUNT) {
+      return classDefCountInIncluded > SINGLE_COUNT;
+    }
     const fieldDeclarationRegex = /^\s*(public|private|protected)\s+\w+\s+\w+\s*[;=]/;
     return codeToInclude.some((line) => {
       const trimmed = line.trim();
@@ -3619,12 +3627,20 @@ var NODE_TYPE_ELEMENT = 1;
 var EMPTY_ARRAY_LENGTH = 0;
 var SINGLE_ELEMENT_INDEX = 0;
 var MIN_ARRAY_INDEX = 0;
+var DOT_SEPARATOR_LENGTH = 1;
 function isCliInvocation() {
   const [, entryPath] = argv;
   if (entryPath === void 0) {
     return false;
   }
-  return import.meta.url === pathToFileURL(entryPath).href;
+  try {
+    const currentModulePath = fileURLToPath(import.meta.url);
+    const resolvedEntryPath = resolve3(process.cwd(), entryPath);
+    const absoluteEntryPath = realpathSync2(resolvedEntryPath);
+    return currentModulePath === absoluteEntryPath;
+  } catch {
+    return false;
+  }
 }
 function findXmlFiles(directory) {
   const xmlFiles = [];
@@ -3760,8 +3776,16 @@ function removeWrappersFromXmlDom(doc, exampleIndex, wrapperInfo) {
     const allNodes2 = doc.getElementsByTagName("*");
     for (const node of Array.from(allNodes2)) {
       const definingType = node.getAttribute("DefiningType");
+      if (definingType === null) {
+        continue;
+      }
       if (definingType === wrapperClassName2) {
         node.removeAttribute("DefiningType");
+      } else if (definingType.startsWith(`${wrapperClassName2}.`)) {
+        const classNameWithoutPrefix = definingType.slice(
+          wrapperClassName2.length + DOT_SEPARATOR_LENGTH
+        );
+        node.setAttribute("DefiningType", classNameWithoutPrefix);
       }
     }
     return;
@@ -3921,8 +3945,16 @@ function removeWrappersFromXmlDom(doc, exampleIndex, wrapperInfo) {
   const allNodes = doc.getElementsByTagName("*");
   for (const node of Array.from(allNodes)) {
     const definingType = node.getAttribute("DefiningType");
+    if (definingType === null) {
+      continue;
+    }
     if (definingType === wrapperClassName) {
       node.removeAttribute("DefiningType");
+    } else if (definingType.startsWith(`${wrapperClassName}.`)) {
+      const classNameWithoutPrefix = definingType.slice(
+        wrapperClassName.length + DOT_SEPARATOR_LENGTH
+      );
+      node.setAttribute("DefiningType", classNameWithoutPrefix);
     }
   }
 }
@@ -4052,16 +4084,18 @@ function determineNodeColor(options) {
       return void 0;
     }
   }
-  let hasViolationSection = false;
-  let hasValidSection = false;
+  let violationMatchCount = 0;
+  let validMatchCount = 0;
   for (const lineNum of matchingLines) {
     const section = lineSectionMap.get(lineNum);
     if (section === "violation") {
-      hasViolationSection = true;
+      violationMatchCount++;
     } else if (section === "valid") {
-      hasValidSection = true;
+      validMatchCount++;
     }
   }
+  const hasViolationSection = violationMatchCount > EMPTY_MARKERS_LENGTH;
+  const hasValidSection = validMatchCount > EMPTY_MARKERS_LENGTH;
   let alreadyCovered = false;
   if (xpath !== null && previousExamplesCoverage !== void 0 && previousExamplesCoverage.length > EMPTY_COVERAGE_LENGTH) {
     const nodeTypeInXPath = xpath.includes(nodeType);
@@ -4140,10 +4174,19 @@ function determineNodeColor(options) {
       }
     }
   }
-  if (hasViolationSection && violationMarkers.length > EMPTY_MARKERS_LENGTH) {
+  if (hasViolationSection && hasValidSection) {
+    if (violationMarkers.length > EMPTY_MARKERS_LENGTH && validMarkers.length > EMPTY_MARKERS_LENGTH) {
+      return "orange";
+    }
+    if (violationMarkers.length > EMPTY_MARKERS_LENGTH) {
+      return alreadyCovered ? "dark-red" : "red";
+    }
+    if (validMarkers.length > EMPTY_MARKERS_LENGTH) {
+      return alreadyCovered ? "dark-green" : "green";
+    }
+  } else if (hasViolationSection && violationMarkers.length > EMPTY_MARKERS_LENGTH) {
     return alreadyCovered ? "dark-red" : "red";
-  }
-  if (hasValidSection && validMarkers.length > EMPTY_MARKERS_LENGTH) {
+  } else if (hasValidSection && validMarkers.length > EMPTY_MARKERS_LENGTH) {
     return alreadyCovered ? "dark-green" : "green";
   }
   return void 0;
@@ -4243,6 +4286,7 @@ function applyColorToNodeName(nodeName, color) {
   const ANSI_DARK_GREEN = "\x1B[32;2m";
   const ANSI_RED = "\x1B[31m";
   const ANSI_DARK_RED = "\x1B[31;2m";
+  const ANSI_ORANGE = "\x1B[33m";
   if (color === "green") {
     return `${ANSI_GREEN}${nodeName}${ANSI_RESET}`;
   }
@@ -4252,7 +4296,10 @@ function applyColorToNodeName(nodeName, color) {
   if (color === "red") {
     return `${ANSI_RED}${nodeName}${ANSI_RESET}`;
   }
-  return `${ANSI_DARK_RED}${nodeName}${ANSI_RESET}`;
+  if (color === "dark-red") {
+    return `${ANSI_DARK_RED}${nodeName}${ANSI_RESET}`;
+  }
+  return `${ANSI_ORANGE}${nodeName}${ANSI_RESET}`;
 }
 function parseXmlAstAndStripWrappers(options) {
   const {