@sun-asterisk/sunlint 1.3.54 → 1.3.55

package/engines/heuristic-engine.js

@@ -999,7 +999,11 @@ class HeuristicEngine extends AnalysisEngineInterface {
           // Group violations by file
           const violationsByFile = this.groupViolationsByFile(ruleViolations);
 
-          for (const [filePath, violations] of violationsByFile) {
+          for (const [filePath, fileViolations] of violationsByFile) {
+
+            // Filter violations suppressed by inline disable comments
+            const violations = this.filterViolationsByInlineDisable(filePath, fileViolations);
+            if (violations.length === 0) continue;
 
             // Apply per-file config overrides — skip violations disabled by overrides
             let overriddenSeverity = null;
@@ -1343,6 +1347,127 @@ class HeuristicEngine extends AnalysisEngineInterface {
     return groups;
   }
 
+  /**
+   * Filter violations suppressed by inline disable comments
+   * Supports: sunlint-disable-next-line <ruleId>, sunlint-disable <ruleId>,
+   *           sunlint-disable-file <ruleId>, sunlint-disable (all rules)
+   * Following Rule C006: Verb-noun naming
+   * @param {string} filePath - Path to the source file
+   * @param {Object[]} violations - Violations found in the file
+   * @returns {Object[]} Filtered violations (without suppressed ones)
+   */
+  filterViolationsByInlineDisable(filePath, violations) {
+    if (!violations || violations.length === 0) return violations;
+
+    let lines;
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      lines = content.split('\n');
+    } catch {
+      return violations;
+    }
+
+    // Pre-scan for file-level disables and block-level disable/enable ranges
+    const fileDisabledRules = new Set();
+    const disableRanges = []; // { ruleId: string|null, startLine: number, endLine: number }
+    let activeDisables = new Map(); // ruleId|'*' → startLineNumber
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+
+      // File-level disable: sunlint-disable-file or sunlint-disable-file S004
+      const fileDisableMatch = line.match(/(?:\/\/|\/\*)\s*sunlint-disable-file(?:\s+([\w,\s]+))?\s*(?:\*\/)?/);
+      if (fileDisableMatch) {
+        const ruleIds = fileDisableMatch[1] ? fileDisableMatch[1].split(',').map(r => r.trim()) : [null];
+        for (const ruleId of ruleIds) {
+          fileDisabledRules.add(ruleId); // null means all rules
+        }
+        continue;
+      }
+
+      // Block-level disable: sunlint-disable or sunlint-disable S004
+      const blockDisableMatch = line.match(/(?:\/\/|\/\*)\s*sunlint-disable(?!\s*-(?:next-line|file))(?:\s+([\w,\s]+))?\s*(?:\*\/)?/);
+      if (blockDisableMatch) {
+        const ruleIds = blockDisableMatch[1] ? blockDisableMatch[1].split(',').map(r => r.trim()) : ['*'];
+        for (const ruleId of ruleIds) {
+          if (!activeDisables.has(ruleId)) {
+            activeDisables.set(ruleId, i + 1); // 1-based line number
+          }
+        }
+        continue;
+      }
+
+      // Block-level enable: sunlint-enable or sunlint-enable S004
+      const blockEnableMatch = line.match(/(?:\/\/|\/\*)\s*sunlint-enable(?:\s+([\w,\s]+))?\s*(?:\*\/)?/);
+      if (blockEnableMatch) {
+        const ruleIds = blockEnableMatch[1] ? blockEnableMatch[1].split(',').map(r => r.trim()) : ['*'];
+        for (const ruleId of ruleIds) {
+          if (activeDisables.has(ruleId)) {
+            disableRanges.push({
+              ruleId: ruleId === '*' ? null : ruleId,
+              startLine: activeDisables.get(ruleId),
+              endLine: i + 1
+            });
+            activeDisables.delete(ruleId);
+          }
+        }
+        continue;
+      }
+    }
+
+    // Close any unclosed disable blocks (extend to end of file)
+    for (const [ruleId, startLine] of activeDisables) {
+      disableRanges.push({
+        ruleId: ruleId === '*' ? null : ruleId,
+        startLine,
+        endLine: lines.length
+      });
+    }
+
+    return violations.filter(violation => {
+      const ruleId = violation.ruleId;
+      const violationLine = violation.line;
+
+      // Check file-level disable
+      if (fileDisabledRules.has(null) || fileDisabledRules.has(ruleId)) {
+        return false;
+      }
+
+      // Check block-level disable ranges
+      for (const range of disableRanges) {
+        if (violationLine >= range.startLine && violationLine <= range.endLine) {
+          if (range.ruleId === null || range.ruleId === ruleId) {
+            return false;
+          }
+        }
+      }
+
+      // Check next-line directive (comment on previous line)
+      if (violationLine > 1) {
+        const prevLine = lines[violationLine - 2]?.trim() || '';
+        const nextLinePattern = /(?:\/\/|\/\*)\s*sunlint-disable-next-line(?:\s+([\w,\s]+))?\s*(?:\*\/)?/;
+        const nextLineMatch = prevLine.match(nextLinePattern);
+        if (nextLineMatch) {
+          if (!nextLineMatch[1]) return false; // No rule specified = disable all
+          const disabledRules = nextLineMatch[1].split(',').map(r => r.trim());
+          if (disabledRules.includes(ruleId)) return false;
+        }
+      }
+
+      // Check same-line disable (comment on the violation line itself)
+      const currentLine = lines[violationLine - 1] || '';
+      const sameLinePattern = /(?:\/\/|\/\*)\s*sunlint-disable(?:-next-line)?(?:\s+([\w,\s]+))?\s*(?:\*\/)?/;
+      const sameLineMatch = currentLine.match(sameLinePattern);
+      if (sameLineMatch) {
+        if (!sameLineMatch[1]) return false;
+        const disabledRules = sameLineMatch[1].split(',').map(r => r.trim());
+        if (disabledRules.includes(ruleId)) return false;
+      }
+
+      return true;
+    });
+  }
+
   /**
    * Get supported rules
    * Following Rule C006: Verb-noun naming

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sun-asterisk/sunlint",
-  "version": "1.3.54",
+  "version": "1.3.55",
   "description": "☀️ SunLint - Multi-language static analysis tool for code quality and security | Sun* Engineering Standards",
   "main": "cli.js",
   "bin": {