@sun-asterisk/sunlint 1.1.8 → 1.2.0

package/rules/common/C043_no_console_or_print/analyzer.js

@@ -1,304 +0,0 @@
-/**
- * C043 Rule: No console.log or print in production code
- * Prevents usage of console logging and print statements in production
- * Severity: warning  
- * Category: Quality
- */
-
-const fs = require('fs');
-const path = require('path');
-
-class C043NoConsoleOrPrintAnalyzer {
-  constructor() {
-    this.ruleId = 'C043';
-    this.ruleName = 'No Console Or Print';
-    this.description = 'Do not use console.log or print in production code';
-    this.severity = 'warning';
-    
-    // Enhanced patterns to catch various console and print usages
-    // Negative lookahead to avoid matches within strings or comments
-    this.consolePatterns = [
-        /\bconsole\.(?:log|debug|info|table|time|timeEnd|count|group|groupCollapsed|trace|dir|dirxml|profile|profileEnd)\s*\(/g,
-        /\bprint\s*\(/g,
-        /\balert\s*\(/g,
-        /\bconfirm\s*\(/g,
-        /\bprompt\s*\(/g
-    ];
-        
-    // Also check if the line is within a comment or string
-    function isInStringOrComment(line, matchIndex) {
-        // Check for single/double quotes before the match
-        const beforeMatch = line.substring(0, matchIndex);
-        const afterMatch = line.substring(matchIndex);
-        
-        // Count quotes before match
-        const singleQuotes = (beforeMatch.match(/'/g) || []).length;
-        const doubleQuotes = (beforeMatch.match(/"/g) || []).length;
-        const backticks = (beforeMatch.match(/`/g) || []).length;
-        
-        // If odd number of quotes, we're inside a string
-        if (singleQuotes % 2 !== 0 || doubleQuotes % 2 !== 0 || backticks % 2 !== 0) {
-            return true;
-        }
-        
-        // Check for comments
-        if (beforeMatch.includes('//') || beforeMatch.includes('/*')) {
-            return true;
-        }
-        
-        return false;
-    }
-    
-    // Patterns for print statements
-    this.printPatterns = [
-      /\bprint\s*\(/g,
-      /\balert\s*\(/g,
-      /\bconfirm\s*\(/g,
-      /\bprompt\s*\(/g
-    ];
-    
-    // Allowed console methods (errors/warnings might be OK)
-    this.allowedConsoleMethods = ['error', 'warn'];
-    
-    // Development context patterns that might allow console
-    this.devContextPatterns = [
-      /if\s*\(\s*(__DEV__|DEBUG|process\.env\.NODE_ENV)/,
-      /if\s*\(\s*process\.env\.NODE_ENV\s*===\s*['"`]development['"`]/,
-      /if\s*\(\s*ENABLE_LOGGING|FEATURES\.debug/
-    ];
-  }
-
-  async analyze(files, language, config) {
-    const violations = [];
-
-    for (const filePath of files) {
-      try {
-        const fileContent = fs.readFileSync(filePath, 'utf8');
-        const fileViolations = await this.analyzeFile(filePath, fileContent, language, config);
-        violations.push(...fileViolations);
-      } catch (error) {
-        console.warn(`C043 analysis error for ${filePath}:`, error.message);
-      }
-    }
-
-    return violations;
-  }
-
-  async analyzeFile(filePath, fileContent, language, config) {
-    const violations = [];
-    
-    try {
-      // Skip test files (console.log often used in tests)
-      if (this.isTestFile(filePath)) {
-        return violations;
-      }
-      
-      // Skip development/debug files
-      if (this.isDevelopmentFile(filePath)) {
-        return violations;
-      }
-
-      const lines = fileContent.split('\n');
-      let inTemplateString = false;
-      let templateStartLine = -1;
-
-      for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const lineNumber = i + 1;
-        
-        // Track template literal state
-        const backtickCount = (line.match(/`/g) || []).length;
-        if (backtickCount % 2 === 1) {
-          if (!inTemplateString) {
-            inTemplateString = true;
-            templateStartLine = i;
-          } else {
-            inTemplateString = false;
-            templateStartLine = -1;
-          }
-        }
-        
-        // Skip if inside template literal
-        if (inTemplateString && templateStartLine !== i) {
-          continue;
-        }
-        
-        // Skip comments and strings (basic check)
-        if (this.isInCommentOrString(line)) {
-          continue;
-        }
-        
-        // Skip if in development context
-        if (this.isInDevelopmentContext(lines, i)) {
-          continue;
-        }
-
-      // Check for console.* calls
-      for (const pattern of this.consolePatterns) {
-        let match;
-        while ((match = pattern.exec(line)) !== null) {
-          // Skip if the match is within a string or comment
-          if (this.isInCommentOrString(line)) {
-            continue;
-          }
-          
-          const method = match[1] || 'log';
-          
-          // Skip allowed methods
-          if (this.allowedConsoleMethods.includes(method)) {
-            continue;
-          }
-          
-          violations.push({
-            ruleId: this.ruleId,
-            severity: this.severity,
-            message: `Do not use console.${method}() in production code. Use proper logging instead.`,
-            filePath: filePath,
-            line: lineNumber,
-            column: match.index + 1,
-            source: line.trim(),
-            suggestion: `Consider using a proper logging library (logger.${method}())`
-          });
-        }
-        pattern.lastIndex = 0; // Reset regex
-      }
-
-        // Check for print/alert calls
-        for (const pattern of this.printPatterns) {
-          let match;
-          while ((match = pattern.exec(line)) !== null) {
-            // Skip if the match is within a string or comment
-            if (this.isInCommentOrString(line)) {
-              continue;
-            }
-            
-            const method = match[0].split('(')[0].trim();
-            
-            violations.push({
-              ruleId: this.ruleId,
-              severity: this.severity,
-              message: `Do not use ${method}() in production code. Use proper logging or UI notifications instead.`,
-              filePath: filePath,
-              line: lineNumber,
-              column: match.index + 1,
-              source: line.trim(),
-              suggestion: `Consider using a logging library or proper UI notification system`
-            });
-          }
-          pattern.lastIndex = 0; // Reset regex
-        }
-      }
-
-    } catch (error) {
-      console.warn(`C043 analysis error for ${filePath}:`, error.message);
-    }
-
-    return violations;
-  }
-
-  isTestFile(filePath) {
-    const testPatterns = [
-      /\.test\.(js|ts|jsx|tsx)$/,
-      /\.spec\.(js|ts|jsx|tsx)$/,
-      /\/__tests__\//,
-      /\/tests?\//,
-      /\.e2e\./,
-      /\.integration\./,
-      /test\.config\./,
-      /jest\.config\./
-    ];
-    
-    return testPatterns.some(pattern => pattern.test(filePath));
-  }
-  
-  isDevelopmentFile(filePath) {
-    const devPatterns = [
-      /\.dev\.(js|ts|jsx|tsx)$/,
-      /\.development\./,
-      /\.debug\./,
-      /\/dev\//,
-      /\/debug\//,
-      /\/development\//
-    ];
-    
-    return devPatterns.some(pattern => pattern.test(filePath));
-  }
-  
-  isInCommentOrString(line) {
-    const trimmed = line.trim();
-    
-    // Single line comment
-    if (trimmed.startsWith('//')) {
-      return true;
-    }
-    
-    // Multi-line comment (basic check)
-    if (trimmed.startsWith('/*') || trimmed.startsWith('*')) {
-      return true;
-    }
-    
-    // Check for console usage within quotes (simple approach)
-    // This is a heuristic - if there are more opening quotes than closing before console, likely inside string
-    const beforeConsole = line.split(/console\.|print\(|alert\(|confirm\(|prompt\(/)[0];
-    
-    if (beforeConsole) {
-      const singleQuotes = (beforeConsole.match(/'/g) || []).length;
-      const doubleQuotes = (beforeConsole.match(/"/g) || []).length;  
-      const backticks = (beforeConsole.match(/`/g) || []).length;
-      
-      // If any odd count, we're probably inside a string
-      if (singleQuotes % 2 === 1 || doubleQuotes % 2 === 1 || backticks % 2 === 1) {
-        return true;
-      }
-    }
-    
-    return false;
-  }
-  
-  isInDevelopmentContext(lines, currentLineIndex) {
-    // Look backwards for development context (like if (__DEV__))
-    const lookBehindLines = 5;
-    const startIndex = Math.max(0, currentLineIndex - lookBehindLines);
-    
-    for (let i = startIndex; i <= currentLineIndex; i++) {
-      const line = lines[i];
-      
-      // Check for development context patterns
-      for (const pattern of this.devContextPatterns) {
-        if (pattern.test(line)) {
-          // Check if current line is within the same block
-          if (this.isWithinBlock(lines, i, currentLineIndex)) {
-            return true;
-          }
-        }
-      }
-    }
-    
-    return false;
-  }
-  
-  isWithinBlock(lines, conditionLineIndex, currentLineIndex) {
-    // Simple block detection based on braces
-    let braceCount = 0;
-    
-    for (let i = conditionLineIndex; i <= currentLineIndex; i++) {
-      const line = lines[i];
-      
-      // Count opening/closing braces
-      const openBraces = (line.match(/\{/g) || []).length;
-      const closeBraces = (line.match(/\}/g) || []).length;
-      
-      braceCount += openBraces - closeBraces;
-      
-      // If we're at current line and still have positive brace count,
-      // we're likely inside the block
-      if (i === currentLineIndex && braceCount > 0) {
-        return true;
-      }
-    }
-    
-    return false;
-  }
-}
-
-module.exports = C043NoConsoleOrPrintAnalyzer;

package/rules/common/C047_no_duplicate_retry_logic/analyzer.js

@@ -1,351 +0,0 @@
-/**
- * Heuristic analyzer for: C047 – Logic retry không được viết lặp lại nhiều nơi
- * Purpose: Detect duplicate retry logic patterns and suggest centralized retry utilities
- */
-
-class C047Analyzer {
-  constructor() {
-    this.ruleId = 'C047';
-    this.ruleName = 'No Duplicate Retry Logic';
-    this.description = 'Logic retry không được viết lặp lại nhiều nơi - use centralized retry utility instead';
-    
-    // Patterns that indicate retry logic
-    this.retryIndicators = [
-      'maxretries', 'maxattempts', 'maxtries',
-      'attempt', 'retry', 'tries', 'retries',
-      'backoff', 'delay', 'timeout',
-      'exponential', 'linear'
-    ];
-    
-    // Allowed centralized retry utilities
-    this.allowedRetryUtils = [
-      'RetryUtil', 'retryWithBackoff', 'withRetry', 'retry',
-      'retryAsync', 'retryPromise', 'retryOperation',
-      'exponentialBackoff', 'linearBackoff'
-    ];
-    
-    // Detected retry patterns for duplicate checking
-    this.retryPatterns = [];
-  }
-
-  async analyze(files, language, options = {}) {
-    const violations = [];
-    
-    for (const filePath of files) {
-      if (options.verbose) {
-        console.log(`🔍 Running C047 analysis on ${require('path').basename(filePath)}`);
-      }
-      
-      try {
-        const content = require('fs').readFileSync(filePath, 'utf8');
-        this.retryPatterns = []; // Reset for each file
-        const fileViolations = this.analyzeFile(content, filePath);
-        violations.push(...fileViolations);
-      } catch (error) {
-        console.warn(`⚠️ Failed to analyze ${filePath}: ${error.message}`);
-      }
-    }
-    
-    return violations;
-  }
-
-  analyzeFile(content, filePath) {
-    const violations = [];
-    const lines = content.split('\n');
-    
-    // Find all retry patterns in the file
-    this.findRetryPatterns(lines, filePath);
-    
-    // Check for duplicates
-    const duplicateGroups = this.findDuplicateRetryLogic();
-    
-    // Report violations for duplicate patterns - only once per function
-    const reportedFunctions = new Set();
-    
-    duplicateGroups.forEach(group => {
-      if (group.patterns.length > 1) {
-        // Find the first occurrence of each function to report
-        const functionViolations = new Map();
-        
-        group.patterns.forEach(pattern => {
-          const functionName = this.getFunctionNameForLine(lines, pattern.line - 1);
-          const functionKey = `${functionName}_${Math.floor(pattern.line / 20)}`; // Group by function and rough location
-          
-          if (!functionViolations.has(functionKey)) {
-            functionViolations.set(functionKey, pattern);
-          }
-        });
-        
-        // Report one violation per function
-        functionViolations.forEach(pattern => {
-          violations.push({
-            file: filePath,
-            line: pattern.line,
-            column: pattern.column,
-            message: `Duplicate retry logic detected (${group.patterns.length} similar patterns found). Consider using a centralized retry utility like RetryUtil.withRetry() or retryWithBackoff().`,
-            severity: 'warning',
-            ruleId: this.ruleId,
-            type: 'duplicate_retry_logic',
-            duplicateCount: group.patterns.length
-          });
-        });
-      }
-    });
-    
-    return violations;
-  }
-  
-  findRetryPatterns(lines, filePath) {
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const trimmedLine = line.trim().toLowerCase();
-      
-      // Skip comments and empty lines
-      if (!trimmedLine || trimmedLine.startsWith('//') || trimmedLine.startsWith('/*')) {
-        continue;
-      }
-      
-      // Skip if using allowed retry utilities
-      if (this.usesAllowedRetryUtil(line)) {
-        continue;
-      }
-      
-      // Pattern 1: For/while loop with retry indicators
-      if (this.isRetryLoopPattern(line, lines, i)) {
-        const pattern = this.extractRetryPattern(lines, i, 'loop');
-        if (pattern) {
-          this.retryPatterns.push({
-            ...pattern,
-            line: i + 1,
-            column: line.indexOf(line.trim()) + 1
-          });
-        }
-      }
-      
-      // Pattern 2: Variable declarations with retry indicators
-      else if (this.isRetryVariableDeclaration(trimmedLine)) {
-        const pattern = this.extractRetryPattern(lines, i, 'variable');
-        if (pattern) {
-          this.retryPatterns.push({
-            ...pattern,
-            line: i + 1,
-            column: line.indexOf(line.trim()) + 1
-          });
-        }
-      }
-      
-      // Pattern 3: Recursive function with retry logic
-      else if (this.isRetryFunctionPattern(lines, i)) {
-        const pattern = this.extractRetryPattern(lines, i, 'recursive');
-        if (pattern) {
-          this.retryPatterns.push({
-            ...pattern,
-            line: i + 1,
-            column: line.indexOf(line.trim()) + 1
-          });
-        }
-      }
-    }
-  }
-  
-  isRetryLoopPattern(line, lines, index) {
-    const trimmedLine = line.trim().toLowerCase();
-    
-    // Check for for/while loops with retry indicators
-    if ((trimmedLine.includes('for') || trimmedLine.includes('while')) &&
-        (trimmedLine.includes('(') && trimmedLine.includes(')'))) {
-      
-      // Look in the loop condition and surrounding context for retry indicators
-      const contextLines = lines.slice(Math.max(0, index - 2), Math.min(lines.length, index + 10));
-      const contextText = contextLines.join('\n').toLowerCase();
-      
-      return this.retryIndicators.some(indicator => contextText.includes(indicator)) &&
-             (contextText.includes('try') || contextText.includes('catch') || contextText.includes('error'));
-    }
-    
-    return false;
-  }
-  
-  isRetryVariableDeclaration(line) {
-    // Check for variable declarations with retry-related names
-    const declarationPatterns = [
-      /(?:const|let|var)\s+.*(?:retry|attempt|tries|maxretries|maxattempts)/,
-      /(?:retry|attempt|tries|maxretries|maxattempts)\s*[:=]/
-    ];
-    
-    return declarationPatterns.some(pattern => pattern.test(line));
-  }
-  
-  isRetryFunctionPattern(lines, index) {
-    const line = lines[index].trim().toLowerCase();
-    
-    // Check for function declarations with retry indicators
-    if ((line.includes('function') || line.includes('=>')) &&
-        this.retryIndicators.some(indicator => line.includes(indicator))) {
-      
-      // Look for retry logic in function body
-      const functionBody = this.getFunctionBody(lines, index);
-      return functionBody && 
-             this.retryIndicators.some(indicator => functionBody.includes(indicator)) &&
-             (functionBody.includes('try') || functionBody.includes('catch') || 
-              functionBody.includes('throw') || functionBody.includes('error'));
-    }
-    
-    return false;
-  }
-  
-  usesAllowedRetryUtil(line) {
-    return this.allowedRetryUtils.some(util => 
-      line.includes(util) && (line.includes('.') || line.includes('('))
-    );
-  }
-  
-  extractRetryPattern(lines, startIndex, type) {
-    // Extract the pattern characteristics for similarity comparison
-    const contextLines = lines.slice(startIndex, Math.min(lines.length, startIndex + 20));
-    const contextText = contextLines.join('\n').toLowerCase();
-    
-    // Extract key characteristics
-    const characteristics = {
-      type: type,
-      hasForLoop: contextText.includes('for'),
-      hasWhileLoop: contextText.includes('while'),
-      hasDoWhile: contextText.includes('do') && contextText.includes('while'),
-      hasTryCatch: contextText.includes('try') && contextText.includes('catch'),
-      hasMaxRetries: /max.*(?:retry|attempt|tries)/.test(contextText),
-      hasBackoff: contextText.includes('backoff') || contextText.includes('delay') || contextText.includes('timeout'),
-      hasExponential: contextText.includes('exponential') || /math\.pow|2\s*\*\*|\*\s*2/.test(contextText),
-      hasLinear: contextText.includes('linear') || /\*\s*(?:attempt|retry)/.test(contextText),
-      hasSetTimeout: contextText.includes('settimeout') || contextText.includes('promise') && contextText.includes('resolve'),
-      signature: this.generatePatternSignature(contextText)
-    };
-    
-    return characteristics;
-  }
-  
-  generatePatternSignature(contextText) {
-    // Create a normalized signature for pattern matching
-    let signature = '';
-    
-    if (contextText.includes('for')) signature += 'FOR_';
-    if (contextText.includes('while')) signature += 'WHILE_';
-    if (/max.*(?:retry|attempt)/.test(contextText)) signature += 'MAX_';
-    if (contextText.includes('try') && contextText.includes('catch')) signature += 'TRYCATCH_';
-    if (contextText.includes('settimeout') || contextText.includes('delay')) signature += 'DELAY_';
-    if (contextText.includes('exponential') || /math\.pow/.test(contextText)) signature += 'EXPONENTIAL_';
-    if (contextText.includes('throw')) signature += 'THROW_';
-    
-    return signature || 'GENERIC_RETRY';
-  }
-  
-  getFunctionBody(lines, startIndex) {
-    // Extract function body for analysis
-    let braceDepth = 0;
-    let foundStartBrace = false;
-    const bodyLines = [];
-    
-    for (let i = startIndex; i < lines.length; i++) {
-      const line = lines[i];
-      
-      for (const char of line) {
-        if (char === '{') {
-          braceDepth++;
-          foundStartBrace = true;
-        } else if (char === '}') {
-          braceDepth--;
-        }
-      }
-      
-      if (foundStartBrace) {
-        bodyLines.push(line);
-        
-        if (braceDepth === 0) {
-          break;
-        }
-      }
-    }
-    
-    return bodyLines.join('\n').toLowerCase();
-  }
-  
-  findDuplicateRetryLogic() {
-    const groups = [];
-    const processed = new Set();
-    
-    this.retryPatterns.forEach((pattern, index) => {
-      if (processed.has(index)) return;
-      
-      const similarPatterns = [pattern];
-      processed.add(index);
-      
-      // Find similar patterns
-      this.retryPatterns.forEach((otherPattern, otherIndex) => {
-        if (otherIndex !== index && !processed.has(otherIndex)) {
-          if (this.areSimilarPatterns(pattern, otherPattern)) {
-            similarPatterns.push(otherPattern);
-            processed.add(otherIndex);
-          }
-        }
-      });
-      
-      if (similarPatterns.length > 0) {
-        groups.push({
-          signature: pattern.signature,
-          patterns: similarPatterns
-        });
-      }
-    });
-    
-    return groups;
-  }
-  
-  areSimilarPatterns(pattern1, pattern2) {
-    // Check if two patterns are similar enough to be considered duplicates
-    
-    // Same signature indicates very similar patterns
-    if (pattern1.signature === pattern2.signature) {
-      return true;
-    }
-    
-    // Compare characteristics
-    const similarities = [
-      pattern1.hasForLoop === pattern2.hasForLoop,
-      pattern1.hasWhileLoop === pattern2.hasWhileLoop,
-      pattern1.hasTryCatch === pattern2.hasTryCatch,
-      pattern1.hasMaxRetries === pattern2.hasMaxRetries,
-      pattern1.hasBackoff === pattern2.hasBackoff,
-      pattern1.hasSetTimeout === pattern2.hasSetTimeout
-    ].filter(Boolean).length;
-    
-    // Consider patterns similar if they share at least 4 out of 6 characteristics
-    return similarities >= 4;
-  }
-  
-  getFunctionNameForLine(lines, lineIndex) {
-    // Look backwards to find the function declaration for this line
-    for (let i = lineIndex; i >= 0; i--) {
-      const line = lines[i].trim();
-      
-      // Match function declarations
-      const functionMatch = line.match(/(?:function|async\s+function)\s+(\w+)/);
-      if (functionMatch) {
-        return functionMatch[1];
-      }
-      
-      // Match arrow functions assigned to variables
-      const arrowMatch = line.match(/(?:const|let|var)\s+(\w+)\s*=.*=>/);
-      if (arrowMatch) {
-        return arrowMatch[1];
-      }
-      
-      // Stop at class/module boundaries
-      if (line.includes('class ') || line.includes('module.exports') || line.includes('export')) {
-        break;
-      }
-    }
-    
-    return 'anonymous';
-  }
-}
-
-module.exports = C047Analyzer;