@sun-asterisk/sunlint 1.2.1 → 1.2.2

package/rules/common/C029_catch_block_logging/semantic-analyzer.js

@@ -0,0 +1,459 @@
+/**
+ * C029 Semantic Analyzer
+ * 
+ * Uses semantic analysis to understand the meaning and intent of error handling code
+ * Goes beyond syntax to understand developer intent and code semantics
+ * 
+ * Technology Showcase: Understanding code intent, not just structure
+ */
+
+class C029SemanticAnalyzer {
+  constructor() {
+    this.ruleId = 'C029';
+    this.ruleName = 'Semantic Intent-Based Catch Analysis';
+    this.description = 'Understands developer intent in error handling through semantic analysis';
+    
+    // Semantic patterns for different error handling intents
+    this.semanticPatterns = {
+      // Intent: Ignore errors intentionally
+      intentionalIgnore: [
+        /catch\s*\(\s*[_][\w]*\s*\)/,  // catch(_), catch(_ignored)
+        /\/\/\s*(ignore|suppress|intentional)/i,
+        /\/\*\s*(ignore|suppress|intentional)/i,
+        /catch\s*\([^)]*ignored[^)]*\)/i
+      ],
+      
+      // Intent: Log and continue
+      logAndContinue: [
+        /console\.(log|error|warn)/,
+        /logger\.(log|error|warn)/,
+        /log\.(error|warn|info)/
+      ],
+      
+      // Intent: Transform and rethrow
+      transformAndRethrow: [
+        /throw\s+new\s+\w+Error/,
+        /throw\s+.*Error\(/,
+        /rethrow/i
+      ],
+      
+      // Intent: Handle gracefully
+      gracefulHandling: [
+        /return\s+.*default/i,
+        /return\s+.*fallback/i,
+        /return\s+null/,
+        /return\s+undefined/,
+        /return\s+\[\]/,
+        /return\s+\{\}/
+      ],
+      
+      // Intent: Notify external systems
+      externalNotification: [
+        /notify/i,
+        /alert/i,
+        /report/i,
+        /track/i,
+        /analytics/i,
+        /monitoring/i,
+        /sentry/i,
+        /bugsnag/i
+      ],
+      
+      // Intent: Test verification
+      testVerification: [
+        /expect\(/,
+        /assert\(/,
+        /should\./,
+        /toBe\(/,
+        /toEqual\(/,
+        /toThrow\(/
+      ],
+      
+      // Intent: State management
+      stateManagement: [
+        /setState/,
+        /dispatch/,
+        /commit/,
+        /rejectWithValue/,
+        /setError/,
+        /setLoading/
+      ]
+    };
+  }
+
+  async analyze(files, language, options = {}) {
+    const violations = [];
+    console.log(`🧠 C029 Semantic: Analyzing ${files.length} files with semantic understanding...`);
+
+    for (const filePath of files) {
+      try {
+        const content = require('fs').readFileSync(filePath, 'utf8');
+        const semanticViolations = await this.analyzeSemanticIntent(content, filePath, language);
+        violations.push(...semanticViolations);
+
+      } catch (error) {
+        console.warn(`C029 Semantic skipping ${filePath}: ${error.message}`);
+      }
+    }
+
+    return violations;
+  }
+
+  /**
+   * Analyze semantic intent of error handling
+   */
+  async analyzeSemanticIntent(content, filePath, language) {
+    const violations = [];
+    const isTestFile = this.isTestFile(filePath);
+    
+    // Find all catch blocks with context
+    const catchBlocks = this.extractCatchBlocksWithContext(content);
+    
+    for (const catchBlock of catchBlocks) {
+      const semanticAnalysis = this.analyzeBlockSemantic(catchBlock, isTestFile, content);
+      
+      if (semanticAnalysis.isViolation) {
+        violations.push({
+          ruleId: this.ruleId,
+          file: filePath,
+          line: catchBlock.lineNumber,
+          column: 1,
+          message: semanticAnalysis.message,
+          severity: semanticAnalysis.severity,
+          code: catchBlock.code,
+          type: semanticAnalysis.type,
+          confidence: semanticAnalysis.confidence,
+          suggestion: semanticAnalysis.suggestion,
+          semanticIntent: semanticAnalysis.intent,
+          contextAnalysis: semanticAnalysis.context
+        });
+      }
+    }
+
+    return violations;
+  }
+
+  /**
+   * Extract catch blocks with surrounding context for semantic analysis
+   */
+  extractCatchBlocksWithContext(content) {
+    const catchBlocks = [];
+    const lines = content.split('\n');
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      
+      if (this.isCatchBlockStart(line)) {
+        const catchBlock = this.extractFullCatchBlock(lines, i);
+        
+        // Add surrounding context for semantic analysis
+        const context = this.extractSurroundingContext(lines, i, catchBlock.endLine);
+        
+        catchBlocks.push({
+          ...catchBlock,
+          lineNumber: i + 1,
+          context
+        });
+      }
+    }
+    
+    return catchBlocks;
+  }
+
+  /**
+   * Analyze semantic intent of a catch block
+   */
+  analyzeBlockSemantic(catchBlock, isTestFile, fullContent) {
+    const blockContent = catchBlock.content;
+    const blockCode = catchBlock.code;
+    const context = catchBlock.context;
+    
+    // 1. Detect semantic intent
+    const intent = this.detectSemanticIntent(blockContent, context, isTestFile);
+    
+    // 2. Validate intent appropriateness
+    const validation = this.validateSemanticIntent(intent, catchBlock, isTestFile, fullContent);
+    
+    if (validation.isValid) {
+      return { isViolation: false, intent, context: validation };
+    }
+    
+    // 3. Generate semantic-aware violation
+    return {
+      isViolation: true,
+      type: validation.violationType,
+      message: validation.message,
+      severity: validation.severity,
+      confidence: validation.confidence,
+      suggestion: validation.suggestion,
+      intent,
+      context: validation
+    };
+  }
+
+  /**
+   * Detect the semantic intent of error handling
+   */
+  detectSemanticIntent(blockContent, context, isTestFile) {
+    const intents = [];
+    
+    // Check each semantic pattern category
+    for (const [intentType, patterns] of Object.entries(this.semanticPatterns)) {
+      for (const pattern of patterns) {
+        if (pattern.test(blockContent) || pattern.test(context.before) || pattern.test(context.after)) {
+          intents.push({
+            type: intentType,
+            confidence: this.calculateIntentConfidence(intentType, blockContent, context, isTestFile)
+          });
+        }
+      }
+    }
+    
+    // Handle empty catch blocks
+    if (this.isEmpty(blockContent)) {
+      intents.push({
+        type: 'silentIgnore',
+        confidence: 0.95
+      });
+    }
+    
+    // Handle unknown intent
+    if (intents.length === 0) {
+      intents.push({
+        type: 'unknown',
+        confidence: 0.1
+      });
+    }
+    
+    // Return primary intent (highest confidence)
+    return intents.sort((a, b) => b.confidence - a.confidence)[0];
+  }
+
+  /**
+   * Validate if the detected intent is appropriate for the context
+   */
+  validateSemanticIntent(intent, catchBlock, isTestFile, fullContent) {
+    const intentType = intent.type;
+    const confidence = intent.confidence;
+    
+    switch (intentType) {
+      case 'intentionalIgnore':
+        return this.validateIntentionalIgnore(catchBlock, confidence);
+        
+      case 'logAndContinue':
+        return this.validateLogAndContinue(catchBlock, confidence);
+        
+      case 'transformAndRethrow':
+        return this.validateTransformAndRethrow(catchBlock, confidence);
+        
+      case 'gracefulHandling':
+        return this.validateGracefulHandling(catchBlock, confidence);
+        
+      case 'externalNotification':
+        return this.validateExternalNotification(catchBlock, confidence);
+        
+      case 'testVerification':
+        return this.validateTestVerification(catchBlock, isTestFile, confidence);
+        
+      case 'stateManagement':
+        return this.validateStateManagement(catchBlock, confidence);
+        
+      case 'silentIgnore':
+        return this.validateSilentIgnore(catchBlock, isTestFile, confidence);
+        
+      default:
+        return this.validateUnknownIntent(catchBlock, confidence);
+    }
+  }
+
+  /**
+   * Validate intentional ignore patterns
+   */
+  validateIntentionalIgnore(catchBlock, confidence) {
+    // Intentional ignore is usually acceptable if properly documented
+    const hasDocumentation = this.hasProperDocumentation(catchBlock);
+    
+    if (hasDocumentation) {
+      return { isValid: true, reason: 'documented_ignore' };
+    }
+    
+    return {
+      isValid: false,
+      violationType: 'undocumented_ignore',
+      message: 'Intentional error ignore should be documented with reason',
+      severity: 'warning',
+      confidence: confidence * 0.8,
+      suggestion: 'Add comment explaining why error is intentionally ignored'
+    };
+  }
+
+  /**
+   * Validate log and continue patterns
+   */
+  validateLogAndContinue(catchBlock, confidence) {
+    // Check if logging actually includes error information
+    const hasErrorInfo = this.loggingIncludesErrorInfo(catchBlock);
+    
+    if (hasErrorInfo) {
+      return { isValid: true, reason: 'proper_logging' };
+    }
+    
+    return {
+      isValid: false,
+      violationType: 'incomplete_logging',
+      message: 'Error logging should include error details (message, stack, context)',
+      severity: 'warning',
+      confidence: confidence * 0.9,
+      suggestion: 'Include error.message, error.stack, or relevant error properties in logging'
+    };
+  }
+
+  /**
+   * Validate silent ignore (empty catch)
+   */
+  validateSilentIgnore(catchBlock, isTestFile, confidence) {
+    // Silent ignore is usually problematic except in specific contexts
+    if (isTestFile && this.isExpectedErrorInTest(catchBlock)) {
+      return { isValid: true, reason: 'expected_test_error' };
+    }
+    
+    return {
+      isValid: false,
+      violationType: 'silent_error_suppression',
+      message: 'Silent error suppression hides bugs and makes debugging difficult',
+      severity: 'error',
+      confidence: confidence,
+      suggestion: 'Add error logging, rethrowing, or explicit ignore with documentation'
+    };
+  }
+
+  /**
+   * Calculate confidence score for intent detection
+   */
+  calculateIntentConfidence(intentType, blockContent, context, isTestFile) {
+    let confidence = 0.5; // Base confidence
+    
+    // Adjust based on pattern strength
+    const patternCount = this.countMatchingPatterns(intentType, blockContent);
+    confidence += Math.min(patternCount * 0.2, 0.4);
+    
+    // Adjust based on context
+    if (isTestFile && intentType === 'testVerification') {
+      confidence += 0.3;
+    }
+    
+    // Adjust based on code quality indicators
+    if (this.hasGoodNaming(blockContent)) {
+      confidence += 0.1;
+    }
+    
+    if (this.hasDocumentation(context)) {
+      confidence += 0.1;
+    }
+    
+    return Math.min(confidence, 1.0);
+  }
+
+  // Helper methods (simplified implementations)
+  
+  isCatchBlockStart(line) {
+    return line.trim().includes('catch (') || line.trim().includes('catch(');
+  }
+
+  extractFullCatchBlock(lines, startIndex) {
+    // Simplified catch block extraction
+    return {
+      content: 'catch block content',
+      code: lines[startIndex],
+      endLine: startIndex + 5
+    };
+  }
+
+  extractSurroundingContext(lines, startLine, endLine) {
+    const before = lines.slice(Math.max(0, startLine - 3), startLine).join('\n');
+    const after = lines.slice(endLine + 1, Math.min(lines.length, endLine + 4)).join('\n');
+    
+    return { before, after };
+  }
+
+  isEmpty(content) {
+    return content.trim().replace(/[{}]/g, '').trim().length === 0;
+  }
+
+  hasProperDocumentation(catchBlock) {
+    const content = catchBlock.content + (catchBlock.context?.before || '');
+    return /\/\/|\/\*/.test(content);
+  }
+
+  loggingIncludesErrorInfo(catchBlock) {
+    const content = catchBlock.content;
+    return /error\.(message|stack|name)/.test(content) || /\$\{error\}/.test(content);
+  }
+
+  isExpectedErrorInTest(catchBlock) {
+    const context = catchBlock.context || {};
+    return /expect.*toThrow|assertThrows|shouldThrow/.test(context.before + context.after);
+  }
+
+  countMatchingPatterns(intentType, content) {
+    const patterns = this.semanticPatterns[intentType] || [];
+    return patterns.filter(pattern => pattern.test(content)).length;
+  }
+
+  hasGoodNaming(content) {
+    return /\b(error|err|exception|ex)\b/.test(content);
+  }
+
+  hasDocumentation(context) {
+    return /\/\/|\/\*/.test((context?.before || '') + (context?.after || ''));
+  }
+
+  isTestFile(filePath) {
+    const testPatterns = ['__tests__', '.test.', '.spec.', '/test/', '/tests/'];
+    return testPatterns.some(pattern => filePath.includes(pattern));
+  }
+
+  // Placeholder validation methods
+  validateTransformAndRethrow(catchBlock, confidence) {
+    return { isValid: true, reason: 'proper_transform' };
+  }
+
+  validateGracefulHandling(catchBlock, confidence) {
+    return { isValid: true, reason: 'graceful_handling' };
+  }
+
+  validateExternalNotification(catchBlock, confidence) {
+    return { isValid: true, reason: 'external_notification' };
+  }
+
+  validateTestVerification(catchBlock, isTestFile, confidence) {
+    if (!isTestFile) {
+      return {
+        isValid: false,
+        violationType: 'test_code_in_production',
+        message: 'Test-style error handling found in production code',
+        severity: 'warning',
+        confidence: confidence * 0.9,
+        suggestion: 'Use proper error handling instead of test assertions'
+      };
+    }
+    return { isValid: true, reason: 'valid_test_verification' };
+  }
+
+  validateStateManagement(catchBlock, confidence) {
+    return { isValid: true, reason: 'state_management' };
+  }
+
+  validateUnknownIntent(catchBlock, confidence) {
+    return {
+      isValid: false,
+      violationType: 'unclear_error_handling_intent',
+      message: 'Error handling intent is unclear - consider explicit error handling',
+      severity: 'info',
+      confidence: confidence,
+      suggestion: 'Make error handling intent clear through logging, rethrowing, or documentation'
+    };
+  }
+}
+
+module.exports = new C029SemanticAnalyzer();

package/rules/common/C031_validation_separation/analyzer.js

@@ -0,0 +1,186 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Rule C031 - Validation Logic Separation
+ * Kiểm tra logic validation có bị trộn lẫn với business logic không
+ */
+class ValidationSeparationAnalyzer {
+    constructor() {
+        this.ruleId = 'C031';
+        this.ruleName = 'Validation Logic Separation';
+        this.category = 'architecture';
+        this.severity = 'warning';
+        this.description = 'Logic kiểm tra dữ liệu (validate) phải nằm riêng biệt';
+    }
+
+    analyzeFile(filePath, options = {}) {
+        const violations = [];
+        
+        try {
+            if (!fs.existsSync(filePath)) {
+                return violations;
+            }
+
+            const content = fs.readFileSync(filePath, 'utf8');
+            const lines = content.split('\n');
+            
+            // Detect functions with mixed validation and business logic
+            const functions = this.extractFunctions(content);
+            
+            for (const func of functions) {
+                const validationCount = this.countValidationStatements(func.body);
+                const businessLogicCount = this.countBusinessLogicStatements(func.body);
+                
+                // If both validation and business logic exist in same function
+                if (validationCount > 0 && businessLogicCount > 0) {
+                    const maxValidationAllowed = options.maxValidationStatementsInFunction || 3;
+                    
+                    if (validationCount > maxValidationAllowed) {
+                        violations.push({
+                            line: func.startLine,
+                            column: 1,
+                            message: `Function '${func.name}' has ${validationCount} validation statements mixed with business logic. Consider separating validation logic.`,
+                            ruleId: this.ruleId,
+                            severity: this.severity,
+                            source: lines[func.startLine - 1]?.trim() || ''
+                        });
+                    }
+                }
+            }
+            
+        } catch (error) {
+            console.error(`Error analyzing ${filePath}:`, error.message);
+        }
+        
+        return violations;
+    }
+
+    extractFunctions(content) {
+        const functions = [];
+        const lines = content.split('\n');
+        
+        // Simple function detection patterns
+        const functionPatterns = [
+            /function\s+(\w+)\s*\(/g,
+            /const\s+(\w+)\s*=\s*\(/g,
+            /(\w+)\s*\(\s*[^)]*\s*\)\s*=>/g,
+            /(\w+)\s*:\s*function\s*\(/g
+        ];
+        
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            
+            for (const pattern of functionPatterns) {
+                const matches = line.matchAll(pattern);
+                for (const match of matches) {
+                    const functionName = match[1];
+                    const startLine = i + 1;
+                    
+                    // Extract function body (simple approach)
+                    const body = this.extractFunctionBody(lines, i);
+                    
+                    functions.push({
+                        name: functionName,
+                        startLine,
+                        body
+                    });
+                }
+            }
+        }
+        
+        return functions;
+    }
+
+    extractFunctionBody(lines, startIndex) {
+        let body = '';
+        let braceCount = 0;
+        let inFunction = false;
+        
+        for (let i = startIndex; i < lines.length; i++) {
+            const line = lines[i];
+            
+            if (line.includes('{')) {
+                braceCount += (line.match(/\{/g) || []).length;
+                inFunction = true;
+            }
+            
+            if (inFunction) {
+                body += line + '\n';
+            }
+            
+            if (line.includes('}')) {
+                braceCount -= (line.match(/\}/g) || []).length;
+                if (braceCount <= 0 && inFunction) {
+                    break;
+                }
+            }
+        }
+        
+        return body;
+    }
+
+    countValidationStatements(code) {
+        const validationPatterns = [
+            /if\s*\(\s*!.*\)\s*\{?\s*throw/g,
+            /if\s*\(.*\.\s*length\s*[<>=]\s*\d+\)/g,
+            /if\s*\(.*\s*==\s*null\s*\||\s*.*\s*==\s*undefined\)/g,
+            /if\s*\(.*\s*!\s*=\s*null\s*&&\s*.*\s*!\s*=\s*undefined\)/g,
+            /throw\s+new\s+Error\s*\(/g,
+            /assert\s*\(/g,
+            /validate\w*\s*\(/g,
+            /check\w*\s*\(/g
+        ];
+        
+        let count = 0;
+        for (const pattern of validationPatterns) {
+            const matches = code.match(pattern);
+            if (matches) {
+                count += matches.length;
+            }
+        }
+        
+        return count;
+    }
+
+    countBusinessLogicStatements(code) {
+        const businessLogicPatterns = [
+            /calculate\w*\s*\(/g,
+            /process\w*\s*\(/g,
+            /save\w*\s*\(/g,
+            /update\w*\s*\(/g,
+            /delete\w*\s*\(/g,
+            /send\w*\s*\(/g,
+            /return\s+\w+\s*\(/g,
+            /await\s+\w+\s*\(/g
+        ];
+        
+        let count = 0;
+        for (const pattern of businessLogicPatterns) {
+            const matches = code.match(pattern);
+            if (matches) {
+                count += matches.length;
+            }
+        }
+        
+        return count;
+    }
+
+    // Main analyze method expected by CLI
+    async analyze(files, language, config) {
+        const violations = [];
+        
+        for (const filePath of files) {
+            try {
+                const fileViolations = this.analyzeFile(filePath, config);
+                violations.push(...fileViolations);
+            } catch (error) {
+                console.error(`Error analyzing file ${filePath}:`, error.message);
+            }
+        }
+        
+        return violations;
+    }
+}
+
+module.exports = new ValidationSeparationAnalyzer();