@sun-asterisk/sunlint 1.2.1 → 1.2.2

package/rules/common/C014_dependency_injection/analyzer.js

@@ -0,0 +1,338 @@
+const fs = require('fs');
+const path = require('path');
+
+class C014Analyzer {
+  constructor() {
+    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}`);
+      }
+    }
+    
+    return violations;
+  }
+
+  async analyzeFile(filePath, content, language, config) {
+    switch (language) {
+      case 'typescript':
+      case 'javascript':
+        return this.analyzeTypeScript(filePath, content, config);
+      default:
+        return [];
+    }
+  }
+
+  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`
+          });
+        }
+      });
+    });
+
+    return violations;
+  }
+
+  isCommentOrImport(line) {
+    const trimmed = line.trim();
+    return trimmed.startsWith('//') || 
+           trimmed.startsWith('/*') || 
+           trimmed.startsWith('*') ||
+           trimmed.startsWith('import ') ||
+           trimmed.startsWith('export ');
+  }
+
+  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;
+  }
+
+  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',
+      
+      // 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));
+  }
+
+  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;
+    }
+
+    // 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);
+      }
+      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));
+  }
+
+  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));
+  }
+}
+
+module.exports = new C014Analyzer();

package/rules/common/C017_constructor_logic/analyzer.js

