@sun-asterisk/sunlint 1.1.7 → 1.2.0

package/rules/common/C029_catch_block_logging/analyzer.js

@@ -1,373 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { PatternMatcher } = require('../../utils/pattern-matchers');
-const { RuleHelper } = require('../../utils/rule-helpers');
-
-class C029Analyzer {
-  constructor() {
-    this.ruleId = 'C029';
-    this.ruleName = 'Enhanced Catch Block Error Logging';
-    this.description = 'Mọi catch block phải log nguyên nhân lỗi đầy đủ và bảo toàn context (enhanced version replacing ESLint C028)';
-    this.aiAnalyzer = null;
-  }
-
-  async analyze(files, language, options = {}) {
-    const violations = [];
-    
-    for (const filePath of files) {
-      if (options.verbose) {
-        console.log(`🔍 Running pattern 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');
-
-    // Focus on core functionality - only detect truly silent catch blocks
-    violations.push(...this.findSilentCatchBlocks(lines, filePath));
-    // Disabled strict checks to reduce false positives:
-    // violations.push(...this.findInadequateErrorLogging(lines, filePath));
-    // violations.push(...this.findMissingErrorContext(lines, filePath));
-
-    return violations;
-  }
-
-  /**
-   * Core functionality from ESLint C029 - detect silent catch blocks
-   */
-  findSilentCatchBlocks(lines, filePath) {
-    const violations = [];
-    
-    lines.forEach((line, index) => {
-      const lineNumber = index + 1;
-      const trimmedLine = line.trim();
-
-      // Detect catch block start
-      if (this.isCatchBlockStart(trimmedLine)) {
-        const catchBlockInfo = this.extractCatchBlockInfo(lines, index);
-        
-        if (catchBlockInfo.isEmpty) {
-          violations.push({
-            ruleId: this.ruleId,
-            file: filePath,
-            line: lineNumber,
-            column: line.indexOf('catch') + 1,
-            message: 'Empty catch block - error is silently ignored',
-            severity: 'error',
-            code: trimmedLine,
-            type: 'empty_catch_block',
-            confidence: 1.0,
-            suggestion: 'Add error logging or rethrowing in catch block'
-          });
-        } else if (!catchBlockInfo.hasLoggingOrRethrow) {
-          violations.push({
-            ruleId: this.ruleId,
-            file: filePath,
-            line: lineNumber,
-            column: line.indexOf('catch') + 1,
-            message: 'Catch block must log error or rethrow - silent error handling hides bugs',
-            severity: 'error',
-            code: trimmedLine,
-            type: 'silent_catch_block',
-            confidence: 0.9,
-            suggestion: 'Add error logging (console.error, logger.error) or rethrow the error'
-          });
-        }
-      }
-    });
-
-    return violations;
-  }
-
-  /**
-   * SunLint enhanced functionality - detect inadequate error logging
-   */
-  findInadequateErrorLogging(lines, filePath) {
-    const violations = [];
-    
-    lines.forEach((line, index) => {
-      const lineNumber = index + 1;
-      const trimmedLine = line.trim();
-
-      if (this.isCatchBlockStart(trimmedLine)) {
-        const catchBlockInfo = this.extractCatchBlockInfo(lines, index);
-        
-        if (catchBlockInfo.hasLoggingOrRethrow && !catchBlockInfo.hasAdequateLogging) {
-          violations.push({
-            ruleId: this.ruleId,
-            file: filePath,
-            line: lineNumber,
-            column: line.indexOf('catch') + 1,
-            message: 'Error logging should include error message, stack trace, and context',
-            severity: 'warning',
-            code: trimmedLine,
-            type: 'inadequate_error_logging',
-            confidence: 0.8,
-            suggestion: 'Include error.message, error.stack, and relevant context in error logging'
-          });
-        }
-      }
-    });
-
-    return violations;
-  }
-
-  /**
-   * SunLint enhanced functionality - detect missing error context
-   * DISABLED: Too strict, causing false positives
-   */
-  findMissingErrorContext(lines, filePath) {
-    // Disabled to reduce false positives
-    return [];
-    
-    /* Original strict implementation:
-    const violations = [];
-    
-    lines.forEach((line, index) => {
-      const lineNumber = index + 1;
-      const trimmedLine = line.trim();
-
-      if (this.isCatchBlockStart(trimmedLine)) {
-        const catchBlockInfo = this.extractCatchBlockInfo(lines, index);
-        
-        if (catchBlockInfo.hasLoggingOrRethrow && !catchBlockInfo.hasContextualLogging) {
-          violations.push({
-            ruleId: this.ruleId,
-            file: filePath,
-            line: lineNumber,
-            column: line.indexOf('catch') + 1,
-            message: 'Error logging should include operational context (function name, input parameters)',
-            severity: 'info',
-            code: trimmedLine,
-            type: 'missing_error_context',
-            confidence: 0.7,
-            suggestion: 'Include function name, input parameters, and operational context in error logging'
-          });
-        }
-      }
-    });
-
-    return violations;
-    */
-  }
-
-  isCatchBlockStart(line) {
-    return line.includes('catch (') || line.includes('catch(');
-  }
-
-  extractCatchBlockInfo(lines, startIndex) {
-    const catchBlockLines = [];
-    let braceDepth = 0;
-    let foundCatchBrace = false;
-
-    for (let i = startIndex; i < lines.length; i++) {
-      const line = lines[i];
-      catchBlockLines.push(line);
-      
-      // Check if this is the catch line with opening brace
-      if (this.isCatchBlockStart(line.trim())) {
-        // Count braces in the catch line itself
-        for (const char of line) {
-          if (char === '{') {
-            foundCatchBrace = true;
-            braceDepth = 1; // Start counting from 1 for the catch block
-          }
-        }
-      } else if (foundCatchBrace) {
-        // 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;
-        }
-      }
-    }
-
-    const content = catchBlockLines.join('\n').toLowerCase();
-    const originalContent = catchBlockLines.join('\n');
-    
-    return {
-      isEmpty: this.isCatchBlockEmpty(catchBlockLines),
-      hasLoggingOrRethrow: this.hasLoggingOrRethrow(content, originalContent),
-      hasAdequateLogging: this.hasAdequateErrorLogging(content, originalContent),
-      hasContextualLogging: this.hasContextualErrorLogging(content, originalContent)
-    };
-  }
-
-  isCatchBlockEmpty(catchBlockLines) {
-    if (catchBlockLines.length === 0) return true;
-    
-    // Join all lines and find the content between braces
-    const fullContent = catchBlockLines.join('\n');
-    
-    // Find the opening brace and closing brace
-    let openBraceIndex = fullContent.indexOf('{');
-    let closeBraceIndex = fullContent.lastIndexOf('}');
-    
-    if (openBraceIndex === -1 || closeBraceIndex === -1) {
-      return true; // Malformed catch block
-    }
-    
-    // Extract body content between braces
-    const bodyContent = fullContent.substring(openBraceIndex + 1, closeBraceIndex).trim();
-    
-    // Remove comments and whitespace
-    const cleanedBody = bodyContent
-      .replace(/\/\*[\s\S]*?\*\//g, '') // Remove block comments
-      .replace(/\/\/.*$/gm, '') // Remove line comments
-      .replace(/\s+/g, ' ') // Normalize whitespace
-      .trim();
-    
-    return cleanedBody.length === 0;
-  }
-
-  hasLoggingOrRethrow(content, originalContent) {
-    // Check for throw statements
-    if (content.includes('throw ') || content.includes('throw;')) {
-      return true;
-    }
-
-    // Check for test assertions - valid form of error handling
-    const testPatterns = [
-      'expect(',
-      'assert(',
-      'tobeinstanceof',
-      'toequal(',
-      'tohavebeencalled',
-      'toBe(',
-      'toHaveBeenCalledWith'
-    ];
-
-    const hasTestAssertions = testPatterns.some(pattern => 
-      content.includes(pattern.toLowerCase()) || originalContent.toLowerCase().includes(pattern.toLowerCase())
-    );
-
-    if (hasTestAssertions) {
-      return true;
-    }
-
-    // Check for Redux/async thunk error handling
-    const reduxErrorHandlers = [
-      'handleaxioserror',
-      'rejectwithvalue',
-      'dispatch(',
-      'seterror(',
-      'return value',
-      'return rejectwithvalue'
-    ];
-
-    const hasReduxHandling = reduxErrorHandlers.some(pattern => 
-      content.includes(pattern.toLowerCase()) || originalContent.toLowerCase().includes(pattern.toLowerCase())
-    );
-
-    if (hasReduxHandling) {
-      return true;
-    }
-
-    // Check for logging patterns (expanded from original)
-    const loggingPatterns = [
-      'console.error',
-      'console.log',
-      'console.warn',
-      'logger.error',
-      'log.error',
-      'logger.warn',
-      'log.warn',
-      'winston.error',
-      'bunyan.error',
-      'pino.error',
-      '.error(',
-      '.warn(',
-      '.log('
-    ];
-
-    // Accept basic error logging - don't require context
-    const hasBasicLogging = loggingPatterns.some(pattern => 
-      content.includes(pattern) || originalContent.includes(pattern)
-    );
-
-    return hasBasicLogging;
-  }
-
-  hasAdequateErrorLogging(content, originalContent) {
-    // Check for error properties being logged
-    const errorProperties = [
-      'error.message',
-      'error.stack',
-      'err.message',
-      'err.stack',
-      'e.message',
-      'e.stack',
-      'error.name',
-      'error.cause'
-    ];
-
-    const hasErrorProperties = errorProperties.some(prop => 
-      content.includes(prop) || originalContent.includes(prop)
-    );
-
-    // Check for comprehensive error logging
-    const hasLogging = this.hasLoggingOrRethrow(content, originalContent);
-    
-    return hasLogging && hasErrorProperties;
-  }
-
-  hasContextualErrorLogging(content, originalContent) {
-    // Check for contextual information in logging
-    const contextualPatterns = [
-      'function',
-      'method',
-      'operation',
-      'input',
-      'parameters',
-      'context',
-      'state',
-      'request',
-      'response',
-      'userId',
-      'sessionId',
-      'transactionId'
-    ];
-
-    // Check if logging includes contextual information
-    const hasContextualInfo = contextualPatterns.some(pattern => 
-      content.includes(pattern) || originalContent.includes(pattern)
-    );
-
-    // Check for template literals or string concatenation (indicates contextual logging)
-    const hasTemplateLogging = originalContent.includes('${') || originalContent.includes('" + ') || originalContent.includes("' + ");
-
-    return hasContextualInfo || hasTemplateLogging;
-  }
-}
-
-module.exports = new C029Analyzer();

package/rules/common/C029_catch_block_logging/config.json

@@ -1,59 +0,0 @@
-{
-  "ruleId": "C029",
-  "name": "Catch Block Error Logging",
-  "description": "Mọi catch block phải log nguyên nhân lỗi đầy đủ",
-  "category": "error-handling",
-  "severity": "error",
-  "languages": ["typescript", "dart", "kotlin", "javascript"],
-  "version": "1.0.0",
-  "status": "activated",
-  "tags": ["error-handling", "logging", "debugging", "monitoring"],
-  "examples": {
-    "typescript": {
-      "violations": [
-        "try { riskyOperation(); } catch (error) { return null; }",
-        "catch (e) { /* empty */ }",
-        "catch (error) { throw new Error('Failed'); }"
-      ],
-      "valid": [
-        "catch (error) { console.error('Operation failed:', error); }",
-        "catch (e) { logger.error('Error in process:', e); }",
-        "catch (error) { console.error(error); throw error; }"
-      ]
-    },
-    "dart": {
-      "violations": [
-        "try { riskyOperation(); } catch (e) { return null; }",
-        "on Exception catch (e) { /* empty */ }"
-      ],
-      "valid": [
-        "catch (e) { print('Error: $e'); }",
-        "on Exception catch (e) { log.severe('Failed:', e); }"
-      ]
-    },
-    "kotlin": {
-      "violations": [
-        "try { riskyOperation() } catch (e: Exception) { return null }",
-        "catch (e: Exception) { /* empty */ }"
-      ],
-      "valid": [
-        "catch (e: Exception) { Log.e(TAG, 'Error:', e) }",
-        "catch (e: Exception) { logger.error('Failed', e) }"
-      ]
-    }
-  },
-  "configuration": {
-    "requiredLoggingMethods": [
-      "console.error",
-      "console.log", 
-      "logger.error",
-      "log.error",
-      "print",
-      "log.severe",
-      "Log.e",
-      "timber.e"
-    ],
-    "allowEmptyWhenRethrow": true,
-    "checkErrorParameter": true
-  }
-}

package/rules/common/C031_validation_separation/analyzer.js

@@ -1,186 +0,0 @@
-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();