@sun-asterisk/sunlint 1.2.1 → 1.2.2

package/rules/common/C010_limit_block_nesting/analyzer.js

@@ -0,0 +1,389 @@
+/**
+ * C010 Rule: Limit Block Nesting Depth
+ * Prevents deep nesting of blocks (if/for/while/switch/try) to improve code readability
+ * Maximum recommended depth: 3 levels
+ * Severity: warning
+ * Category: Maintainability
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class C010LimitBlockNestingAnalyzer {
+  constructor() {
+    this.ruleId = 'C010';
+    this.ruleName = 'Limit Block Nesting';
+    this.description = 'Do not exceed maximum block nesting depth for better readability';
+    this.severity = 'warning';
+    this.maxDepth = 3;
+    
+    // Control flow blocks that create nesting - Match ESLint rule exactly
+    // Only: if, for, while, do-while, switch, try-catch statements
+    this.blockPatterns = [
+      // if/else patterns - handle both same-line and multi-line blocks
+      { pattern: /^\s*if\s*\(.*\)\s*\{/, type: 'if', opens: true },
+      { pattern: /^\s*if\s*\(.*\)\s*$/, type: 'if-pending', opens: false, needsBrace: true },
+      { pattern: /^\s*else\s*if\s*\(.*\)\s*\{/, type: 'else-if', opens: true },
+      { pattern: /^\s*else\s*if\s*\(.*\)\s*$/, type: 'else-if-pending', opens: false, needsBrace: true },
+      { pattern: /^\s*else\s*\{/, type: 'else', opens: true },
+      { pattern: /^\s*else\s*$/, type: 'else-pending', opens: false, needsBrace: true },
+      
+      // Loop patterns - handle both same-line and multi-line blocks
+      { pattern: /^\s*for\s*\(.*\)\s*\{/, type: 'for', opens: true },
+      { pattern: /^\s*for\s*\(.*\)\s*$/, type: 'for-pending', opens: false, needsBrace: true },
+      { pattern: /^\s*while\s*\(.*\)\s*\{/, type: 'while', opens: true },
+      { pattern: /^\s*while\s*\(.*\)\s*$/, type: 'while-pending', opens: false, needsBrace: true },
+      { pattern: /^\s*do\s*\{/, type: 'do-while', opens: true },
+      { pattern: /^\s*do\s*$/, type: 'do-while-pending', opens: false, needsBrace: true },
+      
+      // Switch statements (not individual case blocks)
+      { pattern: /^\s*switch\s*\(.*\)\s*\{/, type: 'switch', opens: true },
+      { pattern: /^\s*switch\s*\(.*\)\s*$/, type: 'switch-pending', opens: false, needsBrace: true },
+      
+      // Try-catch patterns
+      { pattern: /^\s*try\s*\{/, type: 'try', opens: true },
+      { pattern: /^\s*try\s*$/, type: 'try-pending', opens: false, needsBrace: true },
+      { pattern: /^\s*catch\s*\(.*\)\s*\{/, type: 'catch', opens: true },
+      { pattern: /^\s*catch\s*\(.*\)\s*$/, type: 'catch-pending', opens: false, needsBrace: true },
+      { pattern: /^\s*finally\s*\{/, type: 'finally', opens: true },
+      { pattern: /^\s*finally\s*$/, type: 'finally-pending', opens: false, needsBrace: true },
+      
+      // With statements (rarely used but included for completeness)
+      { pattern: /^\s*with\s*\(.*\)\s*\{/, type: 'with', opens: true },
+      { pattern: /^\s*with\s*\(.*\)\s*$/, type: 'with-pending', opens: false, needsBrace: true },
+      
+      // Standalone opening brace (follows pending blocks)
+      { pattern: /^\s*\{\s*$/, type: 'brace-block', opens: true }
+    ];
+
+    // Track pending blocks that expect a brace on next line
+    this.pendingBlocks = [];
+
+    // Patterns for inline blocks (without braces)
+    this.inlineBlockPatterns = [
+      { pattern: /^\s*if\s*\(.*\)\s*[^{]/, type: 'if-inline' },
+      { pattern: /^\s*else\s+if\s*\(.*\)\s*[^{]/, type: 'else-if-inline' },
+      { pattern: /^\s*else\s+[^{]/, type: 'else-inline' },
+      { pattern: /^\s*for\s*\(.*\)\s*[^{]/, type: 'for-inline' },
+      { pattern: /^\s*while\s*\(.*\)\s*[^{]/, type: 'while-inline' }
+    ];
+  }
+
+  async analyze(files, language, config = {}) {
+    const violations = [];
+    
+    if (config?.rules?.C010?.maxDepth) {
+      this.maxDepth = config.rules.C010.maxDepth;
+    }
+
+    for (const filePath of files) {
+      try {
+        if (this.isTestFile(filePath)) {
+          continue;
+        }
+        
+        const fileContent = fs.readFileSync(filePath, 'utf8');
+        const fileViolations = await this.analyzeFile(filePath, fileContent, language, config);
+        violations.push(...fileViolations);
+      } catch (error) {
+        console.warn(`C010 analysis error for ${filePath}:`, error.message);
+      }
+    }
+    
+    return violations;
+  }
+
+  async analyzeFile(filePath, fileContent, language, config) {
+    const violations = [];
+    
+    // Reset pending blocks for each file
+    this.pendingBlocks = [];
+    
+    try {
+      const lines = fileContent.split('\n');
+      let controlFlowStack = []; // Only track control flow blocks
+      let commentState = { inMultiLine: false, startChar: 0 };
+
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNumber = i + 1;
+        
+        // Update comment state and skip if in comment
+        commentState = this.updateCommentState(line, commentState);
+        if (this.isLineInComment(line, commentState)) {
+          continue;
+        }
+        
+        const trimmedLine = line.trim();
+        if (!trimmedLine) continue;
+        
+        // Track control flow statements
+        const controlFlowMatch = this.detectControlFlow(trimmedLine);
+        if (controlFlowMatch) {
+          // Check if this line has opening brace (same line)
+          if (trimmedLine.includes('{')) {
+            controlFlowStack.push({
+              type: controlFlowMatch.type,
+              line: lineNumber,
+              column: this.getBlockStartColumn(line)
+            });
+            
+            // Check depth violation at the control flow statement
+            if (controlFlowStack.length > this.maxDepth) {
+              violations.push(this.createViolation(
+                filePath, 
+                lineNumber, 
+                this.getBlockStartColumn(line), 
+                line, 
+                controlFlowStack.length, 
+                controlFlowStack
+              ));
+            }
+          } else {
+            // Look ahead for opening brace on next line
+            let braceLineIndex = -1;
+            for (let j = i + 1; j < Math.min(i + 3, lines.length); j++) {
+              if (lines[j].trim() === '{') {
+                braceLineIndex = j;
+                break;
+              }
+              if (lines[j].trim() !== '') break; // Stop if non-empty, non-brace line
+            }
+            
+            if (braceLineIndex >= 0) {
+              controlFlowStack.push({
+                type: controlFlowMatch.type,
+                line: braceLineIndex + 1,
+                column: this.getBlockStartColumn(lines[braceLineIndex])
+              });
+              
+              // Check depth violation at the opening brace
+              if (controlFlowStack.length > this.maxDepth) {
+                violations.push(this.createViolation(
+                  filePath, 
+                  braceLineIndex + 1, 
+                  this.getBlockStartColumn(lines[braceLineIndex]), 
+                  lines[braceLineIndex], 
+                  controlFlowStack.length, 
+                  controlFlowStack
+                ));
+              }
+            }
+          }
+        }
+        
+        // Handle closing braces - only remove if we have control flow blocks
+        const closeBraces = (line.match(/\}/g) || []).length;
+        for (let j = 0; j < closeBraces && controlFlowStack.length > 0; j++) {
+          controlFlowStack.pop();
+        }
+      }
+      
+    } catch (error) {
+      console.warn(`C010 analysis error for ${filePath}:`, error.message);
+    }
+
+    return violations;
+  }
+  
+  detectControlFlow(line) {
+    // Match control flow keywords that create nesting
+    const patterns = [
+      { pattern: /^\s*if\s*\(/, type: 'if' },
+      { pattern: /^\s*else\s+if\s*\(/, type: 'else-if' },
+      { pattern: /^\s*else\s*$/, type: 'else' },
+      { pattern: /^\s*for\s*\(/, type: 'for' },
+      { pattern: /^\s*while\s*\(/, type: 'while' },
+      { pattern: /^\s*do\s*$/, type: 'do-while' },
+      { pattern: /^\s*switch\s*\(/, type: 'switch' },
+      { pattern: /^\s*try\s*$/, type: 'try' },
+      { pattern: /^\s*catch\s*\(/, type: 'catch' },
+      { pattern: /^\s*finally\s*$/, type: 'finally' },
+      { pattern: /^\s*with\s*\(/, type: 'with' },
+      // Handle closing brace followed by control flow
+      { pattern: /^\s*}\s*else\s+if\s*\(/, type: 'else-if' },
+      { pattern: /^\s*}\s*else\s*$/, type: 'else' },
+      { pattern: /^\s*}\s*catch\s*\(/, type: 'catch' },
+      { pattern: /^\s*}\s*finally\s*$/, type: 'finally' }
+    ];
+    
+    for (const pattern of patterns) {
+      if (pattern.pattern.test(line)) {
+        return { type: pattern.type };
+      }
+    }
+    
+    return null;
+  }
+  
+  updateCommentState(line, currentState) {
+    let { inMultiLine, startChar } = currentState;
+    let pos = startChar;
+    
+    while (pos < line.length) {
+      if (!inMultiLine) {
+        // Check for single line comment
+        if (line.substr(pos, 2) === '//') {
+          return { inMultiLine: false, startChar: line.length };
+        }
+        // Check for multi-line comment start
+        if (line.substr(pos, 2) === '/*') {
+          inMultiLine = true;
+          pos += 2;
+          continue;
+        }
+      } else {
+        // Check for multi-line comment end
+        if (line.substr(pos, 2) === '*/') {
+          inMultiLine = false;
+          pos += 2;
+          continue;
+        }
+      }
+      pos++;
+    }
+    
+    return { inMultiLine, startChar: 0 };
+  }
+  
+  isLineInComment(line, commentState) {
+    const trimmed = line.trim();
+    
+    // Single line comment
+    if (trimmed.startsWith('//')) return true;
+    
+    // JSDoc style comment
+    if (trimmed.startsWith('*') && !trimmed.startsWith('*/')) return true;
+    
+    // In multi-line comment
+    if (commentState.inMultiLine) {
+      // Unless the line ends the comment, it's a comment line
+      return !line.includes('*/');
+    }
+    
+    return false;
+  }
+  
+  detectBlockOpening(trimmedLine, fullLine) {
+    // First check if this is a standalone opening brace that follows a pending block
+    if (trimmedLine === '{' && this.pendingBlocks.length > 0) {
+      const pendingBlock = this.pendingBlocks.pop();
+      return {
+        opens: true,
+        type: pendingBlock.type.replace('-pending', ''),
+        column: this.getBlockStartColumn(fullLine),
+        inline: false
+      };
+    }
+    
+    // Check for block patterns
+    for (const blockPattern of this.blockPatterns) {
+      if (blockPattern.pattern.test(trimmedLine)) {
+        if (blockPattern.needsBrace) {
+          // This is a pending block, add to pending list
+          this.pendingBlocks.push({
+            type: blockPattern.type,
+            line: fullLine
+          });
+          return { opens: false };
+        } else {
+          return {
+            opens: blockPattern.opens,
+            type: blockPattern.type,
+            column: this.getBlockStartColumn(fullLine),
+            inline: false
+          };
+        }
+      }
+    }
+    
+    return { opens: false };
+  }
+  
+  detectInlineBlock(trimmedLine) {
+    // Skip if line ends with { or ;
+    if (trimmedLine.endsWith('{') || trimmedLine.endsWith(';')) {
+      return null;
+    }
+    
+    for (const pattern of this.inlineBlockPatterns) {
+      if (pattern.pattern.test(trimmedLine)) {
+        return { type: pattern.type };
+      }
+    }
+    
+    return null;
+  }
+  
+  isClosingBrace(line) {
+    // Match closing brace, possibly followed by else/catch/finally
+    return /^\s*}\s*(else|catch|finally)?\s*(\{|$)/.test(line);
+  }
+  
+  handleClosingBrace(blockStack) {
+    if (blockStack.length > 0) {
+      // Remove the most recent block
+      blockStack.pop();
+    }
+  }
+  
+  calculateEffectiveDepth(blockStack) {
+    // Count only non-inline blocks for depth calculation
+    return blockStack.filter(block => !block.inline).length;
+  }
+  
+  getBlockStartColumn(line) {
+    const match = line.match(/^\s*/);
+    return match ? match[0].length + 1 : 1;
+  }
+  
+  isTestFile(filePath) {
+    const testPatterns = [
+      /\.test\.(js|ts|jsx|tsx)$/,
+      /\.spec\.(js|ts|jsx|tsx)$/,
+      /\/__tests__\//,
+      /\/tests?\//,
+      /\.e2e\./,
+      /test\.config\./,
+      /jest\.config\./,
+      /vitest\.config\./,
+      /cypress\//
+    ];
+    
+    return testPatterns.some(pattern => pattern.test(filePath));
+  }
+  
+  createViolation(filePath, lineNumber, column, sourceLine, depth, blockStack) {
+    return {
+      ruleId: this.ruleId,
+      severity: this.severity,
+      message: `Block nesting depth ${depth} exceeds maximum of ${this.maxDepth}. Consider refactoring to reduce complexity.`,
+      filePath: filePath,
+      line: lineNumber,
+      column: column,
+      source: sourceLine.trim(),
+      suggestion: this.getSuggestion(depth),
+      nestingStack: blockStack.map(b => ({ 
+        type: b.type, 
+        line: b.line,
+        inline: b.inline || false
+      }))
+    };
+  }
+  
+  getSuggestion(currentDepth) {
+    const suggestions = [
+      "Extract nested logic into separate functions",
+      "Use early returns to reduce nesting",
+      "Consider using guard clauses",
+      "Break complex conditions into meaningful variables",
+      "Use strategy pattern for complex conditional logic",
+      "Consider using a state machine for complex flow control"
+    ];
+    
+    const index = Math.min(currentDepth - this.maxDepth - 1, suggestions.length - 1);
+    return suggestions[Math.max(0, index)];
+  }
+}
+
+module.exports = C010LimitBlockNestingAnalyzer;