@@ -0,0 +1,314 @@
+const fs = require('fs');
+const path = require('path');
+
+class C017Analyzer {
+  constructor() {
+    this.ruleId = 'C017';
+    this.ruleName = 'Constructor Logic Limitation';
+    this.description = 'Không gán logic xử lý vào constructor';
+  }
+
+  async analyze(files, language, options = {}) {
+    const violations = [];
+    
+    for (const filePath of files) {
+      if (options.verbose) {
+        console.log(`🔍 Running C017 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}`);
+      }
+    }
+    
+    return violations;
+  }
+
+  async analyzeFile(filePath, content, language, config) {
+    switch (language) {
+      case 'typescript':
+      case 'javascript':
+        return this.analyzeTypeScript(filePath, content, config);
+      default:
+        return [];
+    }
+  }
+
+  async analyzeTypeScript(filePath, content, config) {
+    const violations = [];
+    const lines = content.split('\n');
+    
+    // Find constructor blocks and analyze their content
+    lines.forEach((line, index) => {
+      const lineNumber = index + 1;
+      const trimmedLine = line.trim();
+
+      // Detect constructor start
+      if (this.isConstructorStart(trimmedLine)) {
+        const constructorInfo = this.extractConstructorInfo(lines, index);
+        
+        const complexLogic = this.findComplexLogic(constructorInfo.body);
+        
+        complexLogic.forEach(logic => {
+          violations.push({
+            ruleId: this.ruleId,
+            file: filePath,
+            line: lineNumber + logic.lineOffset,
+            column: logic.column,
+            message: `Constructor contains complex logic: ${logic.description}. Move to initialization methods`,
+            severity: 'warning',
+            code: logic.code,
+            type: logic.type,
+            confidence: logic.confidence,
+            suggestion: 'Move complex logic to separate initialization methods or lifecycle hooks'
+          });
+        });
+      }
+    });
+
+    return violations;
+  }
+
+  isConstructorStart(line) {
+    return line.includes('constructor(') || line.match(/constructor\s*\(/);
+  }
+
+  extractConstructorInfo(lines, startIndex) {
+    const constructorLines = [];
+    let braceDepth = 0;
+    let foundConstructorBrace = false;
+
+    for (let i = startIndex; i < lines.length; i++) {
+      const line = lines[i];
+      constructorLines.push(line);
+      
+      // Check if this is the constructor line with opening brace
+      if (this.isConstructorStart(line.trim())) {
+        // Count braces in the constructor line itself
+        for (const char of line) {
+          if (char === '{') {
+            foundConstructorBrace = true;
+            braceDepth = 1; // Start counting from 1 for the constructor block
+          }
+        }
+      } else if (foundConstructorBrace) {
+        // Count braces in subsequent lines
+        for (const char of line) {
+          if (char === '{') {
+            braceDepth++;
+          } else if (char === '}') {
+            braceDepth--;
+          }
+        }
+        
+        // If we've closed all braces, we're done
+        if (braceDepth === 0) {
+          break;
+        }
+      }
+    }
+
+    return {
+      body: constructorLines,
+      startLine: startIndex
+    };
+  }
+
+  findComplexLogic(constructorBody) {
+    const complexLogic = [];
+    
+    constructorBody.forEach((line, index) => {
+      const trimmedLine = line.trim();
+      
+      // Skip comments, empty lines, and constructor declaration
+      if (!trimmedLine || 
+          trimmedLine.startsWith('//') || 
+          trimmedLine.startsWith('/*') ||
+          trimmedLine.startsWith('*') ||
+          this.isConstructorStart(trimmedLine) ||
+          trimmedLine === '{' ||
+          trimmedLine === '}') {
+        return;
+      }
+
+      // Analyze line for complex logic patterns
+      const logicType = this.analyzeLineComplexity(trimmedLine);
+      
+      if (logicType) {
+        complexLogic.push({
+          lineOffset: index,
+          column: line.indexOf(trimmedLine) + 1,
+          code: trimmedLine,
+          type: logicType.type,
+          description: logicType.description,
+          confidence: logicType.confidence
+        });
+      }
+    });
+
+    return complexLogic;
+  }
+
+  analyzeLineComplexity(line) {
+    // Simple property assignments are OK
+    if (this.isSimpleAssignment(line)) {
+      return null;
+    }
+
+    // Super calls are OK
+    if (this.isSuperCall(line)) {
+      return null;
+    }
+
+    // Parameter assignments are OK
+    if (this.isParameterAssignment(line)) {
+      return null;
+    }
+
+    // MobX decorators/observables setup are OK
+    if (this.isMobXSetup(line)) {
+      return null;
+    }
+
+    // Allowed method calls are OK
+    if (this.isAllowedMethodCall(line)) {
+      return null;
+    }
+
+    // Detect complex logic patterns
+    const complexPatterns = [
+      {
+        pattern: /\bif\s*\(|\belse\s|\bswitch\s*\(/,
+        type: 'conditional_logic',
+        description: 'conditional statements (if/else/switch)',
+        confidence: 0.9
+      },
+      {
+        pattern: /\bfor\s*\(|\bwhile\s*\(|\bdo\s+/,
+        type: 'loop_logic',
+        description: 'loops (for/while)',
+        confidence: 0.95
+      },
+      {
+        pattern: /\btry\s*{|\bcatch\s*\(|\bfinally\s*{/,
+        type: 'exception_handling',
+        description: 'exception handling (try/catch/finally)',
+        confidence: 0.8
+      },
+      {
+        pattern: /\.then\s*\(|\.catch\s*\(|await\s+/,
+        type: 'async_logic',
+        description: 'asynchronous operations',
+        confidence: 0.9
+      },
+      {
+        pattern: /\w+\s*\(\s*[^)]*\)\s*[;{]/,
+        type: 'method_call',
+        description: 'complex method calls',
+        confidence: 0.6 // Lower confidence, only flag complex calls
+      },
+      {
+        pattern: /new\s+\w+\s*\([^)]*\)\s*\./,
+        type: 'chained_instantiation',
+        description: 'chained object instantiation',
+        confidence: 0.8
+      }
+    ];
+
+    for (const { pattern, type, description, confidence } of complexPatterns) {
+      if (pattern.test(line)) {
+        return { type, description, confidence };
+      }
+    }
+
+    // Check for complex expressions
+    if (this.hasComplexExpression(line)) {
+      return {
+        type: 'complex_expression',
+        description: 'complex expression or calculation',
+        confidence: 0.6
+      };
+    }
+
+    return null;
+  }
+
+  isSimpleAssignment(line) {
+    // Patterns for simple assignments
+    const simplePatterns = [
+      /^this\.\w+\s*=\s*[^;]+;?$/,          // this.property = value;
+      /^this\.\w+\s*=\s*\w+;?$/,            // this.property = parameter;
+      /^this\.\w+\s*=\s*(null|undefined|true|false|\d+|'[^']*'|"[^"]*");?$/, // this.property = literal;
+    ];
+
+    return simplePatterns.some(pattern => pattern.test(line));
+  }
+
+  isSuperCall(line) {
+    return line.includes('super(') || line.startsWith('super.');
+  }
+
+  isParameterAssignment(line) {
+    // Check if it's just assigning constructor parameters to properties
+    return /^this\.\w+\s*=\s*\w+;?$/.test(line);
+  }
+
+  isMobXSetup(line) {
+    // MobX patterns that are OK in constructor
+    const mobxPatterns = [
+      'makeObservable',
+      'makeAutoObservable',
+      'observable',
+      'action',
+      'computed',
+      'reaction',
+      'autorun',
+      '@observable',
+      '@action',
+      '@computed'
+    ];
+
+    const lowerLine = line.toLowerCase();
+    return mobxPatterns.some(pattern => 
+      lowerLine.includes(pattern.toLowerCase())
+    );
+  }
+
+  isAllowedMethodCall(line) {
+    // Method calls that are typically OK in constructors
+    const allowedMethods = [
+      'makeObservable',
+      'makeAutoObservable',
+      'bind',
+      'addEventListener',
+      'removeEventListener',
+      'Object.assign',
+      'Object.defineProperty',
+      'console.log',
+      'console.warn'
+    ];
+
+    return allowedMethods.some(method => 
+      line.includes(method)
+    );
+  }
+
+  hasComplexExpression(line) {
+    // Check for complex expressions (multiple operators, complex calculations)
+    const complexityIndicators = [
+      /[+\-*/]\s*[+\-*/]/,    // Multiple arithmetic operators
+      /\?\s*.*\s*:/,          // Ternary operators
+      /&&|\|\|/,              // Logical operators
+      /\[[^\]]*\]/,           // Array access
+      /\.[^.]*\./             // Chained property access
+    ];
+
+    return complexityIndicators.some(pattern => pattern.test(line));
+  }
+}
+
+module.exports = new C017Analyzer();