@sun-asterisk/sunlint 1.3.16 → 1.3.17

package/rules/common/C024_no_scatter_hardcoded_constants/symbol-based-analyzer.js

@@ -11,7 +11,129 @@ class C024SymbolBasedAnalyzer {
     this.ruleName = 'Error Scatter hardcoded constants throughout the logic (Symbol-Based)';
     this.semanticEngine = semanticEngine;
     this.verbose = false;
-    this.safeStrings = ["UNKNOWN", "N/A"]; // allowlist of special fallback values
+
+    // === Files to ignore (constant/config files) ===
+    // === Files to ignore (constant/config files) ===
+    this.ignoredFilePatterns = [
+      /const/i,
+      /constants/i,
+      /enum/i,
+      /enums/i,
+      /interface/i,
+      /interfaces/i,
+      /type/i,
+      /types/i,
+      /dto/i,
+      /model/i,
+      /response/i,
+      /request/i,
+      /\.res\./i,
+      /\.req\./i,
+      /schema/i,
+      /definition/i,
+      /config/i,
+      /configuration/i,
+      // Test files
+      /test\//,
+      /tests\//,
+      /__tests__\//,
+      /\.test\./,
+      /\.spec\./,
+      /node_modules\//,
+      /mock/i,
+      /fixture/i,
+    ];
+
+    // === Safe numeric values (not magic numbers) ===
+    this.safeNumbers = new Set([
+      -1, 0, 1, 2, 10, 100, 1000,  // Common values
+      24, 60,                       // Time-related
+      100,                          // Percentages
+    ]);
+
+    // === Contexts where constants are acceptable ===
+    this.acceptableContexts = [
+      SyntaxKind.EnumDeclaration,
+      SyntaxKind.InterfaceDeclaration,
+      SyntaxKind.TypeAliasDeclaration,
+      SyntaxKind.VariableDeclaration,  // Top-level constants are OK
+      SyntaxKind.PropertyDeclaration,  // Class properties
+    ];
+
+    // === String patterns that are acceptable (not magic strings) ===
+    this.acceptableStringPatterns = [
+      // Empty or very short strings (1-3 chars only)
+      /^$/,
+      /^.$/,
+      /^..$/,
+      /^...$/,
+
+      // Common delimiters and formatting
+      /^[,;:\.\-_\/\\|]+$/,
+      /^\s+$/,
+      /^[\r\n]+$/,
+
+      // HTML/XML tags
+      /^<[^>]+>$/,
+
+      // Common boolean-like words (exact match only)
+      /^(true|false|yes|no|ok|error|success|fail|null|undefined)$/i,
+
+      // Property access patterns
+      /^\./,
+      /^\[.*\]$/,
+
+      // SQL/Query patterns - table.column notation
+      /^[a-z_][a-z0-9_]*\.[a-z_][a-z0-9_]*$/i,  // table.column
+      /\.[a-z_][a-z0-9_]*$/i,                    // .column_name
+      /^[a-z_][a-z0-9_]*\.[a-z_][a-z0-9_]*\s+(LIKE|=|>|<|!=|IS)/i, // SQL conditions
+      /^[a-z_][a-z0-9_]*\.[a-z_][a-z0-9_]*\s+is\s+(null|not null)/i, // IS NULL checks
+
+      // SQL keywords
+      /^(SELECT|INSERT|UPDATE|DELETE|FROM|WHERE|AND|OR|JOIN|ON|AS|LIKE|IN|NOT|IS|NULL)\s/i,
+      /\s+(is null|is not null)$/i,  // NULL checks
+
+      // TypeScript typeof checks
+      /^(string|number|boolean|object|function|symbol|bigint|undefined)$/,
+
+      // Common file extensions
+      /^\.[a-z]{2,4}$/i,
+
+      // HTTP methods and REST paths
+      /^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)$/i,
+      /^\/[a-z0-9\-_\/]*$/i,  // URL paths: /api/users, /search
+
+      // Event names (kebab-case or camelCase with common prefixes)
+      /^(on|handle|click|change|submit|load|error|success)/i,
+      /-activity$/i,
+      /-service$/i,
+      /-handler$/i,
+      /-event$/i,
+
+      // Status codes (lowercase or kebab-case only, not SCREAMING_CASE)
+      /^(pending|active|inactive|completed|failed|success|error)$/i,
+      /^[a-z]+(-[a-z]+)*$/,  // kebab-case only
+
+      // Common paths
+      /^[\.\/]/,
+
+      // Variable interpolation
+      /\$\{.*\}/,
+
+      // Error messages (human-readable sentences with spaces)
+      /^[A-Z][a-z]+\s+.+/,  // "User not found", "Invalid parameter" (must have space and more text)
+      /Exception$/,
+      /Error$/,
+
+      // SQL parameter placeholders
+      /^:[a-zA-Z_][a-zA-Z0-9_]*$/,  // :empNo, :userId
+      /^@[a-zA-Z_][a-zA-Z0-9_]*$/,  // @param, @userId
+    ];
+
+    // === Minimum thresholds ===
+    this.minStringLength = 4;      // Strings shorter than this are ignored (but 4+ should be checked)
+    this.minNumberValue = 1000;    // Numbers less than this need more context
+    this.minOccurrences = 2;       // Need to appear at least this many times
   }
 
   async initialize(semanticEngine = null) {
@@ -43,32 +165,39 @@ class C024SymbolBasedAnalyzer {
       return violations;
     }
 
+    if (this.shouldIgnoreFile(filePath)) {
+      if (verbose) console.log(`[${this.ruleId}] Ignoring ${filePath}`);
+      return violations;
+    }
+
     if (verbose) {
       console.log(`🔍 [C024 Symbol-Based] Starting analysis for ${filePath}`);
     }
 
     try {
-      // skip ignored files
-      if (this.isIgnoredFile(filePath)) {
+      const sourceFile = this.semanticEngine.project.getSourceFile(filePath);
+      if (!sourceFile) {
         if (verbose) {
-          console.log(`🔍 [C024 Symbol-Based] Skipping ignored file: ${filePath}`);
+          console.log(`⚠️  [C024] Could not load source file: ${filePath}`);
         }
         return violations;
       }
 
-      const sourceFile = this.semanticEngine.project.getSourceFile(filePath);
-      if (!sourceFile) {
-        return violations;
-      }
+      // Track constants to find duplicates
+      const constantUsage = new Map(); // value -> [locations]
 
-      // skip constants files
-      if (this.isConstantsFile(filePath)) return violations;
-      // Detect hardcoded constants
-      sourceFile.forEachDescendant((node) => {
-        this.checkLiterals(node, sourceFile, violations);
-        this.checkConstDeclaration(node, sourceFile, violations);
-        this.checkStaticReadonly(node, sourceFile, violations);
-      });
+      // Find all numeric literals in logic
+      this.checkNumericLiterals(sourceFile, violations, constantUsage);
+
+      // Find all string literals in logic
+      this.checkStringLiterals(sourceFile, violations, constantUsage);
+
+      // Check for duplicate constants (same value used multiple times)
+      this.checkDuplicateConstants(constantUsage, sourceFile, violations);
+
+      if (verbose) {
+        console.log(`✅ [C024] Found ${violations.length} violations in ${filePath}`);
+      }
 
 
       if (verbose) {
@@ -85,202 +214,415 @@ class C024SymbolBasedAnalyzer {
     }
   }
 
-  // --- push violation object ---
-  pushViolation(violations, node, filePath, text, message) {
-    violations.push({
+  createViolation(node, sourceFile, message, type, value) {
+    return {
       ruleId: this.ruleId,
-      severity: "warning",
-      message: message || `Hardcoded constant found: "${text}"`,
+      severity: 'medium',
+      message: message,
       source: this.ruleId,
-      file: filePath,
+      file: sourceFile.getFilePath(),
       line: node.getStartLineNumber(),
-      column: node.getStart() - node.getStartLinePos(),
+      column: node.getStart() - node.getStartLinePos() + 1,
       description:
         "[SYMBOL-BASED] Hardcoded constants should be defined in a single place to improve maintainability.",
-      suggestion: "Define constants in a dedicated file or section",
-      category: "constants",
+      category: "maintainability",
+      suggestion: `Define the ${type} '${value}' in a dedicated constants file or section`,
+    };
+  }
+
+  checkNumericLiterals(sourceFile, violations, constantUsage) {
+    const numericLiterals = sourceFile.getDescendantsOfKind(SyntaxKind.NumericLiteral);
+
+    numericLiterals.forEach(literal => {
+      const value = literal.getLiteralValue();
+      const text = literal.getText();
+
+      // Skip safe numbers
+      if (this.safeNumbers.has(value)) {
+        return;
+      }
+
+      // Skip if in acceptable context (enum, const declaration, etc.)
+      if (this.isInAcceptableContext(literal)) {
+        return;
+      }
+
+      // Skip if it's an array index or simple loop counter
+      if (this.isArrayIndexOrLoopCounter(literal)) {
+        return;
+      }
+
+      // Track for duplicate detection
+      this.trackConstant(constantUsage, `number:${value}`, literal);
+
+      // Flag as magic number if value is significant
+      if (Math.abs(value) >= this.minNumberValue || this.isLikelyMagicNumber(literal)) {
+        violations.push(this.createViolation(
+          literal,
+          sourceFile,
+          `Magic number '${text}' should be extracted as a named constant`,
+          'magic-number',
+          value
+        ));
+      }
     });
   }
 
-  // --- check literals like "ADMIN", 123, true ---
-  checkLiterals(node, sourceFile, violations) {
-    const kind = node.getKind();
-    if (
-      kind === SyntaxKind.StringLiteral ||
-      kind === SyntaxKind.NumericLiteral
-    ) {
-      const text = node.getText().replace(/['"`]/g, ""); // strip quotes
-      if (this.isAllowedLiteral(node, text)) return;
-
-      this.pushViolation(
-        violations,
-        node,
-        sourceFile.getFilePath(),
-        node.getText()
-      );
-    }
+  checkStringLiterals(sourceFile, violations, constantUsage) {
+    const stringLiterals = sourceFile.getDescendantsOfKind(SyntaxKind.StringLiteral);
+
+    stringLiterals.forEach(literal => {
+      const value = literal.getLiteralValue();
+      const text = literal.getText();
+
+      // Skip short strings
+      if (value.length < this.minStringLength) {
+        return;
+      }
+
+      // Skip acceptable string patterns
+      if (this.isAcceptableString(value)) {
+        return;
+      }
+
+      // Skip if in acceptable context
+      if (this.isInAcceptableContext(literal)) {
+        return;
+      }
+
+      // Skip if it's a property key or object key
+      if (this.isPropertyKey(literal)) {
+        return;
+      }
+
+      // Skip if it's in a QueryBuilder pattern
+      if (this.isQueryBuilderPattern(literal)) {
+        return;
+      }
+
+      // Skip template literals that are mostly variables
+      if (this.isTemplateWithVariables(literal)) {
+        return;
+      }
+
+      // Track for duplicate detection
+      this.trackConstant(constantUsage, `string:${value}`, literal);
+
+      // Flag as magic string if it's in logic
+      if (this.isInLogicContext(literal) || this.isInComparison(literal)) {
+        violations.push(this.createViolation(
+          literal,
+          sourceFile,
+          `Magic string '${this.truncate(value, 50)}' should be extracted as a named constant`,
+          'magic-string',
+          value
+        ));
+      }
+    });
   }
 
-  // --- check const declarations outside constants.ts ---
-  checkConstDeclaration(node, sourceFile, violations) {
-    const kind = node.getKind();
-    if (kind === SyntaxKind.VariableDeclaration) {
-      const parentKind = node.getParent()?.getKind();
-      // Skip detection for `for ... of` loop variable
-      const loopAncestor = node.getFirstAncestor((ancestor) => {
-        const kind = ancestor.getKind?.();
-        return (
-          kind === SyntaxKind.ForOfStatement ||
-          kind === SyntaxKind.ForInStatement ||
-          kind === SyntaxKind.ForStatement ||
-          kind === SyntaxKind.WhileStatement ||
-          kind === SyntaxKind.DoStatement ||
-          kind === SyntaxKind.SwitchStatement
-        );
-      });
-
-      if (loopAncestor) {
-        return; // skip for all loop/switch contexts, no matter how nested
-      }
-
-      if (
-        parentKind === SyntaxKind.VariableDeclarationList &&
-        node.getParent().getDeclarationKind() === "const" &&
-        !node.getInitializer()
-      ) {
-        this.pushViolation(
-          violations,
-          node,
-          sourceFile.getFilePath(),
-          node.getName(),
-          `Const declaration "${node.getName()}" should be moved into constants file`
+  checkDuplicateConstants(constantUsage, sourceFile, violations) {
+    for (const [key, locations] of constantUsage.entries()) {
+      if (locations.length >= this.minOccurrences) {
+        const [type, value] = key.split(':', 2);
+        const firstLocation = locations[0];
+
+        // Only flag if not already flagged as magic number/string
+        const alreadyFlagged = violations.some(v =>
+          v.line === firstLocation.getStartLineNumber() &&
+          v.column === firstLocation.getStart() - firstLocation.getStartLinePos() + 1
         );
+
+        if (!alreadyFlagged) {
+          violations.push(this.createViolation(
+            firstLocation,
+            sourceFile,
+            `Duplicate constant '${this.truncate(value, 50)}' used ${locations.length} times. Extract to a named constant.`,
+            'duplicate-constant',
+            value
+          ));
+        }
       }
     }
   }
 
-  // --- check static readonly properties inside classes ---
-  checkStaticReadonly(node, sourceFile, violations) {
-    const kind = node.getKind();
-    if (kind === SyntaxKind.PropertyDeclaration) {
-      const modifiers = node.getModifiers().map((m) => m.getText());
-      if (modifiers.includes("static") && modifiers.includes("readonly")) {
-        this.pushViolation(
-          violations,
-          node,
-          sourceFile.getFilePath(),
-          node.getName(),
-          `Static readonly property "${node.getName()}" should be moved into constants file`
-        );
+  isInAcceptableContext(node) {
+    let parent = node.getParent();
+    let depth = 0;
+    const maxDepth = 5;
+
+    while (parent && depth < maxDepth) {
+      const kind = parent.getKind();
+
+      // Top-level const declaration
+      if (kind === SyntaxKind.VariableDeclaration) {
+        const varDecl = parent;
+        const varStatement = varDecl.getParent()?.getParent();
+        if (varStatement && varStatement.getKind() === SyntaxKind.VariableStatement) {
+          const isConst = varStatement.getDeclarationKind() === 'const';
+          const isTopLevel = varStatement.getParent()?.getKind() === SyntaxKind.SourceFile;
+
+          // Allow const declarations (top-level or in functions)
+          if (isConst) {
+            return true;
+          }
+        }
+      }
+
+      // Enum, interface, type alias
+      if (this.acceptableContexts.includes(kind)) {
+        return true;
+      }
+
+      // Object literal that's assigned to a const
+      if (kind === SyntaxKind.ObjectLiteralExpression) {
+        const objectParent = parent.getParent();
+        if (objectParent?.getKind() === SyntaxKind.VariableDeclaration) {
+          return true;
+        }
+      }
+
+      // Array literal assigned to a const (for SQL columns, etc.)
+      if (kind === SyntaxKind.ArrayLiteralExpression) {
+        const arrayParent = parent.getParent();
+        if (arrayParent?.getKind() === SyntaxKind.VariableDeclaration) {
+          return true;
+        }
+      }
+
+      // Decorator arguments (NestJS @Post('search'), @Param('id'))
+      if (kind === SyntaxKind.Decorator) {
+        return true;
+      }
+
+      // Call expression arguments for decorators
+      if (kind === SyntaxKind.CallExpression) {
+        const callParent = parent.getParent();
+        if (callParent?.getKind() === SyntaxKind.Decorator) {
+          return true;
+        }
+      }
+
+      // TypeOf expression (typeof x === 'string')
+      if (kind === SyntaxKind.TypeOfExpression) {
+        return true;
       }
+
+      // Binary expression with typeof
+      if (kind === SyntaxKind.BinaryExpression) {
+        const binaryExpr = parent;
+        const left = binaryExpr.getLeft();
+        if (left.getKind() === SyntaxKind.TypeOfExpression) {
+          return true;
+        }
+      }
+
+      parent = parent.getParent();
+      depth++;
     }
+
+    return false;
   }
 
-  // --- helper: allow safe literals ---
-  isAllowedLiteral(node, text) {
+  isArrayIndexOrLoopCounter(node) {
     const parent = node.getParent();
+    if (!parent) return false;
 
-    // 1 Skip imports/exports
-    if (parent?.getKind() === SyntaxKind.ImportDeclaration) return true;
-    if (parent?.getKind() === SyntaxKind.ExportDeclaration) return true;
+    const kind = parent.getKind();
 
-    // 2 Skip literals that are inside call expressions (direct or nested)
-    if (
-      parent?.getKind() === SyntaxKind.CallExpression ||
-      parent?.getFirstAncestorByKind(SyntaxKind.CallExpression)
-    ) {
+    // Array element access: arr[0], arr[1]
+    if (kind === SyntaxKind.ElementAccessExpression) {
       return true;
     }
 
-    if (
-      parent?.getKind() === SyntaxKind.ElementAccessExpression &&
-      parent.getArgumentExpression?.() === node
-    ) {
-      return true; // skip array/object key
+    // Loop increment: i++, i += 1
+    if (kind === SyntaxKind.BinaryExpression ||
+        kind === SyntaxKind.PostfixUnaryExpression ||
+        kind === SyntaxKind.PrefixUnaryExpression) {
+      return true;
     }
 
-    // 3 Allow short strings
-    if (typeof text === "string" && text.length <= 1) return true;
+    return false;
+  }
 
-    // 4 Allow sentinel numbers
-    if (text === "0" || text === "1" || text === "-1") return true;
+  isLikelyMagicNumber(node) {
+    const parent = node.getParent();
+    if (!parent) return false;
+
+    // Numbers in comparisons are often magic numbers
+    if (parent.getKind() === SyntaxKind.BinaryExpression) {
+      const binaryExpr = parent;
+      const operator = binaryExpr.getOperatorToken().getText();
+      if (['>', '<', '>=', '<=', '===', '!==', '==', '!='].includes(operator)) {
+        return true;
+      }
+    }
 
-    // 5 Allow known safe strings (like "UNKNOWN")
-    if (this.safeStrings.includes(text)) return true;
+    // Numbers in calculations
+    if (parent.getKind() === SyntaxKind.BinaryExpression) {
+      const binaryExpr = parent;
+      const operator = binaryExpr.getOperatorToken().getText();
+      if (['*', '/', '%'].includes(operator)) {
+        return true;
+      }
+    }
 
-    // 6 Allow SQL-style placeholders (:variable) inside string/template
-    if (typeof text === "string" && /:\w+/.test(text)) {
+    return false;
+  }
+
+  isAcceptableString(value) {
+    return this.acceptableStringPatterns.some(pattern => pattern.test(value));
+  }
+
+  isPropertyKey(node) {
+    const parent = node.getParent();
+    if (!parent) return false;
+
+    // Object property key
+    if (parent.getKind() === SyntaxKind.PropertyAssignment) {
+      const prop = parent;
+      return prop.getInitializer() !== node;
+    }
+
+    // Dot notation property access
+    if (parent.getKind() === SyntaxKind.PropertyAccessExpression) {
       return true;
     }
 
+    // Parameter decorator name: @Param('cm_cst_id')
+    if (parent.getKind() === SyntaxKind.CallExpression) {
+      const callParent = parent.getParent();
+      if (callParent?.getKind() === SyntaxKind.Decorator) {
+        return true;
+      }
+    }
+
     return false;
   }
 
-  // helper to check if file is a constants file
-  isConstantsFile(filePath) {
-    const lower = filePath.toLowerCase();
-
-    // common suffixes/patterns for utility or structural files
-    const ignoredSuffixes = [
-      ".constants.ts",
-      ".const.ts",
-      ".enum.ts",
-      ".interface.ts",
-      ".response.ts",
-      ".request.ts",
-      ".res.ts",
-      ".req.ts",
-    ];
+  isQueryBuilderPattern(node) {
+    let parent = node.getParent();
+    let depth = 0;
+    const maxDepth = 5;
 
-    // 1 direct suffix match
-    if (ignoredSuffixes.some(suffix => lower.endsWith(suffix))) {
-      return true;
+    // Walk up the tree to find if we're in a QueryBuilder call
+    while (parent && depth < maxDepth) {
+      const kind = parent.getKind();
+
+      // Check if part of a call expression
+      if (kind === SyntaxKind.CallExpression) {
+        const callExpr = parent;
+        const expression = callExpr.getExpression();
+        const exprText = expression.getText();
+
+        // QueryBuilder methods: .where(), .andWhere(), .orWhere(), etc.
+        if (/\.(where|andWhere|orWhere|having|andHaving|orHaving|select|addSelect|leftJoin|innerJoin|join|orderBy|groupBy|setParameter)$/i.test(exprText)) {
+          return true;
+        }
+
+        // Also check for common ORM query builders
+        if (/(queryBuilder|qb|query)\.(where|andWhere|orWhere)/i.test(exprText)) {
+          return true;
+        }
+      }
+
+      // Skip through conditional expressions (ternary operators)
+      if (kind === SyntaxKind.ConditionalExpression) {
+        parent = parent.getParent();
+        depth++;
+        continue;
+      }
+
+      parent = parent.getParent();
+      depth++;
     }
 
-    // 2 matches dto.xxx.ts (multi-dot dto files)
-    if (/\.dto\.[^.]+\.ts$/.test(lower)) {
+    return false;
+  }
+
+  isTemplateWithVariables(node) {
+    const parent = node.getParent();
+    if (!parent) return false;
+
+    if (parent.getKind() === SyntaxKind.TemplateExpression) {
       return true;
     }
 
-    // 3 matches folder-based conventions
-    if (
-      lower.includes("/constants/") ||
-      lower.includes("/enums/") ||
-      lower.includes("/interfaces/")
-    ) {
+    return false;
+  }
+
+  isInLogicContext(node) {
+    let parent = node.getParent();
+    let depth = 0;
+    const maxDepth = 5;
+
+    while (parent && depth < maxDepth) {
+      const kind = parent.getKind();
+      // Skip when part of an element access chain like arr['key1']['key2']
+      // Walk up any nested ElementAccessExpression hierarchy
+      if (kind === SyntaxKind.ElementAccessExpression) {
+        return false; // skip, this is not a logic context — it's array/object access
+      }
+
+      // Inside function body, method, arrow function
+      if (kind === SyntaxKind.FunctionDeclaration ||
+          kind === SyntaxKind.MethodDeclaration ||
+          kind === SyntaxKind.ArrowFunction ||
+          kind === SyntaxKind.FunctionExpression) {
+        return true;
+      }
+
+      // Inside if statement, switch, loop
+      if (kind === SyntaxKind.IfStatement ||
+          kind === SyntaxKind.SwitchStatement ||
+          kind === SyntaxKind.ForStatement ||
+          kind === SyntaxKind.WhileStatement ||
+          kind === SyntaxKind.DoStatement) {
+        return true;
+      }
+
+      parent = parent.getParent();
+      depth++;
+    }
+
+    return false;
+  }
+
+  isInComparison(node) {
+    const parent = node.getParent();
+    if (!parent) return false;
+
+    // Direct comparison: if (type === 'GOLD')
+    if (parent.getKind() === SyntaxKind.BinaryExpression) {
+      const binaryExpr = parent;
+      const operator = binaryExpr.getOperatorToken().getText();
+      if (['===', '!==', '==', '!=', '>', '<', '>=', '<='].includes(operator)) {
+        return true;
+      }
+    }
+
+    // Case clause: case 'GOLD':
+    if (parent.getKind() === SyntaxKind.CaseClause) {
       return true;
     }
 
     return false;
   }
 
+  trackConstant(constantUsage, key, node) {
+    if (!constantUsage.has(key)) {
+      constantUsage.set(key, []);
+    }
+    constantUsage.get(key).push(node);
+  }
 
-  isIgnoredFile(filePath) {
-    const ignoredPatterns = [
-      /\.test\./i,
-      /\.tests\./i,
-      /\.spec\./i,
-      /\.mock\./i,
-      /\.css$/i,
-      /\.scss$/i,
-      /\.html$/i,
-      /\.json$/i,
-      /\.md$/i,
-      /\.svg$/i,
-      /\.png$/i,
-      /\.jpg$/i,
-      /\.jpeg$/i,
-      /\.gif$/i,
-      /\.bmp$/i,
-      /\.ico$/i,
-      /\.lock$/i,
-      /\.log$/i,
-      /\/test\//i,
-      /\/tests\//i,
-      /\/spec\//i
-    ];
+  truncate(str, maxLength) {
+    if (str.length <= maxLength) return str;
+    return str.substring(0, maxLength) + '...';
+  }
 
-    return ignoredPatterns.some((regex) => regex.test(filePath));
+  shouldIgnoreFile(filePath) {
+    return this.ignoredFilePatterns.some((pattern) => pattern.test(filePath));
   }
 }