@sun-asterisk/sunlint 1.3.0 → 1.3.2

package/rules/common/C014_dependency_injection/analyzer.js

@@ -1,338 +1,73 @@
-const fs = require('fs');
-const path = require('path');
+const C014SymbolBasedAnalyzer = require('./symbol-based-analyzer.js');
 
 class C014Analyzer {
-  constructor() {
+  constructor(semanticEngine = null) {
     this.ruleId = 'C014';
     this.ruleName = 'Dependency Injection Pattern';
-    this.description = 'Dùng Dependency Injection thay vì new trực tiếp trong logic';
-  }
-
-  async analyze(files, language, options = {}) {
-    const violations = [];
-    
-    for (const filePath of files) {
-      if (options.verbose) {
-        console.log(`🔍 Running C014 analysis on ${path.basename(filePath)}`);
-      }
-      
-      try {
-        const content = fs.readFileSync(filePath, 'utf8');
-        const fileViolations = await this.analyzeFile(filePath, content, language, options);
-        violations.push(...fileViolations);
-      } catch (error) {
-        console.warn(`⚠️ Failed to analyze ${filePath}: ${error.message}`);
-      }
-    }
+    this.description = 'Use Dependency Injection instead of direct instantiation in business logic';
+    this.semanticEngine = semanticEngine;
+    this.verbose = false;
     
-    return violations;
+    // Use symbol-based only for accuracy
+    this.symbolAnalyzer = new C014SymbolBasedAnalyzer(semanticEngine);
   }
 
-  async analyzeFile(filePath, content, language, config) {
-    switch (language) {
-      case 'typescript':
-      case 'javascript':
-        return this.analyzeTypeScript(filePath, content, config);
-      default:
-        return [];
+  async initialize(semanticEngine = null) {
+    if (semanticEngine) {
+      this.semanticEngine = semanticEngine;
     }
+    this.verbose = semanticEngine?.verbose || false;
+    await this.symbolAnalyzer.initialize(semanticEngine);
   }
 
-  async analyzeTypeScript(filePath, content, config) {
-    const violations = [];
-    const lines = content.split('\n');
-
-    lines.forEach((line, index) => {
-      const lineNumber = index + 1;
-      const trimmedLine = line.trim();
-
-      // Skip comments and imports
-      if (this.isCommentOrImport(trimmedLine)) {
-        return;
-      }
-
-      // Find new expressions
-      const newExpressions = this.findNewExpressions(trimmedLine, line);
-      
-      newExpressions.forEach(expr => {
-        if (this.shouldFlag(expr.className, line, filePath)) {
-          violations.push({
-            ruleId: this.ruleId,
-            file: filePath,
-            line: lineNumber,
-            column: expr.column,
-            message: `Avoid direct instantiation of '${expr.className}'. Use dependency injection or factory pattern instead`,
-            severity: 'warning',
-            code: trimmedLine,
-            type: 'direct_instantiation',
-            confidence: expr.confidence,
-            suggestion: `Consider injecting ${expr.className} as a dependency or using a factory`
-          });
+  async analyzeFileBasic(filePath, options = {}) {
+    try {
+      // Check if symbol engine is ready
+      if (!this.semanticEngine?.isSymbolEngineReady?.() || !this.semanticEngine.project) {
+        const errorMsg = 'Symbol engine required for C014 analysis - consider enabling semantic analysis';
+        if (this.verbose) {
+          console.log(`[DEBUG] ❌ C014: ${errorMsg} for ${filePath.split('/').pop()}`);
         }
-      });
-    });
-
-    return violations;
-  }
-
-  isCommentOrImport(line) {
-    const trimmed = line.trim();
-    return trimmed.startsWith('//') || 
-           trimmed.startsWith('/*') || 
-           trimmed.startsWith('*') ||
-           trimmed.startsWith('import ') ||
-           trimmed.startsWith('export ');
-  }
+        throw new Error(errorMsg);
+      }
 
-  findNewExpressions(line, originalLine) {
-    const expressions = [];
-    const regex = /\bnew\s+([A-Z][a-zA-Z0-9_]*)\s*\(/g;
-    
-    let match;
-    while ((match = regex.exec(line)) !== null) {
-      expressions.push({
-        className: match[1],
-        column: match.index + 1,
-        confidence: this.calculateConfidence(match[1], line)
-      });
-    }
-    
-    return expressions;
-  }
+      if (this.verbose) {
+        console.log(`[DEBUG] 🎯 C014: Using symbol-based analysis for ${filePath.split('/').pop()}`);
+      }
 
-  shouldFlag(className, line, filePath) {
-    // Don't flag built-in JavaScript/TypeScript classes and common patterns
-    const allowedClasses = [
-      // Built-in JavaScript classes
-      'Date', 'Array', 'Object', 'String', 'Number', 'Boolean', 'RegExp',
-      'Map', 'Set', 'WeakMap', 'WeakSet', 'Promise', 'Error', 'TypeError', 
-      'RangeError', 'SyntaxError', 'ReferenceError', 'EvalError', 'URIError',
-      'Function', 'Symbol', 'BigInt', 'ArrayBuffer', 'DataView',
-      'Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array', 'Uint16Array',
-      'Int32Array', 'Uint32Array', 'Float32Array', 'Float64Array',
-      
-      // DOM classes (Frontend)
-      'FormData', 'Headers', 'Request', 'Response', 'URLSearchParams', 
-      'URL', 'Blob', 'File', 'FileReader', 'Image', 'Audio', 'Video',
-      'XMLHttpRequest', 'WebSocket', 'Worker', 'MessageChannel',
-      'MutationObserver', 'ResizeObserver', 'IntersectionObserver',
-      'AbortController', 'CustomEvent', 'Event', 'ErrorEvent',
-      
-      // Node.js classes
-      'Buffer', 'URL', 'URLSearchParams', 'ReadableStream', 'WritableStream',
+      const violations = await this.symbolAnalyzer.analyzeFileBasic(filePath, options);
       
-      // React/Next.js common patterns
-      'NextResponse', 'Response', 'Headers', 'FormData',
-      
-      // Common library classes that are okay to instantiate directly
-      'Axios', 'HttpClient', 'Logger', 'Configuration', 'Config', 'AppConfig', 'UserSettings',
-      'AppConfiguration', 'SystemLogger', 'Cache', 'Monitor', 'Connection', 'DatabaseConfig'
-    ];
-
-    if (allowedClasses.includes(className)) {
-      return false;
-    }
-
-    // Don't flag if it's clearly for testing
-    if (this.isTestContext(line, filePath)) {
-      return false;
-    }
-
-    // Don't flag if it's in React hooks or state management
-    if (this.isReactHookContext(line)) {
-      return false;
-    }
-
-    // Don't flag if it's in a factory pattern or builder pattern
-    if (this.isFactoryOrBuilderPattern(line)) {
-      return false;
-    }
-
-    // Don't flag if it's a utility class or static helper
-    if (this.isUtilityClass(className, line)) {
-      return false;
-    }
-
-    // Don't flag if it's in constructor or initialization context
-    if (this.isConstructorOrInitContext(line)) {
-      return false;
-    }
-
-    // Don't flag if it's immediate usage pattern (e.g., new Date().getTime())
-    if (this.isImmediateUsagePattern(line)) {
-      return false;
-    }
-
-    return true;
-  }
-
-  isTestContext(line, filePath) {
-    // Check if file is a test file
-    const testPatterns = ['.test.', '.spec.', '__tests__', '/tests/'];
-    const isTestFile = testPatterns.some(pattern => filePath.includes(pattern));
-    
-    if (isTestFile) {
-      return true;
-    }
-
-    // Check if line contains test-related keywords - use word boundaries to avoid false matches
-    const testKeywords = ['test', 'describe', 'expect', 'mock', 'spy', 'stub'];
-    const lowerLine = line.toLowerCase();
-    
-    // Use word boundaries to avoid false positives like "Repository" containing "it"
-    const hasTestKeywords = testKeywords.some(keyword => {
-      const wordBoundaryRegex = new RegExp(`\\b${keyword}\\b`);
-      return wordBoundaryRegex.test(lowerLine);
-    });
-    
-    // Special case for "it" - only match as standalone word or in specific contexts
-    const hasItKeyword = /\bit\s*\(/.test(lowerLine); // it( function calls
-    
-    return hasTestKeywords || hasItKeyword;
-  }
-
-  isFactoryOrBuilderPattern(line) {
-    const lowerLine = line.toLowerCase();
-    const patterns = [
-      'factory',
-      'builder',
-      'create',
-      'build',
-      'make',
-      'construct',
-      'getinstance',
-      'newinstance',
-      '=> new',
-      'return new'
-    ];
-    
-    return patterns.some(pattern => lowerLine.includes(pattern));
-  }
+      if (this.verbose) {
+        console.log(`[DEBUG] 🎯 C014: Symbol-based analysis found ${violations.length} violations`);
+      }
 
-  isUtilityClass(className, line) {
-    // Common utility class patterns based on name - but exclude business logic handlers
-    const utilityPatterns = [
-      /Helper$/,
-      /Util$/,
-      /Utils$/,
-      /Manager$/,
-      /Processor$/,
-      /Validator$/,
-      /Parser$/,
-      /Formatter$/,
-      /Converter$/
-    ];
-    
-    // Business logic handlers should not be considered utilities
-    const businessLogicExceptions = [
-      'EventHandler',
-      'CommandHandler',
-      'RequestHandler',
-      'ActionHandler',
-      'MessageHandler',
-      'HttpHandler',
-      'ApiHandler'
-    ];
-    
-    if (businessLogicExceptions.includes(className)) {
-      return false; // These should be flagged as DI violations
-    }
-    
-    const isUtilityName = utilityPatterns.some(pattern => pattern.test(className));
-    
-    if (isUtilityName) {
-      return true;
+      return violations;
+    } catch (error) {
+      if (this.verbose) {
+        console.error(`[DEBUG] ❌ C014: Analysis failed: ${error.message}`);
+      }
+      throw new Error(`C014 analysis failed: ${error.message}`);
     }
-
-    // Check if it's used as return value (factory pattern)
-    const factoryContext = [
-      'return new',
-      'export new',
-      'export default new'
-    ];
-    
-    return factoryContext.some(context => line.includes(context));
-  }
-
-  isConstructorOrInitContext(line) {
-    const lowerLine = line.toLowerCase();
-    const patterns = [
-      'constructor',
-      'init',
-      'setup',
-      'configure',
-      'this.',
-      'super(',
-      'initialize'
-    ];
-    
-    return patterns.some(pattern => lowerLine.includes(pattern));
   }
 
-  isReactHookContext(line) {
-    // Check for React hooks patterns
-    const reactHookPatterns = [
-      'useState(',
-      'useEffect(',
-      'useMemo(',
-      'useCallback(',
-      'useRef(',
-      'useContext(',
-      'useReducer(',
-      'useImperativeHandle(',
-      'useLayoutEffect(',
-      'useDebugValue(',
-      // Custom hooks
-      'use[A-Z]'
-    ];
-    
-    return reactHookPatterns.some(pattern => {
-      if (pattern.includes('[A-Z]')) {
-        return new RegExp(pattern).test(line);
+  async analyzeFiles(files, options = {}) {
+    const allViolations = [];
+    for (const filePath of files) {
+      try {
+        const violations = await this.analyzeFileBasic(filePath, options);
+        allViolations.push(...violations);
+      } catch (error) {
+        console.warn(`C014: Skipping ${filePath}: ${error.message}`);
       }
-      return line.includes(pattern);
-    });
-  }
-
-  isImmediateUsagePattern(line) {
-    // Check for immediate usage patterns like new Date().getTime()
-    const immediatePatterns = [
-      /new\s+\w+\(\)\./, // new Date().getTime(), new Error().stack
-      /new\s+\w+\([^)]*\)\./, // new Date(value).getTime()
-      /window\.dispatchEvent\(new\s+/, // window.dispatchEvent(new Event())
-      /document\.dispatchEvent\(new\s+/, // document.dispatchEvent(new Event())
-    ];
-    
-    // Special case: standalone built-in class instantiation (not assignment)
-    const standaloneBuiltinPattern = /(?:^|\s|;)\s*new\s+(Date|Error|Array|Set|Map|Promise|RegExp|URL|FormData|Event|FileReader|XMLHttpRequest)\(\)\s*;?\s*$/;
-    if (standaloneBuiltinPattern.test(line)) {
-      return true;
     }
-    
-    return immediatePatterns.some(pattern => pattern.test(line));
+    return allViolations;
   }
 
-  calculateConfidence(className, line) {
-    let confidence = 0.7; // Base confidence
-    
-    // Increase confidence for business logic classes
-    if (className.includes('Service') || className.includes('Repository') || 
-        className.includes('Controller') || className.includes('Component')) {
-      confidence += 0.2;
-    }
-    
-    // Decrease confidence if in constructor or initialization context
-    if (line.includes('constructor') || line.includes('init') || line.includes('setup')) {
-      confidence -= 0.1;
-    }
-    
-    // Decrease confidence if it looks like configuration
-    if (line.includes('config') || line.includes('options') || line.includes('settings')) {
-      confidence -= 0.1;
-    }
-    
-    return Math.max(0.3, Math.min(1.0, confidence));
+  // Legacy method for backward compatibility
+  async analyze(files, language, options = {}) {
+    return this.analyzeFiles(files, options);
   }
+
 }
 
-module.exports = new C014Analyzer();
+module.exports = C014Analyzer;

package/rules/common/C014_dependency_injection/config.json

@@ -0,0 +1,26 @@
+{
+  "maxNestingLevel": 3,
+  "allowedBuiltins": [
+    "Date", "Array", "Object", "String", "Number", "Boolean", "RegExp",
+    "Map", "Set", "WeakMap", "WeakSet", "Promise", "Error", "TypeError",
+    "FormData", "Headers", "Request", "Response", "URLSearchParams",
+    "URL", "Blob", "File", "Buffer"
+  ],
+  "allowedValueObjects": [
+    "Money", "Price", "Currency", "Quantity", "Amount",
+    "Email", "Phone", "Address", "Name", "Id", "UserId",
+    "UUID", "Timestamp", "Duration", "Range"
+  ],
+  "infraPatterns": [
+    "Client", "Repository", "Service", "Gateway", "Adapter",
+    "Provider", "Factory", "Builder", "Manager", "Handler",
+    "Controller", "Processor", "Validator", "Logger"
+  ],
+  "excludePatterns": [
+    "**/*.test.ts", "**/*.spec.ts", "**/*.test.js", "**/*.spec.js",
+    "**/tests/**", "**/test/**", "**/migration/**", "**/scripts/**"
+  ],
+  "includePatterns": [
+    "**/*.js", "**/*.ts", "**/*.jsx", "**/*.tsx"
+  ]
+}